@tt-a1i/openpi 0.5.0 → 0.6.0

package/extensions/subagents/src/domain.ts

@@ -69,6 +69,8 @@ export interface SpawnTask {
   readonly tools?: readonly string[];
   /** Agent type that supplied the above, for the session label. */
   readonly agentTypeName?: string;
+  /** Optional JSON Schema for one terminating, validated child result. */
+  readonly outputSchema?: unknown;
   /**
    * Isolated git worktree this child runs in, created by the tool layer. The
    * backend only reclaims it when the session scope closes; it does not know
@@ -142,7 +144,11 @@ export interface QueuedMessage {
 // --- Events ------------------------------------------------------------------
 
 export type RunOutcome =
-  | { readonly _tag: "Completed"; readonly finalText: string }
+  | {
+      readonly _tag: "Completed";
+      readonly finalText: string;
+      readonly structuredResult?: StructuredSubagentResult;
+    }
   | {
       readonly _tag: "Failed";
       readonly errorText: string;
@@ -232,10 +238,19 @@ export interface SubagentSnapshot {
   readonly queued: ReadonlyArray<QueuedMessage>;
   /** Final text of the most recent completed run (v1 `finalOutput`). */
   readonly finalText: string;
+  /** Present only when this run supplied and satisfied output_schema. */
+  readonly structuredResult?: StructuredSubagentResult;
   /** Count of finalized assistant messages (for subagent_check). */
   readonly turns: number;
 }
 
+export interface StructuredSubagentResult {
+  readonly value: unknown;
+  readonly json: string;
+  readonly byteLength: number;
+  readonly artifactPath: string;
+}
+
 /** Final text, or the live streaming buffer while a run is active (v1 `latestOutput`). */
 export function latestText(snap: SubagentSnapshot) {
   const live = snap.liveAssistant?.text.trim();

package/extensions/subagents/src/manager.ts

@@ -123,6 +123,7 @@ interface MutableSnapshot {
   liveTools: LiveToolState[];
   queued: SubagentSnapshot["queued"];
   finalText: string;
+  structuredResult?: SubagentSnapshot["structuredResult"];
   turns: number;
 }
 
@@ -363,6 +364,7 @@ const makeManager = (config: SubagentManagerConfig = {}) =>
           s.outcome = "completed";
           s.errorText = undefined;
           s.finalText = outcome.finalText.slice(0, FINAL_TEXT_MAX_LENGTH);
+          s.structuredResult = outcome.structuredResult;
           break;
         case "Failed":
           s.status = "error";
@@ -373,6 +375,7 @@ const makeManager = (config: SubagentManagerConfig = {}) =>
             0,
             FINAL_TEXT_MAX_LENGTH,
           );
+          s.structuredResult = undefined;
           break;
         case "Interrupted":
           s.status = "error";
@@ -382,6 +385,7 @@ const makeManager = (config: SubagentManagerConfig = {}) =>
             0,
             FINAL_TEXT_MAX_LENGTH,
           );
+          s.structuredResult = undefined;
           break;
       }
       s.liveAssistant = undefined;
@@ -446,6 +450,7 @@ const makeManager = (config: SubagentManagerConfig = {}) =>
           s.outcome = undefined;
           s.settledAt = undefined;
           s.errorText = undefined;
+          s.structuredResult = undefined;
           armWatchdog(entry);
           break;
         case "RunSettled":

package/extensions/subagents/src/prompt.ts

@@ -17,8 +17,8 @@ export const SUBAGENT_SCHEMA_BUDGETS = Object.freeze({
 
 /** Describes subagent_spawn, including the fixed concurrency cap. */
 export const SUBAGENT_SPAWN_TOOL_DESCRIPTION =
-  "Spawn a background in-process Pi subagent with its own context, child-safe tools, and normal host permissions. Returns immediately; its final result is delivered automatically. The child cannot see this conversation, ask the user, or orchestrate agents/workflows. Use only trusted working directories. " +
-  `Max ${MAX_RUNNING} subagents can be running at once.`;
+  "Spawn a background Pi subagent with isolated context and child-safe tools. Returns immediately; its result arrives automatically. It cannot see this chat, ask the user, or orchestrate. Use trusted directories. " +
+  `Max ${MAX_RUNNING} subagents can run at once.`;
 
 /** UTF-8 bounded, whitespace-normalized text for the parent-facing roster. */
 function boundedPurpose(description: string) {
@@ -152,6 +152,7 @@ export const SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS = {
     'Optional "provider/model-id" or current-provider model override. Omit to use the preset, configured role, or parent default. Never guess a model name.',
   reasoningEffort:
     "Optional child thinking level. Honor the user's requested level. Otherwise choose a level supported by the resolved child model based on the selected role and task difficulty. An explicit value overrides a role default.",
+  outputSchema: "Optional result JSON Schema.",
 };
 
 /** The exact name/description/wire-schema source used by registration/tests. */
@@ -193,6 +194,15 @@ export function createSubagentSpawnToolSurface(
           description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.reasoningEffort,
         }),
       ),
+      output_schema: Type.Optional(
+        Type.Object(
+          {},
+          {
+            additionalProperties: true,
+            description: SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS.outputSchema,
+          },
+        ),
+      ),
     }),
   };
 }
@@ -207,6 +217,7 @@ export function buildSubagentSpawnResult(options: {
   agentTypeName?: string;
   tools?: readonly string[];
   worktreeBranch?: string;
+  structured?: boolean;
 }) {
   const typeNote = options.agentTypeName
     ? ` Agent type "${options.agentTypeName}" applied.`
@@ -226,8 +237,11 @@ export function buildSubagentSpawnResult(options: {
   const worktreeNote = options.worktreeBranch
     ? ` Isolated in its own worktree on branch "${options.worktreeBranch}" — its edits are invisible here until you merge that branch. The checkout stays available for later send/review and is reclaimed on Session retirement only when bounded inspection proves it empty.`
     : "";
+  const structuredNote = options.structured
+    ? " This run must finish with the requested validated structured result."
+    : "";
   return (
-    `Spawned subagent ${options.id} "${options.title}" (${options.harness}: ${options.modelLabel}, ${options.cwd}).${typeNote}${toolNote}${worktreeNote}\n` +
+    `Spawned subagent ${options.id} "${options.title}" (${options.harness}: ${options.modelLabel}, ${options.cwd}).${typeNote}${toolNote}${worktreeNote}${structuredNote}\n` +
     `It runs in the background — keep working on independent work. If none remains in an interactive session, briefly tell the user it is still running and end your turn; its result is delivered automatically and you are automatically re-invoked when it finishes. Do not poll or call subagent_wait merely because a later step depends on it. ` +
     `Use subagent_wait(ids: ["${options.id}"]) only if the user explicitly asked you to keep the current response open for this result, or a non-interactive automation must return it in the same invocation; subagent_cancel stops it, subagent_check peeks at a running one, subagent_list shows all.`
   );

package/extensions/subagents/src/result-artifact.ts

@@ -77,6 +77,38 @@ export function persistResultArtifact(agentDir: string, content: string) {
   return artifactPath;
 }
 
+/** Persist one complete validated structured value under a JSON identity. */
+export function persistStructuredResultArtifact(
+  agentDir: string,
+  content: string,
+) {
+  let directory = path.resolve(agentDir);
+  for (const segment of RESULT_ARTIFACT_DIR) {
+    directory = ensureDirectory(directory, segment);
+  }
+
+  const digest = createHash("sha256").update(content).digest("hex");
+  const artifactPath = path.join(directory, `${digest}.json`);
+  try {
+    writeFileSync(artifactPath, content, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    const stat = lstatSync(artifactPath);
+    if (
+      !stat.isFile() ||
+      stat.isSymbolicLink() ||
+      readFileSync(artifactPath, "utf8") !== content
+    ) {
+      throw new Error(`Structured result artifact collision: ${artifactPath}`);
+    }
+  }
+  return artifactPath;
+}
+
 /**
  * Build the single model-visible projection used by automatic delivery and
  * explicit waits. Short answers pass through byte-for-byte. Long answers keep

package/extensions/subagents/src/result-delivery.ts

@@ -1,10 +1,16 @@
 import type { ConsumableResultDeliveryQueue } from "../../shared/result-delivery.ts";
+import {
+  type CompletionOwner,
+  createCompletionInbox,
+} from "../../shared/completion-inbox.ts";
 
 export interface SubagentResultDeliveryOptions<T> {
   /** True only when the parent has no run or queued continuation in flight. */
   readonly isIdle: () => boolean;
   /** Deliver one drained batch and wake the parent. */
   readonly deliver: (results: readonly T[]) => void;
+  /** Current Pi Session transcript owner. */
+  readonly owner?: () => CompletionOwner | undefined;
 }
 
 /**
@@ -22,50 +28,63 @@ export interface SubagentResultDeliveryOptions<T> {
  * The parent boundary wakes even if an earlier extension handler has already
  * started another turn: Pi queues the follow-up into that active run.
  *
- * The Map is the one-shot gate: `subagent_wait` may consume a result before it
- * is delivered, and whichever path drains first prevents duplicate delivery.
+ * The shared inbox is the one-shot gate: `subagent_wait` may consume a result
+ * before it is delivered, and whichever path claims first prevents duplicate
+ * delivery.
  */
 export function createSubagentResultDelivery<T extends { id: string }>(
   options: SubagentResultDeliveryOptions<T>,
 ) {
-  const pending = new Map<string, T>();
+  const inbox = createCompletionInbox<T>();
+  const owner = options.owner ?? (() => ({ sessionId: "test", epoch: 0 }));
 
   const flush = () => {
-    if (pending.size === 0) return;
-    const results = [...pending.values()];
-    pending.clear();
+    const envelopes = inbox.claim(owner());
+    if (envelopes.length === 0) return;
+    const results = envelopes.map((envelope) => envelope.payload);
     try {
       options.deliver(results);
+      inbox.acknowledge(envelopes.map((envelope) => envelope.deliveryId));
     } catch (error) {
       // A synchronous session teardown may reject append/send. Preserve the
       // original batch ahead of anything deferred re-entrantly while delivery
       // ran, so a later boundary can retry without loss or reordering.
-      const current = [...pending.values()];
-      pending.clear();
-      for (const result of results) pending.set(result.id, result);
-      for (const result of current) pending.set(result.id, result);
+      inbox.retry(envelopes, owner());
       throw error;
     }
   };
 
   const queue = {
     defer(result: T) {
-      pending.set(result.id, result);
+      const currentOwner = owner();
+      inbox.defer(
+        {
+          deliveryId: `subagent:${result.id}`,
+          owner: currentOwner ?? { sessionId: "unowned", epoch: 0 },
+          producer: "subagent",
+          producerId: result.id,
+          terminalRef: { kind: "subagent-snapshot", id: result.id },
+          wake: "follow-up",
+          payload: result,
+        },
+        currentOwner,
+      );
       if (options.isIdle()) flush();
     },
     consume(ids: Iterable<string>) {
-      for (const id of ids) pending.delete(id);
+      inbox.consume("subagent", ids);
     },
     /** Flush at the authoritative parent boundary. */
     parentSettled() {
       flush();
     },
     clear() {
-      pending.clear();
+      inbox.clear();
     },
     size() {
-      return pending.size;
+      return inbox.size();
     },
+    inspectDeadLetters: inbox.inspectDeadLetters,
   };
   return queue satisfies ConsumableResultDeliveryQueue<T>;
 }

package/extensions/ui-customization/footer.ts

@@ -1,5 +1,5 @@
 import { homedir } from "node:os";
-import { relative } from "node:path";
+import { posix, win32 } from "node:path";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import {
   getCapabilities,
@@ -117,10 +117,21 @@ export function formatTokens(tokens: number) {
   return `${(tokens / 1_000_000).toFixed(1)}m`;
 }
 
-export function formatDirectory(cwd: string) {
-  const home = homedir();
-  if (cwd === home) return "~";
-  const display = cwd.startsWith(`${home}/`) ? `~/${relative(home, cwd)}` : cwd;
+export function formatDirectory(
+  cwd: string,
+  home = homedir(),
+  pathModule = process.platform === "win32" ? win32 : posix,
+) {
+  const relativePath = pathModule.relative(home, cwd);
+  const outsideHome =
+    relativePath === ".." ||
+    relativePath.startsWith(`..${pathModule.sep}`) ||
+    pathModule.isAbsolute(relativePath);
+  const display = outsideHome
+    ? cwd
+    : relativePath
+      ? `~/${relativePath.replaceAll(pathModule.sep, "/")}`
+      : "~";
   return sanitizeTerminalLabel(display);
 }
 

package/extensions/user-input-fold/index.ts

@@ -40,8 +40,35 @@ type Segment =
   | { kind: "prose"; lines: string[] }
   | { kind: "code"; open: string; content: string[]; close: string };
 
-const FENCE_OPEN = /^ {0,3}`{3,}/;
-const FENCE_CLOSE = /^ {0,3}`{3,}[ \t]*\r?$/;
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+
+/**
+ * Parse an opening code fence (CommonMark §4.5): which character it uses and
+ * how long it is. A backtick fence's info string may not contain backticks.
+ */
+function openFence(line: string) {
+  const match = FENCE_OPEN.exec(line);
+  if (!match) return undefined;
+  const fence = match[1];
+  if (fence[0] === "`" && line.slice(match[0].length).includes("`")) {
+    return undefined;
+  }
+  return { char: fence[0], length: fence.length };
+}
+
+/**
+ * A closing fence must use the same character as the opening fence and be at
+ * least as long: a ``` line does not close a ```` block, and backticks never
+ * close a tilde block.
+ */
+function isCloseFence(line: string, open: { char: string; length: number }) {
+  const match = /^ {0,3}(`{3,}|~{3,})[ \t]*\r?$/.exec(line);
+  return (
+    match !== null &&
+    match[1][0] === open.char &&
+    match[1].length >= open.length
+  );
+}
 
 function countLines(markdown: string) {
   const parts = markdown.split("\n");
@@ -60,7 +87,8 @@ function parseSegments(lines: string[]): Segment[] {
   let prose: string[] = [];
   let i = 0;
   while (i < lines.length) {
-    if (!FENCE_OPEN.test(lines[i])) {
+    const fence = openFence(lines[i]);
+    if (!fence) {
       prose.push(lines[i]);
       i += 1;
       continue;
@@ -74,13 +102,21 @@ function parseSegments(lines: string[]): Segment[] {
     let close: string | undefined;
     let j = i + 1;
     while (j < lines.length && close === undefined) {
-      if (FENCE_CLOSE.test(lines[j])) close = lines[j];
+      if (isCloseFence(lines[j], fence)) close = lines[j];
       else content.push(lines[j]);
       j += 1;
     }
     if (close === undefined) {
-      // Unterminated fence: fold the whole message conservatively as text.
-      return [{ kind: "prose", lines }];
+      // Unterminated fence: the block runs to the end of the message. Keep it
+      // as a code block with a synthesized closing fence so a folded preview
+      // never leaks an unclosed fence into the TUI.
+      segments.push({
+        kind: "code",
+        open,
+        content,
+        close: fence.char.repeat(fence.length),
+      });
+      return segments;
     }
     segments.push({ kind: "code", open, content, close });
     i = j;

package/extensions/web/index.ts

@@ -5,6 +5,11 @@ import type {
   ExtensionAPI,
   ExtensionCommandContext,
 } from "@earendil-works/pi-coding-agent";
+import {
+  missingPiCodingAgentDiagnostic,
+  PI_CODING_AGENT_ENTRY_ENV,
+  resolvePiCodingAgentEntry,
+} from "../../web/host/pi-coding-agent-entry.ts";
 
 const DEFAULT_SHUTDOWN_TIMEOUT_MS = 5_000;
 
@@ -26,12 +31,20 @@ interface SpawnWebOptions {
   stdio: "inherit";
 }
 
-function webProcessEnvironment(cwd: string) {
+function webProcessEnvironment(
+  cwd: string,
+  piCodingAgentEntry: string | undefined,
+) {
   const environment: NodeJS.ProcessEnv = { ...process.env, PWD: cwd };
   delete environment.OLDPWD;
   delete environment.INIT_CWD;
   delete environment.PI_SESSION_ID;
   delete environment.PI_SESSION_FILE;
+  if (piCodingAgentEntry) {
+    environment[PI_CODING_AGENT_ENTRY_ENV] = piCodingAgentEntry;
+  } else {
+    delete environment[PI_CODING_AGENT_ENTRY_ENV];
+  }
   return environment;
 }
 
@@ -40,6 +53,7 @@ export interface WebCommandDependencies {
   spawn(command: string, args: string[], options: SpawnWebOptions): WebProcess;
   clearTerminal(): void;
   holdParentSigint(): () => void;
+  resolvePiCodingAgentEntry(): string | undefined;
   shutdownTimeoutMs: number;
 }
 
@@ -65,6 +79,8 @@ const defaultDependencies: WebCommandDependencies = {
     process.on("SIGINT", keepPiAlive);
     return () => process.removeListener("SIGINT", keepPiAlive);
   },
+  resolvePiCodingAgentEntry: () =>
+    resolvePiCodingAgentEntry({ source: "host" }),
   shutdownTimeoutMs: DEFAULT_SHUTDOWN_TIMEOUT_MS,
 };
 
@@ -95,6 +111,7 @@ function runWebInForeground(
   dependencies: WebCommandDependencies,
   setActive: (active: ActiveWebProcess | undefined) => void,
   isShuttingDown: () => boolean,
+  piCodingAgentEntry: string,
 ) {
   return ctx.ui.custom<WebExit>((tui, _theme, _keybindings, done) => {
     let finished = false;
@@ -128,7 +145,7 @@ function runWebInForeground(
         [dependencies.entrypoint, "web", "--no-workspace"],
         {
           cwd: childCwd,
-          env: webProcessEnvironment(childCwd),
+          env: webProcessEnvironment(childCwd, piCodingAgentEntry),
           shell: false,
           stdio: "inherit",
         },
@@ -191,6 +208,11 @@ export default function web(
         ctx.ui.notify("OpenPI Web Workbench is already running.", "warning");
         return;
       }
+      const piCodingAgentEntry = dependencies.resolvePiCodingAgentEntry();
+      if (!piCodingAgentEntry) {
+        ctx.ui.notify(missingPiCodingAgentDiagnostic(), "error");
+        return;
+      }
 
       running = true;
       try {
@@ -201,6 +223,7 @@ export default function web(
             active = next;
           },
           () => shuttingDown,
+          piCodingAgentEntry,
         );
         if (shuttingDown) return;
         if (result.kind === "error") {

package/extensions/workflows/acceptance.ts

@@ -22,6 +22,25 @@ export interface AcceptanceLedger {
   readonly status: "accepted" | "rejected" | "missing" | "malformed";
   readonly criteria: readonly AcceptanceCriterionResult[];
   readonly errors: readonly string[];
+  /** Child-authored judgment retained only for migration; never a runtime fact. */
+  readonly authority?: "model-self-attestation";
+  readonly deprecated?: {
+    readonly since: "0.5";
+    readonly removal: "1.0";
+  };
+}
+
+export const ACCEPTANCE_DEPRECATION_WARNING =
+  "acceptance is deprecated since OpenPI 0.5 and will be removed in 1.0; it is model self-attestation, not runtime-verified evidence, and does not determine ok";
+
+function ledger(
+  value: Omit<AcceptanceLedger, "authority" | "deprecated">,
+): AcceptanceLedger {
+  return {
+    ...value,
+    authority: "model-self-attestation",
+    deprecated: { since: "0.5", removal: "1.0" },
+  };
 }
 
 const ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
@@ -169,6 +188,12 @@ export function isAcceptanceLedger(value: unknown): value is AcceptanceLedger {
       value.status === "rejected" ||
       value.status === "missing" ||
       value.status === "malformed") &&
+    (value.authority === undefined ||
+      value.authority === "model-self-attestation") &&
+    (value.deprecated === undefined ||
+      (record(value.deprecated) &&
+        value.deprecated.since === "0.5" &&
+        value.deprecated.removal === "1.0")) &&
     value.errors.every((error) => typeof error === "string") &&
     value.criteria.every(
       (criterion) =>
@@ -187,7 +212,7 @@ export function acceptanceInstruction(contract: AcceptanceContract) {
       `- ${criterion.id}: ${criterion.description}${criterion.requiredEvidence?.length ? `; required evidence labels: ${criterion.requiredEvidence.join(", ")}` : ""}`,
   );
   return [
-    "Acceptance is explicit evidence, not a self-awarded success claim.",
+    "Deprecated compatibility protocol: this acceptance ledger is your own model self-attestation, not runtime-verified evidence, and it does not determine execution success.",
     "Include an `acceptance.criteria` array in structured_output with exactly these ids. Mark rejected when the criterion is not demonstrated. Evidence entries must be concise labels or concrete references; do not invent evidence.",
     ...criteria,
   ].join("\n");
@@ -198,19 +223,19 @@ export function evaluateAcceptance(
   structured: unknown,
 ): AcceptanceLedger {
   if (!record(structured) || !record(structured.acceptance)) {
-    return {
+    return ledger({
       status: "missing",
       criteria: [],
       errors: ["structured result omitted acceptance"],
-    };
+    });
   }
   const rawCriteria = structured.acceptance.criteria;
   if (!Array.isArray(rawCriteria)) {
-    return {
+    return ledger({
       status: "malformed",
       criteria: [],
       errors: ["acceptance.criteria is not an array"],
-    };
+    });
   }
   const errors: string[] = [];
   const byId = new Map<string, AcceptanceCriterionResult>();
@@ -265,14 +290,15 @@ export function evaluateAcceptance(
       errors.push(`unexpected acceptance criterion "${id}"`);
     }
   }
-  if (errors.length) return { status: "malformed", criteria: results, errors };
-  return {
+  if (errors.length)
+    return ledger({ status: "malformed", criteria: results, errors });
+  return ledger({
     status: results.every((result) => result.status === "accepted")
       ? "accepted"
       : "rejected",
     criteria: results,
     errors: [],
-  };
+  });
 }
 
 export function applyAcceptance(options: {
@@ -284,15 +310,13 @@ export function applyAcceptance(options: {
   const ledger = options.contract
     ? evaluateAcceptance(options.contract, options.structured)
     : undefined;
-  const acceptanceError =
-    ledger && ledger.status !== "accepted"
-      ? `Acceptance ${ledger.status}${ledger.errors.length ? `: ${ledger.errors.join("; ")}` : ": one or more criteria were rejected"}`
-      : undefined;
-  const ok = options.agentOk && !acceptanceError;
-  const error = ok
-    ? undefined
-    : options.agentError
-      ? `${options.agentError}${acceptanceError ? `; ${acceptanceError}` : ""}`
-      : (acceptanceError ?? "Agent failed");
-  return { ok, ...(ledger ? { ledger } : {}), ...(error ? { error } : {}) };
+  const ok = options.agentOk;
+  const error = ok ? undefined : (options.agentError ?? "Agent failed");
+  return {
+    ok,
+    ...(ledger
+      ? { ledger, acceptanceWarning: ACCEPTANCE_DEPRECATION_WARNING }
+      : {}),
+    ...(error ? { error } : {}),
+  };
 }

package/extensions/workflows/completion-projection.ts

@@ -230,7 +230,9 @@ function buildOperatorReport(
               : "running";
       lines.push(
         `- [${agent.label}]${agent.phase ? ` (${agent.phase})` : ""} ${state}` +
-          (agent.acceptance ? ` · acceptance ${agent.acceptance.status}` : "") +
+          (agent.acceptance
+            ? ` · deprecated model self-attestation ${agent.acceptance.status}`
+            : "") +
           (agent.error ? ` — ${agent.error}` : ""),
       );
     }

package/extensions/workflows/dashboard.ts

@@ -220,6 +220,14 @@ function normalizeDelivery(value: unknown): WorkflowDetails["delivery"] {
       : 0;
   return {
     id: sanitizeLine(record.id, 256),
+    ...(typeof record.ownerSessionId === "string" && record.ownerSessionId
+      ? { ownerSessionId: sanitizeLine(record.ownerSessionId, 256) }
+      : {}),
+    ...(typeof record.ownerEpoch === "number" &&
+    Number.isSafeInteger(record.ownerEpoch) &&
+    record.ownerEpoch >= 0
+      ? { ownerEpoch: record.ownerEpoch }
+      : {}),
     state,
     attempts,
     updatedAt,

package/extensions/workflows/index.ts

@@ -55,6 +55,7 @@ import {
 import { fitNavigationSides } from "../shared/below-editor-navigation.ts";
 import { waitBounded } from "../shared/child-session.ts";
 import { contextPercent } from "../shared/context-utilization.ts";
+import { completionOwnerFor } from "../shared/completion-inbox.ts";
 import {
   registerEditorLayer,
   removeEditorLayer,
@@ -537,6 +538,8 @@ interface ScriptAgentResult {
   /** Opaque same-run handle for bounded downstream handoff. */
   ref?: string;
   acceptance?: AgentRecord["acceptance"];
+  /** Present only for the deprecated model self-attestation compatibility path. */
+  acceptanceWarning?: string;
   error?: string;
 }
 
@@ -857,6 +860,8 @@ export default function workflows(
   };
   const resultDelivery = createWorkflowResultDelivery({
     isIdle: () => lastContext?.isIdle() ?? false,
+    owner: () =>
+      lastContext ? completionOwnerFor(lastContext.sessionManager) : undefined,
     persist: (details) => {
       if (!details.delivery)
         throw new Error("Workflow delivery identity is missing");
@@ -1276,6 +1281,8 @@ export default function workflows(
         agents: [],
         delivery: {
           id: `workflow:${runId}:terminal`,
+          ownerSessionId: completionOwnerFor(ctx.sessionManager).sessionId,
+          ownerEpoch: completionOwnerFor(ctx.sessionManager).epoch,
           state: launchMode === "inline" ? "held-for-inline" : "none",
           attempts: 0,
           updatedAt: now,
@@ -1880,6 +1887,9 @@ export default function workflows(
               : {}),
             ...(ref ? { ref } : {}),
             ...(record.acceptance ? { acceptance: record.acceptance } : {}),
+            ...(judged.acceptanceWarning
+              ? { acceptanceWarning: judged.acceptanceWarning }
+              : {}),
           };
         }
 
@@ -2131,6 +2141,9 @@ export default function workflows(
                   : {}),
                 ...(ref ? { ref } : {}),
                 ...(acceptance ? { acceptance } : {}),
+                ...(judged.acceptanceWarning
+                  ? { acceptanceWarning: judged.acceptanceWarning }
+                  : {}),
                 ...(record.error !== undefined ? { error: record.error } : {}),
               };
             } finally {