pi-extensible-workflows 3.1.0 → 3.3.0

package/dist/src/cli.js

@@ -8,7 +8,8 @@ import { ProjectTrustStore, SessionManager, SettingsManager, createAgentSessionF
 import { Value } from "typebox/value";
 import { doctor, doctorExitCode, formatDoctorReport } from "./doctor.js";
 import { doctorCleanup, doctorCleanupExitCode, formatDoctorCleanupReport } from "./doctor-cleanup.js";
-import workflowExtension, { formatWorkflowProgress, truncateWorkflowProgress, workflowCatalog, workflowSettingsPath } from "./index.js";
+import workflowExtension, { formatWorkflowProgress, loadAgentDefinitions, registeredWorkflowFunctions, truncateWorkflowProgress, workflowCatalog, workflowSettingsPath } from "./index.js";
+import { portableEngineVersion, portablePiVersion, writePortableWorkflowBundle } from "./bundles.js";
 import { runSessionInspector, transcriptFileLines } from "./session-inspector.js";
 function object(value) { return typeof value === "object" && value !== null && !Array.isArray(value); }
 function has(value, key) { return Object.prototype.hasOwnProperty.call(value, key); }
@@ -193,7 +194,30 @@ function launcherHelpLines() {
     ];
 }
 function workflowUsage() { return [`Usage: pi-extensible-workflows run <workflow-name> [workflow arguments] | export <workflow-name> [--name <command>] [--output <path>] [--force]`, "", "Launcher options:", ...launcherHelpLines()].join("\n") + "\n"; }
-function exportUsage() { return [`Usage: pi-extensible-workflows export <workflow-name> [--name <command>] [--output <path>] [--force]`, "", "Launcher options:", ...launcherHelpLines()].join("\n") + "\n"; }
+function exportUsage() { return [`Usage: pi-extensible-workflows export <workflow-name> [--name <command>] [--output <path>] [--force] [--bundle]`, "", "Launcher options:", ...launcherHelpLines()].join("\n") + "\n"; }
+function bundleUsage() { return [`Usage: pi-extensible-workflows bundle <workflow-name> [--name <command>] [--output <directory>] [--force]`, "", "The bundle contains a launcher, manifest, workflow payload, and external-runtime setup instructions.", "Repeat --role, --alias, --tool, --command, or --environment to declare recipient requirements.", "Use --extension, --skill, --resource, and --dependency to copy selected payload resources."].join("\n") + "\n"; }
+function parseInspectArgs(rawArgs) {
+    let sessionId;
+    let mode = "tui";
+    let failedOnly = false;
+    for (const arg of rawArgs) {
+        if (arg === "--json" || arg === "--summary") {
+            const next = arg === "--json" ? "json" : "summary";
+            if (mode !== "tui" && mode !== next)
+                throw new Error("inspect accepts only one output mode");
+            mode = next;
+        }
+        else if (arg === "--failed")
+            failedOnly = true;
+        else if (arg.startsWith("--"))
+            throw new Error(`Unknown inspect option: ${arg}`);
+        else if (sessionId !== undefined)
+            throw new Error(`Unexpected argument: ${arg}`);
+        else
+            sessionId = arg;
+    }
+    return { ...(sessionId ? { sessionId } : {}), mode: failedOnly && mode === "tui" ? "summary" : mode, failedOnly };
+}
 export function parseDoctorCleanupArgs(rawArgs) {
     let olderThanDays = 90;
     let yes = false;
@@ -286,7 +310,7 @@ async function createWorkflowRuntime(options, shutdownHandlers = []) {
         cwd,
         agentDir,
         settingsManager,
-        resourceLoaderOptions: {},
+        resourceLoaderOptions: { ...(options.skillPaths?.length ? { additionalSkillPaths: [...options.skillPaths] } : {}) },
         resourceLoaderReloadOptions: { resolveProjectTrust },
     });
     const extensions = services.resourceLoader.getExtensions();
@@ -303,7 +327,7 @@ async function createWorkflowRuntime(options, shutdownHandlers = []) {
         sendMessage() { },
         events: { emit() { } },
     };
-    workflowExtension(headlessPi, homedir(), undefined, undefined, agentDir);
+    workflowExtension(headlessPi, homedir(), undefined, undefined, agentDir, options.skillPaths);
     const workflowTool = tools.find((tool) => object(tool) && tool.name === "workflow");
     if (!workflowTool)
         throw new Error("The workflow runtime could not be initialized");
@@ -356,28 +380,33 @@ function terminalProgressStyles(enabled) {
 }
 class CliProgress {
     stderr;
+    onRunId;
     #lastStable = "";
     #lines = 0;
     #frame = 0;
     #run;
+    #runId;
     #timer;
     #interactive;
     #styles;
-    constructor(stderr, tty) {
+    constructor(stderr, tty, onRunId) {
         this.stderr = stderr;
+        this.onRunId = onRunId;
         this.#interactive = tty && process.env.NO_COLOR === undefined && process.env.TERM !== "dumb";
         this.#styles = terminalProgressStyles(this.#interactive);
     }
     update(run) {
-        const stable = formatWorkflowProgress(run, "◇", this.#styles);
+        if (this.#runId !== run.id) {
+            this.#runId = run.id;
+            this.onRunId(run.id);
+        }
+        this.#run = run;
         if (!this.#interactive) {
-            if (stable !== this.#lastStable) {
-                this.#lastStable = stable;
-                this.stderr(`${stable}\n`);
-            }
+            this.#timer ??= setInterval(() => { this.render(); }, 1000);
+            this.#timer.unref();
+            this.render();
             return;
         }
-        this.#run = run;
         this.#timer ??= setInterval(() => { this.render(); }, 80);
         this.#timer.unref();
         this.render();
@@ -385,6 +414,14 @@ class CliProgress {
     render() {
         if (!this.#run)
             return;
+        if (!this.#interactive) {
+            const stable = formatWorkflowProgress(this.#run, "◇", this.#styles);
+            if (stable !== this.#lastStable) {
+                this.#lastStable = stable;
+                this.stderr(`${stable}\n`);
+            }
+            return;
+        }
         const spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"][this.#frame++ % 10] ?? "◇";
         const width = process.stderr.columns || 80;
         const text = truncateWorkflowProgress(formatWorkflowProgress(this.#run, spinner, this.#styles), width).join("\n");
@@ -406,18 +443,24 @@ class CliProgress {
 async function invokeWorkflow(fn, args, runtime, options, context) {
     if (!Value.Check(fn.input, args))
         throw new Error(`Invalid input for ${fn.name}`);
-    const progress = new CliProgress(options.stderr, options.isTTY ?? process.stderr.isTTY);
+    let announcedRunId;
+    const announceRunId = (runId) => { if (announcedRunId === runId)
+        return; announcedRunId = runId; options.stderr(`Run ID: ${runId}\n`); };
+    const progress = new CliProgress(options.stderr, options.isTTY ?? process.stderr.isTTY, announceRunId);
     try {
         const result = await runtime.workflowTool.execute(randomUUID(), { workflow: fn.name, args, foreground: true }, options.signal, (update) => { if (object(update) && object(update.details) && object(update.details.run))
             progress.update(update.details.run); }, context);
         const details = object(result.details) ? result.details : {};
+        const runId = typeof details.runId === "string" ? details.runId : undefined;
+        if (runId)
+            announceRunId(runId);
         if (has(details, "value"))
-            return details.value;
+            return { value: details.value, ...(runId ? { runId } : {}) };
         const first = result.content[0];
         if (!first || first.type !== "text")
             throw new Error("Workflow returned no result");
         try {
-            return parseJsonInput(first.text);
+            return { value: parseJsonInput(first.text), ...(runId ? { runId } : {}) };
         }
         catch {
             throw new Error("Workflow returned invalid JSON");
@@ -471,14 +514,16 @@ async function runWorkflowCli(rawArgs, options) {
             return 0;
         }
         const input = parseWorkflowCliArgs(fn.input, args.slice(1));
-        const value = await invokeWorkflow(fn, input, runtime, options, context);
-        options.write(`${JSON.stringify(value)}\n`);
+        const result = await invokeWorkflow(fn, input, runtime, options, context);
+        options.write(`${JSON.stringify(result.value)}\n`);
         return 0;
     });
 }
 async function exportWorkflowCli(rawArgs, options) {
     const parsed = stripTrustOptions(rawArgs);
     const args = parsed.args;
+    if (args.includes("--bundle"))
+        return bundleWorkflowCli(args.filter((arg) => arg !== "--bundle"), options);
     if (!args.length || args[0] === "--help" || args[0] === "-h") {
         options.write(exportUsage());
         return args.length ? 0 : 1;
@@ -534,6 +579,80 @@ async function exportWorkflowCli(rawArgs, options) {
         return 0;
     });
 }
+async function bundleWorkflowCli(rawArgs, options) {
+    const parsed = stripTrustOptions(rawArgs);
+    const args = parsed.args;
+    if (!args.length || args[0] === "--help" || args[0] === "-h") {
+        options.write(bundleUsage());
+        return args.length ? 0 : 1;
+    }
+    const workflowName = args[0];
+    return withWorkflowRuntime({ ...options, ...(parsed.trustOverride !== undefined ? { trustOverride: parsed.trustOverride } : {}) }, async (runtime) => {
+        let name;
+        let output;
+        let force = false;
+        const requirements = { roles: [], aliases: [], tools: [], commands: [], environment: [] };
+        const resources = { extensions: [], skills: [], static: [], dependencies: [] };
+        for (let index = 1; index < args.length; index += 1) {
+            const arg = args[index];
+            if (arg === "--force") {
+                force = true;
+                continue;
+            }
+            const equals = arg.indexOf("=");
+            const option = equals >= 0 ? arg.slice(0, equals) : arg;
+            const requirementOptions = { "--role": "roles", "--alias": "aliases", "--tool": "tools", "--command": "commands", "--environment": "environment" };
+            const resourceOptions = { "--extension": "extensions", "--skill": "skills", "--resource": "static", "--dependency": "dependencies" };
+            if (option === "--name" || option === "--output" || Object.prototype.hasOwnProperty.call(requirementOptions, option) || Object.prototype.hasOwnProperty.call(resourceOptions, option)) {
+                const value = equals >= 0 ? arg.slice(equals + 1) : args[++index];
+                if (!value)
+                    throw new Error(`Missing value for ${option}`);
+                if (option === "--name")
+                    name = value;
+                else if (option === "--output")
+                    output = value;
+                else if (Object.prototype.hasOwnProperty.call(requirementOptions, option))
+                    requirements[requirementOptions[option]].push(value);
+                else
+                    resources[resourceOptions[option]].push(value);
+                continue;
+            }
+            if (arg === "--help" || arg === "-h") {
+                options.write(bundleUsage());
+                return 0;
+            }
+            throw new Error(`Unknown option: ${arg}`);
+        }
+        const fn = runtime.catalog.functions.find((candidate) => candidate.name === workflowName);
+        if (!fn)
+            throw new Error(`Unknown workflow function: ${workflowName}`);
+        const registered = registeredWorkflowFunctions()[workflowName];
+        if (!registered)
+            throw new Error(`Workflow ${workflowName} is not exportable because its registered implementation is unavailable`);
+        const definitions = requirements.roles.length ? loadAgentDefinitions(options.cwd ?? process.cwd(), options.agentDir ?? getAgentDir(), runtime.services.settingsManager.isProjectTrusted()) : {};
+        const roles = Object.fromEntries(requirements.roles.map((role) => {
+            if (!role || role === "." || role === ".." || role.includes("/") || role.includes("\\"))
+                throw new Error(`Invalid role name for bundle: ${role}`);
+            const definition = definitions[role];
+            if (!definition)
+                throw new Error(`Unknown role for bundle: ${role}`);
+            return [role, definition];
+        }));
+        const command = commandName(name ?? kebabCase(workflowName));
+        if (!command)
+            throw new Error("Command name must be a non-empty name without path separators");
+        const destination = output ?? join(homedir(), ".local", "share", "pi-extensible-workflows", "bundles", command);
+        const aliasTargets = Object.fromEntries(requirements.aliases.flatMap((name) => {
+            const target = runtime.catalog.modelAliases?.[name];
+            return typeof target === "string" ? [[name, target]] : [];
+        }));
+        const selectedResources = Object.values(resources).some((entries) => entries.length) ? resources : undefined;
+        writePortableWorkflowBundle({ destination, command, workflow: fn, functionSource: registered.run.toString(), requirements, aliasTargets, roles, ...(selectedResources ? { resources: selectedResources } : {}), piVersion: portablePiVersion(), engineVersion: portableEngineVersion(), force });
+        options.write(`Bundled ${workflowName} at ${destination}\n`);
+        options.write(`Run ${join(destination, command)} setup before launching the workflow.\n`);
+        return 0;
+    });
+}
 export async function runCli(args, options = {}, write = (text) => { process.stdout.write(text); }) {
     const stderr = options.stderr ?? ((text) => { process.stderr.write(text); });
     if (args[0] === "doctor" && args.length === 1) {
@@ -558,9 +677,13 @@ export async function runCli(args, options = {}, write = (text) => { process.std
             return 1;
         }
     }
-    if (args[0] === "inspect" && args.length <= 2) {
+    if (args[0] === "inspect") {
         try {
-            await (options.inspect ?? runSessionInspector)(args[1]);
+            const parsed = parseInspectArgs(args.slice(1));
+            if (options.inspect)
+                await options.inspect(parsed.sessionId, parsed.mode, parsed.failedOnly);
+            else
+                await runSessionInspector(parsed.sessionId, parsed.mode, options.cwd ?? process.cwd(), undefined, write, parsed.failedOnly);
             return 0;
         }
         catch (error) {
@@ -581,9 +704,11 @@ export async function runCli(args, options = {}, write = (text) => { process.std
             return 1;
         }
     }
-    if (args[0] === "run" || args[0] === "export") {
+    if (args[0] === "bundle" || args[0] === "run" || args[0] === "export") {
         try {
-            const workflowOptions = { write, stderr, ...(options.cwd !== undefined ? { cwd: options.cwd } : {}), ...(options.agentDir !== undefined ? { agentDir: options.agentDir } : {}), ...(options.signal ? { signal: options.signal } : {}), ...(options.trustOverride !== undefined ? { trustOverride: options.trustOverride } : {}), ...(options.isTTY !== undefined ? { isTTY: options.isTTY } : {}) };
+            const workflowOptions = { write, stderr, ...(options.cwd !== undefined ? { cwd: options.cwd } : {}), ...(options.agentDir !== undefined ? { agentDir: options.agentDir } : {}), ...(options.signal ? { signal: options.signal } : {}), ...(options.trustOverride !== undefined ? { trustOverride: options.trustOverride } : {}), ...(options.isTTY !== undefined ? { isTTY: options.isTTY } : {}), ...(options.skillPaths?.length ? { skillPaths: [...options.skillPaths] } : {}) };
+            if (args[0] === "bundle")
+                return await bundleWorkflowCli(args.slice(1), workflowOptions);
             return args[0] === "run" ? await runWorkflowCli(args.slice(1), workflowOptions) : await exportWorkflowCli(args.slice(1), workflowOptions);
         }
         catch (error) {
@@ -591,7 +716,7 @@ export async function runCli(args, options = {}, write = (text) => { process.std
             return 1;
         }
     }
-    write("Usage: pi-extensible-workflows doctor | inspect [session-id] | transcript <session-file> | run <workflow-name> [workflow arguments] | export <workflow-name> [--name <command>] [--output <path>] [--force]\n");
+    write("Usage: pi-extensible-workflows doctor | inspect [session-id] [--json|--summary] [--failed] | transcript <session-file> | bundle <workflow-name> [--name <command>] [--output <path>] [--force] | run <workflow-name> [workflow arguments] | export <workflow-name> [--name <command>] [--output <path>] [--force] [--bundle]\n");
     return 1;
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {

package/dist/src/doctor-cleanup.js

@@ -10,7 +10,7 @@ import { acquireSessionLease, hasLiveSessionLease, projectSessionsDirectory, Run
 const TERMINAL_STATES = new Set(["completed", "failed", "stopped"]);
 const DAY_MS = 24 * 60 * 60 * 1000;
 const REQUIRED_RUN_FILES = ["workflow.js", "state.json", "snapshot.json", "journal.json", "ownership.json", "worktrees.json", "borrowed-worktrees.json", "system-prompts.json"];
-const OPTIONAL_RUN_FILES = new Set(["result.json"]);
+const OPTIONAL_RUN_FILES = new Set(["result.json", "summary.json"]);
 const RUN_DIRECTORIES = new Set(["worktrees"]);
 const RUN_FILES = new Set([...REQUIRED_RUN_FILES, ...OPTIONAL_RUN_FILES]);
 const AGENT_STATES = new Set(["queued", "running", "waiting_for_child", "paused", "retrying", "completed", "failed", "cancelled"]);
@@ -65,7 +65,8 @@ function validateScheduledOptions(value, label) { if (!object(value) || typeof v
 } }
 function validateAgent(value, label) { if (!object(value) || typeof value.id !== "string" || !value.id || typeof value.name !== "string" || !value.name || typeof value.path !== "string" || !value.path || typeof value.state !== "string" || !AGENT_STATES.has(value.state))
     throw new Error(`${label} is invalid`); optionalString(value.label, `${label}.label`); optionalString(value.parentId, `${label}.parentId`); if (value.structuralPath !== undefined)
-    stringList(value.structuralPath, `${label}.structuralPath`); optionalString(value.parentBreadcrumb, `${label}.parentBreadcrumb`); optionalString(value.worktreeOwner, `${label}.worktreeOwner`); optionalString(value.role, `${label}.role`); optionalString(value.requestedModel, `${label}.requestedModel`); model(value.model, `${label}.model`); stringList(value.tools, `${label}.tools`); nonNegativeInteger(value.attempts, `${label}.attempts`); if (value.attemptDetails !== undefined) {
+    stringList(value.structuralPath, `${label}.structuralPath`); optionalString(value.parentBreadcrumb, `${label}.parentBreadcrumb`); optionalString(value.worktreeOwner, `${label}.worktreeOwner`); optionalString(value.role, `${label}.role`); optionalString(value.requestedModel, `${label}.requestedModel`); model(value.model, `${label}.model`); stringList(value.tools, `${label}.tools`); nonNegativeInteger(value.attempts, `${label}.attempts`); if (value.lastEventAt !== undefined)
+    finiteNumber(value.lastEventAt, `${label}.lastEventAt`); if (value.attemptDetails !== undefined) {
     if (!Array.isArray(value.attemptDetails))
         throw new Error(`${label}.attemptDetails is invalid`);
     for (const [index, attempt] of value.attemptDetails.entries()) {
@@ -135,6 +136,7 @@ function validateRunRecord(run) {
         if (!object(session) || typeof session.sessionId !== "string" || !session.sessionId || typeof session.sessionFile !== "string" || !session.sessionFile)
             throw new Error(`nativeSessions[${String(index)}] is invalid`);
     optionalString(value.parentRunId, "Persisted parent run");
+    optionalString(value.failedAt, "Persisted failed path");
     if (value.retry !== undefined) {
         if (!object(value.retry) || typeof value.retry.sourceRunId !== "string" || !value.retry.sourceRunId || typeof value.retry.lineageRootRunId !== "string" || !value.retry.lineageRootRunId)
             throw new Error("Persisted retry provenance is invalid");

package/dist/src/eval-capture-extension.js

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { validateWorkflowLaunch, WorkflowError, WORKFLOW_TOOL_DESCRIPTION, WORKFLOW_TOOL_LABEL, WORKFLOW_TOOL_PARAMETERS, WORKFLOW_TOOL_PROMPT_SNIPPET } from "./index.js";
+import { validateWorkflowLaunch, WorkflowError, WORKFLOW_RETRY_PARAMETERS, WORKFLOW_TOOL_DESCRIPTION, WORKFLOW_TOOL_LABEL, WORKFLOW_TOOL_PARAMETERS, WORKFLOW_TOOL_PROMPT_SNIPPET } from "./index.js";
 export const CAPTURE_IDENTITY = "pi-extensible-workflows-eval-capture-v1";
 export const CAPTURE_ERROR_PREFIX = `${CAPTURE_IDENTITY}:`;
 export function resolveWorkflowSkillPath() {
@@ -45,4 +45,19 @@ export default function evalCaptureExtension(pi) {
             }
         },
     });
+    pi.registerTool({
+        name: "workflow_retry",
+        label: "Workflow Retry",
+        description: "Capture a recovery selection without executing it",
+        parameters: WORKFLOW_RETRY_PARAMETERS,
+        async execute(_id, params) {
+            if (!params.runId.trim())
+                throw new WorkflowError("RESUME_INCOMPATIBLE", `${CAPTURE_ERROR_PREFIX}RESUME_INCOMPATIBLE: workflow_retry requires an explicit run ID`);
+            const selection = { tool: "workflow_retry", arguments: { runId: params.runId } };
+            return {
+                content: [{ type: "text", text: JSON.stringify({ captured: true, ...selection }) }],
+                details: { captured: true, captureIdentity: CAPTURE_IDENTITY, realWorkflowAgentsLaunched: 0, selection },
+            };
+        },
+    });
 }

package/dist/src/execution.js

@@ -1,5 +1,5 @@
 import { fork, spawn } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
@@ -72,6 +72,7 @@ const named = (value, kind) => { if (typeof value !== "string" || !value.trim())
 const path = (...names) => names.map(encodeURIComponent).join("/");
 const inheritedAgentPath = new AsyncLocalStorage();
 const agentOccurrences = new Map();
+const agentInflight = new Set();
 const shellOccurrences = new Map();
 const worktreeOwners = new AsyncLocalStorage();
 const rejectAgent = () => { throw workError("INVALID_METADATA", "Workflow agent calls must use a direct agent(...) call; aliases and indirect calls are unsupported"); };
@@ -92,14 +93,22 @@ 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]);
+  if (agentInflight.has(occurrenceKey)) throw workError("INVALID_METADATA", "Concurrent agent calls from the same source call site are unsupported; use parallel(...) or pipeline(...)");
+  agentInflight.add(occurrenceKey);
   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);
+  let result;
+  try {
+    result = rpc("agent", [values[0], options, identity]).then(unwrap);
+  } catch (error) {
+    agentInflight.delete(occurrenceKey);
+    throw error;
+  }
+  void result.then(() => agentInflight.delete(occurrenceKey), () => agentInflight.delete(occurrenceKey));
   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"); } },
@@ -421,7 +430,7 @@ function workflowErrorFromWorker(error) {
 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 childDir = realpathSync(mkdtempSync(join(tmpdir(), "pi-wf-")));
     const childFile = join(childDir, "child.cjs");
     writeFileSync(childFile, childSource);
     const child = fork(childFile, [String(RPC_LIMIT_BYTES), config], {

package/dist/src/host.d.ts

@@ -34,8 +34,8 @@ export declare function formatWorkflowPreview(args: {
     description?: unknown;
 }): string;
 export declare const WORKFLOW_TOOL_LABEL = "Workflow";
-export declare const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow";
-export declare const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow that orchestrates subagents. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Runs in the background by default; completion arrives as a follow-up message. Foreground results include the completed run ID. Use workflow_retry with an explicit failed run ID to replay completed structural operations; parentRunId only reuses named worktrees.";
+export declare const WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline parallel-to-summary path by default";
+export declare const WORKFLOW_TOOL_PROMPT_SNIPPET = "Run a deterministic, resumable JavaScript workflow. Prefer a named inline script that fans out independent work with parallel(...), awaits the keyed results before interpolating them into one summarizing agent(...), and returns. Inline launches require an explicit non-empty name; registered function launches reject name and use workflow as the run name. Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. Use workflow_retry with an explicit failed run ID; parentRunId only reuses named worktrees. Runs are in the background by default; completion arrives as a follow-up message. Set foreground: true when the caller must wait for the final value. If a foreground call detaches before its result is accepted, its terminal success or failure is promoted to one follow-up message. Foreground results include the completed run ID. Recovery inherits the source launch mode; legacy snapshots without launchMode recover in the background. Set foreground: true or false on workflow_resume/workflow_retry to override it; foreground recovery waits for terminal value and run details, while background recovery returns immediately with a follow-up. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, foreground? }) replays a failed run into a child; workflow_resume({ runId, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
 export declare const WORKFLOW_TOOL_PARAMETERS: Type.TObject<{
     name: Type.TOptional<Type.TString>;
     description: Type.TOptional<Type.TString>;
@@ -49,6 +49,7 @@ export declare const WORKFLOW_TOOL_PARAMETERS: Type.TObject<{
 }>;
 export declare const WORKFLOW_RETRY_PARAMETERS: Type.TObject<{
     runId: Type.TString;
+    foreground: Type.TOptional<Type.TBoolean>;
 }>;
 export type WorkflowPhaseState = "not started" | "running" | "completed" | "failed" | "cancelled" | "interrupted" | "budget_exhausted";
 export interface WorkflowPhaseAgentCounts {
@@ -64,7 +65,6 @@ export interface WorkflowPhaseView {
     name: string;
     occurrence: number;
     state: WorkflowPhaseState;
-    status: WorkflowPhaseState;
     observed: boolean;
     afterAgent?: number;
     agents: readonly AgentRecord[];
@@ -83,19 +83,62 @@ export declare function buildWorkflowPhaseModel(run: Pick<PersistedRun, "state"
 export interface WorkflowPhaseSelection {
     phaseId?: string | undefined;
     agentId?: string | undefined;
+    nodeId?: string | undefined;
+    expandedNodeIds?: readonly string[] | undefined;
+    treeOnly?: boolean | undefined;
+    detailsOnly?: boolean | undefined;
+    actions?: {
+        title: string;
+        options: readonly string[];
+        index: number;
+    } | undefined;
+}
+export type WorkflowPhaseTreeNodeKind = "phase" | "operation" | "agent";
+export interface WorkflowPhaseTreeNode {
+    id: string;
+    kind: WorkflowPhaseTreeNodeKind;
+    label: string;
+    depth: number;
+    phaseId: string;
+    operationPath: readonly string[];
+    parentId?: string;
+    children: readonly string[];
+    state: WorkflowPhaseState | AgentRecord["state"];
+    agentId?: string;
+    agent?: AgentRecord;
+    phase?: WorkflowPhaseView;
+}
+export interface WorkflowPhaseTree {
+    roots: readonly string[];
+    nodes: readonly WorkflowPhaseTreeNode[];
+    byId: ReadonlyMap<string, WorkflowPhaseTreeNode>;
+}
+export interface WorkflowPhaseTreeSelection {
+    nodeId?: string | undefined;
 }
+export type WorkflowPhaseTreeDirection = "up" | "down" | "left" | "right";
+export declare function buildWorkflowPhaseTree(model: WorkflowPhaseModel): WorkflowPhaseTree;
+export declare function workflowPhaseTreeVisibleNodes(tree: WorkflowPhaseTree, expanded?: ReadonlySet<string>): readonly WorkflowPhaseTreeNode[];
+export declare function workflowPhaseTreeInitialExpanded(tree: WorkflowPhaseTree): ReadonlySet<string>;
+export declare function preserveWorkflowPhaseTreeSelection(tree: WorkflowPhaseTree, selection: WorkflowPhaseTreeSelection): WorkflowPhaseTreeSelection;
+export declare function navigateWorkflowPhaseTree(tree: WorkflowPhaseTree, selectedNodeId: string | undefined, expandedNodeIds: ReadonlySet<string>, direction: WorkflowPhaseTreeDirection): {
+    nodeId?: string;
+    expandedNodeIds: ReadonlySet<string>;
+};
 export declare function preserveWorkflowPhaseSelection(model: WorkflowPhaseModel, selection: WorkflowPhaseSelection): WorkflowPhaseSelection;
-export declare function formatWorkflowProgress(run: PersistedRun, spinner?: string, styles?: WorkflowProgressStyles): string;
+export declare function formatWorkflowProgress(run: PersistedRun, spinner?: string, styles?: WorkflowProgressStyles, now?: number): string;
 export declare function truncateWorkflowProgress(text: string, width: number): string[];
 export declare function formatBudgetStatus(run: Pick<PersistedRun, "budget" | "budgetVersion" | "usage" | "budgetEvents">): string[];
 export declare function agentBreadcrumbParts(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath?: boolean): string[];
 export declare function agentBreadcrumb(agent: AgentRecord, byId: Map<string, AgentRecord>, includeStructuralPath?: boolean): string;
-export declare function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[]): string;
+export declare function formatStalledDuration(durationMs: number): string;
+export declare function formatNavigatorDashboard(run: PersistedRun, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now?: number): string;
 export declare function formatNavigatorRun(loaded: {
     run: PersistedRun;
     snapshot: Readonly<LaunchSnapshot>;
-}, checkpoints: readonly AwaitingCheckpoint[], _worktrees: readonly WorktreeReference[]): string;
-export declare function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection?: WorkflowPhaseSelection, styles?: WorkflowProgressStyles): string[];
+}, checkpoints: readonly AwaitingCheckpoint[], worktrees: readonly WorktreeReference[], now?: number): string;
+export declare function formatWorkflowPhaseDashboard(run: PersistedRun, snapshot: Readonly<LaunchSnapshot>, width: number, selection?: WorkflowPhaseSelection, styles?: WorkflowProgressStyles, now?: number): string[];
 export declare function formatWorkflowFailureDiagnostics(diagnostic: WorkflowFailureDiagnostics): string;
-export default function workflowExtension(pi: ExtensionAPI, home?: string, clipboard?: typeof copyToClipboard, createSession?: SessionFactory, agentDir?: string): void;
+export declare function formatWorkflowFailureDelivery(diagnostic: WorkflowFailureDiagnostics): string;
+export default function workflowExtension(pi: ExtensionAPI, home?: string, clipboard?: typeof copyToClipboard, createSession?: SessionFactory, agentDir?: string, additionalSkillPaths?: readonly string[]): void;
 export {};