harnery 0.31.6 → 0.33.0

package/src/core/hooks/resolve/transcript.ts

@@ -1,4 +1,5 @@
-import { existsSync, statSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 
 /**
  * Scan a CC-style JSONL transcript for the `┌─ agent-` status-box prefix in
@@ -20,6 +21,56 @@ export function scanStatusBoxPresent(transcriptPath: string | undefined): boolea
   return text.includes("┌─ agent-");
 }
 
+/**
+ * Scan a CC-style JSONL transcript for a needle in ASSISTANT message text
+ * blocks only. Used by `turn.stop` to detect the suggested session name in the
+ * reply.
+ *
+ * The row filter is load-bearing: the transcript tail also carries the needle
+ * inside `tool_result` rows (the `agents set-task` JSON output) and hook
+ * context rows, so a raw `includes()` over the tail — the way the status-box
+ * scan works — would false-pass the moment set-task runs. Verified empirically
+ * 2026-08-09 against a live transcript.
+ *
+ * Same 256KB tail window as the other scans; the window's first line may be a
+ * truncated JSON row, which the per-line parse guard skips.
+ */
+export function scanAssistantTextIncludes(
+  transcriptPath: string | undefined,
+  needle: string,
+): boolean {
+  if (!transcriptPath || !needle || !existsSync(transcriptPath)) return false;
+  const text = tailText(transcriptPath);
+  if (!text) return false;
+  for (const line of text.split("\n")) {
+    // Cheap gate before parsing: most lines don't contain the needle at all.
+    if (!line.includes(needle)) continue;
+    try {
+      const row = JSON.parse(line) as {
+        type?: unknown;
+        message?: { content?: unknown };
+      };
+      if (row.type !== "assistant") continue;
+      const content = row.message?.content;
+      if (typeof content === "string") {
+        if (content.includes(needle)) return true;
+        continue;
+      }
+      if (!Array.isArray(content)) continue;
+      for (const block of content) {
+        if (typeof block !== "object" || block === null) continue;
+        const b = block as { type?: unknown; text?: unknown };
+        if (b.type === "text" && typeof b.text === "string" && b.text.includes(needle)) {
+          return true;
+        }
+      }
+    } catch {
+      // Truncated/partial line (tail-window start or flush race); skip it.
+    }
+  }
+  return false;
+}
+
 /**
  * Resolve the agent's model from a CC-style JSONL transcript by reading the
  * most-recent assistant message's `message.model`. Claude Code's SessionStart
@@ -56,6 +107,118 @@ export function scanTranscriptModel(transcriptPath: string | undefined): string
   return undefined;
 }
 
+const SESSION_FILE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+/** Skip absurdly large transcripts rather than buffering them. */
+const FORK_SCAN_MAX_BYTES = 128 * 1024 * 1024;
+/** How many message uuids to sample across the fork's copied prefix. */
+const FORK_SAMPLE_SIZE = 24;
+
+/**
+ * Detect the parent session of a forked CC conversation from its transcript.
+ *
+ * Empirical basis (verified 2026-08-05 against `claude --resume <id>
+ * --fork-session`): the fork copies the parent's rows into a new
+ * `<new-session-id>.jsonl`, rewriting every row's `sessionId` to the new id
+ * but PRESERVING each copied message row's `uuid`. So a sibling transcript in
+ * the same project directory that contains the fork's message uuids is an
+ * ancestor of the fork.
+ *
+ * Ancestor vs. parent: a grandparent (when the parent was itself a fork)
+ * shares the fork's early uuids too, but only the true parent contains the
+ * whole copied prefix. At detection time the fork's transcript is almost
+ * entirely copied prefix, so uuids sampled across the whole file separate the
+ * two: score candidates by containment, highest wins.
+ *
+ * Sibling forks force a second rule: a PRIOR fork of the same parent also
+ * contains the whole copied prefix, so it ties the true parent on score. The
+ * sibling additionally carries its own post-fork turns, which the parent
+ * lacks, so among tied scores the MINIMAL container (fewest message rows)
+ * wins. A wrong pick under this rule stays within the ancestry (grandparent
+ * at worst); a recency tie-break can name a non-ancestor sibling (observed
+ * 2026-08-05 with two probes forked off one parent).
+ *
+ * Fail-soft by design: any read error, an unflushed transcript, or no
+ * qualifying sibling returns undefined, which downgrades the caller to the
+ * no-lineage behavior. Never throws.
+ */
+export function detectForkParent(
+  transcriptPath: string | undefined,
+  sessionId: string,
+): string | undefined {
+  try {
+    if (!transcriptPath || !sessionId || !existsSync(transcriptPath)) return undefined;
+    if (statSync(transcriptPath).size > FORK_SCAN_MAX_BYTES) return undefined;
+    const own = readFileSync(transcriptPath, "utf8");
+    const uuids = messageUuids(own);
+    if (uuids.length === 0) return undefined;
+    const sample = sampleEvenly(uuids, FORK_SAMPLE_SIZE);
+
+    const dir = dirname(transcriptPath);
+    const ownFile = basename(transcriptPath);
+    let best: { id: string; score: number; rows: number; mtimeMs: number } | null = null;
+    for (const file of readdirSync(dir)) {
+      if (file === ownFile || !SESSION_FILE_RE.test(file)) continue;
+      const candidateId = file.slice(0, -".jsonl".length);
+      if (candidateId === sessionId) continue;
+      const path = join(dir, file);
+      let stat: ReturnType<typeof statSync>;
+      try {
+        stat = statSync(path);
+      } catch {
+        continue;
+      }
+      if (stat.size > FORK_SCAN_MAX_BYTES) continue;
+      let text: string;
+      try {
+        text = readFileSync(path, "utf8");
+      } catch {
+        continue;
+      }
+      // Cheap gate before scoring: an ancestor must contain the fork's first
+      // copied message uuid (the copy always starts at the beginning).
+      if (!text.includes(sample[0]!)) continue;
+      let score = 0;
+      for (const u of sample) if (text.includes(u)) score++;
+      if (score < Math.max(1, Math.ceil(sample.length / 2))) continue;
+      const rows = messageUuids(text).length;
+      const wins =
+        !best ||
+        score > best.score ||
+        (score === best.score &&
+          (rows < best.rows || (rows === best.rows && stat.mtimeMs < best.mtimeMs)));
+      if (wins) best = { id: candidateId, score, rows, mtimeMs: stat.mtimeMs };
+    }
+    return best?.id;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Message-row uuids (user/assistant rows only), in file order. */
+function messageUuids(text: string): string[] {
+  const out: string[] = [];
+  for (const line of text.split("\n")) {
+    if (!line.includes('"uuid"')) continue;
+    try {
+      const row = JSON.parse(line) as { type?: unknown; uuid?: unknown };
+      if (row.type !== "user" && row.type !== "assistant") continue;
+      if (typeof row.uuid === "string" && row.uuid.length > 0) out.push(row.uuid);
+    } catch {
+      // Truncated/partial line (flush race); skip it.
+    }
+  }
+  return out;
+}
+
+/** Up to <n> items spread evenly across the list, always including the first. */
+function sampleEvenly(items: string[], n: number): string[] {
+  if (items.length <= n) return items;
+  const out: string[] = [];
+  const step = items.length / n;
+  for (let i = 0; i < n; i++) out.push(items[Math.floor(i * step)]!);
+  return out;
+}
+
 /** Tail-read up to 256KB from the end of a file as UTF-8, or undefined on error. */
 function tailText(path: string): string | undefined {
   try {

package/src/core/hooks/session-name-presence.ts

@@ -0,0 +1,52 @@
+/**
+ * Session-name presence for `turn.stop`.
+ *
+ * While the heartbeat carries a `suggested_session_name`, report whether the
+ * naming ritual is satisfied: either this turn's reply shows the name, or an
+ * earlier reply already did. Scanning covers assistant text blocks only (the
+ * raw transcript tail also carries the name inside the set-task tool_result,
+ * which must not count) plus the adapter-supplied last assistant message, for
+ * stops that arrive without a transcript.
+ *
+ * Two properties the stop-hook naming rule depends on:
+ *
+ * 1. Once a name is satisfied, every later stop keeps reporting `true` rather
+ *    than omitting the field. The rule wants an in-window `turn.stop` carrying
+ *    `session_name_present: true`; omitting it after the heartbeat stamp meant
+ *    nothing could ever re-emit the flag, so every subsequent reply blocked --
+ *    including the replies reproducing the exact name the rule asked for.
+ * 2. The result names WHICH suggested name it covered, so a projector rebuild
+ *    attributes the sighting to that name instead of to whichever name is
+ *    current during the replay. Without it, a re-minted name inherited an older
+ *    name's sighting and looked satisfied without ever having been shown.
+ *
+ * Never throws: coordination telemetry must not take down a hook.
+ */
+
+import { readHeartbeat, stampSessionNameSeen } from "../agents/state/heartbeat-writer.ts";
+
+export interface SessionNamePresence {
+  session_name_present?: boolean;
+  session_name_present_for?: string;
+}
+
+export function sessionNamePresence(
+  coordRoot: string,
+  instanceId: string,
+  lastAssistantMessage: string,
+  scanAssistantText: (name: string) => boolean,
+): SessionNamePresence {
+  try {
+    const hb = readHeartbeat(coordRoot, instanceId);
+    const name = hb?.suggested_session_name;
+    if (!name) return {};
+    if (hb?.session_name_seen_for === name) {
+      return { session_name_present: true, session_name_present_for: name };
+    }
+    const present = scanAssistantText(name) || lastAssistantMessage.includes(name);
+    if (present) stampSessionNameSeen(coordRoot, instanceId, name);
+    return { session_name_present: present, session_name_present_for: name };
+  } catch {
+    return {};
+  }
+}

package/src/core/hooks/unsafe-cross-shell.ts

@@ -0,0 +1,160 @@
+import { isWslUncPath } from "./codex-wsl-bridge.ts";
+import type { Adapter } from "./events/schema.ts";
+
+export interface CrossShellInspection {
+  adapter: Adapter;
+  cwd: unknown;
+  toolName: unknown;
+  toolInput: unknown;
+}
+
+const DENY_REASON =
+  "Unsafe Windows-to-WSL shell-string construction blocked. Use the host's argv-preserving " +
+  "WSL bridge for a single executable, or its literal-script mode for compound Bash. Do not " +
+  "invoke wsl.exe with bash -c or bash -lc.";
+
+function shellCommand(toolName: unknown, toolInput: unknown): string | null {
+  if (typeof toolName !== "string") return null;
+  const normalized = toolName.toLowerCase();
+  if (
+    normalized !== "bash" &&
+    normalized !== "shell" &&
+    normalized !== "shell_command" &&
+    normalized !== "functions.shell_command"
+  ) {
+    return null;
+  }
+
+  let input = toolInput;
+  if (typeof input === "string") {
+    try {
+      input = JSON.parse(input) as unknown;
+    } catch {
+      return null;
+    }
+  }
+  if (!input || typeof input !== "object") return null;
+  const command = (input as Record<string, unknown>).command;
+  return typeof command === "string" ? command : null;
+}
+
+function quotedToken(command: string, start: number): { token: string; end: number } {
+  const quote = command[start]!;
+  let token = "";
+  for (let index = start + 1; index < command.length; index += 1) {
+    const char = command[index]!;
+    if (char === "`" && quote === '"' && index + 1 < command.length) {
+      token += command[index + 1]!;
+      index += 1;
+      continue;
+    }
+    if (char === quote) {
+      if (quote === "'" && command[index + 1] === "'") {
+        token += "'";
+        index += 1;
+        continue;
+      }
+      return { token, end: index + 1 };
+    }
+    token += char;
+  }
+  return { token, end: command.length };
+}
+
+/** Find direct PowerShell command invocations of wsl/wsl.exe outside quoted strings. */
+function wslInvocationOffsets(command: string): number[] {
+  const offsets: number[] = [];
+  let expectCommand = true;
+  let callOperator = false;
+
+  for (let index = 0; index < command.length; ) {
+    const char = command[index]!;
+    if (/\s/.test(char)) {
+      if (char === "\n" || char === "\r") {
+        expectCommand = true;
+        callOperator = false;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "#" && expectCommand) {
+      const newline = command.indexOf("\n", index + 1);
+      index = newline === -1 ? command.length : newline + 1;
+      expectCommand = true;
+      callOperator = false;
+      continue;
+    }
+    if (";|{}=()".includes(char)) {
+      expectCommand = true;
+      callOperator = false;
+      index += 1;
+      continue;
+    }
+    if (char === "&") {
+      expectCommand = true;
+      callOperator = true;
+      index += command[index + 1] === "&" ? 2 : 1;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      const parsed = quotedToken(command, index);
+      if (expectCommand && callOperator && /^wsl(?:\.exe)?$/i.test(parsed.token)) {
+        offsets.push(index);
+      }
+      expectCommand = false;
+      callOperator = false;
+      index = parsed.end;
+      continue;
+    }
+
+    const start = index;
+    while (index < command.length && !/[\s;|{}=()&]/.test(command[index]!)) index += 1;
+    const token = command.slice(start, index);
+    if (expectCommand && /^wsl(?:\.exe)?$/i.test(token)) offsets.push(start);
+    expectCommand = false;
+    callOperator = false;
+  }
+
+  return offsets;
+}
+
+function statementEnd(command: string, start: number): number {
+  let quote: string | null = null;
+  for (let index = start; index < command.length; index += 1) {
+    const char = command[index]!;
+    if (quote) {
+      if (char === "`" && quote === '"') {
+        index += 1;
+      } else if (char === quote) {
+        if (quote === "'" && command[index + 1] === "'") index += 1;
+        else quote = null;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') quote = char;
+    else if (char === ";" || char === "\n" || char === "\r" || char === "|") return index;
+    else if (char === "&" && command[index + 1] === "&") return index;
+  }
+  return command.length;
+}
+
+function invokesBashCommandString(command: string): boolean {
+  for (const offset of wslInvocationOffsets(command)) {
+    const segment = command.slice(offset, statementEnd(command, offset));
+    if (/(?:^|\s)(?:\/bin\/)?bash(?=\s|$)[\s\S]*?\s-[a-z]*c[a-z]*(?=\s|$)/i.test(segment)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Deny only the unsafe hybrid shape: Windows-native Codex, WSL UNC workspace,
+ * shell tool, and a direct wsl.exe -> bash -c/-lc command-string invocation.
+ */
+export function unsafeCrossShellReason(input: CrossShellInspection): string | null {
+  if (input.adapter !== "codex" || !isWslUncPath(input.cwd)) return null;
+  const command = shellCommand(input.toolName, input.toolInput);
+  if (!command || !invokesBashCommandString(command)) return null;
+  return DENY_REASON;
+}

package/src/core/presence/blob.ts

@@ -9,6 +9,7 @@ import { createHash } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { resolveMachineLabel } from "../../lib/machine.ts";
+import type { AgentActivity, TaskState } from "../agents/state/session-state.ts";
 
 /** Mirror of the local heartbeat freshness window (commands/agents.ts). */
 const FRESHNESS_SECS = 600;
@@ -24,6 +25,9 @@ export interface PresenceAgent {
   session_id?: string;
   platform?: string;
   task?: string;
+  activity: AgentActivity;
+  task_state: TaskState;
+  task_state_reason?: string;
   turn_summary?: string;
   files_touched?: string[];
   last_tool?: string;
@@ -78,6 +82,9 @@ export function buildPresenceBlob(coordRoot: string, now: Date = new Date()): Bu
         session_id: strOr(hb.session_id),
         platform: strOr(hb.platform),
         task: strOr(hb.task),
+        activity: activityOrUnknown(hb.activity),
+        task_state: taskStateOrActive(hb.task_state),
+        task_state_reason: clamp(strOr(hb.task_state_reason), 160),
         turn_summary: clamp(strOr(hb.turn_summary), 160),
         files_touched: Array.isArray(hb.files_touched)
           ? (hb.files_touched as string[]).slice(0, MAX_FILES_PER_AGENT)
@@ -107,6 +114,9 @@ export function buildPresenceBlob(coordRoot: string, now: Date = new Date()): Bu
     n: a.name ?? null,
     k: a.kind ?? null,
     t: a.task ?? null,
+    a: a.activity,
+    l: a.task_state,
+    r: a.task_state_reason ?? null,
     s: a.turn_summary ?? null,
     f: [...(a.files_touched ?? [])].sort(),
   }));
@@ -119,6 +129,14 @@ function strOr(v: unknown): string | undefined {
   return typeof v === "string" && v.length > 0 ? v : undefined;
 }
 
+function activityOrUnknown(v: unknown): AgentActivity {
+  return v === "working" || v === "needs_input" || v === "idle" ? v : "unknown";
+}
+
+function taskStateOrActive(v: unknown): TaskState {
+  return v === "blocked" || v === "done" ? v : "active";
+}
+
 function clamp(v: string | undefined, max: number): string | undefined {
   if (!v) return undefined;
   return v.length > max ? v.slice(0, max) : v;

package/src/core/presence/index.ts

@@ -263,7 +263,7 @@ export function readRemoteMachines(
         machine,
         published_at: blob.published_at,
         age_secs: ageSecs,
-        agents: blob.agents,
+        agents: blob.agents.map(normalizePresenceAgent),
       });
     }
     out.sort((a, b) => a.machine.localeCompare(b.machine));
@@ -272,3 +272,20 @@ export function readRemoteMachines(
     return [];
   }
 }
+
+function normalizePresenceAgent(agent: PresenceAgent): PresenceAgent {
+  const legacy = agent as Partial<PresenceAgent>;
+  return {
+    ...agent,
+    activity:
+      legacy.activity === "working" ||
+      legacy.activity === "needs_input" ||
+      legacy.activity === "idle"
+        ? legacy.activity
+        : "unknown",
+    task_state:
+      legacy.task_state === "blocked" || legacy.task_state === "done"
+        ? legacy.task_state
+        : "active",
+  };
+}

package/src/core/work/state.ts

@@ -21,7 +21,7 @@ import { readWorkflowRunManifest, workflowScriptDigest } from "../workflow/run-s
 import { WORKFLOW_TRANSCRIPT_EVENT_BYTES, workflowTranscriptPath } from "../workflow/transcript.ts";
 import { isWorkspaceBoundExecutionEvidence } from "../workflow/workspaces/validate.ts";
 
-export const WORK_INTENT_SCHEMA_VERSION = 1 as const;
+export const WORK_INTENT_SCHEMA_VERSION = 2 as const;
 export const WORK_EVENT_SCHEMA_VERSION = 1 as const;
 
 const WORK_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
@@ -77,12 +77,11 @@ export interface WorkIntent {
   dependencies: string[];
   workflow: { path: string; sha256: string };
   max_attempts: number;
-  /** Ceiling on CONSECUTIVE uncharged attempts (ADR 0046), separate from
+  /** Ceiling on consecutive uncharged attempts (ADR 0046), separate from
    * max_attempts. An upstream outage produces uncharged attempt after uncharged
    * attempt; without a bound it would retry forever. At the bound the item stops
-   * and reports it is blocked on an outside service. Optional for back-compat:
-   * an intent written before ADR 0046 has none and falls back to the default. */
-  max_uncharged_attempts?: number;
+   * and reports it is blocked on an outside service. */
+  max_uncharged_attempts: number;
   source?: { kind: "human" | "workflow" | "external"; ref?: string };
   created_at: string;
 }
@@ -551,7 +550,7 @@ function deriveWorkProjection(
     // Count trailing consecutive uncharged attempts in the current window. The
     // bound is the only brake on an outage that never ends, so at the limit the
     // item stops and names the outside service — distinct from work-blocked.
-    const maxUncharged = intent.max_uncharged_attempts ?? DEFAULT_MAX_UNCHARGED_ATTEMPTS;
+    const maxUncharged = intent.max_uncharged_attempts;
     let trailingUncharged = 0;
     for (let index = currentAttempts.length - 1; index >= 0; index--) {
       if (currentAttempts[index]!.uncharged === undefined) break;
@@ -1041,12 +1040,9 @@ function validateWorkIntent(intent: WorkIntent, workId: string): void {
     !Number.isSafeInteger(intent.max_attempts) ||
     intent.max_attempts < 1 ||
     intent.max_attempts > 100 ||
-    // Optional for back-compat: absent on pre-ADR-0046 intents. When present it
-    // must be a valid bound.
-    (intent.max_uncharged_attempts !== undefined &&
-      (!Number.isSafeInteger(intent.max_uncharged_attempts) ||
-        intent.max_uncharged_attempts < 1 ||
-        intent.max_uncharged_attempts > 100))
+    !Number.isSafeInteger(intent.max_uncharged_attempts) ||
+    intent.max_uncharged_attempts < 1 ||
+    intent.max_uncharged_attempts > 100
   ) {
     throw new Error(`work intent ${workId} has an unsupported or mismatched schema`);
   }

package/src/core/workflow/engine.ts

@@ -87,7 +87,7 @@ import {
 import type {
   WorkspaceAttestation,
   WorkspaceBinding,
-  WorkspaceUnsupportedExecutionEvidence,
+  WorkspaceCompatibilityExecutionEvidence,
 } from "./workspaces/types.ts";
 import { isWorkspaceAttestation } from "./workspaces/validate.ts";
 
@@ -324,7 +324,7 @@ async function executeWorkflow(
   const fallbackMeta = normalizeWorkflowMeta(undefined, fallbackName);
   const workspaceProvider = isolation === "shared" ? undefined : opts.workspace?.provider;
   let workspaceBinding: WorkspaceBinding | undefined;
-  let workspaceFallback: WorkspaceUnsupportedExecutionEvidence | undefined =
+  let workspaceFallback: WorkspaceCompatibilityExecutionEvidence | undefined =
     resumeState?.manifest.execution.workspace_fallback;
   try {
     workspaceBinding = await resolveWorkspaceBinding({

package/src/core/workflow/index.ts

@@ -143,7 +143,6 @@ export type {
   WorkspaceProviderCapabilities,
   WorkspaceProviderRef,
   WorkspaceResourceState,
-  WorkspaceUnsupportedExecutionEvidence,
 } from "./workspaces/index.ts";
 export {
   applyIntegration,

package/src/core/workflow/proof.ts

@@ -40,13 +40,13 @@ import { isCanonicalWorkflowWorkContext } from "./work-context.ts";
 import type {
   WorkspaceAttestation,
   WorkspaceBinding,
+  WorkspaceCompatibilityExecutionEvidence,
   WorkspaceExecutionEvidence,
-  WorkspaceUnsupportedExecutionEvidence,
 } from "./workspaces/index.ts";
 import {
   isWorkspaceBoundExecutionEvidence,
+  isWorkspaceCompatibilityExecutionEvidence,
   isWorkspaceExecutionEvidence,
-  isWorkspaceUnsupportedExecutionEvidence,
   workspaceProofLifecycle,
 } from "./workspaces/validate.ts";
 
@@ -101,7 +101,7 @@ export interface BuildWorkflowProofInput {
   blocked?: { reason: string; decisionId?: string };
   workspaceBinding?: WorkspaceBinding;
   workspaceAttestation?: WorkspaceAttestation;
-  workspaceFallback?: WorkspaceUnsupportedExecutionEvidence;
+  workspaceFallback?: WorkspaceCompatibilityExecutionEvidence;
   result?: unknown;
   error?: string;
 }
@@ -401,7 +401,7 @@ export function readWorkflowProof(coordRoot: string, runId: string): WorkflowPro
       ? isWorkspaceBoundExecutionEvidence(proofExecution, runId) &&
         stableDigest(proofExecution.binding) === stableDigest(manifestBinding)
       : manifestFallback !== undefined
-        ? isWorkspaceUnsupportedExecutionEvidence(proofExecution, runId) &&
+        ? isWorkspaceCompatibilityExecutionEvidence(proofExecution, runId) &&
           stableDigest(proofExecution) === stableDigest(manifestFallback)
         : proofExecution === undefined;
   if (!executionMatches) {

package/src/core/workflow/run-state.ts

@@ -33,12 +33,12 @@ import { isCanonicalWorkflowWorkContext } from "./work-context.ts";
 import type {
   WorkspaceAllocationRequest,
   WorkspaceBinding,
-  WorkspaceUnsupportedExecutionEvidence,
+  WorkspaceCompatibilityExecutionEvidence,
 } from "./workspaces/index.ts";
 import {
   assertWorkspaceManifestAuthority,
   isWorkspaceBinding,
-  isWorkspaceUnsupportedExecutionEvidence,
+  isWorkspaceCompatibilityExecutionEvidence,
 } from "./workspaces/validate.ts";
 
 export const WORKFLOW_RUN_MANIFEST_SCHEMA_VERSION = 1 as const;
@@ -70,7 +70,7 @@ export interface WorkflowRunManifest {
     policy?: NormalizedPolicy;
     specialists?: Record<string, WorkflowSpecialistProfile>;
     workspace_binding?: WorkspaceBinding;
-    workspace_fallback?: WorkspaceUnsupportedExecutionEvidence;
+    workspace_fallback?: WorkspaceCompatibilityExecutionEvidence;
   };
 }
 
@@ -307,9 +307,9 @@ function validWorkspaceBinding(binding: WorkspaceBinding | undefined): boolean {
 }
 
 function validWorkspaceFallback(
-  fallback: WorkspaceUnsupportedExecutionEvidence | undefined,
+  fallback: WorkspaceCompatibilityExecutionEvidence | undefined,
 ): boolean {
-  return fallback === undefined || isWorkspaceUnsupportedExecutionEvidence(fallback);
+  return fallback === undefined || isWorkspaceCompatibilityExecutionEvidence(fallback);
 }
 
 function validSpecialists(

package/src/core/workflow/types.ts

@@ -425,11 +425,11 @@ export type Spawner = (req: SpawnRequest) => Promise<SpawnResult>;
 /** The API surface injected into a workflow script's default export. Explicit
  * injection (no ambient globals): keeps scripts portable and unit-testable. */
 export interface WorkflowContext {
-  /** Frozen durable-work assignment for work-linked runs. Standalone and
-   * legacy-resumed workflows have no work context. */
+  /** Frozen durable-work assignment for work-linked runs. Standalone workflows
+   * have no work context. */
   work?: Readonly<WorkflowWorkContext>;
   /** Frozen attempt identity and, on retry, a bounded synopsis of prior
-   * terminal evidence. Absent for standalone and legacy-resumed workflows. */
+   * terminal evidence. Absent for standalone workflows. */
   attempt?: Readonly<WorkflowAttemptContext>;
   /** Spawn one subagent; resolves to validated JSON (schema) or reply text. */
   agent: (prompt: string, opts?: AgentOpts) => Promise<unknown>;