comisai 1.0.45 → 1.0.46

package/node_modules/@comis/daemon/dist/api/types.d.ts

@@ -1,16 +1,14 @@
 /**
  * Per-domain API dependency slices for daemon RPC handlers.
  *
- * The monolithic dispatcher-deps superset is replaced with 11 per-domain
- * cluster slices. Each handler factory consumes its narrow slice; the
- * ApiDispatchDeps aggregator (extends all 11) is consumed ONLY by the
- * dispatcher itself.
+ * The dispatcher deps are partitioned into 11 per-domain cluster slices.
+ * Each handler factory consumes its narrow slice; the ApiDispatchDeps
+ * aggregator (extends all 11) is consumed ONLY by the dispatcher itself.
  *
- * The field partition is exhaustive: every field on the legacy
- * dispatcher-deps interface maps to exactly one cluster slice. The
- * aggregator's `extends` clause unions all 11 slices back into the legacy
- * shape, preserving structural compatibility with the 27 still-legacy
- * `*HandlerDeps` interfaces in api/*-handlers.ts.
+ * The field partition is exhaustive: every dispatcher dep maps to exactly
+ * one cluster slice. The aggregator's `extends` clause unions all 11 slices
+ * into the full dispatch shape, preserving structural compatibility with
+ * the 27 `*HandlerDeps` interfaces in api/*-handlers.ts.
  *
  * @module
  */
@@ -89,13 +87,13 @@ export interface SessionsApiDeps {
      *  consumes the derived field to filter to CONFIRMED-only messages, but the
      *  field is also useful to the dashboard / observers. */
     deliveryQueue?: import("@comis/core").DeliveryQueuePort;
-    /** LCD lossless-store write+run surface — `session.reset_conversation` (164-06)
+    /** LCD lossless-store write+run surface — `session.reset_conversation`
      *  calls `deleteConversationLcd` in `runOnConversation` to clear lcd_* rows.
      *  Optional: the handler fails-closed (throws "LCD store not available") when
      *  absent, never a silent 0 count. Same instance as MemoryApiDeps; the copy here
      *  lets session-archive.ts access it without widening to the full MemoryApiDeps slice. */
     lcdStore?: import("@comis/core").ContextStorePort;
-    /** MemoryPort for session-archive --memory reset (DIST-05). The concrete
+    /** MemoryPort for session-archive --memory reset. The concrete
      *  adapter is SqliteMemoryAdapter (which implements MemoryPort) — it is the
      *  SAME object as MemoryApiDeps.memoryAdapter, threaded onto this slice at the
      *  composition root (daemon.ts) so the session.reset_conversation handler can
@@ -104,22 +102,22 @@ export interface SessionsApiDeps {
      *  --memory flag logs a not-available WARN and clears LCD + sessionStore only. */
     memoryPort?: import("@comis/core").MemoryPort;
     /** MemoryConsolidationStore for --memory consolidated-observation unlink /
-     *  --purge-derived (DIST-05). The SAME instance as MemoryApiDeps.consolidationStore.
+     *  --purge-derived. The SAME instance as MemoryApiDeps.consolidationStore.
      *  Optional for the same handler-test reason; absent ⇒ the unlink/purge steps are
      *  skipped (the by-session memory delete itself still runs). */
     consolidationStore?: import("@comis/core").MemoryConsolidationStore;
-    /** Runtime-layer (L3) destroy for `session.reset_conversation` — live finding
-     *  2026-06-11: clearing LCD + sessionStore alone resurrects (the surviving pi
+    /** Runtime-layer (L3) destroy for `session.reset_conversation` — clearing
+     *  LCD + sessionStore alone resurrects the conversation (the surviving pi
      *  runtime JSONL re-ingests wholesale via the lcd-ingest epoch rebase). Wired
      *  at the composition root from `createConversationReset(...).destroyRuntimeSession`
      *  bound to the default agent. Returns true when an adapter destroy ran.
      *  Optional: absent ⇒ the handler reports `runtimeSessionDestroyed: false`
      *  and WARNs with the resurrection consequence (honest degradation). */
     destroyRuntimeSession?: (formattedSessionKey: string) => Promise<boolean>;
-    /** Executor session-scoped state cleanup (175-REVIEW CR-02): wired at the
+    /** Executor session-scoped state cleanup: wired at the
      *  composition root (daemon.ts) to @comis/agent's clearSessionState — the
      *  single authoritative path that drops the per-key tool-schema snapshots,
-     *  the GBNF-02 strip-retry once-gate, JIT-guide delivery, cache latches,
+     *  the GBNF strip-retry once-gate, JIT-guide delivery, cache latches,
      *  etc. session.reset_conversation / session.delete call it so a reset or
      *  recreated session does not inherit the old key's executor state (the
      *  strip once-gate would otherwise terminal-fail the "fresh" session's
@@ -205,13 +203,13 @@ export interface MemoryApiDeps {
     onSuspiciousContent?: import("@comis/core").WrapExternalContentOptions["onSuspiciousContent"];
     /** LCD lossless-store read surface — the `context.tree` handler resolves a
      *  conversation's context_items + summaries via `getContextItems` /
-     *  `getSummaries` (R4 agent+tenant scoped). The SAME ContextStorePort
+     *  `getSummaries` (agent+tenant scoped). The SAME ContextStorePort
      *  setup-memory builds (`lcdStore`). Optional so existing handler tests build
      *  deps without it; the context.* handlers fail-closed (empty result) when absent. */
     lcdStore?: import("@comis/core").ContextStorePort;
     /** LCD operator-browse read surface — the `context.conversations` handler
      *  enumerates the agent's distinct conversations via `listConversations`
-     *  (R4 agent+tenant scoped). Built by setup-memory (`createLcdBrowseStore`).
+     *  (agent+tenant scoped). Built by setup-memory (`createLcdBrowseStore`).
      *  Optional for the same handler-test reason; absent ⇒ empty result. */
     contextBrowse?: import("@comis/core").ContextBrowsePort;
 }
@@ -244,11 +242,11 @@ export interface ChannelsApiDeps {
     workspaceDirs: Map<string, string>;
     logger: ComisLogger;
     persistDeps?: PersistToConfigDeps;
-    /** Phase 213 (QUOTA-01/02): the bounded-autonomy service. message.send/reply/react consult `tryOutward` (origin/grant/per-hour/volume) before deliver. Optional; absent ⇒ inert. A daemon-initiated send (no `_agentId`) is never gated. */
+    /** The bounded-autonomy service. message.send/reply/react consult `tryOutward` (origin/grant/per-hour/volume) before deliver. Optional; absent ⇒ inert. A daemon-initiated send (no `_agentId`) is never gated. */
     boundedAutonomy?: import("../autonomy/bounded-autonomy.js").BoundedAutonomy;
-    /** Phase 216 ONCE-01/02: tree-stable rootRunId resolver (same as SessionsApiDeps.resolveRootRunId, already spread into the flat dispatch deps). message.send/reply/react derive the outward-ledger idempotency key from it; absent ⇒ the wrap is a pass-through. */
+    /** Tree-stable rootRunId resolver (same as SessionsApiDeps.resolveRootRunId, already spread into the flat dispatch deps). message.send/reply/react derive the outward-ledger idempotency key from it; absent ⇒ the wrap is a pass-through. */
     resolveRootRunId?: (sessionKey: import("@comis/core").SessionKey) => string;
-    /** Phase 216 ONCE-01: the three-state outward ledger; absent ⇒ no exactly-once wrap (older/non-autonomy daemon) */
+    /** The three-state outward ledger; absent ⇒ no exactly-once wrap (non-autonomy daemon) */
     outwardLedger?: import("@comis/core").OutwardSendLedgerPort;
 }
 /**
@@ -286,7 +284,7 @@ export interface AgentsApiDeps {
 /**
  * Dependencies for cron-handlers + graph-handlers + heartbeat-handlers + subagent-handlers
  * (cron.list/run, graph.list/run, heartbeat.list/run, subagent.list).
- * @optional-field-count: 14 — daemon-internal orchestration-plane slice; every optional gates on a daemon-global resource (graph coordinator, heartbeat runner, leaseManager/durableRuns, the Phase-217 autonomy plane denialBreaker/evictRegistry/escalate). daemon.ts supplies each from the cap-endpoint handle or config; a non-autonomy boot leaves them absent (byte-identical pre-217). Keep until a structural slice split.
+ * @optional-field-count: 15 — daemon-internal orchestration-plane slice; every optional gates on a daemon-global resource (graph coordinator, heartbeat runner, leaseManager/durableRuns, the autonomy plane denialBreaker/evictRegistry/escalate, the orchestrateReplay wiring cluster). daemon.ts supplies each from the cap-endpoint handle or config; a non-autonomy boot leaves them absent. Keep until a structural slice split.
  */
 export interface OrchestratorApiDeps {
     getAgentCronScheduler: (agentId: string) => CronScheduler;
@@ -320,12 +318,14 @@ export interface OrchestratorApiDeps {
     logger: ComisLogger;
     /** graph-handlers reads deps.dataDir for graph-runs output. */
     dataDir?: string;
-    /** subagent-handlers reads deps.subAgentRunner.list/kill/steer; autonomy-handlers (213-06) reads killByRootRun for run.kill. */
+    /** subagent-handlers reads deps.subAgentRunner.list/kill/steer; autonomy-handlers reads killByRootRun for run.kill. */
     subAgentRunner: ReturnType<typeof createSubAgentRunner>;
-    /** autonomy-handlers (213-06 REVOKE-01/03) revoke fan-outs. Optional: Plan 07 wires it; absent ⇒ handlers not registered. */ leaseManager?: import("@comis/infra").LeaseManager;
-    /** Phase 216 DUR-03: the durable-run store — autonomy-handlers ALSO calls invalidateForRevoke(rootRunId) on lease.revoke/run.kill so a restart cannot resume pre-revoke caps. Optional; absent ⇒ the persisted record is not poisoned (only matters when durability is enabled, which is when Plan 07 wires it). */ durableRuns?: import("@comis/core").DurableRunPort;
+    /** autonomy-handlers revoke fan-outs. Optional: wired at the composition root; absent ⇒ handlers not registered. */ leaseManager?: import("@comis/infra").LeaseManager;
+    /** The durable-run store — autonomy-handlers ALSO calls invalidateForRevoke(rootRunId) on lease.revoke/run.kill so a restart cannot resume pre-revoke caps. Optional; absent ⇒ the persisted record is not poisoned (only matters when durability is enabled, which is when the composition root wires it). */ durableRuns?: import("@comis/core").DurableRunPort;
     denialBreaker?: import("../autonomy/denial-breaker.js").DenialBreaker;
     evictRegistry?: import("../autonomy/evict-registry.js").EvictRegistry;
+    /** The operator deterministic-replay wiring cluster (outputGuard + the sandbox-backed pinned-byte re-spawn seam + an optional replay-socket factory). OPTIONAL — the composition root assembles it from the cap-endpoint handle + the sandbox; absent ⇒ `orchestrate.replay` is not registered. Combined in rpc-dispatch with `durableRuns` (runId validation) + a workspace resolver into the createOrchestrateReplayHandlers session deps. The SEPARATE replay socket + re-spawn are never a mode of the production endpoint (INV-1). */
+    orchestrateReplay?: import("../wiring/setup-orchestrate-replay.js").OrchestrateReplayWiring;
     escalate?: import("../autonomy/durable-resume-engine.js").NotifyFn;
     eventBus?: AppContainer["eventBus"];
     getProviderCapabilityClass?: (provider: string | undefined) => import("@comis/agent").CapabilityClass | undefined;
@@ -503,9 +503,9 @@ export interface AuthApiDeps {
  * Dependencies for media-handlers + image-handlers
  * (media.transcribe/extract_document/tts, image.generate).
  */
-/** OBS-03 (196): the boot-resolved voice (STT/TTS) selection threaded to the
+/** The boot-resolved voice (STT/TTS) selection threaded to the
  *  daemon RPC handlers for the trajectory emit — `provider`/`keyless`/`source` rung
- *  + the collected `onSkip` reasons (the OBS-03 selection observability). Resolved
+ *  + the collected `onSkip` reasons (the selection observability). Resolved
  *  ONCE at boot by `setupMedia` from the SAME `SttSelection`/`TtsSelection` the
  *  adapter construction used (no second source of truth). Optional — a selector-less
  *  boot leaves it undefined and the handler derives provider+keyless from config. */
@@ -526,9 +526,9 @@ export interface MediaApiDeps {
             defaultScopeAction: "allow" | "deny";
             defaultProvider?: string;
         };
-        /** OBS-03 (196): the STT (transcription) config slice. The runtime object is the
+        /** The STT (transcription) config slice. The runtime object is the
          *  full `integrations.media` config, so this is already present; declared here so
-         *  `media.test.stt` reports the STT provider (the :595 reads-TTS RED-proof fix). */
+         *  `media.test.stt` reports the STT provider (not the TTS one). */
         transcription: {
             provider?: string;
             model?: string;
@@ -557,19 +557,19 @@ export interface MediaApiDeps {
         logger: ComisLogger;
         /** Direct channel delivery -- resolve adapter by channel type. */
         getChannelAdapter: (channelType: string) => Pick<import("@comis/core").ChannelPort, "sendAttachment"> | undefined;
-        /** RES-01: resolve the agent's main provider in lockstep with the
-         *  completion path (I4 — delegates to the same resolveAgentModel). The
+        /** Resolve the agent's main provider in lockstep with the
+         *  completion path (delegates to the same resolveAgentModel). The
          *  handler uses this only for observability + lockstep verification; the
          *  provider INSTANCE is selected at wiring time (setup-image-provider.ts),
          *  never re-derived here (no second source of truth). */
         resolveAgentMainProvider: (agentId: string) => {
             providerId: string;
         };
-        /** IN-01 (185): resolve a `reference_image` workspace file path under the
+        /** Resolve a `reference_image` workspace file path under the
          *  caller's agent dir (safePath confinement). Mirror MediaApiDeps:572-573. */
         workspaceDirs: Map<string, string>;
         defaultWorkspaceDir: string;
-        /** DEL-01 (186): the per-agent persistence getter. Persists the generated
+        /** The per-agent persistence getter. Persists the generated
          *  image buffer to the agent's confined workspace (`~/.comis/workspace/media/
          *  photos/`) via MediaPersistenceService — replacing the ephemeral tmpdir
          *  write+delete. The agentId resolves the workspace inside the getter
@@ -581,7 +581,7 @@ export interface MediaApiDeps {
             mediaKind: "image";
             mimeType: string;
         }) => Promise<import("@comis/shared").Result<import("@comis/skills/tools").PersistedFile, Error>>;
-        /** OBS-04 (186): the per-session trajectory recorder registry. The handler
+        /** The per-session trajectory recorder registry. The handler
          *  resolves the recorder by `_callerSessionKey` and direct-emits the 4
          *  image.* lifecycle events via `getRecorder(sessionKey)?.recordEvent(...)`
          *  (the comis-session-manager.ts:298 precedent — the daemon RPC context has
@@ -589,7 +589,7 @@ export interface MediaApiDeps {
          *  a boot mode without a registry, and a null recorder is skipped. Read off
          *  the BootContext `c.trajectoryRegistry` (already a field). */
         trajectoryRegistry?: import("@comis/observability").SessionTrajectoryHandleRegistry;
-        /** SEC-02 (186): the per-agent/hour USD cost ceiling. Optional — undefined
+        /** The per-agent/hour USD cost ceiling. Optional — undefined
          *  when `integrations.media.imageGeneration.maxCostPerHourUsd` is unset, in
          *  which case the ceiling check is skipped and only the count rate limit
          *  applies (no regression). When present, the handler pre-checks
@@ -598,40 +598,40 @@ export interface MediaApiDeps {
          *  rate limiter (maxPerHour) is RETAINED and orthogonal. Constructed in
          *  buildImageGenBundle (main-helpers.ts), gated on maxCostPerHourUsd. */
         costLimiter?: import("./image-cost-limiter.js").ImageCostLimiter;
-        /** OBS-03 (186, optional secondary): the typed event bus. After a successful
+        /** The typed event bus (optional secondary route). After a successful
          *  generation with a non-zero costUsd the handler emits a synthetic
          *  `observability:token_usage` (tokens all 0, cost.total = costUsd) so the
          *  image cost reaches sharedCostTracker + the token_usage SQLite table +
-         *  billing — the BINDING OBS-03 assertion is the trajectory `image.generated`
-         *  cost-carry (Route a), this is the secondary. Same shape as the
+         *  billing — the BINDING assertion is the trajectory `image.generated`
+         *  cost-carry, this is the secondary. Same shape as the
          *  MemoryApiDeps / WorkspaceApiDeps eventBus so the slices unify. */
         eventBus?: AppContainer["eventBus"];
     };
     videoHandlerDeps?: import("./video-handler-deps.js").VideoHandlerDepsShape;
-    /** Video status deps (Phase 189 / Plan 03 — JOB-04). The READ side of the
+    /** Video status deps. The READ side of the
      *  async lifecycle: `video.status` reads the agent-scoped job store the poller
      *  writes. Lives in the same sibling leaf module (`./video-handler-deps.ts`) to
      *  keep THIS file under the 800-line cap; the dispatcher passes it through to
      *  createVideoStatusHandlers. */
     videoStatusHandlerDeps?: import("./video-handler-deps.js").VideoStatusHandlerDepsShape;
-    /** VIS-01 (187): resolve the agent's MAIN provider id in lockstep with the
-     *  completion path (I4) — used for the obs label + the resolveVisionPath
+    /** Resolve the agent's MAIN provider id in lockstep with the
+     *  completion path — used for the obs label + the resolveVisionPath
      *  input. The provider INSTANCE/creds are resolved inside mainProviderVision
-     *  (no second source of truth — the 183 firewall). Top-level (the vision
+     *  (no second source of truth). Top-level (the vision
      *  handlers read `deps.X` directly, unlike image's nested imageHandlerDeps).
      *  Optional — absent on a boot mode without vision wiring → the handler treats
      *  the main as "unknown" (not vision-capable) and falls to the registry. */
     resolveAgentMainProvider?: (agentId: string) => {
         providerId: string;
     };
-    /** VIS-01 (187): resolve the agent's MAIN model id, the SAME way
+    /** Resolve the agent's MAIN model id, the SAME way
      *  buildMediaVisionBundle resolves it (the single resolveAgentModel source of
      *  truth). The handler-side vision gate computes `isVisionCapable(getModel(
      *  main.providerId, mainModelIdFor(agentId)))` to short-circuit a non-vision
      *  main WITHOUT an LLM call (the setup-channels-media.ts:135 try/catch dance).
      *  Optional/undefined → the gate is conservative (not vision-capable). */
     mainModelIdFor?: (agentId: string) => string | undefined;
-    /** VIS-01 (187): the main-provider vision bridge — ONE bounded completeSimple
+    /** The main-provider vision bridge — ONE bounded completeSimple
      *  over a multimodal [text,image] message on the agent's MAIN model, reusing
      *  the main creds (no separate vision key). Returns the description + optional
      *  costUsd, or an honest err (errorKind). The handler tries this FIRST when
@@ -642,20 +642,19 @@ export interface MediaApiDeps {
             costUsd?: number;
         }, Error>>;
     };
-    /** VIS-04 (187, Plan 03 fills the emits): the per-session trajectory recorder
+    /** The per-session trajectory recorder
      *  registry — the handler resolves getRecorder(_callerSessionKey) and direct-
      *  emits the media.vision.* lifecycle (the comis-session-manager.ts:298
-     *  precedent — no eventBus bridge in the daemon RPC context). Declared now;
-     *  the emits land in Plan 03. */
+     *  precedent — no eventBus bridge in the daemon RPC context). */
     trajectoryRegistry?: import("@comis/observability").SessionTrajectoryHandleRegistry;
-    /** OBS-03 (196): the boot-resolved voice selections the daemon voice handlers
+    /** The boot-resolved voice selections the daemon voice handlers
      *  thread onto the `media.stt.*`/`media.tts.*` trajectory via `wireVoiceObs`.
      *  Optional — undefined on a selector-less boot (handler derives from config). */
     voiceSelection?: {
         stt?: ResolvedVoiceSelection;
         tts?: ResolvedVoiceSelection;
     };
-    /** OBS-04 (196): the obs store the voice obs inserts a `voice_degraded`
+    /** The obs store the voice obs inserts a `voice_degraded`
      *  health_signal row into on a STT/TTS failure (feeds the `comis fleet`
      *  voice_health finding). Same instance as `ObservabilityApiDeps.obsStore`;
      *  declared here so the voice handlers' deps slice can read it. Optional. */
@@ -673,7 +672,7 @@ export interface MediaApiDeps {
 /**
  * Dependencies for obs-handlers (obs.usage/billing/diagnostics/budget/spend).
  * @optional-field-count: 14 — a composition-root deps bag; each optional field is a
- * distinct obs source present iff wired (absent ⇒ honest-degrade). +1 per new source (spendSnapshot 179; durableRuns 220-03 autonomy).
+ * distinct obs source present iff wired (absent ⇒ honest-degrade). +1 per new source.
  */
 export interface ObservabilityApiDeps {
     diagnosticCollector: DiagnosticCollector;
@@ -687,8 +686,8 @@ export interface ObservabilityApiDeps {
             perDay: number;
         };
     }>;
-    /** WEBUI-02 (179-04): reader for the LIVE daemon-wide spend the kill-switch enforces (locked
-     *  A1 — `getSnapshot()`, NOT the lagging SQL) + the ceilings, so `obs.spend.snapshot` computes
+    /** Reader for the LIVE daemon-wide spend the kill-switch enforces
+     *  (`getSnapshot()`, NOT the lagging SQL) + the ceilings, so `obs.spend.snapshot` computes
      *  headroom = ceiling − spend (the `budgetGuards` precedent). Absent ⇒ off → `enabled:false`. @optional-field */
     spendSnapshot?: () => {
         perAgent: ReadonlyMap<string, number>;
@@ -728,12 +727,12 @@ export interface ObservabilityApiDeps {
      * Injected ClockPort for obs.fleet.health's `sinceHours` -> `sinceMs`
      * conversion (the globals gate forbids Date.now()/new Date() in the
      * handler/assembler). Populated by `buildRpcDispatchDeps` in daemon.ts
-     * (Phase 161-02) from `boot.clock`. Optional preserves existing handler
+     * from `boot.clock`. Optional preserves existing handler
      * tests that pass {} for deps; the fleet handler asserts `deps.clock!`
-     * because 161-02 always populates it, and the fleet tests inject a fakeClock.
+     * because buildRpcDispatchDeps always populates it, and the fleet tests inject a fakeClock.
      */
     clock?: import("@comis/core").ClockPort;
-    /** FLEET-01/02/04 (220-03): the durable-run store the fleet assembler reads (`countByStatus`) for the autonomy block. Soft-fail (obsStore? precedent): absent ⇒ the block is OMITTED (offline CLI / non-durability boot). Wired on the SAME object as obsStore/clock by buildRpcDispatchDeps (daemon.ts:893). @optional-field */ durableRuns?: import("@comis/core").DurableRunPort;
+    /** The durable-run store the fleet assembler reads (`countByStatus`) for the autonomy block. Soft-fail (obsStore? precedent): absent ⇒ the block is OMITTED (offline CLI / non-durability boot). Wired on the SAME object as obsStore/clock by buildRpcDispatchDeps (daemon.ts:893). @optional-field */ durableRuns?: import("@comis/core").DurableRunPort;
     /**
      * DI seam for the bundle pipeline.
      * Tests inject a stub that returns ok({ bundleDir: "/tmp/bundle", ... }).
@@ -757,10 +756,10 @@ export interface DaemonApiDeps {
  * architecture test bans handler-to-handler imports; aggregator narrowing is
  * structural and happens at the dispatcher boundary.
  *
- * Structural-typing invariant: the union of the 11 slices is structurally
- * IDENTICAL to the legacy aggregator. Every field name and type was
- * lifted verbatim and partitioned across slices with NO duplication. The
- * 27 legacy `*HandlerDeps` interfaces in api/*-handlers.ts remain assignable
+ * Structural-typing invariant: every field lives on exactly ONE slice
+ * (no duplication), and the union of the 11 slices is the full dispatch
+ * shape. The
+ * 27 `*HandlerDeps` interfaces in api/*-handlers.ts remain assignable
  * from ApiDispatchDeps via structural subtyping at every dispatcher call
  * site (createSessionHandlers(deps), createMemoryHandlers(deps), ...).
  */

package/node_modules/@comis/daemon/dist/api/types.js

@@ -2,16 +2,14 @@
 /**
  * Per-domain API dependency slices for daemon RPC handlers.
  *
- * The monolithic dispatcher-deps superset is replaced with 11 per-domain
- * cluster slices. Each handler factory consumes its narrow slice; the
- * ApiDispatchDeps aggregator (extends all 11) is consumed ONLY by the
- * dispatcher itself.
+ * The dispatcher deps are partitioned into 11 per-domain cluster slices.
+ * Each handler factory consumes its narrow slice; the ApiDispatchDeps
+ * aggregator (extends all 11) is consumed ONLY by the dispatcher itself.
  *
- * The field partition is exhaustive: every field on the legacy
- * dispatcher-deps interface maps to exactly one cluster slice. The
- * aggregator's `extends` clause unions all 11 slices back into the legacy
- * shape, preserving structural compatibility with the 27 still-legacy
- * `*HandlerDeps` interfaces in api/*-handlers.ts.
+ * The field partition is exhaustive: every dispatcher dep maps to exactly
+ * one cluster slice. The aggregator's `extends` clause unions all 11 slices
+ * into the full dispatch shape, preserving structural compatibility with
+ * the 27 `*HandlerDeps` interfaces in api/*-handlers.ts.
  *
  * @module
  */

package/node_modules/@comis/daemon/dist/api/veo-adapter.d.ts

@@ -1,6 +1,6 @@
 import type { VideoGenerationPort } from "@comis/core";
 import type { ComisLogger } from "@comis/infra";
-/** Options bounding the result download (WR-01). Copied from fal-adapter.ts. */
+/** Options bounding the result download. Copied from fal-adapter.ts. */
 export interface VideoFetchResultOpts {
     signal?: AbortSignal;
     maxBytes?: number;

package/node_modules/@comis/daemon/dist/api/veo-adapter.js

@@ -1,18 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // @allow-throw: integration/SDK boundary wrapper; throws caught by fromPromise at the port boundary.
 /**
- * Google Veo video adapter (VEO-01 / VEO-02).
+ * Google Veo video adapter.
  *
  * A `VideoGenerationPort` over `@google/genai@1.52.0`. Unlike the FAL adapter
  * (a queue API), Veo is an SDK LONG-RUNNING OPERATION (LRO):
  *   - submit:  `ai.models.generateVideos({ model, prompt, config })` → an
  *              operation whose `.name` is the durable, secret-free jobId
- *              (VPORT-03) — DIFFERS from FAL's queue `request_id`.
+ *              — DIFFERS from FAL's queue `request_id`.
  *   - poll:    `ai.operations.getVideosOperation({ operation: { name } })` →
  *              `.done` + `.error`; `!done ? pending : (error ? failed : done)`.
  *   - fetch:   `op.response.generatedVideos[0].video` → either inline base64
  *              `videoBytes` (no fetch) or a 2-day-expiry `uri` fetched WITH the
- *              Dev-API `&key=` query param → a Buffer (DEL-01: download BEFORE
+ *              Dev-API `&key=` query param → a Buffer (download BEFORE
  *              return so the expiring URI can never orphan the job).
  *
  * PLACEMENT: this adapter lives in `@comis/daemon/src/api/` (NOT `@comis/skills`,
@@ -22,7 +22,7 @@
  * helpers are COPIED from `fal-adapter.ts` (private there) rather than imported,
  * to avoid a skills→daemon import edge (the FAL file's comment directs this).
  *
- * COST (A4): `GenerateVideosResponse` has NO usage/cost field — Veo's actual
+ * COST: `GenerateVideosResponse` has NO usage/cost field — Veo's actual
  * cost is the pre-submit estimate (rate × duration). The adapter therefore does
  * NOT populate `costUsd`; the handler's `estimateVideoCostUsd` is the actual.
  *
@@ -44,13 +44,13 @@ import { classifyVeoVideoError } from "./classify-veo-video-error.js";
  */
 const DEFAULT_VEO_MODEL = "veo-3.0-fast-generate-001";
 /**
- * WR-01: hard fallback timeout for the result download when the caller threads no
- * AbortSignal (a standalone `fetchResult` from Phase 189's poller). Bounds a hung
+ * Hard fallback timeout for the result download when the caller threads no
+ * AbortSignal (a standalone `fetchResult` from the off-turn poller). Bounds a hung
  * CDN on the download leg. Copied from fal-adapter.ts.
  */
 const DOWNLOAD_TIMEOUT_MS = 120_000;
 /**
- * WR-01: default streamed byte ceiling for the result download (a Content-Length
+ * Default streamed byte ceiling for the result download (a Content-Length
  * pre-check + a streamed running total → OOM guard). 200 MB matches
  * VIDEO_PERSIST_MAX_BYTES. Copied from fal-adapter.ts.
  */
@@ -67,16 +67,16 @@ export function createVeoVideoAdapter(opts) {
     const ai = new GoogleGenAI({ apiKey: opts.apiKey });
     const model = opts.model ?? DEFAULT_VEO_MODEL;
     /** Re-poll the operation by name to obtain its current state/response. Both
-     *  poll() and fetchResult() use this (the 189 poller calls them with only the
+     *  poll() and fetchResult() use this (the off-turn poller calls them with only the
      *  persisted { jobId }, so the operation handle is reconstructed from the name —
      *  the SDK reads `.name`). */
     const getOperation = (jobId) => ai.operations.getVideosOperation({ operation: { name: jobId } });
     /**
-     * WR-04: build the `VideoGenOutput` from an ALREADY-FETCHED terminal operation
+     * Build the `VideoGenOutput` from an ALREADY-FETCHED terminal operation
      * — the single source of the download decision. `fetchResult` polls once then
      * calls this; `execute()` passes the terminal operation its poll loop ALREADY
-     * read, so it makes ONE getVideosOperation round-trip instead of two (the old
-     * code re-read the operation inside fetchResult). The download fetch is separate.
+     * read, so it makes ONE getVideosOperation round-trip instead of two.
+     * The download fetch is separate.
      */
     const buildVeoOutput = async (job, cur, fetchOpts) => {
         if (cur.error) {
@@ -91,12 +91,12 @@ export function createVeoVideoAdapter(opts) {
         let buffer;
         let mimeType;
         if (video.videoBytes) {
-            // Inline base64 — no fetch (Pitfall 2).
+            // Inline base64 — no fetch.
             buffer = Buffer.from(video.videoBytes, "base64");
             mimeType = video.mimeType ?? "video/mp4";
         }
         else if (video.uri) {
-            // Dev API requires the key as a query param (A5). SEC: this keyed URL is
+            // The Dev API requires the key as a query param. SEC: this keyed URL is
             // NEVER logged. deriveVideoMime reads the UN-keyed video.uri.
             const url = `${video.uri}&key=${opts.apiKey}`;
             const { buffer: dl, contentType } = await downloadVideoBytes(url, fetchOpts);
@@ -107,12 +107,12 @@ export function createVeoVideoAdapter(opts) {
             const c = classifyVeoVideoError(null, { emptyResult: true });
             throw new VideoGenError(c.hint, c);
         }
-        // WR-03: the output model reflects what actually rendered — `job.model` (set
+        // The output model reflects what actually rendered — `job.model` (set
         // at submit from `input.model ?? construction model`; round-tripped through
         // the persisted row to the off-turn poller) when present, else the default.
         const outModel = job.model || model;
         opts.logger?.debug({ model: outModel, jobId: job.jobId, step: "video.fetch" }, "veo: downloaded result");
-        // NO costUsd (A4): GenerateVideosResponse has no usage/cost field; the
+        // NO costUsd: GenerateVideosResponse has no usage/cost field; the
         // handler's estimate is the actual. Do NOT invent a cost field.
         return {
             buffer,
@@ -127,7 +127,7 @@ export function createVeoVideoAdapter(opts) {
         isAvailable: () => true,
         submit(input) {
             return fromPromise((async () => {
-                // WR-03: the PER-REQUEST `input.model` (what the IN-02 handler validated
+                // The PER-REQUEST `input.model` (what the handler validated
                 // against, `params.model ?? config.model`) wins over the construction
                 // default so validation and execution AGREE. poll()/fetchResult() key on
                 // the operation NAME (not the model), so the effective model only matters
@@ -136,12 +136,12 @@ export function createVeoVideoAdapter(opts) {
                 const op = await ai.models.generateVideos({
                     model: effectiveModel,
                     prompt: input.prompt,
-                    // IN-01 (A4): the first-frame image is a TOP-LEVEL generateVideos arg
+                    // The first-frame image is a TOP-LEVEL generateVideos arg
                     // (the SDK Image_2 raw-bytes shape { imageBytes, mimeType }), NOT a
                     // config field. SAME model id for t2v AND i2v (no endpoint swap,
                     // unlike FAL). Only the SINGULAR referenceImage is consumed; the
-                    // additive referenceImages array (Veo lastFrame/referenceImages) is a
-                    // LOCKED fast-follow deferral — buildVeoConfig is unchanged on that axis.
+                    // additive referenceImages array (Veo lastFrame/referenceImages) is
+                    // deliberately unsupported — buildVeoConfig is unchanged on that axis.
                     ...(input.referenceImage
                         ? { image: { imageBytes: input.referenceImage.data, mimeType: input.referenceImage.mimeType } }
                         : {}),
@@ -151,9 +151,9 @@ export function createVeoVideoAdapter(opts) {
                     throw new Error("veo: generateVideos returned no operation name");
                 }
                 const job = {
-                    jobId: op.name, // op.name is the durable, secret-free jobId (VPORT-03)
+                    jobId: op.name, // op.name is the durable, secret-free jobId
                     provider: "veo",
-                    model: effectiveModel, // WR-03: the model that actually rendered
+                    model: effectiveModel, // the model that actually rendered
                 };
                 opts.logger?.debug({ model: effectiveModel, jobId: job.jobId, step: "video.submit" }, "veo: submitted render");
                 return job;
@@ -163,7 +163,7 @@ export function createVeoVideoAdapter(opts) {
             return fromPromise((async () => {
                 const cur = await getOperation(job.jobId);
                 const state = !cur.done ? "pending" : cur.error ? "failed" : "done";
-                // WR-01: on a terminal failure, thread the SAME classified kind+hint the
+                // On a terminal failure, thread the SAME classified kind+hint the
                 // execute() path emits onto the snapshot (reusing the existing classifier,
                 // not a third one) so the off-turn poller persists the specific kind +
                 // actionable hint instead of collapsing to empty_response. The hint is a
@@ -177,7 +177,7 @@ export function createVeoVideoAdapter(opts) {
         },
         fetchResult(job, fetchOpts) {
             return fromPromise((async () => {
-                // Standalone path (the Phase-189 off-turn poller calls poll() then
+                // Standalone path (the off-turn poller calls poll() then
                 // fetchResult() with NO terminal snapshot): read the operation ONCE here
                 // — it is the source of the download uri/bytes — then build the output.
                 const cur = await getOperation(job.jobId);
@@ -191,11 +191,11 @@ export function createVeoVideoAdapter(opts) {
             const job = submitted.value;
             const deadline = createPollDeadline(runOpts.timeoutMs);
             let lastErr;
-            // WR-04: capture the TERMINAL operation the poll loop reads so fetchResult
+            // Capture the TERMINAL operation the poll loop reads so fetchResult
             // does not re-read it. The poll callback reads the operation DIRECTLY (once
             // per iteration) and derives the state, instead of calling this.poll() (which
             // would discard the operation) + a separate re-read of operation.error on the
-            // failed branch — collapsing the old 2–3 reads to one read per iteration.
+            // failed branch — one read per iteration instead of 2–3.
             let doneOp;
             const outcome = await pollUntilDone({
                 poll: async () => {
@@ -232,13 +232,13 @@ export function createVeoVideoAdapter(opts) {
             if (outcome.kind === "failed") {
                 return mapThrownToErr(lastErr ?? new Error("veo: job failed"));
             }
-            // WR-04: build from the terminal operation the loop already read — no second
+            // Build from the terminal operation the loop already read — no second
             // getVideosOperation. `doneOp` is set whenever the loop reached `done`.
             const fetched = await fromPromise(buildVeoOutput(job, doneOp ?? (await getOperation(job.jobId)), runOpts.signal ? { signal: runOpts.signal } : undefined));
             if (!fetched.ok) {
                 return mapThrownToErr(fetched.error);
             }
-            // WR-05: Veo reports no duration (A4) — fall back to the duration WE
+            // Veo reports no duration — fall back to the duration WE
             // requested so the handler's reconcile + delivery metadata is not empty.
             if (fetched.value.durationSecs === undefined && input.durationSecs !== undefined) {
                 return ok({ ...fetched.value, durationSecs: input.durationSecs });
@@ -248,15 +248,15 @@ export function createVeoVideoAdapter(opts) {
     };
 }
 /**
- * Map a normalized `VideoGenInput` to the Veo `GenerateVideosConfig` (VEO-02).
+ * Map a normalized `VideoGenInput` to the Veo `GenerateVideosConfig`.
  * `durationSeconds` is a NUMBER (NOT the FAL `${n}s` string). Omitted input
  * fields are ABSENT from the config (the `...(x !== undefined ? {k:x} : {})`
  * idiom — no `undefined` keys).
  *
- * IN-01 (Phase 191): the first-frame i2v image is wired as a TOP-LEVEL
- * `generateVideos({image})` arg in `submit` (A4), NOT here — the config holds
- * only `lastFrame`/`referenceImages`, which are the LOCKED multi-ref deferral
- * (no adapter reads `input.referenceImages` this phase), so this config is
+ * The first-frame i2v image is wired as a TOP-LEVEL
+ * `generateVideos({image})` arg in `submit`, NOT here — the config holds
+ * only `lastFrame`/`referenceImages`, which are deliberately unsupported
+ * (no adapter reads `input.referenceImages`), so this config is
  * unchanged on the i2v axis.
  */
 function buildVeoConfig(input) {
@@ -270,38 +270,38 @@ function buildVeoConfig(input) {
     };
 }
 /**
- * WR-07 (trust boundary): `url` is the Veo `video.uri` (with the Dev-API key) — a
+ * Trust boundary: `url` is the Veo `video.uri` (with the Dev-API key) — a
  * PROVIDER-OWNED CDN URL, NOT the agent-supplied i2v `image_url`. The input path
  * is SSRF-guarded elsewhere; this OUTPUT download trusts the Google CDN by design
  * and so does NOT re-run the SSRF resolver — but it still hardens with
  * `redirect:"error"` (never silently follow a CDN open-redirect to an internal
- * IP), a bounded signal (CR-01/WR-01), and a streamed byte cap. COPIED from
- * fal-adapter.ts (the FAL file's comment directs Phase 190 to follow this shape).
+ * IP), a bounded signal, and a streamed byte cap. COPIED from
+ * fal-adapter.ts (see the module header for why it is copied, not imported).
  *
- * @returns the downloaded bytes plus the CDN `content-type` (for WR-06 MIME).
- * @throws on a non-2xx status (CR-01), an empty body, an over-cap body (WR-01),
+ * @returns the downloaded bytes plus the CDN `content-type` (for MIME derivation).
+ * @throws on a non-2xx status, an empty body, an over-cap body,
  *   or an aborted signal — all caught by `fromPromise` at the call site and
  *   classified by `classifyVeoVideoError` into a typed `VideoGenError`.
  */
 async function downloadVideoBytes(url, opts) {
     const maxBytes = opts?.maxBytes ?? DEFAULT_DOWNLOAD_MAX_BYTES;
-    // WR-01: honor the caller's deadline signal; else a hard fallback timeout.
+    // Honor the caller's deadline signal; else a hard fallback timeout.
     const signal = opts?.signal ?? AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS);
     const response = await fetch(url, { redirect: "error", signal });
-    // CR-01: reject a non-2xx status BEFORE reading the body (an expired/4xx Veo
-    // URI returns a 403 error page; without this guard it flows out as a
-    // "successful" mp4 — the orphan-on-expiry class DEL-01 closes).
+    // Reject a non-2xx status BEFORE reading the body: an expired/4xx Veo
+    // URI returns a 403 error page; without this guard it would flow out as a
+    // "successful" mp4, orphaning the job when the URI has expired.
     if (!response.ok) {
         throw new Error(`veo: failed to download video.uri: HTTP ${response.status}`);
     }
-    // WR-01: Content-Length pre-check — abort before buffering if the server
+    // Content-Length pre-check — abort before buffering if the server
     // DECLARES a body over the cap (an OOM guard).
     const declared = parseInt(response.headers.get("content-length") ?? "", 10);
     if (Number.isFinite(declared) && declared > maxBytes) {
         await response.body?.cancel();
         throw new Error(`veo: video.uri body exceeds the ${maxBytes}-byte cap (declared ${declared})`);
     }
-    // WR-01: stream with a running byte cap when a body reader is available; fall
+    // Stream with a running byte cap when a body reader is available; fall
     // back to arrayBuffer otherwise.
     const reader = response.body?.getReader?.();
     let buffer;
@@ -337,16 +337,16 @@ async function downloadVideoBytes(url, opts) {
     }
     return { buffer, contentType: response.headers.get("content-type") };
 }
-/** Known video MIME types for the URL-extension fallback (WR-06). Copied from fal-adapter.ts. */
+/** Known video MIME types for the URL-extension fallback. Copied from fal-adapter.ts. */
 const VIDEO_EXT_MIME = {
     mp4: "video/mp4",
     webm: "video/webm",
     mov: "video/quicktime",
 };
 /**
- * WR-06: derive the output MIME from the CDN `content-type` header when it is a
+ * Derive the output MIME from the CDN `content-type` header when it is a
  * `video/*` type, else from the URL path extension, else fall back to mp4. The
- * `url` passed here is the UN-keyed `video.uri` (SEC — no credential in a
+ * `url` passed here is the UN-keyed `video.uri` (no credential in a
  * logged/errored mime-derivation source). Copied from fal-adapter.ts.
  */
 function deriveVideoMime(contentType, url) {