@tt-a1i/openpi 0.3.0 → 0.4.0

package/extensions/workflows/model.ts

@@ -9,6 +9,7 @@ import {
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { formatContextUtilization } from "../shared/context-utilization.ts";
+import { spinnerFrame } from "../shared/spinner.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import type { WorktreeCleanup } from "../shared/worktree.ts";
 import type { AcceptanceLedger } from "./acceptance.ts";
@@ -47,8 +48,31 @@ export function emptyUsage(): AgentUsage {
   };
 }
 
-export type AgentState = "running" | "done" | "error";
-export type WorkflowStatus = "running" | "completed" | "failed" | "aborted";
+export type AgentState = "running" | "done" | "error" | "uncertain";
+export type WorkflowStatus =
+  | "running"
+  | "completed"
+  | "failed"
+  | "aborted"
+  | "uncertain";
+
+export type WorkflowDeliveryState =
+  | "none"
+  | "held-for-inline"
+  | "pending"
+  | "delivered"
+  | "consumed-inline";
+
+/** Durable completion-delivery plane, independent from execution status. */
+export interface WorkflowDelivery {
+  /** Stable per-run idempotency identity, never a transport-batch id. */
+  id: string;
+  state: WorkflowDeliveryState;
+  attempts: number;
+  updatedAt: number;
+  deliveredAt?: number;
+  lastError?: string;
+}
 
 export type TranscriptRole =
   | "user"
@@ -84,6 +108,8 @@ export interface AgentRecord {
   inputCallIds?: string[];
   /** Opaque same-run reference returned to the workflow script. */
   resultRef?: string;
+  /** Run-directory-relative authoritative result captured before projection. */
+  resultArtifact?: string;
   label: string;
   phase?: string;
   state: AgentState;
@@ -124,6 +150,8 @@ export interface WorkflowDetails {
   name?: string;
   description?: string;
   background: boolean;
+  /** Whether this run's terminal result is pending, delivered, or inline. */
+  delivery?: WorkflowDelivery;
   status: WorkflowStatus;
   startedAt: number;
   finishedAt?: number;
@@ -334,19 +362,31 @@ export function createUsageReader(agents: readonly AgentRecord[]) {
   };
 }
 
-/** Colored square state indicator (no emojis/glyphs). */
-export const SQUARE = "■";
-
-export function stateSquare(state: AgentState, theme: Theme): string {
-  if (state === "done") return theme.fg("success", SQUARE);
-  if (state === "error") return theme.fg("error", SQUARE);
-  return theme.fg("warning", SQUARE);
+/**
+ * One status indicator per state, shared by the transcript card, the
+ * dashboard, and the strips. Running spins on the package-wide cadence so
+ * every live view animates in step.
+ */
+export function stateGlyph(
+  state: AgentState,
+  theme: Theme,
+  now: number,
+): string {
+  if (state === "done") return theme.fg("success", "✓");
+  if (state === "error") return theme.fg("error", "✗");
+  if (state === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("warning", spinnerFrame(now));
 }
 
-export function statusSquare(status: WorkflowStatus, theme: Theme): string {
-  if (status === "completed") return theme.fg("success", SQUARE);
-  if (status === "running") return theme.fg("warning", SQUARE);
-  return theme.fg("error", SQUARE);
+export function statusGlyph(
+  status: WorkflowStatus,
+  theme: Theme,
+  now: number,
+): string {
+  if (status === "completed") return theme.fg("success", "✓");
+  if (status === "running") return theme.fg("warning", spinnerFrame(now));
+  if (status === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("error", "✗");
 }
 
 export function statusWord(status: WorkflowStatus): string {
@@ -357,7 +397,7 @@ export function statusColor(
   status: WorkflowStatus,
 ): "success" | "warning" | "error" {
   if (status === "completed") return "success";
-  if (status === "running") return "warning";
+  if (status === "running" || status === "uncertain") return "warning";
   return "error";
 }
 
@@ -420,13 +460,15 @@ export function aggregateUsage(agents: AgentRecord[]): AgentUsage {
 export function countStates(details: WorkflowDetails) {
   let done = 0;
   let failed = 0;
+  let uncertain = 0;
   let running = 0;
   for (const agent of details.agents) {
     if (agent.state === "done") done++;
     else if (agent.state === "error") failed++;
+    else if (agent.state === "uncertain") uncertain++;
     else running++;
   }
-  return { done, failed, running };
+  return { done, failed, uncertain, running };
 }
 
 export interface PhaseGroup {

package/extensions/workflows/navigation.ts

@@ -4,7 +4,9 @@ import {
   BelowEditorStripState,
   belowEditorStripInput,
   fitNavigationSides,
+  renderNavigationMetrics,
 } from "../shared/below-editor-navigation.ts";
+import { SPINNER_INTERVAL_MS, spinnerFrame } from "../shared/spinner.ts";
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import {
   aggregateUsage,
@@ -12,9 +14,9 @@ import {
   formatElapsed,
   formatTokens,
   statusColor,
-  statusSquare,
   type Theme,
   type WorkflowDetails,
+  type WorkflowStatus,
 } from "./model.ts";
 
 /** Workflow-named aliases preserve the public seam while sharing interaction. */
@@ -33,6 +35,17 @@ function cleanLine(value: string) {
   return sanitizeTerminalText(value).replace(/\s+/g, " ").trim();
 }
 
+/**
+ * One status indicator per run state; doubles as the focus marker when
+ * selected. Running spins, in step with the dashboard and takeover headers.
+ */
+function statusGlyph(status: WorkflowStatus, theme: Theme, now: number) {
+  if (status === "completed") return theme.fg("success", "✓");
+  if (status === "running") return theme.fg("warning", spinnerFrame(now));
+  if (status === "uncertain") return theme.fg("warning", "?");
+  return theme.fg("error", "✗");
+}
+
 /** Live, one-line Claude-style workflow entry rendered below the editor. */
 export class WorkflowStripWidget {
   private readonly timer: ReturnType<typeof setInterval>;
@@ -51,7 +64,10 @@ export class WorkflowStripWidget {
     this.theme = theme;
     this.strip = strip;
     this.getEntry = getEntry;
-    this.timer = setInterval(() => this.tui.requestRender(), 500);
+    this.timer = setInterval(
+      () => this.tui.requestRender(),
+      SPINNER_INTERVAL_MS,
+    );
     this.timer.unref?.();
   }
 
@@ -65,29 +81,32 @@ export class WorkflowStripWidget {
     const entry = this.getEntry();
     if (!entry || width <= 0) return [];
     const details = entry.details;
-    const { done, failed } = countStates(details);
+    const { done, failed, uncertain } = countStates(details);
     const settled = done + failed;
     const usage = aggregateUsage(details.agents);
     const tokenCount = usage.input + usage.output;
-    const marker = this.strip.focused
+    const glyph = this.strip.focused
       ? this.theme.fg("accent", "❯")
-      : this.theme.fg("dim", "○");
+      : statusGlyph(details.status, this.theme, Date.now());
     const displayName = cleanLine(details.name ?? entry.runId) || entry.runId;
     const name = this.strip.focused
       ? this.theme.bold(this.theme.fg("accent", displayName))
       : this.theme.fg("text", displayName);
     const rawContext = details.currentPhase ?? details.description;
     const context = rawContext ? cleanLine(rawContext) : undefined;
-    const left = ` ${marker} ${statusSquare(details.status, this.theme)} ${name}${context ? this.theme.fg("dim", ` · ${context}`) : ""}`;
-    const metrics = [
-      `${settled}/${details.agents.length} agents`,
-      formatElapsed(details.startedAt, details.finishedAt),
-      tokenCount > 0 ? `${formatTokens(tokenCount)} tokens` : undefined,
+    const left = ` ${glyph} ${name}${context ? this.theme.fg("dim", ` · ${context}`) : ""}`;
+    const right = renderNavigationMetrics(
+      this.theme,
+      [
+        details.agents.length > 0
+          ? `${settled}/${details.agents.length} agents${uncertain ? ` · ${uncertain} uncertain` : ""}`
+          : undefined,
+        formatElapsed(details.startedAt, details.finishedAt),
+        tokenCount > 0 ? `${formatTokens(tokenCount)} tokens` : undefined,
+      ],
       this.strip.focused ? "enter open · ↑ back" : "↓ to manage",
-    ]
-      .filter((part): part is string => Boolean(part))
-      .join(" · ");
-    const right = this.theme.fg(statusColor(details.status), metrics);
+      details.status === "running" ? undefined : statusColor(details.status),
+    );
     return [fitNavigationSides(left, right, width)];
   }
 }

package/extensions/workflows/prompt.ts

@@ -1,4 +1,9 @@
 import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import {
+  allocateResultBudgets,
+  type ParentContextUsage,
+} from "../shared/result-budget.ts";
+import { projectText } from "../shared/text-projection.ts";
 import {
   countStates,
   formatElapsed,
@@ -7,13 +12,14 @@ import {
   type WorkflowDetails,
 } from "./model.ts";
 
-/** Model-facing schema descriptions for workflow source, arguments, and background mode. */
+/** Model-facing schema descriptions for workflow source and launch policy. */
 export const WORKFLOW_PARAMETER_DESCRIPTIONS = {
   script:
     "JavaScript workflow script. May start with `export const meta = {...}`, then use phase(), agent(), parallel(), args, and a final `return`.",
   args: "Optional JSON string exposed to the script as `args` (parsed when valid JSON, otherwise passed through as the raw string).",
   background:
-    "Run in the background: the tool returns a run id immediately and you receive a follow-up message when the workflow finishes. Defaults to false (blocking with live progress).",
+    "Deprecated compatibility alias: true means wait=false; false means wait=true. Do not provide both background and wait.",
+  wait: "Wait for the final result in this tool call. Interactive sessions default to false and deliver completion later; print/automation defaults to true. Interrupting the wait does not cancel the workflow.",
   resumeFromRunId:
     "Optional prior run id or unique suffix for safe read-only replay. See the workflows Skill for matching rules.",
 };
@@ -29,7 +35,7 @@ export const WORKFLOW_STOP_PARAMETER_DESCRIPTIONS = {
 
 /** Describes nonblocking inspection of workflow runs, mirroring subagent_check/subagent_list. */
 export const WORKFLOW_STATUS_TOOL_DESCRIPTION =
-  "Peek at background workflow runs without blocking. With a run id, returns that run's phases, per-agent status, and result if finished; without one, lists this session's active and recently finished runs. Does not wait — use background:false when you need the result inline.";
+  "Peek at workflow runs without blocking. With a run id, returns a bounded status and coverage summary plus the artifact location; without one, lists this session's active and recently finished runs. Does not wait, consume a completion, or repeat the full final result.";
 
 /** Model-facing schema description for the optional workflow run id to inspect. */
 export const WORKFLOW_STATUS_PARAMETER_DESCRIPTIONS = {
@@ -44,9 +50,11 @@ export const WORKFLOW_LIFECYCLE_PROMPT_SNIPPET =
 /** Compact resident contract; the workflows Skill carries the complete guide. */
 export const WORKFLOW_TOOL_DESCRIPTION = [
   "Use the workflow tool when the user explicitly requests a workflow run or when the task clearly requires multi-phase dynamic orchestration.",
-  "Write an async JavaScript body using optional meta, phase(), log(), usage(), agent(), pipeline(), parallel(), args, and a JSON-serializable return.",
+  "Write an async JavaScript body using optional meta, phase(), log(), usage(), agent(), pipeline(), parallel(), args, and a JSON-serializable return. usage().limits reports the resolved concurrency and remaining call capacity.",
   "agent() returns { ok, output, structured?, ref?, error? }; always check `.ok`, use a schema for branching, and surface failed or null results.",
   "Prefer pipeline() for independent multi-stage items. Use parallel() only for a real barrier where the next step needs every prior result.",
+  "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.",
 ].join("\n");
@@ -80,11 +88,11 @@ export function buildWorkflowResultMessage(
   details: WorkflowDetails,
   runDir: string,
 ) {
-  const { done, failed } = countStates(details);
+  const { done, failed, uncertain } = countStates(details);
   const elapsed = formatElapsed(details.startedAt, details.finishedAt);
   const lines = [
     `Workflow ${details.name ? `"${details.name}"` : details.runId} ${details.status} — ` +
-      `${done}/${details.agents.length} agents ok${failed ? `, ${failed} failed` : ""} ` +
+      `${done}/${details.agents.length} agents ok${failed ? `, ${failed} failed` : ""}${uncertain ? `, ${uncertain} uncertain` : ""} ` +
       `across ${details.phases.length} phase(s) in ${elapsed}.`,
     `Run dir: ${shortenHome(runDir)}`,
   ];
@@ -144,7 +152,9 @@ export function buildWorkflowResultMessage(
             : "ok"
           : agent.state === "error"
             ? "FAILED"
-            : "running";
+            : agent.state === "uncertain"
+              ? "UNCERTAIN"
+              : "running";
       lines.push(
         `- [${agent.label}]${agent.phase ? ` (${agent.phase})` : ""} ${status}` +
           (agent.acceptance ? ` · acceptance ${agent.acceptance.status}` : "") +
@@ -157,6 +167,31 @@ export function buildWorkflowResultMessage(
   return sanitizeTerminalText(lines.join("\n"));
 }
 
+/** One bounded model projection; exact run/agent results remain in artifacts. */
+export function buildProjectedWorkflowResultMessage(
+  details: WorkflowDetails,
+  runDir: string,
+  usage?: ParentContextUsage | null,
+) {
+  const full = buildWorkflowResultMessage(details, runDir);
+  const allocation = allocateResultBudgets(
+    [Buffer.byteLength(full, "utf8")],
+    usage,
+    {
+      maxBatchBytes: 48 * 1024,
+      maxResultBytes: 48 * 1024,
+      minResultBytes: 8 * 1024,
+      headroomShare: 0.25,
+      estimatedBytesPerToken: 4,
+    },
+  );
+  return projectText(full, {
+    maxBytes: allocation.budgets[0] ?? 8 * 1024,
+    maxLines: 400,
+    recovery: `Full workflow evidence is available in ${shortenHome(runDir)}.`,
+  });
+}
+
 /** Builds the follow-up message that delivers a settled background workflow to the parent model. */
 export function buildBackgroundWorkflowFollowUp(options: {
   runId: string;
@@ -167,7 +202,47 @@ export function buildBackgroundWorkflowFollowUp(options: {
   // Sentence lead-in matching the subagent/terminal completion messages.
   const label = options.name ? `"${options.name}"` : options.runId;
   const verb = options.status === "completed" ? "finished" : options.status;
-  return `Background workflow ${label} (${options.runId}) ${verb}.\n\n${options.result}`;
+  return `Background workflow ${label} (${options.runId}) ${verb}.\n\n${options.result}\n\n(This result is already shown to the user. Act on it and relay only the decisions or next steps — do not repeat it verbatim.)`;
+}
+
+/** Fairly project one transport batch against the parent's current headroom. */
+export function buildProjectedWorkflowCompletionBatch(
+  entries: readonly {
+    deliveryId: string;
+    details: WorkflowDetails;
+    runDir: string;
+  }[],
+  usage?: ParentContextUsage | null,
+) {
+  const full = entries.map(({ deliveryId, details, runDir }) =>
+    buildBackgroundWorkflowFollowUp({
+      runId: details.runId,
+      name: details.name,
+      status: details.status,
+      result: `${buildWorkflowResultMessage(details, runDir)}\n\nDelivery id: ${deliveryId}`,
+    }),
+  );
+  const separatorBytes = Math.max(0, entries.length - 1) * 2;
+  const allocation = allocateResultBudgets(
+    full.map((message) => Buffer.byteLength(message, "utf8")),
+    usage,
+    {
+      maxBatchBytes: 48 * 1024 - separatorBytes,
+      maxResultBytes: 48 * 1024,
+      minResultBytes: 1024,
+      headroomShare: 0.25,
+      estimatedBytesPerToken: 4,
+    },
+  );
+  return full
+    .map((message, index) =>
+      projectText(message, {
+        maxBytes: allocation.budgets[index] ?? 1024,
+        maxLines: 400,
+        recovery: `Full workflow evidence is available in ${shortenHome(entries[index]!.runDir)}; duplicate deliveries carry the same delivery id.`,
+      }),
+    )
+    .join("\n\n");
 }
 
 /** Builds the background-launch result and tells the parent model how to inspect or stop the run. */
@@ -182,3 +257,24 @@ export function buildBackgroundWorkflowLaunchResult(options: {
     `Its result will be delivered to you when it finishes, or use workflow_status(runId: "${options.runId}") to peek and workflow_stop(runId: "${options.runId}") to cancel; /workflows shows progress.`,
   ].join("\n");
 }
+
+/** Pure observation: bounded status/coverage without replaying final output. */
+export function buildWorkflowStatusSummary(
+  details: WorkflowDetails,
+  runDir: string,
+) {
+  const { done, failed, uncertain } = countStates(details);
+  const settled = done + failed;
+  return [
+    `Workflow ${details.name ? `"${details.name}"` : details.runId} ${details.status}.`,
+    details.status === "uncertain"
+      ? "Recovery warning: the prior owner disappeared without terminal evidence; some external effects may have occurred."
+      : undefined,
+    `Coverage: ${settled}/${details.agents.length} agents settled (${done} ok, ${failed} failed)${uncertain ? `; ${uncertain} uncertain` : ""}.`,
+    details.currentPhase ? `Current phase: ${details.currentPhase}` : undefined,
+    details.delivery ? `Delivery: ${details.delivery.state}.` : undefined,
+    `Artifacts: ${shortenHome(runDir)}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}

package/extensions/workflows/replay-safety.ts

@@ -1,5 +1,5 @@
-import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { homedir } from "node:os";
 import * as path from "node:path";
@@ -17,6 +17,9 @@ const REPLAY_FILESYSTEM_TOOL_NAMES = new Set([
   "ls",
   "fd",
   "rg",
+  "git_show",
+  "git_diff",
+  "git_log",
 ]);
 const REPLAY_BUILTIN_FILESYSTEM_TOOL_NAMES = new Set([
   "read",
@@ -24,7 +27,13 @@ const REPLAY_BUILTIN_FILESYSTEM_TOOL_NAMES = new Set([
   "find",
   "ls",
 ]);
-const REPLAY_PACKAGE_FILESYSTEM_TOOL_NAMES = new Set(["fd", "rg"]);
+const REPLAY_PACKAGE_FILESYSTEM_TOOL_NAMES = new Set([
+  "fd",
+  "rg",
+  "git_show",
+  "git_diff",
+  "git_log",
+]);
 const GIT_OUTPUT_LIMIT = 32 * 1024 * 1024;
 const REPLAY_IDENTITY_TIMEOUT_MS = 5_000;
 const REPLAY_RESOURCE_FILE_LIMIT = 8 * 1024 * 1024;
@@ -179,12 +188,13 @@ function hasKnownReplayFilesystemImplementation(tool: {
     );
   }
   if (!REPLAY_PACKAGE_FILESYSTEM_TOOL_NAMES.has(tool.name)) return false;
+  // fd/rg come from file-search; the read-only git tools from git-read.
+  const ownerSourceSuffix = tool.name.startsWith("git_")
+    ? "/extensions/git-read/index.ts"
+    : "/extensions/file-search/index.ts";
   return (
     tool.sourceInfo?.origin === "package" &&
-    tool.sourceInfo.path
-      .split(path.sep)
-      .join("/")
-      .endsWith("/extensions/file-search/index.ts")
+    tool.sourceInfo.path.split(path.sep).join("/").endsWith(ownerSourceSuffix)
   );
 }
 

package/extensions/workflows/result-delivery.ts

@@ -0,0 +1,189 @@
+import type { WorkflowDetails } from "./model.ts";
+
+export interface WorkflowCompletionEnvelope {
+  deliveryId: string;
+  runId: string;
+  details: WorkflowDetails;
+}
+
+export interface WorkflowDeliveryReceipt {
+  deliveryId: string;
+  delivered: boolean;
+  error?: string;
+}
+
+export interface WorkflowResultDeliveryOptions {
+  isIdle: () => boolean;
+  persist: (details: WorkflowDetails) => void;
+  deliver: (
+    envelopes: readonly WorkflowCompletionEnvelope[],
+    wake: boolean,
+  ) => Promise<readonly WorkflowDeliveryReceipt[]>;
+}
+
+function errorText(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/**
+ * Durable, per-run workflow completion delivery.
+ *
+ * Execution status remains authoritative in WorkflowDetails. This module owns
+ * only the orthogonal delivery plane. A transport batch is an optimization:
+ * every run keeps its own stable delivery id and receipt so partial success
+ * can be retried without duplicating siblings.
+ */
+export function createWorkflowResultDelivery(
+  options: WorkflowResultDeliveryOptions,
+) {
+  const pending = new Map<string, WorkflowCompletionEnvelope>();
+  let flushing: Promise<void> | undefined;
+
+  const persistState = (
+    details: WorkflowDetails,
+    state: NonNullable<WorkflowDetails["delivery"]>["state"],
+    patch: Partial<NonNullable<WorkflowDetails["delivery"]>> = {},
+  ) => {
+    const delivery = details.delivery;
+    if (!delivery) throw new Error("Workflow delivery identity is missing");
+    const next = {
+      ...delivery,
+      ...patch,
+      state,
+      updatedAt: Date.now(),
+    };
+    if (patch.lastError === undefined) delete next.lastError;
+    details.delivery = next;
+    options.persist(details);
+  };
+
+  const enqueue = (envelope: WorkflowCompletionEnvelope) => {
+    pending.set(envelope.deliveryId, envelope);
+  };
+
+  const flush = async (wake: boolean) => {
+    if (flushing) return flushing;
+    if (pending.size === 0) return;
+    const envelopes = [...pending.values()];
+    for (const envelope of envelopes) pending.delete(envelope.deliveryId);
+
+    flushing = (async () => {
+      let receipts: readonly WorkflowDeliveryReceipt[];
+      try {
+        receipts = await options.deliver(envelopes, wake);
+      } catch (error) {
+        const message = errorText(error);
+        for (const envelope of envelopes) {
+          enqueue(envelope);
+          persistState(envelope.details, "pending", {
+            attempts: (envelope.details.delivery?.attempts ?? 0) + 1,
+            lastError: message,
+          });
+        }
+        return;
+      }
+
+      const byId = new Map(
+        receipts.map((receipt) => [receipt.deliveryId, receipt] as const),
+      );
+      for (const envelope of envelopes) {
+        const receipt = byId.get(envelope.deliveryId);
+        if (receipt?.delivered) {
+          try {
+            persistState(envelope.details, "delivered", {
+              attempts: (envelope.details.delivery?.attempts ?? 0) + 1,
+              deliveredAt: Date.now(),
+              lastError: undefined,
+            });
+          } catch (error) {
+            // The transport already accepted the message, but the durable
+            // receipt did not commit. Retain it for at-least-once recovery;
+            // the visible stable id lets the parent recognize a rare replay.
+            enqueue(envelope);
+            const delivery = envelope.details.delivery;
+            if (delivery) {
+              envelope.details.delivery = {
+                ...delivery,
+                state: "pending",
+                updatedAt: Date.now(),
+                lastError: `Delivery receipt persistence failed: ${errorText(error)}`,
+              };
+            }
+          }
+          continue;
+        }
+        enqueue(envelope);
+        persistState(envelope.details, "pending", {
+          attempts: (envelope.details.delivery?.attempts ?? 0) + 1,
+          lastError:
+            receipt?.error ?? "Completion delivery was not acknowledged",
+        });
+      }
+    })().finally(() => {
+      flushing = undefined;
+    });
+    return flushing;
+  };
+
+  return {
+    /** Register inline interest before the run starts. */
+    holdInline(details: WorkflowDetails) {
+      persistState(details, "held-for-inline");
+    },
+
+    /** Terminal won the wait/abort arbitration and will be returned inline. */
+    consumeInline(details: WorkflowDetails) {
+      if (details.delivery) pending.delete(details.delivery.id);
+      persistState(details, "consumed-inline", {
+        deliveredAt: Date.now(),
+        lastError: undefined,
+      });
+    },
+
+    /** Abort won the wait/terminal arbitration; deliver the result later. */
+    releaseInline(envelope: WorkflowCompletionEnvelope) {
+      persistState(envelope.details, "pending", { lastError: undefined });
+      enqueue(envelope);
+      if (options.isIdle()) void flush(true);
+    },
+
+    /** Queue a detached run after terminal status and pending are persisted. */
+    defer(envelope: WorkflowCompletionEnvelope) {
+      persistState(envelope.details, "pending", { lastError: undefined });
+      enqueue(envelope);
+      if (options.isIdle()) void flush(true);
+    },
+
+    /** Restore only explicitly pending/held new-format runs. */
+    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") {
+        persistState(envelope.details, "pending", {
+          lastError: "Inline waiter was not active after session restart",
+        });
+      }
+      enqueue(envelope);
+      return true;
+    },
+
+    parentSettled() {
+      return flush(true);
+    },
+
+    flushIfIdle() {
+      if (!options.isIdle()) return Promise.resolve();
+      return flush(true) ?? Promise.resolve();
+    },
+
+    size() {
+      return pending.size;
+    },
+
+    clear() {
+      pending.clear();
+    },
+  };
+}

package/extensions/workflows/sandbox-child.cjs

@@ -207,6 +207,11 @@ const BOOTSTRAP = String.raw`
       const value = raw && typeof raw === "object" ? raw[key] : undefined;
       return typeof value === "number" && Number.isFinite(value) ? value : 0;
     };
+    const readLimit = (key) => {
+      const limits = raw && typeof raw === "object" ? raw.limits : undefined;
+      const value = limits && typeof limits === "object" ? limits[key] : undefined;
+      return typeof value === "number" && Number.isFinite(value) ? value : 0;
+    };
     // Every field is coerced, so a missing or malformed snapshot reads as zero
     // rather than undefined: a script doing arithmetic on it gets 0, not NaN.
     return deepFreeze({
@@ -217,6 +222,12 @@ const BOOTSTRAP = String.raw`
       total: read("total"),
       cost: read("cost"),
       agents: read("agents"),
+      limits: {
+        concurrency: readLimit("concurrency"),
+        maxAgentCalls: readLimit("maxAgentCalls"),
+        callsUsed: readLimit("callsUsed"),
+        callsRemaining: readLimit("callsRemaining"),
+      },
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tt-a1i/openpi",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "OpenPI — a Pi-native multi-agent workbench with background execution, isolated subagents, replay-safe workflows, goals, tasks, and observable TUI",
   "license": "MIT",
   "author": "tt-a1i",