comisai 1.0.44 → 1.0.46

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

@@ -14,10 +14,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
@@ -41,14 +41,14 @@ export function dialecticWiringDepsFromBoot(c) {
         agentsConfig: c.agentsConfig,
         // The master cost-feature kill switch — the dialectic (memory_ask) is a cost feature, so a
         // `false` here force-disables it regardless of any agent's per-agent dialectic.enabled.
-        // `!== false` (IN-01) matches the H-1 fail-open contract on every other gate reader: a
+        // `!== false` matches the fail-open contract on every other gate reader: a
         // missing/undefined `enabled` at this boundary stays ENABLED (default-on), never silently
         // fail-CLOSED — though the schema always materializes `enabled` so this is defense-in-depth.
         costFeaturesEnabled: c.container.config.memory.enabled !== false,
         secretManager: c.container.secretManager,
-        // FLAG-3: per-agent OAuth-credential resolver — returns a per-call getApiKey for the cheap
+        // Per-agent OAuth-credential resolver — returns a per-call getApiKey for the cheap
         // provider when that agent has an OAuth manager (openai-codex), else undefined (seam falls back
-        // to the static apiKey). Resolves the OAuth bearer so memory.ask no longer abstains on OAuth deployments.
+        // to the static apiKey). Resolves the OAuth bearer so memory.ask does not abstain on OAuth deployments.
         getResolveCredential: (agentId, provider) => {
             // eslint-disable-next-line security/detect-object-injection -- agentId is the invoking agent's configured id
             const mgr = c.oauthManagers?.get(agentId);
@@ -76,9 +76,9 @@ export function dialecticWiringDepsFromBoot(c) {
             tripleStore: c.tripleStore,
             embeddingStore: c.embeddingStore,
             usefulnessStore: c.usefulnessStore,
-            // R6: c.memoryAdapter implements BOTH MemoryPort AND MemoryPinnedStore (SqliteMemoryAdapter
+            // c.memoryAdapter implements BOTH MemoryPort AND MemoryPinnedStore (SqliteMemoryAdapter
             // satisfies both); pass it here as the segregated pinnedStore so the dialectic recall's
-            // Step-0 pinned-first lane can fire — parity with the main path (prompt-assembly) fix.
+            // Step-0 pinned-first lane can fire — parity with the main path (prompt-assembly).
             pinnedStore: c.memoryAdapter,
         },
         clock: c.clock,
@@ -156,19 +156,19 @@ export function buildDialecticWiring(deps) {
             }, "Dialectic enabled but no API key resolved — memory.ask will abstain");
         }
         // Custom-provider model spec (the resolved …/v1 baseUrl) so a keyless/local YAML provider
-        // the pi-ai catalog can't see still resolves a Model. Without it, memory.ask abstained
-        // "model not found" on every keyless ask — even with a CAPABLE model (live 2026-06-20; the
-        // #223 judge-resolver bug class, this seam was the missed sibling). Undefined for built-ins.
+        // the pi-ai catalog can't see still resolves a Model. Without it, memory.ask abstains
+        // "model not found" on every keyless ask — even with a CAPABLE model (the same bug class
+        // as the #223 judge resolver). Undefined for built-ins.
         const customModel = buildCustomJudgeModelSpec(providerEntry, resolved.provider, resolved.modelId);
-        // R6 (CR-01): derive the capability routing for the cron/memory model that
+        // Derive the capability routing for the cron/memory model that
         // actually makes the synthesis LLM call. A small/nano cron model (absent an
         // operator capable override) routes synthesize() to { abstain: true } so a weak
-        // model never fabricates citations into the dialectic answer (T-153-fabricate).
+        // model never fabricates citations into the dialectic answer.
         const seamCapability = resolveMemoryOpsCapability({ provider: resolved.provider, modelId: resolved.modelId }, providerEntry?.capabilities);
         // The ONE query-time synthesis seam (bounded by THIS agentʼs dialectic.maxOutputTokens — the
         // cost axis; falls back to the schema default when the agentʼs dialectic block is absent).
-        // FLAG-3: per-call OAuth-credential resolver for THIS agent's cheap provider. Undefined for
-        // non-OAuth/keyless providers ⇒ the seam keeps using the static `apiKey` (pre-fix behavior).
+        // Per-call OAuth-credential resolver for THIS agent's cheap provider. Undefined for
+        // non-OAuth/keyless providers ⇒ the seam uses the static `apiKey`.
         const resolveCredential = getResolveCredential?.(agentId, resolved.provider);
         const seamDeps = {
             provider: resolved.provider,
@@ -179,7 +179,7 @@ export function buildDialecticWiring(deps) {
             clock,
             logger,
             agentId,
-            // R6 routing (CR-01): keys on the cron/memory model, not the agent primary.
+            // Capability routing keys on the cron/memory model, not the agent primary.
             capabilityClass: seamCapability.capabilityClass,
             hasCapableModelOverride: seamCapability.hasCapableModelOverride,
             ...(customModel !== undefined ? { customModel } : {}),
@@ -191,24 +191,24 @@ export function buildDialecticWiring(deps) {
     // The seam the handler calls passes the invoking agentId so the per-agent model/key/
     // token bound are used (not the default agentʼs).
     const dialecticSeam = (agentId, question, groundingText) => seamFor(agentId)(question, groundingText);
-    // The per-agent recall factory re-reads the INVOKING agentʼs RagConfig (the prior code
-    // ignored its agentId param and always read the default agentʼs rag — so a non-default agentʼs
-    // includeTrustLevels / maxResults / scoring were never honored). The FULL createMemoryRecall
-    // (trust-filtered) is reconstructed exactly as prompt-assemblyʼs executor read path does.
+    // The per-agent recall factory re-reads the INVOKING agentʼs RagConfig — never the default
+    // agentʼs — so a non-default agentʼs includeTrustLevels / maxResults / scoring are honored.
+    // The FULL createMemoryRecall (trust-filtered) is reconstructed exactly as prompt-assemblyʼs
+    // executor read path does.
     //
-    // The main↔dialectic recall-parity fix:
-    //   - `forget` (the FadeMem decay gate) is now passed — the SAME
+    // Main↔dialectic recall parity:
+    //   - `forget` (the FadeMem decay gate) is passed — the SAME
     //     field the main path passes at prompt-assembly.ts:854 — so memory.ask applies the per-type
     //     decay when `rag.forget.enabled`. Default-OFF byte-identity holds (score.ts forces the
     //     forgetFactor to EXACTLY 1.0 when off).
     //
-    // Recall scoring is the FIXED `rag.scoring` alphas (Phase 224, RECALL-02/03): the UCB
-    // tuned-alpha bandit + its overlay were DELETED, so memory.ask — like the main prompt-assembly
+    // Recall scoring is the FIXED `rag.scoring` alphas: there is no UCB tuned-alpha bandit or
+    // overlay, so memory.ask — like the main prompt-assembly
     // recall path — applies the config-sourced alphas only (no learned-weight read). The factory is
     // SYNCHRONOUS (`(agentId) => MemoryRecall`; the handler reads it without an `await`).
     const buildDialecticRecall = (agentId) => {
         const rag = configFor(agentId).rag;
-        // `feedback` predates its config landing — structural-widen like prompt-assembly.
+        // `feedback` is not declared on the RagConfig type — structural-widen like prompt-assembly.
         const ragFeedback = rag.feedback;
         // Construct the FULL orchestrator with the fixed config `scoring`. Everything is identical to
         // the main path's recall deps/config.
@@ -221,8 +221,8 @@ export function buildDialecticWiring(deps) {
             ...(stores.tripleStore !== undefined ? { tripleStore: stores.tripleStore } : {}),
             ...(stores.embeddingStore !== undefined ? { embeddingStore: stores.embeddingStore } : {}),
             ...(stores.usefulnessStore !== undefined ? { usefulnessStore: stores.usefulnessStore } : {}),
-            // R6: wire the pinned store so the dialectic recall's Step-0 pinned-first lane can
-            // fire — parity with the main path (prompt-assembly) fix. Default-OFF byte-identity:
+            // Wire the pinned store so the dialectic recall's Step-0 pinned-first lane can
+            // fire — parity with the main path (prompt-assembly). Default-OFF byte-identity:
             // with `rag.pinned.enabled=false` (the default), no query runs even when the store is present.
             ...(stores.pinnedStore !== undefined ? { pinnedStore: stores.pinnedStore } : {}),
             ...(timers !== undefined ? { timers } : {}),
@@ -234,7 +234,7 @@ export function buildDialecticWiring(deps) {
             minScore: rag.minScore,
             includeTrustLevels: rag.includeTrustLevels,
             rerank: rag.rerank,
-            // Fixed config-sourced scoring alphas — no learned overlay (Phase 224, RECALL-02/03).
+            // Fixed config-sourced scoring alphas — no learned overlay.
             scoring: rag.scoring,
             lanes: rag.lanes,
             entityLane: rag.entityLane,
@@ -242,7 +242,7 @@ export function buildDialecticWiring(deps) {
             queryUnderstanding: rag.queryUnderstanding,
             // The FadeMem decay gate — the SAME field prompt-assembly.ts:854 passes.
             forget: rag.forget,
-            // R6: forward the pinned-memory injection config so the dialectic recall's
+            // Forward the pinned-memory injection config so the dialectic recall's
             // Step-0 knows the cap. A fully-defaulted RagConfig field (same posture as mmr/forget).
             // Default-OFF (`enabled:false`) ⇒ the pinned lane is skipped (byte-identical).
             pinned: rag.pinned,

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

@@ -1,5 +1,5 @@
 /**
- * Durable resume subsystem wiring (Phase 216 — the composition root for the
+ * Durable resume subsystem wiring (the composition root for the
  * durability engine). Mirrors `setup-delivery.ts`'s two-phase STRUCTURE:
  *
  *   1. `setupDurableResume()` constructs the two SQLite stores (against the SHARED
@@ -9,7 +9,7 @@
  *      adapters (the boot-order constraint — the engine's reconcile + replay need
  *      LIVE adapters), exactly like the delivery queue's `drainAndStart()`. It
  *      runs the bounded boot recovery (`engine.resumeAll()`) THEN starts a single
- *      daemon-wide watchdog interval (HB-01) that sweeps lapsed heartbeats.
+ *      daemon-wide watchdog interval that sweeps lapsed heartbeats.
  *   3. `shutdown()` cancels the watchdog interval — no leaked timer.
  *
  * GATING: when `config.enabled` is false (the default, OR no autonomy-bearing
@@ -18,9 +18,9 @@
  * NO watchdog timer) so a default install is byte-identical — mirroring
  * `setup-delivery.ts`'s inert-when-disabled return.
  *
- * The engine itself is PURE / I/O-free (Plan 04); this wiring binds it to the
+ * The engine itself is PURE / I/O-free; this wiring binds it to the
  * real stores + the injected LeaseManager re-mint / run-resume / send-replay /
- * channel-adapter / notify closures (Task 3 supplies those). The watchdog uses
+ * channel-adapter / notify closures. The watchdog uses
  * the INJECTED TimerPort (never the interval-scheduler global — the
  * globals.test.ts arch-gate).
  *
@@ -31,21 +31,84 @@ import type { ComisLogger, LeaseManager } from "@comis/infra";
 import { type Result } from "@comis/shared";
 import { type MintLeaseInput, type IssuedLease, type NotifyFn, type DurableEventEmitter } from "../autonomy/durable-resume-engine.js";
 import type { BoundedAutonomy } from "../autonomy/bounded-autonomy.js";
-/** The resolved `autonomy.durability` config the wiring reads (Plan 07-Task-1 schema). */
+/**
+ * The injected seams the orchestrate-kind resume arm verifies against — a
+ * workspace resolver + an fs-exists probe. Injected so the arm is PURE and
+ * macOS-unit-testable against a real temp workspace with no daemon boot.
+ */
+export interface OrchestrateResumeSeams {
+    /**
+     * Resolve a run's workspace ROOT from its record (undefined ⇒ unresolvable ⇒
+     * not resumable). The pinned script lives at the workspace root; the checkpoint
+     * blob lives under `<workspace>/results/`.
+     */
+    readonly workspaceFor: (record: DurableRunRecord) => string | undefined;
+    /** Whether an absolute path exists on disk (the real `existsSync` in production). */
+    readonly fileExists: (absPath: string) => boolean;
+}
+/**
+ * The orchestrate-kind resume arm: VERIFY the pinned script + (when a
+ * `checkpointRef` is set) the checkpoint blob are on disk. The refs are
+ * WORKSPACE-RELATIVE (a `<runId>.<language>` at the root / a `results/…`
+ * ResultRef), `safePath`-confined BEFORE any fs touch (a `..`/absolute escape is
+ * refused, never resumed). PRESENT → `ok` (the closure re-anchors + the engine
+ * surfaces `durable:resumed` — SURFACE-ONLY on boot; the byte re-execution is the
+ * explicit `orchestrate({resumeRunId})`, A2); MISSING → `err` (the engine's
+ * existing orphan path turns it into a `durable:orphaned` + reclaim). Every `err`
+ * message NAMES why AND contains "not resumable" so `orphanReasonToEnum` maps it
+ * to the closed `not_resumable` member — the free text stays on the WARN
+ * log / notify only (INV-5). Pure over the injected seams.
+ */
+export declare function verifyOrchestrateResumable(record: DurableRunRecord, seams: OrchestrateResumeSeams): Result<void, Error>;
+/**
+ * The full orchestrate-resume wiring cluster `buildDurableResume` binds: the arm
+ * seams ({@link OrchestrateResumeSeams}) PLUS the orphan-reclaim seams. ONE
+ * optional cluster (not N loose fields — optional-field-bloat honesty): the arm
+ * + the RESUME-04 reclaim are wired TOGETHER (both need the workspace resolver).
+ * Structurally a superset of both the arm's {@link OrchestrateResumeSeams} and the
+ * engine's `OrchestrateReclaimSeams`, so the SAME object passes to
+ * `verifyOrchestrateResumable` (the arm) and `reclaimOrphanedOrchestrateRun` (the
+ * reclaim) directly.
+ */
+export interface OrchestrateResumeWiring extends OrchestrateResumeSeams {
+    /** Delete a dead run's `results/` dir — reuses result-ref-store.cleanupRun (rmSync recursive). */
+    readonly cleanupResults: (workspacePath: string, runId: string) => Promise<void>;
+    /** Delete the pinned `<scriptRef>` (guarded rmSync — a missing file is a no-op → idempotent). */
+    readonly removePinnedScript: (workspacePath: string, scriptRef: string) => void;
+}
+/**
+ * Build the production {@link OrchestrateResumeWiring} cluster for the composition
+ * root — the LIVE seams the boot-sweep arm + the RESUME-04 orphan reclaim run
+ * against. A `DurableRunRecord` carries no `agentId` (an orchestrate row's
+ * caps/leaseIds/spawnTree are all `[]`), so `workspaceFor` resolves to the
+ * default-agent workspace — the correct target for the common single-agent case;
+ * the resolver is the multi-agent extension point. The reclaim REUSES the existing
+ * `result-ref-store.cleanupRun` (rmSync-recursive of `results/`) for the checkpoint
+ * blob + a `safePath`-guarded `rmSync` for the pinned `<runId>.<language>` script at
+ * the workspace root — no new GC primitive (NG4), scoped, and idempotent (a missing
+ * file / a traversal-escape scriptRef is a no-op, never a throw that aborts the sweep).
+ */
+export declare function buildOrchestrateResumeWiring(deps: {
+    /** The default-agent jailed workspace root (a bare durable row's resume target). */
+    defaultWorkspaceDir: string;
+    /** Logger for the reused result-ref store (its cleanupRun path). */
+    logger: ComisLogger;
+}): OrchestrateResumeWiring;
+/** The resolved `autonomy.durability` config the wiring reads. */
 export interface DurableResumeConfig {
     /** Master gate — already folds in `autonomy.durability.enabled AND an autonomy agent`. */
     readonly enabled: boolean;
     /** The lapsed-heartbeat threshold (ms) — the watchdog interval period + the stale cutoff. */
     readonly staleHeartbeatMs: number;
-    /** The wall-clock recovery budget (ms) for one boot/watchdog pass (HB-02). */
+    /** The wall-clock recovery budget (ms) for one boot/watchdog pass. */
     readonly recoveryBudgetMs: number;
 }
-/** The deps `setupDurableResume` closes over (Task 3 binds the real closures). */
+/** The deps `setupDurableResume` closes over. */
 export interface SetupDurableResumeDeps {
     /**
      * The durable-run + outward-send stores. The daemon builds these EARLY (before
      * the cap layer, so the jail-leg chokepoint can thread the durable store for the
-     * HIGH-1 _outwardStepIndex allocation) and passes them here. When omitted AND
+     * _outwardStepIndex allocation) and passes them here. When omitted AND
      * `config.enabled`, they are constructed from `db` (the standalone/test path).
      */
     durableRunStore?: DurableRunPort;
@@ -54,7 +117,7 @@ export interface SetupDurableResumeDeps {
     db: unknown;
     /** The resolved `autonomy.durability` posture (gate + thresholds). */
     config: DurableResumeConfig;
-    /** Narrow content-free event emitter (Task 3 adapts the real TypedEventBus). */
+    /** Narrow content-free event emitter (adapts the real TypedEventBus). */
     eventBus: DurableEventEmitter;
     logger: ComisLogger;
     /** Resolve a LIVE channel adapter by channel type (undefined when none) — populated post-setupChannels. */
@@ -63,11 +126,13 @@ export interface SetupDurableResumeDeps {
     remintLease: (input: MintLeaseInput) => IssuedLease;
     /** Resume a run from its checkpoint under the re-minted lease. */
     resumeRun: (record: DurableRunRecord, leaseId: string) => Promise<Result<void, Error>>;
+    /** Reclaim a dead resumable orchestrate run's artifacts on the orphan path (RESUME-04); threaded into the engine. Absent ⇒ no reclaim. */
+    reclaimOrchestrateRun?: (record: DurableRunRecord) => Promise<void>;
     /** Re-deliver a not_sent ledger row exactly once. */
     replaySend: (row: OutwardSendRecord) => Promise<Result<{
         platformMessageId: string;
     }, Error>>;
-    /** Content-free operator notification for an orphan / unresolved reconcile (HB-03). */
+    /** Content-free operator notification for an orphan / unresolved reconcile. */
     notify: NotifyFn;
     clock: ClockPort;
     timers: TimerPort;
@@ -142,8 +207,8 @@ export declare function buildDurableResume(deps: {
     clock: ClockPort;
     timers: TimerPort;
     /**
-     * Phase 216 Plan 12 (DUR-02/LOW-2): the graph coordinator's `resumeGraph(record)`
-     * entry (Plan 11). The resume engine's `resumeRun` dispatch routes a DAG-shaped run
+     * The graph coordinator's `resumeGraph(record)`
+     * entry. The resume engine's `resumeRun` dispatch routes a DAG-shaped run
      * record (spawn_tree entries are OBJECTS with a `status` field — {@link isDagSpawnTree})
      * to this for node re-entry; a flat run (string[] spawn_tree) takes the flat re-anchor.
      * Late-bound: the daemon constructs the coordinator AFTER buildDurableResume, so it is
@@ -152,4 +217,15 @@ export declare function buildDurableResume(deps: {
      * to the flat re-anchor (no crash; node re-entry is simply unavailable).
      */
     resumeGraph?: (record: DurableRunRecord) => Promise<Result<void, Error>>;
+    /**
+     * The orchestrate-kind resume + orphan-reclaim seams (workspace resolver +
+     * fs-exists probe + cleanupRun/rmSync reclaim). When present: a flat row with
+     * `scriptRef != null` routes to the orchestrate arm — VERIFY the pinned script +
+     * checkpoint on disk (surface-only on boot; explicit `orchestrate({resumeRunId})`
+     * re-executes — A2) — and a dead resumable run's artifacts are reclaimed on the
+     * orphan path (RESUME-04). Absent ⇒ a scriptRef row degrades to the plain flat
+     * re-anchor (no disk verification, no reclaim) — the gated, deny-by-absence
+     * posture: the runner only writes scriptRef rows when `orchestrateResume` is on.
+     */
+    orchestrateResume?: OrchestrateResumeWiring;
 }): DurableResumeWiring;

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

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 /**
- * Durable resume subsystem wiring (Phase 216 — the composition root for the
+ * Durable resume subsystem wiring (the composition root for the
  * durability engine). Mirrors `setup-delivery.ts`'s two-phase STRUCTURE:
  *
  *   1. `setupDurableResume()` constructs the two SQLite stores (against the SHARED
@@ -10,7 +10,7 @@
  *      adapters (the boot-order constraint — the engine's reconcile + replay need
  *      LIVE adapters), exactly like the delivery queue's `drainAndStart()`. It
  *      runs the bounded boot recovery (`engine.resumeAll()`) THEN starts a single
- *      daemon-wide watchdog interval (HB-01) that sweeps lapsed heartbeats.
+ *      daemon-wide watchdog interval that sweeps lapsed heartbeats.
  *   3. `shutdown()` cancels the watchdog interval — no leaked timer.
  *
  * GATING: when `config.enabled` is false (the default, OR no autonomy-bearing
@@ -19,20 +19,110 @@
  * NO watchdog timer) so a default install is byte-identical — mirroring
  * `setup-delivery.ts`'s inert-when-disabled return.
  *
- * The engine itself is PURE / I/O-free (Plan 04); this wiring binds it to the
+ * The engine itself is PURE / I/O-free; this wiring binds it to the
  * real stores + the injected LeaseManager re-mint / run-resume / send-replay /
- * channel-adapter / notify closures (Task 3 supplies those). The watchdog uses
+ * channel-adapter / notify closures. The watchdog uses
  * the INJECTED TimerPort (never the interval-scheduler global — the
  * globals.test.ts arch-gate).
  *
  * @module
  */
-import { resolveAutonomy, DurabilityConfigSchema } from "@comis/core";
+import { existsSync, rmSync } from "node:fs";
+import { resolveAutonomy, DurabilityConfigSchema, safePath } from "@comis/core";
 import { createSqliteDurableRunStore, createSqliteOutwardSendLedger } from "@comis/memory";
+import { createResultRefStore } from "@comis/skills/tools";
 import { ok, err } from "@comis/shared";
-import { createDurableResumeEngine, } from "../autonomy/durable-resume-engine.js";
+import { createDurableResumeEngine, reclaimOrphanedOrchestrateRun, } from "../autonomy/durable-resume-engine.js";
 import { detectStaleRuns } from "../autonomy/durable-watchdog.js";
 import { isDagSpawnTree } from "../graph/graph-durable-checkpoint.js";
+/**
+ * The orchestrate-kind resume arm: VERIFY the pinned script + (when a
+ * `checkpointRef` is set) the checkpoint blob are on disk. The refs are
+ * WORKSPACE-RELATIVE (a `<runId>.<language>` at the root / a `results/…`
+ * ResultRef), `safePath`-confined BEFORE any fs touch (a `..`/absolute escape is
+ * refused, never resumed). PRESENT → `ok` (the closure re-anchors + the engine
+ * surfaces `durable:resumed` — SURFACE-ONLY on boot; the byte re-execution is the
+ * explicit `orchestrate({resumeRunId})`, A2); MISSING → `err` (the engine's
+ * existing orphan path turns it into a `durable:orphaned` + reclaim). Every `err`
+ * message NAMES why AND contains "not resumable" so `orphanReasonToEnum` maps it
+ * to the closed `not_resumable` member — the free text stays on the WARN
+ * log / notify only (INV-5). Pure over the injected seams.
+ */
+export function verifyOrchestrateResumable(record, seams) {
+    const workspacePath = seams.workspaceFor(record);
+    if (workspacePath === undefined) {
+        return err(new Error("orchestrate resume not resumable: workspace unavailable"));
+    }
+    const scriptRef = record.scriptRef;
+    if (scriptRef == null) {
+        // The closure discriminator guarantees scriptRef != null before this is
+        // called; a null here is a mis-routed non-orchestrate row — refuse honestly.
+        return err(new Error("orchestrate resume not resumable: no pinned script"));
+    }
+    // 1. the pinned script (workspace ROOT, `<runId>.<language>`).
+    let scriptAbs;
+    try {
+        scriptAbs = safePath(workspacePath, scriptRef);
+    }
+    catch {
+        return err(new Error("orchestrate resume not resumable: pinned script path escaped the workspace"));
+    }
+    if (!seams.fileExists(scriptAbs)) {
+        return err(new Error("orchestrate resume not resumable: the pinned script is gone"));
+    }
+    // 2. the checkpoint blob (`<workspace>/results/…`), when a `checkpointRef` is
+    //    set. A null checkpointRef = a run that registered but never checkpointed —
+    //    still resumable from the pinned bytes alone (a re-run from scratch).
+    const checkpointRef = record.checkpointRef;
+    if (checkpointRef != null) {
+        let checkpointAbs;
+        try {
+            checkpointAbs = safePath(workspacePath, checkpointRef);
+        }
+        catch {
+            return err(new Error("orchestrate resume not resumable: checkpoint path escaped the workspace"));
+        }
+        if (!seams.fileExists(checkpointAbs)) {
+            return err(new Error("orchestrate resume not resumable: the checkpoint blob is gone"));
+        }
+    }
+    return ok(undefined);
+}
+/**
+ * Build the production {@link OrchestrateResumeWiring} cluster for the composition
+ * root — the LIVE seams the boot-sweep arm + the RESUME-04 orphan reclaim run
+ * against. A `DurableRunRecord` carries no `agentId` (an orchestrate row's
+ * caps/leaseIds/spawnTree are all `[]`), so `workspaceFor` resolves to the
+ * default-agent workspace — the correct target for the common single-agent case;
+ * the resolver is the multi-agent extension point. The reclaim REUSES the existing
+ * `result-ref-store.cleanupRun` (rmSync-recursive of `results/`) for the checkpoint
+ * blob + a `safePath`-guarded `rmSync` for the pinned `<runId>.<language>` script at
+ * the workspace root — no new GC primitive (NG4), scoped, and idempotent (a missing
+ * file / a traversal-escape scriptRef is a no-op, never a throw that aborts the sweep).
+ */
+export function buildOrchestrateResumeWiring(deps) {
+    // Reuse the SHIPPED result-ref store for cleanupRun (results/ wipe) — never a
+    // hand-rolled results-dir resolver that could drift from the store's layout.
+    const resultStore = createResultRefStore({ logger: deps.logger });
+    return {
+        workspaceFor: () => deps.defaultWorkspaceDir,
+        // eslint-disable-next-line security/detect-non-literal-fs-filename -- absPath is safePath-confined by the caller (the boot-sweep arm resolves scriptRef/checkpointRef via safePath before probing).
+        fileExists: (absPath) => existsSync(absPath),
+        cleanupResults: (workspacePath, runId) => resultStore.cleanupRun({ workspacePath, runId }),
+        removePinnedScript: (workspacePath, scriptRef) => {
+            // safePath refuses a `..`/absolute escape BEFORE any unlink; rmSync force:true
+            // makes a missing file a no-op (idempotent). A refused/failed path is a silent
+            // no-op — the reclaim must never throw and abort the boot/watchdog sweep.
+            try {
+                const abs = safePath(workspacePath, scriptRef);
+                rmSync(abs, { force: true });
+            }
+            catch {
+                /* traversal-escape scriptRef (safePath threw) or an unlink failure — no-op. */
+            }
+        },
+    };
+}
 export function setupDurableResume(deps) {
     const { db, config, eventBus, logger, channelAdapters, remintLease, resumeRun, replaySend, notify, clock, timers } = deps;
     // GATING: disabled (default, or no autonomy agent) ⇒ inert. No stores, no
@@ -67,13 +157,16 @@ export function setupDurableResume(deps) {
         recoveryBudgetMs: config.recoveryBudgetMs,
         logger,
         eventBus,
+        // RESUME-04: the engine calls this on the orphan path to reclaim a dead
+        // resumable orchestrate run's artifacts (scoped + idempotent). Absent ⇒ no reclaim.
+        ...(deps.reclaimOrchestrateRun ? { reclaimOrchestrateRun: deps.reclaimOrchestrateRun } : {}),
     });
     // ONE daemon-wide watchdog interval (Open Question 2 — NOT per-run). Cancelled
     // on shutdown so there is no leaked timer across a restart.
     let watchdog;
     const resumeAndStart = async () => {
         // 1. Boot recovery: reconcile crashed-mid-send rows + resume-or-orphan, bounded
-        //    by recoveryBudgetMs (HB-02 — a backlog larger than the budget is deferred).
+        //    by recoveryBudgetMs (a backlog larger than the budget is deferred).
         const startMs = clock.now();
         const result = await engine.resumeAll();
         if (result.ok) {
@@ -82,7 +175,7 @@ export function setupDurableResume(deps) {
         else {
             logger.warn({ err: result.error, hint: "boot recovery failed — the watchdog/next boot retries; no runs were resumed this pass", errorKind: "dependency", durationMs: clock.now() - startMs }, "Durable resume: boot recovery failed");
         }
-        // 2. Start the single daemon-wide watchdog (HB-01). It fires at the stale
+        // 2. Start the single daemon-wide watchdog. It fires at the stale
         //    threshold cadence, detects lapsed-heartbeat runs, and feeds the engine.
         //    .unref() so it never blocks event-loop exit (mirrors the delivery drain timer).
         watchdog = timers.setInterval(() => {
@@ -137,7 +230,13 @@ export function buildDurableStores(deps) {
  * time — after channels). Returns the handle + the boot seam + the facts resolver.
  */
 export function buildDurableResume(deps) {
-    const { durabilityCfg, durableRunStore, outwardLedger, boundedAutonomy, sharedLeaseManager, channelAdaptersRef, eventBus, logger, clock, timers, resumeGraph } = deps;
+    const { durabilityCfg, durableRunStore, outwardLedger, boundedAutonomy, sharedLeaseManager, channelAdaptersRef, eventBus, logger, clock, timers, resumeGraph, orchestrateResume } = deps;
+    // RESUME-04 orphan-reclaim: bind the engine's reclaim hook to the wiring's
+    // reclaim seams (workspace + cleanupRun + guarded rmSync). The bound helper is
+    // scoped (a non-orchestrate row is a no-op) + idempotent. Absent ⇒ no reclaim.
+    const reclaimOrchestrateRun = orchestrateResume
+        ? (record) => reclaimOrphanedOrchestrateRun(record, orchestrateResume)
+        : undefined;
     const durableResume = setupDurableResume({
         db: deps.db,
         ...(durableRunStore ? { durableRunStore } : {}),
@@ -149,18 +248,26 @@ export function buildDurableResume(deps) {
         logger,
         // channelFor reads the LIVE registry (populated by reference post-setupChannels).
         channelAdapters: (type) => channelAdaptersRef?.get(type),
-        // remintLease: re-mint from the persisted attenuated caps VERBATIM (DUR-02/03).
+        // remintLease: re-mint from the persisted attenuated caps VERBATIM.
         remintLease: (input) => sharedLeaseManager.mintLease(input),
         // resumeRun: re-anchor the root with BoundedAutonomy so the re-minted lease is
         // bounded (budget/kill reach). The checkpoint carries caps/tree/budget, not a
-        // full re-spawnable task spec, so M1 resumes-as-anchored (a richer re-spawn from
-        // the checkpoint is a future enhancement — see the SUMMARY known limitation).
+        // full re-spawnable task spec, so a run resumes-as-anchored (a richer re-spawn
+        // from the checkpoint is a future enhancement).
         resumeRun: async (record, leaseId) => {
-            // LOW-2 DAG-vs-flat dispatch (Plan 12): a DAG record (spawn_tree entries are
-            // OBJECTS with a `status` field) routes to the graph coordinator's resumeGraph
-            // for node re-entry; a flat sub-agent run (string[] spawn_tree) takes the flat
-            // re-anchor below and can NEVER mis-route. The discriminator is the explicit
-            // entry-has-`status` check (isDagSpawnTree), not a heuristic.
+            // DAG-vs-flat-vs-orchestrate dispatch — all explicit discriminators, never a
+            // heuristic, so a flat run can NEVER mis-route:
+            //   - a DAG record (spawn_tree entries are OBJECTS with a `status` field →
+            //     isDagSpawnTree) routes to the graph coordinator's resumeGraph for node
+            //     re-entry;
+            //   - a flat RE-RUNNABLE orchestrate row (string[] spawn_tree AND a pinned
+            //     `scriptRef`, with the orchestrateResume seams wired) takes the
+            //     orchestrate arm — VERIFY the pinned script + checkpoint are on disk
+            //     (SURFACE-ONLY on boot; the byte re-execution is the explicit
+            //     `orchestrate({resumeRunId})` — A2). A MISSING artifact returns err so the
+            //     engine's orphan path emits `durable:orphaned` + reclaims (no silent loss);
+            //   - a plain flat sub-agent run (no scriptRef, or the seams unwired) takes the
+            //     flat re-anchor below.
             if (isDagSpawnTree(record.spawnTree)) {
                 if (resumeGraph)
                     return resumeGraph(record);
@@ -168,6 +275,15 @@ export function buildDurableResume(deps) {
                 // re-anchor so the run is still bounded/killable across restart (no crash).
                 logger.warn({ rootRunId: record.rootRunId, hint: "DAG record but resumeGraph is unwired; falling back to the flat re-anchor (no node re-entry)", errorKind: "internal" }, "Durable resume: DAG resume unavailable");
             }
+            else if (record.scriptRef != null && orchestrateResume) {
+                // Orchestrate-kind arm: verify the pinned script + checkpoint on disk. On a
+                // MISSING artifact the engine's existing orphan path turns this err into a
+                // durable:orphaned (closed-enum) + reclaim — do NOT emit orphaned here.
+                const verified = verifyOrchestrateResumable(record, orchestrateResume);
+                if (!verified.ok)
+                    return verified;
+                // PRESENT → fall through to the re-anchor (surface-only; no re-spawn on boot).
+            }
             try {
                 boundedAutonomy?.registerRoot(record.rootRunId, leaseId);
                 return ok(undefined);
@@ -176,17 +292,21 @@ export function buildDurableResume(deps) {
                 return err(e instanceof Error ? e : new Error(String(e)));
             }
         },
+        // reclaimOrchestrateRun: the engine calls this on the orphan path to reclaim a
+        // dead resumable orchestrate run's results/ + pinned script (RESUME-04). Absent
+        // ⇒ no reclaim (the seams unwired / orchestrateResume off).
+        ...(reclaimOrchestrateRun ? { reclaimOrchestrateRun } : {}),
         // replaySend: the content-free ledger row has no body, so a replay that lacks
         // the original message is an err — the engine parks it unresolved rather than
-        // double-sending a wrong body (Pitfall 2 honesty over a fabricated replay).
+        // double-sending a wrong body (honesty over a fabricated replay).
         replaySend: async (_row) => err(new Error("durable replay requires the original message body, which the content-free ledger does not retain; parked unresolved")),
-        // notify: content-free operator escalation (HB-03). The engine also emits durable:orphaned.
+        // notify: content-free operator escalation. The engine also emits durable:orphaned.
         notify: (opts) => logger.warn({ kind: opts.kind, rootRunId: opts.rootRunId, hint: opts.hint, errorKind: "internal" }, `Durable resume: ${opts.reason}`),
         clock,
         timers,
     });
     const startAndResumeDurable = () => durableResume.resumeAndStart();
-    // durableRunFacts (DUR-01): the runner's checkpoint reads the correlated leaseIds
+    // durableRunFacts: the runner's checkpoint reads the correlated leaseIds
     // from BoundedAutonomy (caps come from the spawn param; budgetConsumed is
     // informational — the meter exposes remaining, not consumed, so 0 here).
     const durableRunFacts = durableResume.durableRunStore

package/node_modules/@comis/daemon/dist/wiring/setup-gateway/non-secret-projections.d.ts

@@ -1,7 +1,7 @@
 /**
  * Non-secret config projections for the web dashboard's REST listings.
  *
- * The §17.8 security sign-off removed `agents` and `channels` from the getConfig
+ * A security sign-off removed `agents` and `channels` from the getConfig
  * RPC's non-secret allowlist, so the dashboard can no longer source its agent and
  * channel listings from getConfig. These pure projections return ONLY the
  * non-secret identity fields the dashboard needs — never auth profiles, API

package/node_modules/@comis/daemon/dist/wiring/setup-gateway/non-secret-projections.js

@@ -2,7 +2,7 @@
 /**
  * Non-secret config projections for the web dashboard's REST listings.
  *
- * The §17.8 security sign-off removed `agents` and `channels` from the getConfig
+ * A security sign-off removed `agents` and `channels` from the getConfig
  * RPC's non-secret allowlist, so the dashboard can no longer source its agent and
  * channel listings from getConfig. These pure projections return ONLY the
  * non-secret identity fields the dashboard needs — never auth profiles, API

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

@@ -73,7 +73,7 @@ export declare function buildGreetingGenerator(input: {
     container: AppContainer;
 }): GreetingGenerator | undefined;
 /**
- * Detect the greeting variant (spec §12) from wiring-tier state — NOT
+ * Detect the greeting variant from wiring-tier state — NOT
  * from a `core/bootstrap.ts` hook. Pure: reads only
  * non-secret agent-config presence + an interactivity flag, never `process.env`
  * and never a secret (the API-key gate stays in {@link buildGreetingGenerator}).

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

@@ -195,7 +195,7 @@ export function buildGreetingGenerator(input) {
     });
 }
 /**
- * Detect the greeting variant (spec §12) from wiring-tier state — NOT
+ * Detect the greeting variant from wiring-tier state — NOT
  * from a `core/bootstrap.ts` hook. Pure: reads only
  * non-secret agent-config presence + an interactivity flag, never `process.env`
  * and never a secret (the API-key gate stays in {@link buildGreetingGenerator}).

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

@@ -142,6 +142,11 @@ export interface GatewayDeps {
      *  + resolver mounted at `ALL /approve/:token`. Built in the agents phase;
      *  optional (absent when no channels / approvals path). */
     interactiveCallbackWiring?: import("../setup-interactive-callback.js").InteractiveCallbackWiring;
+    /** Microsoft Teams inbound ingress sub-app, built by the channel bootstrap
+     *  when the channel is enabled with valid credentials. Passed through to
+     *  `mountGatewayRoutes` so the `/channels/msteams` route mounts only when
+     *  present; absent ⇒ no route. */
+    msTeamsIngress?: import("hono").Hono;
 }
 /** All services produced by the gateway setup. */
 export interface GatewayResult {

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

@@ -219,6 +219,7 @@ export async function setupGateway(deps) {
         workspaceDirs,
         defaultWorkspaceDir: workspaceDirs.get(defaultAgentId),
         interactiveCallbackWiring: deps.interactiveCallbackWiring,
+        msTeamsIngress: deps.msTeamsIngress,
     });
     await gatewayHandle.start();
     gatewayLogger.debug({ host: gwConfig.host, port: gwConfig.port }, "Gateway server started");