@tt-a1i/openpi 0.5.0 → 0.6.1

package/extensions/workflows/index.ts

@@ -53,8 +53,13 @@ import {
   formatActivityStatus,
 } from "../shared/activity-status.ts";
 import { fitNavigationSides } from "../shared/below-editor-navigation.ts";
-import { waitBounded } from "../shared/child-session.ts";
+import {
+  inheritedChildToolAllowlist,
+  resolveStandaloneChildProjectTrust,
+  waitBounded,
+} from "../shared/child-session.ts";
 import { contextPercent } from "../shared/context-utilization.ts";
+import { completionOwnerFor } from "../shared/completion-inbox.ts";
 import {
   registerEditorLayer,
   removeEditorLayer,
@@ -537,10 +542,13 @@ 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;
 }
 
 interface AgentCallOptions {
+  working_dir?: unknown;
   agent_type?: unknown;
   label?: unknown;
   phase?: unknown;
@@ -857,6 +865,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 +1286,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,
@@ -1332,11 +1344,12 @@ export default function workflows(
         structured: boolean,
         cwd: string,
         agentTypePrompt?: string,
+        childProjectTrusted = projectTrusted,
       ) =>
         createWorkflowResources(
           cwd,
           structured ? "structured" : "plain",
-          projectTrusted,
+          childProjectTrusted,
           agentTypePrompt,
         );
 
@@ -1631,6 +1644,36 @@ export default function workflows(
           );
         }
 
+        const childTools = inheritedChildToolAllowlist(
+          pi.getActiveTools(),
+          agentType?.tools,
+        );
+        if (
+          opts.working_dir !== undefined &&
+          (typeof opts.working_dir !== "string" || !opts.working_dir.trim())
+        ) {
+          return fail(
+            `agent "${label}": working_dir must be a non-empty string`,
+          );
+        }
+        const requestedCwd = path.resolve(
+          ctx.cwd,
+          typeof opts.working_dir === "string" ? opts.working_dir : ".",
+        );
+        try {
+          if (!fs.statSync(requestedCwd).isDirectory())
+            throw new Error("not a directory");
+        } catch {
+          return fail(
+            `agent "${label}": working_dir is not a directory: ${requestedCwd}`,
+          );
+        }
+        const childProjectTrusted = resolveStandaloneChildProjectTrust({
+          parentCwd: ctx.cwd,
+          childCwd: requestedCwd,
+          parentTrusted: projectTrusted,
+        });
+
         const explicitModel =
           typeof opts.model === "string" && opts.model.trim()
             ? opts.model.trim()
@@ -1701,11 +1744,14 @@ export default function workflows(
         const operatorFingerprint = operatorKey
           ? agentCallKey("workflow-operator", {
               execution: {
+                cwd: requestedCwd,
+                projectTrusted: childProjectTrusted,
+                tools: childTools,
                 agentType: agentType
                   ? {
                       name: agentType.name,
                       body: agentType.body,
-                      tools: agentType.tools,
+                      tools: childTools,
                     }
                   : undefined,
                 model: model ? `${model.provider}/${model.id}` : undefined,
@@ -1725,7 +1771,7 @@ export default function workflows(
         const replaySafe =
           operatorKey === undefined &&
           isReplaySafeAgentCall({
-            tools: agentType?.tools,
+            tools: agentType?.tools === undefined ? undefined : childTools,
             isolation: opts.isolation,
           });
         const replayLease = beginProcessReplayWorkspaceLease(replaySafe);
@@ -1737,13 +1783,14 @@ export default function workflows(
           try {
             replayResources = await getResources(
               effectiveSchema !== undefined,
-              ctx.cwd,
+              requestedCwd,
               agentType?.body,
+              childProjectTrusted,
             );
             replayIdentity = createReplayIdentity(
-              ctx.cwd,
+              requestedCwd,
               replayResources.loader,
-              projectTrusted,
+              childProjectTrusted,
             );
           } catch {
             // Fingerprinting is an optimization boundary. If resources cannot
@@ -1761,7 +1808,7 @@ export default function workflows(
                 ? {
                     name: agentType.name,
                     body: agentType.body,
-                    tools: agentType.tools,
+                    tools: childTools,
                   }
                 : undefined,
               model: model ? `${model.provider}/${model.id}` : undefined,
@@ -1880,6 +1927,9 @@ export default function workflows(
               : {}),
             ...(ref ? { ref } : {}),
             ...(record.acceptance ? { acceptance: record.acceptance } : {}),
+            ...(judged.acceptanceWarning
+              ? { acceptanceWarning: judged.acceptanceWarning }
+              : {}),
           };
         }
 
@@ -1915,7 +1965,7 @@ export default function workflows(
                 );
               }
               const created = await createWorktree({
-                cwd: ctx.cwd,
+                cwd: requestedCwd,
                 label,
                 id: `${details.runId}-${record.index}`,
               });
@@ -1927,18 +1977,19 @@ export default function workflows(
               worktree = created.worktree;
               if (!runSettled) record.worktreeBranch = worktree.branch;
             }
-            if (runSignal.aborted || runSettled) {
-              throw runSignal.reason instanceof Error
-                ? runSignal.reason
-                : new Error("Workflow was aborted");
-            }
-            const agentCwd = worktree?.path ?? ctx.cwd;
+            const agentCwd = worktree?.path ?? requestedCwd;
 
             // Inside the try, not before it: building resources can throw
             // (bad settings, an unreadable skills dir), and a throw out here
             // would skip the finally and leak the worktree permanently —
             // nothing sweeps `.git/pi-worktrees/` afterwards.
             try {
+              if (runSignal.aborted || runSettled) {
+                throw runSignal.reason instanceof Error
+                  ? runSignal.reason
+                  : new Error("Workflow was aborted");
+              }
+
               let rejectResourceLoad: (() => void) | undefined;
               const resourceAbort = new Promise<never>((_resolve, reject) => {
                 rejectResourceLoad = () =>
@@ -1958,6 +2009,7 @@ export default function workflows(
                     effectiveSchema !== undefined,
                     agentCwd,
                     agentType?.body,
+                    childProjectTrusted,
                   ),
                 resourceAbort,
               ]).finally(() => {
@@ -1982,7 +2034,7 @@ export default function workflows(
                   settingsManager: resources.settingsManager,
                   ...(sessionManager ? { sessionManager } : {}),
                   modelRegistry: ctx.modelRegistry,
-                  ...(agentType?.tools ? { tools: agentType.tools } : {}),
+                  tools: childTools,
                   ...(testAgentSessionFactory
                     ? { sessionFactory: testAgentSessionFactory }
                     : {}),
@@ -2098,9 +2150,9 @@ export default function workflows(
               // unfingerprintable calls always run for real.
               const completedIdentity = callKey
                 ? createReplayIdentity(
-                    ctx.cwd,
+                    requestedCwd,
                     resources.loader,
-                    projectTrusted,
+                    childProjectTrusted,
                   )
                 : undefined;
               const completedKey = completedIdentity
@@ -2131,6 +2183,9 @@ export default function workflows(
                   : {}),
                 ...(ref ? { ref } : {}),
                 ...(acceptance ? { acceptance } : {}),
+                ...(judged.acceptanceWarning
+                  ? { acceptanceWarning: judged.acceptanceWarning }
+                  : {}),
                 ...(record.error !== undefined ? { error: record.error } : {}),
               };
             } finally {
@@ -2144,7 +2199,7 @@ export default function workflows(
                   runId: details.runId,
                   agentIndex: record.index,
                   agentLabel: record.label,
-                  repoCwd: ctx.cwd,
+                  repoCwd: requestedCwd,
                   worktree,
                 });
                 let cleanup: WorktreeCleanup;
@@ -2161,7 +2216,7 @@ export default function workflows(
                   const reclaimer =
                     workflowLifecycleTestHooks?.reclaimWorktree ??
                     reclaimWorktree;
-                  cleanup = await reclaimer(ctx.cwd, worktree).catch(
+                  cleanup = await reclaimer(requestedCwd, worktree).catch(
                     (error): WorktreeCleanup => ({
                       removed: false,
                       branchDeleted: false,

package/extensions/workflows/model.ts

@@ -67,6 +67,10 @@ export type WorkflowDeliveryState =
 export interface WorkflowDelivery {
   /** Stable per-run idempotency identity, never a transport-batch id. */
   id: string;
+  /** Destination transcript identity; legacy records fall back to run.sessionId. */
+  ownerSessionId?: string;
+  /** Process-local generation of the Pi SessionManager owner. */
+  ownerEpoch?: number;
   state: WorkflowDeliveryState;
   attempts: number;
   updatedAt: number;
@@ -123,7 +127,7 @@ export interface AgentRecord {
   usage: AgentUsage;
   /** Replayed from a prior run's journal instead of actually executed. */
   replayed?: boolean;
-  /** Explicit caller-supplied acceptance result; never inferred from role/task. */
+  /** Deprecated child self-attestation; never runtime-observed evidence. */
   acceptance?: AcceptanceLedger;
   /** Branch of the isolated worktree this agent ran in, when it holds commits. */
   worktreeBranch?: string;

package/extensions/workflows/progress-projection.ts

@@ -250,8 +250,11 @@ export class AgentProgressProjection {
   snapshot(
     toolTimings: ReadonlyMap<string, ProgressToolTiming> = new Map(),
   ): AgentProgressProjectionSnapshot {
+    // Reserve the initial task, then spend the remaining byte budget on the
+    // newest evidence. Forward selection would silently discard final errors
+    // after enough large tool results, even below the entry-count limit.
     const selected = this.firstEntry
-      ? [this.firstEntry, ...this.tailEntries]
+      ? [this.firstEntry, ...this.tailEntries.slice().reverse()]
       : [];
     const transcript: TranscriptEntry[] = [];
     let totalBytes = 0;
@@ -277,6 +280,9 @@ export class AgentProgressProjection {
           : { timestamp: entry.timestamp }),
       });
     }
+    // Budgeting order is not display order: keep the retained tail chronological.
+    const newestFirstTail = transcript.splice(1);
+    transcript.push(...newestFirstTail.reverse());
     if (transcript.length < this.totalEntries) {
       transcript.push({
         role: "toolResult",

package/extensions/workflows/prompt.ts

@@ -56,7 +56,7 @@ export const WORKFLOW_TOOL_DESCRIPTION = [
   "Interactive sessions launch in the background by default and deliver completion later. Set wait: true only when this tool call must return the final result inline.",
   "Derive fan-out from independent verifiable work items and task difficulty. Concurrency is a runtime ceiling, not a target or the total-call limit; user cost, count, model, and effort constraints take precedence.",
   "For concurrent writers use isolation: 'worktree' and tell each agent to commit. Read-only work should normally stay in the shared checkout.",
-  "Read the workflows Skill before a nontrivial script; it covers the restricted sandbox, full DSL, acceptance, result refs, replay, background lifecycle, limits, and examples.",
+  "Read the workflows Skill before a nontrivial script; it covers the restricted sandbox, full DSL, result refs, replay, background lifecycle, limits, and examples.",
 ].join("\n");
 
 /** Adds workflow orchestration primitives and background execution to the model's tool prompt. */
@@ -75,14 +75,6 @@ export function buildWorkflowAgentPrompt(prompt: string) {
   return prompt;
 }
 
-/** Instructs structured workflow children to terminate with exactly one structured_output call. */
-export const STRUCTURED_OUTPUT_SYSTEM_INSTRUCTION =
-  "When your task is complete, call the `structured_output` tool exactly once as your final action, with fields matching the required schema. Do not write any other text after it.";
-
-/** Describes the terminating structured_output tool and its final-action contract. */
-export const STRUCTURED_OUTPUT_TOOL_DESCRIPTION =
-  "Return your final result as structured data matching the required schema. Call this exactly once, as your last action; do not write any other text after it.";
-
 /** Builds the workflow completion report returned to the parent model. */
 export function buildWorkflowResultMessage(
   details: WorkflowDetails,
@@ -157,7 +149,9 @@ export function buildWorkflowResultMessage(
               : "running";
       lines.push(
         `- [${agent.label}]${agent.phase ? ` (${agent.phase})` : ""} ${status}` +
-          (agent.acceptance ? ` · acceptance ${agent.acceptance.status}` : "") +
+          (agent.acceptance
+            ? ` · deprecated model self-attestation ${agent.acceptance.status}`
+            : "") +
           (agent.error ? ` — ${agent.error}` : ""),
       );
     }

package/extensions/workflows/result-delivery.ts

@@ -1,8 +1,13 @@
-import type { WorkflowDetails } from "./model.ts";
+import {
+  type CompletionEnvelope,
+  type CompletionOwner,
+  createCompletionInbox,
+} from "../shared/completion-inbox.ts";
 import type {
   DurableResultDeliveryQueue,
   DurableResultDeliveryReceipt,
 } from "../shared/result-delivery.ts";
+import type { WorkflowDetails } from "./model.ts";
 
 export interface WorkflowCompletionEnvelope {
   deliveryId: string;
@@ -12,6 +17,7 @@ export interface WorkflowCompletionEnvelope {
 
 export interface WorkflowResultDeliveryOptions {
   isIdle: () => boolean;
+  owner?: () => CompletionOwner | undefined;
   persist: (details: WorkflowDetails) => void;
   deliver: (
     envelopes: readonly WorkflowCompletionEnvelope[],
@@ -34,7 +40,9 @@ function errorText(error: unknown) {
 export function createWorkflowResultDelivery(
   options: WorkflowResultDeliveryOptions,
 ) {
-  const pending = new Map<string, WorkflowCompletionEnvelope>();
+  const inbox = createCompletionInbox<WorkflowCompletionEnvelope>();
+  const currentOwner =
+    options.owner ?? (() => ({ sessionId: "test", epoch: 0 }));
   let flushing: Promise<void> | undefined;
   let flushRequested = false;
   let wakeRequested = false;
@@ -57,10 +65,44 @@ export function createWorkflowResultDelivery(
     options.persist(details);
   };
 
-  const enqueue = (envelope: WorkflowCompletionEnvelope) => {
-    pending.set(envelope.deliveryId, envelope);
+  const inboxEnvelope = (
+    envelope: WorkflowCompletionEnvelope,
+  ): CompletionEnvelope<WorkflowCompletionEnvelope> => {
+    const delivery = envelope.details.delivery;
+    const deliverySessionId = delivery?.ownerSessionId;
+    const detailsSessionId = envelope.details.sessionId;
+
+    // Conflicting owner fields invalidate delivery ownership fail-closed.
+    const hasConflict =
+      deliverySessionId !== undefined &&
+      detailsSessionId !== undefined &&
+      deliverySessionId !== detailsSessionId;
+
+    const ownerSessionId = hasConflict ? undefined : deliverySessionId;
+    return {
+      deliveryId: envelope.deliveryId,
+      owner: {
+        sessionId:
+          ownerSessionId && ownerSessionId !== "unowned"
+            ? ownerSessionId
+            : "unowned",
+        epoch: delivery?.ownerEpoch ?? 0,
+      },
+      producer: "workflow",
+      producerId: envelope.runId,
+      terminalRef: {
+        kind: "workflow-terminal",
+        runId: envelope.runId,
+        status: envelope.details.status,
+      },
+      wake: "producer-policy",
+      payload: envelope,
+    };
   };
 
+  const enqueue = (envelope: WorkflowCompletionEnvelope) =>
+    inbox.defer(inboxEnvelope(envelope), currentOwner());
+
   const retainPending = (
     envelope: WorkflowCompletionEnvelope,
     patch: Partial<NonNullable<WorkflowDetails["delivery"]>>,
@@ -69,7 +111,7 @@ export function createWorkflowResultDelivery(
     // Memory owns the retry before persistence is attempted. A broken disk
     // must not make this envelope, or any sibling after it, disappear from the
     // current process.
-    enqueue(envelope);
+    const admitted = enqueue(envelope);
     try {
       persistState(envelope.details, "pending", patch);
     } catch (error) {
@@ -83,6 +125,7 @@ export function createWorkflowResultDelivery(
         };
       }
     }
+    return admitted;
   };
 
   const flush = async (wake: boolean) => {
@@ -91,17 +134,16 @@ export function createWorkflowResultDelivery(
       wakeRequested ||= wake;
       return flushing;
     }
-    if (pending.size === 0) return;
+    if (inbox.size() === 0) return;
 
     flushing = (async () => {
       let passWake = wake;
-      while (pending.size > 0) {
+      while (inbox.size() > 0) {
         flushRequested = false;
         wakeRequested = false;
-        const envelopes = [...pending.values()];
-        for (const envelope of envelopes) {
-          pending.delete(envelope.deliveryId);
-        }
+        const claimed = inbox.claim(currentOwner());
+        const envelopes = claimed.map((envelope) => envelope.payload);
+        if (envelopes.length === 0) break;
 
         let receipts: readonly DurableResultDeliveryReceipt[] | undefined;
         try {
@@ -109,6 +151,7 @@ export function createWorkflowResultDelivery(
         } catch (error) {
           const message = errorText(error);
           for (const envelope of envelopes) {
+            inbox.acknowledge([envelope.deliveryId]);
             retainPending(
               envelope,
               {
@@ -127,6 +170,7 @@ export function createWorkflowResultDelivery(
           for (const envelope of envelopes) {
             const receipt = byId.get(envelope.deliveryId);
             if (receipt?.delivered) {
+              inbox.acknowledge([envelope.deliveryId]);
               try {
                 persistState(envelope.details, "delivered", {
                   attempts: (envelope.details.delivery?.attempts ?? 0) + 1,
@@ -150,6 +194,7 @@ export function createWorkflowResultDelivery(
               }
               continue;
             }
+            inbox.acknowledge([envelope.deliveryId]);
             retainPending(
               envelope,
               {
@@ -183,7 +228,7 @@ export function createWorkflowResultDelivery(
 
     /** Terminal won the wait/abort arbitration and will be returned inline. */
     consumeInline(details: WorkflowDetails) {
-      if (details.delivery) pending.delete(details.delivery.id);
+      if (details.delivery) inbox.consumeDeliveryIds([details.delivery.id]);
       persistState(details, "consumed-inline", {
         deliveredAt: Date.now(),
         lastError: undefined,
@@ -214,18 +259,46 @@ export function createWorkflowResultDelivery(
     restore(envelope: WorkflowCompletionEnvelope) {
       const state = envelope.details.delivery?.state;
       if (state !== "pending" && state !== "held-for-inline") return false;
-      // A process restart cannot still own the inline waiter. Deterministically
-      // reconstruct pending delivery from the terminal artifact.
-      if (state === "held-for-inline") {
-        retainPending(
+      const owner = currentOwner();
+      const deliverySessionId = envelope.details.delivery?.ownerSessionId;
+      const detailsSessionId = envelope.details.sessionId;
+      const hasConflict =
+        deliverySessionId !== undefined &&
+        detailsSessionId !== undefined &&
+        deliverySessionId !== detailsSessionId;
+      const storedSessionId = hasConflict
+        ? undefined
+        : (deliverySessionId ?? detailsSessionId);
+
+      // Restoring canonical producer state is the explicit owner-revival
+      // boundary. Rebind only the same transcript to this process-local
+      // SessionManager generation; a different Session still dead-letters.
+      if (
+        owner &&
+        storedSessionId !== undefined &&
+        storedSessionId === owner.sessionId
+      ) {
+        envelope.details.delivery = {
+          ...envelope.details.delivery!,
+          ownerSessionId: owner.sessionId,
+          ownerEpoch: owner.epoch,
+        };
+        return retainPending(
           envelope,
-          { lastError: "Inline waiter was not active after session restart" },
+          {
+            ownerSessionId: owner.sessionId,
+            ownerEpoch: owner.epoch,
+            lastError:
+              state === "held-for-inline"
+                ? "Inline waiter was not active after session restart"
+                : undefined,
+          },
           "Restored delivery state persistence failed",
         );
-      } else {
-        enqueue(envelope);
       }
-      return true;
+      // Keep the canonical terminal artifact pending, but record that this
+      // process is not its transcript owner instead of redirecting it.
+      return enqueue(envelope);
     },
 
     retryPending() {
@@ -242,12 +315,13 @@ export function createWorkflowResultDelivery(
     },
 
     size() {
-      return pending.size;
+      return inbox.size();
     },
 
     clear() {
-      pending.clear();
+      inbox.clear();
     },
+    inspectDeadLetters: inbox.inspectDeadLetters,
   };
   return queue satisfies DurableResultDeliveryQueue<WorkflowCompletionEnvelope>;
 }

package/extensions/workflows/retention.ts

@@ -237,6 +237,12 @@ function makeProjection(
       ? {
           delivery: {
             id: details.delivery.id,
+            ...(details.delivery.ownerSessionId
+              ? { ownerSessionId: details.delivery.ownerSessionId }
+              : {}),
+            ...(details.delivery.ownerEpoch !== undefined
+              ? { ownerEpoch: details.delivery.ownerEpoch }
+              : {}),
             state: details.delivery.state,
             attempts: details.delivery.attempts,
             updatedAt: details.delivery.updatedAt,