@sema-agent/core 7.5.2 → 7.6.1

package/dist/orchestration/run-workflow-tool.js

@@ -322,10 +322,10 @@ export async function createRunWorkflowTool(d) {
             "• Research/audit workflows: document and file claims are HYPOTHESES, not evidence — add a VERIFY " +
             "stage whose agents EXECUTE (run the command, the test, the reproducer) and cross-check claims " +
             "against actual output before the synthesis stage reports them as fact.\n" +
-            "• r.status: agent() does NOT throw when the sub-agent FAILS — it RETURNS the result with r.status " +
-            "('completed' on success; 'failed'/'blocked'/etc otherwise, with the failure text in r.result). ALWAYS " +
-            "check r.status before building on a result, and GATE later phases on it — e.g. " +
-            "`const impl = await agent({ objective: '…' }, { label: 'implement-fix' }); if (impl.status !== 'completed') return { failed: 'implement', why: impl.result }` " +
+            "• r.terminal.kind: agent() does NOT throw when the sub-agent FAILS — it RETURNS the result with r.terminal " +
+            "({ kind: 'completed' } on success; kind 'failed' (with r.terminal.code / r.terminal.message) / 'blocked' (r.terminal.reason) / 'paused' otherwise, " +
+            "with any failure text also in r.result). ALWAYS check r.terminal.kind before building on a result, and GATE later phases on it — e.g. " +
+            "`const impl = await agent({ objective: '…' }, { label: 'implement-fix' }); if (impl.terminal.kind !== 'completed') return { failed: 'implement', why: impl.result }` " +
             "— running later phases on a failed prerequisite burns tokens on garbage.\n" +
             "• phase (two forms, both fine): bare marker — phase('Scan'); groups every later agent() under 'Scan' " +
             "until the next phase() call. Scoped — await phase('Fix', async () => { ...agents... }); groups just the " +

package/dist/orchestration/workflow-governance.d.ts

@@ -194,10 +194,10 @@ export interface ResourceClampNote {
  * `restoreGatedTools` / `readFace` / … — for exactly the children an untrusted script can route to
  * the overlay (`isolation: "worktree"`), own-`undefined` keys included (a spread copies them; the
  * old `=== null` face drop missed that half). One rule at the one merge point: a new baseline key
- * is safe with no list to extend. The single exception is {@link NULL_VALUED_BASELINE_KEYS}
- * (`checkpointStore: null` — the deployment disarming durable suspend for isolated children is a
- * capability removal it must be able to spell). Explicit non-nullish overlay values keep winning
- * wholesale — the documented deployment override.
+ * is safe with no list to extend, and there is no exception list — the one key that used to give
+ * `null` a meaning of its own (`checkpointStore`, the durable off switch) now spells it as the word
+ * `"disabled"`, an ordinary non-nullish value the rule already keeps. Explicit non-nullish overlay
+ * values keep winning wholesale — the documented deployment override.
  *
  * ACCEPTED COST, stated (adversarial-review round 2): the rule is direction-blind — a CAPABILITY
  * key's out-of-type overlay `null` used to WITHHOLD the base value by the same spread accident

package/dist/orchestration/workflow-governance.js

@@ -4,6 +4,7 @@ import { sanitizeUntrustedText } from "../core/untrusted-text.js";
 import { compileReadDeny } from "../tools/fs/read-deny.js";
 import { WorkflowScriptError } from "./workflow-meta.js";
 import { uuidv7 } from "../engine/session/uuid.js";
+import { retiredCheckpointStoreNull } from "../core/checkpoint-store.js";
 export class WorkflowModelNotAllowedError extends Error {
     modelName;
     code = "workflow.model_not_allowed";
@@ -79,12 +80,13 @@ export function emitIgnoredAgentOptionsNotice(total, sample, accepted, onNotice)
     }
 }
 const VALID_THINKING = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-const NULL_VALUED_BASELINE_KEYS = new Set(["checkpointStore"]);
 export function overlayWorktreeBaseline(base, worktreeBase) {
     let overlay = worktreeBase;
     for (const key of Object.keys(worktreeBase)) {
         const v = worktreeBase[key];
-        if (v !== undefined && (v !== null || NULL_VALUED_BASELINE_KEYS.has(key)))
+        if (key === "checkpointStore" && v === null)
+            throw retiredCheckpointStoreNull();
+        if (v !== undefined && v !== null)
             continue;
         if (overlay === worktreeBase)
             overlay = { ...worktreeBase };

package/dist/orchestration/workflow-primitives.d.ts

@@ -33,7 +33,7 @@ export interface WorkflowGovernance {
  * `agent` primitive is GOVERNED when `governance` is set (LLM-authored), else a trusted pass-through.
  */
 export declare function buildWorkflowPrimitives(ctx: WorkflowRunContext, governance?: WorkflowGovernance, onAgentSpawn?: (handle: WorkflowAgentHandle) => void, parentThinking?: () => TaskSpec["thinking"], parentPrincipal?: string, 
-/** ruled 2026-08-04 — the host run set `TaskSpec.checkpointStore: null` (the per-run durable off
+/** ruled 2026-08-04 — the host run set `TaskSpec.checkpointStore: "disabled"` (the per-run durable off
  *  switch). Every agent this workflow spawns inherits it; see the injection below. */
 parentCheckpointStoreDisabled?: boolean, 
 /** 5.30 merge-rescan (design/199 parity gap) — the host run's RESOLVED read-face containment

package/dist/orchestration/workflow-primitives.js

@@ -83,7 +83,7 @@ export function buildWorkflowPrimitives(ctx, governance, onAgentSpawn, parentThi
             childSpec.principal = parentPrincipal;
         }
         if (parentCheckpointStoreDisabled === true) {
-            childSpec.checkpointStore = null;
+            childSpec.checkpointStore = "disabled";
         }
         if (parentReadFace) {
             const pf = parentReadFace();

package/dist/orchestration/workflow.d.ts

@@ -1,5 +1,5 @@
 import type { TSchema } from "typebox";
-import type { Runner } from "../core/runner/runtask.js";
+import type { RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { AgentDefinition, TaskEvent, TaskResult, TaskSpec } from "../core/types.js";
 import type { WorkflowRunStore } from "../core/workflow-run-store.js";
 import type { WorkflowJournalStore, ResumeClaimArgs } from "../core/workflow-journal-store.js";
@@ -111,6 +111,17 @@ export declare class WorkflowResultTooLargeError extends Error {
     readonly code = "workflow.result_too_large";
     constructor(size: number, max: number);
 }
+/** A resume journal entry whose result carries no terminal cause — a journal written before
+ *  `TaskResult.terminal` existed, or a malformed entry — is INCOMPATIBLE, and the resume is refused
+ *  before any work is dispatched. The alternative (letting the entry diverge into a live re-run) would
+ *  execute the already-completed prefix again, side effects included; a schema mismatch is never a
+ *  permission to rerun finished work. Start a fresh run instead of resuming such a journal. */
+export declare class WorkflowJournalIncompatibleError extends Error {
+    readonly fromRunId: string;
+    readonly ordinal: number;
+    readonly code = "workflow.journal_incompatible";
+    constructor(fromRunId: string, ordinal: number);
+}
 /**
  * A TRUSTED, run-scoped internal channel carrying the workflow **nesting depth** across a process boundary
  * (design/98 §0.1 BLOCKER3). It is NOT a `TaskSpec` field and NOT a `run_workflow` tool param — a worker or
@@ -441,7 +452,7 @@ export interface RunWorkflowOptions {
      *  (`RunInternals.inheritedGate`) on both spawn legs (`agent()` and `agentStream()`). Set by the
      *  `run_workflow` tool wiring; a directly-started workflow may pass its own. Absent ⇒ children run
      *  under only their own gates (pre-seam behavior). TRUSTED: never a script/model argument. */
-    inheritedGate?: import("../core/runner/prepare-task.js").InheritedGate;
+    inheritedGate?: import("../core/runner/contracts.js").InheritedGate;
     /** RB-201 FO-3 (workflow lane) — the session's auto-mode classifier, consulted BEFORE each script-spawned
      *  child starts (objective + toolset + output schema, finalized). The delegation-tool lane reviews its
      *  children at one shared point; a workflow's children reach `runner.runTask` through this module instead,
@@ -542,11 +553,11 @@ export declare const workflowResumeClaimFallback: {
  * `done` rejects. `cancel(reason)` aborts the whole run. A nesting/validation violation throws SYNCHRONOUSLY
  * from this call (before any handle exists). Thin composition over `runner.runTask` — no Runner changes.
  */
-export declare function startWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): WorkflowHandle<T>;
+export declare function startWorkflow<T>(runner: RunnerSelfSeat, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): WorkflowHandle<T>;
 /**
  * Run a workflow to completion (design/97 S1a) — the thin await over {@link startWorkflow}: returns the
  * script's value + the assembled {@link WorkflowRun}. A synchronous nesting/validation throw from
  * `startWorkflow` becomes a rejected promise here (this function is `async`), preserving the original
  * `runWorkflow` contract (`await runWorkflow(...)` rejects rather than throwing synchronously).
  */
-export declare function runWorkflow<T>(runner: Runner, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): Promise<RunWorkflowResult<T>>;
+export declare function runWorkflow<T>(runner: RunnerSelfSeat, fn: (ctx: WorkflowRunContext) => Promise<T>, opts?: RunWorkflowOptions, internals?: WorkflowInternals): Promise<RunWorkflowResult<T>>;

package/dist/orchestration/workflow.js

@@ -3,6 +3,8 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
 import { availableParallelism } from "node:os";
 import { uuidv7 } from "../internal/harness.js";
+import { TERMINAL_CAUSE_IS_REPLAYABLE, isTerminalCauseKind } from "../core/terminal-cause.js";
+import { terminalProjection } from "../core/runner/terminal-projection.js";
 import { builtinAgentDefinitions } from "../agents/builtin-agents.js";
 import { GENERAL_PURPOSE_SUBAGENT_TYPE, markerFragment } from "../agents/subagent.js";
 import { combinePolicies, createAllowDenyPolicy } from "../core/tool-policy.js";
@@ -200,6 +202,19 @@ export class WorkflowResultTooLargeError extends Error {
         this.name = "WorkflowResultTooLargeError";
     }
 }
+export class WorkflowJournalIncompatibleError extends Error {
+    fromRunId;
+    ordinal;
+    code = "workflow.journal_incompatible";
+    constructor(fromRunId, ordinal) {
+        super(`startWorkflow: resume from "${fromRunId}" was REFUSED — journal entry #${ordinal} carries no terminal cause ` +
+            "(a journal written before TaskResult.terminal, or a malformed entry). Completed work must not run again; " +
+            "start a fresh run instead of resuming this journal.");
+        this.fromRunId = fromRunId;
+        this.ordinal = ordinal;
+        this.name = "WorkflowJournalIncompatibleError";
+    }
+}
 const workflowDepthStore = new AsyncLocalStorage();
 function currentWorkflowDepth() {
     return workflowDepthStore.getStore()?.depth ?? 0;
@@ -768,9 +783,12 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     };
     let journalTail = Promise.resolve();
     const JOURNAL_DRAIN_MAX_MS = 5_000;
-    const journalDurableResult = (result) => result.status !== "completed" && typeof result.errorMessage === "string" && result.errorMessage !== ""
-        ? { ...result, errorMessage: boundedRedactedSummary(result.errorMessage, MAX_TRANSCRIPT_CHARS) }
-        : result;
+    const journalDurableResult = (result) => {
+        const t = result.terminal;
+        if (t === undefined || t.kind !== "failed" || typeof t.message !== "string" || t.message === "")
+            return result;
+        return { ...result, terminal: { ...t, message: boundedRedactedSummary(t.message, MAX_TRANSCRIPT_CHARS) } };
+    };
     const journalAppend = async (callKey, result, label) => {
         const dbg = typeof process !== "undefined" && process.env?.SEMA_DEBUG_WORKFLOW_JOURNAL === "1";
         if (!journalStore) {
@@ -972,16 +990,17 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         }
         emitRunLog(`resume: replay stopped at agent #${ordinal} (${reason}) — this call and every later call run live.`);
     };
-    const settleAgentError = (rec, result, label, rawOutput) => {
-        if (result.status !== "completed") {
-            if (result.errorCode !== undefined)
-                rec.errorCode = result.errorCode;
-            if (result.errorMessage !== undefined && result.errorMessage !== "") {
-                rec.errorMessage = boundedRedactedSummary(result.errorMessage, MAX_TRANSCRIPT_CHARS);
+    const settleAgentError = (rec, terminal, label, rawOutput) => {
+        const face = terminalProjection(terminal);
+        if (terminal.kind !== "completed") {
+            if (face.errorCode !== undefined)
+                rec.errorCode = face.errorCode;
+            if (face.errorMessage !== undefined && face.errorMessage !== "") {
+                rec.errorMessage = boundedRedactedSummary(face.errorMessage, MAX_TRANSCRIPT_CHARS);
             }
-            emitRunLog(`[${label}] ${result.status}${result.errorCode !== undefined ? ` (${result.errorCode})` : ""}${rec.errorMessage !== undefined ? `: ${rec.errorMessage.slice(0, 300)}` : ""}`);
+            emitRunLog(`[${label}] ${face.status}${face.errorCode !== undefined ? ` (${face.errorCode})` : ""}${rec.errorMessage !== undefined ? `: ${rec.errorMessage.slice(0, 300)}` : ""}`);
         }
-        const output = rawOutput || (result.status !== "completed" ? (rec.errorMessage ?? "") : "");
+        const output = rawOutput || (terminal.kind !== "completed" ? (rec.errorMessage ?? "") : "");
         rec.output = output;
         return output;
     };
@@ -1128,14 +1147,14 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
     const settleAgentResult = async (rec, result, activityTail, agentOpts, journal) => {
         const s = result.stats;
         accumulateStats(result, true);
-        rec.status = result.status === "completed" ? "completed" : "failed";
-        rec.taskStatus = result.status;
+        rec.status = result.terminal.kind === "completed" ? "completed" : "failed";
+        rec.taskStatus = terminalProjection(result.terminal).status;
         if (result.sessionId)
             rec.sessionId = result.sessionId;
         setLegRunId(rec, result);
         rec.endedAt = now();
         rec.stats = { tokens: s.tokens ?? 0, turns: s.turns ?? 0, costMicroUsd: s.costMicroUsd };
-        const output = settleAgentError(rec, result, rec.label, boundedRedactedSummary(result.structuredOutput ?? result.result, MAX_TRANSCRIPT_CHARS));
+        const output = settleAgentError(rec, result.terminal, rec.label, boundedRedactedSummary(result.structuredOutput ?? result.result, MAX_TRANSCRIPT_CHARS));
         if (result.stats.toolCalls !== undefined)
             rec.toolCalls = result.stats.toolCalls;
         if (activityTail.length > 0)
@@ -1149,7 +1168,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         else {
             void journalAppend(rec.callKey, result, rec.label).catch(() => undefined);
         }
-        if (agentOpts.schema && result.status === "completed" && result.structuredOutput === undefined) {
+        if (agentOpts.schema && result.terminal.kind === "completed" && result.structuredOutput === undefined) {
             throw new WorkflowAgentSchemaError(rec.label, result);
         }
     };
@@ -1165,7 +1184,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             const { label, phase, phaseInstance, groupId, inheritedModelSnap, callKey, prompt, model } = prepareAgentCall(spec, agentOpts);
             if (opts.resumeFromRunId !== undefined && !diverged) {
                 const cached = replayByOrdinal[run.agents.length];
-                if (cached && cached.callKey === callKey && cached.result.status === "completed") {
+                if (cached && cached.callKey === callKey && TERMINAL_CAUSE_IS_REPLAYABLE[cached.result.terminal.kind]) {
                     if (finalized)
                         return cached.result;
                     const r = cached.result;
@@ -1181,8 +1200,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         prompt,
                         ...(replayModel !== undefined ? { model: replayModel } : {}),
                         replayed: true,
-                        status: r.status === "completed" ? "completed" : "failed",
-                        taskStatus: r.status,
+                        status: r.terminal.kind === "completed" ? "completed" : "failed",
+                        taskStatus: terminalProjection(r.terminal).status,
                         ...(r.sessionId ? { sessionId: r.sessionId } : {}),
                         ...(r.runId ? { taskRunId: r.runId } : {}),
                         queuedAt: at,
@@ -1204,7 +1223,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     accumulateStats(r, false);
                     void persist("update");
                     await journalAppend(callKey, r);
-                    if (agentOpts.schema && r.status === "completed" && r.structuredOutput === undefined) {
+                    if (agentOpts.schema && r.terminal.kind === "completed" && r.structuredOutput === undefined) {
                         throw new WorkflowAgentSchemaError(label, r);
                     }
                     return r;
@@ -1217,9 +1236,9 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             : "no journal entry at this ordinal (never recorded, e.g. an oversize result under a pre-tombstone engine, or dropped)"
                     : cached.callKey !== callKey
                         ? "the call key changed — the script or its args differ here"
-                        : cached.result.errorCode === JOURNAL_OVERSIZE_ERROR_CODE
+                        : cached.result.terminal?.kind === "failed" && cached.result.terminal.code === JOURNAL_OVERSIZE_ERROR_CODE
                             ? "the prior result exceeded the journal size cap and was never cached"
-                            : `the journaled result was ${cached.result.status}, not completed`);
+                            : `the journaled result was ${cached.result.terminal?.kind ?? "(no terminal record)"}, not completed`);
                 diverged = true;
             }
             if (budgetTotal !== null && spent() >= budgetTotal) {
@@ -1379,7 +1398,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         }
                         throw new Error("workflow aborted");
                     }
-                    if (stallFired && attemptResult?.status !== "completed") {
+                    if (stallFired && attemptResult?.terminal.kind !== "completed") {
                         if (attemptResult !== undefined && !finalized)
                             accumulateStats(attemptResult, true);
                         if (attemptResult !== undefined && !finalized)
@@ -1403,7 +1422,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                         throw attemptError;
                     result = attemptResult;
                     const durationMs = now() - attemptStart;
-                    const degraded = result.status === "completed" &&
+                    const degraded = result.terminal.kind === "completed" &&
                         result.structuredOutput === undefined &&
                         (result.stats.outputTokens ?? Number.POSITIVE_INFINITY) < 50 &&
                         lastStopReason === undefined &&
@@ -1451,14 +1470,15 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     if (salvaged?.runId === undefined)
                         delete rec.taskRunId;
                     if (salvaged !== undefined) {
-                        rec.taskStatus = salvaged.status;
+                        const salvagedFace = terminalProjection(salvaged.terminal);
+                        rec.taskStatus = salvagedFace.status;
                         if (salvaged.sessionId)
                             rec.sessionId = salvaged.sessionId;
                         setLegRunId(rec, salvaged);
-                        if (salvaged.errorCode !== undefined)
-                            rec.errorCode = salvaged.errorCode;
-                        if (salvaged.errorMessage !== undefined && salvaged.errorMessage !== "")
-                            rec.errorMessage = boundedRedactedSummary(salvaged.errorMessage, MAX_TRANSCRIPT_CHARS);
+                        if (salvagedFace.errorCode !== undefined)
+                            rec.errorCode = salvagedFace.errorCode;
+                        if (salvagedFace.errorMessage !== undefined && salvagedFace.errorMessage !== "")
+                            rec.errorMessage = boundedRedactedSummary(salvagedFace.errorMessage, MAX_TRANSCRIPT_CHARS);
                         rec.output = boundedRedactedSummary(salvaged.structuredOutput ?? salvaged.result, MAX_TRANSCRIPT_CHARS) || (rec.errorMessage ?? "");
                         rec.stats = { tokens: salvaged.stats.tokens ?? 0, turns: salvaged.stats.turns ?? 0, costMicroUsd: salvaged.stats.costMicroUsd };
                     }
@@ -1479,10 +1499,12 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     const journaled = journalAppend(callKey, salvaged ?? {
                         taskId: callKey,
                         sessionId: "",
-                        status: "failed",
                         result: boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500),
-                        ...(err instanceof WorkflowAgentBlockedError ? { errorCode: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } : {}),
-                        ...(err instanceof WorkflowBudgetExceededError ? { errorCode: err.code } : {}),
+                        terminal: {
+                            kind: "failed",
+                            ...(err instanceof WorkflowAgentBlockedError ? { code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE } : err instanceof WorkflowBudgetExceededError ? { code: err.code } : {}),
+                            message: boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500),
+                        },
                         stats: { turns: 0, tokens: 0, costMicroUsd: 0 },
                     }, label).catch(() => undefined);
                     if (!(err instanceof WorkflowBudgetExceededError && rec.startedAt === undefined))
@@ -1496,7 +1518,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
             }
             if (finalized)
                 return result;
-            if (isDurablePause(result.status)) {
+            if (isDurablePause(result.terminal)) {
                 result = mapNestedSuspend(result);
             }
             await settleAgentResult(rec, result, activityTail, agentOpts, "awaited");
@@ -1548,9 +1570,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 void journalAppend(callKey, {
                     taskId: callKey,
                     sessionId: "",
-                    status: "failed",
+                    terminal: { kind: "failed", code: refusal.code, message: boundedRedactedSummary(refusal.message, 500) },
                     result: boundedRedactedSummary(refusal.message, 500),
-                    errorCode: refusal.code,
                     stats: { turns: 0, tokens: 0, costMicroUsd: 0 },
                 }).catch(() => undefined);
                 throw refusal;
@@ -1607,9 +1628,8 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     void journalAppend(callKey, {
                         taskId: callKey,
                         sessionId: "",
-                        status: "failed",
+                        terminal: { kind: "failed", code: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE, message: boundedRedactedSummary(err.message, 500) },
                         result: boundedRedactedSummary(err.message, 500),
-                        errorCode: WORKFLOW_SPAWN_BLOCKED_ERROR_CODE,
                         stats: { turns: 0, tokens: 0, costMicroUsd: 0 },
                     }).catch(() => undefined);
                 }
@@ -1658,7 +1678,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                     void journalAppend(callKey, {
                         taskId: callKey,
                         sessionId: "",
-                        status: "failed",
+                        terminal: { kind: "failed", message: boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500) },
                         result: boundedRedactedSummary(err instanceof Error ? err.message : String(err), 500),
                         stats: { turns: partialSpend?.turns ?? 0, tokens: partialSpend?.tokens ?? 0, costMicroUsd: partialSpend?.costMicroUsd ?? 0 },
                     }).catch(() => undefined);
@@ -1670,7 +1690,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                 releaseOnce();
                 if (finalized)
                     return result;
-                if (isDurablePause(result.status)) {
+                if (isDurablePause(result.terminal)) {
                     result = mapNestedSuspend(result);
                 }
                 await settleAgentResult(rec, result, activityTail, agentOpts, "best-effort");
@@ -1828,8 +1848,13 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
                             "state (or stop it) and resume again.");
                     }
                     const entries = await journalStore.load(opts.resumeFromRunId, scope);
-                    for (const e of entries)
+                    for (const e of entries) {
+                        const t = e.result?.terminal;
+                        if (t === null || typeof t !== "object" || !isTerminalCauseKind(t.kind)) {
+                            throw new WorkflowJournalIncompatibleError(clampRunIdText(opts.resumeFromRunId), callKeyOrdinal(e.callKey));
+                        }
                         replayByOrdinal[callKeyOrdinal(e.callKey)] = e;
+                    }
                     run.resume = {
                         fromRunId: clampRunIdText(opts.resumeFromRunId),
                         journalEntries: entries.length,

package/dist/prompts/supervisor.d.ts

@@ -49,7 +49,7 @@ export declare const SUPERVISOR_PROMPT = "You are a supervisor \u2014 the delega
  *  This block is strategy-blind (it is composed from the prompt context, which carries no strategy
  *  fact), so it must not promise the arm that only one strategy delivers. */
 export declare const ORCHESTRATION_GUIDANCE_DEFERRED = "You can author and run your own WORKFLOW via the Workflow tool (multi-agent orchestration). Its schema and how-to are deferred: when a task genuinely needs orchestration, activate the tool (see the deferred-tools note) and work from what the activation returns.";
-export declare const ORCHESTRATION_GUIDANCE = "You can author and run your own WORKFLOW via the Workflow tool \u2014 a\ndeterministic JS script that spawns and coordinates sub-agents. Use it to be more thorough (decompose and\ncover in parallel), more confident (independent perspectives + adversarial checks before committing), or to\nhandle scale one context can't hold. This is a power tool: reach for it on a SUBSTANTIAL task that genuinely\ndecomposes \u2014 for a simple or sequential task, just do the work directly. Over-orchestrating a trivial task\nwastes tokens and adds latency.\n\nHow a workflow script works (the contract):\n- It begins with `export const meta = { name, description, phases }` \u2014 a PURE LITERAL (no variables, calls,\n  or template strings). Use the same phase titles in meta.phases as in your phase() calls and in each\n  agent's opts `phase`.\n- \uD83D\uDD34 After the meta line, write the body as TOP-LEVEL async statements \u2014 the primitives are already in\n  scope. Do NOT wrap the body in `export default`, a function, or a `body()` method; do NOT use\n  `import`/`require`; do NOT put the script inside markdown code fences. End with `return <value>`.\n  The script IS the function body. A complete example \u2014 copy this SHAPE exactly:\n\n      export const meta = { name: 'risk-scan', description: 'list risks in parallel', phases: [{ title: 'scan' }] }\n      const results = await parallel([\n        () => agent({ objective: 'Name one risk of X. Reply in one short sentence.' }, { label: 'scan-risk-a', phase: 'scan' }),\n        () => agent({ objective: 'Name a DIFFERENT risk of X. Reply in one short sentence.' }, { label: 'scan-risk-b', phase: 'scan' }),\n      ])\n      return results.filter((r) => r && r.status === 'completed').map((r) => r.result)\n\n- The body is async and uses these injected primitives:\n  - agent(spec, opts?) \u2014 run one sub-agent. spec is { objective: string (USE `objective`, not `goal`),\n    modelName?, thinking?, systemPrompt? }; opts is { schema?, label?, phase?, isolation? } (schema goes in\n    OPTS, not in spec). ALWAYS pass a short kebab-case `label` naming what THIS agent does (e.g.\n    { label: 'find-dead-code' }) \u2014 label/phase go in OPTS, never inside spec (a spec-side label is ignored);\n    unlabeled agents render as anonymous agent-N rows in the monitor. Set opts `phase` to one of your\n    meta.phases titles so the agent groups under its stage.\n    `isolation: \"worktree\"` runs the agent in its own isolated git worktree \u2014 use it ONLY\n    when concurrent agents WRITE THE SAME repo/files and must not clobber each other (a separate working copy,\n    not merely several agents). Returns the task result \u2014 read `r.result` (text) or `r.structuredOutput`\n    (when you passed {schema}). agent() does NOT throw when the sub-agent fails \u2014 it RETURNS the result\n    with `r.status` set; ALWAYS check `r.status` and GATE later phases on it (the Workflow tool card\n    shows the full gate pattern).\n  - parallel(thunks) \u2014 run thunks concurrently; BARRIER (awaits all); a thrown thunk resolves to null\n    (filter before use). Use when you need all results together.\n  - pipeline(items, ...stages) \u2014 each item flows through all stages independently, NO barrier between stages\n    (item A can be in stage 3 while B is in stage 1). DEFAULT for multi-stage work. Each stage gets\n    (prevResult, originalItem, index). A stage that throws drops that item to null.\n  - phase(title, body) \u2014 group work under a named phase (shows in /workflows).\n  - budget \u2014 { total, spent(), remaining() }; once spend reaches total, agent() throws. Loop on\n    budget.remaining() for budget-scaled depth \u2014 but GUARD the loop on budget.total: with no budget set,\n    remaining() returns Infinity and the loop runs straight into the agent cap (add a hard iteration cap).\n    spent() moves when an agent SETTLES (authoritative accounting); the live per-turn figures you may see\n    in run observability are display-only and never charge the budget gate.\n  - log(message) \u2014 emit a progress line.\n  - args \u2014 the JSON value passed to Workflow.\n- The script returns a value; you are notified when it completes and can read the result + the run via the\n  workflow observability.\n\nDiscipline (this is where orchestration earns its cost):\n- DEFAULT TO pipeline(). Only use parallel() (a barrier) when a stage genuinely needs ALL prior results at\n  once (dedup/merge across the full set, early-exit on zero, cross-item comparison). Otherwise pipeline so a\n  fast item isn't blocked by a slow one.\n- Give each sub-agent a CLEAR goal + output spec + boundary, so they don't duplicate or conflict. A vague\n  delegation produces duplicated or off-scope work. Detailed sub-task instructions matter.\n- Be confident, not just fast: for findings that must be right, spawn INDEPENDENT verifiers prompted to\n  REFUTE (default to refuted if uncertain) and keep a finding only if it survives. Diverse lenses\n  (correctness / security / does-it-reproduce) catch failure modes redundancy can't. When workers fan out, a\n  single bad conclusion gets amplified \u2014 verify before you commit to it.\n- Scale to the task: a quick check needs a couple of agents; \"be comprehensive / audit thoroughly\" warrants a\n  larger finder pool + an adversarial verify pass. Don't fan out wider than the task needs.\n\nYou operate under hard caps (a runaway script is bounded, not trusted): a token budget, a concurrency limit,\nper-agent and total timeouts, a max agent count, and a nesting limit of ONE level (a workflow's agent cannot\nitself start another workflow). Every sub-agent you spawn runs under the deployment's permission/approval/\nsafety policy \u2014 you may inherit or TIGHTEN it for a sub-agent, never loosen it. Work within these; they are\nthe safety net that lets you be trusted with this power.";
+export declare const ORCHESTRATION_GUIDANCE = "You can author and run your own WORKFLOW via the Workflow tool \u2014 a\ndeterministic JS script that spawns and coordinates sub-agents. Use it to be more thorough (decompose and\ncover in parallel), more confident (independent perspectives + adversarial checks before committing), or to\nhandle scale one context can't hold. This is a power tool: reach for it on a SUBSTANTIAL task that genuinely\ndecomposes \u2014 for a simple or sequential task, just do the work directly. Over-orchestrating a trivial task\nwastes tokens and adds latency.\n\nHow a workflow script works (the contract):\n- It begins with `export const meta = { name, description, phases }` \u2014 a PURE LITERAL (no variables, calls,\n  or template strings). Use the same phase titles in meta.phases as in your phase() calls and in each\n  agent's opts `phase`.\n- \uD83D\uDD34 After the meta line, write the body as TOP-LEVEL async statements \u2014 the primitives are already in\n  scope. Do NOT wrap the body in `export default`, a function, or a `body()` method; do NOT use\n  `import`/`require`; do NOT put the script inside markdown code fences. End with `return <value>`.\n  The script IS the function body. A complete example \u2014 copy this SHAPE exactly:\n\n      export const meta = { name: 'risk-scan', description: 'list risks in parallel', phases: [{ title: 'scan' }] }\n      const results = await parallel([\n        () => agent({ objective: 'Name one risk of X. Reply in one short sentence.' }, { label: 'scan-risk-a', phase: 'scan' }),\n        () => agent({ objective: 'Name a DIFFERENT risk of X. Reply in one short sentence.' }, { label: 'scan-risk-b', phase: 'scan' }),\n      ])\n      return results.filter((r) => r && r.terminal.kind === 'completed').map((r) => r.result)\n\n- The body is async and uses these injected primitives:\n  - agent(spec, opts?) \u2014 run one sub-agent. spec is { objective: string (USE `objective`, not `goal`),\n    modelName?, thinking?, systemPrompt? }; opts is { schema?, label?, phase?, isolation? } (schema goes in\n    OPTS, not in spec). ALWAYS pass a short kebab-case `label` naming what THIS agent does (e.g.\n    { label: 'find-dead-code' }) \u2014 label/phase go in OPTS, never inside spec (a spec-side label is ignored);\n    unlabeled agents render as anonymous agent-N rows in the monitor. Set opts `phase` to one of your\n    meta.phases titles so the agent groups under its stage.\n    `isolation: \"worktree\"` runs the agent in its own isolated git worktree \u2014 use it ONLY\n    when concurrent agents WRITE THE SAME repo/files and must not clobber each other (a separate working copy,\n    not merely several agents). Returns the task result \u2014 read `r.result` (text) or `r.structuredOutput`\n    (when you passed {schema}). agent() does NOT throw when the sub-agent fails \u2014 it RETURNS the result\n    with `r.terminal` set (`r.terminal.kind` is 'completed' | 'failed' | 'blocked' | 'paused'); ALWAYS check\n    `r.terminal.kind` and GATE later phases on it (the Workflow tool card shows the full gate pattern).\n  - parallel(thunks) \u2014 run thunks concurrently; BARRIER (awaits all); a thrown thunk resolves to null\n    (filter before use). Use when you need all results together.\n  - pipeline(items, ...stages) \u2014 each item flows through all stages independently, NO barrier between stages\n    (item A can be in stage 3 while B is in stage 1). DEFAULT for multi-stage work. Each stage gets\n    (prevResult, originalItem, index). A stage that throws drops that item to null.\n  - phase(title, body) \u2014 group work under a named phase (shows in /workflows).\n  - budget \u2014 { total, spent(), remaining() }; once spend reaches total, agent() throws. Loop on\n    budget.remaining() for budget-scaled depth \u2014 but GUARD the loop on budget.total: with no budget set,\n    remaining() returns Infinity and the loop runs straight into the agent cap (add a hard iteration cap).\n    spent() moves when an agent SETTLES (authoritative accounting); the live per-turn figures you may see\n    in run observability are display-only and never charge the budget gate.\n  - log(message) \u2014 emit a progress line.\n  - args \u2014 the JSON value passed to Workflow.\n- The script returns a value; you are notified when it completes and can read the result + the run via the\n  workflow observability.\n\nDiscipline (this is where orchestration earns its cost):\n- DEFAULT TO pipeline(). Only use parallel() (a barrier) when a stage genuinely needs ALL prior results at\n  once (dedup/merge across the full set, early-exit on zero, cross-item comparison). Otherwise pipeline so a\n  fast item isn't blocked by a slow one.\n- Give each sub-agent a CLEAR goal + output spec + boundary, so they don't duplicate or conflict. A vague\n  delegation produces duplicated or off-scope work. Detailed sub-task instructions matter.\n- Be confident, not just fast: for findings that must be right, spawn INDEPENDENT verifiers prompted to\n  REFUTE (default to refuted if uncertain) and keep a finding only if it survives. Diverse lenses\n  (correctness / security / does-it-reproduce) catch failure modes redundancy can't. When workers fan out, a\n  single bad conclusion gets amplified \u2014 verify before you commit to it.\n- Scale to the task: a quick check needs a couple of agents; \"be comprehensive / audit thoroughly\" warrants a\n  larger finder pool + an adversarial verify pass. Don't fan out wider than the task needs.\n\nYou operate under hard caps (a runaway script is bounded, not trusted): a token budget, a concurrency limit,\nper-agent and total timeouts, a max agent count, and a nesting limit of ONE level (a workflow's agent cannot\nitself start another workflow). Every sub-agent you spawn runs under the deployment's permission/approval/\nsafety policy \u2014 you may inherit or TIGHTEN it for a sub-agent, never loosen it. Work within these; they are\nthe safety net that lets you be trusted with this power.";
 /**
  * Goal-mode completion guidance, composed when goal mode is enabled (design/96 C 节 LLM-self-report gate).
  * Red line (G1, design/96 §定.0): declaring "done" STOPS iteration and surfaces for review (the completion

package/dist/prompts/supervisor.js

@@ -53,7 +53,7 @@ How a workflow script works (the contract):
         () => agent({ objective: 'Name one risk of X. Reply in one short sentence.' }, { label: 'scan-risk-a', phase: 'scan' }),
         () => agent({ objective: 'Name a DIFFERENT risk of X. Reply in one short sentence.' }, { label: 'scan-risk-b', phase: 'scan' }),
       ])
-      return results.filter((r) => r && r.status === 'completed').map((r) => r.result)
+      return results.filter((r) => r && r.terminal.kind === 'completed').map((r) => r.result)
 
 - The body is async and uses these injected primitives:
   - agent(spec, opts?) — run one sub-agent. spec is { objective: string (USE \`objective\`, not \`goal\`),
@@ -66,8 +66,8 @@ How a workflow script works (the contract):
     when concurrent agents WRITE THE SAME repo/files and must not clobber each other (a separate working copy,
     not merely several agents). Returns the task result — read \`r.result\` (text) or \`r.structuredOutput\`
     (when you passed {schema}). agent() does NOT throw when the sub-agent fails — it RETURNS the result
-    with \`r.status\` set; ALWAYS check \`r.status\` and GATE later phases on it (the ${RUN_WORKFLOW_TOOL_NAME} tool card
-    shows the full gate pattern).
+    with \`r.terminal\` set (\`r.terminal.kind\` is 'completed' | 'failed' | 'blocked' | 'paused'); ALWAYS check
+    \`r.terminal.kind\` and GATE later phases on it (the ${RUN_WORKFLOW_TOOL_NAME} tool card shows the full gate pattern).
   - parallel(thunks) — run thunks concurrently; BARRIER (awaits all); a thrown thunk resolves to null
     (filter before use). Use when you need all results together.
   - pipeline(items, ...stages) — each item flows through all stages independently, NO barrier between stages

package/dist/scenarios/scenario-registry.d.ts

@@ -11,7 +11,7 @@
  * yet implemented). The model pairing (who's cheap / who's strong / heterogeneous decorrelation) is
  * deploy-side knowledge — core fills guard-number defaults + prompts + orchestrator choice, never the model.
  */
-import type { Runner } from "../core/runner/runtask.js";
+import type { RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { ModelRef, ModelRole, TaskSpec } from "../core/types.js";
 import { type TeamResult } from "../agents/team.js";
 import { type VerificationResult } from "../agents/verify.js";
@@ -59,7 +59,7 @@ export interface ScenarioProfile {
 export declare const SCENARIO_REGISTRY: Record<ScenarioId, ScenarioProfile>;
 export interface RunScenarioOptions {
     scenario: ScenarioId;
-    runner: Runner;
+    runner: RunnerSelfSeat;
     /** What the scenario operates on — the team `topic` (design/code review) or the solo task objective. */
     objective: string;
     /**
@@ -83,7 +83,7 @@ export interface RunScenarioOptions {
 /** Per-scenario result union — each entry returns its orchestrator's native result shape. */
 export type RunScenarioResult = {
     scenario: "solo";
-    result: Awaited<ReturnType<Runner["runTask"]>>;
+    result: Awaited<ReturnType<RunnerSelfSeat["runTask"]>>;
 } | {
     scenario: "design-review";
     result: TeamResult;

package/dist/scenarios/scenario-registry.js

@@ -125,7 +125,7 @@ async function runCodeReviewVerify(opts) {
     const reviewed = {
         taskId: "code-review",
         sessionId: "code-review",
-        status: "completed",
+        terminal: { kind: "completed" },
         result: opts.objective,
         stats: { turns: 0, tokens: 0 },
     };

package/dist/scenarios/teacher-quickstart.d.ts

@@ -10,7 +10,7 @@
  * defaults only. The guard defaults are NOT re-stated here: we let teacher.ts own them (single source of
  * truth, no drift).
  */
-import type { Runner } from "../core/runner/runtask.js";
+import type { RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { ModelRef, TaskSpec } from "../core/types.js";
 import { type TeacherRunResult } from "../agents/teacher.js";
 export interface TeacherModePair {
@@ -25,7 +25,7 @@ export interface TeacherModePair {
  * student task spec's `model`. All guards use teacher.ts's built-in defaults (not re-stated here, so core
  * owns the single source of truth). The caller supplies only the two models + the task spec.
  */
-export declare function teacherMode(runner: Runner, spec: TaskSpec, pair: TeacherModePair): Promise<TeacherRunResult>;
+export declare function teacherMode(runner: RunnerSelfSeat, spec: TaskSpec, pair: TeacherModePair): Promise<TeacherRunResult>;
 /**
  * Teacher-mode preset profile (G2: a profile = which two models to fill). The two model cells are role-name
  * placeholders the deploy side maps to concrete models (core never guesses); guard defaults are NOT pinned

package/dist/server/http.d.ts

@@ -1,6 +1,6 @@
 import http from "node:http";
 import type { IncomingMessage } from "node:http";
-import type { Runner } from "../core/runner/runtask.js";
+import type { RunnerSelfSeat } from "../core/runner/contracts.js";
 import type { ImageInput, TaskSpec } from "../core/types.js";
 /** Inbound request body. Tool *code* can never come over the wire — the server injects tools via resolveSpec. */
 export interface TaskRequestBody {
@@ -10,7 +10,7 @@ export interface TaskRequestBody {
     [key: string]: unknown;
 }
 export interface TaskServerOptions {
-    runner: Runner;
+    runner: RunnerSelfSeat;
     /**
      * Map an inbound request body to a full TaskSpec. This is where the SERVER decides the model,
      * tools, MCP servers, system prompt, and limits for the request. The body only supplies content