chainlesschain 0.166.6 → 0.166.9

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

@@ -28,6 +28,8 @@ import { createHash, randomUUID } from "node:crypto";
 
 export const DEFAULT_LEASE_TTL_MS = 60000;
 export const DEFAULT_MAX_ATTEMPTS = 3;
+export const DEFAULT_QUEUE_WAIT_SLO_MS = 10_000;
+export const DEFAULT_AGING_WINDOW_MS = 2_500;
 export const ADJUDICATION_DECISIONS = Object.freeze({
   RETRY: "retry",
   ACCEPT: "accept",
@@ -154,11 +156,21 @@ export class TaskLeaseRegistry {
     now = () => Date.now(),
     defaultTtlMs = DEFAULT_LEASE_TTL_MS,
     maxAttempts = DEFAULT_MAX_ATTEMPTS,
+    queueWaitSloMs = DEFAULT_QUEUE_WAIT_SLO_MS,
+    agingWindowMs = DEFAULT_AGING_WINDOW_MS,
     leaseEpoch = randomUUID(),
   } = {}) {
     this._now = typeof now === "function" ? now : () => now;
     this.defaultTtlMs = defaultTtlMs > 0 ? defaultTtlMs : DEFAULT_LEASE_TTL_MS;
     this.maxAttempts = maxAttempts > 0 ? maxAttempts : DEFAULT_MAX_ATTEMPTS;
+    this.queueWaitSloMs =
+      Number.isFinite(queueWaitSloMs) && queueWaitSloMs > 0
+        ? Math.floor(queueWaitSloMs)
+        : DEFAULT_QUEUE_WAIT_SLO_MS;
+    this.agingWindowMs =
+      Number.isFinite(agingWindowMs) && agingWindowMs > 0
+        ? Math.floor(agingWindowMs)
+        : DEFAULT_AGING_WINDOW_MS;
     this._leaseEpoch = String(leaseEpoch || randomUUID());
     this._leaseSequence = 0;
     this._tasks = new SharedTaskList({ groupId, now: this._now });
@@ -175,6 +187,11 @@ export class TaskLeaseRegistry {
       ["low", new Set()],
     ]);
     this._leasedKeys = new Set();
+    this._priorityInheritanceCache = null;
+    // The ready timestamp is part of the durable scheduler contract. Restarts
+    // must not reset a task's queue-wait clock and thereby reintroduce
+    // starvation under a sustained high-priority stream.
+    this._readySinceByKey = new Map();
   }
 
   /**
@@ -300,6 +317,7 @@ export class TaskLeaseRegistry {
       }
       dependents.add(key);
     }
+    this._priorityInheritanceCache = null;
     this._enqueueIfReady(key);
     return { ok: true, key, id: created.id };
   }
@@ -325,6 +343,9 @@ export class TaskLeaseRegistry {
       attempts: t.metadata?.attempts || 0,
       lease: lease ? { ...lease } : null,
       assignee: t.assignee,
+      createdBy: t.createdBy ?? null,
+      createdAt: t.createdAt,
+      updatedAt: t.updatedAt,
       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
@@ -402,12 +423,75 @@ export class TaskLeaseRegistry {
     this._requeueExpiredLeases(now);
     const excluded =
       excludeKeys instanceof Set ? excludeKeys : new Set(excludeKeys || []);
+    let selected = null;
     for (const priority of ["high", "normal", "low"]) {
       for (const key of this._readyByPriority.get(priority)) {
-        if (!excluded.has(key)) return key;
+        if (excluded.has(key)) continue;
+        const scheduling = this.schedulingPriority(key, { now });
+        const bothUrgent =
+          scheduling.sloUrgent && selected?.scheduling?.sloUrgent;
+        if (
+          !selected ||
+          (bothUrgent &&
+            scheduling.queueWaitMs > selected.scheduling.queueWaitMs) ||
+          (!bothUrgent &&
+            (scheduling.total > selected.scheduling.total ||
+              (scheduling.total === selected.scheduling.total &&
+                scheduling.queueWaitMs > selected.scheduling.queueWaitMs)))
+        ) {
+          selected = { key, scheduling };
+        }
+        // FIFO inside one priority class is sufficient: later members cannot
+        // have waited longer than the first non-excluded member.
+        break;
       }
     }
-    return null;
+    return selected?.key || null;
+  }
+
+  /**
+   * Explain the effective scheduling priority for one task.
+   *
+   * A blocked high-priority descendant donates its priority transitively to
+   * the dependency that can unblock it. Ready tasks also age, and once they
+   * consume 75% of the declared queue-wait SLO they enter an urgent band that
+   * outranks newly arriving work. This makes the SLO enforceable rather than
+   * leaving aging as telemetry-only decoration.
+   */
+  schedulingPriority(key, { now = this._now() } = {}) {
+    const task = this.getTask(key);
+    if (!task) return null;
+    const base = this._priorityScore(task.priority);
+    const readySince = this._readySinceByKey.get(key);
+    const queueWaitMs = Math.max(
+      0,
+      Number(now) -
+        Number(
+          readySince ??
+            task.createdAt ??
+            (Number.isFinite(now) ? Number(now) : 0),
+        ),
+    );
+    const inheritance = this._priorityInheritanceFor(key);
+    const donatedBase = Math.max(base, inheritance.donatedBase);
+    const criticalPathBoost = inheritance.criticalPathBoost;
+    const aging = Math.min(1000, Math.floor(queueWaitMs / this.agingWindowMs));
+    const sloUrgent = queueWaitMs >= Math.floor(this.queueWaitSloMs * 0.75);
+    const sloBoost = sloUrgent ? 10_000 : 0;
+    return Object.freeze({
+      base,
+      donation: Math.max(0, donatedBase - base),
+      aging,
+      criticalPathBoost,
+      sloBoost,
+      sloUrgent,
+      total: donatedBase + aging + Math.min(1000, criticalPathBoost) + sloBoost,
+      queueWaitMs,
+      queueWaitSloMs: this.queueWaitSloMs,
+      readySince: Number(readySince ?? task.createdAt ?? now),
+      queueWaitDeadlineAt:
+        Number(readySince ?? task.createdAt ?? now) + this.queueWaitSloMs,
+    });
   }
 
   /**
@@ -1465,6 +1549,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);
@@ -1556,6 +1954,9 @@ export class TaskLeaseRegistry {
       registry: {
         defaultTtlMs: this.defaultTtlMs,
         maxAttempts: this.maxAttempts,
+        queueWaitSloMs: this.queueWaitSloMs,
+        agingWindowMs: this.agingWindowMs,
+        readySinceByKey: Array.from(this._readySinceByKey.entries()),
         byKey: Array.from(this._byKey.entries()),
       },
       tasks: this._tasks.snapshot(),
@@ -1567,9 +1968,12 @@ export class TaskLeaseRegistry {
       now,
       defaultTtlMs: snapshot?.registry?.defaultTtlMs,
       maxAttempts: snapshot?.registry?.maxAttempts,
+      queueWaitSloMs: snapshot?.registry?.queueWaitSloMs,
+      agingWindowMs: snapshot?.registry?.agingWindowMs,
     });
     reg._tasks = SharedTaskList.restore(snapshot.tasks, { now: reg._now });
     reg._byKey = new Map(snapshot?.registry?.byKey || []);
+    reg._readySinceByKey = new Map(snapshot?.registry?.readySinceByKey || []);
     reg._rebuildIndexes();
     return reg;
   }
@@ -1584,6 +1988,7 @@ export class TaskLeaseRegistry {
         patch,
         actor: patch.assignee,
       });
+      if (patch.status !== undefined) this._priorityInheritanceCache = null;
       return true;
     } catch {
       // ConcurrencyError (rev changed under us) — caller re-reads and retries.
@@ -1655,8 +2060,72 @@ export class TaskLeaseRegistry {
         : "normal";
   }
 
-  _removeReady(key) {
+  _priorityScore(priority) {
+    return priority === "high" ? 2 : priority === "low" ? 0 : 1;
+  }
+
+  _priorityInheritanceFor(key) {
+    if (!this._priorityInheritanceCache) {
+      const keys = [...this._byKey.keys()];
+      const indegree = new Map(
+        keys.map((candidate) => [
+          candidate,
+          (this._depsByKey.get(candidate) || []).filter((dependency) =>
+            this._byKey.has(dependency),
+          ).length,
+        ]),
+      );
+      const ready = keys.filter((candidate) => indegree.get(candidate) === 0);
+      const order = [];
+      for (let index = 0; index < ready.length; index += 1) {
+        const candidate = ready[index];
+        order.push(candidate);
+        for (const dependent of this._dependentsByKey.get(candidate) || []) {
+          if (!indegree.has(dependent)) continue;
+          indegree.set(dependent, indegree.get(dependent) - 1);
+          if (indegree.get(dependent) === 0) ready.push(dependent);
+        }
+      }
+      const inherited = new Map();
+      for (const candidate of order.reverse()) {
+        const task = this.getTask(candidate);
+        let donatedBase = this._priorityScore(task?.priority);
+        let criticalPathBoost = 0;
+        for (const dependent of this._dependentsByKey.get(candidate) || []) {
+          const dependentTask = this.getTask(dependent);
+          if (
+            !dependentTask ||
+            [TASK_STATUS.COMPLETED, TASK_STATUS.CANCELLED].includes(
+              dependentTask.status,
+            )
+          ) {
+            continue;
+          }
+          const child = inherited.get(dependent) || {
+            donatedBase: this._priorityScore(dependentTask.priority),
+            criticalPathBoost: 0,
+          };
+          donatedBase = Math.max(donatedBase, child.donatedBase);
+          criticalPathBoost = Math.max(
+            criticalPathBoost,
+            child.criticalPathBoost + 1,
+          );
+        }
+        inherited.set(candidate, { donatedBase, criticalPathBoost });
+      }
+      this._priorityInheritanceCache = inherited;
+    }
+    return (
+      this._priorityInheritanceCache.get(key) || {
+        donatedBase: this._priorityScore(this.getTask(key)?.priority),
+        criticalPathBoost: 0,
+      }
+    );
+  }
+
+  _removeReady(key, { clearWait = true } = {}) {
     for (const queue of this._readyByPriority.values()) queue.delete(key);
+    if (clearWait) this._readySinceByKey.delete(key);
   }
 
   _dependenciesCompleted(key) {
@@ -1697,6 +2166,9 @@ export class TaskLeaseRegistry {
       return false;
     }
     this._leasedKeys.delete(key);
+    if (!this._readySinceByKey.has(key)) {
+      this._readySinceByKey.set(key, Number(now));
+    }
     this._readyByPriority.get(this._priorityFor(task)).add(key);
     return true;
   }
@@ -1712,6 +2184,7 @@ export class TaskLeaseRegistry {
   }
 
   _rebuildIndexes() {
+    const restoredReadySince = new Map(this._readySinceByKey || []);
     this._depsByKey = new Map();
     this._dependentsByKey = new Map();
     this._readyByPriority = new Map([
@@ -1720,6 +2193,8 @@ export class TaskLeaseRegistry {
       ["low", new Set()],
     ]);
     this._leasedKeys = new Set();
+    this._readySinceByKey = restoredReadySince;
+    this._priorityInheritanceCache = null;
     for (const task of this._tasks.list()) {
       const key = task.metadata?.key;
       const dependencies = task.metadata?.dependsOn || [];
@@ -1738,5 +2213,14 @@ export class TaskLeaseRegistry {
     }
     const now = this._now();
     for (const key of this._byKey.keys()) this._enqueueIfReady(key, now);
+    for (const priority of ["high", "normal", "low"]) {
+      const ordered = [...this._readyByPriority.get(priority)].sort(
+        (left, right) =>
+          (this._readySinceByKey.get(left) || 0) -
+            (this._readySinceByKey.get(right) || 0) ||
+          left.localeCompare(right),
+      );
+      this._readyByPriority.set(priority, new Set(ordered));
+    }
   }
 }

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 =