pi-extensible-workflows 0.3.0

package/dist/src/index.js

@@ -0,0 +1,2839 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { fork } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, dirname, extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as acorn from "acorn";
+import { Script } from "node:vm";
+import { Type } from "@earendil-works/pi-ai";
+import { Value } from "typebox/value";
+import { copyToClipboard, getAgentDir, parseFrontmatter, highlightCode, SessionManager, truncateToVisualLines } from "@earendil-works/pi-coding-agent";
+import { createNativeAgentSession, FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
+import { transcriptLines } from "./session-inspector.js";
+import { acquireSessionLease, listRunIds, RunStore, structuralPath as operationPath } from "./persistence.js";
+export const RUN_STATES = ["queued", "running", "pausing", "paused", "awaiting_input", "completed", "failed", "stopped", "interrupted"];
+export const AGENT_STATES = ["queued", "running", "waiting_for_child", "paused", "retrying", "completed", "failed", "cancelled"];
+export const WORKFLOW_ASYNC_STARTED_EVENT = "workflow:async-started";
+export const WORKFLOW_ASYNC_COMPLETE_EVENT = "workflow:async-complete";
+const SETTLED_AGENT_STATES = new Set(["completed", "failed", "cancelled"]);
+export const ERROR_CODES = [
+    "INVALID_SETTINGS", "INVALID_SYNTAX", "INVALID_METADATA", "DUPLICATE_NAME", "INVALID_SCHEMA", "UNKNOWN_MODEL", "UNKNOWN_TOOL", "UNKNOWN_AGENT_TYPE",
+    "RUN_LIMIT_EXCEEDED", "RUN_OWNED", "REGISTRY_FROZEN", "GLOBAL_COLLISION", "MISSING_WORKFLOW", "RPC_LIMIT_EXCEEDED", "AGENT_TIMEOUT", "AGENT_FAILED", "RESULT_INVALID",
+    "CANCELLED", "WORKER_UNRESPONSIVE", "WORKTREE_FAILED", "RESUME_INCOMPATIBLE", "INTERNAL_ERROR",
+];
+const LAUNCH_SNAPSHOT_IDENTITY_VERSION = 2;
+export class WorkflowError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "WorkflowError";
+    }
+}
+const WORKFLOW_AUTHORED_ERROR = Symbol("workflowAuthoredError");
+function errorText(error) { return error && typeof error === "object" && typeof error.message === "string" ? error.message : error instanceof Error ? error.message : String(error); }
+function errorCode(error) {
+    if (error instanceof WorkflowError)
+        return ERROR_CODES.includes(error.code) ? error.code : undefined;
+    if (!error || typeof error !== "object")
+        return undefined;
+    const code = error.code;
+    return typeof code === "string" && ERROR_CODES.includes(code) ? code : undefined;
+}
+function markWorkflowAuthored(error, authored = false) {
+    if (authored)
+        Object.defineProperty(error, WORKFLOW_AUTHORED_ERROR, { value: true });
+    return error;
+}
+function isWorkflowAuthored(error) { return Boolean(error && typeof error === "object" && WORKFLOW_AUTHORED_ERROR in error); }
+function workflowDetail(message) {
+    const detail = message.trim().replace(new RegExp(`\\b(?:${ERROR_CODES.join("|")})\\b:?\\s*`, "g"), "").replace(/^\s*[A-Z][A-Z0-9_]+:\s*/, "").split("\n").filter((line) => !/^\s*at\s/.test(line)).join("\n").replace(/^Run \S+(?=\s(?:exceeded|is))/i, "Run").replace(/\b[0-9a-f]{8}-[0-9a-f-]{27,}\b/gi, "the workflow").replace(/^(?:Pi )session \S+(?=\s(?:is|has))/i, "session").replace(/^(Unknown scheduler run|Missing production ownership record|Persisted agent belongs to another run):\s*\S+/i, "$1").replace(/\b(?:runId|sessionId|callSite|occurrence|failedAt|id)[:=]\s*\S+/gi, "").replace(/\s{2,}/g, " ").trim();
+    return detail || "No further details were provided";
+}
+const WORKFLOW_ERROR_PROSE = {
+    INVALID_SETTINGS: (detail) => `The workflow settings are invalid: ${detail}.`,
+    INVALID_SYNTAX: (detail) => `The workflow source is invalid: ${detail}.`,
+    INVALID_METADATA: (detail) => `The workflow metadata is invalid: ${detail}.`,
+    DUPLICATE_NAME: (detail) => `The workflow contains a duplicate name: ${detail}.`,
+    INVALID_SCHEMA: (detail) => `The workflow schema is invalid: ${detail}.`,
+    REGISTRY_FROZEN: (detail) => `Workflow extension registration is closed: ${detail}.`,
+    GLOBAL_COLLISION: (detail) => `The workflow global name is already in use: ${detail}.`,
+    MISSING_WORKFLOW: (detail) => `The workflow primitive is unavailable: ${detail}.`,
+    UNKNOWN_MODEL: (detail) => `The workflow requested the unavailable model ${detail.replace(/^(?:Unknown model(?: for role [^:]+)?|Invalid model spec):\s*/, "")}.`,
+    UNKNOWN_TOOL: (detail) => `The workflow requested the unavailable tool ${detail.replace(/^Unknown tool:\s*/, "")}.`,
+    UNKNOWN_AGENT_TYPE: (detail) => `The workflow requested the unavailable agent role ${detail.replace(/^Unknown agent role:\s*/, "")}.`,
+    RUN_LIMIT_EXCEEDED: (detail) => `The workflow exceeded its agent launch limit: ${detail.replace(/^Run\s+exceeded\s+/i, "")}.`,
+    RUN_OWNED: (detail) => /already owned|active ownership/.test(detail) ? "The workflow session is already in use." : `The workflow session is already in use: ${detail}.`,
+    RPC_LIMIT_EXCEEDED: (detail) => `The workflow communication data exceeded its size limit: ${detail}.`,
+    AGENT_TIMEOUT: (detail) => `The workflow agent timed out: ${detail}.`,
+    AGENT_FAILED: (detail) => `The workflow agent failed: ${detail}.`,
+    RESULT_INVALID: (detail) => `The workflow produced an invalid result: ${detail}.`,
+    CANCELLED: (detail) => `The workflow was cancelled: ${detail}.`,
+    WORKER_UNRESPONSIVE: (detail) => `The workflow worker stopped responding: ${detail}.`,
+    WORKTREE_FAILED: (detail) => `The workflow worktree operation failed: ${detail}.`,
+    RESUME_INCOMPATIBLE: (detail) => `The workflow cannot resume this run: ${detail}.`,
+    INTERNAL_ERROR: (detail) => `The workflow encountered an internal error: ${detail}.`,
+};
+export function formatWorkflowFailure(error) {
+    if (isWorkflowAuthored(error))
+        return errorText(error);
+    const code = errorCode(error);
+    if (code)
+        return WORKFLOW_ERROR_PROSE[code](workflowDetail(errorText(error)));
+    if (error instanceof Error)
+        return error.message || "The workflow failed without an error message.";
+    return `The workflow failed with value ${String(error)}.`;
+}
+function workflowErrorFromWorker(error) {
+    const code = errorCode(error);
+    const typed = markWorkflowAuthored(new WorkflowError(code ?? "INTERNAL_ERROR", error.message), error.authored || !code);
+    return error.failedAt === undefined ? typed : Object.assign(typed, { failedAt: error.failedAt });
+}
+function asWorkflowError(error) {
+    const code = errorCode(error);
+    return markWorkflowAuthored(error instanceof WorkflowError && code ? error : new WorkflowError(code ?? "INTERNAL_ERROR", errorText(error)), isWorkflowAuthored(error) || !code);
+}
+function mainAgentError(error) {
+    const typed = asWorkflowError(error);
+    const presented = new WorkflowError(typed.code, formatWorkflowFailure(typed));
+    Object.assign(presented, typed);
+    presented.message = formatWorkflowFailure(typed);
+    return presented;
+}
+export class RunLifecycle {
+    changed;
+    #state;
+    #active = 0;
+    #waiters = [];
+    constructor(state = "running", changed) {
+        this.changed = changed;
+        this.#state = state;
+    }
+    get state() { return this.#state; }
+    async enter() {
+        while (this.#state === "pausing" || this.#state === "paused" || this.#state === "awaiting_input")
+            await new Promise((resolve) => { this.#waiters.push(resolve); });
+        if (this.#state !== "running")
+            throw new WorkflowError("CANCELLED", `Run is ${this.#state}`);
+        this.#active += 1;
+    }
+    async leave() {
+        if (this.#active > 0)
+            this.#active -= 1;
+        if (this.#state === "pausing" && this.#active === 0)
+            await this.#set("paused");
+    }
+    async enterAwaitingInput() {
+        while (this.#state === "pausing" || this.#state === "paused")
+            await new Promise((resolve) => { this.#waiters.push(resolve); });
+        if (this.#state === "awaiting_input")
+            return;
+        if (this.#state !== "running")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot await input for ${this.#state} run`);
+        await this.#set("awaiting_input");
+    }
+    async resolveAwaitingInput() {
+        if (this.#state !== "awaiting_input")
+            return;
+        await this.#set("running");
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async pause() {
+        if (this.#state !== "running")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot pause ${this.#state} run`);
+        await this.#set("pausing");
+        if (this.#active === 0)
+            await this.#set("paused");
+    }
+    async resume() {
+        if (this.#state !== "paused" && this.#state !== "interrupted")
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Cannot resume ${this.#state} run`);
+        await this.#set("running");
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async providerPause() {
+        await this.leave();
+        if (this.#state === "running")
+            await this.pause();
+        await this.enter();
+    }
+    async terminal(state) {
+        if (["completed", "failed", "stopped"].includes(this.#state))
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `${this.#state} runs are terminal`);
+        await this.#set(state);
+        for (const resolve of this.#waiters.splice(0))
+            resolve();
+    }
+    async #set(state) { this.#state = state; await this.changed?.(state); }
+}
+export const DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, maxAgentLaunches: 1000 });
+function fail(code, message) { throw new WorkflowError(code, message); }
+function object(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
+function positiveInteger(value) { return Number.isInteger(value) && value > 0; }
+export function parseModelReference(value) {
+    const match = /^([^/:\s]+)\/([^:\s]+)(?::([^:\s]+))?$/.exec(value);
+    if (!match?.[1] || !match[2])
+        fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+    const thinking = match[3];
+    if (thinking && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(thinking))
+        fail("UNKNOWN_MODEL", `Invalid thinking level: ${thinking}`);
+    return { provider: match[1], model: match[2], ...(thinking ? { thinking: thinking } : {}) };
+}
+function modelCapability(value) {
+    const parsed = parseModelReference(value);
+    return `${parsed.provider}/${parsed.model}`;
+}
+export function validateCheckpoint(value) {
+    if (!object(value) || Object.keys(value).some((key) => !["name", "prompt", "context"].includes(key)) || typeof value.name !== "string" || value.name.trim() === "" || typeof value.prompt !== "string" || !jsonValue(value.context))
+        fail("INVALID_METADATA", "checkpoint requires only name, prompt, and JSON context");
+    if (Buffer.byteLength(value.prompt) > 1024)
+        fail("INVALID_METADATA", "checkpoint prompt exceeds 1024 UTF-8 bytes");
+    if (Buffer.byteLength(JSON.stringify(value.context)) > 4096)
+        fail("INVALID_METADATA", "checkpoint context exceeds 4096 UTF-8 bytes");
+    return { name: value.name, prompt: value.prompt, context: value.context };
+}
+export function workflowSettingsPath(agentDir = getAgentDir()) { return join(agentDir, ROLE_DIRECTORY, "settings.json"); }
+export function loadSettings(path = workflowSettingsPath()) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return DEFAULT_SETTINGS;
+        fail("INVALID_SETTINGS", `Invalid workflow settings: ${errorText(error)}`);
+    }
+    if (!object(parsed))
+        fail("INVALID_SETTINGS", "Workflow settings must be an object");
+    const allowed = new Set(["concurrency", "maxAgentLaunches"]);
+    const unknown = Object.keys(parsed).find((key) => !allowed.has(key));
+    if (unknown)
+        fail("INVALID_SETTINGS", `Unknown workflow setting: ${unknown}`);
+    const concurrency = parsed.concurrency === undefined ? DEFAULT_SETTINGS.concurrency : parsed.concurrency;
+    const maxAgentLaunches = parsed.maxAgentLaunches === undefined ? DEFAULT_SETTINGS.maxAgentLaunches : parsed.maxAgentLaunches;
+    if (!positiveInteger(concurrency) || concurrency > 16)
+        fail("INVALID_SETTINGS", "concurrency must be an integer from 1 to 16");
+    if (!positiveInteger(maxAgentLaunches))
+        fail("INVALID_SETTINGS", "maxAgentLaunches must be a positive integer");
+    return Object.freeze({ concurrency, maxAgentLaunches });
+}
+export function parseRoleMarkdown(content, strict = false) {
+    if (!strict) {
+        if (!content.startsWith("---\n"))
+            return { prompt: content };
+        const end = content.indexOf("\n---", 4);
+        if (end < 0)
+            return { prompt: content };
+        const meta = {};
+        for (const line of content.slice(4, end).split("\n")) {
+            const match = /^(model|thinking|tools|description)\s*:\s*(.+)$/.exec(line.trim());
+            if (match?.[1] && match[2])
+                meta[match[1]] = match[2].trim();
+        }
+        const tools = meta.tools ? meta.tools.replace(/^\[|\]$/g, "").split(",").map((tool) => tool.trim().replace(/^[']|[']$/g, "").replace(/^["]|["]$/g, "")).filter(Boolean) : undefined;
+        const thinking = meta.thinking?.replace(/^[']|[']$/g, "").replace(/^["]|["]$/g, "");
+        if (thinking && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(thinking))
+            fail("INVALID_METADATA", `Invalid role thinking level: ${thinking}`);
+        const definition = { prompt: content.slice(end + 4).replace(/^\n/, "") };
+        if (meta.model)
+            definition.model = meta.model.replace(/^[']|[']$/g, "").replace(/^["]|["]$/g, "");
+        if (meta.description)
+            definition.description = meta.description.replace(/^[']|[']$/g, "").replace(/^["]|["]$/g, "");
+        if (thinking)
+            definition.thinking = thinking;
+        if (tools)
+            definition.tools = tools;
+        return definition;
+    }
+    const normalized = content.replace(/\r\n?/g, "\n");
+    if (normalized.startsWith("---\n") && normalized.indexOf("\n---", 3) < 0)
+        fail("INVALID_METADATA", "Role frontmatter is missing its closing delimiter");
+    let parsed;
+    try {
+        parsed = parseFrontmatter(content);
+    }
+    catch (error) {
+        fail("INVALID_METADATA", `Invalid role frontmatter: ${errorText(error)}`);
+    }
+    if (!object(parsed.frontmatter))
+        fail("INVALID_METADATA", "Role frontmatter must be an object");
+    const { model, thinking, tools, description } = parsed.frontmatter;
+    if (model !== undefined && (typeof model !== "string" || model.trim() === ""))
+        fail("INVALID_METADATA", "Role model must be a non-empty string");
+    if (thinking !== undefined && (typeof thinking !== "string" || !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(thinking)))
+        fail("INVALID_METADATA", `Invalid role thinking level: ${typeof thinking === "string" ? thinking : typeof thinking}`);
+    if (description !== undefined && (typeof description !== "string" || description.trim() === "" || description.length > 1024 || /[\r\n]/.test(description)))
+        fail("INVALID_METADATA", "Role description must be a non-empty single-line string of at most 1024 characters");
+    if (tools !== undefined && (!Array.isArray(tools) || tools.some((tool) => typeof tool !== "string" || tool.trim() === "")))
+        fail("INVALID_METADATA", "Role tools must be an array of non-empty strings");
+    return { prompt: parsed.body, ...(typeof description === "string" ? { description: description.trim() } : {}), ...(typeof model === "string" ? { model: model.trim() } : {}), ...(typeof thinking === "string" ? { thinking: thinking } : {}), ...(Array.isArray(tools) ? { tools: tools.map((tool) => tool.trim()) } : {}) };
+}
+const ROLE_DIRECTORY = "pi-extensible-workflows";
+export function workflowRoleDirectories(agentDir = getAgentDir()) {
+    return [join(agentDir, ROLE_DIRECTORY, "roles")];
+}
+function projectRoleDirectories(root) {
+    return [join(root, ROLE_DIRECTORY, "roles")];
+}
+function readAgentDefinitions(dir) {
+    try {
+        return Object.fromEntries(readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && extname(entry.name) === ".md")
+            .map((entry) => [basename(entry.name, ".md"), parseRoleMarkdown(readFileSync(join(dir, entry.name), "utf8"), true)]));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw error;
+    }
+}
+function readRoleDefinitions(dirs) {
+    return Object.fromEntries(dirs.flatMap((dir) => Object.entries(readAgentDefinitions(dir))));
+}
+export function loadAgentDefinitions(cwd, agentDir = getAgentDir(), projectTrusted = true) {
+    return deepFreeze({ ...readRoleDefinitions(workflowRoleDirectories(agentDir)), ...(projectTrusted ? readRoleDefinitions(projectRoleDirectories(join(cwd, ".pi"))) : {}) });
+}
+function validateRolePolicies(definitions, roles, availableModels, rootTools) {
+    for (const role of roles) {
+        const definition = definitions[role];
+        if (!definition)
+            continue;
+        if (definition.model !== undefined && !availableModels.has(modelCapability(definition.model)))
+            fail("UNKNOWN_MODEL", `Unknown model for role ${role}: ${definition.model}`);
+        const missingTool = (definition.tools ?? [...rootTools]).find((tool) => !rootTools.has(tool));
+        if (missingTool)
+            fail("UNKNOWN_TOOL", `Unknown tool for role ${role}: ${missingTool}`);
+    }
+}
+function validateWorkflowMetadata(value) {
+    if (!object(value) || typeof value.name !== "string" || value.name.trim() === "")
+        fail("INVALID_METADATA", "Workflow metadata requires a non-empty name");
+    if (value.description !== undefined && (typeof value.description !== "string" || value.description.trim() === ""))
+        fail("INVALID_METADATA", "Workflow description must be a non-empty string when provided");
+    if (Object.keys(value).some((key) => !["name", "description"].includes(key)))
+        fail("INVALID_METADATA", "Unknown workflow metadata");
+    return Object.freeze({ name: value.name.trim(), ...(typeof value.description === "string" ? { description: value.description.trim() } : {}) });
+}
+function workflowBody(script) {
+    if (typeof script !== "string" || script.trim() === "")
+        fail("INVALID_SYNTAX", "Workflow script must be non-empty");
+    try {
+        const program = acorn.parse(script, { ecmaVersion: "latest", sourceType: "module", allowReturnOutsideFunction: true });
+        const first = program.body[0];
+        if (first?.type === "ExportNamedDeclaration" && first.declaration?.type === "VariableDeclaration") {
+            const declarator = first.declaration.declarations[0];
+            if (declarator?.id.type === "Identifier" && declarator.id.name === "meta")
+                return script.slice(first.end).replace(/^\s*/, "");
+        }
+        return script;
+    }
+    catch (error) {
+        fail("INVALID_SYNTAX", `Invalid workflow syntax: ${errorText(error)}`);
+    }
+}
+function parseWorkflow(script) {
+    const body = workflowBody(script);
+    try {
+        new Script(`(async()=>{${body}\n})`);
+        return acorn.parse(body, { ecmaVersion: "latest", sourceType: "module", allowReturnOutsideFunction: true });
+    }
+    catch (error) {
+        fail("INVALID_SYNTAX", `Invalid workflow syntax: ${errorText(error)}`);
+    }
+}
+function astNode(value) {
+    return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function workflowCalls(program) {
+    const calls = [];
+    const visit = (node) => {
+        if (node.type === "CallExpression" && node.callee.type === "Identifier" && ["agent", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"].includes(node.callee.name))
+            calls.push(node);
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const child of value)
+                    if (astNode(child))
+                        visit(child);
+            }
+            else if (astNode(value))
+                visit(value);
+        }
+    };
+    visit(program);
+    return calls.sort((left, right) => left.start - right.start);
+}
+function workflowCallsWithStructure(program) {
+    const calls = [];
+    const visit = (node, context) => {
+        let current = context;
+        if (node.type === "Property" && current.structure.length) {
+            const scope = current.structure.at(-1);
+            const key = node.key.type === "Identifier" ? node.key.name : node.key.type === "Literal" ? String(node.key.value) : undefined;
+            if (scope?.key === null && key)
+                current = { ...current, structure: [...current.structure.slice(0, -1), { ...scope, key }] };
+        }
+        if (node.type === "CallExpression" && node.callee.type === "Identifier" && ["agent", "parallel", "pipeline", "checkpoint", "phase", "withWorktree"].includes(node.callee.name)) {
+            const call = node;
+            const operation = call.callee.name;
+            const execution = operation === "parallel" ? "parallel" : operation === "pipeline" ? "sequential" : current.execution;
+            calls.push({ call, execution, structure: current.structure });
+            for (const [index, argument] of call.arguments.entries()) {
+                if (argument.type === "SpreadElement")
+                    continue;
+                const scopeKind = operation === "parallel" && index === 1 ? "parallel" : operation === "pipeline" && index === 2 ? "pipeline" : undefined;
+                visit(argument, scopeKind ? { execution, structure: [...current.structure, { kind: scopeKind, name: staticString(callArgument(call, 0)), key: null }] } : current);
+            }
+            return;
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const child of value)
+                    if (astNode(child))
+                        visit(child, current);
+            }
+            else if (astNode(value))
+                visit(value, current);
+        }
+    };
+    visit(program, { execution: "sequential", structure: [] });
+    return calls.sort((left, right) => left.call.start - right.call.start);
+}
+function validateDirectPrimitiveReferences(program, name) {
+    const visit = (node, parent) => {
+        if (node.type === "Identifier" && node.name === name) {
+            const directCall = parent?.type === "CallExpression" && parent.callee === node;
+            const propertyKey = parent?.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand;
+            if (!directCall && !propertyKey)
+                fail("INVALID_METADATA", `${name} calls must use a direct ${name}(...) call; aliases and indirect calls are unsupported`);
+        }
+        for (const value of Object.values(node)) {
+            if (Array.isArray(value)) {
+                for (const child of value)
+                    if (astNode(child))
+                        visit(child, node);
+            }
+            else if (astNode(value))
+                visit(value, node);
+        }
+    };
+    visit(program);
+}
+function hasIdentifier(node, name) {
+    if (node.type === "Identifier" && node.name === name)
+        return true;
+    return Object.values(node).some((value) => Array.isArray(value) ? value.some((child) => astNode(child) && hasIdentifier(child, name)) : astNode(value) && hasIdentifier(value, name));
+}
+const INTERNAL_AGENT_NAME = "__pi_extensible_workflows_agent";
+const INTERNAL_WORKTREE_NAME = "__pi_extensible_workflows_withWorktree";
+function callHasTrailingComma(source, call) {
+    let previous;
+    let current;
+    for (const token of acorn.tokenizer(source.slice(call.start, call.end), { ecmaVersion: "latest", sourceType: "module" })) {
+        previous = current;
+        current = token;
+    }
+    return current?.type.label === ")" && previous?.type.label === ",";
+}
+function instrumentWorkflow(script) {
+    const body = workflowBody(script);
+    if (!body.trim())
+        return body;
+    const program = parseWorkflow(body);
+    if (hasIdentifier(program, INTERNAL_AGENT_NAME))
+        fail("INVALID_METADATA", `${INTERNAL_AGENT_NAME} is reserved for workflow agent instrumentation`);
+    if (hasIdentifier(program, INTERNAL_WORKTREE_NAME))
+        fail("INVALID_METADATA", `${INTERNAL_WORKTREE_NAME} is reserved for workflow withWorktree instrumentation`);
+    const calls = workflowCalls(program).filter((call) => ["agent", "withWorktree"].includes(call.callee.name));
+    const edits = calls.flatMap((call) => {
+        const callSite = `${String(call.start)}:${String(call.end)}`;
+        const hiddenArgument = call.arguments.length === 0 || callHasTrailingComma(body, call) ? "" : ", ";
+        return [
+            { start: call.callee.start, end: call.callee.end, text: call.callee.name === "agent" ? INTERNAL_AGENT_NAME : INTERNAL_WORKTREE_NAME },
+            { start: call.end - 1, end: call.end - 1, text: `${hiddenArgument}${JSON.stringify(callSite)}` },
+        ];
+    }).sort((left, right) => right.start - left.start);
+    let instrumented = body;
+    for (const edit of edits)
+        instrumented = instrumented.slice(0, edit.start) + edit.text + instrumented.slice(edit.end);
+    return instrumented;
+}
+function literalString(node) {
+    return node?.type === "Literal" && typeof node.value === "string" ? node.value : undefined;
+}
+function propertyNode(node, name) {
+    if (node?.type !== "ObjectExpression")
+        return undefined;
+    for (let index = node.properties.length - 1; index >= 0; index -= 1) {
+        const property = node.properties[index];
+        if (!property || property.type === "SpreadElement" || property.computed)
+            return undefined;
+        const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+        if (key === name)
+            return property.value;
+    }
+    return undefined;
+}
+function stableName(node) {
+    if (!node)
+        return false;
+    if (node.type !== "ObjectExpression") {
+        if (["Literal", "ArrayExpression", "ArrowFunctionExpression", "FunctionExpression", "ClassExpression", "TemplateLiteral", "UnaryExpression", "UpdateExpression", "BinaryExpression"].includes(node.type))
+            return false;
+        return undefined;
+    }
+    let result = false;
+    for (const property of node.properties) {
+        if (property.type === "SpreadElement" || property.computed) {
+            result = undefined;
+            continue;
+        }
+        const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+        if (key !== "name")
+            continue;
+        const value = literalString(property.value);
+        result = value === undefined ? property.value.type === "Literal" ? false : undefined : value.trim() !== "";
+    }
+    return result;
+}
+function jsonValue(value, seen = new Set()) {
+    if (value === null || typeof value === "boolean" || typeof value === "string")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (typeof value !== "object" || seen.has(value))
+        return false;
+    if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+        return false;
+    const keys = Reflect.ownKeys(value);
+    if (keys.some((key) => typeof key !== "string"))
+        return false;
+    seen.add(value);
+    const values = Array.isArray(value) ? Array.from(value) : keys.map((key) => value[key]);
+    const valid = values.every((item) => jsonValue(item, seen));
+    seen.delete(value);
+    return valid;
+}
+function workflowPrompt(template, values) {
+    if (typeof template !== "string")
+        fail("INVALID_METADATA", "prompt() template must be a string");
+    if (!object(values) || Array.isArray(values) || !jsonValue(values))
+        fail("INVALID_METADATA", "prompt() values must be a plain JSON-compatible object");
+    const placeholders = [...template.matchAll(/{{|}}|{([A-Za-z_$][\w$]*)}/g)].flatMap((match) => match[1] === undefined ? [] : [match[1]]);
+    const used = new Set(placeholders);
+    const keys = Object.keys(values);
+    const missing = placeholders.find((key) => !Object.prototype.hasOwnProperty.call(values, key));
+    if (missing)
+        fail("INVALID_METADATA", `Missing prompt value "${missing}"`);
+    const unused = keys.find((key) => !used.has(key));
+    if (unused !== undefined)
+        fail("INVALID_METADATA", `Unused prompt value "${unused}"`);
+    return template.replace(/{{|}}|{([A-Za-z_$][\w$]*)}/g, (match, key) => match === "{{" ? "{" : match === "}}" ? "}" : typeof values[key] === "string" ? values[key] : JSON.stringify(values[key], null, 2));
+}
+function validateSchema(schema, at = "schema") {
+    if (!object(schema) || Object.getPrototypeOf(schema) !== Object.prototype || !jsonValue(schema))
+        fail("INVALID_SCHEMA", `${at} must be a plain JSON-compatible Schema object`);
+    if (typeof schema.type !== "string" && !Array.isArray(schema.type) && schema.$ref === undefined && schema.anyOf === undefined && schema.oneOf === undefined && schema.allOf === undefined && schema.const === undefined && schema.enum === undefined)
+        fail("INVALID_SCHEMA", `${at} has no JSON Schema shape`);
+    if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string")))
+        fail("INVALID_SCHEMA", `${at}.required must be an array of strings`);
+    if (schema.properties !== undefined && !object(schema.properties))
+        fail("INVALID_SCHEMA", `${at}.properties must be an object`);
+}
+const AGENT_OPTION_KEYS = new Set(["label", "model", "thinking", "tools", "role", "outputSchema", "retries", "timeoutMs"]);
+function validateAgentOption(key, value) {
+    switch (key) {
+        case "label":
+            if (typeof value !== "string" || !value.trim())
+                fail("INVALID_METADATA", "agent label must be a non-empty string");
+            break;
+        case "model":
+            if (typeof value !== "string")
+                fail("INVALID_METADATA", "agent model must be a string");
+            parseModelReference(value);
+            break;
+        case "thinking":
+            if (typeof value !== "string" || !parseThinking(value))
+                fail("INVALID_METADATA", "agent thinking must be off, minimal, low, medium, high, xhigh, or max");
+            break;
+        case "tools":
+            if (!Array.isArray(value) || value.some((tool) => typeof tool !== "string"))
+                fail("INVALID_METADATA", "agent tools must be an array of strings");
+            break;
+        case "role":
+            if (typeof value !== "string" || !value.trim())
+                fail("INVALID_METADATA", "agent role must be a non-empty string");
+            break;
+        case "outputSchema":
+            validateSchema(value, "agent outputSchema");
+            break;
+        case "retries":
+            if (!Number.isInteger(value) || value < 0)
+                fail("INVALID_METADATA", "agent retries must be a non-negative integer");
+            break;
+        case "timeoutMs":
+            if (value !== null && !positiveInteger(value))
+                fail("INVALID_METADATA", "agent timeoutMs must be null or a positive integer");
+            break;
+    }
+}
+function validateAgentOptions(value) {
+    if (!object(value) || !jsonValue(value))
+        fail("INVALID_METADATA", "agent options must be a JSON object");
+    const unknown = Object.keys(value).find((key) => !AGENT_OPTION_KEYS.has(key));
+    if (unknown)
+        fail("INVALID_METADATA", `Unknown agent option: ${unknown}`);
+    for (const [key, option] of Object.entries(value))
+        validateAgentOption(key, option);
+    if (typeof value.role === "string" && ["model", "thinking", "tools"].some((key) => Object.prototype.hasOwnProperty.call(value, key)))
+        fail("INVALID_METADATA", "Role agents must not specify model, thinking, or tools");
+    return value;
+}
+function staticValue(node) {
+    if (!node)
+        return { known: false };
+    if (node.type === "Literal")
+        return { known: true, value: node.value };
+    if (node.type === "UnaryExpression" && (node.operator === "-" || node.operator === "+")) {
+        const argument = staticValue(node.argument);
+        return argument.known && typeof argument.value === "number" ? { known: true, value: node.operator === "-" ? -argument.value : argument.value } : { known: false };
+    }
+    if (node.type === "ArrayExpression") {
+        const values = [];
+        for (const element of node.elements) {
+            if (!element || element.type === "SpreadElement")
+                return { known: false };
+            const value = staticValue(element);
+            if (!value.known)
+                return { known: false };
+            values.push(value.value);
+        }
+        return { known: true, value: values };
+    }
+    if (node.type === "ObjectExpression") {
+        const value = {};
+        for (const property of node.properties) {
+            if (property.type === "SpreadElement" || property.computed)
+                return { known: false };
+            const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+            const child = staticValue(property.value);
+            if (!key || !child.known)
+                return { known: false };
+            value[key] = child.value;
+        }
+        return { known: true, value };
+    }
+    return { known: false };
+}
+function callArgument(call, index) {
+    const argument = call.arguments[index];
+    return argument?.type === "SpreadElement" ? undefined : argument;
+}
+function staticString(node) {
+    const value = staticValue(node);
+    return value.known && typeof value.value === "string" ? value.value : null;
+}
+export function inspectWorkflowScript(script) {
+    return workflowCallsWithStructure(parseWorkflow(script)).map(({ call, execution, structure }) => {
+        const kind = call.callee.name;
+        const first = callArgument(call, 0);
+        const options = callArgument(call, 1);
+        const placement = { execution, structure };
+        if (kind === "agent") {
+            const retries = staticValue(propertyNode(options, "retries"));
+            const outputSchema = staticValue(propertyNode(options, "outputSchema"));
+            const optionKeys = options?.type === "ObjectExpression" ? options.properties.flatMap((property) => {
+                if (property.type === "SpreadElement" || property.computed)
+                    return [];
+                const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+                return key ? [key] : [];
+            }) : [];
+            const knownOptions = Object.fromEntries(optionKeys.flatMap((key) => { const value = staticValue(propertyNode(options, key)); return value.known && jsonValue(value.value) ? [[key, value.value]] : []; }));
+            const base = { ...placement, kind, start: call.start, end: call.end, name: null, prompt: staticString(first), model: staticString(propertyNode(options, "model")), label: staticString(propertyNode(options, "label")), role: staticString(propertyNode(options, "role")) };
+            return { ...base, ...(retries.known && typeof retries.value === "number" ? { retries: retries.value } : {}), ...(outputSchema.known && object(outputSchema.value) ? { outputSchema: outputSchema.value } : {}), ...(optionKeys.length ? { options: knownOptions, optionKeys } : {}) };
+        }
+        if (kind === "checkpoint")
+            return { ...placement, kind, start: call.start, end: call.end, name: staticString(propertyNode(first, "name")), prompt: staticString(propertyNode(first, "prompt")), model: null, role: null };
+        return { ...placement, kind, start: call.start, end: call.end, name: staticString(first), prompt: null, model: null, role: null };
+    });
+}
+function validateStaticAgentOptions(node) {
+    if (node?.type !== "ObjectExpression")
+        return;
+    for (const property of node.properties) {
+        if (property.type === "SpreadElement" || property.computed)
+            continue;
+        const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+        if (key && !AGENT_OPTION_KEYS.has(key))
+            fail("INVALID_METADATA", `Unknown agent option: ${key}`);
+    }
+    const role = propertyNode(node, "role");
+    if (role && ["model", "thinking", "tools"].some((key) => propertyNode(node, key) !== undefined))
+        fail("INVALID_METADATA", "Role agents must not specify model, thinking, or tools");
+    for (const key of AGENT_OPTION_KEYS) {
+        const value = staticValue(propertyNode(node, key));
+        if (value.known)
+            validateAgentOption(key, value.value);
+    }
+    const options = staticValue(node);
+    if (options.known && object(options.value) && typeof options.value.role === "string" && ["model", "thinking", "tools"].some((key) => Object.prototype.hasOwnProperty.call(options.value, key)))
+        fail("INVALID_METADATA", "Role agents must not specify model, thinking, or tools");
+}
+function validateStaticWithWorktree(call) {
+    if (call.arguments.some((argument) => argument.type === "SpreadElement"))
+        return;
+    if (call.arguments.length !== 1 && call.arguments.length !== 2)
+        fail("INVALID_METADATA", "withWorktree requires a callback or a name and callback");
+    const callback = call.arguments[call.arguments.length - 1];
+    if (staticValue(callback).known)
+        fail("INVALID_METADATA", "withWorktree callback must be a function");
+    if (call.arguments.length === 2) {
+        const name = staticValue(call.arguments[0]);
+        if (name.known && (typeof name.value !== "string" || !name.value.trim()))
+            fail("INVALID_METADATA", "withWorktree name must be a non-empty string");
+    }
+}
+const RESERVED_GLOBALS = new Set(["agent", "prompt", "checkpoint", "parallel", "pipeline", "phase", "withWorktree", "log", "args", "Promise", "JSON", "Math", "Date", "eval", "Function", "WebAssembly", "process", "require", "module", "exports", "console", "fetch", "XMLHttpRequest", "WebSocket", "performance", "crypto", "setTimeout", "setInterval", "setImmediate", "queueMicrotask", "Intl", "SharedArrayBuffer", "Atomics", "globalThis", "global", "undefined", "NaN", "Infinity", "extensions", "workflow_catalog"]);
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+const SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export class WorkflowRegistry {
+    #extensions = new Map();
+    #globals = new Map();
+    #frozen = false;
+    get frozen() { return this.#frozen; }
+    freeze() { this.#frozen = true; }
+    register(extension) {
+        if (this.#frozen)
+            fail("REGISTRY_FROZEN", "Workflow extension registration is closed after session_start");
+        if (!object(extension) || Object.keys(extension).some((key) => !["namespace", "version", "headline", "description", "functions", "variables", "workflows"].includes(key)) || typeof extension.namespace !== "string" || typeof extension.version !== "string" || !IDENTIFIER.test(extension.namespace) || !SEMVER.test(extension.version) || typeof extension.headline !== "string" || !extension.headline.trim() || typeof extension.description !== "string" || !extension.description.trim())
+            fail("INVALID_METADATA", "Workflow extensions require a namespace, semantic version, headline, and description");
+        if (this.#extensions.has(extension.namespace))
+            fail("DUPLICATE_NAME", `Workflow extension already registered: ${extension.namespace}`);
+        const functions = extension.functions ?? {};
+        const variables = extension.variables ?? {};
+        const workflows = extension.workflows ?? {};
+        if (!object(functions) || !object(variables) || !object(workflows) || (Object.keys(functions).length === 0 && Object.keys(variables).length === 0 && Object.keys(workflows).length === 0))
+            fail("INVALID_METADATA", "Workflow extensions require functions, variables, or workflows");
+        const names = [...Object.keys(functions), ...Object.keys(variables)];
+        if (new Set(names).size !== names.length)
+            fail("GLOBAL_COLLISION", `Global name collision inside ${extension.namespace}`);
+        for (const name of names) {
+            if (!IDENTIFIER.test(name) || name.startsWith("__pi_extensible_workflows_"))
+                fail("INVALID_METADATA", `Invalid global name: ${extension.namespace}.${name}`);
+            if (RESERVED_GLOBALS.has(name))
+                fail("GLOBAL_COLLISION", `Global name is reserved: ${name}`);
+            const owner = this.#globals.get(name);
+            if (owner)
+                fail("GLOBAL_COLLISION", `Global name ${name} is already owned by ${owner}; cannot register ${extension.namespace}.${name}`);
+        }
+        for (const [name, fn] of Object.entries(functions)) {
+            if (!object(fn) || Object.keys(fn).some((key) => !["description", "input", "output", "run"].includes(key)) || typeof fn.description !== "string" || !fn.description.trim() || typeof fn.run !== "function")
+                fail("INVALID_METADATA", `Invalid workflow function: ${extension.namespace}.${name}`);
+            validateSchema(fn.input, `${extension.namespace}.${name} input`);
+            validateSchema(fn.output, `${extension.namespace}.${name} output`);
+            if (fn.input.type !== "object")
+                fail("INVALID_SCHEMA", `${extension.namespace}.${name} input must describe one object`);
+        }
+        for (const [name, variable] of Object.entries(variables)) {
+            if (!object(variable) || Object.keys(variable).some((key) => !["description", "schema", "resolve"].includes(key)) || typeof variable.description !== "string" || !variable.description.trim() || typeof variable.resolve !== "function")
+                fail("INVALID_METADATA", `Invalid workflow variable: ${extension.namespace}.${name}`);
+            validateSchema(variable.schema, `${extension.namespace}.${name} schema`);
+        }
+        for (const [name, workflow] of Object.entries(workflows)) {
+            if (!IDENTIFIER.test(name) || !object(workflow) || Object.keys(workflow).some((key) => !["description", "script"].includes(key)) || typeof workflow.description !== "string" || !workflow.description.trim() || typeof workflow.script !== "string" || !workflow.script.trim())
+                fail("INVALID_METADATA", `Invalid workflow script: ${extension.namespace}.${name}`);
+            parseWorkflow(workflow.script);
+        }
+        const stored = deepFreeze({ ...extension, functions, variables, workflows });
+        this.#extensions.set(extension.namespace, stored);
+        for (const name of names)
+            this.#globals.set(name, `${extension.namespace}.${name}`);
+    }
+    workflow(name) {
+        const separator = name.indexOf(".");
+        if (separator <= 0 || separator !== name.lastIndexOf(".") || !IDENTIFIER.test(name.slice(0, separator)) || !IDENTIFIER.test(name.slice(separator + 1)))
+            fail("MISSING_WORKFLOW", `Registered workflows require a qualified namespace.name: ${name}`);
+        const workflow = this.#extensions.get(name.slice(0, separator))?.workflows?.[name.slice(separator + 1)];
+        if (!workflow)
+            fail("MISSING_WORKFLOW", `Workflow is unavailable: ${name}`);
+        return workflow;
+    }
+    workflows() {
+        return Object.freeze(Object.fromEntries([...this.#extensions].flatMap(([namespace, extension]) => Object.entries(extension.workflows ?? {}).map(([name, workflow]) => [`${namespace}.${name}`, workflow]))));
+    }
+    catalog() {
+        const functions = [];
+        const variables = [];
+        const workflows = [];
+        for (const [namespace, extension] of this.#extensions) {
+            for (const [name, fn] of Object.entries(extension.functions ?? {}))
+                functions.push({ name, namespace, version: extension.version, headline: extension.headline, extensionDescription: extension.description, description: fn.description, input: structuredClone(fn.input), output: structuredClone(fn.output) });
+            for (const [name, variable] of Object.entries(extension.variables ?? {}))
+                variables.push({ name, namespace, version: extension.version, headline: extension.headline, extensionDescription: extension.description, description: variable.description, schema: structuredClone(variable.schema) });
+            for (const [name, workflow] of Object.entries(extension.workflows ?? {}))
+                workflows.push({ name: `${namespace}.${name}`, namespace, version: extension.version, headline: extension.headline, extensionDescription: extension.description, description: workflow.description });
+        }
+        const sort = (left, right) => left.namespace.localeCompare(right.namespace) || left.name.localeCompare(right.name);
+        return deepFreeze({ functions: functions.sort(sort), variables: variables.sort(sort), workflows: workflows.sort((left, right) => left.name.localeCompare(right.name)) });
+    }
+    globals() {
+        return Object.freeze(Object.fromEntries([...this.#extensions].flatMap(([namespace, extension]) => Object.keys(extension.functions ?? {}).map((name) => [name, { namespace, name }]))));
+    }
+    async invokeFunction(namespace, name, input, context, path, journal) {
+        const fn = this.#extensions.get(namespace)?.functions?.[name];
+        if (!fn)
+            fail("MISSING_WORKFLOW", `Workflow function is unavailable: ${namespace}.${name}`);
+        if (!object(input) || !jsonValue(input) || !Value.Check(fn.input, input))
+            fail("RESULT_INVALID", `Invalid input for ${namespace}.${name}`);
+        const replayed = journal.get(path);
+        if (replayed !== undefined) {
+            if (!jsonValue(replayed) || !Value.Check(fn.output, replayed))
+                fail("RESULT_INVALID", `Invalid replay for ${namespace}.${name}`);
+            return structuredClone(replayed);
+        }
+        const result = await fn.run(deepFreeze(structuredClone(input)), Object.freeze({ run: context.run, agent: context.agent, prompt: context.prompt, parallel: context.parallel, pipeline: context.pipeline, withWorktree: context.withWorktree, checkpoint: context.checkpoint, phase: context.phase, log: context.log }));
+        if (!jsonValue(result) || !Value.Check(fn.output, result))
+            fail("RESULT_INVALID", `Invalid output from ${namespace}.${name}`);
+        const stored = structuredClone(result);
+        journal.put(path, stored);
+        return structuredClone(stored);
+    }
+    variables() {
+        return [...this.#extensions].flatMap(([namespace, extension]) => Object.entries(extension.variables ?? {}).map(([name, variable]) => ({ namespace, name, variable })));
+    }
+}
+const WORKFLOW_REGISTRY_KEY = Symbol.for("pi-extensible-workflows.workflow-registry");
+const globalRegistry = globalThis;
+function createWorkflowRegistryApi(registry) {
+    return {
+        get frozen() { return registry.frozen; },
+        freeze: () => { registry.freeze(); },
+        register: (extension) => { registry.register(extension); },
+        workflow: (name) => registry.workflow(name),
+        workflows: () => registry.workflows(),
+        catalog: () => registry.catalog(),
+        globals: () => registry.globals(),
+        invokeFunction: (...args) => registry.invokeFunction(...args),
+        variables: () => registry.variables(),
+    };
+}
+function workflowRegistryHost() {
+    return globalRegistry[WORKFLOW_REGISTRY_KEY] ??= { api: createWorkflowRegistryApi(new WorkflowRegistry()) };
+}
+function resetWorkflowRegistry() {
+    workflowRegistryHost().api = createWorkflowRegistryApi(new WorkflowRegistry());
+}
+function beginWorkflowExtensionLoading() {
+    if (workflowRegistryHost().api.frozen)
+        resetWorkflowRegistry();
+}
+function loadingRegistry() { return workflowRegistryHost().api; }
+beginWorkflowExtensionLoading();
+export function registerWorkflowExtension(extension) { loadingRegistry().register(extension); }
+export function workflowCatalog() { return loadingRegistry().catalog(); }
+export function registeredWorkflowDefinitions() { return loadingRegistry().workflows(); }
+export function formatWorkflowPreview(args) {
+    const name = typeof args.name === "string" && args.name.trim() ? args.name.trim() : typeof args.workflow === "string" && args.workflow.trim() ? args.workflow : "workflow";
+    if (typeof args.script !== "string" || !args.script.trim())
+        return `workflow ${name}${typeof args.workflow === "string" ? "\nRegistered workflow" : ""}`;
+    return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
+}
+export const WORKFLOW_TOOL_LABEL = "Workflow";
+export const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow";
+export const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow that orchestrates subagents. Inline scripts require a name; registered workflows use their workflow name. Runs in the background by default; completion arrives as a follow-up message.";
+export const WORKFLOW_TOOL_PARAMETERS = Type.Object({
+    name: Type.Optional(Type.String({ description: "Workflow name for inline scripts" })),
+    description: Type.Optional(Type.String({ description: "Optional human-readable workflow description" })),
+    script: Type.Optional(Type.String({ description: "Immutable workflow source without metadata" })),
+    workflow: Type.Optional(Type.String({ description: "Registered reusable workflow as namespace.name" })),
+    args: Type.Optional(Type.Unknown({ description: "JSON-compatible workflow arguments" })),
+    foreground: Type.Optional(Type.Boolean({ description: "Wait for completion instead of running in the background" })),
+    concurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: 16 })),
+    maxAgentLaunches: Type.Optional(Type.Integer({ minimum: 1, description: "Total logical agent launches for the run, including nested agents; not concurrency" })),
+});
+function hasDynamicAgentRole(node) {
+    if (!node)
+        return false;
+    if (node.type !== "ObjectExpression")
+        return true;
+    for (let index = node.properties.length - 1; index >= 0; index -= 1) {
+        const property = node.properties[index];
+        if (!property || property.type === "SpreadElement" || property.computed)
+            return true;
+        const key = property.key.type === "Identifier" ? property.key.name : property.key.type === "Literal" ? String(property.key.value) : undefined;
+        if (key === "role")
+            return literalString(property.value) === undefined;
+    }
+    return false;
+}
+export function preflight(script, capabilities, schemas = [], metadata = { name: "workflow" }) {
+    const checkedMetadata = validateWorkflowMetadata(metadata);
+    const program = parseWorkflow(script);
+    if (hasIdentifier(program, INTERNAL_AGENT_NAME))
+        fail("INVALID_METADATA", `${INTERNAL_AGENT_NAME} is reserved for workflow agent instrumentation`);
+    if (hasIdentifier(program, INTERNAL_WORKTREE_NAME))
+        fail("INVALID_METADATA", `${INTERNAL_WORKTREE_NAME} is reserved for workflow withWorktree instrumentation`);
+    validateDirectPrimitiveReferences(program, "withWorktree");
+    for (const [index, schema] of schemas.entries())
+        validateSchema(schema, `schema[${String(index)}]`);
+    const calls = workflowCalls(program);
+    const phases = calls.filter((call) => call.callee.name === "phase").map((call) => literalString(call.arguments[0])).filter((phase) => phase !== undefined);
+    for (const call of calls) {
+        const operation = call.callee.name;
+        if (operation === "agent")
+            validateStaticAgentOptions(call.arguments[1]);
+        if (operation === "withWorktree")
+            validateStaticWithWorktree(call);
+        if ((operation === "parallel" || operation === "pipeline") && call.arguments.some((argument) => argument.type === "SpreadElement"))
+            continue;
+        if (operation === "checkpoint" && stableName(call.arguments[0]) === false)
+            fail("INVALID_METADATA", `${operation} requires a stable explicit name`);
+        if (operation === "parallel" && (call.arguments.length !== 2 || !literalString(call.arguments[0])?.trim() || call.arguments[1]?.type !== "ObjectExpression"))
+            fail("INVALID_METADATA", "parallel requires an operation name string and tasks record");
+        if (operation === "pipeline" && (call.arguments.length !== 3 || !literalString(call.arguments[0])?.trim() || call.arguments[1]?.type !== "ObjectExpression" || call.arguments[2]?.type !== "ObjectExpression"))
+            fail("INVALID_METADATA", "pipeline requires an operation name string, items record, and stages record");
+    }
+    const agentCalls = calls.filter((call) => call.callee.name === "agent");
+    const dynamicAgentRoles = agentCalls.some((call) => hasDynamicAgentRole(call.arguments[1]));
+    const staticSchemas = agentCalls.flatMap((call) => { const value = staticValue(propertyNode(call.arguments[1], "outputSchema")); return value.known ? [value.value] : []; });
+    for (const [index, schema] of staticSchemas.entries())
+        validateSchema(schema, `agent outputSchema[${String(index)}]`);
+    const checkedSchemas = [...schemas, ...staticSchemas];
+    const models = agentCalls.flatMap((call) => { const value = literalString(propertyNode(call.arguments[1], "model")); return value === undefined ? [] : [modelCapability(value)]; });
+    const tools = agentCalls.flatMap((call) => {
+        const value = propertyNode(call.arguments[1], "tools");
+        return value?.type === "ArrayExpression" ? value.elements.flatMap((element) => { const tool = element && element.type !== "SpreadElement" ? literalString(element) : undefined; return tool === undefined ? [] : [tool]; }) : [];
+    });
+    const agentTypes = agentCalls.flatMap((call) => { const value = literalString(propertyNode(call.arguments[1], "role")); return value === undefined ? [] : [value]; });
+    const missingModel = models.find((model) => !capabilities.models.has(model));
+    if (missingModel)
+        fail("UNKNOWN_MODEL", `Unknown model: ${missingModel}`);
+    const missingTool = tools.find((tool) => !capabilities.tools.has(tool));
+    if (missingTool)
+        fail("UNKNOWN_TOOL", `Unknown tool: ${missingTool}`);
+    const missingType = agentTypes.find((type) => !capabilities.agentTypes.has(type));
+    if (missingType)
+        fail("UNKNOWN_AGENT_TYPE", `Unknown agent type: ${missingType}`);
+    return Object.freeze({ metadata: deepFreeze(checkedMetadata), referenced: deepFreeze({ phases, models, tools, agentTypes }), schemas: deepFreeze(checkedSchemas), dynamicAgentRoles });
+}
+export function validateWorkflowLaunch(params, context) {
+    return validateWorkflowLaunchWithRegistry(params, context, loadingRegistry());
+}
+function validateWorkflowLaunchWithRegistry(params, context, registry) {
+    if (params.script !== undefined && params.workflow !== undefined)
+        fail("INVALID_METADATA", "Provide either script or workflow, not both");
+    const definition = typeof params.workflow === "string" ? registry.workflow(params.workflow) : undefined;
+    const script = typeof params.script === "string" && params.script.trim() ? params.script : definition?.script ?? "";
+    if (!script)
+        fail("INVALID_SYNTAX", "Provide script or registered workflow");
+    const workflowName = typeof params.name === "string" && params.name.trim() ? params.name.trim() : typeof params.workflow === "string" ? params.workflow : "";
+    if (!workflowName)
+        fail("INVALID_METADATA", "Inline workflows require name");
+    const metadata = validateWorkflowMetadata({ name: workflowName, ...(typeof params.description === "string" ? { description: params.description } : definition?.description ? { description: definition.description } : {}) });
+    const globalAgentDefinitions = loadAgentDefinitions(context.cwd, undefined, false);
+    const projectAgentDefinitions = context.projectTrusted ? readRoleDefinitions(projectRoleDirectories(join(context.cwd, ".pi"))) : {};
+    const agentDefinitions = deepFreeze({ ...globalAgentDefinitions, ...projectAgentDefinitions });
+    const checked = preflight(script, { models: context.availableModels, tools: context.rootTools, agentTypes: new Set(Object.keys(agentDefinitions)) }, [], metadata);
+    const roleNames = checked.dynamicAgentRoles ? Object.keys(agentDefinitions) : checked.referenced.agentTypes;
+    validateRolePolicies(agentDefinitions, roleNames, context.availableModels, context.rootTools);
+    return { script, checked, agentDefinitions, projectAgentDefinitions, roleNames };
+}
+function deepFreeze(value) {
+    if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}
+export function createLaunchSnapshot(input) {
+    return deepFreeze(structuredClone({ ...input, identityVersion: input.identityVersion ?? LAUNCH_SNAPSHOT_IDENTITY_VERSION }));
+}
+export function loadLaunchSnapshot(input) {
+    return deepFreeze(structuredClone(input));
+}
+export const RPC_LIMIT_BYTES = 10 * 1024 * 1024;
+export const HEARTBEAT_TIMEOUT_MS = 5000;
+const OUTCOME_ERRORS = new Set(["AGENT_TIMEOUT", "AGENT_FAILED", "RESULT_INVALID"]);
+const WORK_RESULT_BRAND = "__workResult";
+const childSource = String.raw `
+"use strict";
+const { AsyncLocalStorage } = require("node:async_hooks");
+const vm = require("node:vm");
+const LIMIT = parseInt(process.argv[2], 10);
+const config = JSON.parse(process.argv[3]);
+for (const key of ["getBuiltinModule","binding","_linkedBinding","dlopen","kill","abort","exit","reallyExit","_kill","umask","chdir","setuid","setgid","seteuid","setegid","setgroups","initgroups"]) {
+  if (key in process) process[key] = undefined;
+}
+let nextId = 0;
+let cancelled = false;
+const pending = new Map();
+const inflight = new Set();
+const hasMessage = error => Boolean(error && typeof error === "object" && typeof error.message === "string");
+const errorText = error => hasMessage(error) ? error.message : String(error);
+const errorCode = error => { if (!error || typeof error !== "object") return undefined; const code = error.code; return typeof code === "string" ? code : undefined; };
+const errorAuthored = error => Boolean(error && typeof error === "object" && error.authored === true);
+const workerError = error => { const code = errorCode(error); return { code: code || "INTERNAL_ERROR", message: errorText(error), ...(error && typeof error === "object" && typeof error.failedAt === "string" ? { failedAt: error.failedAt } : {}), ...(errorAuthored(error) || hasMessage(error) && !code ? { authored: true } : {}) }; };
+const workflowError = error => Object.assign(new Error(errorText(error)), workerError(error));
+function send(value) {
+  const json = JSON.stringify(value);
+  if (json === undefined || Buffer.byteLength(json) > LIMIT) throw Object.assign(new Error("RPC value exceeds the 10 MB JSON boundary"), { code: "RPC_LIMIT_EXCEEDED" });
+  process.send(json);
+}
+function rpc(method, args) {
+  if (cancelled) throw Object.assign(new Error("Workflow cancelled"), { code: "CANCELLED" });
+  const id = ++nextId;
+  send({ type: "rpc", id, method, args });
+  const promise = new Promise((resolve, reject) => pending.set(id, { resolve, reject }));
+  inflight.add(promise);
+  void promise.then(() => inflight.delete(promise), () => inflight.delete(promise));
+  return promise;
+}
+process.on("message", raw => {
+  let message;
+  try {
+    if (typeof raw !== "string" || Buffer.byteLength(raw) > LIMIT) throw Object.assign(new Error("RPC value exceeds the 10 MB JSON boundary"), { code: "RPC_LIMIT_EXCEEDED" });
+    message = JSON.parse(raw);
+  } catch (error) { send({ type: "error", error: workerError(error) }); return; }
+  if (message.type === "cancel") { cancelled = true; for (const { reject } of pending.values()) reject(Object.assign(new Error("Workflow cancelled"), { code: "CANCELLED" })); pending.clear(); return; }
+  if (message.type !== "rpcResult") return;
+  const request = pending.get(message.id);
+  if (!request) return;
+  pending.delete(message.id);
+  if (message.ok) request.resolve(message.value);
+  else request.reject(workflowError(message.error));
+});
+const heartbeat = setInterval(() => send({ type: "heartbeat" }), 1000);
+send({ type: "heartbeat" });
+const BRAND = "${WORK_RESULT_BRAND}";
+const workError = (code, message) => Object.assign(new Error(message), { code });
+const isBranded = value => value && typeof value === "object" && value[BRAND] === true;
+const unwrap = result => {
+  if (!isBranded(result)) return result;
+  if (result.ok) return result.value;
+  throw Object.assign(workflowError(result.error), { failedAt: result.failedAt });
+};
+const named = (value, kind) => { if (typeof value !== "string" || !value.trim()) throw workError("INVALID_METADATA", kind + " requires a stable explicit name"); return value; };
+const path = (...names) => names.map(encodeURIComponent).join("/");
+const inheritedAgentPath = new AsyncLocalStorage();
+const agentOccurrences = new Map();
+const worktreeOwners = new AsyncLocalStorage();
+const worktreeOccurrences = new Map();
+const rejectAgent = () => { throw workError("INVALID_METADATA", "Workflow agent calls must use a direct agent(...) call; aliases and indirect calls are unsupported"); };
+const rejectWorktree = () => { throw workError("INVALID_METADATA", "withWorktree calls must use a direct withWorktree(...) call; aliases and indirect calls are unsupported"); };
+const internalWithWorktree = async (...values) => {
+  const callSite = values.pop();
+  if (typeof callSite !== "string") throw workError("INTERNAL_ERROR", "Missing withWorktree call-site identity");
+  if (values.length !== 1 && values.length !== 2) throw workError("INVALID_METADATA", "withWorktree requires a callback or a name and callback");
+  const callback = values[values.length - 1];
+  if (typeof callback !== "function") throw workError("INVALID_METADATA", "withWorktree callback must be a function");
+  let owner;
+  if (values.length === 2) {
+    if (typeof values[0] !== "string" || !values[0].trim()) throw workError("INVALID_METADATA", "withWorktree name must be a non-empty string");
+    owner = path("worktree", "named", values[0].trim());
+  } else {
+    const inherited = inheritedAgentPath.getStore() || [];
+    const occurrenceKey = JSON.stringify([inherited, callSite]);
+    const occurrence = (worktreeOccurrences.get(occurrenceKey) || 0) + 1;
+    worktreeOccurrences.set(occurrenceKey, occurrence);
+    owner = path("worktree", "unnamed", ...inherited, "callsite:" + callSite, "occurrence:" + String(occurrence));
+  }
+  return await worktreeOwners.run(owner, callback);
+};
+const internalAgent = (...values) => {
+  const callSite = values.pop();
+  if (typeof callSite !== "string") throw workError("INTERNAL_ERROR", "Missing workflow agent call-site identity");
+  const inherited = inheritedAgentPath.getStore() || [];
+  // ponytail: same-callsite races outside parallel/pipeline lack a stable structural scope and are unsupported.
+  const occurrenceKey = JSON.stringify([inherited, callSite]);
+  const occurrence = (agentOccurrences.get(occurrenceKey) || 0) + 1;
+  agentOccurrences.set(occurrenceKey, occurrence);
+  const options = values.length < 2 || values[1] === undefined ? {} : values[1];
+  const worktreeOwner = worktreeOwners.getStore();
+  const identity = { structuralPath: [...inherited], callSite, occurrence, ...(worktreeOwner ? { worktreeOwner } : {}) };
+  const result = rpc("agent", [values[0], options, identity]).then(unwrap);
+  Object.defineProperties(result, {
+    toJSON: { value() { throw workError("INVALID_METADATA", "Workflow agent result is a Promise; await it before serialization"); } },
+    toString: { value() { throw workError("INVALID_METADATA", "Workflow agent result is a Promise; await it before interpolation"); } },
+    [Symbol.toPrimitive]: { value() { throw workError("INVALID_METADATA", "Workflow agent result is a Promise; await it before interpolation"); } },
+  });
+  return result;
+};
+const agent = rejectAgent;
+const promptPath = (at, key) => /^[A-Za-z_$][\w$]*$/.test(key) ? at + "." + key : at + "[" + JSON.stringify(key) + "]";
+const plainPromptObject = value => {
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || Object.getPrototypeOf(proto) === null && Object.prototype.hasOwnProperty.call(proto, "constructor") && typeof proto.constructor === "function" && Function.prototype.toString.call(proto.constructor) === Function.prototype.toString.call(Object);
+};
+const promptValue = (value, at, seen) => {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") { if (!Number.isFinite(value)) throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" must be a finite number"); return; }
+  if (typeof value !== "object") throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" cannot be " + typeof value);
+  if (typeof value.then === "function") throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" is a Promise or thenable; await it before calling prompt()");
+  if (!Array.isArray(value) && !plainPromptObject(value)) throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" must be a plain object");
+  if (seen.has(value)) throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" contains a cycle");
+  const keys = Reflect.ownKeys(value);
+  const symbol = keys.find(key => typeof key === "symbol");
+  if (symbol) throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" contains a symbol key");
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) promptProperty(value, String(index), at + "[" + index + "]", seen);
+    for (const key of keys) {
+      const index = Number(key);
+      if (key !== "length" && !(Number.isInteger(index) && index >= 0 && index < value.length && String(index) === key)) promptProperty(value, key, promptPath(at, key), seen);
+    }
+  } else for (const key of keys) promptProperty(value, key, promptPath(at, key), seen);
+  seen.delete(value);
+};
+const promptProperty = (value, key, at, seen) => {
+  const descriptor = Object.getOwnPropertyDescriptor(value, key);
+  if (descriptor && (descriptor.get || descriptor.set)) throw workError("INVALID_METADATA", "Prompt value \"" + at + "\" cannot use getters or setters");
+  promptValue(descriptor && descriptor.value, at, seen);
+};
+const prompt = (template, values) => {
+  if (typeof template !== "string") throw workError("INVALID_METADATA", "prompt() template must be a string");
+  if (!values || typeof values !== "object" || Array.isArray(values) || !plainPromptObject(values)) throw workError("INVALID_METADATA", "prompt() values must be a plain object");
+  const placeholders = [...template.matchAll(/{{|}}|{([A-Za-z_$][\w$]*)}/g)].flatMap(match => match[1] === undefined ? [] : [match[1]]);
+  const used = new Set(placeholders);
+  const keys = Reflect.ownKeys(values);
+  const symbol = keys.find(key => typeof key === "symbol");
+  if (symbol) throw workError("INVALID_METADATA", "prompt() values must use string keys");
+  const missing = placeholders.find(key => !Object.prototype.hasOwnProperty.call(values, key));
+  if (missing) throw workError("INVALID_METADATA", "Missing prompt value \"" + missing + "\"");
+  const unused = keys.find(key => !used.has(key));
+  if (unused !== undefined) throw workError("INVALID_METADATA", "Unused prompt value \"" + unused + "\"");
+  for (const key of keys) promptProperty(values, key, key, new Set());
+  return template.replace(/{{|}}|{([A-Za-z_$][\w$]*)}/g, (match, key) => match === "{{" ? "{" : match === "}}" ? "}" : typeof values[key] === "string" ? values[key] : JSON.stringify(values[key], null, 2));
+};
+const checkpoint = input => rpc("checkpoint", [input]).then(unwrap);
+const phase = name => rpc("phase", [name]);
+const log = message => rpc("log", [message]);
+const functionOccurrences = new Map();
+const functionPath = (namespace, name) => {
+  const inherited = inheritedAgentPath.getStore() || [];
+  const key = JSON.stringify([inherited, namespace, name]);
+  const occurrence = (functionOccurrences.get(key) || 0) + 1;
+  functionOccurrences.set(key, occurrence);
+  return path("function", ...inherited, namespace, name, String(occurrence));
+};
+const functions = Object.freeze(Object.fromEntries(Object.entries(config.functions || {}).map(([local, target]) => [local, (...values) => {
+  if (values.length !== 1 || !values[0] || typeof values[0] !== "object" || Array.isArray(values[0])) throw workError("RESULT_INVALID", local + " requires exactly one JSON object argument");
+  const result = rpc("function", [target.namespace, target.name, values[0], functionPath(target.namespace, target.name), worktreeOwners.getStore() || null]).then(unwrap);
+  Object.defineProperty(result, "toJSON", { value() { throw workError("INVALID_METADATA", "Workflow function result is a Promise; await it before serialization"); } });
+  return result;
+}])));
+const freeze = value => { if (value && typeof value === "object" && !Object.isFrozen(value)) { Object.freeze(value); for (const child of Object.values(value)) freeze(child); } return value; };
+const recordEntries = (value, kind) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw workError("INVALID_METADATA", kind + " must be a record");
+  return Object.entries(value);
+};
+const parallel = async (operationName, tasks) => {
+  named(operationName, "parallel");
+  const entries = recordEntries(tasks, "parallel tasks");
+  for (const [name, run] of entries) {
+    named(name, "parallel task");
+    if (typeof run !== "function") throw workError("INVALID_METADATA", "parallel task values must be run functions");
+  }
+  const results = await Promise.all(entries.map(async ([name, run]) => {
+    try {
+      const parent = inheritedAgentPath.getStore() || [];
+      return { name, ok: true, value: await inheritedAgentPath.run([...parent, operationName, name], run) };
+    } catch (error) {
+      if (errorCode(error) === "CANCELLED") throw error;
+      const failedAt = error && typeof error === "object" && typeof error.failedAt === "string" ? error.failedAt : undefined;
+      return { name, ok: false, failedAt: failedAt ? path(operationName, name, failedAt) : path(operationName, name), error: workerError(error) };
+    }
+  }));
+  const failure = results.find(result => !result.ok);
+  if (failure) throw Object.assign(workflowError(failure.error), { failedAt: failure.failedAt });
+  return Object.fromEntries(results.map(result => [result.name, result.value]));
+};
+const pipeline = async (operationName, items, stages) => {
+  named(operationName, "pipeline");
+  const itemEntries = recordEntries(items, "pipeline items");
+  const stageEntries = recordEntries(stages, "pipeline stages");
+  if (!stageEntries.length) throw workError("INVALID_METADATA", "pipeline requires at least one stage");
+  for (const [name] of itemEntries) named(name, "pipeline item");
+  for (const [stageName, run] of stageEntries) {
+    named(stageName, "pipeline stage");
+    if (typeof run !== "function") throw workError("INVALID_METADATA", "pipeline stage values must be run functions");
+  }
+  const results = await Promise.all(itemEntries.map(async ([name, initial]) => {
+    let value = initial;
+    let failedAt = path(operationName, name);
+    try {
+      for (const [stageName, run] of stageEntries) {
+        failedAt = path(operationName, name, stageName);
+        const parent = inheritedAgentPath.getStore() || [];
+        value = await inheritedAgentPath.run([...parent, operationName, name, stageName], () => run(value));
+      }
+      return { name, ok: true, value };
+    } catch (error) {
+      if (errorCode(error) === "CANCELLED") throw error;
+      const nestedFailedAt = error && typeof error === "object" && typeof error.failedAt === "string" ? error.failedAt : undefined;
+      return { name, ok: false, failedAt: nestedFailedAt ? path(failedAt, nestedFailedAt) : failedAt, error: workerError(error) };
+    }
+  }));
+  const failure = results.find(result => !result.ok);
+  if (failure) throw Object.assign(workflowError(failure.error), { failedAt: failure.failedAt });
+  return Object.fromEntries(results.map(result => [result.name, result.value]));
+};
+const safeMath = Object.fromEntries(Object.getOwnPropertyNames(Math).filter(name => name !== "random").map(name => [name, Math[name]]));
+const sandbox = { agent, withWorktree: rejectWorktree, prompt, checkpoint, parallel, pipeline, phase, log, args: config.args, Promise, JSON, Math: Object.freeze(safeMath) };
+for (const [name, fn] of Object.entries(functions)) Object.defineProperty(sandbox, name, { value: fn, writable: false, configurable: false });
+for (const [name, value] of Object.entries(config.variables || {})) Object.defineProperty(sandbox, name, { value: freeze(value), writable: false, configurable: false });
+for (const name of ["Date","eval","Function","WebAssembly","process","require","module","exports","console","fetch","XMLHttpRequest","WebSocket","performance","crypto","setTimeout","setInterval","setImmediate","queueMicrotask","Intl","SharedArrayBuffer","Atomics"]) sandbox[name] = undefined;
+const context = vm.createContext(sandbox, { codeGeneration: { strings: false, wasm: false } });
+const body = config.script;
+Promise.resolve().then(() => new vm.Script("(async(__pi_extensible_workflows_agent,__pi_extensible_workflows_withWorktree)=>{" + body + "\n})", { filename: "workflow.js" }).runInContext(context)(internalAgent, internalWithWorktree))
+  .then(async value => { await Promise.all(inflight); send({ type: "result", value: value === undefined ? null : value }); })
+  .catch(error => send({ type: "error", error: workerError(error) }))
+  .finally(() => clearInterval(heartbeat));
+`;
+function encoded(value) {
+    if (!jsonValue(value))
+        fail("RPC_LIMIT_EXCEEDED", "RPC values must be JSON-compatible");
+    const json = JSON.stringify(value);
+    if (Buffer.byteLength(json) > RPC_LIMIT_BYTES)
+        fail("RPC_LIMIT_EXCEEDED", "RPC value exceeds the 10 MB JSON boundary");
+    return json;
+}
+function readAgentIdentity(value) {
+    if (!object(value))
+        fail("INTERNAL_ERROR", "Invalid workflow agent identity");
+    const structuralPath = value.structuralPath;
+    const callSite = value.callSite;
+    const occurrence = value.occurrence;
+    const worktreeOwner = value.worktreeOwner;
+    const parentBreadcrumb = value.parentBreadcrumb;
+    if (!Array.isArray(structuralPath) || !structuralPath.every((part) => typeof part === "string" && Boolean(part.trim())) || typeof callSite !== "string" || !callSite || !positiveInteger(occurrence) || parentBreadcrumb !== undefined && (typeof parentBreadcrumb !== "string" || !parentBreadcrumb.trim()) || worktreeOwner !== undefined && (typeof worktreeOwner !== "string" || !worktreeOwner))
+        fail("INTERNAL_ERROR", "Invalid workflow agent identity");
+    return { structuralPath: [...structuralPath], callSite, occurrence, ...(typeof parentBreadcrumb === "string" ? { parentBreadcrumb } : {}), ...(typeof worktreeOwner === "string" ? { worktreeOwner } : {}) };
+}
+function agentIdentityPath(identity) {
+    return operationPath("agent", ...identity.structuralPath, `callsite:${identity.callSite}`, `occurrence:${String(identity.occurrence)}`);
+}
+function agentWorktree(identity) {
+    return identity.worktreeOwner ? { worktreeOwner: identity.worktreeOwner } : {};
+}
+export function runWorkflow(script, args = null, bridge = {}, signal) {
+    encoded(args);
+    const config = JSON.stringify({ script: instrumentWorkflow(script), args: structuredClone(args), functions: bridge.functions ?? {}, variables: bridge.variables ?? {} });
+    const childDir = mkdtempSync(join(tmpdir(), "pi-wf-"));
+    const childFile = join(childDir, "child.cjs");
+    writeFileSync(childFile, childSource);
+    const child = fork(childFile, [String(RPC_LIMIT_BYTES), config], {
+        execArgv: (() => {
+            const filtered = [];
+            const skip = new Set(["--input-type", "-e", "--eval", "-p", "--print"]);
+            let skipNext = false;
+            for (const arg of process.execArgv) {
+                if (skipNext) {
+                    skipNext = false;
+                    continue;
+                }
+                if (skip.has(arg) || skip.has(arg.split("=")[0] ?? "")) {
+                    if (!arg.includes("="))
+                        skipNext = true;
+                    continue;
+                }
+                filtered.push(arg);
+            }
+            return [...filtered, "--max-old-space-size=128", "--permission", `--allow-fs-read=${childDir}`];
+        })(),
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+        serialization: "advanced",
+    });
+    const controller = new AbortController();
+    let settled = false;
+    let rejectResult = () => undefined;
+    let watchdog = setTimeout(() => { stop("WORKER_UNRESPONSIVE", "Workflow worker missed its five-second heartbeat"); }, HEARTBEAT_TIMEOUT_MS);
+    const result = new Promise((resolve, reject) => {
+        rejectResult = reject;
+        child.on("message", (raw) => {
+            try {
+                if (typeof raw !== "string" || Buffer.byteLength(raw) > RPC_LIMIT_BYTES)
+                    fail("RPC_LIMIT_EXCEEDED", "RPC value exceeds the 10 MB JSON boundary");
+                const message = JSON.parse(raw);
+                if (!jsonValue(message))
+                    fail("RPC_LIMIT_EXCEEDED", "Worker RPC must contain JSON-compatible values");
+                if (message.type === "heartbeat") {
+                    clearTimeout(watchdog);
+                    watchdog = setTimeout(() => { stop("WORKER_UNRESPONSIVE", "Workflow worker missed its five-second heartbeat"); }, HEARTBEAT_TIMEOUT_MS);
+                    return;
+                }
+                if (message.type === "result") {
+                    encoded(message.value);
+                    finish();
+                    resolve(message.value ?? null);
+                    return;
+                }
+                if (message.type === "error") {
+                    finish();
+                    reject(workflowErrorFromWorker(message.error ?? { code: "INTERNAL_ERROR", message: "Worker failed" }));
+                    return;
+                }
+                if (message.type === "rpc" && message.id !== undefined)
+                    void handleRpc(message.id, message.method ?? "", message.args ?? []);
+            }
+            catch (error) {
+                stop(error instanceof WorkflowError ? error.code : "INTERNAL_ERROR", error instanceof Error ? error.message : String(error));
+            }
+        });
+        child.on("error", (error) => { stop("INTERNAL_ERROR", error.message); });
+        child.on("exit", (code) => { if (!settled && code !== 0)
+            stop("INTERNAL_ERROR", `Workflow child exited with code ${String(code)}`); });
+    });
+    function killChild() {
+        if (!child.killed) {
+            child.kill("SIGTERM");
+            setTimeout(() => { if (!child.killed)
+                child.kill("SIGKILL"); }, 1000).unref();
+        }
+    }
+    function finish() { settled = true; clearTimeout(watchdog); signal?.removeEventListener("abort", cancel); killChild(); rmSync(childDir, { recursive: true, force: true }); }
+    function stop(code, message) { if (settled)
+        return; controller.abort(); finish(); rejectResult(new WorkflowError(code, message)); }
+    function branded(result) { return { ...result, [WORK_RESULT_BRAND]: true }; }
+    async function handleRpc(id, method, values) {
+        try {
+            encoded(values);
+            let value = null;
+            if (method === "agent") {
+                if (!bridge.agent)
+                    fail("AGENT_FAILED", "No agent bridge is available");
+                if (typeof values[0] !== "string")
+                    fail("INTERNAL_ERROR", "agent prompt must be a string");
+                const opts = validateAgentOptions(values[1]);
+                const identity = readAgentIdentity(values[2]);
+                const path = agentIdentityPath(identity);
+                const label = typeof opts.label === "string" ? opts.label : typeof opts.role === "string" ? opts.role : "agent";
+                try {
+                    const result = await bridge.agent(values[0], opts, controller.signal, identity);
+                    value = branded({ name: label, ok: true, value: result ?? null });
+                }
+                catch (error) {
+                    const typed = asWorkflowError(error);
+                    if (!OUTCOME_ERRORS.has(typed.code))
+                        throw typed;
+                    value = branded({ name: label, ok: false, failedAt: path, error: { code: typed.code, message: typed.message, ...(isWorkflowAuthored(typed) ? { authored: true } : {}) } });
+                }
+            }
+            else if (method === "checkpoint") {
+                if (!bridge.checkpoint || !object(values[0]))
+                    fail("INTERNAL_ERROR", "checkpoint requires an available bridge and object input");
+                const name = typeof values[0].name === "string" ? values[0].name : "checkpoint";
+                try {
+                    const result = await bridge.checkpoint(values[0], controller.signal);
+                    if (typeof result !== "boolean")
+                        fail("INTERNAL_ERROR", "checkpoint must return a boolean");
+                    value = branded({ name, ok: true, value: result ? "approved" : "rejected" });
+                }
+                catch (error) {
+                    const typed = asWorkflowError(error);
+                    if (!OUTCOME_ERRORS.has(typed.code))
+                        throw typed;
+                    value = branded({ name, ok: false, failedAt: name, error: { code: typed.code, message: typed.message, ...(isWorkflowAuthored(typed) ? { authored: true } : {}) } });
+                }
+            }
+            else if (method === "function") {
+                const worktreeOwner = values[4] === undefined || values[4] === null ? undefined : typeof values[4] === "string" && values[4] ? values[4] : fail("INTERNAL_ERROR", "function worktree scope is invalid");
+                if (!bridge.function || typeof values[0] !== "string" || typeof values[1] !== "string" || !object(values[2]) || typeof values[3] !== "string")
+                    fail("INTERNAL_ERROR", "function requires an available bridge, names, object input, and path");
+                const name = values[0] + "." + values[1];
+                try {
+                    const result = await bridge.function(values[0], values[1], values[2], values[3], controller.signal, worktreeOwner);
+                    value = branded({ name, ok: true, value: result ?? null });
+                }
+                catch (error) {
+                    const typed = asWorkflowError(error);
+                    if (!OUTCOME_ERRORS.has(typed.code))
+                        throw typed;
+                    value = branded({ name, ok: false, failedAt: name, error: { code: typed.code, message: typed.message, ...(isWorkflowAuthored(typed) ? { authored: true } : {}) } });
+                }
+            }
+            else if (method === "phase") {
+                if (typeof values[0] !== "string")
+                    fail("INTERNAL_ERROR", "phase name must be a string");
+                await bridge.phase?.(values[0]);
+            }
+            else if (method === "log") {
+                if (typeof values[0] !== "string")
+                    fail("INTERNAL_ERROR", "log message must be a string");
+                await bridge.log?.(values[0]);
+            }
+            else
+                fail("INTERNAL_ERROR", `Unknown worker RPC method: ${method}`);
+            encoded(value);
+            child.send(encoded({ type: "rpcResult", id, ok: true, value }));
+        }
+        catch (error) {
+            const typed = asWorkflowError(error);
+            child.send(encoded({ type: "rpcResult", id, ok: false, error: { code: typed.code, message: typed.message, ...(isWorkflowAuthored(typed) ? { authored: true } : {}) } }));
+        }
+    }
+    function cancel() {
+        if (settled)
+            return;
+        controller.abort();
+        child.send(encoded({ type: "cancel" }));
+        stop("CANCELLED", "Workflow cancelled");
+    }
+    if (signal?.aborted)
+        cancel();
+    else
+        signal?.addEventListener("abort", cancel, { once: true });
+    return { result, cancel };
+}
+function nativeSessionReference(attempt) {
+    return { sessionId: attempt.sessionId, sessionFile: attempt.sessionFile };
+}
+export async function persistActiveAgentAttempt(store, id, active) {
+    await store.updateState((run) => {
+        const agent = run.agents.find((candidate) => candidate.id === id);
+        if (!agent)
+            throw new WorkflowError("INTERNAL_ERROR", `Missing production ownership record: ${id}`);
+        const accounting = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+        const nativeSessions = run.nativeSessions.some(({ sessionId }) => sessionId === active.sessionId) ? run.nativeSessions : [...run.nativeSessions, nativeSessionReference(active)];
+        return { ...run, agents: run.agents.map((candidate) => candidate.id === id ? { ...candidate, attempts: active.attempt, attemptDetails: [{ ...active, accounting }] } : candidate), nativeSessions };
+    });
+}
+export async function persistAgentAttempts(store, id, attempts) {
+    await store.updateState((run) => {
+        const agent = run.agents.find((candidate) => candidate.id === id);
+        if (!agent)
+            throw new WorkflowError("INTERNAL_ERROR", `Missing production ownership record: ${id}`);
+        const total = attempts.reduce((sum, attempt) => ({ input: sum.input + attempt.accounting.input, output: sum.output + attempt.accounting.output, cacheRead: sum.cacheRead + attempt.accounting.cacheRead, cacheWrite: sum.cacheWrite + attempt.accounting.cacheWrite, cost: sum.cost + attempt.accounting.cost }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
+        const attemptDetails = attempts.map(({ attempt, sessionId, sessionFile, error, accounting }) => ({ attempt, sessionId, sessionFile, ...(error ? { error } : {}), accounting }));
+        const sessionIds = new Set(attempts.map(({ sessionId }) => sessionId));
+        return { ...run, agents: run.agents.map((candidate) => candidate.id === id ? { ...candidate, attempts: attempts.length, attemptDetails, accounting: total } : candidate), nativeSessions: [...run.nativeSessions.filter(({ sessionId }) => !sessionIds.has(sessionId)), ...attempts.map((attempt) => nativeSessionReference(attempt))] };
+    });
+}
+export function formatWorkflowProgress(run, spinner = "◇") {
+    const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
+    const lines = [`${run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "running" ? spinner : "◆"} Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done)`];
+    if (run.phase)
+        lines.push(`  Phase: ${run.phase}`);
+    const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
+    for (const [index, agent] of run.agents.entries()) {
+        let depth = 0;
+        for (let parent = agent.parentId; parent && byId.has(parent); parent = byId.get(parent)?.parentId)
+            depth += 1;
+        const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? spinner : "○";
+        const indent = "  ".repeat(depth + 1);
+        const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner);
+        lines.push(`${indent}#${String(index + 1)} ${icon} ${agent.parentBreadcrumb ? `${agent.parentBreadcrumb} > ` : ""}${agent.label ?? agent.name} [${agent.state}]${activity ? ` ${activity}` : ""}`);
+    }
+    return lines.join("\n");
+}
+function workflowToolUpdate(run) {
+    return { content: [{ type: "text", text: formatWorkflowProgress(run) }], details: { runId: run.id, run } };
+}
+const workflowSpinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function textBlock(text) {
+    return {
+        render(width) {
+            return text.split("\n").map((line) => line.length <= width ? line : `${line.slice(0, Math.max(0, width - 1))}…`);
+        },
+        invalidate() { },
+    };
+}
+function workflowProgressBlock(run) {
+    return {
+        render(width) {
+            const frame = workflowSpinner[Math.floor(Date.now() / 80) % workflowSpinner.length] ?? "◇";
+            return formatWorkflowProgress(run, frame).split("\n").map((line) => line.length <= width ? line : `${line.slice(0, Math.max(0, width - 1))}…`);
+        },
+        invalidate() { },
+    };
+}
+const ATTENTION_ORDER = { awaiting_input: 0, running: 1, pausing: 2, paused: 3, interrupted: 4, failed: 5, queued: 6, stopped: 7, completed: 8 };
+function navigatorAttentionSort(entries) {
+    return [...entries].sort((a, b) => (ATTENTION_ORDER[a.loaded.run.state] ?? 9) - (ATTENTION_ORDER[b.loaded.run.state] ?? 9));
+}
+function navigatorRunLabels(entries) {
+    const nameCount = new Map();
+    for (const { loaded: { run } } of entries)
+        nameCount.set(run.workflowName, (nameCount.get(run.workflowName) ?? 0) + 1);
+    return entries.map(({ store, loaded: { run } }) => {
+        const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
+        const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+        const suffix = (nameCount.get(run.workflowName) ?? 0) > 1 ? ` ${store.runId.slice(0, 8)}` : "";
+        const cost = run.agents.reduce((sum, a) => sum + (a.accounting?.cost ?? 0), 0);
+        const costStr = cost > 0 ? ` $${cost.toFixed(2)}` : "";
+        return `${glyph} ${run.workflowName}${suffix}  ${run.state}  ${run.phase ?? ""}  ${String(done)}/${String(run.agents.length)} agents${costStr}`;
+    });
+}
+function agentBreadcrumb(agent, byId) {
+    const name = agent.label ?? agent.name;
+    const parts = [name];
+    const seen = new Set([agent.id]);
+    for (let parentId = agent.parentId; parentId; parentId = byId.get(parentId)?.parentId) {
+        if (seen.has(parentId))
+            break; // ponytail: cycle guard for corrupt data
+        seen.add(parentId);
+        const parent = byId.get(parentId);
+        if (parent)
+            parts.unshift(parent.label ?? parent.name);
+        else
+            break;
+    }
+    return parts.length > 1 ? parts.join(" > ") : name;
+}
+function formatAgentActivity(agent, spinner) {
+    if (agent.activity?.kind === "reasoning")
+        return `${spinner} reasoning`;
+    if (agent.activity?.kind === "text")
+        return `${spinner} responding`;
+    if (agent.activity?.kind === "tool")
+        return `${spinner} ${agent.activity.text}`;
+    const tool = [...(agent.toolCalls ?? [])].reverse().find(({ state }) => state === "running");
+    return tool ? `${spinner} ${tool.name}` : "";
+}
+function formatAccounting(accounting) {
+    const total = accounting.input + accounting.output + accounting.cacheRead + accounting.cacheWrite;
+    return `${new Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(total).toLowerCase()} tok`;
+}
+export function formatNavigatorDashboard(run, checkpoints, worktrees) {
+    const done = run.agents.filter((a) => SETTLED_AGENT_STATES.has(a.state)).length;
+    const totalAccounting = run.agents.reduce((sum, a) => ({ input: sum.input + (a.accounting?.input ?? 0), output: sum.output + (a.accounting?.output ?? 0), cacheRead: sum.cacheRead + (a.accounting?.cacheRead ?? 0), cacheWrite: sum.cacheWrite + (a.accounting?.cacheWrite ?? 0), cost: sum.cost + (a.accounting?.cost ?? 0) }), { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
+    const hasAccounting = run.agents.some((a) => a.accounting);
+    const glyph = run.state === "completed" ? "✓" : run.state === "failed" || run.state === "stopped" ? "✗" : run.state === "running" ? "⠦" : run.state === "awaiting_input" ? "●" : "◆";
+    const header = `${glyph} ${run.workflowName}`;
+    const meta = [run.state, run.phase ? `phase: ${run.phase}` : "", `${String(done)}/${String(run.agents.length)} agents`, hasAccounting ? formatAccounting(totalAccounting) : "", totalAccounting.cost > 0 ? `$${totalAccounting.cost.toFixed(2)}` : ""].filter(Boolean).join(" · ");
+    const lines = [header, meta];
+    if (run.error)
+        lines.push(`Error: ${run.error.code}: ${run.error.message}`);
+    lines.push("");
+    const byId = new Map(run.agents.map((a) => [a.id, a]));
+    const activeStates = new Set(["running", "waiting_for_child", "queued", "retrying", "paused"]);
+    const prioritised = [...run.agents].sort((a, b) => {
+        const aActive = activeStates.has(a.state) || a.state === "failed" ? 0 : 1;
+        const bActive = activeStates.has(b.state) || b.state === "failed" ? 0 : 1;
+        return aActive - bActive;
+    });
+    for (const agent of prioritised) {
+        const icon = agent.state === "completed" ? "✓" : agent.state === "failed" || agent.state === "cancelled" ? "✗" : agent.state === "running" ? "⠦" : "○";
+        const breadcrumb = agentBreadcrumb(agent, byId);
+        const model = `${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`;
+        const policy = [`model=${model}`, `tools=${agent.tools.join(",") || "(none)"}`, agent.role ? `role=${agent.role}` : ""];
+        const tokens = agent.accounting ? formatAccounting(agent.accounting) : "";
+        const parts = [`${icon} ${breadcrumb}`, agent.state, ...policy, tokens].filter(Boolean);
+        lines.push(parts.join(" · "));
+        if (agent.state === "failed" && agent.attemptDetails?.length) {
+            const last = agent.attemptDetails[agent.attemptDetails.length - 1];
+            if (last?.error)
+                lines.push(`  error: ${last.error.code}: ${last.error.message}`);
+        }
+        const activity = !SETTLED_AGENT_STATES.has(agent.state) ? formatAgentActivity(agent, "⠦") : "";
+        if (activity)
+            lines.push(`  ${activity}`);
+    }
+    if (checkpoints.length) {
+        lines.push("");
+        for (const cp of checkpoints)
+            lines.push(`● checkpoint ${cp.name}: ${cp.prompt}`);
+    }
+    if (worktrees.length) {
+        lines.push("");
+        for (const wt of worktrees)
+            lines.push(`branch ${wt.branch} (${wt.path})`);
+    }
+    return lines.join("\n");
+}
+export function formatNavigatorRun(loaded, checkpoints, worktrees) {
+    const { run, snapshot } = loaded;
+    const lines = [
+        `Workflow: ${run.workflowName}`,
+        `Run: ${run.id}`,
+        `Status: ${run.state}`,
+        `Phase: ${run.phase ?? "(none)"}`,
+        `Launch cwd: ${run.cwd}`,
+        `Launch models: ${snapshot.models.join(", ") || "(none)"}`,
+    ];
+    if (run.error)
+        lines.push(`Run error: ${run.error.code}: ${run.error.message}`);
+    lines.push("Agents / ownership:");
+    if (!run.agents.length)
+        lines.push("  (none)");
+    for (const agent of run.agents) {
+        const model = `${agent.model.provider}/${agent.model.model}${agent.model.thinking ? `:${agent.model.thinking}` : ""}`;
+        const role = agent.role ? ` role=${agent.role}` : "";
+        const tools = ` tools=${agent.tools.join(",") || "(none)"}`;
+        const accounting = agent.accounting ? ` input=${String(agent.accounting.input)} output=${String(agent.accounting.output)} cache-read=${String(agent.accounting.cacheRead)} cache-write=${String(agent.accounting.cacheWrite)} cost=${String(agent.accounting.cost)}` : "";
+        lines.push(`  ${agent.label ?? agent.name} (${agent.id}) state=${agent.state} parent=${agent.parentId ?? "root"} model=${model}${role}${tools} attempts=${String(agent.attempts)} retries=${String(Math.max(0, agent.attempts - 1))}${accounting}`);
+        for (const attempt of agent.attemptDetails ?? [])
+            lines.push(`    attempt ${String(attempt.attempt)} transcript=${attempt.sessionFile}${attempt.error ? ` error=${attempt.error.code}: ${attempt.error.message}` : ""}`);
+        for (const call of agent.toolCalls ?? [])
+            lines.push(`    tool ${call.name} state=${call.state}`);
+    }
+    lines.push("Checkpoints:");
+    if (!checkpoints.length)
+        lines.push("  (none)");
+    for (const checkpoint of checkpoints)
+        lines.push(`  ${checkpoint.name}: ${checkpoint.prompt} context=${JSON.stringify(checkpoint.context)}`);
+    lines.push("Worktrees / branches:");
+    if (!worktrees.length)
+        lines.push("  (none)");
+    for (const worktree of worktrees)
+        lines.push(`  ${worktree.owner}: branch=${worktree.branch} path=${worktree.path} cwd=${worktree.cwd}`);
+    lines.push("Native Pi transcript paths:");
+    if (!run.nativeSessions.length)
+        lines.push("  (none)");
+    for (const session of run.nativeSessions)
+        lines.push(`  ${session.sessionId}: ${session.sessionFile}`);
+    return lines.join("\n");
+}
+function formatCheckpointReview(checkpoint) {
+    return [`Name: ${checkpoint.name}`, "Prompt:", checkpoint.prompt, "Context:", JSON.stringify(checkpoint.context, null, 2)].join("\n");
+}
+const DELIVERY_LIMIT_BYTES = 4 * 1024;
+const WORKFLOW_LOG_ENTRY = "workflow-log";
+function completionDelivery(name, value, resultPath, worktrees) {
+    const locations = worktrees.length ? ` Changes: ${worktrees.map(({ branch, path }) => `${branch} (${path})`).join(", ")}.` : "";
+    const message = `Workflow ${name} completed: ${JSON.stringify(value)}${locations}`;
+    if (Buffer.byteLength(message) <= DELIVERY_LIMIT_BYTES)
+        return message;
+    const suffix = `... Full result: ${resultPath}${locations}`;
+    const suffixBytes = Buffer.byteLength(suffix);
+    if (suffixBytes >= DELIVERY_LIMIT_BYTES)
+        return utf8Prefix(suffix, DELIVERY_LIMIT_BYTES);
+    return utf8Prefix(message, DELIVERY_LIMIT_BYTES - suffixBytes) + suffix;
+}
+function utf8Prefix(value, maxBytes) {
+    const bytes = Buffer.from(value);
+    let end = Math.min(bytes.length, maxBytes);
+    while (end < bytes.length && end > 0 && ((bytes[end] ?? 0) & 0xc0) === 0x80)
+        end -= 1;
+    return bytes.subarray(0, end).toString("utf8");
+}
+function deliver(pi, content) {
+    pi.sendMessage({ customType: "workflow", content, display: true }, { deliverAs: "followUp", triggerTurn: true });
+}
+function deliverFailure(pi, name, error) {
+    deliver(pi, `Workflow ${name} failed: ${formatWorkflowFailure(error)}`);
+}
+const inheritedHostAgentPath = new AsyncLocalStorage();
+const inheritedHostWorktreeOwner = new AsyncLocalStorage();
+function namedRecord(value, kind) {
+    if (!object(value))
+        fail("INVALID_METADATA", `${kind} must be a record`);
+    return Object.entries(value);
+}
+function hostWithWorktree(args, identity, occurrences) {
+    if (args.length !== 1 && args.length !== 2)
+        fail("INVALID_METADATA", "withWorktree requires a callback or a name and callback");
+    const callback = args[args.length - 1];
+    if (typeof callback !== "function")
+        fail("INVALID_METADATA", "withWorktree callback must be a function");
+    let owner;
+    if (args.length === 2) {
+        if (typeof args[0] !== "string" || !args[0].trim())
+            fail("INVALID_METADATA", "withWorktree name must be a non-empty string");
+        owner = operationPath("worktree", "named", args[0].trim());
+    }
+    else {
+        const structuralPath = inheritedHostAgentPath.getStore() ?? [];
+        const key = `${identity}\0${JSON.stringify(structuralPath)}`;
+        const occurrence = (occurrences.get(key) ?? 0) + 1;
+        occurrences.set(key, occurrence);
+        owner = operationPath("worktree", "unnamed", "function", identity, ...structuralPath, `occurrence:${String(occurrence)}`);
+    }
+    return inheritedHostWorktreeOwner.run(owner, async () => await callback());
+}
+function workflowRunContext(cwd, sessionId, runId, workflow, args, signal) {
+    return Object.freeze({ cwd, sessionId, runId, workflow: deepFreeze(structuredClone(workflow)), args: deepFreeze(structuredClone(args)), signal });
+}
+async function resolveWorkflowVariables(run, controller, registry) {
+    let first;
+    const tasks = registry.variables().map(async ({ namespace, name, variable }) => {
+        try {
+            const result = await variable.resolve(run);
+            if (!jsonValue(result) || !Value.Check(variable.schema, result))
+                fail("RESULT_INVALID", `Invalid output from ${namespace}.${name}`);
+            return [name, deepFreeze(structuredClone(result))];
+        }
+        catch (error) {
+            const typed = errorCode(error) ? new WorkflowError(errorCode(error), `${namespace}.${name}: ${errorText(error)}`) : new WorkflowError("INTERNAL_ERROR", `${namespace}.${name}: ${errorText(error)}`);
+            if (!first) {
+                first = typed;
+                controller.abort();
+            }
+            throw typed;
+        }
+    });
+    await Promise.allSettled(tasks);
+    if (first)
+        throw first;
+    return Object.freeze(Object.fromEntries((await Promise.all(tasks)).map(([name, value]) => [name, value])));
+}
+async function hostParallel(rawOperation, rawTasks) {
+    if (typeof rawOperation !== "string" || !rawOperation.trim())
+        fail("INVALID_METADATA", "parallel requires a stable explicit name");
+    const tasks = namedRecord(rawTasks, "parallel tasks");
+    for (const [name, run] of tasks) {
+        if (!name.trim())
+            fail("INVALID_METADATA", "parallel task requires a stable explicit name");
+        if (typeof run !== "function")
+            fail("INVALID_METADATA", "parallel task values must be run functions");
+    }
+    const results = await Promise.all(tasks.map(async ([name, run]) => {
+        try {
+            const parent = inheritedHostAgentPath.getStore() ?? [];
+            return { name, value: await inheritedHostAgentPath.run([...parent, rawOperation, name], run) };
+        }
+        catch (error) {
+            const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", error instanceof Error ? error.message : String(error));
+            if (typed.code === "CANCELLED")
+                throw typed;
+            return { name, error: typed };
+        }
+    }));
+    const failure = results.find((result) => result.error);
+    if (failure?.error)
+        throw failure.error;
+    return Object.fromEntries(results.map((result) => [result.name, result.value]));
+}
+async function hostPipeline(rawOperation, rawItems, rawStages) {
+    if (typeof rawOperation !== "string" || !rawOperation.trim())
+        fail("INVALID_METADATA", "pipeline requires a stable explicit name");
+    const items = namedRecord(rawItems, "pipeline items");
+    const stages = namedRecord(rawStages, "pipeline stages");
+    if (!stages.length)
+        fail("INVALID_METADATA", "pipeline requires at least one stage");
+    for (const [name] of items)
+        if (!name.trim())
+            fail("INVALID_METADATA", "pipeline item requires a stable explicit name");
+    for (const [stageName, run] of stages) {
+        if (!stageName.trim())
+            fail("INVALID_METADATA", "pipeline stage requires a stable explicit name");
+        if (typeof run !== "function")
+            fail("INVALID_METADATA", "pipeline stage values must be run functions");
+    }
+    const results = await Promise.all(items.map(async ([name, initial]) => {
+        let current = initial;
+        try {
+            for (const [stageName, run] of stages) {
+                const parent = inheritedHostAgentPath.getStore() ?? [];
+                current = await inheritedHostAgentPath.run([...parent, rawOperation, name, stageName], () => run(current));
+            }
+            return { name, value: current };
+        }
+        catch (error) {
+            const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", error instanceof Error ? error.message : String(error));
+            if (typed.code === "CANCELLED")
+                throw typed;
+            return { name, error: typed };
+        }
+    }));
+    const failure = results.find((result) => result.error);
+    if (failure?.error)
+        throw failure.error;
+    return Object.fromEntries(results.map((result) => [result.name, result.value]));
+}
+function nextNamedOccurrence(counters, label) {
+    const count = (counters.get(label) ?? 0) + 1;
+    counters.set(label, count);
+    return count === 1 ? label : `${label}#${String(count)}`;
+}
+function withWorkflowFunctions(bridge, store, runContext, variables, registry) {
+    const functionAgentOccurrences = new Map();
+    const functionWorktreeOccurrences = new Map();
+    return { ...bridge, functions: registry.globals(), variables, function: async (namespace, name, input, path, signal, worktreeOwner) => {
+            const replayed = await store.replay(path);
+            let stored;
+            const sideEffects = [];
+            const context = {
+                run: runContext,
+                agent: async (...args) => {
+                    if (!bridge.agent || typeof args[0] !== "string")
+                        fail("AGENT_FAILED", "No agent bridge is available");
+                    const options = validateAgentOptions(args[1] === undefined ? {} : args[1]);
+                    const scopedWorktreeOwner = inheritedHostWorktreeOwner.getStore() ?? worktreeOwner;
+                    const structuralPath = inheritedHostAgentPath.getStore() ?? [];
+                    const key = `${path}\0${JSON.stringify(structuralPath)}`;
+                    const occurrence = (functionAgentOccurrences.get(key) ?? 0) + 1;
+                    functionAgentOccurrences.set(key, occurrence);
+                    return bridge.agent(args[0], options, signal, { structuralPath: [...structuralPath], callSite: `function:${path}`, occurrence, parentBreadcrumb: `${namespace}.${name}`, ...(scopedWorktreeOwner ? { worktreeOwner: scopedWorktreeOwner } : {}) });
+                },
+                prompt: workflowPrompt,
+                parallel: (...args) => hostParallel(args[0], args[1]),
+                pipeline: (...args) => hostPipeline(args[0], args[1], args[2]),
+                withWorktree: (...args) => hostWithWorktree(args, path, functionWorktreeOccurrences),
+                checkpoint: async (...args) => {
+                    if (!bridge.checkpoint || !object(args[0]) || !jsonValue(args[0]))
+                        fail("INTERNAL_ERROR", "No checkpoint bridge is available");
+                    return bridge.checkpoint(args[0], signal);
+                },
+                phase: (name) => { sideEffects.push(Promise.resolve(bridge.phase?.(name))); },
+                log: (message) => { sideEffects.push(Promise.resolve(bridge.log?.(message))); },
+            };
+            const result = await registry.invokeFunction(namespace, name, input, context, path, { get: () => replayed?.value, put: (_path, value) => { stored = value; } });
+            await Promise.all(sideEffects);
+            if (!replayed)
+                await store.complete(path, stored ?? result);
+            return result;
+        } };
+}
+function projectTrusted(ctx) {
+    const check = object(ctx) ? ctx.isProjectTrusted : undefined;
+    return typeof check === "function" ? Boolean(Reflect.apply(check, ctx, [])) : true;
+}
+function parseThinking(value) {
+    switch (value) {
+        case "off":
+        case "minimal":
+        case "low":
+        case "medium":
+        case "high":
+        case "xhigh":
+        case "max": return value;
+        default: return undefined;
+    }
+}
+export default function workflowExtension(pi, home, clipboard = copyToClipboard, createSession = createNativeAgentSession) {
+    beginWorkflowExtensionLoading();
+    const registry = loadingRegistry();
+    const registerEntryRenderer = pi.registerEntryRenderer;
+    registerEntryRenderer?.(WORKFLOW_LOG_ENTRY, (entry) => {
+        const data = entry.data;
+        return textBlock(data ? `Workflow ${data.workflowName}: ${data.message}` : "");
+    });
+    const logBridge = (lifecycle, workflowName) => async (message) => {
+        await lifecycle.enter();
+        try {
+            pi.appendEntry(WORKFLOW_LOG_ENTRY, { workflowName, message: utf8Prefix(message, DELIVERY_LIMIT_BYTES) });
+        }
+        finally {
+            await lifecycle.leave();
+        }
+    };
+    const events = pi.events;
+    pi.on("resources_discover", () => {
+        if (!pi.getActiveTools().includes("workflow"))
+            return;
+        const extensionDir = dirname(fileURLToPath(import.meta.url));
+        const skillPath = [join(extensionDir, "../skills"), join(extensionDir, "../../skills")].find((path) => existsSync(path));
+        return skillPath ? { skillPaths: [skillPath] } : undefined;
+    });
+    const emitAsyncStarted = (store, metadata) => {
+        events?.emit(WORKFLOW_ASYNC_STARTED_EVENT, { id: store.runId, runId: store.runId, pid: process.pid, sessionId: store.sessionId, asyncDir: store.directory, agent: metadata.name });
+    };
+    const emitAsyncComplete = (store, state, error) => {
+        events?.emit(WORKFLOW_ASYNC_COMPLETE_EVENT, { id: store.runId, runId: store.runId, sessionId: store.sessionId, asyncDir: store.directory, success: state === "complete", state, ...(state === "stopped" ? { stopped: true } : {}), ...(error ? { error: error.message } : {}) });
+    };
+    const runs = new Map();
+    let sessionLease;
+    let sessionLeasePromise;
+    const ensureSessionLease = async (cwd, sessionId) => {
+        if (sessionLease?.active)
+            return;
+        const pending = sessionLeasePromise ?? (sessionLeasePromise = acquireSessionLease(cwd, sessionId, home));
+        try {
+            sessionLease = await pending;
+        }
+        finally {
+            if (sessionLeasePromise === pending)
+                sessionLeasePromise = undefined;
+        }
+    };
+    const releaseSessionLease = async () => {
+        const lease = sessionLease ?? await sessionLeasePromise?.catch(() => undefined);
+        sessionLease = undefined;
+        sessionLeasePromise = undefined;
+        await lease?.release();
+    };
+    const lifecycleFor = (store, state) => new RunLifecycle(state, async (next) => {
+        const run = await store.updateState((current) => {
+            const nextRun = { ...current, state: next };
+            if (next === "running" || next === "completed")
+                delete nextRun.error;
+            return nextRun;
+        });
+        runs.get(store.runId)?.update?.(workflowToolUpdate(run));
+    });
+    const scheduler = new FairAgentScheduler(async ({ id, runId, parentId, prompt, options, signal, setSteer }) => {
+        const run = runs.get(runId);
+        if (!run)
+            throw new WorkflowError("INTERNAL_ERROR", `Unknown production run: ${runId}`);
+        try {
+            const onProgress = async (progress) => {
+                let runState;
+                if (progress.persist) {
+                    runState = await run.store.updateState((current) => current.agents.some((agent) => agent.id === id) ? { ...current, agents: current.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity } : agent) } : current);
+                }
+                else {
+                    const loaded = await run.store.load();
+                    if (!loaded.run.agents.some((agent) => agent.id === id))
+                        return;
+                    runState = { ...loaded.run, agents: loaded.run.agents.map((agent) => agent.id === id ? { ...agent, accounting: progress.accounting, toolCalls: progress.toolCalls, activity: progress.activity } : agent) };
+                }
+                if (!runState.agents.some((agent) => agent.id === id))
+                    return;
+                run.update?.(workflowToolUpdate(runState));
+            };
+            const onAttempt = async (attempt) => {
+                await scheduler.flush();
+                await persistActiveAgentAttempt(run.store, id, attempt);
+                run.update?.(workflowToolUpdate((await run.store.load()).run));
+            };
+            const result = await run.executor.execute(prompt, { label: options.label, workflowName: run.metadata.name, onProgress, onAttempt, ...(parentId ? { parent: parentId, cwd: options.cwd, ...(options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}) } : options.worktreeOwner ? { worktreeOwner: options.worktreeOwner } : {}), ...(options.model ? { model: options.model } : {}), ...(options.thinking ? { thinking: options.thinking } : {}), ...(options.role ? { role: options.role } : {}), ...(options.role ? {} : { tools: options.tools }), effectiveTools: options.tools, ...(options.schema ? { schema: options.schema } : {}), ...(options.retries === undefined ? {} : { retries: options.retries }), ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }) }, signal, scheduler.toolsFor(id, (role, tools, model, inheritedTools, thinking) => run.executor.resolve({ label: "child", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(tools !== undefined ? { tools } : {}) }, inheritedTools).tools), setSteer, () => { scheduler.cancelChildren(id); });
+            await persistAgentAttempts(run.store, id, result.attempts);
+            return result.value;
+        }
+        catch (error) {
+            const attempts = error.attempts;
+            if (attempts?.length)
+                await persistAgentAttempts(run.store, id, attempts);
+            throw error;
+        }
+    }, 16, async (runId, ownership) => {
+        const run = runs.get(runId);
+        if (!run)
+            return;
+        await run.store.saveOwnership(ownership);
+        const runState = await run.store.updateState((current) => {
+            const existing = new Map(current.agents.map((agent) => [agent.id, agent]));
+            const agents = ownership.map((node) => {
+                const previous = existing.get(node.id);
+                const requested = { label: node.options.label, workflowName: run.metadata.name, ...(node.options.model ? { model: node.options.model } : {}), ...(node.options.thinking ? { thinking: node.options.thinking } : {}), ...(node.options.role ? { role: node.options.role } : {}), effectiveTools: node.options.tools };
+                let effective;
+                try {
+                    effective = run.executor.resolve(requested);
+                }
+                catch {
+                    effective = previous ? { model: previous.model, tools: previous.tools } : { model: node.options.model ? modelSpec(node.options.model, run.model) : { ...run.model, ...(node.options.thinking ? { thinking: node.options.thinking } : {}) }, tools: node.options.tools };
+                }
+                return { id: node.id, name: node.label, ...(node.options.requestedLabel ? { label: node.options.requestedLabel } : {}), path: node.id, state: node.state, ...(node.parentId ? { parentId: node.parentId } : {}), ...(node.options.parentBreadcrumb ? { parentBreadcrumb: node.options.parentBreadcrumb } : {}), ...(node.options.role ? { role: node.options.role } : {}), model: effective.model, tools: effective.tools, attempts: previous?.attempts ?? 0, ...(previous?.attemptDetails ? { attemptDetails: previous.attemptDetails } : {}), ...(previous?.accounting ? { accounting: previous.accounting } : {}), ...(previous?.toolCalls ? { toolCalls: previous.toolCalls } : {}), ...(previous?.activity ? { activity: previous.activity } : {}) };
+            });
+            return { ...current, agents };
+        });
+        run.update?.(workflowToolUpdate(runState));
+    });
+    const answerCheckpoint = async (runId, name, approved, silent = false) => {
+        const run = runs.get(runId);
+        if (!run)
+            return false;
+        const checkpoint = await run.store.answerCheckpoint(name, approved);
+        if (!checkpoint)
+            return false;
+        if ((await run.store.awaitingCheckpoints()).length === 0)
+            await run.lifecycle.resolveAwaitingInput();
+        run.checkpointResolvers.get(checkpoint.path)?.(approved);
+        run.checkpointResolvers.delete(checkpoint.path);
+        if (!silent)
+            deliver(pi, `Workflow ${run.metadata.name} checkpoint ${name}: ${approved ? "Approved" : "Rejected"}.`);
+        return true;
+    };
+    const checkpointBridge = (runId, store, metadata, foreground, ui) => {
+        const checkpointCounters = new Map();
+        return async (raw, signal) => {
+            const input = validateCheckpoint(raw);
+            const label = nextNamedOccurrence(checkpointCounters, input.name);
+            const path = operationPath("checkpoint", label);
+            if (foreground && !ui?.select)
+                fail("RESUME_INCOMPATIBLE", "Foreground checkpoints require UI");
+            const alreadyAwaiting = (await store.awaitingCheckpoints()).some((checkpoint) => checkpoint.path === path);
+            const replayed = await store.awaitCheckpoint({ ...input, name: label, path });
+            if (replayed !== undefined)
+                return replayed;
+            const run = runs.get(runId);
+            await run?.lifecycle.enterAwaitingInput();
+            if (!alreadyAwaiting && !ui?.select)
+                deliver(pi, `Workflow ${metadata.name} checkpoint ${label}: ${input.prompt}\nContext: ${JSON.stringify(input.context)}\nRespond with workflow_respond.`);
+            const decision = new Promise((resolve, reject) => {
+                run?.checkpointResolvers.set(path, resolve);
+                if (signal.aborted)
+                    reject(new WorkflowError("CANCELLED", "Workflow cancelled"));
+                else
+                    signal.addEventListener("abort", () => { run?.checkpointResolvers.delete(path); reject(new WorkflowError("CANCELLED", "Workflow cancelled")); }, { once: true });
+            });
+            const answered = await store.awaitCheckpoint({ ...input, name: label, path });
+            if (answered !== undefined) {
+                if ((await store.awaitingCheckpoints()).length === 0)
+                    await run?.lifecycle.resolveAwaitingInput();
+                run?.checkpointResolvers.get(path)?.(answered);
+                run?.checkpointResolvers.delete(path);
+            }
+            if (ui?.select)
+                void (async () => {
+                    while (!signal.aborted && run?.checkpointResolvers.has(path)) {
+                        const choice = await ui.select?.(input.prompt, ["Approve", "Reject"]);
+                        if (!choice) {
+                            if (foreground)
+                                continue; // foreground: retry until answered
+                            // Background resume: user dismissed UI, fall back to LLM
+                            deliver(pi, `Workflow ${metadata.name} checkpoint ${label}: ${input.prompt}\nContext: ${JSON.stringify(input.context)}\nRespond with workflow_respond.`);
+                            return;
+                        }
+                        if (await answerCheckpoint(runId, label, choice === "Approve", true))
+                            return;
+                    }
+                })().catch(() => undefined);
+            return decision;
+        };
+    };
+    pi.registerTool({
+        name: "workflow_respond",
+        label: "Workflow Respond",
+        description: "Approve or reject one pending workflow checkpoint",
+        parameters: Type.Object({ runId: Type.String(), name: Type.String(), approved: Type.Boolean() }, { additionalProperties: false }),
+        async execute(_id, params) {
+            try {
+                const accepted = await answerCheckpoint(params.runId, params.name, params.approved);
+                return { content: [{ type: "text", text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response." }], details: { accepted } };
+            }
+            catch (error) {
+                throw mainAgentError(error);
+            }
+        },
+    });
+    let catalogRegistered = false;
+    let sessionStarted = false;
+    const registerCatalog = () => {
+        if (catalogRegistered || !pi.getActiveTools().includes("workflow"))
+            return;
+        const catalog = registry.catalog();
+        if (!catalog.functions.length && !catalog.variables.length && !catalog.workflows.length)
+            return;
+        pi.registerTool({
+            name: "workflow_catalog",
+            label: "Workflow Catalog",
+            description: "List global workflow functions, variables, and reusable workflows",
+            parameters: Type.Object({}, { additionalProperties: false }),
+            async execute() { return { content: [{ type: "text", text: JSON.stringify(registry.catalog()) }], details: {} }; }
+        });
+        catalogRegistered = true;
+    };
+    const coldResumeRun = async (run, hasUI, ui, trustedProject) => {
+        const loaded = await run.store.load();
+        if (loaded.snapshot.identityVersion !== LAUNCH_SNAPSHOT_IDENTITY_VERSION)
+            throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
+        if (loaded.snapshot.roles === undefined)
+            throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow role definitions are missing from the launch snapshot");
+        if ((loaded.snapshot.projectRoles?.length ?? 0) > 0 && !trustedProject)
+            throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot restore project roles in an untrusted project");
+        const missingRole = loaded.snapshot.agentTypes.find((role) => !loaded.snapshot.roles?.[role]);
+        if (missingRole)
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Role definition is missing from the launch snapshot: ${missingRole}`);
+        const active = new Set(pi.getActiveTools().filter((tool) => tool !== "workflow" && tool !== "workflow_respond" && tool !== "workflow_catalog"));
+        const missing = loaded.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
+        if (missing)
+            throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
+        preflight(loaded.snapshot.script, { models: new Set(loaded.snapshot.models), tools: active, agentTypes: new Set(loaded.snapshot.agentTypes) }, loaded.snapshot.schemas, loaded.snapshot.metadata);
+        const controller = new AbortController();
+        run.abortController = controller;
+        const runContext = workflowRunContext(run.store.cwd, run.store.sessionId, run.store.runId, loaded.snapshot.metadata, loaded.snapshot.args, controller.signal);
+        let variables;
+        try {
+            variables = await resolveWorkflowVariables(runContext, controller, registry);
+        }
+        catch (error) {
+            const typed = asWorkflowError(error);
+            if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
+                await run.lifecycle.terminal("failed").catch(() => undefined);
+                await run.store.updateState((current) => ({ ...current, error: { code: typed.code, message: typed.message } }));
+            }
+            throw typed;
+        }
+        await scheduler.cancelRun(run.store.runId);
+        await run.lifecycle.resume();
+        const execution = runWorkflow(loaded.snapshot.script, loaded.snapshot.args, withWorkflowFunctions({ agent: async (prompt, options, signal, identity) => {
+                await run.lifecycle.enter();
+                try {
+                    const path = agentIdentityPath(identity);
+                    const replayed = await run.store.replay(path);
+                    if (replayed)
+                        return replayed.value;
+                    const worktree = agentWorktree(identity);
+                    const cwd = worktree.worktreeOwner ? (await run.store.worktree(worktree.worktreeOwner)).cwd : run.store.cwd;
+                    const role = typeof options.role === "string" ? options.role : undefined;
+                    const model = typeof options.model === "string" ? options.model : undefined;
+                    const thinking = parseThinking(options.thinking);
+                    const requestedLabel = typeof options.label === "string" ? options.label : undefined;
+                    const resolved = run.executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: run.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}) });
+                    const label = displayAgentName(requestedLabel, role, resolved.model);
+                    const tools = resolved.tools;
+                    const schema = object(options.outputSchema) ? options.outputSchema : undefined;
+                    const spawned = scheduler.spawn(run.store.runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}) });
+                    const cancel = () => { scheduler.cancel(spawned.id); };
+                    signal.addEventListener("abort", cancel, { once: true });
+                    const outcome = await spawned.result.finally(() => { signal.removeEventListener("abort", cancel); });
+                    if (!outcome.ok)
+                        throw new WorkflowError(outcome.error.code, outcome.error.message);
+                    await run.store.complete(path, outcome.value);
+                    return outcome.value;
+                }
+                finally {
+                    await run.lifecycle.leave();
+                }
+            }, checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, false, hasUI ? ui : undefined), phase: async (phase) => { await run.lifecycle.enter(); try {
+                await run.store.updateState((current) => ({ ...current, phase }));
+            }
+            finally {
+                await run.lifecycle.leave();
+            } }, log: logBridge(run.lifecycle, run.metadata.name) }, run.store, runContext, variables, registry), controller.signal);
+        run.execution = execution;
+        emitAsyncStarted(run.store, run.metadata);
+        const completion = execution.result.then(async (value) => { await scheduler.flush(); const resultPath = await run.store.saveResult(value); await run.lifecycle.terminal("completed"); emitAsyncComplete(run.store, "complete"); return { value, resultPath }; }, async (error) => { await scheduler.flush(); if (run.lifecycle.state !== "stopped" && run.lifecycle.state !== "interrupted")
+            await run.lifecycle.terminal("failed"); const typed = error instanceof WorkflowError ? error : new WorkflowError(errorCode(error) ?? "INTERNAL_ERROR", errorText(error)); await run.store.updateState((current) => ({ ...current, error: { code: typed.code, message: typed.message } })); emitAsyncComplete(run.store, run.lifecycle.state === "stopped" ? "stopped" : "failed", typed); if (run.lifecycle.state !== "stopped" && run.lifecycle.state !== "interrupted")
+            deliverFailure(pi, run.metadata.name, error); });
+        run.completion = completion;
+        void completion;
+    };
+    pi.on("session_start", async (_event, ctx) => {
+        if (sessionStarted)
+            return;
+        sessionStarted = true;
+        registry.freeze();
+        registerCatalog();
+        await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+        try {
+            for (const runId of await listRunIds(ctx.cwd, ctx.sessionManager.getSessionId(), home)) {
+                if (runs.has(runId))
+                    continue;
+                const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
+                let loaded;
+                try {
+                    loaded = await store.load();
+                }
+                catch {
+                    if (!await store.isComplete())
+                        await store.delete(true).catch(() => undefined);
+                    continue;
+                }
+                if (["completed", "failed", "stopped"].includes(loaded.run.state))
+                    continue;
+                if (loaded.run.state !== "interrupted") {
+                    await store.updateState((current) => ["completed", "failed", "stopped", "interrupted"].includes(current.state) ? current : { ...current, state: "interrupted" });
+                    loaded = { ...loaded, run: (await store.load()).run };
+                }
+                const model = modelSpec(loaded.snapshot.models[0] ?? "", { provider: ctx.model?.provider ?? "", model: ctx.model?.id ?? "", thinking: pi.getThinkingLevel() });
+                const lifecycle = lifecycleFor(store, loaded.run.state);
+                const providerPause = async () => { deliver(pi, `Workflow ${loaded.snapshot.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
+                const roleDefinitions = loaded.snapshot.roles ?? {};
+                runs.set(runId, { executor: new WorkflowAgentExecutor({ cwd: ctx.cwd, model, tools: new Set(loaded.snapshot.tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")), availableModels: new Set(loaded.snapshot.models), agentDefinitions: roleDefinitions, runStore: store, providerPause }, createSession), store, metadata: loaded.snapshot.metadata, model, lifecycle, abortController: new AbortController(), checkpointResolvers: new Map() });
+                for (const checkpoint of await store.awaitingCheckpoints())
+                    deliver(pi, `Workflow ${loaded.snapshot.metadata.name} checkpoint ${checkpoint.name}: ${checkpoint.prompt}\nContext: ${JSON.stringify(checkpoint.context)}\nRespond with workflow_respond.`);
+                scheduler.restoreRun(runId, loaded.snapshot.settings.concurrency, loaded.snapshot.settings.maxAgentLaunches, loaded.snapshot.identityVersion === LAUNCH_SNAPSHOT_IDENTITY_VERSION ? await store.loadOwnership() : []);
+            }
+            const resumeSelect = ctx.ui?.select;
+            if (ctx.hasUI && resumeSelect) {
+                const interrupted = [...runs.values()].filter((r) => r.lifecycle.state === "interrupted");
+                if (interrupted.length > 0) {
+                    const labels = interrupted.map((r) => `Resume: ${r.metadata.name} (${r.store.runId.slice(0, 8)})`);
+                    const options = [...labels, ...(interrupted.length > 1 ? ["Resume all"] : []), "Skip"];
+                    const choice = await resumeSelect(`${String(interrupted.length)} interrupted workflow${interrupted.length > 1 ? "s" : ""} found`, options);
+                    if (choice && choice !== "Skip") {
+                        const toResume = choice === "Resume all" ? interrupted : interrupted.filter((_, i) => labels[i] === choice);
+                        for (const run of toResume) {
+                            try {
+                                await coldResumeRun(run, true, ctx.ui, projectTrusted(ctx));
+                                ctx.ui.notify(`Resumed workflow ${run.metadata.name}.`, "info");
+                            }
+                            catch (err) {
+                                ctx.ui.notify(`Cannot resume ${run.metadata.name}: ${err instanceof Error ? err.message : String(err)}`, "warning");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            await releaseSessionLease();
+            throw error;
+        }
+    });
+    pi.on("before_agent_start", (event, ctx) => {
+        if (!pi.getActiveTools().includes("workflow"))
+            return;
+        const roles = Object.entries(loadAgentDefinitions(ctx.cwd, undefined, projectTrusted(ctx))).filter(([, definition]) => definition.description);
+        if (!roles.length)
+            return;
+        const content = `Workflow role descriptions:\n${roles.map(([name, definition]) => `- \`${name}\`: ${String(definition.description)}`).join("\n")}`;
+        return { systemPrompt: `${event.systemPrompt}\n\n${content}` };
+    });
+    pi.registerTool({
+        name: "workflow",
+        label: WORKFLOW_TOOL_LABEL,
+        description: WORKFLOW_TOOL_DESCRIPTION,
+        promptSnippet: WORKFLOW_TOOL_PROMPT_SNIPPET,
+        parameters: WORKFLOW_TOOL_PARAMETERS,
+        async execute(_id, params, signal, onUpdate, ctx) {
+            try {
+                if (!ctx.model)
+                    throw new WorkflowError("UNKNOWN_MODEL", "A launching model is required");
+                const defaults = loadSettings();
+                const settings = Object.freeze({ concurrency: params.concurrency ?? defaults.concurrency, maxAgentLaunches: params.maxAgentLaunches ?? defaults.maxAgentLaunches });
+                const rootModel = { provider: ctx.model.provider, model: ctx.model.id, thinking: pi.getThinkingLevel() };
+                const rootModelName = `${rootModel.provider}/${rootModel.model}`;
+                const modelRegistry = ctx.modelRegistry;
+                const availableModels = new Set((modelRegistry?.getAvailable() ?? [ctx.model]).map((model) => `${model.provider}/${model.id}`));
+                availableModels.add(rootModelName);
+                const rootTools = pi.getActiveTools().filter((name) => name !== "workflow" && name !== "workflow_respond" && name !== "workflow_catalog");
+                const trustedProject = projectTrusted(ctx);
+                const validated = validateWorkflowLaunchWithRegistry(params, { cwd: ctx.cwd, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools) }, registry);
+                const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames } = validated;
+                await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+                const runId = randomUUID();
+                const args = (params.args ?? null);
+                encoded(args);
+                const runController = new AbortController();
+                if (signal?.aborted)
+                    runController.abort();
+                else
+                    signal?.addEventListener("abort", () => { runController.abort(); }, { once: true });
+                const runContext = workflowRunContext(ctx.cwd, ctx.sessionManager.getSessionId(), runId, checked.metadata, args, runController.signal);
+                const variables = await resolveWorkflowVariables(runContext, runController, registry);
+                const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
+                const roles = Object.fromEntries(roleNames.map((role) => [role, agentDefinitions[role]]));
+                const projectRoles = roleNames.filter((role) => projectAgentDefinitions[role] !== undefined);
+                const roleModels = roleNames.flatMap((role) => { const model = agentDefinitions[role]?.model; return model ? [modelCapability(model)] : []; });
+                const snapshotModels = [...new Set([rootModelName, ...checked.referenced.models, ...roleModels])];
+                const snapshot = createLaunchSnapshot({ script, args, metadata: checked.metadata, settings, models: snapshotModels, tools: rootTools, agentTypes: checked.referenced.agentTypes, roles, projectRoles, schemas: checked.schemas });
+                await store.create({ id: runId, workflowName: checked.metadata.name, cwd: ctx.cwd, sessionId: ctx.sessionManager.getSessionId(), state: "running", agents: [], nativeSessions: [] }, snapshot);
+                const lifecycle = lifecycleFor(store, "running");
+                const background = !params.foreground;
+                const providerPause = async () => { if (background)
+                    deliver(pi, `Workflow ${checked.metadata.name} paused: provider limit.`); await lifecycle.providerPause(); };
+                const executor = new WorkflowAgentExecutor({ cwd: ctx.cwd, model: rootModel, tools: new Set(rootTools), availableModels, agentDefinitions, runStore: store, providerPause }, createSession);
+                runs.set(runId, { executor, store, metadata: checked.metadata, model: rootModel, lifecycle, abortController: runController, checkpointResolvers: new Map(), ...(params.foreground && onUpdate ? { update: onUpdate } : {}) });
+                if (params.foreground && onUpdate)
+                    onUpdate(workflowToolUpdate((await store.load()).run));
+                scheduler.addRun(runId, settings.concurrency, settings.maxAgentLaunches);
+                const execution = runWorkflow(script, args, withWorkflowFunctions({ agent: async (prompt, options, agentSignal, identity) => {
+                        await lifecycle.enter();
+                        try {
+                            const path = agentIdentityPath(identity);
+                            const replayed = await store.replay(path);
+                            if (replayed)
+                                return replayed.value;
+                            const worktree = agentWorktree(identity);
+                            const cwd = worktree.worktreeOwner ? (await store.worktree(worktree.worktreeOwner)).cwd : ctx.cwd;
+                            const role = typeof options.role === "string" ? options.role : undefined;
+                            const model = typeof options.model === "string" ? options.model : undefined;
+                            const thinking = parseThinking(options.thinking);
+                            const requestedLabel = typeof options.label === "string" ? options.label : undefined;
+                            const resolved = executor.resolve({ label: requestedLabel ?? role ?? "agent", workflowName: checked.metadata.name, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(Array.isArray(options.tools) ? { tools: options.tools } : {}) });
+                            const label = displayAgentName(requestedLabel, role, resolved.model);
+                            const tools = resolved.tools;
+                            const schema = object(options.outputSchema) ? options.outputSchema : undefined;
+                            const spawned = scheduler.spawn(runId, prompt, { label, ...(requestedLabel ? { requestedLabel } : {}), ...(identity.parentBreadcrumb ? { parentBreadcrumb: identity.parentBreadcrumb } : {}), cwd, tools, ...worktree, ...(model ? { model } : {}), ...(thinking ? { thinking } : {}), ...(role ? { role } : {}), ...(schema ? { schema } : {}), ...(typeof options.retries === "number" && Number.isInteger(options.retries) && options.retries >= 0 ? { retries: options.retries } : {}), ...(positiveInteger(options.timeoutMs) || options.timeoutMs === null ? { timeoutMs: options.timeoutMs } : {}) });
+                            const cancel = () => { scheduler.cancel(spawned.id); };
+                            if (agentSignal.aborted)
+                                cancel();
+                            else
+                                agentSignal.addEventListener("abort", cancel, { once: true });
+                            const outcome = await spawned.result.finally(() => { agentSignal.removeEventListener("abort", cancel); });
+                            if (!outcome.ok)
+                                throw new WorkflowError(outcome.error.code, outcome.error.message);
+                            await store.complete(path, outcome.value);
+                            return outcome.value;
+                        }
+                        finally {
+                            await lifecycle.leave();
+                        }
+                    }, checkpoint: checkpointBridge(runId, store, checked.metadata, Boolean(params.foreground), params.foreground && ctx.hasUI ? ctx.ui : undefined), phase: async (phase) => {
+                        await lifecycle.enter();
+                        try {
+                            const run = await store.updateState((current) => ({ ...current, phase }));
+                            runs.get(runId)?.update?.(workflowToolUpdate(run));
+                        }
+                        finally {
+                            await lifecycle.leave();
+                        }
+                    }, log: logBridge(lifecycle, checked.metadata.name) }, store, runContext, variables, registry), runController.signal);
+                runs.get(runId).execution = execution;
+                if (background)
+                    emitAsyncStarted(store, checked.metadata);
+                const finish = execution.result.then(async (value) => { await scheduler.flush(); const resultPath = await store.saveResult(value); await lifecycle.terminal("completed"); return { value, resultPath }; }, async (error) => { await scheduler.flush(); const typed = error instanceof WorkflowError ? error : new WorkflowError("INTERNAL_ERROR", String(error)); if (lifecycle.state !== "stopped" && lifecycle.state !== "interrupted")
+                    await lifecycle.terminal(typed.code === "CANCELLED" ? "stopped" : "failed"); await store.updateState((current) => ({ ...current, error: { code: typed.code, message: typed.message } })); throw typed; });
+                runs.get(runId).completion = finish;
+                if (background) {
+                    void finish.then(async ({ value, resultPath }) => {
+                        emitAsyncComplete(store, "complete");
+                        deliver(pi, completionDelivery(checked.metadata.name, value, resultPath, await store.changedWorktrees()));
+                    }, (error) => { emitAsyncComplete(store, lifecycle.state === "stopped" ? "stopped" : "failed", error instanceof Error ? error : new Error(errorText(error))); deliverFailure(pi, checked.metadata.name, error); });
+                    return { content: [{ type: "text", text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` } };
+                }
+                const { value } = await finish;
+                const run = (await store.load()).run;
+                return { content: [{ type: "text", text: JSON.stringify(value) }], details: { runId, value, run } };
+            }
+            catch (error) {
+                throw mainAgentError(error);
+            }
+        },
+        renderCall(args) {
+            return textBlock(formatWorkflowPreview(args));
+        },
+        renderResult(result, { isPartial }, _theme, context) {
+            const details = result.details;
+            const state = context.state;
+            if (details?.run && isPartial && details.run.state === "running" && !state.workflowSpinner) {
+                state.workflowSpinner = setInterval(context.invalidate, 80);
+                state.workflowSpinner.unref();
+            }
+            else if ((!isPartial || details?.run?.state !== "running") && state.workflowSpinner) {
+                clearInterval(state.workflowSpinner);
+                delete state.workflowSpinner;
+            }
+            if (details?.run)
+                return workflowProgressBlock(details.run);
+            const content = result.content[0];
+            return textBlock(isPartial ? "Workflow starting..." : details?.preview ?? (content?.type === "text" ? content.text : "Workflow finished"));
+        },
+    });
+    pi.registerCommand("workflow", {
+        description: "Inspect and control workflows for this Pi session",
+        handler: async (args, ctx) => {
+            const command = args.trim();
+            if (command === "doctor") {
+                const { doctor, doctorExitCode, formatDoctorReport } = await import("./doctor.js");
+                const report = await doctor({ cwd: ctx.cwd, activeTools: pi.getActiveTools().filter((tool) => tool !== "workflow" && tool !== "workflow_respond") });
+                ctx.ui.notify(formatDoctorReport(report), doctorExitCode(report) ? "warning" : "info");
+                return;
+            }
+            await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
+            const loadStores = async () => {
+                const entries = await Promise.all((await listRunIds(ctx.cwd, ctx.sessionManager.getSessionId(), home)).map(async (runId) => {
+                    const store = new RunStore(ctx.cwd, ctx.sessionManager.getSessionId(), runId, home);
+                    try {
+                        return { store, loaded: await store.load() };
+                    }
+                    catch {
+                        if (!await store.isComplete())
+                            await store.delete(true).catch(() => undefined);
+                        return undefined;
+                    }
+                }));
+                return entries.filter((entry) => entry !== undefined);
+            };
+            let stores = await loadStores();
+            const usage = "Usage: /workflow [doctor], or /workflow pause|resume|stop|approve|reject|delete <run-id> [checkpoint]";
+            const setWorkflowStatus = (text) => {
+                const setStatus = ctx.ui.setStatus;
+                setStatus?.call(ctx.ui, "workflow-stop", text);
+            };
+            const runAction = async (actionCommand, keepContext, status = setWorkflowStatus) => {
+                const [action, runId, ...rest] = actionCommand.split(/\s+/);
+                try {
+                    const run = runId ? runs.get(runId) : undefined;
+                    const storedEntry = runId ? stores.find(({ store }) => store.runId === runId) : undefined;
+                    const stored = storedEntry ? { store: storedEntry.store, loaded: await storedEntry.store.load() } : undefined;
+                    if ((action === "approve" || action === "reject") && runId && rest.length) {
+                        const accepted = await answerCheckpoint(runId, rest.join(" "), action === "approve", true);
+                        ctx.ui.notify(accepted ? `${action === "approve" ? "Approved" : "Rejected"} checkpoint ${rest.join(" ")}.` : "Checkpoint is not awaiting a response.", accepted ? "info" : "warning");
+                        return keepContext ? "dashboard" : "done";
+                    }
+                    if (action === "delete" && stored) {
+                        if (!["completed", "failed", "stopped"].includes(stored.loaded.run.state)) {
+                            ctx.ui.notify("Stop the workflow before deleting it.", "warning");
+                            return keepContext ? "dashboard" : "done";
+                        }
+                        if (!await ctx.ui.confirm("Delete workflow?", `Delete ${stored.loaded.run.workflowName} (${stored.store.runId}) and all owned artifacts? This cannot be undone.`))
+                            return keepContext ? "dashboard" : "done";
+                        await stored.store.delete(true);
+                        runs.delete(stored.store.runId);
+                        ctx.ui.notify(`Deleted workflow ${stored.store.runId}.`, "info");
+                        return keepContext ? "picker" : "done";
+                    }
+                    if (action === "pause" && run) {
+                        await run.lifecycle.pause();
+                        ctx.ui.notify(`Paused workflow ${run.store.runId}.`, "info");
+                        return keepContext ? "dashboard" : "done";
+                    }
+                    if (action === "resume" && run) {
+                        if (run.lifecycle.state === "interrupted")
+                            await coldResumeRun(run, ctx.hasUI, ctx.ui, projectTrusted(ctx));
+                        else
+                            await run.lifecycle.resume();
+                        ctx.ui.notify(`Resumed workflow ${run.store.runId}.`, "info");
+                        return keepContext ? "dashboard" : "done";
+                    }
+                    if (action === "stop" && run) {
+                        const workflowName = stored?.loaded.run.workflowName ?? run.metadata.name;
+                        if (keepContext && !await ctx.ui.confirm("Stop workflow?", `Stop workflow ${workflowName} (${run.store.runId})? This cannot be undone.`))
+                            return "dashboard";
+                        if (keepContext)
+                            status(`Stopping workflow ${workflowName}...`);
+                        await run.lifecycle.terminal("stopped");
+                        run.abortController.abort();
+                        run.execution?.cancel();
+                        await scheduler.cancelRun(run.store.runId);
+                        await scheduler.flush();
+                        if (keepContext)
+                            status(`Workflow ${run.store.runId} stopped.`);
+                        ctx.ui.notify(`Stopped workflow ${run.store.runId}.`, "info");
+                        return keepContext ? "dashboard" : "done";
+                    }
+                    if (keepContext && action && runId) {
+                        ctx.ui.notify(`Cannot ${action} workflow ${runId}: the run is no longer available.`, "warning");
+                        return "dashboard";
+                    }
+                    ctx.ui.notify(usage, "warning");
+                    return "done";
+                }
+                catch (error) {
+                    if (!keepContext)
+                        throw error;
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (action === "stop")
+                        status(`Could not stop workflow ${runId ?? ""}: ${message}`);
+                    ctx.ui.notify(`Cannot ${action ?? "workflow action"}${runId ? ` for ${runId}` : ""}: ${message}`, "warning");
+                    return "dashboard";
+                }
+            };
+            if (!command) {
+                for (;;) {
+                    if (!stores.length) {
+                        ctx.ui.notify("No workflow runs in this session.", "info");
+                        return;
+                    }
+                    if (!ctx.hasUI) {
+                        const details = await Promise.all(stores.map(async ({ store, loaded }) => formatNavigatorRun(loaded, await store.awaitingCheckpoints(), await store.worktrees())));
+                        ctx.ui.notify(details.join("\n\n"), "info");
+                        return;
+                    }
+                    const sorted = navigatorAttentionSort(stores);
+                    const labels = navigatorRunLabels(sorted);
+                    const terminalStates = new Set(["completed", "failed", "stopped"]);
+                    const hasCompleted = sorted.some(({ loaded: { run } }) => run.state === "completed");
+                    const pickerOptions = [...labels, ...(hasCompleted ? ["Delete all completed"] : []), "Close"];
+                    const runChoice = await ctx.ui.select("Workflows\n", pickerOptions);
+                    if (!runChoice || runChoice === "Close")
+                        return;
+                    if (runChoice === "Delete all completed") {
+                        if (!await ctx.ui.confirm("Delete completed runs?", "Delete all completed workflow runs and their artifacts? This cannot be undone."))
+                            continue;
+                        for (const entry of sorted) {
+                            if (entry.loaded.run.state === "completed") {
+                                await entry.store.delete(true);
+                                runs.delete(entry.store.runId);
+                            }
+                        }
+                        ctx.ui.notify("Deleted all completed workflow runs.", "info");
+                        stores = await loadStores();
+                        continue;
+                    }
+                    const runIndex = labels.indexOf(runChoice);
+                    if (runIndex < 0)
+                        return;
+                    const selected = sorted[runIndex];
+                    if (!selected)
+                        return;
+                    const { store } = selected;
+                    const copyArtifact = async (value, artifact) => {
+                        try {
+                            await clipboard(value);
+                            ctx.ui.notify(`Copied ${artifact}.`, "info");
+                        }
+                        catch (error) {
+                            ctx.ui.notify(`Failed to copy ${artifact}: ${error instanceof Error ? error.message : String(error)}`, "error");
+                        }
+                    };
+                    const loadDashboard = async () => {
+                        const loaded = await store.load();
+                        const checkpoints = await store.awaitingCheckpoints();
+                        const worktrees = await store.worktrees();
+                        const actions = new Map();
+                        const copies = new Map();
+                        const reviews = new Map();
+                        const add = (label, value) => { actions.set(label, `${value} ${store.runId}`); };
+                        const addCopy = (label, value, artifact) => { actions.set(label, "copy"); copies.set(label, { value, artifact }); };
+                        if (loaded.run.state === "running")
+                            add("Pause", "pause");
+                        if (["paused", "interrupted"].includes(loaded.run.state))
+                            add("Resume", "resume");
+                        if (!terminalStates.has(loaded.run.state))
+                            add("Stop", "stop");
+                        for (const cp of checkpoints) {
+                            if (ctx.mode === "tui") {
+                                const label = `Review ${cp.name}`;
+                                actions.set(label, "review");
+                                reviews.set(label, cp);
+                            }
+                            else {
+                                actions.set(`Approve ${cp.name}`, `approve ${store.runId} ${cp.name}`);
+                                actions.set(`Reject ${cp.name}`, `reject ${store.runId} ${cp.name}`);
+                            }
+                        }
+                        if (ctx.mode !== "tui")
+                            actions.set("Refresh", "refresh");
+                        else
+                            actions.set("View script", "view-script");
+                        const transcripts = [...new Set([...loaded.run.agents.flatMap((agent) => (agent.attemptDetails ?? []).map((attempt) => attempt.sessionFile)), ...loaded.run.nativeSessions.map(({ sessionFile }) => sessionFile)])];
+                        if (ctx.mode === "tui" && transcripts.length)
+                            actions.set("View transcript", "view-transcript");
+                        if (transcripts.length)
+                            actions.set("Transcript paths", "transcripts");
+                        if (terminalStates.has(loaded.run.state))
+                            add("Delete", "delete");
+                        if (ctx.mode === "tui") {
+                            addCopy("Copy run path", store.directory, "run path");
+                            addCopy("Copy run ID", store.runId, "run ID");
+                            for (const worktree of worktrees) {
+                                addCopy(`Copy branch (${worktree.owner})`, worktree.branch, "branch");
+                                addCopy(`Copy worktree path (${worktree.owner})`, worktree.path, "worktree path");
+                            }
+                        }
+                        return { dashboard: formatNavigatorDashboard(loaded.run, checkpoints, worktrees), actions, copies, reviews, transcripts, script: loaded.snapshot.script };
+                    };
+                    for (;;) {
+                        let view = await loadDashboard();
+                        const actionChoice = ctx.mode === "tui"
+                            ? await ctx.ui.custom((tui, theme, keybindings, done) => {
+                                let options = [...view.actions.keys(), "Close"];
+                                let selectedIndex = 0;
+                                let dashboardOffset = 0;
+                                let refreshing = false;
+                                let disposed = false;
+                                let stopRequested = false;
+                                let stopStatus;
+                                const terminalRows = () => Math.max(1, (tui.terminal?.rows) ?? 24);
+                                const keyLabels = { up: "↑", down: "↓", pageUp: "pgup", pageDown: "pgdn", escape: "esc" };
+                                const keyLabel = (binding, fallback) => {
+                                    const getKeys = keybindings.getKeys;
+                                    const keys = getKeys?.call(keybindings, binding);
+                                    return keys?.length ? keys.map((key) => keyLabels[key] ?? key).join("/") : fallback;
+                                };
+                                const dashboardLayout = () => {
+                                    const rows = terminalRows();
+                                    const hintRows = rows >= 4 ? 1 : 0;
+                                    const separatorRows = rows >= 6 ? 1 : 0;
+                                    const available = Math.max(1, rows - hintRows - separatorRows);
+                                    const actionViewport = Math.min(options.length, Math.max(1, Math.floor(available / 2)));
+                                    return { rows, hintRows, separatorRows, actionViewport, dashboardViewport: available - actionViewport };
+                                };
+                                const updateDashboard = async (selectedOption) => {
+                                    const next = await loadDashboard();
+                                    if (disposed)
+                                        return;
+                                    view = next;
+                                    options = [...view.actions.keys(), "Close"];
+                                    selectedIndex = Math.max(0, options.indexOf(selectedOption ?? ""));
+                                    tui.requestRender();
+                                };
+                                const requestStop = () => {
+                                    if (stopRequested)
+                                        return;
+                                    stopRequested = true;
+                                    stopStatus = undefined;
+                                    setWorkflowStatus(undefined);
+                                    const selectedOption = options[selectedIndex];
+                                    void runAction(`stop ${store.runId}`, true, (status) => {
+                                        stopStatus = status;
+                                        setWorkflowStatus(status);
+                                        if (!disposed)
+                                            tui.requestRender();
+                                    }).then(() => updateDashboard(selectedOption)).catch((error) => {
+                                        if (disposed)
+                                            return;
+                                        stopStatus = `Could not stop workflow ${store.runId}: ${error instanceof Error ? error.message : String(error)}`;
+                                        tui.requestRender();
+                                    }).finally(() => {
+                                        stopRequested = false;
+                                        if (!disposed)
+                                            tui.requestRender();
+                                    });
+                                };
+                                const timer = setInterval(() => {
+                                    if (refreshing || stopRequested)
+                                        return;
+                                    refreshing = true;
+                                    const selectedOption = options[selectedIndex];
+                                    void updateDashboard(selectedOption).catch(() => undefined).finally(() => { refreshing = false; });
+                                }, 1000);
+                                timer.unref();
+                                return {
+                                    render(width) {
+                                        const dashboard = stopStatus ? `${view.dashboard}\n\n${stopStatus}` : view.dashboard;
+                                        const dashboardLines = truncateToVisualLines(theme.fg("accent", dashboard), Number.MAX_SAFE_INTEGER, width, 1).visualLines;
+                                        const actionLines = options.map((option, index) => truncateToVisualLines(`${index === selectedIndex ? "→ " : "  "}${option}`, Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "");
+                                        const layout = dashboardLayout();
+                                        const hint = truncateToVisualLines(theme.fg("dim", `${keyLabel("tui.select.up", "↑")}/${keyLabel("tui.select.down", "↓")} navigate${dashboardLines.length > layout.dashboardViewport ? ` · ${keyLabel("tui.select.pageUp", "pgup")}/${keyLabel("tui.select.pageDown", "pgdn")} scroll` : ""} · ${keyLabel("tui.select.confirm", "enter")} select · ${keyLabel("tui.select.cancel", "esc")} close · auto-refresh 1s`), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                                        const compact = [...dashboardLines, "", ...actionLines, "", hint];
+                                        if (compact.length <= layout.rows) {
+                                            dashboardOffset = 0;
+                                            return compact;
+                                        }
+                                        const maxOffset = Math.max(0, dashboardLines.length - layout.dashboardViewport);
+                                        dashboardOffset = Math.max(0, Math.min(maxOffset, dashboardOffset));
+                                        const actionStart = Math.min(Math.max(0, selectedIndex - layout.actionViewport + 1), Math.max(0, options.length - layout.actionViewport));
+                                        return [
+                                            ...dashboardLines.slice(dashboardOffset, dashboardOffset + layout.dashboardViewport),
+                                            ...(layout.separatorRows && layout.dashboardViewport ? [""] : []),
+                                            ...actionLines.slice(actionStart, actionStart + layout.actionViewport),
+                                            ...(layout.hintRows ? [hint] : []),
+                                        ];
+                                    },
+                                    invalidate() { },
+                                    handleInput(data) {
+                                        if (stopRequested)
+                                            return;
+                                        if (keybindings.matches(data, "tui.select.up"))
+                                            selectedIndex = (selectedIndex + options.length - 1) % options.length;
+                                        else if (keybindings.matches(data, "tui.select.down"))
+                                            selectedIndex = (selectedIndex + 1) % options.length;
+                                        else if (keybindings.matches(data, "tui.select.pageUp")) {
+                                            dashboardOffset = Math.max(0, dashboardOffset - Math.max(1, dashboardLayout().dashboardViewport));
+                                        }
+                                        else if (keybindings.matches(data, "tui.select.pageDown")) {
+                                            dashboardOffset += Math.max(1, dashboardLayout().dashboardViewport);
+                                        }
+                                        else if (keybindings.matches(data, "tui.select.confirm")) {
+                                            if (options[selectedIndex] === "Stop")
+                                                requestStop();
+                                            else
+                                                done(options[selectedIndex]);
+                                        }
+                                        else if (keybindings.matches(data, "tui.select.cancel"))
+                                            done(undefined);
+                                        tui.requestRender();
+                                    },
+                                    dispose() { disposed = true; clearInterval(timer); setWorkflowStatus(undefined); },
+                                };
+                            }, { overlay: true })
+                            : await ctx.ui.select(view.dashboard, [...view.actions.keys(), "Close"]);
+                        if (!actionChoice || actionChoice === "Close")
+                            return;
+                        if (actionChoice === "Refresh")
+                            continue;
+                        if (actionChoice === "View script") {
+                            await ctx.ui.custom((tui, theme, keybindings, done) => {
+                                const highlighted = highlightCode(view.script, "javascript");
+                                let offset = 0;
+                                let renderedLines = [];
+                                const viewport = () => Math.max(1, ((tui.terminal?.rows) ?? 24) - 3);
+                                const move = (delta) => {
+                                    const maxOffset = Math.max(0, renderedLines.length - viewport());
+                                    offset = Math.max(0, Math.min(maxOffset, offset + delta));
+                                };
+                                return {
+                                    render(width) {
+                                        renderedLines = highlighted.flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, width, 0).visualLines : [""]);
+                                        const maxOffset = Math.max(0, renderedLines.length - viewport());
+                                        offset = Math.min(offset, maxOffset);
+                                        return [
+                                            theme.fg("accent", "Workflow script"),
+                                            ...renderedLines.slice(offset, offset + viewport()),
+                                            "",
+                                            theme.fg("dim", "↑↓/pgup/pgdn scroll · esc close"),
+                                        ];
+                                    },
+                                    invalidate() { },
+                                    handleInput(data) {
+                                        if (keybindings.matches(data, "tui.select.up"))
+                                            move(-1);
+                                        else if (keybindings.matches(data, "tui.select.down"))
+                                            move(1);
+                                        else if (keybindings.matches(data, "tui.select.pageUp"))
+                                            move(-viewport());
+                                        else if (keybindings.matches(data, "tui.select.pageDown"))
+                                            move(viewport());
+                                        else if (keybindings.matches(data, "tui.select.cancel"))
+                                            done(undefined);
+                                        tui.requestRender();
+                                    },
+                                };
+                            });
+                            continue;
+                        }
+                        if (actionChoice === "View transcript") {
+                            const transcript = await ctx.ui.select("Native Pi transcripts", [...view.transcripts, "Back"]);
+                            if (transcript && transcript !== "Back") {
+                                try {
+                                    const entries = SessionManager.open(transcript).buildContextEntries();
+                                    await ctx.ui.custom((tui, theme, keybindings, done) => {
+                                        let offset;
+                                        let renderedLines = [];
+                                        const terminalRows = () => Math.max(1, (tui.terminal?.rows) ?? 24);
+                                        const viewport = () => Math.max(1, terminalRows() - 3);
+                                        const move = (delta) => {
+                                            const maxOffset = Math.max(0, renderedLines.length - viewport());
+                                            offset = Math.max(0, Math.min(maxOffset, (offset ?? maxOffset) + delta));
+                                        };
+                                        return {
+                                            render(width) {
+                                                renderedLines = transcriptLines(entries).flatMap((line) => line ? truncateToVisualLines(line, Number.MAX_SAFE_INTEGER, width, 0).visualLines : [""]);
+                                                const maxOffset = Math.max(0, renderedLines.length - viewport());
+                                                offset = Math.min(offset ?? maxOffset, maxOffset);
+                                                return [
+                                                    theme.fg("accent", "Native Pi transcript"),
+                                                    ...renderedLines.slice(offset, offset + viewport()),
+                                                    "",
+                                                    theme.fg("dim", "↑↓/pgup/pgdn scroll · Home/End jump · esc close"),
+                                                ];
+                                            },
+                                            invalidate() { },
+                                            handleInput(data) {
+                                                if (keybindings.matches(data, "tui.select.up"))
+                                                    move(-1);
+                                                else if (keybindings.matches(data, "tui.select.down"))
+                                                    move(1);
+                                                else if (keybindings.matches(data, "tui.select.pageUp"))
+                                                    move(-viewport());
+                                                else if (keybindings.matches(data, "tui.select.pageDown"))
+                                                    move(viewport());
+                                                else if (keybindings.matches(data, "tui.editor.cursorLineStart"))
+                                                    offset = 0;
+                                                else if (keybindings.matches(data, "tui.editor.cursorLineEnd"))
+                                                    offset = Math.max(0, renderedLines.length - viewport());
+                                                else if (keybindings.matches(data, "tui.select.cancel"))
+                                                    done(undefined);
+                                                tui.requestRender();
+                                            },
+                                        };
+                                    }, { overlay: true });
+                                }
+                                catch (error) {
+                                    ctx.ui.notify(`Cannot open transcript ${transcript}: ${error instanceof Error ? error.message : String(error)}`, "warning");
+                                }
+                            }
+                            continue;
+                        }
+                        if (actionChoice === "Transcript paths") {
+                            const transcript = await ctx.ui.select("Native Pi transcript paths", [...view.transcripts, "Back"]);
+                            if (transcript && transcript !== "Back") {
+                                if (ctx.mode === "tui")
+                                    await copyArtifact(transcript, "transcript path");
+                                else
+                                    ctx.ui.notify(transcript, "info");
+                            }
+                            continue;
+                        }
+                        const copy = view.copies.get(actionChoice);
+                        if (copy) {
+                            await copyArtifact(copy.value, copy.artifact);
+                            continue;
+                        }
+                        if (actionChoice.startsWith("Review ")) {
+                            const checkpoint = view.reviews.get(actionChoice);
+                            if (!checkpoint)
+                                continue;
+                            const decision = await ctx.ui.custom((tui, theme, keybindings, done) => {
+                                const options = ["Approve", "Reject", "Cancel"];
+                                let selectedIndex = 0;
+                                let offset = 0;
+                                let renderedLines = [];
+                                const layout = () => {
+                                    const rows = Math.max(1, ((tui.terminal?.rows) ?? 24));
+                                    const compactControls = rows < 4;
+                                    const titleRows = rows >= 5 ? 1 : 0;
+                                    const hintRows = rows >= 8 ? 1 : 0;
+                                    const separatorRows = rows >= 8 ? 2 : 0;
+                                    const controlRows = compactControls ? 1 : options.length;
+                                    const contentViewport = Math.max(0, rows - titleRows - hintRows - separatorRows - controlRows);
+                                    return { rows, compactControls, titleRows, hintRows, separatorRows, contentViewport };
+                                };
+                                const move = (delta) => {
+                                    const maxOffset = Math.max(0, renderedLines.length - layout().contentViewport);
+                                    offset = Math.max(0, Math.min(maxOffset, offset + delta));
+                                };
+                                return {
+                                    render(width) {
+                                        renderedLines = truncateToVisualLines(formatCheckpointReview(checkpoint), Number.MAX_SAFE_INTEGER, width, 0).visualLines;
+                                        const currentLayout = layout();
+                                        const maxOffset = Math.max(0, renderedLines.length - currentLayout.contentViewport);
+                                        offset = Math.min(offset, maxOffset);
+                                        const hint = truncateToVisualLines(theme.fg("dim", "↑↓/pgup/pgdn scroll · enter select · esc cancel"), Number.MAX_SAFE_INTEGER, width, 1).visualLines[0] ?? "";
+                                        const controls = currentLayout.compactControls
+                                            ? [options.map((option, index) => `${index === selectedIndex ? "[" : " "}${option}${index === selectedIndex ? "]" : " "}`).join(" ")]
+                                            : options.map((option, index) => `${index === selectedIndex ? "→ " : "  "}${option}`);
+                                        return [
+                                            ...(currentLayout.titleRows ? [theme.fg("accent", "Checkpoint review")] : []),
+                                            ...renderedLines.slice(offset, offset + currentLayout.contentViewport),
+                                            ...(currentLayout.separatorRows ? [""] : []),
+                                            ...controls,
+                                            ...(currentLayout.separatorRows ? [""] : []),
+                                            ...(currentLayout.hintRows ? [hint] : []),
+                                        ];
+                                    },
+                                    invalidate() { },
+                                    handleInput(data) {
+                                        if (keybindings.matches(data, "tui.select.up"))
+                                            selectedIndex = (selectedIndex + options.length - 1) % options.length;
+                                        else if (keybindings.matches(data, "tui.select.down"))
+                                            selectedIndex = (selectedIndex + 1) % options.length;
+                                        else if (keybindings.matches(data, "tui.select.pageUp"))
+                                            move(-layout().contentViewport);
+                                        else if (keybindings.matches(data, "tui.select.pageDown"))
+                                            move(layout().contentViewport);
+                                        else if (keybindings.matches(data, "tui.select.confirm"))
+                                            done(options[selectedIndex] === "Cancel" ? undefined : options[selectedIndex]);
+                                        else if (keybindings.matches(data, "tui.select.cancel"))
+                                            done(undefined);
+                                        tui.requestRender();
+                                    },
+                                };
+                            });
+                            if (decision) {
+                                const accepted = await answerCheckpoint(store.runId, checkpoint.name, decision === "Approve", true);
+                                if (!accepted)
+                                    ctx.ui.notify("Checkpoint is not awaiting a response.", "warning");
+                            }
+                            continue;
+                        }
+                        const actionCommand = view.actions.get(actionChoice);
+                        if (!actionCommand) {
+                            ctx.ui.notify(`Cannot select workflow action: ${actionChoice}`, "warning");
+                            continue;
+                        }
+                        const outcome = await runAction(actionCommand, true);
+                        if (outcome === "picker") {
+                            stores = await loadStores();
+                            break;
+                        }
+                    }
+                }
+            }
+            await runAction(command, false);
+        },
+    });
+    pi.on("session_shutdown", async () => {
+        try {
+            await Promise.all([...runs.entries()].map(async ([runId, run]) => {
+                if (["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
+                    await run.completion?.catch(() => undefined);
+                    return;
+                }
+                if (!["completed", "failed", "stopped"].includes(run.lifecycle.state)) {
+                    try {
+                        await run.lifecycle.terminal("interrupted");
+                    }
+                    catch (error) {
+                        if (!["completed", "failed", "stopped"].includes(run.lifecycle.state))
+                            throw error;
+                    }
+                    run.abortController.abort();
+                    run.execution?.cancel();
+                    await scheduler.cancelRun(runId);
+                }
+                await run.completion?.catch(() => undefined);
+            }));
+            await scheduler.flush();
+        }
+        finally {
+            await releaseSessionLease();
+            resetWorkflowRegistry();
+        }
+    });
+}
+function displayAgentName(label, role, model) {
+    return label ?? role ?? model.model;
+}
+function modelSpec(value, fallback) {
+    try {
+        const parsed = parseModelReference(value);
+        return { ...parsed, ...(parsed.thinking || !fallback.thinking ? {} : { thinking: fallback.thinking }) };
+    }
+    catch {
+        return fallback;
+    }
+}
+export { acquireSessionLease, projectStorageKey, RunStore, runsDirectory, SessionLease, structuralPath } from "./persistence.js";
+export { FairAgentScheduler, WorkflowAgentExecutor } from "./agent-execution.js";
+export { doctor, doctorExitCode, formatDoctorReport } from "./doctor.js";