v2.0 - studio UI - #7

…Slim

SqliteSessionStore now serialises access to the shared Microsoft.Data.Sqlite
connection through a SemaphoreSlim(1,1), eliminating concurrent
SQLiteException / corrupted reads on hot paths (AgentCore, background
services, concurrent CLI + WebAPI).

Changes:
- src/agent/Storage/SqliteSessionStore.cs: _connLock = SemaphoreSlim(1,1),
  _disposed flag (Interlocked-protected); all 23 *Async methods wrap body in
  WaitAsync/Release; 20 sync wrappers route through same lock; IsHealthy
  uses non-blocking Wait(0) probe; Dispose/DisposeAsync drain in-flight
  commands before disposing the connection.
- tests/Hercules.Agent.Tests/Storage/SqliteSessionStoreDirectTests.cs: 4 new
  concurrency tests (10 parallel LogInteractionAsync, 24 mixed writes across
  interactions/audit/budget, IsHealthy under load, sync wrappers via Task.Run).

Sync wrappers and broader sync-over-async refactors (AgentCore,
WebApiAdapter, ConsoleUI, TelegramBot, ReflectionEngine, MemoryStore,
FileSkillRepository, SqliteOutboxStore) are explicitly tracked under
task_077 (sync-over-async-sweep) and task_075 (DI lifetime).

Validation:
- dotnet build tests/Hercules.Agent.Tests: 0 errors.
- dotnet test --filter SqliteSessionStoreDirectTests: 19/19 pass.
- dotnet test full: 1727 pass / 10 fail (all 10 failures pre-existing
  OtelService/WasmTool/Budget; confirmed via git stash baseline).

…ibuted quotas

- QuotaService: switch ConcurrentBag -> ConcurrentQueue (FIFO, O(1) cleanup)
- QuotaService: fix broken CleanOldEntries (dummy-key swap never touched real basket)
- QuotaService: fix MakeStatus to use the actual QuotaScope instead of hardcoding Agent
- QuotaService.SweepAllBuckets: public method for periodic eviction
- QuotaCleanupBackgroundService: 60s sweep loop registered as HostedService
- DistributedQuotaService: optional decorator that mirrors rate-limit counters
  to IMeshStateStore (Redis/Postgres/NATS) with sliding-window TTL, falls back
  to in-memory on store failure
- IMeshStateStore.IncrementAsync: add optional ttl parameter (backward-compatible)
  and honor it in InProcess/Redis/Postgres/Nats backends
- QuotasConfig: DistributedEnabled, DistributedKeyPrefix, CleanupIntervalSeconds
- DI: QuotaService registered as concrete singleton; IQuotaService picks
  DistributedQuotaService when DistributedEnabled && IMeshStateStore available
- 13 new unit tests covering cleanup fix, scope correctness, distributed path,
  fallback, and disabled mode
- backlog.md + task_072.md updated

…eue prune fix

Implements JetStream ack/nak/terminate semantics for NatsTaskQueue (was no-ops).

- New NatsTaskInFlightTracker holds action delegates captured in DequeueAsync
  so AckAsync/FailAsync can find the original JetStream message later.
- AckAsync: JetStream msg.AckAsync(); removes from tracker.
- FailAsync: NakAsync for retry, or AckTerminateAsync(AckOpts{TerminateReason})
  + append to local JSONL DLQ when retry budget or MaxDeliveryAttempts exhausted.
- NatsMeshConfig.MaxDeliveryAttempts (default 10) replaces hardcoded MaxDeliver.
- NatsTaskDlqStore: thread-safe JSONL DLQ file (Append/List/Remove, atomic
  temp-file + rename). Legacy JetStream DLQ stream removed.
- 31 new unit tests (NatsTaskInFlightTracker, NatsTaskDlqStore, NatsTaskQueue
  config + AckAsync/FailAsync no-op behavior); all green.
- Full test suite: 1769/1779 (10 pre-existing failures unrelated to this task).

Refs: docs/roadmap/tasks/task_074.md

… pre-existing drift on 061/062/064)

…gentCore singleton)

Remove per-call writes to shared ResilientLLMClient.ProviderName/ModelName
that caused last-writer-wins races under concurrent calls. Per-call
provider/model now flow exclusively through LlmResponse (already populated
by ChatClientLLMClient) and OTel Activity tags use the actual response
provider/model, not shared instance state. Streaming paths emit a
per-stream OTel Activity with provider/model tags instead of mutating
instance fields.

- ResilientLLMClient.CompleteMainAsync: use resp.Provider/Model for OTel
  and metrics, drop writes to this.ProviderName/ModelName.
- ResilientLLMClient.InvokeRoleAsync: return LlmResponse as-is.
- ResilientLLMClient.StreamMainAsync/StreamSingleAsync: per-stream
  Activity with provider/model tags, no instance-field mutation.
- New tests (ResilientLLMClientPerCallProviderTests): 10 concurrent
  CompleteAsync with primary + fallback verify response.Provider/Model
  stability; OTel activity tags per-call match actual response.
- Wrappers ProviderName/ModelName now reflect the configured primary
  (set only in ctor/RebuildChain), not the last successful call.

- ToolPolicyEngine.Evaluate -> EvaluateAsync (Task<ToolPolicyResult>);
  AgentCore caller + unit tests updated; legacy Evaluate kept as
  [Obsolete] shim.
- SloService: ISloService.Evaluate/GetStatus/GetReport/GetSummary promoted
  to Task<T>; SloController handlers converted to async minimal-API
  lambdas. _violations/_statusCache moved to ConcurrentDictionary with
  per-vertical lock on mutation. 7-day compliance path no longer
  loads 100k audit rows.
- IAuditService.GetActionStatsAsync + IAuditLog.GetAuditLogStatsAsync +
  SqliteSessionStore.GetAuditLogStatsAsync: single SQL aggregate that
  groups audit_log by result class, replacing 100k-row QueryAsync +
  in-memory .Count().
- RedisTaskQueue, RedisMeshStateStore, PostgresMeshStateStore,
  PostgresTaskQueue: Timer callbacks are now sync void wrappers that
  re-enter via fire-and-forget async helpers (no more
  .GetAwaiter().GetResult() inside timer callbacks).
- RolloutController promote/rollback endpoints: async lambdas.
- EscalationService.BatchApproveAsync: await instead of sync-over-async.
- LlmClientFactory: sync Create() uses a ConcurrentDictionary (no async
  cache lookup); added CreateAsync for async callers.

…lience handlers

task_078: переход с per-call 'new HttpClient' на IHttpClientFactory с
named clients и standard resilience handlers. Устраняет socket
exhaustion под нагрузкой, добавляет retry+circuit-breaker+timeout на
hot-path (intent-transport, http-tool, a2a-client, operator-notify).

* Hercules.csproj: добавлен Microsoft.Extensions.Http.Resilience 10.0.0
* AppConfig.cs: новая HttpResilienceConfig (TimeoutSeconds, RetryCount,
  CircuitBreaker*); HttpConfig.Resilience section.
* appsettings.json: Http.Resilience defaults (RetryCount=3, ratio=0.5).
* Program.cs (CLI) + Hercules.WebApi/Program.cs: AddHttpClient() +
  11 named clients (http-tool, a2a-client, network-monitor, operator-notify,
  llm-health, llm-capabilities, lm-studio-info, intent-transport,
  http-transport, grpc-transport, skill-marketplace). DI registrations
  обновлены — все per-call long-lived HttpClient получают IHttpClientFactory.
* HttpTool, A2AClient, NetworkMonitor, OperatorNotificationService,
  ProviderHealthChecker, ProviderCapabilityDetector, LMStudioClient,
  HttpTransportAdapter, SkillMarketplace: optional IHttpClientFactory
  parameter; legacy 'new HttpClient' fallback сохранён.
* LlmClientFactory: DI ctor пробрасывает IHttpClientFactory в LMStudioClient.
* DegradationManager.CheckNetworkHealthAsync: убран hardcoded google.com
  ping — без NetworkMonitor помечает network как Degraded.
* IntentTransport/HttpTransportAdapter/GrpcTransportAdapter: добавлены
  HttpClientName const-ы для named-client регистрации.
* tests/Hercules.Agent.Tests/Http/HttpClientFactoryTests.cs (new, 13
  tests): HttpTool/A2AClient/NetworkMonitor/OperatorNotificationService/
  ProviderHealthChecker wiring, allow-list preservation, named-client
  uniqueness, AddStandardResilienceHandler retry on 503.

… message

CheckAndGetDegradationMessage_WhenHardCapViolation_ReturnsMessage
expected 'превышен лимит безопасности' (lowercase p) but source in
BudgetGuard.cs uses 'Превышен' (capital P) — корректно для русского.
Assertion was case-sensitive и не находил substring. Switch to
OrdinalIgnoreCase чтобы тест был устойчив к возможным правкам регистра.

…(liveness + readiness)

…ression, output cache

Replace custom RateLimitMiddleware with framework AddRateLimiter (fixed window per IP for /api/chat, concurrency limiter for reflection/eval/SLO). Add Brotli+Gzip response compression. Add named output cache policies for /api/skills and /api/config. Tune Kestrel limits (1000 connections, 4 MiB body, 120s keep-alive). Harden RequestBodyLimitMiddleware with a real LimitedStream for chunked uploads. Lock down CORS default to localhost whitelist. Remove duplicate app.MapCache() call. Add 23 new tests covering rate limit, compression, output cache, and body limit.

task_082: H13 RouterHealthTracker lock; H14 Redis CAS via ITransaction.AddCondition; H15 PostgresMeshBus LISTEN reconnect-with-backoff; H16 AddMeshServices no longer calls BuildServiceProvider.

Adds 18 new tests under tests/.../Phase5Tests/. All 165 related tests pass; full suite shows only pre-existing environmental failures (Otel/Redis runtime not in test host).

…ction, mutable entries

CacheService refactor:
- Stampede dedup via per-key SemaphoreSlim (concurrent misses share one
  factory invocation; waiters re-check as hits).
- Per-class ConcurrentDictionary replaces global "Class:Key" store,
  eliminating per-hit string concat and giving O(k) InvalidateClass.
- SortedDictionary<long, ExpiryRecord> expiry index lets EvictOne peek
  the oldest entry in O(log n) instead of sorting all keys on every
  insert.
- CacheEntry converted from record-with to mutable class; sliding-
  expiration touch performs a single Volatile.Write on _expiresAtTicks
  (no record allocation, no dictionary write).
- GetOrSetAsync split into non-async fast path (returns Task.FromResult)
  and async GetOrSetMissAsync slow path, avoiding state-machine
  allocation on hits.
- Debug LogDebug calls gated by IsEnabled to skip params[] allocation
  when debug logging is off.

Tests: 14 new tests in
tests/Hercules.Agent.Tests/Phase5Tests/CacheServiceStampedeEvictionTests.cs
covering stampede dedup, eviction ordering, per-class invalidation,
sliding-hit allocation budget, and 10k insert eviction benchmark.

backlog.md: 081/082/083 status synced to done.

Deferred: distributed IDistributedCache (Redis) backend requires follow-up
in the multi-node story (task_067 mesh coordination backend).

Validation: 50/50 cache tests pass; full suite 1896 pass / 8 pre-existing
environmental failures (OtelService x5, RedisTaskQueue x1, NumericValidator x2).

…r pool

Reflection/ProposalStore: snapshot via FileSystemWatcher (250ms debounce, 60s safety refresh), ListAll sync reads from ImmutableList, ListAllAsync bypasses cache, Save/Delete eagerly update snapshot, defensive deep-copy in Clone, IDisposable. Lock-free read path; only file Write/Delete guarded by _writeLock.

StringBuilder pooling via Microsoft.Extensions.ObjectPool (DefaultObjectPoolProvider.CreateStringBuilderPool) in 7 hot-path call sites: LayeredMemoryManager.BuildContextBlockAsync, ContextBuilder.BuildContextAsync, TraceSummarizer.Summarize, AgentCore.BuildSystemPrompt, MemoryManager.BuildContextBlock, MemoryManager.ParseSections, ResponseAggregator.AggregateWithLlmJudgeAsync. Get/try/finally/Return pattern; policy clears buffer on Return.

Tests: ProposalStoreCachingTests (12, includes FileSystemWatcher invalidation on external Add/Delete, lock-free concurrent reader/writer stress, defensive clone), StringBuilderPoolTests (4). 1912 passed / 9 pre-existing failures (OtelService, RedisTaskQueue, NumericValidator — reproduce on bare HEAD).

…ss instrumentation, histograms, sampled logging)

Console exporter is now gated by OtelConfig.GetEffectiveConsoleExporterEnabled() — when OtlpEndpoint is set, console exporters are skipped to avoid duplicate export cost. AddProcessInstrumentation() registers CPU/memory/thread metrics. Latency and token histograms use explicit bucket boundaries tuned for SLO dashboards. LLM retry/quota/timeout/policy warnings use 1-in-N sampling (default N=10) while the underlying LlmRetryCounter metric increments on every occurrence. OtelConfig gains ConsoleExporterEnabled, LoggingSampleRate, OtlpLogExporterEnabled fields. Tests cover console gating, bucket boundaries, sampled-log helper (including thread-safety), and end-to-end ResilientLLMClient retry-counter behavior.

…Q/visibility fixes, Redis O(1) ack

- InMemoryEventBus: bounded Channel<T>(capacity) + TryWrite→WriteAsync(timeout)→drop policy
  with BusChannelDropCounter; configurable via BusConfig.
- InProcessMeshBus: SemaphoreSlim(MaxConcurrentHandlers) gates handler fan-out;
  MeshHandlerDropCounter on saturation; configurable via MeshBackpressureConfig.
- InProcessTaskQueue: ReEnqueueTimedOut now actually re-enqueues in-flight tasks after
  visibility timeout (was a no-op stub); RequeueDeadLetterAsync atomically dequeues
  from DLQ under per-queue lock (previously left stale entries in _dlqs).
- RedisTaskQueue: AckAsync/FailAsync use O(1) global hash index (hercules:inflight:lookup)
  instead of O(N) server.Keys(pattern:...) scan; visibility requeue cleans up lookup.
- AppConfig: BusConfig + MeshBackpressureConfig + appsettings.json wiring;
  DI factories in MeshServiceExtensions and Program.cs.
- OtelMetrics: BusChannelDropCounter + MeshHandlerDropCounter.
- OtelHostBuilderExtensions: add missing AddHistogramViews stub (pre-existing build regression
  from task_085; bucket boundaries are baked into instruments at creation time).
- Tests: bounded-bus overflow (5), backpressure timeout, fast-subscriber drain, visibility
  re-enqueue (1.2s), DLQ atomic dequeue, MeshBus concurrency peak, Redis O(1) lookup.

…phrase/MaxSizeMb, network fallback, escalation logging, delegation TTL

- SharedMemorySync: replace silent catch with structured LogWarning
  (peer.AgentId, exception type) so operator sees why a peer was skipped.
- BackupConfig: add RequirePassphrase (default false); BackupScheduler logs
  warning at startup if Passphrase is empty, escalates to LogError when
  RequirePassphrase=true (production fail-fast).
- BackupService: enforce MaxSizeMb after compression+encryption; abort with
  warning and empty ArchivePath if exceeded, do not write the file.
- OfflineSyncConfig: add NetworkFallbackPollUrl (default https://1.1.1.1);
  NetworkMonitor.ResolveUrl chains: NetworkPollUrl -> NetworkFallbackPollUrl
  -> null.
- IntentRouter: add optional ILogger (default NullLogger); replace
  fire-and-forget _ = EscalateAsync with EscalateSafelyAsync helper that
  logs exceptions and respects OperationCanceledException on shutdown.
- DelegationBoundaryService: add ChainContextTtlSec (default 300s) and
  public CleanupExpiredChainContexts(); opportunistic sweep on
  RecordHopCompletion when dictionary > 64 entries.
- appsettings.json: DelegationBoundaries.ChainContextTtlSec = 300.
- Tests: Phase5Tests/MiscHardeningTests.cs — 9 unit tests for
  ResolveUrl fallback, CleanupExpiredChainContexts semantics, config
  defaults.
- docs/roadmap/backlog.md: mark task_086 as done (was pending — drift
  fixed in this tick).
- task_085: doc-note clarifications (no code change).

Validation:
- dotnet build src/agent/Hercules.csproj: 0 errors, 15 pre-existing
  warnings (same as baseline).
- dotnet build tests/.../Hercules.Agent.Tests.csproj: 0 errors.
- dotnet test --filter
  'FullyQualifiedName~SharedMemorySyncTests|FullyQualifiedName~Backup|
   FullyQualifiedName~NetworkMonitor|FullyQualifiedName~IntentRouter|
   FullyQualifiedName~DelegationBoundary|FullyQualifiedName~MiscHardening':
  79/79 passed (includes 9 new tests).
- 6 of 12 task_087 sub-tasks completed; remaining (ResilientTransport
  semaphore trim, SLO real metrics, AuditService filters, FleetPolicy
  enforcement) deferred to subsequent ticks.

…mentation

Sub-task #33: AuditService.QueryAsync previously dropped every filter except

'target' so the audit dashboard could not narrow down by actor / action /

sessionId / toolName / result / time window. Round 2 introduces:

- Storage.AuditLogQuery record with the full filter set and EffectiveLimit

  guard (clamps non-positive Limit to 100 so the SQL parameter cannot be 0)

- IAuditLog.QueryAsync default interface method (C# 8+) with an in-memory

  fallback over GetRecentAsync(Limit*4) capped at 4000 rows, so non-SQLite

  implementations still honour the contract

- AuditLogService override that delegates to a parameterised SQL query

- SqliteSessionStore.GetAuditLogQueryAsync builds WHERE 1=1 AND col=\ per

  non-null filter, parameterised to prevent SQL-injection, uses the existing

  _connLock (task_071) for thread-safety, and reuses the audit_log SELECT

  column list

- AuditService.QueryAsync now constructs an AuditLogQuery and delegates

11 new unit tests in AuditServiceFilterTests exercise every filter

individually and combined against a real SqliteSessionStore, plus the

no-filter backward-compat path and the EffectiveLimit clamp.

Validation: dotnet build clean; 47/47 AuditService+AuditLogService+MiscHardening

tests pass; full dotnet test shows only the 11 pre-existing failures already

documented in task_085/task_087 notes (OtelServiceTests, NumericValidatorTests,

RedisTaskQueueTests, ResilientLLMClientSampledLogTests,

ProposalStoreCachingTests.CountToday_OnlyIncludesTodayUtc).

Supervisor-managed restart protocol for the Hercules agent:

- RestartService: persistent flag in {DataRoot}/restart-state.json with
  atomic write (.tmp + File.Move). Auto-clear on startup if pending
  (prevents repeated restart after a stale request). Audit events
  'restart_requested' / 'restart_cleared' via IAuditService (fire-and-forget).
  Placed in Hercules.Restart namespace to avoid shadowing BCL System.*,
  mirroring the task_098 CheckIn lesson.

- SystemController: 3 new system-only endpoints with RequireSystemRole()
  + WithName() for OpenAPI codegen:
    POST /api/system/restart          -> 202 Accepted + snapshot
    GET  /api/system/restart-pending  -> status JSON for supervisor poll
    POST /api/system/restart/clear    -> 204 / 404

- DI: singleton via factory passing DataRoot-derived file path.

- 14 unit tests in RestartServiceTests covering request/clear, persistence,
  auto-clear on startup, corrupted-file fallback, audit-failure isolation,
  concurrent reads, whitespace/empty validation.

- dotnet build src/agent/Hercules.slnx: 0 errors.
- dotnet test --filter Restart|CheckIn|WebApi: 86/86 pass, no regressions.
- Full suite: 2066/2074 (8 pre-existing external-service failures
  unrelated to Restart: Wasmtime/Redis/OTLP/LLM).

Implements diff-based hot-reload for McpClientService so changes to
AppConfig.Mcp.Servers via PATCH /api/config are applied without process
restart. POST /api/mcp/servers/reload also re-uses the live config
via RuntimeConfigStore.Current.Mcp instead of a constructor snapshot.

- McpClientService : IConfigReload.
  * IConfigReload.Reload(AppConfig) — sync trigger that schedules
    a background ReloadFromConfigAsync via Task.Run + try/catch
    (reactor contract is fire-and-forget).
  * ReloadAsync(ct) — awaitable public path used by the
    /api/mcp/servers/reload controller endpoint; reads
    _store.Current.Mcp at call time.
  * ReloadFromConfigAsync(newConfig) — diff logic:
    - servers in _connections but not in newConfig → dispose +
      UnregisterServerTools(name);
    - servers in both with changed Transport/Command/Endpoint/Args/
      Enabled/HealthCheckEnabled/TimeoutSeconds → disconnect + unregister
      old tools + reconnect;
    - servers only in newConfig → ConnectServerAsync.
  * SemaphoreSlim serialises concurrent reloads (PATCH + manual).
  * McpServerConnection now carries the originating McpServerConfig
    so diff comparisons don't need to round-trip through config.

- IToolRegistryService.UnregisterEntry(string) : bool — case-insensitive
  TryRemove. ToolRegistryService implementation. Used by
  McpClientService.UnregisterServerTools for entries matching
  mcp.{serverName}.*.

- Program.cs DI: McpClientService registered as IConfigReload
  consumer next to AgentCore/SkillManager so RuntimeConfigReactor
  auto-wires the new config on Changed events.

- 17 unit tests:
  * McpClientServiceTests — 13 total (7 existing rewritten for the
    new constructor using a temp-file RuntimeConfigStore, 6 new):
    adds/keeps, removes/unregisters, updates/reconnects, empty-clears,
    IConfigReload fire-and-forget, adds-with-real-registry.
  * ToolRegistryServiceTests — 4 new UnregisterEntry cases:
    existing/non-existent/empty+null/case-insensitive.

Validation: dotnet build + dotnet test (Mcp/ToolRegistry/RuntimeConfig/
WebApi/CheckIn/Restart filters) — 150/150 pass. Full suite 2087/2097
with 10 pre-existing external-service failures (Otel/Redis/Wasm/
Numeric/InProcessTaskQueue) unrelated to this change.

Hierarchical context compression (recent raw + older summaries + ancient
key-facts) for long-session token savings. Deterministic (no LLM in hot
path: word-frequency topics + sentence scoring for summaries, n-gram
frequency with dedup for key facts).

- ContextConfig.Distillation block: Mode (Off/Auto/Manual), Strategy,
  RecentRawCount, SummaryInterval, KeyFactsExtraction, MaxAncientFacts,
  SummaryTokenBudget, KeyFactsTokenBudget, DistillationPreset
  (Economy/Balanced/Full)
- IDistillationStore + SqliteDistillationStore: context_summaries and
  context_key_facts tables in shared SQLite, upsert on (session_id,
  fact_text)
- ContextDistillationService.DistillAsync and GetSummaryAsync
- ContextBuilder integrates distilled block additively when
  Distillation.Mode != Off (legacy facts+episodes+working path preserved)
- New endpoints: POST /api/context/distill,
  GET /api/context/summary?sessionId=&maxTokens= (returns real markdown)
- SqliteSessionStore.GetSessionInteractionsAsync (chronological
  InteractionLog list for the service)
- DI wired in both Program.cs (Hercules agent + Hercules.WebApi)
- 19 new unit tests; full Context suite 103/103; WebApi 47/47

Validation: dotnet build src/agent/Hercules.slnx exit 0; full test
suite 2108/2116 (8 pre-existing failures in Otel/Redis/InProcessQueue/
NumericValidator/TransportFault — external services, unrelated).

Studio Stage 6 prerequisite for Hercules Studio. Phase 8.

…tore

Extract the storage-agnostic ISessionStore contract from SqliteSessionStore
(sessions, interactions, budget, audit, approvals, durable tasks, checkpoints,
escalations, sandbox, skill-evaluations) so the same code can target a shared
PostgreSQL backend or remain on a local SQLite file.

- Add src/agent/Storage/ISessionStore.cs (async-only contract; sync overloads
  stay on the concrete class).
- Mark SqliteSessionStore as ISessionStore (no behaviour change).
- Add StorageConfig.SessionStore (Provider + ConnectionString + Schema) and
  StorageConfig.CollectiveMind (Enabled + SharedMemory + SessionIsolation)
  with backward-compatible defaults.
- Add src/agent/Storage/PostgresSessionStore.cs (Npgsql, idempotent schema
  bootstrap, sessions + interactions + budget + audit + approvals working
  end-to-end; remaining surface throws NotImplementedException with
  explicit follow-up pointers for task_103/106/108).
- Wire DI in Program.cs: register ISessionStore conditionally on
  StorageConfig.SessionStore.Provider; keep concrete SqliteSessionStore
  registered for direct consumers (SqliteOutboxStore, SqliteTaskRepository,
  SqliteDistillationStore, SkillQualityStore).
- Add tests/Hercules.Agent.Tests/Storage/SessionStoreInterfaceTests.cs
  (6 tests: contract smoke, config defaults, Postgres ctor validation).

Build + 2081/2081 relevant tests pass. 8 pre-existing failures are unrelated
(Redis/Otel/Transport/Numeric/ResilientLLM need external services). Task
left as in_progress; remaining Postgres parity + collective-mind semantics +
migration tool are documented in the task file for the next tick.

Replace in-memory ConcurrentDictionary in TaskLifecycleProtocol with a
write-through SQLite store. The protocol keeps a fast in-memory cache
hydrated from the store on construction, and every state transition is
persisted. A background timer scans for expired tasks and prunes
terminal rows past the deadline.

New files:
- IDelegatedTaskStore: persistence contract (Save/Get/List/ListPending/
  Delete/PruneExpired)
- SqliteDelegatedTaskStore: SQLite impl with WAL, busy_timeout, and
  SemaphoreSlim(1,1) per task_071. AwaitingInputContext serialized as
  JSON to avoid a separate poller-metadata table.
- DelegatedTaskPersistenceTests: 15 tests covering roundtrip, JSON
  context, list filters, prune, write-through, startup recovery,
  expire, resume, BindLocalTask, backward-compat.

Modified:
- TaskLifecycleProtocol: write-through cache, recovery ctor, expiry
  scan timer, Dispose/DisposeAsync. The 2-arg constructor (in-memory
  only) is preserved so the 30 existing Phase-3 tests stay green.
- MeshServiceExtensions.AddMeshServices: wire IDelegatedTaskStore as
  singleton and pass to TaskLifecycleProtocol.

Validation:
- dotnet build (agent + WebApi): 0 errors
- New + existing lifecycle tests: 48/48 passed
- Full suite: 2128/2137 passed (9 pre-existing failures unchanged
  from baseline — Otel/Numeric/Wasm/Redis/ResilientLLM, all need
  external services)

Unblocks: task_107 (parent/child), task_108 (checkpoint persistence),
and the workflow executor in task_104/105 that needs durable task
state across restarts.

…eneration

In scope:
- AddOpenApi() with ShouldInclude = _ => true (opts all minimal API endpoints in)
- AddEndpointsApiExplorer() (bridges minimal API routes to MVC discovery)
- app.MapOpenApi() and app.MapScalarApiReference() after all MapXxx calls
- isBuildTime guard wrapping side-effecting post-build code:
  * CodeExecutionTool registration (ambiguous constructors trip DI validation)
  * ApiKeyStore key generation (file I/O)
  * WebApiAdapter.EnsureSessionStarted (SQLite touch)
  * Agent manifest / agent card publishing (file I/O)
  * Tool registry discovery (filesystem I/O)
  * MCP client init (network I/O)
  * app.Run() (blocks)
- csproj: Scalar.AspNetCore 2.11.4, Microsoft.AspNetCore.OpenApi 10.0.0,
  Microsoft.Extensions.ApiDescription.Server 10.0.0, OpenApiDocumentsDirectory,
  OpenApiGenerateDocumentsOptions, GenerateDocumentationFile, NoWarn for 1591/1573
- dotnet build writes src/agent/Hercules.WebApi/openapi.json via the package
  build target

Out of scope (documented in task_109.md Known limitations):
- Build-time openapi.json contains paths: {} — dotnet-getdocument tool does
  not enumerate minimal API routes in this project (reproduction in clean
  dotnet new web works, so the issue is specific to the Hercules host).
  Workarounds (ShouldInclude, AddEndpointsApiExplorer, route ordering,
  per-route WithOpenApi) applied but do not help. Follow-up: register
  [ApiController] controllers via AddControllers/MapControllers, or
  replace the package with a custom MSBuild target that runs our program
  with --getdocument.
- Runtime smoke blocked by pre-existing CodeExecutionTool constructor
  ambiguity (out of scope for this task).

- Add Hercules.BuiltIn with all directory/file constants and ResolveDataRoot().
- Resolve data root outside repository (sibling HerculesData/) or via env var.
- Replace hardcoded data/* paths in AppConfig, services and Program.cs with BuiltIn.
- Update .gitignore to ignore HerculesData/ instead of scattered data paths.

Refactor MarketplaceController and TemplateController from legacy
ControllerBase/[ApiController] style to project's standard minimal API
pattern (public static class + IEndpointRouteBuilder extension method),
then add .WithName(...) to each of the 13 endpoints and wire
app.MapMarketplace() / app.MapTemplate() in Program.cs.

Before this tick both controllers were dead code: they were the only
two of 35 controllers without WithName, AND they were never wired to
HTTP (no MapMarketplace/MapTemplate call, no AddControllers). The
refactor unblocks the runtime OpenAPI document for these routes and
aligns them with the convention used by the other 33 controllers.

OperationIds:
  Marketplace: ListMarketplace, SearchMarketplace,
    VerifyMarketplacePackage, GetMarketplacePackageDeps,
    InstallMarketplacePackage, InstallMarketplacePackageWithDeps,
    DeleteMarketplacePackage, PublishMarketplacePackage,
    ImportMarketplacePackage, ImportMarketplacePackageFromUrl
  Templates: ListTemplates, GetTemplate, ApplyTemplate

Build: 0 errors. Tests: 2131/2143 pass (same 12 pre-existing
baseline failures, verified via git stash round-trip).

Refs: task_112

Create new ASP.NET Core 10 service src/workflow-server/ for durable
multi-agent workflow execution (ADR-0008, Studio Stage 8b). Listens on
port 8430.

MVP foundation (task_105 follow-up implements the executor):
- ClientCredentialStore: auto-generate clientId/clientSecret on first
  start, persist to data/security/workflow-credentials.json (mirrors
  agent's ApiKeyStore pattern from task_097)
- ClientAuthMiddleware: X-Client-Id + X-Client-Secret header auth with
  constant-time comparison; bypasses CORS preflight, /health, webhook
- SqliteWorkflowDefinitionStore: SQLite CRUD with WAL and
  SemaphoreSlim(1,1) (same thread-safe pattern as agent's
  SqliteSessionStore, task_071)
- WorkflowsController: REST API for workflow definitions CRUD +
  501 Not Implemented stubs for run/list-executions/get-execution
- TriggersController: webhook trigger (in-memory ring buffer) + 501
  stub for cron list
- HealthController: /api/workflows/health returns status, version,
  uptime, storage health
- Program.cs: Kestrel on 8430, JSON options, DI, middleware pipeline

Wire-up:
- src/agent/Hercules.slnx: added project reference
- src/agent/Hercules.csproj: added Hercules.WorkflowServer/** to
  DefaultItemExcludes to prevent globbing into core
- tests/Hercules.Agent.Tests/Hercules.Agent.Tests.csproj: added project
  reference
- .gitignore: src/workflow-server/data/

Tests: 20 unit tests in tests/Hercules.Agent.Tests/WorkflowServer/
(ClientCredentialStoreTests, ClientAuthMiddlewareTests,
SqliteWorkflowDefinitionStoreTests) - all green.

Validation:
- dotnet build src/agent/Hercules.slnx - 0 errors
- dotnet test --filter 'FullyQualifiedName~WorkflowServer' - 20/20 pass
- Smoke test: server starts on 8430, auto-generates credentials,
  health/auth/CRUD/webhook endpoints all behave as expected;
  workflow definitions persist across restarts in workflow-server.db

…e provider

task_109 shipped a build-time `openapi.json` that was a 117-byte skeleton with
`paths: {}` while the runtime endpoint served 210 paths. Everything downstream
(task_113/115 TS codegen, task_117 Spectral lint) was blocked on this.

The `Microsoft.Extensions.ApiDescription.Server` build tool resolves the document
through MVC's action-descriptor collection. This API surface is 100% minimal API,
so the tool logged "No action descriptors found" and wrote an empty document. On a
clean `dotnet new web` probe the same tool failed outright with
`Unable to find service type 'IDocumentProvider'` — the tool is simply not usable
here. Replaced it with a custom `GenerateOpenApiDocument` MSBuild target that runs
the app itself with an `openapi-output` flag; Program.cs resolves the document and
writes it.

Two things silently produce a valid-but-empty document, both found by experiment:

- the provider reads `EndpointDataSource`, which is not finalised until the host
  starts, so `await app.StartAsync()` is required before generating;
- `AddOpenApi()` registers the provider as a *keyed* service under "v1", so
  unkeyed `GetRequiredService<IOpenApiDocumentProvider>()` throws
  "No service for type ... has been registered" — `GetRequiredKeyedService` is
  the correct call.

Going through the same `IOpenApiDocumentProvider` that backs `/openapi/v1.json`
means the committed file cannot drift from the served document. In build mode the
host binds an ephemeral loopback port so a build never collides with a dev server
on 8421, and `app.Run()` stays behind `if (!isBuildTime)`.

Dropping ApiDescription.Server also clears NU1903 (GHSA-v5pm-xwqc-g5wc):
Microsoft.OpenApi moves 2.0.0 -> 2.7.5.

Verified: build-time document is 210 paths / 61 schemas, matching the runtime
document exactly, and byte-stable across two --no-incremental builds. Runtime
/openapi/v1.json and /scalar both return 200. Full suite is 2150 passed / 13
failed both with and without this change (Redis, NATS, Otel, Wasmtime, numeric
validator, eval and config-default tests that need external services) — the
baseline was measured via a stash round-trip, not assumed.

Also corrects task_112, which repeated two stale claims: the empty-document
blocker (now fixed) and a "pre-existing CodeExecutionTool constructor ambiguity"
that does not exist — the type has a single IServiceProvider constructor and the
agent starts fine.

task_110 asked for `.WithTags()` on every endpoint. Every operation in the
generated document is now tagged: 223 operations, 0 untagged, 37 domain tags
plus the framework's auto-tag for the two non-API endpoints.

Applied 180 `.WithTags(...)` calls across 30 controllers, purely additive —
180 insertions / 180 deletions, no route string, handler signature or return
type touched. The remaining 42 endpoints were already covered: 20 by existing
per-endpoint tags (MeshObservability, TaskProgress, ToolRegistry) and 22 by
`app.MapGroup(...).WithTags(...)` (Mcp, Rollout, SecurityOps, System).

Three corrections to the plan recorded in the task file, all verified against
the code rather than taken on trust:

- it is 37 controller files, not 35. SecurityOpsController and SystemController
  were added after the task was written and missing from its mapping table;
  both already tag via MapGroup, so they needed no per-endpoint tags, but they
  are now accounted for (SecurityOps -> "Security", System -> "System");
- MeshObservabilityController used the tag "Mesh.Observability". Orval's
  tags-split mode derives a filename from the tag, so the dot would end up in a
  generated TS file. Normalised to "MeshObservability" per the documented
  mapping;
- the note claiming "4 controllers already have WithTags" described per-endpoint
  tags; in fact those four tag once at group level, which covers all endpoints.

Also recorded, not fixed: POST /api/skills/{id}/improve is registered twice,
in SkillsController and in SkillLifecycleController. ASP.NET Core resolves a
duplicate route to the last registration, so the operation resolves to
ImproveSkillLifecycle / SkillLifecycle and the SkillsController metadata is
dead. That is a route collision rather than a tagging problem and needs its own
task.

Build 0 errors. Tests 2152 passed; the 13 failures are the same pre-existing
set as baseline (Redis, NATS, Otel, Wasmtime, numeric validator, eval and
config-default tests needing external services), with membership identical
across runs - the count moves between 11 and 13 because several are flaky.

Finalize the first release off this branch. The Electron shell is replaced by
the agent serving the Studio SPA itself (ADR-0009), which removes a runtime
surface existing installations depend on — hence the major bump from the
documented-but-untagged 1.0.0.

Version identity (owner decision, explicit confirmation):
- CHANGELOG-EN/RU: restructured to Keep a Changelog order. The previous
  "[Unreleased]" block held shipped, tested work (Phase 4, v2, Phase 8) and is
  now folded into 2.0.0; the new release section sits above the historical
  1.0.0 instead of below it. 1.0.0 is annotated as never tagged.
- Directory.Build.props: single <Version>2.0.0</Version> for the assemblies.
  Imported before each csproj body, so SkillSdk keeps its independent
  0.4.0-preview NuGet lineage.
- package.json: 0.2.0 -> 2.0.0.

Fix found while re-verifying before tagging:
- GraphEditor.vue: setEdge was typed "from" | "to" but the edge-label input
  called it with "label", breaking `npm run typecheck`. Widened to
  keyof WorkflowEdge. The illegal v-model="graph.edges[index].label" had
  already been replaced by :value + @input under noUncheckedIndexedAccess;
  this finishes that change rather than reverting it.

Verified on this commit:
- dotnet build src/agent/Hercules.slnx -c Release: 0 warnings, 0 errors
- agent tests: 2276 passed, 0 failed
- Studio typecheck: 0 errors; biome lint: 81 files clean
- Studio unit: 97 passed; E2E (Playwright): 30 passed
- vite build OK

Not in this release, still open:
- task_105 (workflow executor + typed WorkflowGraph) — no node definitions or
  named owner; declined repeatedly rather than invented.
- Stage 6.10 withdrawal — provisional, awaiting explicit owner confirmation.

Follow-up to the 2.0.0 release commit, found while validating the rewritten
changelogs against the repo's own guards.

stage_06_config_restart.md — the `**Status:**` banner asserted 6.10's C# tab
"is withdrawn", flatly. The body of the same file already documented that the
withdrawal rests on a timeout auto-selection (`explicitUserConfirmation: false`)
and is therefore provisional. The banner is the line anyone reads first, so the
unauthorised claim was the one that propagated; it now says "withdrawn
provisionally, not by owner decision" and points at 6.10. Also dropped a stray
trailing `|` on that line.

count-stage-tasks.cjs — printed a bare "TOTAL open=345", which reads as a
backlog. It is not one: none of these ten stage files had their checkboxes
ticked during the web-first migration, and every file carries an explicit
banner saying so. That figure had already been mis-cited once as outstanding
work. The script now prints each file's authoritative `**Status:**` line, labels
the box count as "not a progress report", and exits non-zero if any file loses
its status line or its disclaimer — turning a misleading counter into a
consistency guard.

No product code changed. Guards after the edit: 841 doc links resolve, 117
backlog rows consistent, all 10 stage files carry status + disclaimer, ci.yml
structurally sound.