chainlesschain 0.166.6 → 0.166.7

package/src/commands/team.js

@@ -17,7 +17,7 @@
 
 import fs from "fs";
 import path from "path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { fileURLToPath } from "url";
 import { TaskLeaseRegistry } from "../lib/agent-team/task-lease.js";
 import { TeamRunner } from "../lib/agent-team/team-runner.js";
@@ -32,6 +32,8 @@ import {
   computeTeamGraphRevisionDigest,
   projectTeamGraphCollaboration,
 } from "../lib/agent-team/team-graph-projection.js";
+import { TeamGraphRuntimeAdapter } from "../lib/agent-team/team-graph-runtime-adapter.js";
+import { createRuntimeGraphCutoverAuthorityResolver } from "../lib/graph-kernel/cutover-authority-resolver.js";
 import { resolveTeamTaskContract } from "../lib/agent-team/team-task-contract.js";
 import {
   TeamScopeLock,
@@ -326,6 +328,41 @@ function teamExecutionMode(options) {
   return "dry-run";
 }
 
+export function teamGraphAuthorityMode(
+  options,
+  env = process.env,
+  { runKey = undefined, optIn = false, resolver = undefined } = {},
+) {
+  const executionMode = teamExecutionMode(options);
+  const configured = String(env.CHAINLESSCHAIN_GRAPH_CLI_TEAM || "")
+    .trim()
+    .toLowerCase();
+  if (configured && !["legacy", "shadow", "canonical"].includes(configured)) {
+    throw new Error(
+      "CHAINLESSCHAIN_GRAPH_CLI_TEAM must be legacy, shadow, or canonical",
+    );
+  }
+  const fallbackMode =
+    executionMode === "dry-run" ? "shadow" : configured || "legacy";
+  const authorityResolver =
+    resolver ||
+    createRuntimeGraphCutoverAuthorityResolver({
+      env,
+      surface: "cli_team",
+      entryId: "cli-team-local",
+      fallbackMode,
+    });
+  const resolved =
+    typeof authorityResolver === "function"
+      ? authorityResolver({ runKey, optIn })
+      : authorityResolver.resolve({ runKey, optIn, fallbackMode });
+  const mode = typeof resolved === "string" ? resolved : resolved?.mode;
+  if (!["legacy", "shadow", "canonical"].includes(mode)) {
+    throw new Error("Team Graph authority resolver returned an invalid mode");
+  }
+  return mode;
+}
+
 function optionWasProvided(command, name) {
   const source = command?.getOptionValueSource?.(name);
   return source != null && source !== "default";
@@ -1008,8 +1045,23 @@ export function makeShellRunTask() {
           settle(terminationError);
           return;
         }
-        if (code === 0) settle(null, { code });
-        else {
+        if (code === 0) {
+          settle(null, {
+            code,
+            terminalEvidence: {
+              outputDigest: `sha256:${createHash("sha256")
+                .update(
+                  JSON.stringify({
+                    command,
+                    cwd: process.cwd(),
+                    exitCode: code,
+                  }),
+                  "utf8",
+                )
+                .digest("hex")}`,
+            },
+          });
+        } else {
           const stderr = Buffer.concat(stderrChunks).toString("utf8");
           settle(new Error(safeProcessError(stderr, `command exited ${code}`)));
         }
@@ -1310,6 +1362,7 @@ function spawnAgentProcess(prompt, cwd, opts = {}) {
         return;
       }
       const result = { code };
+      result.terminalEvidence = parser.terminalEvidence();
       if (sawStdout || summary.usage || summary.provider || summary.model) {
         if (summary.usage) result.usage = summary.usage;
         if (summary.provider) result.provider = summary.provider;
@@ -1994,6 +2047,10 @@ export function registerTeamCommand(program, { logger } = {}) {
       "--resume",
       "Restore progress from --state (completed tasks stay done; stale leases freed)",
     )
+    .option(
+      "--graph-canary-opt-in",
+      "Opt this new Team run into an entry-scoped Graph canary",
+    )
     .option("--json", "Emit the event stream as JSON lines")
     .option(
       "--otlp <file>",
@@ -2642,6 +2699,42 @@ export function registerTeamCommand(program, { logger } = {}) {
               (_, index) => `teammate-${index + 1}`,
             ),
           });
+        const graphAuthorityMode =
+          resumeSnapshot?.graphProjection?.authorityMode ||
+          teamGraphAuthorityMode(options, process.env, {
+            runKey: teamGraphRunId,
+            optIn: options.graphCanaryOptIn === true,
+          });
+        let graphRuntime = null;
+        const shadowDivergences = [];
+        const recordShadowDivergence = (divergence) => {
+          shadowDivergences.push(divergence);
+          while (shadowDivergences.length > 256) shadowDivergences.shift();
+        };
+        if (["shadow", "canonical"].includes(graphAuthorityMode)) {
+          graphRuntime = new TeamGraphRuntimeAdapter();
+          graphRuntime.open({
+            registry: reg,
+            runId: teamGraphRunId,
+            executionMode: executionContract.mode,
+            worktree: options.worktree === true,
+            teammates,
+            budget: limits,
+            authorityMode: graphAuthorityMode,
+            dynamic: true,
+          });
+          if (graphAuthorityMode === "canonical") {
+            reg = graphRuntime.bindRegistry(reg);
+            mailbox = graphRuntime.bindMailbox(mailbox);
+          } else {
+            reg = graphRuntime.bindRegistry(reg, {
+              onDivergence: recordShadowDivergence,
+            });
+            mailbox = graphRuntime.bindMailbox(mailbox, {
+              onDivergence: recordShadowDivergence,
+            });
+          }
+        }
         const settleGovernance = (key, status, extra = {}) => {
           const governanceKey = sessionTaskKeyFor(key);
           const unit = collaborationUnits.get(governanceKey);
@@ -2704,6 +2797,9 @@ export function registerTeamCommand(program, { logger } = {}) {
               revisionDigest: teamGraphRevisionDigest,
               authorityDigest: teamGraphAuthorityDigest,
             }),
+            graphAuthorityMode,
+            graphAuthority: graphRuntime?.status() || null,
+            graphShadowDivergences: [...shadowDivergences],
           });
         };
 
@@ -2956,13 +3052,34 @@ export function registerTeamCommand(program, { logger } = {}) {
           realtimeMessaging: options.agent === true,
           scopeLock,
           recorder,
-          beforeTask: ({ key }) => {
-            settleGovernance(key, "running", {
-              startedAt: Date.now(),
-            });
+          beforeTask: (context) => {
+            const { key } = context;
+            if (graphAuthorityMode === "canonical") {
+              graphRuntime?.beforeTask(context);
+            } else if (graphAuthorityMode === "shadow") {
+              try {
+                graphRuntime?.beforeTask(context);
+              } catch (error) {
+                recordShadowDivergence({
+                  phase: "assignment",
+                  key,
+                  code: error?.code || "CC_TEAM_GRAPH_SHADOW_DIVERGED",
+                  error: error?.message || String(error),
+                });
+              }
+            }
             try {
+              settleGovernance(key, "running", {
+                startedAt: Date.now(),
+              });
               persist();
             } catch (error) {
+              try {
+                graphRuntime?.abandonTask(key, error);
+              } catch (canonicalError) {
+                canonicalError.cause ||= error;
+                throw canonicalError;
+              }
               try {
                 settleGovernance(key, "pending", {
                   startedAt: null,
@@ -2973,6 +3090,38 @@ export function registerTeamCommand(program, { logger } = {}) {
               throw error;
             }
           },
+          canonicalSettlement:
+            graphAuthorityMode === "canonical" && graphRuntime
+              ? (settlement) => graphRuntime.settleTask(settlement)
+              : null,
+          canonicalReady:
+            graphAuthorityMode === "canonical" && graphRuntime
+              ? ({ excludeKeys }) =>
+                  graphRuntime.nextReadyTaskKey({ excludeKeys })
+              : null,
+          shadowSettlement:
+            graphAuthorityMode === "shadow" && graphRuntime
+              ? (settlement) => graphRuntime.settleTask(settlement)
+              : null,
+          canonicalCancellation:
+            graphAuthorityMode === "canonical" && graphRuntime
+              ? ({ reason }) => graphRuntime.cancel(reason)
+              : null,
+          shadowCancellation:
+            graphAuthorityMode === "shadow" && graphRuntime
+              ? async ({ reason }) => {
+                  try {
+                    return await graphRuntime.cancel(reason);
+                  } catch (error) {
+                    recordShadowDivergence({
+                      phase: "run-cancel",
+                      code: error?.code || "CC_TEAM_GRAPH_SHADOW_DIVERGED",
+                      error: error?.message || String(error),
+                    });
+                    return null;
+                  }
+                }
+              : null,
           afterTask: ({ key, status, retry }) => {
             const governanceStatus =
               status === "completion-discarded" ||
@@ -3094,6 +3243,19 @@ export function registerTeamCommand(program, { logger } = {}) {
           }
           throw err;
         }
+        if (graphRuntime) {
+          const graphStatus = graphRuntime.finalize();
+          summary.graphAuthorityMode = graphAuthorityMode;
+          summary.graphRuntime = graphStatus;
+          summary.graphShadowDivergences = [...shadowDivergences];
+          if (
+            graphAuthorityMode === "canonical" &&
+            graphStatus.status !== "succeeded"
+          ) {
+            summary.success = false;
+            summary.done = false;
+          }
+        }
         if (controlStore) {
           for (const request of controlStore.pending({
             anchor: controlCursor,

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.7",
+      "cliVersions": ["0.166.6", "0.166.7"],
+      "date": "2026-08-28",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added - cc CLI 0.166.7: authoritative Graph Kernel cutover",
+          "body": "> `chainlesschain` **0.166.6 -> 0.166.7** (release candidate,\n> 2026-08-28).\n\n- **Canonical execution authority**: CLI graph, Team, distributed-team,\n  Cowork, Scheduler, and App Server entry points now resolve through the\n  Graph Kernel cutover ledger instead of silently retaining parallel mutation\n  paths.\n- **Durable fencing and recovery**: graph writers, leases, receipts, takeover,\n  migration, and crash/resume flows are bound to persisted authority and\n  checked-out source evidence so stale owners cannot resume mutations.\n- **Legacy containment**: retired runtimes retain explicitly read-only history\n  access while unclassified or mutating legacy routes fail closed and report\n  their canonical replacement targets.\n- **Release validation**: publication requires this exact candidate to pass\n  Linux/Windows/macOS `CLI CI` and `CLI Strict Sandbox`, the Graph real-journey\n  matrix, immutable package checks, and public-registry provenance readback."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.6",

package/src/generated/cc-agent-protocol.schema.json

@@ -3390,7 +3390,12 @@
                     "thread/list",
                     "thread/archive",
                     "turn/start",
-                    "turn/interrupt"
+                    "turn/interrupt",
+                    "graph/compile",
+                    "graph/run",
+                    "graph/status",
+                    "graph/cancel",
+                    "graph/reconcile"
                   ]
                 }
               }

package/src/lib/agent-team/task-lease.js

@@ -325,6 +325,7 @@ export class TaskLeaseRegistry {
       attempts: t.metadata?.attempts || 0,
       lease: lease ? { ...lease } : null,
       assignee: t.assignee,
+      createdBy: t.createdBy ?? null,
       rev: t.rev,
       // Full metadata is exposed so executors can read user payload
       // (e.g. a task's shell `command` or agent `prompt`) — it carries the
@@ -1465,6 +1466,320 @@ export class TaskLeaseRegistry {
     return { ok: true, priorStatus };
   }
 
+  /**
+   * Repair the compatibility task view from a terminal canonical Graph node.
+   * This exceptional path may correct a fail-closed recovery cancellation when
+   * the immutable Graph ledger proves that the effect/attempt already settled.
+   */
+  applyCanonicalTaskProjection(
+    key,
+    {
+      runId,
+      nodeId,
+      graphStatus,
+      authorityGeneration,
+      eventHead,
+      revisionDigest,
+      evidence = null,
+      now = this._now(),
+    } = {},
+  ) {
+    const terminalStatus =
+      graphStatus === "succeeded"
+        ? TASK_STATUS.COMPLETED
+        : ["failed", "blocked", "cancelled"].includes(graphStatus)
+          ? TASK_STATUS.CANCELLED
+          : null;
+    if (!terminalStatus) {
+      return { ok: false, reason: "graph_not_terminal" };
+    }
+    if (
+      !SAFE_HANDOFF_ID_PATTERN.test(String(runId || "")) ||
+      !SAFE_HANDOFF_ID_PATTERN.test(String(nodeId || "")) ||
+      !Number.isSafeInteger(Number(authorityGeneration)) ||
+      Number(authorityGeneration) < 1 ||
+      !SHA256_PATTERN.test(String(eventHead || "")) ||
+      !SHA256_PATTERN.test(String(revisionDigest || ""))
+    ) {
+      return { ok: false, reason: "invalid_graph_binding" };
+    }
+    let cleanEvidence;
+    try {
+      cleanEvidence = cloneValue(evidence);
+    } catch {
+      return { ok: false, reason: "invalid_graph_evidence" };
+    }
+    const binding = {
+      schema: "chainlesschain.team-graph-task-projection/v1",
+      runId: String(runId),
+      nodeId: String(nodeId),
+      graphStatus,
+      authorityGeneration: Number(authorityGeneration),
+      eventHead: String(eventHead),
+      revisionDigest: String(revisionDigest),
+      evidence: cleanEvidence,
+    };
+    const projectionDigest = digestValue(binding);
+    const id = this._byKey.get(key);
+    const task = id ? this._tasks.get(id) : null;
+    if (!task) return { ok: false, reason: "not_found" };
+    const prior = task.metadata?.canonicalGraphProjection || null;
+    if (prior?.projectionDigest === projectionDigest) {
+      return {
+        ok: true,
+        idempotent: true,
+        status: task.status,
+        projectionDigest,
+      };
+    }
+    if (
+      prior &&
+      (prior.runId !== binding.runId ||
+        prior.nodeId !== binding.nodeId ||
+        prior.revisionDigest !== binding.revisionDigest ||
+        prior.graphStatus !== binding.graphStatus)
+    ) {
+      return { ok: false, reason: "graph_projection_conflict" };
+    }
+    const snapshot = this._tasks.snapshot();
+    const stored = snapshot.tasks.find((candidate) => candidate.id === task.id);
+    if (!stored || stored.rev !== task.rev) {
+      return { ok: false, reason: "concurrent" };
+    }
+    const projectedAt = Number.isFinite(Number(now))
+      ? Number(now)
+      : this._now();
+    const metadata = {
+      ...stored.metadata,
+      lease: null,
+      canonicalGraphProjection: {
+        ...binding,
+        projectionDigest,
+        projectedAt,
+      },
+    };
+    delete metadata.adjudication;
+    if (terminalStatus === TASK_STATUS.COMPLETED) {
+      metadata.result = {
+        canonicalGraph: true,
+        terminalEvidence: cleanEvidence,
+      };
+      delete metadata.lastError;
+    } else {
+      metadata.lastError = `canonical Graph node settled ${graphStatus}`;
+    }
+    stored.status = terminalStatus;
+    stored.assignee = null;
+    stored.updatedAt = projectedAt;
+    stored.rev += 1;
+    stored.metadata = metadata;
+    stored.history = [
+      ...(stored.history || []),
+      {
+        ts: projectedAt,
+        actor: "graph-kernel",
+        action: "canonical-projection-repaired",
+        changes: ["status", "assignee", "metadata"],
+        graphStatus,
+        projectionDigest,
+      },
+    ];
+    this._tasks = SharedTaskList.restore(snapshot, { now: this._now });
+    this._rebuildIndexes();
+    if (terminalStatus === TASK_STATUS.COMPLETED) {
+      for (const dependent of this._dependentsByKey.get(key) || []) {
+        this._enqueueIfReady(dependent, projectedAt);
+      }
+    }
+    return { ok: true, status: terminalStatus, projectionDigest };
+  }
+
+  applyCanonicalHandoffProjection(
+    key,
+    { handoff: source, targetLease = null, now = this._now() } = {},
+  ) {
+    if (!source || typeof source !== "object") {
+      return { ok: false, reason: "invalid_handoff_projection" };
+    }
+    const id = normalizedHandoffId(source.id, () => null);
+    const fromHolder = normalizedHolder(source.fromHolder);
+    const toHolder = normalizedHolder(source.toHolder);
+    const revisionDigest = normalizedDigest(source.revisionDigest);
+    const authorityDigest = normalizedDigest(source.authorityDigest);
+    const artifactIds = normalizedArtifactIds(source.artifactIds);
+    const status = String(source.status || "");
+    const ttlMs = Number(source.ttlMs);
+    if (
+      !id ||
+      !fromHolder ||
+      !toHolder ||
+      fromHolder === toHolder ||
+      !revisionDigest ||
+      !authorityDigest ||
+      !artifactIds ||
+      !TEAM_CUSTODY_HANDOFF_STATUSES.includes(status) ||
+      !Number.isSafeInteger(ttlMs) ||
+      ttlMs <= 0 ||
+      ttlMs > MAX_HANDOFF_TTL_MS ||
+      source.taskKey !== key ||
+      typeof source.fromLeaseId !== "string" ||
+      source.fromLeaseId.length === 0 ||
+      !["string", "number"].includes(typeof source.fromFence)
+    ) {
+      return { ok: false, reason: "invalid_handoff_projection" };
+    }
+    let preconditions;
+    let summary;
+    try {
+      preconditions = cloneValue(source.preconditions);
+      summary = cloneValue(source.summary);
+    } catch {
+      return { ok: false, reason: "invalid_handoff_projection" };
+    }
+    const idempotencyKey = normalizedHandoffId(
+      source.idempotencyKey,
+      () => null,
+    );
+    if (!idempotencyKey) {
+      return { ok: false, reason: "invalid_handoff_projection" };
+    }
+    const binding = {
+      schema: TEAM_CUSTODY_HANDOFF_SCHEMA,
+      id,
+      taskKey: key,
+      fromHolder,
+      fromLeaseId: source.fromLeaseId,
+      fromFence: source.fromFence,
+      toHolder,
+      revisionDigest,
+      authorityDigest,
+      artifactIds,
+      preconditions,
+      summary,
+      idempotencyKey,
+      ttlMs,
+    };
+    const bindingDigest = digestValue(binding);
+    if (source.bindingDigest && source.bindingDigest !== bindingDigest) {
+      return { ok: false, reason: "handoff_binding_conflict" };
+    }
+    let cleanTargetLease = null;
+    if (status === "committed") {
+      try {
+        cleanTargetLease = cloneValue(targetLease || source.targetLease);
+      } catch {
+        return { ok: false, reason: "invalid_target_lease" };
+      }
+      if (
+        !cleanTargetLease ||
+        cleanTargetLease.holder !== toHolder ||
+        typeof cleanTargetLease.leaseId !== "string" ||
+        cleanTargetLease.leaseId.length === 0 ||
+        !Number.isFinite(Number(cleanTargetLease.expiresAt))
+      ) {
+        return { ok: false, reason: "invalid_target_lease" };
+      }
+    }
+    const taskId = this._byKey.get(key);
+    const task = taskId ? this._tasks.get(taskId) : null;
+    if (!task) return { ok: false, reason: "not_found" };
+    const history = handoffHistory(task);
+    const existing = history.find((entry) => entry.id === id);
+    if (existing && existing.bindingDigest !== bindingDigest) {
+      return { ok: false, reason: "handoff_binding_conflict" };
+    }
+    if (existing && existing.status !== status) {
+      const transitions = {
+        offered: new Set([
+          "accepted",
+          "rejected",
+          "committed",
+          "revoked",
+          "expired",
+        ]),
+        accepted: new Set(["committed", "revoked", "expired"]),
+      };
+      if (!transitions[existing.status]?.has(status)) {
+        return { ok: false, reason: "handoff_projection_regressed" };
+      }
+    }
+    if (existing?.status === status) {
+      return { ok: true, idempotent: true, handoff: cloneValue(existing) };
+    }
+    const projectedAt = Number.isFinite(Number(now))
+      ? Number(now)
+      : this._now();
+    const projected = {
+      ...(existing || binding),
+      ...binding,
+      bindingDigest,
+      expiresAtMs: Number(source.expiresAtMs),
+      status,
+      offeredAt: Number(source.offeredAt),
+      acceptedAt: source.acceptedAt == null ? null : Number(source.acceptedAt),
+      rejectedAt: source.rejectedAt == null ? null : Number(source.rejectedAt),
+      committedAt:
+        source.committedAt == null ? null : Number(source.committedAt),
+      revokedAt: source.revokedAt == null ? null : Number(source.revokedAt),
+      expiredAt: source.expiredAt == null ? null : Number(source.expiredAt),
+      targetStartedAt: existing?.targetStartedAt ?? null,
+      targetSettledAt: existing?.targetSettledAt ?? null,
+      targetSettlement: existing?.targetSettlement ?? null,
+      reason:
+        source.reason == null ? null : String(source.reason).slice(0, 1024),
+      acceptedByAttempt: existing?.acceptedByAttempt ?? null,
+      targetLease:
+        status === "committed"
+          ? cloneValue(existing?.targetLease || cleanTargetLease)
+          : null,
+      canonicalProjectedAt: projectedAt,
+      updatedAt: Number(source.updatedAt) || projectedAt,
+    };
+    if (existing) {
+      history[history.indexOf(existing)] = projected;
+    } else {
+      history.push(projected);
+      while (history.length > MAX_HANDOFF_HISTORY) history.shift();
+    }
+    const snapshot = this._tasks.snapshot();
+    const stored = snapshot.tasks.find((candidate) => candidate.id === task.id);
+    if (!stored || stored.rev !== task.rev) {
+      return { ok: false, reason: "concurrent" };
+    }
+    stored.rev += 1;
+    stored.updatedAt = projectedAt;
+    stored.metadata = { ...stored.metadata, custodyHandoffs: history };
+    if (
+      status === "committed" &&
+      ![TASK_STATUS.COMPLETED, TASK_STATUS.CANCELLED].includes(stored.status)
+    ) {
+      stored.status = TASK_STATUS.IN_PROGRESS;
+      stored.assignee = toHolder;
+      stored.metadata.lease = cloneValue(projected.targetLease);
+    } else if (
+      status === "expired" &&
+      stored.metadata?.lease?.leaseId === binding.fromLeaseId
+    ) {
+      stored.status = TASK_STATUS.PENDING;
+      stored.assignee = null;
+      stored.metadata.lease = null;
+    }
+    stored.history = [
+      ...(stored.history || []),
+      {
+        ts: projectedAt,
+        actor: "graph-kernel",
+        action: "canonical-handoff-projected",
+        changes: ["status", "assignee", "metadata"],
+        handoffId: id,
+        handoffStatus: status,
+      },
+    ];
+    this._tasks = SharedTaskList.restore(snapshot, { now: this._now });
+    this._rebuildIndexes();
+    return { ok: true, handoff: cloneValue(projected) };
+  }
+
   /** Bind a pending adjudication to its immutable durable case evidence. */
   bindAdjudicationCase(key, { caseId, registryDigest, sideEffectDigest } = {}) {
     const id = this._byKey.get(key);

package/src/lib/agent-team/team-agent-stream.js

@@ -7,6 +7,7 @@
  * are never copied into parser state or returned to callers.
  */
 
+import { createHash } from "node:crypto";
 import { TextDecoder } from "node:util";
 
 export const DEFAULT_TEAM_AGENT_MAX_LINE_BYTES = 1024 * 1024;
@@ -96,6 +97,7 @@ export class TeamAgentStreamParser {
   #tokenUsageEvents = 0;
   #usageByIdentity = new Map();
   #sawTerminalResult = false;
+  #terminalResultDigest = null;
   #finished = false;
   #failed = null;
   #finalSummary = null;
@@ -204,6 +206,16 @@ export class TeamAgentStreamParser {
     return this.#copyLiveSummary();
   }
 
+  /**
+   * Return an immutable digest of the exact terminal result record without
+   * retaining or exposing its prompt/result body.
+   */
+  terminalEvidence() {
+    return this.#terminalResultDigest
+      ? Object.freeze({ outputDigest: this.#terminalResultDigest })
+      : null;
+  }
+
   #copyLiveSummary() {
     return {
       provider: this.#provider,
@@ -291,6 +303,9 @@ export class TeamAgentStreamParser {
     }
     if (line.trim() === "") return;
 
+    const lineDigest = `sha256:${createHash("sha256")
+      .update(line, "utf8")
+      .digest("hex")}`;
     let event;
     try {
       event = JSON.parse(line);
@@ -345,6 +360,7 @@ export class TeamAgentStreamParser {
 
     if (event.type === "result") {
       this.#sawTerminalResult = true;
+      this.#terminalResultDigest = lineDigest;
       this.#lastResultProvider =
         typeof event.provider === "string" ? event.provider : this.#provider;
       this.#lastResultModel =