comisai 1.0.44 → 1.0.46

package/node_modules/@comis/daemon/dist/export-session-bundle.d.ts

@@ -0,0 +1,47 @@
+/**
+ * `exportSessionBundleFromKey` — the testable unit behind the
+ * `/export-trajectory` slash command's bundle export.
+ *
+ * A formatted sessionKey is resolved to its REAL session `.jsonl` via the
+ * pointer discipline (`resolveSessionFilePath`) BEFORE the exporter is called.
+ * The exporter CONSUMES `sessionFile` (it stats + SDK-opens it), so a
+ * hand-built flat `<dataDir>/sessions/<id>.jsonl` path — which never exists on
+ * disk — makes the export fail `session-file-not-readable` for every real
+ * channel session. Resolving through the pointer is the ONE authoritative way
+ * to find the file; a genuine miss returns an honest error rather than statting
+ * a fabricated path.
+ *
+ * @module
+ */
+import { type Result } from "@comis/shared";
+import { exportTrajectoryBundle } from "@comis/observability";
+/** Dependencies for `exportSessionBundleFromKey`. */
+export interface ExportSessionBundleDeps {
+    /** The `~/.comis` root the session tree lives under. */
+    readonly dataDir: string;
+    /** The workspace dir the exporter derives `trace-exports/` from. */
+    readonly workspaceDir: string;
+    /** A formatted SessionKey (`tenant:user:channel[:peer:...]`). */
+    readonly sessionId: string;
+    /**
+     * Injectable exporter seam (defaults to the real `exportTrajectoryBundle`)
+     * so a unit test can drive the resolution without writing a bundle.
+     */
+    readonly exportTrace?: typeof exportTrajectoryBundle;
+}
+/** Failure shape: the resolver miss OR a mapped exporter error kind. */
+export interface ExportSessionBundleError {
+    readonly kind: string;
+    readonly reason: string;
+}
+/**
+ * Resolve the sessionKey → real `.jsonl` via the pointer discipline, then export
+ * the trajectory bundle into `<workspaceDir>/trace-exports/`.
+ *
+ * Returns `err({ kind: "session-not-resolvable" })` when no session artifacts
+ * exist for the key (the caller can surface that instead of a stat failure on a
+ * fabricated path), or the mapped exporter error kind on an export failure.
+ */
+export declare function exportSessionBundleFromKey(deps: ExportSessionBundleDeps): Promise<Result<{
+    bundlePath: string;
+}, ExportSessionBundleError>>;

package/node_modules/@comis/daemon/dist/export-session-bundle.js

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * `exportSessionBundleFromKey` — the testable unit behind the
+ * `/export-trajectory` slash command's bundle export.
+ *
+ * A formatted sessionKey is resolved to its REAL session `.jsonl` via the
+ * pointer discipline (`resolveSessionFilePath`) BEFORE the exporter is called.
+ * The exporter CONSUMES `sessionFile` (it stats + SDK-opens it), so a
+ * hand-built flat `<dataDir>/sessions/<id>.jsonl` path — which never exists on
+ * disk — makes the export fail `session-file-not-readable` for every real
+ * channel session. Resolving through the pointer is the ONE authoritative way
+ * to find the file; a genuine miss returns an honest error rather than statting
+ * a fabricated path.
+ *
+ * @module
+ */
+import { ok, err } from "@comis/shared";
+import { exportTrajectoryBundle } from "@comis/observability";
+import { resolveSessionFilePath } from "./api/obs-handlers/obs-explain-readers.js";
+/** Render an exporter error variant into a diagnosable reason string. */
+function describeExportError(e) {
+    switch (e.kind) {
+        case "session-file-too-large":
+            return `session file too large (${e.bytes} bytes)`;
+        case "session-file-not-readable":
+            return `session file not readable: ${e.reason}`;
+        case "bundle-dir-create-failed":
+            return `bundle dir create failed: ${e.reason}`;
+        case "bundle-file-write-failed":
+            return `bundle file write failed (${e.file}): ${e.reason}`;
+    }
+}
+/**
+ * Resolve the sessionKey → real `.jsonl` via the pointer discipline, then export
+ * the trajectory bundle into `<workspaceDir>/trace-exports/`.
+ *
+ * Returns `err({ kind: "session-not-resolvable" })` when no session artifacts
+ * exist for the key (the caller can surface that instead of a stat failure on a
+ * fabricated path), or the mapped exporter error kind on an export failure.
+ */
+export async function exportSessionBundleFromKey(deps) {
+    const sessionFile = resolveSessionFilePath(deps.dataDir, deps.sessionId);
+    if (sessionFile === undefined) {
+        return err({
+            kind: "session-not-resolvable",
+            reason: "no session artifacts found on disk for the requested session",
+        });
+    }
+    const exportTrace = deps.exportTrace ?? exportTrajectoryBundle;
+    const result = await exportTrace({
+        sessionId: deps.sessionId,
+        sessionKey: deps.sessionId,
+        sessionFile,
+        workspaceDir: deps.workspaceDir,
+        traceId: deps.sessionId, // best-effort; the exporter uses it for naming only
+        agentId: "unknown", // best-effort; the real agentId lives in the session header
+    });
+    if (!result.ok) {
+        return err({ kind: result.error.kind, reason: describeExportError(result.error) });
+    }
+    return ok({ bundlePath: result.value.bundleDir });
+}

package/node_modules/@comis/daemon/dist/graph/graph-capability-defaults.d.ts

@@ -1,15 +1,15 @@
 /**
- * F3: capability-gated graph concurrency defaults.
+ * Capability-gated graph concurrency defaults.
  *
- * Background: the 2026-06-08 live re-verification observed 8 concurrent
- * qwen3.6:35b inferences saturate a single Ollama GPU — 4/8 sub-agents died
- * on 180-second prompt timeouts and 0/11 graph nodes completed. The DAG
+ * Background: 8 concurrent qwen3.6:35b inferences were observed live to
+ * saturate a single Ollama GPU — 4/8 sub-agents died on 180-second prompt
+ * timeouts and 0/11 graph nodes completed. The DAG
  * decomposition was correct; the failure was concurrency × timeout × hardware
  * ceiling. Reducing the small/nano default concurrency to 2 prevents saturation.
  *
  * Tier mapping:
  * - small / nano → maxConcurrency = 2  (local inference hardware ceiling)
- * - frontier / mid → maxConcurrency = 4  (byte-identical to pre-F3)
+ * - frontier / mid → maxConcurrency = 4  (the hosted-provider default)
  *
  * Operators can always raise the ceiling via the existing
  * `security.agentToAgent.graphMaxConcurrency` config key — the ?? chain in
@@ -31,7 +31,7 @@ export interface GraphConcurrencyDefaults {
  * Resolve capability-gated graph concurrency defaults for a model.
  *
  * Returns `maxConcurrency=2` for small/nano models (local inference hardware ceiling)
- * and `maxConcurrency=4` for frontier/mid (unchanged from pre-F3).
+ * and `maxConcurrency=4` for frontier/mid (the hosted-provider default).
  *
  * @param model - The agent's primary model (`{ provider, modelId }`).
  * @param capabilityOverride - Optional operator override for the capability class

package/node_modules/@comis/daemon/dist/graph/graph-capability-defaults.js

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * F3: capability-gated graph concurrency defaults.
+ * Capability-gated graph concurrency defaults.
  *
- * Background: the 2026-06-08 live re-verification observed 8 concurrent
- * qwen3.6:35b inferences saturate a single Ollama GPU — 4/8 sub-agents died
- * on 180-second prompt timeouts and 0/11 graph nodes completed. The DAG
+ * Background: 8 concurrent qwen3.6:35b inferences were observed live to
+ * saturate a single Ollama GPU — 4/8 sub-agents died on 180-second prompt
+ * timeouts and 0/11 graph nodes completed. The DAG
  * decomposition was correct; the failure was concurrency × timeout × hardware
  * ceiling. Reducing the small/nano default concurrency to 2 prevents saturation.
  *
  * Tier mapping:
  * - small / nano → maxConcurrency = 2  (local inference hardware ceiling)
- * - frontier / mid → maxConcurrency = 4  (byte-identical to pre-F3)
+ * - frontier / mid → maxConcurrency = 4  (the hosted-provider default)
  *
  * Operators can always raise the ceiling via the existing
  * `security.agentToAgent.graphMaxConcurrency` config key — the ?? chain in
@@ -23,15 +23,15 @@
  * @module
  */
 import { resolveModelProfile } from "@comis/agent";
-/** F3: small/nano local inference hardware saturation threshold (measured 2026-06-08). */
+/** Small/nano local inference hardware saturation threshold (measured live). */
 const SMALL_NANO_GRAPH_MAX_CONCURRENCY = 2;
-/** F3: frontier/mid concurrency — byte-identical to the pre-F3 hardcoded `4`. */
+/** Frontier/mid concurrency — the hosted-provider default. */
 const DEFAULT_GRAPH_MAX_CONCURRENCY = 4;
 /**
  * Resolve capability-gated graph concurrency defaults for a model.
  *
  * Returns `maxConcurrency=2` for small/nano models (local inference hardware ceiling)
- * and `maxConcurrency=4` for frontier/mid (unchanged from pre-F3).
+ * and `maxConcurrency=4` for frontier/mid (the hosted-provider default).
  *
  * @param model - The agent's primary model (`{ provider, modelId }`).
  * @param capabilityOverride - Optional operator override for the capability class

package/node_modules/@comis/daemon/dist/graph/graph-completion.d.ts

@@ -22,11 +22,11 @@ export interface GraphAnnouncement {
  * node lists its upstream parents in `dependsOn`, so a node's children are the
  * nodes that name it in their `dependsOn`). A child's cost therefore rolls into
  * its parent's subtree total; the recursion composes
- * (`rollup(p) === own(p) + Σ rollup(child)`), the Hermes structure but over
- * CORRECTED dollars rather than estimates (the E5 beat).
+ * (`rollup(p) === own(p) + Σ rollup(child)`) over CORRECTED dollars from
+ * provider usage reports, never estimates.
  *
- * PURE + deterministic (no IO) — unit-testable in isolation and reusable by the
- * COST-02 read RPC. (tenant,agent)-scoped: reads ONLY the per-graph `gs` (which
+ * PURE + deterministic (no IO) — unit-testable in isolation and reusable by
+ * read-side cost reporting. (tenant,agent)-scoped: reads ONLY the per-graph `gs` (which
  * IS that scope), so two graphs in different scopes never cross-contaminate.
  * A cycle-safe visited set guards against malformed graphs (sorted/validated
  * graphs are acyclic, but the rollup must never infinite-loop).

package/node_modules/@comis/daemon/dist/graph/graph-completion.js

@@ -13,7 +13,7 @@ import { writeRegularFile } from "@comis/observability";
 import { ANNOUNCE_PARENT_TIMEOUT_MS } from "@comis/agent";
 import { clearAllTimers } from "./graph-cleanup.js";
 // ---------------------------------------------------------------------------
-// COST-02: per-subagent corrected-$ subtree rollup
+// Per-subagent corrected-$ subtree rollup
 // ---------------------------------------------------------------------------
 /**
  * Sum a node's own corrected-$ cost plus the cost of every descendant (the
@@ -25,11 +25,11 @@ import { clearAllTimers } from "./graph-cleanup.js";
  * node lists its upstream parents in `dependsOn`, so a node's children are the
  * nodes that name it in their `dependsOn`). A child's cost therefore rolls into
  * its parent's subtree total; the recursion composes
- * (`rollup(p) === own(p) + Σ rollup(child)`), the Hermes structure but over
- * CORRECTED dollars rather than estimates (the E5 beat).
+ * (`rollup(p) === own(p) + Σ rollup(child)`) over CORRECTED dollars from
+ * provider usage reports, never estimates.
  *
- * PURE + deterministic (no IO) — unit-testable in isolation and reusable by the
- * COST-02 read RPC. (tenant,agent)-scoped: reads ONLY the per-graph `gs` (which
+ * PURE + deterministic (no IO) — unit-testable in isolation and reusable by
+ * read-side cost reporting. (tenant,agent)-scoped: reads ONLY the per-graph `gs` (which
  * IS that scope), so two graphs in different scopes never cross-contaminate.
  * A cycle-safe visited set guards against malformed graphs (sorted/validated
  * graphs are acyclic, but the rollup must never infinite-loop).
@@ -96,7 +96,7 @@ export function handleGraphCompletion(state, deps, gs) {
         else if (nState.status === "skipped")
             nodesSkipped++;
     }
-    // 3.3: Compute cache rollup once -- shared by event emission and completion log
+    // Compute cache rollup once -- shared by event emission and completion log
     let graphCacheReadTokens = 0;
     let graphCacheWriteTokens = 0;
     const nodeEffectiveness = {};
@@ -115,16 +115,16 @@ export function handleGraphCompletion(state, deps, gs) {
     const cacheRollupFields = gs.nodeCacheData.size > 0
         ? { graphCacheReadTokens, graphCacheWriteTokens, graphCacheEffectiveness, nodeEffectiveness }
         : {};
-    // IN-01: surface the per-node token-spend breakdown (the production reader of
+    // Surface the per-node token-spend breakdown (the production reader of
     // gs.nodeTokenSpend, otherwise a dead write). Present only when at least one
-    // node recorded spend — byte-identical to today's payload otherwise.
+    // node recorded spend — the payload is unchanged otherwise.
     const nodeTokenSpendFields = gs.nodeTokenSpend.size > 0
         ? { nodeTokenSpend: Object.fromEntries(gs.nodeTokenSpend) }
         : {};
-    // COST-02: surface the per-node CUMULATIVE corrected-$ cost ledger (the
+    // Surface the per-node CUMULATIVE corrected-$ cost ledger (the
     // production reader of gs.nodeCost). Content-free (nodeId → number); present
-    // only when non-empty — byte-identical otherwise (the nodeTokenSpend mold).
-    // The subtree rollups derive from this via computeSubtreeCost (below).
+    // only when non-empty — the payload is unchanged otherwise (same shape rule
+    // as nodeTokenSpend). The subtree rollups derive from this via computeSubtreeCost.
     const nodeCostFields = gs.nodeCost.size > 0
         ? { nodeCost: Object.fromEntries(gs.nodeCost) }
         : {};
@@ -138,11 +138,11 @@ export function handleGraphCompletion(state, deps, gs) {
         nodesSkipped,
         ...(gs.cancelReason !== undefined && { cancelReason: gs.cancelReason }),
         timestamp: systemNowMs(),
-        // 3.3: Graph-level cache aggregation
+        // Graph-level cache aggregation
         ...cacheRollupFields,
-        // IN-01: per-node token-spend breakdown
+        // Per-node token-spend breakdown
         ...nodeTokenSpendFields,
-        // COST-02: per-node cumulative corrected-$ cost ledger
+        // Per-node cumulative corrected-$ cost ledger
         ...nodeCostFields,
     });
     // 2c. Write _run-metadata.json to disk
@@ -213,7 +213,7 @@ export function handleGraphCompletion(state, deps, gs) {
         nodesFailed,
         totalCostUsd: gs.cumulativeCost > 0 ? gs.cumulativeCost : undefined,
         totalTokens: gs.cumulativeTokens > 0 ? gs.cumulativeTokens : undefined,
-        // 3.3: Graph-level cache aggregation (computed above for event + log)
+        // Graph-level cache aggregation (computed above for event + log)
         ...cacheRollupFields,
     }, "Graph execution complete");
 }
@@ -409,14 +409,15 @@ export function handleBudgetExceeded(state, deps, gs, reason) {
         gs.stateMachine.cancel();
     }
     handleGraphCompletion(state, deps, gs);
-    // SPEND-04: the graph cumulative-budget seam (this function) interoperates with
-    // the daemon-wide spend kill-switch (Phase 177) via the OPEN `reason` param — a
+    // The graph cumulative-budget seam (this function) interoperates with the
+    // daemon-wide spend kill-switch via the OPEN `reason` param — a
     // spend-ceiling breach routes through HERE with `"spend_exceeded"`, not a parallel
     // graph kill-path. The two ceilings are DISTINCT: `graph.budget.maxTokens/maxCost`
     // is the per-graph cumulative cap (reasons `"tokens"`/`"cost"`); the spend ceiling
     // is the per-(agent|tenant|global) dollar kill-switch (`observability.spend.*`).
     // Name the right knob so an operator drilling the WARN tunes the ceiling that
-    // actually fired. Counts-only payload — never a `$` amount as a body (§2.7).
+    // actually fired. Counts-only payload — dollar amounts ride structured fields,
+    // never the log-message body.
     const hint = reason === "spend_exceeded"
         ? "A spend ceiling (observability.spend.{perAgentUsd,perTenantUsd,daemonGlobalUsd}) was exceeded during graph execution; raise it or set observability.spend.action"
         : "Graph budget is configurable via graph.budget.maxTokens/maxCost";

package/node_modules/@comis/daemon/dist/graph/graph-coordinator-state.d.ts

@@ -28,13 +28,13 @@ export interface GraphRunState {
     runningCount: number;
     callerSessionKey?: string;
     callerAgentId?: string;
-    /** Phase 213 CR-01: the tree-stable rootRunId shared by EVERY node spawn in
+    /** The tree-stable rootRunId shared by EVERY node spawn in
      *  this graph run, resolved ONCE at submission (inherit the driving sub-agent's
      *  root, else the caller session's stable root). Threaded into each
-     *  `subAgentRunner.spawn` so the tree-wide ceiling (CEIL-01) and
+     *  `subAgentRunner.spawn` so the tree-wide ceiling and
      *  `killByRootRun` see one tree per graph run instead of a fresh root per node
-     *  (which made a `run.kill {rootRunId}` miss graph children). Undefined ⇒ no
-     *  resolver wired (the runner mints per node — pre-213 behavior). */
+     *  (which would make a `run.kill {rootRunId}` miss graph children). Undefined ⇒ no
+     *  resolver wired (the runner mints a fresh root per node). */
     rootRunId?: string;
     announceChannelType?: string;
     announceChannelId?: string;
@@ -43,7 +43,7 @@ export interface GraphRunState {
     cumulativeTokens: number;
     cumulativeCost: number;
     cancelReason?: "timeout" | "budget" | "manual";
-    /** Reply language resolved once at graph submission (DET-02), carried to node envelopes. */
+    /** Reply language resolved once at graph submission, carried to node envelopes. */
     resolvedLanguage?: string;
     /** Shared directory path for inter-node data sharing. */
     sharedDir: string;
@@ -66,10 +66,10 @@ export interface GraphRunState {
         cacheReadTokens: number;
         cacheWriteTokens: number;
     }>;
-    /** Per-node full-run token spend captured from completion events (BUDGET-03). */
+    /** Per-node full-run token spend captured from completion events. */
     nodeTokenSpend: Map<string, number>;
-    /** Per-node CUMULATIVE corrected-$ cost ledger captured from completion events
-     *  (COST-02). Accumulates event.cost (the same corrected value feeding
+    /** Per-node CUMULATIVE corrected-$ cost ledger captured from completion
+     *  events. Accumulates event.cost (the same corrected value feeding
      *  cumulativeCost) per nodeId; the subtree rollup sums a node + its
      *  descendants over this ledger. (tenant,agent)-scoped (gs IS that scope). */
     nodeCost: Map<string, number>;
@@ -138,16 +138,16 @@ export interface GraphCoordinatorDeps {
             callerAgentId?: string;
             model?: string;
             max_steps?: number;
-            /** Per-spawn token budget (BUDGET-01). The child's own per-execution cap. */
+            /** Per-spawn token budget — the child's own per-execution cap. */
             tokenBudget?: number;
             callerType?: "agent" | "graph";
             graphSharedDir?: string;
             graphTraceId?: string;
             graphId?: string;
             nodeId?: string;
-            /** Phase 213 CR-01: the graph run's tree-stable root, shared by all nodes. */
+            /** The graph run's tree-stable root, shared by all nodes. */
             rootRunId?: string;
-            /** Phase 213 REVOKE-02: the lease that authorized the graph run (cascade correlation). */
+            /** The lease that authorized the graph run (cascade correlation). */
             parentLeaseId?: string;
             /** Sorted tool name superset for graph sub-agent cache prefix sharing. */
             graphToolNames?: string[];
@@ -174,33 +174,32 @@ export interface GraphCoordinatorDeps {
             error?: string;
             sessionKey?: string;
         } | undefined;
-        /** Phase 213 CR-01: resolve a driving sub-agent's run by its session key so a
+        /** Resolve a driving sub-agent's run by its session key so a
          *  graph submitted BY a sub-agent inherits that run's tree root. Optional
-         *  (older narrowed wiring); absent ⇒ the resolver/mint fallback applies. */
+         *  (narrowed wiring may omit it); absent ⇒ the resolver/mint fallback applies. */
         getRunBySessionKey?(sessionKey: string): {
             rootRunId: string;
             parentLeaseId?: string;
         } | undefined;
     };
     /**
-     * Phase 213 CR-01: resolve the caller session's tree-stable rootRunId for a
+     * Resolve the caller session's tree-stable rootRunId for a
      * TOP-LEVEL graph submission (no driving sub-agent). Bound by the daemon to the
      * same resolver the session.spawn handler + per-root budget use. Optional —
-     * absent ⇒ each node mints its own root (pre-213 behavior, graph fan-out is
+     * absent ⇒ each node mints its own root (graph fan-out is
      * still bounded by the graph concurrency gate).
      */
     resolveRootRunId?: (sessionKey: SessionKey) => string;
     /**
-     * Phase 216 DUR-01/DUR-02 (Plan 11): the durable run-checkpoint store. When
+     * The durable run-checkpoint store. When
      * present AND the graph run has a resolved tree-stable `rootRunId`, the
      * coordinator checkpoints the per-node completion state (the
      * GraphExecutionSnapshot → `spawn_tree`) at every node transition, so a DAG
      * interrupted by a restart resumes (or is honestly orphaned) instead of
-     * vanishing. Optional — absent ⇒ no DAG durability (pre-216 behavior; the
-     * graph still runs, it just is not restart-survivable). The daemon.ts store
-     * injection into `buildGraphCoordinatorDeps` is the dedicated wiring Plan 12
-     * (NEW-2: no two same-wave plans edit daemon.ts); this plan defines the dep +
-     * the consumption logic, Plan 12 supplies the instance.
+     * vanishing. Optional — absent ⇒ no DAG durability (the
+     * graph still runs, it just is not restart-survivable). daemon.ts injects
+     * the store instance via `buildGraphCoordinatorDeps`; this module owns the
+     * dep definition and the consumption logic.
      */
     durableRuns?: DurableRunPort;
     eventBus: TypedEventBus;
@@ -214,7 +213,7 @@ export interface GraphCoordinatorDeps {
     maxResultLength?: number;
     /** Operator default per-node token budget inherit-share source (security.agentToAgent.tokenBudget).
      *  null = no operator default (per-node budgets resolve from node.tokenBudget or the graph-budget
-     *  inherit-share only). BUDGET-02/03, D3. */
+     *  inherit-share only). */
     subAgentTokenBudget?: number | null;
     graphRetentionMs?: number;
     logger?: {
@@ -278,7 +277,7 @@ export interface GraphCoordinatorDeps {
 export interface CoordinatorConfig {
     maxConcurrency: number;
     maxResultLength: number;
-    /** Operator default per-node token budget inherit-share source (BUDGET-02/03, D3).
+    /** Operator default per-node token budget inherit-share source.
      *  null = no operator default. */
     subAgentTokenBudget: number | null;
     graphRetentionMs: number;

package/node_modules/@comis/daemon/dist/graph/graph-coordinator.d.ts

@@ -40,16 +40,16 @@ export interface GraphCoordinator {
      *  Bypasses event bus for reliability during session cleanup. Idempotent. */
     notifyNodeFailed(graphId: string, nodeId: string, runId: string, error: string): void;
     /**
-     * Phase 216 DUR-01/DUR-02 (Plan 11): resume a DAG run from its durable
+     * Resume a DAG run from its durable
      * checkpoint after a daemon restart. Re-enters ONLY the nodes that were NOT
      * terminal at crash time (`incompleteNodes(record.spawnTree)`) and DRIVES them
      * to execution via the node-lifecycle path (`spawnReadyNodes` → `spawnNode`),
      * so the re-entered node's sub-agent spawn actually fires — it does not merely
      * re-mark the node ready. Completed/skipped/failed nodes are NOT re-run; a
-     * re-run node's outward sends are deduped by the ONCE ledger (Plans 05/07), so
+     * re-run node's outward sends are deduped by the ONCE ledger, so
      * node-boundary resume is exactly-once-safe without persisting intra-node
-     * state. The durable resume engine (Plan 04) routes a DAG-shaped record here;
-     * Plan 12 wires this into the engine's resume dispatch (NEW-2).
+     * state. The durable resume engine routes a DAG-shaped record here via its
+     * resume dispatch.
      */
     resumeGraph(record: DurableRunRecord): Promise<Result<void, Error>>;
 }

package/node_modules/@comis/daemon/dist/graph/graph-coordinator.js

@@ -13,7 +13,7 @@ import { ok, err } from "@comis/shared";
 import { snapshotToSpawnTree, incompleteNodes } from "./graph-durable-checkpoint.js";
 import { computeGraphToolSuperset } from "./graph-tool-superset.js";
 import { preWarmGraphCache } from "./graph-prewarm.js";
-import { getModel, completeSimple } from "@earendil-works/pi-ai";
+import { getModel, completeSimple } from "@earendil-works/pi-ai/compat";
 // Module imports
 import { globalCompletionHandler, releaseAndDrainQueue } from "./graph-concurrency.js";
 import { spawnNode as spawnNodeFn, spawnReadyNodes as spawnReadyNodesFn, startDriverNode as startDriverNodeFn, markNodeFailed as markNodeFailedFn, handleSubAgentCompleted as handleSubAgentCompletedFn, } from "./graph-node-lifecycle.js";
@@ -44,10 +44,10 @@ export function createGraphCoordinator(deps) {
         spawnQueue: [],
     };
     /**
-     * Phase 216 DUR-01/DUR-02 (Plan 11): checkpoint the graph's per-node
+     * Checkpoint the graph's per-node
      * completion state to the durable run store at a NODE boundary. Persists the
      * GraphExecutionSnapshot → `spawn_tree` keyed on the graph's tree-stable
-     * `rootRunId` (CR-01). A no-op when no store is wired or the run has no stable
+     * `rootRunId`. A no-op when no store is wired or the run has no stable
      * root (the durable key). On a terminal graph it flips the record to
      * `completed` so resume skips it. Store errors are logged (WARN, hint +
      * errorKind) but NEVER crash the graph — durability is best-effort overlay on
@@ -67,11 +67,11 @@ export function createGraphCoordinator(deps) {
             });
             return;
         }
-        // Source the run context the same way Plan 07 does for flat runs. The graph
-        // run carries no per-node lease/caps record here (those are minted per node),
-        // so the checkpoint persists the node-completion snapshot + the stable root;
-        // the caps/leaseIds the resumed run rehydrates come from the run record the
-        // outward-send path already wrote (NEW-1 outward_step is owned by
+        // Source the run context the same way the flat-run checkpoint path does. The
+        // graph run carries no per-node lease/caps record here (those are minted per
+        // node), so the checkpoint persists the node-completion snapshot + the stable
+        // root; the caps/leaseIds the resumed run rehydrates come from the run record
+        // the outward-send path already wrote (outward_step is owned by
         // allocateOutwardStep — this upsert deliberately never touches it).
         const record = {
             rootRunId,
@@ -91,7 +91,7 @@ export function createGraphCoordinator(deps) {
         });
     }
     // Callback wiring: bind module functions with closed-over state/deps/config.
-    // Phase 216 (Plan 11): the node-transition entry points (spawnNode →
+    // The node-transition entry points (spawnNode →
     // markNodeRunning; handleSubAgentCompleted → markNodeCompleted/markNodeFailed;
     // markNodeFailed) each `checkpointGraph(gs)` AFTER the transition so the
     // durable spawn_tree tracks node completion at every boundary.
@@ -164,12 +164,12 @@ export function createGraphCoordinator(deps) {
             }
         }
         const stateMachine = createGraphStateMachine(params.graph);
-        // Phase 213 CR-01: resolve ONE tree-stable rootRunId for the whole graph run
+        // Resolve ONE tree-stable rootRunId for the whole graph run
         // so every node spawn shares it (the tree-wide ceiling + killByRootRun see
         // one tree, not a fresh root per node). A graph submitted BY a sub-agent
         // (its session key maps to a live run) inherits that run's root; a top-level
         // submission resolves the caller session's stable root. Undefined when no
-        // resolver is wired (older path; nodes mint per-spawn — graph fan-out is
+        // resolver is wired (nodes mint per-spawn — graph fan-out is
         // still bounded by the graph concurrency gate).
         const graphParentRun = params.callerSessionKey
             ? deps.subAgentRunner.getRunBySessionKey?.(params.callerSessionKey)
@@ -194,9 +194,9 @@ export function createGraphCoordinator(deps) {
             runningCount: 0,
             callerSessionKey: params.callerSessionKey,
             callerAgentId: params.callerAgentId,
-            // GEN-03 (A2 fallback): graph submission carries no inbound NormalizedMessage, so resolve
+            // Graph submission carries no inbound NormalizedMessage, so resolve
             // the reply language once from the caller's RequestContext.resolvedLanguage — set by the
-            // parent executor in 181-04 — and thread it to every node envelope via buildContextEnvelope.
+            // parent executor — and thread it to every node envelope via buildContextEnvelope.
             resolvedLanguage: tryGetContext()?.resolvedLanguage,
             announceChannelType: params.announceChannelType,
             announceChannelId: params.announceChannelId,
@@ -255,7 +255,7 @@ export function createGraphCoordinator(deps) {
             timestamp: systemNowMs(),
         });
         deps.logger?.info({ graphId, graphTraceId, nodeCount: params.graph.graph.nodes.length }, "Graph run assigned traceId for sub-agent correlation");
-        // v2.19: enforce a makespan floor on the graph timeout. A weak model routinely
+        // Enforce a makespan floor on the graph timeout. A weak model routinely
         // sets it too low for the DAG it just decomposed — observed live: a 6-node NVDA
         // pipeline given 10 min, where the 4 analysts (small-model concurrency = 2)
         // consumed the whole budget and the debate + head-trader were starved. The floor
@@ -456,15 +456,15 @@ export function createGraphCoordinator(deps) {
         callbacks.handleSubAgentCompleted(gs, { runId, success: false });
     }
     /**
-     * Phase 216 DUR-01/DUR-02 (Plan 11): resume a DAG run from its durable
+     * Resume a DAG run from its durable
      * checkpoint after a restart. Re-enters ONLY the incomplete nodes and DRIVES
      * them via the node-lifecycle path so each re-entered node's sub-agent spawn
-     * actually fires (LOW-1 — not a bare re-mark-ready). Completed nodes are not
+     * actually fires — not a bare re-mark-ready. Completed nodes are not
      * re-run; a re-run node's outward sends dedupe via the ONCE ledger.
      *
      * The durable record carries node-completion STATE (`spawn_tree`) but not the
-     * original graph topology/tasks (out of scope for 216 — full mid-node DAG
-     * state persistence is deferred). So resume reconstructs a reduced graph from
+     * original graph topology/tasks (full mid-node DAG
+     * state persistence is deliberately not attempted). So resume reconstructs a reduced graph from
      * the incomplete frontier: each incomplete node becomes an independent root
      * (dependsOn=[]), immediately `ready`, and is driven to re-execute. Already-
      * terminal nodes (completed/skipped/failed) are excluded from the reconstructed
@@ -472,8 +472,8 @@ export function createGraphCoordinator(deps) {
      * unfinished frontier, not the whole DAG).
      */
     async function resumeGraph(record) {
-        // Cap/shape guard: a tampered or column-drifted record must not rehydrate
-        // (T-216-01). parseDurableRunRecord permits the stepIndex=-1 never-sent
+        // Cap/shape guard: a tampered or column-drifted record must not rehydrate.
+        // parseDurableRunRecord permits the stepIndex=-1 never-sent
         // sentinel, so a legitimate not-yet-sent DAG checkpoint passes.
         const parsed = parseDurableRunRecord(record);
         if (!parsed.ok) {
@@ -556,7 +556,7 @@ export function createGraphCoordinator(deps) {
             nodeCount: validated.graph.nodes.length,
             timestamp: systemNowMs(),
         });
-        // DRIVE the incomplete nodes (LOW-1): spawnReadyNodes → spawnNode →
+        // DRIVE the incomplete nodes: spawnReadyNodes → spawnNode →
         // subAgentRunner.spawn + markNodeRunning. The re-entered node actually
         // re-executes; it is NOT merely set ready.
         callbacks.spawnReadyNodes(gs);

package/node_modules/@comis/daemon/dist/graph/graph-driver-handler.js

@@ -464,7 +464,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
                     callerSessionKey: gs.callerSessionKey,
                     callerAgentId: gs.callerAgentId,
                     callerType: "graph",
-                    // Phase 213 CR-01: share the graph run's tree root (killByRootRun reach).
+                    // Share the graph run's tree root (killByRootRun reach).
                     ...(gs.rootRunId !== undefined ? { rootRunId: gs.rootRunId } : {}),
                     graphSharedDir: gs.sharedDir,
                     graphTraceId: gs.graphTraceId,
@@ -510,7 +510,7 @@ export function executeDriverAction(state, deps, config, gs, nodeId, action, cal
                         callerSessionKey: gs.callerSessionKey,
                         callerAgentId: gs.callerAgentId,
                         callerType: "graph",
-                        // Phase 213 CR-01: share the graph run's tree root (killByRootRun reach).
+                        // Share the graph run's tree root (killByRootRun reach).
                         ...(gs.rootRunId !== undefined ? { rootRunId: gs.rootRunId } : {}),
                         graphSharedDir: gs.sharedDir,
                         graphTraceId: gs.graphTraceId,