comisai 1.0.45 → 1.0.46

package/node_modules/@comis/daemon/dist/wiring/setup-context-tools.js

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Daemon-side wiring for the in-session expansion-loop `ctx_*` tools
- * (v2.12 Phase 131, E1/E2): `ctx_search` / `ctx_inspect` / `ctx_expand`.
+ * Daemon-side wiring for the in-session expansion-loop `ctx_*` tools:
+ * `ctx_search` / `ctx_inspect` / `ctx_expand`.
  *
  * The daemon is the composition root — it constructs the concrete LCD store
  * (`createLcdStore`, in `setup-memory`) and injects it here AS the core
  * `ContextStorePort` TYPE, then pushes the three tools onto the agent tool array
- * sharing ONE `ContextToolDeps`. This mirrors the v2.11 terminal-driver wiring
+ * sharing ONE `ContextToolDeps`. This mirrors the terminal-driver wiring
  * (`wireTerminalTools`) exactly: a direct-injection, never-export, owner-scoped
  * tool set wired OUTSIDE the platform-tool parity registry — it is structurally
  * DISTINCT from the cross-session recall layer (no in-process RPC dispatch, no
@@ -23,14 +23,14 @@
  * @module
  */
 // Direct-injection ctx_* factories + the shared deps contract. These live on the
-// `./tools` subpath (NOT the `.` barrel) — the terminal-driver precedent (Plan 03).
+// `./tools` subpath (NOT the `.` barrel) — the terminal-driver precedent.
 import { createCtxSearchTool, createCtxInspectTool, createCtxExpandTool, depthForTier, } from "@comis/skills/tools";
-// DEPTH-02: the capability-axis resolver (frontier/mid/small/nano) — the same
+// The capability-axis resolver (frontier/mid/small/nano) — the same
 // minimal {id, provider} the memory-ops capability resolver uses. The capability
-// axis ignores contextWindow (K2 invariant), so a bare model object is correct.
+// axis ignores contextWindow, so a bare model object is correct.
 import { resolveModelProfile } from "@comis/agent";
 /**
- * Wire the three never-export, dag-mode in-session expansion tools (E1/E2).
+ * Wire the three never-export, dag-mode in-session expansion tools.
  * Mirrors `wireTerminalTools`: build one shared `ContextToolDeps` from the
  * injected store + the daemon deps, then push the three factories onto the
  * agent tool array. The `store` is the concrete `createLcdStore` adapter the
@@ -39,22 +39,22 @@ import { resolveModelProfile } from "@comis/agent";
  * in-process RPC dispatch, no recall-store dispatch path.
  */
 export function wireContextTools(tools, store, _agentId, deps) {
-    // R4 (132-03): `_agentId` stays UNUSED. The ctx_* tools read the live agentId
+    // `_agentId` stays UNUSED. The ctx_* tools read the live agentId
     // (+ tenantId) from the per-call RequestContext (`tryGetContext()`), NOT from
-    // this wiring-time closure — multi-agent-safe (Pitfall 4). One wiring can serve
+    // this wiring-time closure — multi-agent-safe. One wiring can serve
     // multiple agents per channel, so a closure-captured agentId would scope every
-    // agent's reads to whichever agent wired the tools (the exact WR-02 cross-agent
+    // agent's reads to whichever agent wired the tools (the exact cross-agent
     // threat). The store read scope therefore comes from the live turn, never here.
     const shared = {
         store,
         logger: deps.skillsLogger,
         nowMs: deps.nowMs,
         maxExpandTokens: deps.maxExpandTokens,
-        // DEPTH-02: the tier-gated multi-hop depth cap (resolved wiring-time from the
-        // agent's ModelProfile). A capacity knob — R4 scope is still per-call.
+        // The tier-gated multi-hop depth cap (resolved wiring-time from the
+        // agent's ModelProfile). A capacity knob — the read scope is still per-call.
         maxExpandDepth: deps.maxExpandDepth,
         getToolResultsDir: deps.getToolResultsDir,
-        // O1: the daemon's real bus (structurally assignable) so each ctx_* hit
+        // The daemon's real bus (structurally assignable) so each ctx_* hit
         // emits a content-free context:dag_expanded. `undefined` ⇒ silent no-op.
         eventBus: deps.eventBus,
     };
@@ -62,13 +62,13 @@ export function wireContextTools(tools, store, _agentId, deps) {
 }
 /**
  * Gate + wire the dag-mode `ctx_*` tools (extracted from `setup-tools.ts` to keep that file
- * under the 800-line cap — Phase 174-04). Wires the tools when the agent's
+ * under the 800-line cap). Wires the tools when the agent's
  * `contextEngine.version` resolves to `"dag"` AND a store is present.
  *
- * WR-05 (Phase 174-04): the missing-version default is `"dag"` — ALIGNED with
- * `shouldRunLcdStorePasses` (which gates the LCD store WRITES + the DEPTH-03 sweep), so a bare
+ * The missing-version default is `"dag"` — ALIGNED with
+ * `shouldRunLcdStorePasses` (which gates the LCD store WRITES + its sweep), so a bare
  * agent config that writes durable history also wires the `ctx_*` tools that read it back (was
- * `?? "pipeline"` — a pre-existing skew). WR-04: the operator `capabilityClassOverride` (the
+ * `?? "pipeline"` — a pre-existing skew). The operator `capabilityClassOverride` (the
  * same `providers.entries.<id>.capabilities.capabilityClass` source pi-executor uses, supplied
  * by the caller) governs the tier-gated `ctx_expand` walk depth; absent ⇒ provider-family
  * heuristic. No-op (nothing pushed) when not dag mode or no store.
@@ -77,7 +77,7 @@ export function maybeWireContextTools(tools, store, agentId, agentConfig, deps)
     if ((agentConfig?.contextEngine?.version ?? "dag") !== "dag" || !store)
         return;
     const maxExpandTokens = agentConfig?.contextEngine?.maxExpandTokens ?? 4000;
-    // DEPTH-02 / WR-04: tier-gated multi-hop depth (capacity knob → wiring-time; R4 per-call).
+    // Tier-gated multi-hop depth (capacity knob → wiring-time; read scope per-call).
     const maxExpandDepth = resolveCtxExpandDepth(agentConfig?.model, agentConfig?.provider, deps.capabilityClassOverride);
     wireContextTools(tools, store, agentId, {
         skillsLogger: deps.skillsLogger,
@@ -85,17 +85,17 @@ export function maybeWireContextTools(tools, store, agentId, agentConfig, deps)
         maxExpandTokens,
         maxExpandDepth,
         getToolResultsDir: deps.getToolResultsDir,
-        eventBus: deps.eventBus, // O1: ctx_* context:dag_expanded
+        eventBus: deps.eventBus, // ctx_* context:dag_expanded
     });
 }
 /**
- * DEPTH-02: resolve the tier-gated `ctx_expand` multi-hop walk depth
+ * Resolve the tier-gated `ctx_expand` multi-hop walk depth
  * (nano1/small2/mid3/frontier4) from an agent's `model`/`provider`.
  *
- * `RequestContext` carries NO `capabilityClass` (Pitfall 3), so the cap is
+ * `RequestContext` carries NO `capabilityClass`, so the cap is
  * resolved HERE at wiring time from the agent's `ModelProfile`. The DEPTH cap is
  * a CAPACITY knob, NOT a scope — wiring-time resolution is correct even when one
- * `wireContextTools` call serves multiple agents per channel (A3); the R4 read
+ * `wireContextTools` call serves multiple agents per channel; the read
  * scope still comes per-call from `requireCtxScope()` inside each tool. The
  * capability axis ignores `contextWindow`, so the minimal `{ id, provider }` the
  * memory-ops resolver uses is correct here too (resolve-memory-ops-capability.ts).
@@ -103,14 +103,14 @@ export function maybeWireContextTools(tools, store, agentId, agentConfig, deps)
  * `model`/`provider` default to "default" on a parsed agent config; an undefined
  * or unknown model fails closed to the most-locked profile (nano → depth 1).
  *
- * WR-04 (Phase 174-04): `capabilityClassOverride` is the operator's per-provider
+ * `capabilityClassOverride` is the operator's per-provider
  * `providers.entries.<id>.capabilities.capabilityClass` pin (the same source pi-executor
  * threads into the live ModelProfile). When supplied it wins over the provider-family
  * heuristic, so an operator who pins a large quantized ollama model "mid" gets the mid
  * walk depth (3) here too — not the ollama→small→2 heuristic. Absent ⇒ heuristic.
  */
 export function resolveCtxExpandDepth(model, provider, capabilityClassOverride) {
-    // WR-04 (Phase 174-04): thread the operator capabilityClass override (the same
+    // Thread the operator capabilityClass override (the same
     // providers.entries.<id>.capabilities.capabilityClass pin pi-executor.ts:359-364 honors)
     // into resolveModelProfile so a pinned tier governs the ctx_expand walk depth consistently
     // with the rest of the platform — not the provider-family heuristic alone. Absent ⇒ the

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/setup-cross-session-graph.d.ts

@@ -54,7 +54,7 @@ export interface ExecuteSubAgentDeps {
     fileLock: FileLockPort;
     logger?: ComisLogger;
     /**
-     * WT-01: the lifecycle GitExec the composition root binds (the real
+     * The lifecycle GitExec the composition root binds (the real
      * execFile-backed `createExecGit` adapted to `{ stdout, exitCode }`). Present
      * ⇒ a child whose session metadata carries `worktree:true` runs in an isolated
      * git worktree. **Absent ⇒ the worktree request is honestly ignored** (no git
@@ -62,7 +62,7 @@ export interface ExecuteSubAgentDeps {
      * silent no-op. Paired with {@link worktreeRegistry}; the daemon wires BOTH.
      */
     worktreeGitExec?: GitExec;
-    /** WT-02: the shared registry the boot/periodic orphan sweep reads. Paired with {@link worktreeGitExec}. */
+    /** The shared registry the boot/periodic orphan sweep reads. Paired with {@link worktreeGitExec}. */
     worktreeRegistry?: WorktreeRegistry;
 }
 /**
@@ -75,7 +75,7 @@ export type ExecuteSubAgentFn = (agentId: string, sessionKey: SessionKey, task:
     graphNodeDepth?: number;
 }, 
 /** Per-spawn token budget — rides executionOverrides into the child's
- *  BudgetGuard per-execution cap (BUDGET-01). Absent ⇒ no per-execution cap. */
+ *  BudgetGuard per-execution cap. Absent ⇒ no per-execution cap. */
 tokenBudget?: number) => Promise<{
     response: string;
     tokensUsed: {

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/setup-cross-session-graph.js

@@ -133,7 +133,7 @@ export function buildExecuteSubAgent(deps) {
         const baseWorkspaceDir = baseAgentConfig
             ? resolveWorkspaceDir(baseAgentConfig, effectiveAgentId, container.config.dataDir || undefined)
             : resolveWorkspaceDir(container.config.agents["default"] ?? {}, effectiveAgentId, container.config.dataDir || undefined);
-        // WT-01: when the child session metadata requests a worktree (persisted by the
+        // When the child session metadata requests a worktree (persisted by the
         // runner from session.spawn's request.worktree), run the child in an ISOLATED
         // git worktree under its base workspace (off HEAD, auto-clean-if-unchanged). The
         // decision + WARN-on-unwired-seam live in maybePrepareWorktreeForSpawn (size cap);
@@ -297,7 +297,7 @@ export function buildExecuteSubAgent(deps) {
         // Build SpawnPacket from session metadata if spawn fields are present
         let spawnPacket;
         if (meta.taskDescription && !isReuseSession) {
-            // WT-01: the spawn packet's workspace path is the run's actual working tree
+            // The spawn packet's workspace path is the run's actual working tree
             // (the worktree when present), so the child's prompt names the right dir.
             const workspaceDir = effectiveWorkspaceDir;
             const agentWorkspaces = {};
@@ -395,8 +395,8 @@ export function buildExecuteSubAgent(deps) {
             operationType: "subagent",
             promptTimeout: (() => {
                 if (isGraphSpawn) {
-                    // LAT-01: the graph constant is NOT operator-tunable — labeled so
-                    // hints render honest prose instead of a fake agents.* knob (D-11).
+                    // The graph constant is NOT operator-tunable — labeled so
+                    // hints render honest prose instead of a fake agents.* knob.
                     return { promptTimeoutMs: GRAPH_PROMPT_TIMEOUT_MS, source: "graph_constant" };
                 }
                 // Falsy-guard semantics preserved: a 0/undefined subagent resolution
@@ -417,11 +417,11 @@ export function buildExecuteSubAgent(deps) {
             // Thread effective tool groups so pi-event-bridge can enrich
             // "Tool X not found" errors with delegation routing hints.
             activeToolGroups: effectiveToolGroups,
-            // BUDGET-01: a per-spawn token budget becomes the child's per-execution
+            // A per-spawn token budget becomes the child's per-execution
             // cap (pi-executor feeds it to budgetGuard.resetExecution). Omitted when
             // absent so the no-budget path stays byte-identical to today.
             ...(tokenBudget !== undefined && { tokenBudget }),
-            // WT-01: when a worktree was created, the child's file-tool jail cwd IS the
+            // When a worktree was created, the child's file-tool jail cwd IS the
             // worktree (the SDK session cwd + resource-loader / context-engine root), so
             // exec/read/write/edit resolve inside it. Omitted when no worktree ⇒ the
             // executor uses its construction-bound deps.workspaceDir (byte-identical).
@@ -434,7 +434,7 @@ export function buildExecuteSubAgent(deps) {
                 : await getExecutor(effectiveAgentId).execute(msg, sessionKey, tools, undefined, agentId, undefined, undefined, executionOverrides);
         }
         finally {
-            // WT-01: on the child's terminal settle (success OR throw), auto-clean the
+            // On the child's terminal settle (success OR throw), auto-clean the
             // worktree if-unchanged — a pristine worktree is removed, a dirty/ahead one
             // is PRESERVED so the agent's work survives (the boot sweep retries it). A
             // cleanup error must NOT mask the run's own outcome, so it is swallowed with

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/setup-cross-session-runtime.d.ts

@@ -101,17 +101,17 @@ export declare function setupCrossSession(deps: {
     /** Timer scheduling. */
     timers: TimerPort;
     /**
-     * WT-01: the lifecycle GitExec the composition root binds (the real
+     * The lifecycle GitExec the composition root binds (the real
      * execFile-backed `createExecGit` adapted to `{ stdout, exitCode }` via
      * `toLifecycleGitExec`). Threaded into executeSubAgent so a `worktree:true`
      * child runs in an isolated git worktree. Paired with {@link worktreeRegistry}.
      * Absent ⇒ the worktree request is honestly skipped (WARN, not silent no-op).
      */
     worktreeGitExec?: import("@comis/skills/tools").GitExec;
-    /** WT-02: the shared registry the boot/periodic orphan sweep reads (paired with {@link worktreeGitExec}). */
+    /** The shared registry the boot/periodic orphan sweep reads (paired with {@link worktreeGitExec}). */
     worktreeRegistry?: import("../setup-worktree-sweep.js").WorktreeRegistry;
     /**
-     * Phase 213 (CEIL-01): the tree-wide spawn ceiling consult, threaded into the
+     * The tree-wide spawn ceiling consult, threaded into the
      * sub-agent runner's `checkSpawnCeiling` so every spawn (session.spawn AND
      * graph.* AND the in-process loop) is bounded at the convergence point. Bound
      * to `boundedAutonomy.tryAcquireSpawn` by the daemon; absent when no agent is
@@ -124,7 +124,7 @@ export declare function setupCrossSession(deps: {
         reason: string;
     };
     /**
-     * Phase 213 (CR-02): the symmetric release of a slot reserved by
+     * The symmetric release of a slot reserved by
      * {@link checkSpawnCeiling}, threaded into the runner's `releaseSpawnCeiling`
      * so a completed run frees its tree-wide slot (paired 1:1 with the acquire).
      * Bound to `boundedAutonomy.releaseSpawn` by the daemon; absent ⇒ the runner's
@@ -132,7 +132,7 @@ export declare function setupCrossSession(deps: {
      */
     releaseSpawnCeiling?: (rootRunId: string) => void;
     /**
-     * Phase 216 (DUR-01 / HB-01): the durable-run store + its keep-alive thresholds
+     * The durable-run store + its keep-alive thresholds
      * + the leaseId/budget facts resolver, threaded into the sub-agent runner so it
      * writes a per-root checkpoint at the spawn boundary + a heartbeat on the
      * injected timer. All optional; absent ⇒ the runner's durable path is inert (the
@@ -149,14 +149,14 @@ export declare function setupCrossSession(deps: {
         budgetConsumed: number;
     } | undefined;
     /**
-     * Phase 216 (HIGH-2 / ONCE-01..04): the three-state outward-send ledger + the
+     * The three-state outward-send ledger + the
      * announce-origin rootRunId resolver, threaded into BOTH `createCrossSessionSender`
-     * (the announce() ledger wrap, Plan 10 Task 1) AND the announcement dead-letter
-     * queue (the drain committed-skip, Plan 10 Task 2) so the completion-announcement
+     * (the announce() ledger wrap) AND the announcement dead-letter
+     * queue (the drain committed-skip) so the completion-announcement
      * outward path is ledgered exactly-once (no restart double-notify). All optional;
      * absent ⇒ both paths are pure pass-throughs (the byte-identical default). The
-     * daemon (Plan 12, the sole daemon.ts editor) wires them ONLY when durability is on,
-     * reusing the SAME store instances Plan 07 built (one ledger, one durable store).
+     * daemon wires them ONLY when durability is on, reusing the SAME store
+     * instances built at composition (one ledger, one durable store).
      */
     outwardLedger?: OutwardSendLedgerPort;
     resolveRootRunId?: (sessionKey: SessionKey) => string;

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/setup-cross-session-runtime.js

@@ -107,7 +107,7 @@ export function setupCrossSession(deps) {
         getExecutor,
         fileLock: deps.fileLock,
         logger: deps.logger,
-        // WT-01: thread the git-worktree seam + registry so a `worktree:true` child
+        // Thread the git-worktree seam + registry so a `worktree:true` child
         // runs in an isolated worktree (auto-clean-if-unchanged). Both absent ⇒ the
         // request is honestly skipped (no git seam) — byte-identical default.
         ...(deps.worktreeGitExec ? { worktreeGitExec: deps.worktreeGitExec } : {}),
@@ -123,7 +123,7 @@ export function setupCrossSession(deps) {
         sendToChannel,
         eventBus: container.eventBus,
         config: container.config.security.agentToAgent,
-        // Phase 216 HIGH-2 (ONCE-01/02): the announce() send is routed through the
+        // The announce() send is routed through the
         // SAME three-state exactly-once ledger as message.send when the durable
         // store + a resolvable rootRunId are wired — a restart-driven re-announce of
         // an already-committed announcement is then a no-op. Absent ⇒ pass-through.
@@ -193,16 +193,16 @@ export function setupCrossSession(deps) {
         maxEntries: 100,
         eventBus: container.eventBus,
         logger: deps.logger?.child({ submodule: "dead-letter-queue" }),
-        // Phase 216 HIGH-2 (ONCE-03/04): the SAME ledger instance — drain consults it
+        // The SAME ledger instance — drain consults it
         // BEFORE re-delivering, so a committed announcement is SKIPPED across a restart
         // (the in-memory deliveredKeys set rebuilds empty on boot; the durable ledger
-        // is the authoritative no-double-notify signal). Absent ⇒ legacy at-least-once.
+        // is the authoritative no-double-notify signal). Absent ⇒ at-least-once delivery.
         ...(deps.outwardLedger ? { outwardLedger: deps.outwardLedger } : {}),
     });
-    // WR-02/WR-03: ONE bounded delivered-key store shared across every
+    // ONE bounded delivered-key store shared across every
     // completion-delivery surface — the batcher success path, the no-batcher
     // success branches in deliverAnnouncement, the failure path
-    // (deliverFailureNotification), and DLQ recovery (WR-01). A single instance is
+    // (deliverFailureNotification), and DLQ recovery. A single instance is
     // what makes cross-path dedup hold whether or not the batcher is on the path;
     // it is bounded (FIFO) so it never leaks for the daemon lifetime.
     const deliveryDedup = createDeliveryDedup();
@@ -213,7 +213,7 @@ export function setupCrossSession(deps) {
         logger: deps.logger?.child({ submodule: "announcement-batcher" }),
         deadLetterQueue,
         deliveryDedup,
-        // DELIVERY-02: inject the transient/permanent classifier + backoff so the
+        // Inject the transient/permanent classifier + backoff so the
         // batcher self-heals transient fallback failures (retry-with-backoff) and
         // fast-paths permanent ones to the DLQ. computeRetryBackoff is an
         // intra-package import (daemon owns it); classifyErrorContext comes from
@@ -255,11 +255,11 @@ export function setupCrossSession(deps) {
         enabled: subagentCtxConfigForCondenser?.narrativeCasting ?? true,
         tagPrefix: subagentCtxConfigForCondenser?.resultTagPrefix ?? "Subagent Result",
     });
-    // Phase 218 (SUMREF-02): the full-output ResultRef store. The runner stays
+    // The full-output ResultRef store. The runner stays
     // @comis/skills-free (DI) — the daemon owns the store + the child-workspace
     // target selection. The callback resolves the CHILD's OWN jailed workspace
     // from ctx.agentId (mirroring setup-cross-session-graph.ts:358-361), NEVER the
-    // lead's (T-218-08); createResultRefStore is additionally safePath-confined to
+    // lead's; createResultRefStore is additionally safePath-confined to
     // that root, so a traversal returns a MaterializeError the runner degrades on.
     // The store's 3-way union (ResultRef | MaterializeError | undefined) is returned
     // UNCHANGED — the runner's dep contract IS that union, so no mapping is forced.
@@ -297,7 +297,7 @@ export function setupCrossSession(deps) {
         announceToParent,
         eventBus: container.eventBus,
         config: container.config.security.agentToAgent,
-        // Sandbox no-downgrade posture resolver (SANDBOX-02). The runner is a
+        // Sandbox no-downgrade posture resolver. The runner is a
         // @comis/agent leaf with no full-config import, so it CANNOT reach
         // container.config.agents — we inject a closure that resolves each agent's
         // posture from its per-agent skills config. The two-arg form mirrors the
@@ -323,21 +323,21 @@ export function setupCrossSession(deps) {
         condenserModel: condenserApiKey ? { id: condensationResolution.modelId, provider: condensationResolution.provider } : undefined,
         condenserApiKey: condenserApiKey || undefined,
         narrativeCaster,
-        // SUMREF-02: the full-output ResultRef materialize, targeting the CHILD's
+        // The full-output ResultRef materialize, targeting the CHILD's
         // own jailed workspace (resolved from ctx.agentId), returning the store's
-        // 3-way union unchanged. Absent of a wired store IS the no-op (no BC shim).
+        // 3-way union unchanged. An absent wired store IS the no-op (no shim layer).
         materializeFullOutput,
         lifecycleHooks,
         deadLetterQueue,
         deliveryDedup,
         clock: deps.clock,
         timers: deps.timers,
-        // Phase 213 CEIL-01: the tree-wide spawn ceiling (bound to
+        // The tree-wide spawn ceiling (bound to
         // boundedAutonomy.tryAcquireSpawn by the daemon). Inert when absent.
         ...(deps.checkSpawnCeiling ? { checkSpawnCeiling: deps.checkSpawnCeiling } : {}),
-        // Phase 213 CR-02: the symmetric release (boundedAutonomy.releaseSpawn).
+        // The symmetric release (boundedAutonomy.releaseSpawn).
         ...(deps.releaseSpawnCeiling ? { releaseSpawnCeiling: deps.releaseSpawnCeiling } : {}),
-        // Phase 216 DUR-01/HB-01: the durable checkpoint store + thresholds + facts
+        // The durable checkpoint store + thresholds + facts
         // resolver (the runner writes a per-root checkpoint + heartbeat). Inert when
         // absent (the byte-identical default; the daemon wires these only when on).
         ...(deps.durableRuns ? { durableRuns: deps.durableRuns } : {}),

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/worktree-spawn-run.d.ts

@@ -5,7 +5,7 @@ import type { WorktreeRegistry } from "../setup-worktree-sweep.js";
  * Resolve the worktree dir for a run, CONFINED under the child's jailed workspace
  * (`<workspaceDir>/.worktrees/wt-<runId>`). The runId is validated (no separators /
  * `..` / null) AND `safePath` rejects any resolved path that escapes the workspace
- * — a worktree can never escape the jail (T-219-11). Throws on either guard (fail
+ * — a worktree can never escape the jail. Throws on either guard (fail
  * LOUD, never a silent escape).
  */
 export declare function resolveWorktreeDir(workspaceDir: string, runId: string): string;
@@ -13,7 +13,7 @@ export declare function resolveWorktreeDir(workspaceDir: string, runId: string):
 export interface PrepareWorktreeDeps {
     /** The lifecycle GitExec (the daemon binds the real execFile wrapper; tests inject a fake). */
     gitExec: GitExec;
-    /** The shared registry the boot/periodic sweep reads (WT-02). */
+    /** The shared registry the boot/periodic sweep reads. */
     registry: WorktreeRegistry;
     /** The child's jailed workspace dir — the worktree is confined under it. */
     workspaceDir: string;

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/worktree-spawn-run.js

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: Apache-2.0
 // @allow-throw: the runId path-traversal guard (assertSafeRunId) throws a
 // PathTraversalError so a worktree dir can NEVER escape the agent's jailed
-// workspace (T-219-11) — a security assertion that MUST fail LOUD, not degrade.
+// workspace — a security assertion that MUST fail LOUD, not degrade.
 // createWorktree (the lifecycle, @comis/skills/tools) also throws WorktreeGitError
 // on a git failure; both surface at the executeSubAgent boundary which fails the
 // spawn rather than silently running a non-worktree / escaped-path child.
 /**
- * `worktree-spawn-run` — the WT-01 create/run/clean seam for executeSubAgent.
+ * `worktree-spawn-run` — the create/run/clean seam for executeSubAgent.
  *
  * When a `spawn --worktree` child runs (its session metadata carries
  * `worktree:true`), executeSubAgent runs it in an ISOLATED git worktree instead
@@ -14,10 +14,10 @@
  * keeps executeSubAgent itself small (the 800-line file-size cap):
  *
  *   1. {@link resolveWorktreeDir} — the worktree dir, CONFINED under the child's
- *      jailed workspace via `safePath` (T-219-11 — a worktree NEVER escapes the
+ *      jailed workspace via `safePath` (a worktree NEVER escapes the
  *      jail; the child stays attenuated + jailed, just on its own working tree).
  *   2. {@link prepareWorktree}    — create the worktree (the lifecycle's
- *      createWorktree over the injected GitExec), register it (WT-02 orphan
+ *      createWorktree over the injected GitExec), register it (orphan
  *      tracking), and return `{ dir, cleanup }`. `cleanup()` runs the lifecycle's
  *      PRECISE cleanIfUnchanged: a pristine worktree is removed + dropped from the
  *      registry; a dirty/ahead one is PRESERVED (the entry is marked completed and
@@ -37,7 +37,7 @@ const WORKTREES_SUBDIR = ".worktrees";
  * A runId is daemon-minted (`root-…` / a randomUUID-derived `sub-agent-<id>`), so
  * it is never attacker-controlled in production — but a path separator / traversal
  * token in it would let the worktree dir drift, so we reject it explicitly
- * (defense in depth, T-219-11). The `wt-<runId>` prefix already anchors the first
+ * (defense in depth). The `wt-<runId>` prefix already anchors the first
  * path component (so `safePath`'s prefix check stays inside the workspace), but a
  * separator inside the runId could still split it into a deeper dir — fail LOUD.
  */
@@ -50,7 +50,7 @@ function assertSafeRunId(runId) {
  * Resolve the worktree dir for a run, CONFINED under the child's jailed workspace
  * (`<workspaceDir>/.worktrees/wt-<runId>`). The runId is validated (no separators /
  * `..` / null) AND `safePath` rejects any resolved path that escapes the workspace
- * — a worktree can never escape the jail (T-219-11). Throws on either guard (fail
+ * — a worktree can never escape the jail. Throws on either guard (fail
  * LOUD, never a silent escape).
  */
 export function resolveWorktreeDir(workspaceDir, runId) {

package/node_modules/@comis/daemon/dist/wiring/setup-delivery.d.ts

@@ -31,7 +31,7 @@ export declare function setupDeliveryQueue(deps: {
     logger: ComisLogger;
     channelAdapters: Map<string, DeliveryAdapter>;
     /**
-     * REACT-02 (Verified Learning, Phase 199): OPTIONAL outbound-message → trajectory
+     * Verified Learning: OPTIONAL outbound-message → trajectory
      * capture, threaded into every drain pass. `undefined` when learning-outcome is
      * disabled for all agents → the drain does ZERO extra work (byte-identity).
      */
@@ -51,7 +51,7 @@ export declare function drainDeliveryQueue(deps: {
     drainBudgetMs: number;
     defaultMaxAttempts: number;
     /**
-     * REACT-02 (Verified Learning, Phase 199): capture (platform messageId →
+     * Verified Learning: capture (platform messageId →
      * trajectory scope) for an agent-authored OUTBOUND message so an inbound
      * reaction can resolve its trajectory. OPTIONAL — `undefined` when learning-
      * outcome is disabled for every agent (the byte-identity default → the drain

package/node_modules/@comis/daemon/dist/wiring/setup-delivery.js

@@ -40,8 +40,8 @@ export async function setupDeliveryQueue(deps) {
     // Single-tick gate: in-flight Promise prevents overlapping ticks.
     let draining = null;
     // Transition-gate state for the empty-drain log.
-    // Previously, every recurring tick on an empty queue emitted
-    // "Delivery queue drain: no pending entries" — dominated debug logs at
+    // Without the gate, every recurring tick on an empty queue would emit
+    // "Delivery queue drain: no pending entries" — dominating debug logs at
     // one line per drainIntervalMs (5–10s). The gate logs ONCE when the
     // queue transitions to empty; subsequent empty ticks are silent. Start
     // `true` so the first empty-after-startup tick still produces a line.
@@ -141,9 +141,9 @@ export async function drainDeliveryQueue(deps) {
     }
     const entries = pendingResult.value;
     if (entries.length === 0) {
-        // Fix B (log-review): the noisy "no pending entries" log moved up to
-        // runOneDrainPass as a transition-gated emit. Direct callers (the
-        // row-selection-invariant unit test) just observe the return value.
+        // The noisy "no pending entries" log lives in runOneDrainPass as a
+        // transition-gated emit. Direct callers (the row-selection-invariant
+        // unit test) just observe the return value.
         return { hadEntries: false };
     }
     let attempted = 0;
@@ -173,7 +173,7 @@ export async function drainDeliveryQueue(deps) {
         if (sendResult.ok) {
             await deliveryQueue.ack(entry.id, sendResult.value);
             delivered++;
-            // REACT-02 (CR-01): capture (platform messageId → trajectory scope) for
+            // Capture (platform messageId → trajectory scope) for
             // inbound-reaction resolution. Agent-authored OUTBOUND only (the delivery
             // queue is outbound); entry.traceId === trajectoryId AND options.agentId are
             // both set from the request ALS at enqueue (delivery-service.ts). The
@@ -181,17 +181,17 @@ export async function drainDeliveryQueue(deps) {
             // reaction observe()s under — it must be the REAL agent, NEVER the tenantId.
             // A null traceId (no trajectory) OR an absent agentId (a pre-executor /
             // non-agent send) is a FAIL-CLOSED skip: mis-attributing a reaction to the
-            // tenantId would corrupt cross-agent isolation (T-198-16), so we record
+            // tenantId would corrupt cross-agent isolation, so we record
             // nothing rather than fall back. The callback is undefined when
             // learning-outcome is disabled for all agents → zero extra work (byte-identity).
             const recordAgentId = typeof options.agentId === "string" ? options.agentId : undefined;
             if (entry.traceId !== null && recordAgentId !== undefined && recordOutboundMessage !== undefined) {
-                // FLAG-2: carry the conversation participant (the inbound sender) persisted
+                // Carry the conversation participant (the inbound sender) persisted
                 // into optionsJson at enqueue (delivery-service.ts) so a reaction resolved
                 // via this drain path is participant-aware — an unmapped group bystander
                 // resolves to "external" (inert) and cannot spoof reaction-learning. Absent
-                // on legacy/pre-threading rows → undefined → the trust resolution fails safe
-                // to the prior defaultTrustLevel-for-unmapped behavior.
+                // on rows whose enqueue did not thread a participant → undefined → the trust
+                // resolution fails safe to the defaultTrustLevel-for-unmapped behavior.
                 const recordParticipantId = typeof options.participantId === "string" ? options.participantId : undefined;
                 recordOutboundMessage(sendResult.value, {
                     traceId: entry.traceId,

package/node_modules/@comis/daemon/dist/wiring/setup-dialectic.d.ts

@@ -13,10 +13,10 @@
  * to abstain at call time; the cron no-key discipline), builds `createDialecticSeam`, and a
  * `buildDialecticRecall(agentId)` factory that constructs the FULL `createMemoryRecall` (NOT
  * `memoryApi.search`) over the daemon's store set + the per-agent RagConfig — reconstructing
- * the A1 deps + config exactly as prompt-assembly's executor read path does, INCLUDING the
- * `forget` FadeMem decay gate the main path passes (the main↔dialectic recall-parity fix;
- * default-OFF ⇒ byte-identical recall). Recall scoring is the fixed `rag.scoring` alphas — the
- * tuned-alpha bandit overlay was deleted in Phase 224 (RECALL-02/03).
+ * the recall deps + config exactly as prompt-assembly's executor read path does, INCLUDING the
+ * `forget` FadeMem decay gate the main path passes (main↔dialectic recall parity;
+ * default-OFF ⇒ byte-identical recall). Recall scoring is the fixed `rag.scoring` alphas —
+ * there is no tuned-alpha bandit overlay.
  *
  * The agent receives the store port TYPEs only (the agent↛memory build cut is untouched —
  * every store dep is a @comis/core port type; the concrete adapters are daemon-constructed
@@ -43,7 +43,7 @@ export interface DialecticStoreSet {
     /** Pinned-memory store. The SAME `SqliteMemoryAdapter` already in `memoryPort`
      *  implements both `MemoryPort` AND `MemoryPinnedStore`. Supplied here as the
      *  segregated `MemoryPinnedStore` port so the dialectic recall's Step-0 pinned-first
-     *  lane can fire (mirrors the main path R6 fix). Absent OR `rag.pinned.enabled=false` ⇒
+     *  lane can fire (parity with the main recall path). Absent OR `rag.pinned.enabled=false` ⇒
      *  no query runs (default-OFF byte-identity). A @comis/core port TYPE (the agent↛memory cut). */
     pinnedStore?: MemoryPinnedStore;
 }
@@ -60,27 +60,26 @@ export interface DialecticWiringDeps {
      *  model/operationModels + rag). The wiring enables when ANY agent opts in and resolves the
      *  seam/recall/maxRecall per invoking agent from THIS map. */
     agentsConfig: Record<string, PerAgentConfig>;
-    /** The master cost-feature kill switch (`memory.enabled`, opt-out posture; renamed from
-     *  costFeatures.enabled in Phase 226).
+    /** The master cost-feature kill switch (`memory.enabled`, opt-out posture).
      *  The dialectic (`memory_ask`) is the ONE query-time LLM tool in the memory stack — a
      *  cost-bearing feature — so when this is `false` the wiring returns the dead `{}` (no seam,
      *  no recall builder, no maxRecall ⇒ the handler abstains, the tool is never exposed) EVEN
      *  for an agent whose own `dialectic.enabled` is true. The cost switch wins over the per-agent
-     *  opt-in. Default `true` (the schema default) ⇒ byte-identical to the pre-switch behavior. */
+     *  opt-in. Default `true` (the schema default) ⇒ only the per-agent opt-in gates the wiring. */
     costFeaturesEnabled: boolean;
     /** Resolves the provider apiKey VALUE by NAME (never logged). */
     secretManager: {
         get: (name: string) => string | undefined;
     };
-    /** FLAG-3: per-agent OAuth-credential resolver factory. Returns a per-call `getApiKey` for the
+    /** Per-agent OAuth-credential resolver factory. Returns a per-call `getApiKey` for the
      *  resolved cheap provider when that agent has an OAuth manager (openai-codex), else `undefined`.
      *  Built in `dialecticWiringDepsFromBoot` from the boot `oauthManagers` map (the SAME the Codex
      *  image/video/vision bundles use). Without it, an OAuth provider resolves no API key and the seam
      *  abstains on every `memory.ask`. */
     getResolveCredential?: (agentId: string, provider: string) => (() => Promise<string>) | undefined;
-    /** Provider entries (for apiKeyName lookup + the R6 capabilities override) —
+    /** Provider entries (for apiKeyName lookup + the capabilities override) —
      *  `container.config.providers?.entries`. `capabilities` supplies the optional
-     *  operator capabilityClass override the dialectic seam's R6 routing reads (CR-01). */
+     *  operator capabilityClass override the dialectic seam's capability routing reads. */
     providers: Record<string, (JudgeProviderEntry & {
         capabilities?: ProviderCapabilities;
     }) | undefined>;
@@ -115,18 +114,18 @@ export interface DialecticWiring {
  *  structurally (the relevant `c` fields only) so daemon.ts can map the boot context to the
  *  wiring deps in ONE expression — keeping daemon.ts at zero net new wiring lines (it is at
  *  the 3000-line cap; all the mapping lives here). The concrete adapters are the SAME ones
- *  daemon.ts threads into createPiExecutor (A1: daemon-constructed in setup-memory). */
+ *  daemon.ts threads into createPiExecutor (daemon-constructed in setup-memory). */
 export interface DialecticBootSlice {
     defaultAgentId: string;
     agentsConfig: Record<string, PerAgentConfig>;
-    /** FLAG-3: per-agent OAuth managers (the boot `oauthManagers` map on PostChannelsBootContext —
+    /** Per-agent OAuth managers (the boot `oauthManagers` map on PostChannelsBootContext —
      *  the SAME one threaded to the Codex image/video/vision bundles). Read to build the dialectic
      *  credential resolver so OAuth providers (openai-codex) don't abstain on a missing API key. */
     oauthManagers?: Map<string, import("@comis/core").OAuthTokenManager>;
-    /** FLAG-3 (approach A): per-agent pi AuthStorage (piAuthStorage) — the runtime-override target.
+    /** Per-agent pi AuthStorage (piAuthStorage) — the runtime-override target.
      *  `resolveProviderApiKey` calls `authStorage.setRuntimeApiKey(token)` so the dialectic's pi model
      *  picks up the OAuth bearer (the PROVEN main-agent path; passing the token as `apiKey` does NOT work
-     *  for openai-codex — empirically verified live 2026-06-22). Threaded beside `oauthManagers`. */
+     *  for openai-codex — verified against a live daemon). Threaded beside `oauthManagers`. */
     authStorages?: Map<string, AuthStorage>;
     container: {
         secretManager: {
@@ -140,10 +139,10 @@ export interface DialecticBootSlice {
             };
             /** The configured tenant (the daemon-wide `container.config.tenantId`). */
             tenantId: string;
-            /** The master cost-feature kill switch (`memory.enabled`, renamed from costFeatures.enabled in
-             *  Phase 226). Threaded into the dialectic wiring so the query-time `memory_ask` tool is
-             *  force-disabled when the operator turns all cost features off. The REAL `MemoryConfig` slice
-             *  (IN-01): tsc enforces the costFeatures→enabled rename here exactly as on the other H-1
+            /** The master cost-feature kill switch (`memory.enabled`).
+             *  Threaded into the dialectic wiring so the query-time `memory_ask` tool is
+             *  force-disabled when the operator turns all cost features off. The REAL `MemoryConfig`
+             *  slice: tsc enforces the schema's field name here exactly as on the other
              *  gate readers — not a loose local `{ enabled: boolean }`. */
             memory: Pick<MemoryConfig, "enabled">;
         };