@marcoscale98/pi-extensible-workflows 5.17.0-fork.1 → 5.19.1-fork.1

package/CHANGELOG.md

@@ -1,6 +1,74 @@
 # Changelog
 ## Unreleased
 
+## [5.19.1] - 2026-10-05
+
+### New capabilities
+
+- Trajectory shows workflow script `shell()` and `tools.<name>()` calls: CALLS and the `script` Gantt lane share status and colours, with phase and timing. Tool arguments and results are not recorded in call state or shown in Trajectory (including live state and HTML exports/shares); tool errors keep only the code. The replay journal retains tool results unchanged. Shell calls keep inputs and output, with environment override names, not values. Calls are recorded without a count cap; tool metadata writes are best-effort, and journaled calls without finish timing show completed with unknown duration.
+
+## [5.19.0] - 2026-10-02
+
+### Breaking changes
+
+- `tools` is a reserved workflow global: registering a workflow function named `tools` fails with `GLOBAL_COLLISION`. Rename the function.
+
+### New capabilities
+
+- Workflow and subagent tools declare an `outputSchema` and return `structuredContent`, so Pi `codemode` scripts receive objects instead of JSON text. For example, `await tools.workflow_status({ runId })` resolves to `{ runId, workflowName, state, agents, ... }`. A completed foreground `workflow`, `workflow_retry`, or `workflow_resume` call resolves with the full `value`, even when the model sees only a result descriptor. Inside workflow agents, the child agent tools `agent` and `get_subagent_result` do the same, and Herdr-bridged tools keep their `outputSchema`.
+- Workflow scripts call the launching session's tools directly as `await tools.<name>(args)`, through Pi's `ctx.executeTool()`, with the names and results of Pi `codemode`. Permission handlers apply, results are journaled for resume and retry, the live workflow item shows calls in flight, and an unknown tool fails the launch with `UNKNOWN_TOOL`. Failed calls reject with the new `TOOL_FAILED` code.
+- `workflow_status`, `workflow_catalog`, and `subagents_inspect` carry the `readOnlyHint` tool annotation, so permission extensions that read annotations can skip confirming them.
+
+### Internal
+
+- Build and test against Pi 1.0.0. `@piewf/cli` bundles Pi 1.0.0.
+
+## [5.18.0] - 2026-09-30
+
+### Breaking changes
+
+- `pi-extensible-workflows` and `@piewf/herdr` require Pi 0.99.0 or later; their `@earendil-works/pi-coding-agent` peer dependency is now `>=0.99.0`. `@piewf/cli` bundles Pi 0.99.1.
+
+### New capabilities
+
+- Global model aliases appear in `/model` and `--model` as virtual models named `workflow/<alias>`, for example `workflow/cheap-model`. The alias target is read from settings on every request, and workflow agents and subagents that inherit the session model run on that target. The thinking level selected in `/model` replaces the one in the alias. Project and extension-provided aliases are not listed, and new aliases need `/reload`.
+- Workflow agents and standalone subagents load Pi's built-in `codemode`, `tool-search`, and `mcp` extensions, so they can reach the MCP servers from `mcp.json` through `codemode` or `tool_search`. `-builtin:<name>` in Pi settings still disables them. Workflow extension selectors name them `builtin:codemode`, `builtin:tool-search`, and `builtin:mcp`; a selector list that starts with `!*` needs `builtin:*` or those names to keep them.
+- The global `codemodeTools` workflow setting limits which workflow and subagent tools Pi `codemode` scripts may call: `"all"` (default), `"read-only"` (`workflow_status`, `workflow_catalog`, and `subagents_inspect`), or `"none"`. The model still calls every tool directly. Changes apply after `/reload`.
+- The agent tool ceiling includes the parent session's tools that only codemode scripts call or `tool_search` loads, such as MCP tools with the default exposure. Role and call tool selectors still restrict them.
+
+### Fixes
+
+- Prompt inspection in `piewf doctor` and role inspection renders the system prompt again on Pi 0.99, including changes made by `before_agent_start` handlers.
+- An agent that asks for a model of Pi's built-in `llama.cpp` provider fails with an error that explains why: Pi does not expose that extension to extension sessions. Declare the server as a provider in `models.json` instead.
+
+### Internal
+
+- Build and test against Pi 0.99.1. Package verification ignores three `brace-expansion` advisories that come from the `npm-shrinkwrap.json` of `@earendil-works/pi-coding-agent@0.99.1`.
+
+## [5.17.2] - 2026-09-28
+
+### Breaking changes
+
+- `subagents_inspect({})` lists only the runs of the current Pi session, matching `/subagents` and Trajectory. Pass `scope: "all"` to list every stored run as before. Lookup by `id` still resolves runs from any session ([#305](https://github.com/vekexasia/pi-extensible-workflows/pull/305)).
+
+### New capabilities
+
+- `piewf doctor` inspects a role file before it is installed: a role ending in `.md`, such as `piewf doctor ./roles/reviewer.md`, is read as a file relative to the current working directory, while other values still name an installed role. A missing file reports `ROLE_FILE_NOT_FOUND` ([#303](https://github.com/vekexasia/pi-extensible-workflows/issues/303)).
+
+### Fixes
+
+- `piewf doctor` no longer fails because of roles that another role overrides: it still reports their invalid frontmatter, but checks tools, models, and settings only for the roles that apply. A role tool missing from doctor's headless tool list is now a `ROLE_TOOL_INACTIVE` warning, because doctor cannot see tools that extensions add when a session starts and the runtime skips unavailable role tools. Role inspection and workflow agent sessions now skip the workflow host extensions of every installed copy of the package, so a Pi package installed next to `@piewf/cli` no longer fails with `Global name is already registered: reviewLoop` ([#302](https://github.com/vekexasia/pi-extensible-workflows/issues/302)).
+
+## [5.17.1] - 2026-09-26
+
+### Fixes
+
+- Running workflow agents and standalone subagents show a fixed status glyph before their names and keep the activity spinner visible after `[running]`, even without a current activity label.
+
+### Internal
+
+- Remove duplicated view and trajectory helpers, unused internal code, and tracked generated images. Preserve the public `pi-extensible-workflows/runtime` type exports.
+
 ## [5.17.0] - 2026-09-23
 
 ### New capabilities

package/dist/src/agent-execution.js

@@ -5,9 +5,9 @@ import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Compile } from "typebox/compile";
-import { createAgentSession, DefaultPackageManager, DefaultResourceLoader, defineTool, getAgentDir, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, createCodemodeExtension, createMcpExtension, createToolSearchExtension, DefaultPackageManager, DefaultResourceLoader, defineTool, getAgentDir, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 ;
-import { SerialLane, assertModelThinking, byPriorityThenName, deepFreeze, errorText, jsonObject, jsonValue, mergeWorkflowExtensionSettings, object, resolveModelReference, resourcePatternHasMagic, unmatchedResourcePatterns } from "./utils.js";
+import { SerialLane, assertModelThinking, byPriorityThenName, deepFreeze, errorText, jsonObject, jsonValue, mergeWorkflowExtensionSettings, object, physicalModel, resolveModelReference, resourcePatternHasMagic, unmatchedResourcePatterns } from "./utils.js";
 import { SETTLED_AGENT_STATES, WorkflowError, isContextFileScope, zeroAccounting } from "./types.js";
 import { createLiveSessionHandoff } from "./session-handoff.js";
 import { createToolTimingExtension } from "./tool-timing.js";
@@ -15,7 +15,8 @@ import { isEmptyAbortedAssistant, normalizePiMessage, normalizePiSessionEvent, r
 import { createPiRuntimeAgentRunner, isRuntimeAgentProviderError, normalizePiRuntimeError } from "./pi-runtime-runner.js";
 import { defaultWorkflowResultSchema } from "./runtime/workflow-result.js";
 import { validateAgentOptions, validateSchema } from "./validation.js";
-import { canonicalPath } from "./paths.js";
+import { canonicalPath, extensionIdentity } from "./paths.js";
+import { isCorePackageName } from "./package-identity.js";
 import { canonicalExtensionSelector, resolveRole } from "./roles.js";
 const localToolTimingExtension = createToolTimingExtension();
 function parseModel(value, fallback, aliases = {}, knownModels, settingsPath) {
@@ -27,16 +28,27 @@ function parseModel(value, fallback, aliases = {}, knownModels, settingsPath) {
 function accounting(stats) {
     return { input: stats.tokens.input, output: stats.tokens.output, cacheRead: stats.tokens.cacheRead, cacheWrite: stats.tokens.cacheWrite, cost: stats.cost };
 }
-const extensionDirectory = dirname(fileURLToPath(import.meta.url));
-const workflowPackageRoot = basename(dirname(extensionDirectory)) === "dist" ? resolve(extensionDirectory, "../..") : resolve(extensionDirectory, "..");
-const WORKFLOW_HOST_ENTRIES = new Set([
-    canonicalPath(resolve(workflowPackageRoot, "src/index.ts")),
-    canonicalPath(resolve(workflowPackageRoot, "dist/src/index.js")),
-    canonicalPath(resolve(workflowPackageRoot, "starter/index.ts")),
-    canonicalPath(resolve(workflowPackageRoot, "dist/starter/index.js")),
-    canonicalPath(resolve(workflowPackageRoot, "subagents/index.ts")),
-    canonicalPath(resolve(workflowPackageRoot, "dist/subagents/index.js")),
-]);
+const WORKFLOW_HOST_ENTRY_PATHS = ["src/index.ts", "dist/src/index.js", "starter/index.ts", "dist/starter/index.js", "subagents/index.ts", "dist/subagents/index.js"];
+function isWorkflowHostEntry(path) {
+    const entryPath = canonicalPath(path);
+    let packageRoot = dirname(entryPath);
+    while (packageRoot !== dirname(packageRoot)) {
+        const packageMetadataPath = join(packageRoot, "package.json");
+        if (existsSync(packageMetadataPath)) {
+            try {
+                const metadata = JSON.parse(readFileSync(packageMetadataPath, "utf8"));
+                if (typeof metadata !== "object" || metadata === null || !("name" in metadata) || !isCorePackageName(metadata.name))
+                    return false;
+                return WORKFLOW_HOST_ENTRY_PATHS.some((entry) => canonicalPath(join(packageRoot, entry)) === entryPath);
+            }
+            catch {
+                return false;
+            }
+        }
+        packageRoot = dirname(packageRoot);
+    }
+    return false;
+}
 const WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 function workflowSystemPromptPath(cwd, agentDir, projectTrusted) {
     const projectPath = join(cwd, ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md");
@@ -71,34 +83,41 @@ function loadPiPackageDirectory() {
         }
     }).catch((error) => ({ error: `could not load @earendil-works/pi-coding-agent package metadata: ${errorText(error)}` }));
 }
-let nativePromptTemplateModule;
-async function loadNativePromptTemplateModule() {
+const nativeCoreModules = new Map();
+/** Pi does not export these core modules, so inspection loads them from the installed package. */
+async function loadNativeCoreModule(file, label) {
     const packageDirectory = await loadPiPackageDirectory();
-    let promptTemplatePath;
+    let modulePath;
     if (packageDirectory.directory) {
-        const candidate = resolve(packageDirectory.directory, "dist/core/prompt-templates.js");
+        const candidate = resolve(packageDirectory.directory, "dist/core", file);
         if (existsSync(candidate))
-            promptTemplatePath = candidate;
+            modulePath = candidate;
     }
-    promptTemplatePath ??= resolve(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core/prompt-templates.js");
+    modulePath ??= resolve(dirname(fileURLToPath(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core", file);
     const packageDirectoryError = packageDirectory.error ? ` Package directory lookup failed: ${packageDirectory.error}` : "";
-    return nativePromptTemplateModule ??= import(promptTemplatePath).then((module) => module).catch((error) => { throw new Error(`Could not load Pi prompt templates.${packageDirectoryError}`, { cause: error }); });
+    let loaded = nativeCoreModules.get(file);
+    if (!loaded) {
+        loaded = import(modulePath).catch((error) => { throw new Error(`Could not load Pi ${label}.${packageDirectoryError}`, { cause: error }); });
+        nativeCoreModules.set(file, loaded);
+    }
+    return loaded;
 }
 async function expandPromptTemplateForInspection(text, templates) {
-    return (await loadNativePromptTemplateModule()).expandPromptTemplate(text, templates);
+    return (await loadNativeCoreModule("prompt-templates.js", "prompt templates")).expandPromptTemplate(text, templates);
+}
+async function buildSystemPromptForInspection(options) {
+    return (await loadNativeCoreModule("system-prompt.js", "system prompt builder")).buildSystemPrompt(options);
 }
 async function preparePiPrompt(native, text) {
     const session = native;
     const diagnostics = [];
     const runner = session._extensionRunner;
-    const baseSystemPrompt = typeof session._baseSystemPrompt === "string" ? session._baseSystemPrompt : session.systemPrompt ?? "";
+    const baseSystemPrompt = session.systemPrompt ?? "";
     const baseOptions = session._baseSystemPromptOptions;
     const expandSkillCommand = session._expandSkillCommand;
     const templates = session.promptTemplates;
     if (!runner)
         diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: extension runner is missing", source: "Pi session" });
-    if (typeof session._baseSystemPrompt !== "string")
-        diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: base system prompt is missing", source: "Pi session" });
     if (baseOptions === undefined)
         diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: base system prompt options are missing", source: "Pi session" });
     if (typeof expandSkillCommand !== "function")
@@ -129,9 +148,11 @@ async function preparePiPrompt(native, text) {
                 diagnostics.push({ type: "error", message: `Pi prompt template expansion is unavailable: ${errorText(error)}`, source: "Pi session" });
             }
         }
-        const result = !inputHandled && runner && baseOptions !== undefined ? await runner.emitBeforeAgentStart(expandedPrompt, undefined, baseSystemPrompt, baseOptions) : undefined;
+        const result = !inputHandled && runner && baseOptions !== undefined ? await runner.emitBeforeAgentStart(expandedPrompt, undefined, baseOptions) : undefined;
         const prepared = result;
-        return { prompt: text, expandedPrompt, systemPrompt: typeof prepared?.systemPrompt === "string" ? prepared.systemPrompt : baseSystemPrompt, systemPromptOptions: baseOptions, messages: prepared?.messages ?? [], inputHandled, diagnostics };
+        const systemPromptOptions = prepared?.systemPromptOptions ?? baseOptions;
+        const systemPrompt = prepared?.systemPromptOptions === undefined ? baseSystemPrompt : await buildSystemPromptForInspection(prepared.systemPromptOptions);
+        return { prompt: text, expandedPrompt, systemPrompt, systemPromptOptions, messages: prepared?.messages ?? [], inputHandled, diagnostics };
     }
     finally {
         unsubscribe?.();
@@ -175,6 +196,22 @@ export function flushExtensionProviders(resourceLoader, modelRuntime) {
     runtime.pendingNativeProviderRegistrations = [];
     return failures;
 }
+/**
+ * The CLI adds Pi's built-in extensions itself; SDK sessions only get them from these public
+ * factories (docs/sdk.md). As `builtin` entries they obey `-builtin:<name>` settings, and like the
+ * CLI's they are replaceable by an extension that registers the same tools or commands.
+ * NOTE: Pi does not export the built-in llama.cpp extension, so workflow agents cannot use models it
+ * provides. Declare the server as a provider in models.json instead.
+ */
+function builtinExtensions() {
+    return [
+        { name: "codemode", factory: createCodemodeExtension(), replaceable: true, builtin: true },
+        { name: "tool-search", factory: createToolSearchExtension(), replaceable: true, builtin: true },
+        { name: "mcp", factory: createMcpExtension(), replaceable: true, builtin: true },
+    ];
+}
+const BUILTIN_EXTENSION_PREFIX = "builtin:";
+function isLlamaModel(model) { return model.provider === "llama.cpp"; }
 async function createLocalPiSessionHandle(input, sessionStartEvent) {
     const agentDir = input.agentDir ?? getAgentDir();
     const systemPromptSource = workflowSystemPromptPath(input.cwd, agentDir, input.resourcePolicy?.projectTrusted ?? true);
@@ -188,13 +225,16 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     const tools = [...new Set([...input.tools, ...customTools.map(({ name }) => name)])];
     let settingsManager;
     let resourceLoader;
+    const builtins = builtinExtensions();
+    const builtinNames = builtins.flatMap((extension) => typeof extension === "function" ? [] : [extension.name]);
+    const extensionFactories = [...builtins, ...(input.extensionFactories ?? [])];
     const policy = input.resourcePolicy;
     if (policy) {
         settingsManager = SettingsManager.create(input.cwd, agentDir, { projectTrusted: false });
         settingsManager.setProjectTrusted(policy.projectTrusted);
-        const packageManager = new DefaultPackageManager({ cwd: input.cwd, agentDir, settingsManager });
+        const packageManager = new DefaultPackageManager({ cwd: input.cwd, agentDir, settingsManager, builtinExtensions: builtinNames });
         const resolved = await packageManager.resolve();
-        const discoveredExtensions = [...new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => canonicalPath(path)))];
+        const discoveredExtensions = [...new Set(resolved.extensions.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => extensionIdentity(path)))];
         const selectorSources = policy.selectorSources;
         const selection = resolveRole(undefined, {
             cwd: input.cwd,
@@ -202,7 +242,7 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
             resources: { extensions: discoveredExtensions },
         });
         const selectedExtensions = selection.selectedExtensions ?? [];
-        const extensionPaths = selectedExtensions.filter((path) => !WORKFLOW_HOST_ENTRIES.has(path));
+        const extensionPaths = selectedExtensions.filter((path) => path.startsWith(BUILTIN_EXTENSION_PREFIX) || !isWorkflowHostEntry(path));
         policy.selectedExtensions = selectedExtensions;
         policy.unmatchedExtensions = selection.unmatchedExtensions ?? [];
         const skillPaths = [...new Set(resolved.skills.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => path))];
@@ -222,7 +262,7 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
             additionalExtensionPaths: extensionPaths,
             noSkills: true,
             additionalSkillPaths: [...new Set([...skillPaths, ...(input.additionalSkillPaths ?? [])])],
-            ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}),
+            extensionFactories,
             ...(contextFilesOverride ? { agentsFilesOverride: contextFilesOverride } : {}),
             skillsOverride: (base) => {
                 const disabledSkills = updateSkillMatches(base.skills);
@@ -235,10 +275,10 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     }
     else {
         settingsManager = SettingsManager.create(input.cwd, agentDir, { projectTrusted: true });
-        const packageManager = new DefaultPackageManager({ cwd: input.cwd, agentDir, settingsManager });
+        const packageManager = new DefaultPackageManager({ cwd: input.cwd, agentDir, settingsManager, builtinExtensions: builtinNames });
         const resolved = await packageManager.resolve();
-        const extensionPaths = [...new Set(resolved.extensions.filter(({ enabled }) => enabled).map(({ path }) => canonicalPath(path)).filter((path) => !WORKFLOW_HOST_ENTRIES.has(path)))];
-        resourceLoader = new DefaultResourceLoader({ cwd: input.cwd, agentDir, settingsManager, noExtensions: true, additionalExtensionPaths: extensionPaths, ...(input.additionalSkillPaths?.length ? { additionalSkillPaths: [...input.additionalSkillPaths] } : {}), ...(input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}), ...(contextFilesOverride ? { agentsFilesOverride: contextFilesOverride } : {}), ...systemPromptOptions, ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}) });
+        const extensionPaths = [...new Set(resolved.extensions.filter(({ enabled }) => enabled).map(({ path }) => extensionIdentity(path)).filter((path) => path.startsWith(BUILTIN_EXTENSION_PREFIX) || !isWorkflowHostEntry(path)))];
+        resourceLoader = new DefaultResourceLoader({ cwd: input.cwd, agentDir, settingsManager, noExtensions: true, additionalExtensionPaths: extensionPaths, ...(input.additionalSkillPaths?.length ? { additionalSkillPaths: [...input.additionalSkillPaths] } : {}), extensionFactories, ...(contextFilesOverride ? { agentsFilesOverride: contextFilesOverride } : {}), ...systemPromptOptions, ...(input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {}) });
         await resourceLoader.reload();
     }
     const providerFailures = flushExtensionProviders(resourceLoader, modelRuntime);
@@ -249,7 +289,7 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
         // missing, so the failure travels with the complaint rather than being
         // swallowed — otherwise a misconfigured gateway reads as a typo in a model
         // name.
-        const because = providerFailures.length > 0 ? ` (provider registration failed — ${providerFailures.join("; ")})` : "";
+        const because = providerFailures.length > 0 ? ` (provider registration failed — ${providerFailures.join("; ")})` : isLlamaModel(input.model) ? " (Pi does not expose its built-in llama.cpp provider to extension sessions; declare the llama.cpp server as a provider in models.json and use that model instead)" : "";
         throw new WorkflowError("UNKNOWN_MODEL", `Unknown model: ${input.model.provider}/${input.model.model}${because}`);
     }
     const effectiveSessionStartEvent = input.settings === undefined && sessionStartEvent === undefined ? undefined : { ...(sessionStartEvent ?? { type: "session_start", reason: "startup" }), settings: input.settings ?? Object.freeze({}) };
@@ -278,13 +318,13 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
         await shutdown("quit").catch(() => undefined);
         throw error;
     }
-    const resourcePaths = { extensions: resourceLoader.getExtensions().extensions.filter(({ path }) => !path.startsWith("<")).map(({ resolvedPath }) => canonicalPath(resolvedPath)), skills: resourceLoader.getSkills().skills.map(({ filePath }) => canonicalPath(filePath)) };
+    const resourcePaths = { extensions: resourceLoader.getExtensions().extensions.filter(({ path }) => !path.startsWith("<")).map(({ resolvedPath }) => extensionIdentity(resolvedPath)), skills: resourceLoader.getSkills().skills.map(({ filePath }) => canonicalPath(filePath)) };
     const resourceInspection = () => {
         const extensions = resourceLoader.getExtensions();
         const skills = resourceLoader.getSkills();
         const diagnostics = [...extensions.errors.map(({ path, error }) => ({ type: "error", message: error, source: path })), ...skills.diagnostics.map(({ type, path, message }) => ({ type, message, ...(path ? { source: path } : {}) }))];
         const systemSource = systemPromptSource;
-        return { extensions: resourceLoader.getExtensions().extensions.filter(({ path }) => !path.startsWith("<")).map(({ resolvedPath }) => canonicalPath(resolvedPath)), skills: skills.skills.map(({ name }) => name), diagnostics, ...(systemSource ? { systemPromptSource: systemSource } : resourceLoader.getSystemPrompt() !== undefined ? { systemPromptSource: "Pi resource loader" } : {}) };
+        return { extensions: resourceLoader.getExtensions().extensions.filter(({ path }) => !path.startsWith("<")).map(({ resolvedPath }) => extensionIdentity(resolvedPath)), skills: skills.skills.map(({ name }) => name), diagnostics, ...(systemSource ? { systemPromptSource: systemSource } : resourceLoader.getSystemPrompt() !== undefined ? { systemPromptSource: "Pi resource loader" } : {}) };
     };
     const managedSession = Object.assign(session, {
         getLeafId: () => manager.getLeafId(),
@@ -971,7 +1011,7 @@ export class WorkflowAgentExecutor {
             ...(options.contextFiles === undefined ? {} : { contextFiles: options.contextFiles }),
             ...(options.effectiveTools === undefined ? {} : { effectiveTools: options.effectiveTools }),
         });
-        return { model: resolved.model ?? this.root.model, ...(resolved.requestedModel === undefined ? {} : { requestedModel: resolved.requestedModel }), tools: resolved.tools ?? [], ...(resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}), systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...(resolved.contextFiles === undefined ? {} : { contextFiles: resolved.contextFiles }) };
+        return { model: physicalModel(resolved.model ?? this.root.model, this.root.modelAliases, this.root.knownModels, this.root.settingsPath), ...(resolved.requestedModel === undefined ? {} : { requestedModel: resolved.requestedModel }), tools: resolved.tools ?? [], ...(resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}), systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...(resolved.contextFiles === undefined ? {} : { contextFiles: resolved.contextFiles }) };
     }
     async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
         const executionSignal = signal ?? this.root.runContext?.signal;
@@ -1439,6 +1479,7 @@ export class FairAgentScheduler {
         const agentTool = defineTool({
             name: "agent", label: "Child Agent", description: "Start a direct child agent",
             parameters: Type.Object({ prompt: Type.String(), label: Type.String(), tools: Type.Optional(Type.Array(Type.String())), skills: Type.Optional(Type.Array(Type.String())), extensions: Type.Optional(Type.Array(Type.String())), model: Type.Optional(Type.String()), role: Type.Optional(Type.String()), contextFiles: Type.Optional(Type.Array(Type.String())), outputSchema: Type.Optional(Type.Record(Type.String(), Type.Unknown())), retries: Type.Optional(Type.Integer({ minimum: 0 })), timeoutMs: Type.Optional(Type.Union([Type.Integer({ minimum: 1 }), Type.Null()])) }, { additionalProperties: true }),
+            outputSchema: Type.Object({ id: Type.String() }),
             execute: async (_id, params) => {
                 if (!isChildAgentToolParams(params))
                     throw new WorkflowError("INVALID_METADATA", "Invalid child agent parameters");
@@ -1451,14 +1492,15 @@ export class FairAgentScheduler {
                 Reflect.deleteProperty(agentOptions, "prompt");
                 const options = { label: params.label, requestedLabel: params.label, cwd: parent.options.cwd, tools, agentOptions, ...(params.skills ? { skills: params.skills } : {}), ...(params.extensions ? { extensions: params.extensions } : {}), ...(params.model ? { model: params.model } : {}), ...(params.role ? { role: params.role } : {}), ...(params.contextFiles ? { contextFiles: params.contextFiles } : {}), ...(outputSchema === undefined ? {} : { schema: outputSchema }), ...(params.retries === undefined ? {} : { retries: params.retries }), ...(params.timeoutMs === undefined ? {} : { timeoutMs: params.timeoutMs }) };
                 const child = this.spawn(parent.runId, params.prompt, options, parentId);
-                return { content: [{ type: "text", text: JSON.stringify({ id: child.id }) }], details: { id: child.id } };
+                return { content: [{ type: "text", text: JSON.stringify({ id: child.id }) }], details: { id: child.id }, structuredContent: { id: child.id } };
             },
         });
         const resultTool = defineTool({
             name: "get_subagent_result", label: "Child Result", description: "Wait for a direct child and return its result once; repeated retrieval fails with AGENT_RESULT_COLLECTED",
             parameters: Type.Object({ id: Type.String() }),
+            outputSchema: Type.Object({ id: Type.String(), ok: Type.Boolean(), value: Type.Optional(Type.Unknown()), error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String() })) }),
             execute: async (_id, params) => { const value = await this.result(parentId, params.id); if (!value.ok && value.error.code === "BUDGET_EXHAUSTED")
-                throw new WorkflowError("BUDGET_EXHAUSTED", value.error.message); return { content: [{ type: "text", text: JSON.stringify(value) }], details: value }; }
+                throw new WorkflowError("BUDGET_EXHAUSTED", value.error.message); return { content: [{ type: "text", text: JSON.stringify(value) }], details: value, structuredContent: value }; }
         });
         const steerTool = defineTool({
             name: "steer_subagent", label: "Steer Child", description: "Steer a running direct child",

package/dist/src/background-widget.d.ts

@@ -22,6 +22,11 @@ export type BackgroundWidgetAPI = Pick<ExtensionAPI, "appendEntry" | "on"> & {
     registerEntryRenderer?: ExtensionAPI["registerEntryRenderer"];
     registerShortcut?: ExtensionAPI["registerShortcut"];
 };
+/**
+ * Repaint interval. Fast enough that the spinner reads as motion rather than a
+ * stutter; the underlying data is only re-read when an event says it changed.
+ */
+export declare const REPAINT_MS = 125;
 /**
  * How long an agent may go without an event before the widget says so.
  *

package/dist/src/background-widget.js

@@ -25,7 +25,7 @@ const ENTRY_TYPE = "piewf-run-receipt";
  * Repaint interval. Fast enough that the spinner reads as motion rather than a
  * stutter; the underlying data is only re-read when an event says it changed.
  */
-const REPAINT_MS = 125;
+export const REPAINT_MS = 125;
 /**
  * Filesystem rescan interval. Shell-only activity has no event, but it does not
  * need to be polled at the animation cadence.

package/dist/src/decoders.js

@@ -434,6 +434,28 @@ function decodeRunEvent(value) {
         return undefined;
     return { type: value.type, message: value.message, ...(timestamp === undefined ? {} : { timestamp }) };
 }
+function decodeScriptCall(value) {
+    if (!object(value) || value.kind !== "shell" && value.kind !== "tool" || typeof value.name !== "string" || typeof value.path !== "string" || !finiteNumber(value.startedAt))
+        return undefined;
+    const shell = value.kind === "shell";
+    if (shell && !jsonValue(value.input))
+        return undefined;
+    const inputBytes = shell ? optionalNumber(value.inputBytes) : undefined;
+    const phase = optionalString(value.phase);
+    const finishedAt = optionalNumber(value.finishedAt);
+    let error;
+    if (value.error !== undefined) {
+        if (shell)
+            error = decodeWorkflowError(value.error);
+        else if (object(value.error) && typeof value.error.code === "string")
+            error = { code: isWorkflowErrorCode(value.error.code) ? value.error.code : "INTERNAL_ERROR" };
+        if (!error)
+            return undefined;
+    }
+    if (inputBytes === INVALID_PERSISTED_VALUE || phase === INVALID_PERSISTED_VALUE || finishedAt === INVALID_PERSISTED_VALUE)
+        return undefined;
+    return { kind: value.kind, name: value.name, path: value.path, ...(shell && jsonValue(value.input) ? { input: value.input } : {}), ...(inputBytes === undefined ? {} : { inputBytes }), ...(phase === undefined ? {} : { phase }), startedAt: value.startedAt, ...(finishedAt === undefined ? {} : { finishedAt }), ...(error === undefined ? {} : { error }) };
+}
 function decodeDelivery(value) {
     if (!object(value))
         return undefined;
@@ -467,6 +489,9 @@ export function decodePersistedRun(value, allowLegacyAgentSessions = false) {
     const budgetEvents = value.budgetEvents === undefined ? undefined : decodeArray(value.budgetEvents, decodeBudgetEvent);
     const events = value.events === undefined ? undefined : decodeArray(value.events, decodeRunEvent);
     const delivery = value.delivery === undefined ? undefined : decodeDelivery(value.delivery);
+    const scriptCalls = value.scriptCalls === undefined ? undefined : decodeArray(value.scriptCalls, decodeScriptCall);
+    if (value.scriptCalls !== undefined && !scriptCalls)
+        return undefined;
     if (!agentSessions || !agents || parentRunId === INVALID_PERSISTED_VALUE || value.retry !== undefined && !retry || phase === INVALID_PERSISTED_VALUE || value.phaseHistory !== undefined && !phaseHistory || phaseHistoryIndex === INVALID_PERSISTED_VALUE || activeShells === INVALID_PERSISTED_VALUE || activeShellStartedAt === INVALID_PERSISTED_VALUE || value.activeShellsByPhase !== undefined && !activeShellsByPhase || value.error !== undefined && !error || failedAt === INVALID_PERSISTED_VALUE || value.budget !== undefined && !budget || budgetVersion === INVALID_PERSISTED_VALUE || value.budgetVersion !== undefined && !integer(budgetVersion) || value.usage !== undefined && !usage || value.budgetEvents !== undefined && !budgetEvents || value.events !== undefined && !events || value.delivery !== undefined && !delivery)
         return undefined;
     if (value.agentSessions === undefined && !allowLegacyAgentSessions)
@@ -487,6 +512,7 @@ export function decodePersistedRun(value, allowLegacyAgentSessions = false) {
         ...(activeShells === undefined ? {} : { activeShells }),
         ...(activeShellStartedAt === undefined ? {} : { activeShellStartedAt }),
         ...(activeShellsByPhase === undefined ? {} : { activeShellsByPhase }),
+        ...(scriptCalls === undefined ? {} : { scriptCalls }),
         ...(error === undefined ? {} : { error }),
         ...(failedAt === undefined ? {} : { failedAt }),
         ...(budget === undefined ? {} : { budget }),

package/dist/src/execution.d.ts

@@ -1,10 +1,12 @@
 import { RunStore } from "./persistence.js";
 import type { AgentAttempt } from "./agent-execution.js";
-import type { AgentIdentity, JsonValue, ShellIdentity, ShellOptions, ShellResult, WorkflowBridge, WorkflowExecution } from "./types.js";
+import type { AgentIdentity, JsonValue, ShellIdentity, ShellOptions, ShellResult, ToolIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";
 export declare const RPC_LIMIT_BYTES: number;
 export declare const HEARTBEAT_TIMEOUT_MS = 5000;
 export declare function encoded(value: JsonValue): string;
 export declare function encoded(value: unknown): asserts value is JsonValue;
+/** The journal path of a script tool call; the arguments' digest keeps calls with different arguments apart whatever order they start in. */
+export declare function toolIdentityPath(identifier: string, args: JsonValue, identity: ToolIdentity): string;
 export declare function agentHandleTurnPath(handle: string, turn: number): string;
 export declare function agentIdentityPath(identity: AgentIdentity): string;
 export declare function shellIdentityPath(identity: ShellIdentity): string;
@@ -16,4 +18,4 @@ export declare function executeShellCommand(command: string, options: ShellOptio
 export declare function runWorkflow(script: string, args?: JsonValue, bridge?: WorkflowBridge, signal?: AbortSignal): WorkflowExecution;
 export declare function persistActiveAgentAttempt(store: RunStore, id: string, active: AgentAttempt): Promise<void>;
 export declare function persistAgentAttempts(store: RunStore, id: string, attempts: readonly AgentAttempt[]): Promise<void>;
-export type { AgentIdentity, FunctionIdentity, ShellIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";
+export type { AgentIdentity, FunctionIdentity, ShellIdentity, ToolIdentity, WorkflowBridge, WorkflowExecution } from "./types.js";

package/dist/src/execution.js

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { structuralPath as operationPath } from "./persistence.js";
 import { WorkflowError, roleNameOf, sumAccounting, zeroAccounting } from "./types.js";
-import { asWorkflowError, errorText, fail, isWorkflowAuthored, isWorkflowErrorCode, jsonValue, markWorkflowAuthored, object, positiveInteger } from "./utils.js";
+import { asWorkflowError, errorText, fail, isWorkflowAuthored, isWorkflowErrorCode, jsonDigest, jsonValue, markWorkflowAuthored, object, positiveInteger } from "./utils.js";
 import { instrumentWorkflow, validateAgentOptions, validateShellCommand, validateShellOptions } from "./validation.js";
 export const RPC_LIMIT_BYTES = 10 * 1024 * 1024;
 export const HEARTBEAT_TIMEOUT_MS = 5000;
@@ -268,6 +268,30 @@ const functions = Object.freeze(Object.fromEntries(Object.entries(config.functio
   Object.defineProperty(result, "toJSON", { value() { throw workError("INVALID_METADATA", "Workflow function result is a Promise; await it before serialization"); } });
   return result;
 }])));
+// tools.<id>(args) runs a Pi session tool through the host. Any identifier resolves, so a resumed run
+// replays journaled calls even when the tool is gone; the host rejects identifiers it cannot call.
+// A call is the n-th call with the same arguments in its scope, so replay does not depend on the
+// order in which concurrent calls start.
+const NOT_TOOLS = new Set(["then", "toJSON", "toString", "valueOf", "constructor"]);
+const sortedJson = value => Array.isArray(value) ? value.map(sortedJson) : value && typeof value === "object" ? Object.fromEntries(Object.keys(value).sort().map(key => [key, sortedJson(value[key])])) : value;
+const toolOccurrences = new Map();
+const toolCall = id => (...values) => {
+  if (worktreeOwners.getStore()) throw workError("INVALID_METADATA", "tools." + id + " is unavailable inside withWorktree: session tools resolve paths against the session working directory");
+  if (values.length > 1 || values[0] !== undefined && (!values[0] || typeof values[0] !== "object" || Array.isArray(values[0]))) throw workError("INVALID_METADATA", "tools." + id + " takes one arguments object");
+  const args = values[0] === undefined ? {} : values[0];
+  const structuralPath = inheritedAgentPath.getStore() || [];
+  const key = JSON.stringify([structuralPath, id, sortedJson(args)]);
+  const occurrence = (toolOccurrences.get(key) || 0) + 1;
+  toolOccurrences.set(key, occurrence);
+  return guardedResult(rpc("tool", [id, args, { structuralPath: [...structuralPath], occurrence }]), "tool");
+};
+const tools = new Proxy(Object.create(null), {
+  get: (_target, key) => typeof key === "string" && !NOT_TOOLS.has(key) ? toolCall(key) : undefined,
+  // Probing would branch on the session that resumed the run; the launch already checks named tools.
+  has: () => { throw workError("INVALID_METADATA", "Workflow scripts cannot probe tools with 'in'; call tools.<name>(...) directly, and the launch checks that the tool exists"); },
+  set: () => false,
+  defineProperty: () => false,
+});
 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);
@@ -328,7 +352,7 @@ const pipeline = async (operationName, items, stages) => {
   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, shell, withWorktree: rejectWorktree, prompt, checkpoint, parallel, pipeline, phase, log, args: config.args, Promise, JSON, Math: Object.freeze(safeMath) };
+const sandbox = { agent, shell, withWorktree: rejectWorktree, prompt, checkpoint, parallel, pipeline, phase, log, tools, 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 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 } });
@@ -378,6 +402,15 @@ function readShellIdentity(value) {
     const identity = readAgentIdentity(value);
     return { structuralPath: identity.structuralPath, callSite: identity.callSite, occurrence: identity.occurrence, ...(identity.worktreeOwner ? { worktreeOwner: identity.worktreeOwner } : {}) };
 }
+function readToolIdentity(value) {
+    if (!object(value) || !Array.isArray(value.structuralPath) || !value.structuralPath.every((part) => typeof part === "string" && Boolean(part.trim())) || !positiveInteger(value.occurrence))
+        fail("INTERNAL_ERROR", "Invalid workflow tool identity");
+    return { structuralPath: [...value.structuralPath], occurrence: value.occurrence };
+}
+/** The journal path of a script tool call; the arguments' digest keeps calls with different arguments apart whatever order they start in. */
+export function toolIdentityPath(identifier, args, identity) {
+    return operationPath("tool", ...identity.structuralPath, identifier, `args:${jsonDigest(args)}`, String(identity.occurrence));
+}
 export function agentHandleTurnPath(handle, turn) {
     return operationPath("agent", "handle", handle, `turn:${String(turn)}`);
 }
@@ -681,6 +714,14 @@ export function runWorkflow(script, args = null, bridge = {}, signal) {
                     value = branded({ name, ok: false, failedAt: name, error: workerErrorShape(typed) });
                 }
             }
+            else if (method === "tool") {
+                if (typeof values[0] !== "string" || !object(values[1]))
+                    fail("INTERNAL_ERROR", "tool requires an identifier and object arguments");
+                const identity = readToolIdentity(values[2]);
+                if (!bridge.tool)
+                    fail("UNKNOWN_TOOL", `tools.${values[0]} is unavailable: this run has no session tools`);
+                value = await bridge.tool(values[0], values[1], controller.signal, identity);
+            }
             else if (method === "worktree") {
                 if (!bridge.worktree || typeof values[0] !== "string" || !values[0])
                     fail("INTERNAL_ERROR", "worktree requires an active host bridge and scope");

package/dist/src/host-delivery.js

@@ -108,6 +108,7 @@ const WORKFLOW_ERROR_PROSE = {
     RUN_NOT_FOUND: (detail) => /^Unknown workflow run\b/.test(detail) ? "The workflow run was not found." : `The workflow run was not found: ${detail}.`,
     RPC_LIMIT_EXCEEDED: (detail) => `The workflow communication data exceeded its size limit: ${detail}.`,
     SHELL_FAILED: (detail) => `The workflow shell command failed: ${detail}.`,
+    TOOL_FAILED: (detail) => `The workflow tool call failed: ${detail}.`,
     AGENT_TIMEOUT: (detail) => `The workflow agent timed out: ${detail}.`,
     AGENT_FAILED: (detail) => `The workflow agent failed: ${detail}.`,
     AGENT_RESULT_COLLECTED: (detail) => `The nested agent result was already collected: ${detail}.`,

package/dist/src/host-recovery.d.ts

@@ -1,8 +1,8 @@
 import type { Api, Model } from "@earendil-works/pi-ai";
-import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionToolContext } from "@earendil-works/pi-coding-agent";
 import { FairAgentScheduler, WorkflowAgentExecutor, type AgentDefinition, type AgentExecutionRoot, type AgentProviderFailure, type AgentProviderRecovery } from "./agent-execution.js";
 import { RunStore, type PersistedRun } from "./persistence.js";
-import { WorkflowError, type AgentIdentity, type AgentResourcePolicy, type BudgetApprovalRequest, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type WorkflowMetadata, type WorkflowWorktreeReference } from "./types.js";
+import { WorkflowError, type AgentIdentity, type AgentResourcePolicy, type BudgetApprovalRequest, type JsonValue, type LaunchSnapshot, type ModelSpec, type RunState, type ShellIdentity, type ShellOptions, type ShellResult, type ToolIdentity, type WorkflowMetadata, type WorkflowWorktreeReference } from "./types.js";
 import { type WorkflowRegistryApi } from "./registry.js";
 import { RunLifecycle, WorkflowEventPublisher, type WorkflowRunRecord, type WorkflowToolUpdate } from "./host-runtime.js";
 import { type CompletionDeliveryContext, type CompletionDeliveryResult } from "./host-delivery.js";
@@ -21,6 +21,7 @@ export type WorkflowRecoveryContext = {
     } | undefined;
     modelRegistry: ModelRegistryCapability | undefined;
     deliveryContext: CompletionDeliveryContext;
+    toolContext?: ExtensionToolContext | undefined;
     signal?: AbortSignal;
     resolvedAliases?: Readonly<Record<string, string>>;
     blockedAliases?: ReadonlySet<string>;
@@ -70,6 +71,7 @@ export type WorkflowRecoveryDependencies = {
     };
     workflowAgentHandler: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, executor: WorkflowAgentExecutor, cwd: string, runId: string, captureRole?: (role: string, model: ModelSpec) => Promise<void>) => (prompt: string, options: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: AgentIdentity) => Promise<JsonValue>;
     shellForRun: (store: RunStore, metadata: WorkflowMetadata, lifecycle: RunLifecycle, command: string, options: ShellOptions, signal: AbortSignal, identity: ShellIdentity) => Promise<ShellResult>;
+    toolForRun: (store: RunStore, lifecycle: RunLifecycle, context: ExtensionToolContext | undefined, identifier: string, args: Readonly<Record<string, JsonValue>>, signal: AbortSignal, identity: ToolIdentity) => Promise<JsonValue>;
     resolveWorktree: (store: RunStore, metadata: WorkflowMetadata, owner: string) => Promise<Readonly<WorkflowWorktreeReference>>;
     checkpointBridge: (runId: string, store: RunStore, metadata: WorkflowMetadata, foreground: boolean, ui?: {
         select?: (prompt: string, options: string[]) => Promise<string | undefined>;
@@ -104,6 +106,7 @@ export declare function createWorkflowRecovery(deps: WorkflowRecoveryDependencie
         } | undefined;
         modelRegistry: WorkflowRecoveryContext["modelRegistry"];
         deliveryContext: CompletionDeliveryContext;
+        toolContext?: ExtensionToolContext | undefined;
         signal?: AbortSignal | undefined;
         resolvedAliases?: Readonly<Record<string, string>>;
         blockedAliases?: ReadonlySet<string>;

package/dist/src/host-recovery.js

@@ -46,7 +46,7 @@ function assertExpectedWorkflowState(expectedState, actualState) {
 }
 export function persistedFailure(run, error) { const failedAt = workflowFailedAt(error); return { ...run, error: { code: error.code, message: error.message, ...(failedAt ? { failedAt } : {}) }, ...(failedAt ? { failedAt } : {}) }; }
 export function createWorkflowRecovery(deps) {
-    const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver, deliverTerminal, workflowToolUpdate, registry, modelSpec } = deps;
+    const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted, resumeHostContext, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, toolForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver, deliverTerminal, workflowToolUpdate, registry, modelSpec } = deps;
     const coordinateRunMutation = deps.coordinateRunMutation ?? ((task) => task());
     const budgetDecisionDelivery = (metadata, request) => `Workflow ${metadata.name} budget adjustment ${request.proposalId} for run ${request.runId} requires approval. Consumed usage: ${JSON.stringify(request.consumed)}. Previous limits: ${JSON.stringify(request.previous)}. Proposed limits: ${JSON.stringify(request.proposed)}. Respond with workflow_respond using proposalId ${request.proposalId}.`;
     const appendBudgetDecisionEvent = async (run, request, type) => {
@@ -119,7 +119,7 @@ export function createWorkflowRecovery(deps) {
         run.executor.setRunContext(runContext);
         await scheduler.cancelRun(run.store.runId);
         await run.lifecycle.resume();
-        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId, roles.capture), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, foreground, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.store, run.lifecycle, run.metadata.name) }, run.store, runContext, registry, snapshot.settings.extensionSettings), controller.signal);
+        const execution = runWorkflow(script, loaded.snapshot.args, withWorkflowFunctions({ tool: (identifier, args, signal, identity) => toolForRun(run.store, run.lifecycle, context?.toolContext, identifier, args, signal, identity), shell: (command, options, signal, identity) => shellForRun(run.store, run.metadata, run.lifecycle, command, options, signal, identity), agent: workflowAgentHandler(run.store, run.metadata, run.lifecycle, run.executor, run.store.cwd, run.store.runId, roles.capture), worktree: async (owner) => resolveWorktree(run.store, run.metadata, owner), checkpoint: checkpointBridge(run.store.runId, run.store, run.metadata, foreground, hasUI ? ui : undefined), phase: phaseBridge(run.store, run.metadata, run.lifecycle), log: logBridge(run.store, run.lifecycle, run.metadata.name) }, run.store, runContext, registry, snapshot.settings.extensionSettings), controller.signal);
         run.execution = execution;
         const completion = execution.result.then(async (value) => {
             await scheduler.flush(run.store.runId);
@@ -333,7 +333,7 @@ export function createWorkflowRecovery(deps) {
             await eventPublisher.runStarted(prepared.childRun.store, prepared.childRun.metadata);
             const { hasUI, ui } = recoveryUi(context);
             const recoveryContext = resumeHostContext(context);
-            const completed = await coldResumeRun(prepared.childRun, hasUI, ui, projectTrusted(context), { model: prepared.hostModel, modelRegistry: prepared.modelRegistry, deliveryContext: recoveryContext.deliveryContext, resolvedAliases: prepared.currentAliases, blockedAliases: prepared.blockedAliases, blockedAliasTargets: prepared.blockedAliasTargets, ...(signal ? { signal } : {}) }, modeOverride);
+            const completed = await coldResumeRun(prepared.childRun, hasUI, ui, projectTrusted(context), { model: prepared.hostModel, modelRegistry: prepared.modelRegistry, deliveryContext: recoveryContext.deliveryContext, toolContext: recoveryContext.toolContext, resolvedAliases: prepared.currentAliases, blockedAliases: prepared.blockedAliases, blockedAliasTargets: prepared.blockedAliasTargets, ...(signal ? { signal } : {}) }, modeOverride);
             const completion = runs.get(prepared.childRun.store.runId)?.completion;
             if (completion) {
                 childStarted = true;

package/dist/src/host-view.d.ts

@@ -84,6 +84,11 @@ export declare function navigatorRunLabels(entries: readonly {
 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 formatStalledDuration(durationMs: number): string;
+export declare function stalledDuration(agent: Pick<AgentDetailPresentation, "state" | "lastEventAt">, now: number): number | undefined;
+export declare function agentActivityLabel(agent: {
+    readonly activity?: AgentRecord["activity"];
+    readonly toolCalls?: AgentRecord["toolCalls"];
+}): string;
 export interface AgentDetailPresentation {
     readonly state: string;
     readonly activity?: AgentRecord["activity"];