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

package/dist/src/index.js

@@ -42,6 +42,7 @@ var ERROR_CODES = [
   "AGENT_FAILED",
   "AGENT_RESULT_COLLECTED",
   "RESULT_INVALID",
+  "TOOL_FAILED",
   "CANCELLED",
   "WORKER_UNRESPONSIVE",
   "WORKTREE_FAILED",
@@ -135,6 +136,7 @@ function createToolTimingExtension(clock = Date.now) {
 }
 
 // src/utils.ts
+import { createHash } from "node:crypto";
 import { Minimatch } from "minimatch";
 var SerialLane = class {
   #tail = Promise.resolve();
@@ -160,6 +162,14 @@ function isStringKey(key) {
 function stringKeyValue(value, key) {
   return object(value) ? value[key] : void 0;
 }
+function sortedJson(value) {
+  if (Array.isArray(value)) return value.map(sortedJson);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortedJson(value[key])]));
+}
+function jsonDigest(value) {
+  return createHash("sha256").update(JSON.stringify(sortedJson(value))).digest("hex").slice(0, 16);
+}
 function jsonValue(value, seen = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value === "boolean" || typeof value === "string") return true;
   if (typeof value === "number") return Number.isFinite(value);
@@ -320,6 +330,16 @@ function resolveModelReference(value, aliases = {}, knownModels, settingsPath) {
   };
   return resolveReference(value, []);
 }
+function reachableTools(pi) {
+  const undeclared = pi.getAllTools?.().filter(({ exposure }) => exposure === "codemode" || exposure === "deferred").map(({ name }) => name) ?? [];
+  return [.../* @__PURE__ */ new Set([...pi.getActiveTools(), ...undeclared])];
+}
+var VIRTUAL_MODEL_PROVIDER = "workflow";
+function physicalModel(spec, aliases = {}, knownModels, settingsPath) {
+  if (spec.provider !== VIRTUAL_MODEL_PROVIDER || !modelAliasName(spec.model, aliases)) return spec;
+  const target = resolveModelReference(spec.model, aliases, knownModels, settingsPath);
+  return spec.thinking === void 0 ? target : { ...target, thinking: spec.thinking };
+}
 function modelCapability(value, aliases, knownModels, settingsPath) {
   const parsed = typeof value === "string" ? resolveModelReference(value, aliases, knownModels, settingsPath) : value;
   return `${parsed.provider}/${parsed.model}`;
@@ -378,7 +398,7 @@ function validateSchema(schema, at = "schema") {
 }
 
 // src/paths.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -394,6 +414,9 @@ function canonicalPath(path) {
     return absolute;
   }
 }
+function extensionIdentity(path) {
+  return path.startsWith("builtin:") ? path : canonicalPath(path);
+}
 function sameFilesystemPath(left, right) {
   return canonicalPath(left) === canonicalPath(right);
 }
@@ -403,7 +426,7 @@ function workflowProjectSettingsPath(cwd) {
 function projectStorageKey(cwd) {
   const exact = resolve(cwd);
   const slug = safePart(basename(exact)) || "root";
-  return `${slug}-${createHash("sha256").update(exact).digest("hex").slice(0, 12)}`;
+  return `${slug}-${createHash2("sha256").update(exact).digest("hex").slice(0, 12)}`;
 }
 function projectSessionsDirectory(cwd, home = homedir()) {
   return join(home, ".pi", "workflows", "projects", projectStorageKey(cwd), "sessions");
@@ -1201,6 +1224,22 @@ function decodeRunEvent(value) {
   if (timestamp === INVALID_PERSISTED_VALUE) return void 0;
   return { type: value.type, message: value.message, ...timestamp === void 0 ? {} : { 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 void 0;
+  const shell = value.kind === "shell";
+  if (shell && !jsonValue(value.input)) return void 0;
+  const inputBytes = shell ? optionalNumber(value.inputBytes) : void 0;
+  const phase = optionalString(value.phase);
+  const finishedAt = optionalNumber(value.finishedAt);
+  let error;
+  if (value.error !== void 0) {
+    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 void 0;
+  }
+  if (inputBytes === INVALID_PERSISTED_VALUE || phase === INVALID_PERSISTED_VALUE || finishedAt === INVALID_PERSISTED_VALUE) return void 0;
+  return { kind: value.kind, name: value.name, path: value.path, ...shell && jsonValue(value.input) ? { input: value.input } : {}, ...inputBytes === void 0 ? {} : { inputBytes }, ...phase === void 0 ? {} : { phase }, startedAt: value.startedAt, ...finishedAt === void 0 ? {} : { finishedAt }, ...error === void 0 ? {} : { error } };
+}
 function decodeDelivery(value) {
   if (!object(value)) return void 0;
   const mode = value.mode;
@@ -1230,6 +1269,8 @@ function decodePersistedRun(value, allowLegacyAgentSessions = false) {
   const budgetEvents = value.budgetEvents === void 0 ? void 0 : decodeArray(value.budgetEvents, decodeBudgetEvent);
   const events = value.events === void 0 ? void 0 : decodeArray(value.events, decodeRunEvent);
   const delivery = value.delivery === void 0 ? void 0 : decodeDelivery(value.delivery);
+  const scriptCalls = value.scriptCalls === void 0 ? void 0 : decodeArray(value.scriptCalls, decodeScriptCall);
+  if (value.scriptCalls !== void 0 && !scriptCalls) return void 0;
   if (!agentSessions || !agents || parentRunId === INVALID_PERSISTED_VALUE || value.retry !== void 0 && !retry || phase === INVALID_PERSISTED_VALUE || value.phaseHistory !== void 0 && !phaseHistory || phaseHistoryIndex === INVALID_PERSISTED_VALUE || activeShells === INVALID_PERSISTED_VALUE || activeShellStartedAt === INVALID_PERSISTED_VALUE || value.activeShellsByPhase !== void 0 && !activeShellsByPhase || value.error !== void 0 && !error || failedAt === INVALID_PERSISTED_VALUE || value.budget !== void 0 && !budget || budgetVersion === INVALID_PERSISTED_VALUE || value.budgetVersion !== void 0 && !integer(budgetVersion) || value.usage !== void 0 && !usage || value.budgetEvents !== void 0 && !budgetEvents || value.events !== void 0 && !events || value.delivery !== void 0 && !delivery) return void 0;
   if (value.agentSessions === void 0 && !allowLegacyAgentSessions) return void 0;
   return {
@@ -1248,6 +1289,7 @@ function decodePersistedRun(value, allowLegacyAgentSessions = false) {
     ...activeShells === void 0 ? {} : { activeShells },
     ...activeShellStartedAt === void 0 ? {} : { activeShellStartedAt },
     ...activeShellsByPhase === void 0 ? {} : { activeShellsByPhase },
+    ...scriptCalls === void 0 ? {} : { scriptCalls },
     ...error === void 0 ? {} : { error },
     ...failedAt === void 0 ? {} : { failedAt },
     ...budget === void 0 ? {} : { budget },
@@ -1527,7 +1569,7 @@ async function listRunIds(cwd, sessionId, home = homedir2(), cleanTemps = true)
 
 // src/store.ts
 import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash2, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "node:crypto";
 import { access, mkdir as mkdir2, readdir as readdir3, readFile as readFile3, realpath, rename as rename3, rm as rm3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { dirname, join as join3, relative, resolve as resolve2, sep } from "node:path";
@@ -1725,7 +1767,7 @@ var RunStore = class _RunStore {
     }
   }
   async appendSystemPromptV2(entry) {
-    const sha256 = createHash2("sha256").update(entry.prompt).digest("hex");
+    const sha256 = createHash3("sha256").update(entry.prompt).digest("hex");
     const bodyPath = join3(systemPromptBodiesPath(this.directory), sha256);
     try {
       await access(bodyPath);
@@ -1778,7 +1820,7 @@ var RunStore = class _RunStore {
       const sha256 = record3.sha256;
       if (typeof sessionId !== "string" || !sessionId || !positiveInteger(attempt) || !positiveInteger(turn) || typeof sha256 !== "string" || !/^[0-9a-f]{64}$/.test(sha256)) throw new Error("Persisted system-prompt record is invalid");
       const prompt = await readFile3(join3(systemPromptBodiesPath(this.directory), sha256), "utf8");
-      if (createHash2("sha256").update(prompt).digest("hex") !== sha256) throw new Error("Persisted system-prompt body is invalid");
+      if (createHash3("sha256").update(prompt).digest("hex") !== sha256) throw new Error("Persisted system-prompt body is invalid");
       entries.push({ sessionId, attempt, turn, sha256, prompt });
     }
     if (sequence < highest) throw new Error("Persisted system-prompt sequence is invalid");
@@ -1920,7 +1962,7 @@ var RunStore = class _RunStore {
     });
   }
   #worktreeKey(owner) {
-    return createHash2("sha256").update(`${this.sessionId}\0${this.runId}\0${owner}`).digest("hex").slice(0, 16);
+    return createHash3("sha256").update(`${this.sessionId}\0${this.runId}\0${owner}`).digest("hex").slice(0, 16);
   }
   expectedWorktree(owner) {
     const key = this.#worktreeKey(owner);
@@ -2391,7 +2433,7 @@ function workflowSettingsPath(agentDir = getAgentDir()) {
   return join4(agentDir, ROLE_DIRECTORY, "settings.json");
 }
 function normalizedResourcePath(value, settingsPath) {
-  if (value === "*") return value;
+  if (value === "*" || value.startsWith("builtin:")) return value;
   let expanded = value === "~" ? homedir4() : value.startsWith("~/") || value.startsWith("~\\") ? join4(homedir4(), value.slice(2)) : value;
   if (expanded.startsWith("file://")) expanded = fileURLToPath(expanded);
   const resolved = resolve3(dirname2(settingsPath), expanded);
@@ -2503,7 +2545,7 @@ function parseSettings(path, partial) {
     fail("CONFIG_ERROR", `Invalid workflow settings JSON at ${path}: ${errorText(error)}`);
   }
   if (!object(parsed)) fail("INVALID_SETTINGS", `Workflow settings at ${path} must be an object`);
-  const allowed = /* @__PURE__ */ new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...partial ? [] : ["backgroundWidget"]]);
+  const allowed = /* @__PURE__ */ new Set(["concurrency", "modelAliases", "skills", "extensions", "extensionSettings", "tools", "retention", "worktreePostCreateCommand", ...partial ? [] : ["backgroundWidget", "codemodeTools"]]);
   const unknown = Object.keys(parsed).find((key) => !allowed.has(key));
   if (Object.prototype.hasOwnProperty.call(parsed, "disabledAgentResources")) fail("INVALID_SETTINGS", `disabledAgentResources is no longer supported; use skills, extensions, and tools selectors (settings: ${path})`);
   if (unknown) fail("INVALID_SETTINGS", `Unknown workflow setting at ${path}: ${unknown}`);
@@ -2511,6 +2553,8 @@ function parseSettings(path, partial) {
   if (concurrency !== void 0 && (!positiveInteger(concurrency) || concurrency > 16)) fail("INVALID_SETTINGS", `${path}.concurrency must be an integer from 1 to 16`);
   const backgroundWidget = parsed.backgroundWidget === void 0 ? partial ? void 0 : DEFAULT_SETTINGS.backgroundWidget : parsed.backgroundWidget;
   if (backgroundWidget !== void 0 && typeof backgroundWidget !== "boolean") fail("INVALID_SETTINGS", `${path}.backgroundWidget must be a boolean`);
+  const codemodeTools = parsed.codemodeTools;
+  if (codemodeTools !== void 0 && codemodeTools !== "all" && codemodeTools !== "read-only" && codemodeTools !== "none") fail("INVALID_SETTINGS", `${path}.codemodeTools must be "all", "read-only", or "none"`);
   const modelAliases = parsed.modelAliases === void 0 ? void 0 : validateModelAliases(parsed.modelAliases, path);
   const skills = validateSelectorList(parsed.skills, path, "skills");
   const tools = validateSelectorList(parsed.tools, path, "tools");
@@ -2521,6 +2565,7 @@ function parseSettings(path, partial) {
   return Object.freeze({
     ...concurrency === void 0 ? {} : { concurrency },
     ...backgroundWidget === void 0 ? {} : { backgroundWidget },
+    ...codemodeTools === void 0 ? {} : { codemodeTools },
     ...modelAliases === void 0 ? {} : { modelAliases },
     ...skills === void 0 ? {} : { skills },
     ...extensions === void 0 ? {} : { extensions },
@@ -2533,6 +2578,18 @@ function parseSettings(path, partial) {
 function loadSettings(path = workflowSettingsPath()) {
   return parseSettings(path, false);
 }
+var READ_ONLY_WORKFLOW_TOOLS = /* @__PURE__ */ new Set(["workflow_status", "workflow_catalog", "subagents_inspect"]);
+function workflowToolExposure(name, codemodeTools) {
+  const readOnly = READ_ONLY_WORKFLOW_TOOLS.has(name);
+  return { ...codemodeTools === "none" || codemodeTools === "read-only" && !readOnly ? { exposure: "model-only" } : {}, ...readOnly ? { annotations: { readOnlyHint: true } } : {} };
+}
+function loadCodemodeToolsSetting(agentDir) {
+  try {
+    return loadSettings(workflowSettingsPath(agentDir)).codemodeTools;
+  } catch {
+    return void 0;
+  }
+}
 function loadSettingsOverrides(path) {
   return parseSettings(path, true);
 }
@@ -2607,7 +2664,7 @@ function saveModelAliases(path = workflowSettingsPath(), aliases = {}) {
 }
 
 // src/registry.ts
-var RESERVED_GLOBALS = /* @__PURE__ */ new Set(["agent", "shell", "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"]);
+var RESERVED_GLOBALS = /* @__PURE__ */ new Set(["agent", "shell", "tools", "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"]);
 var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
 var SEMVER = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 var PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
@@ -3127,7 +3184,7 @@ function loadAgentDefinitions(cwd, agentDir = getAgentDir2(), projectTrusted2 =
 function canonicalExtensionSelector(selector, base = process.cwd()) {
   const negated = selector.startsWith("!");
   const body = negated ? selector.slice(1) : selector;
-  if (body === "*" || body === "**" || body.startsWith("**/")) return selector;
+  if (body === "*" || body === "**" || body.startsWith("**/") || body.startsWith("builtin:")) return selector;
   const resolved = resolve4(base, body);
   if (resourcePatternHasMagic(body)) return `${negated ? "!" : ""}${resolved}`;
   return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
@@ -3188,7 +3245,7 @@ function resolveRole(name, options) {
     if (outsideRootTool) fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideRootTool}`);
   }
   const selectedSkills = resources.skills === void 0 ? void 0 : selectResourcesByLayers(selectorLayers.skills, resources.skills);
-  const extensionResources = resources.extensions?.map((extension) => canonicalPath(extension));
+  const extensionResources = resources.extensions?.map((extension) => extensionIdentity(extension));
   const selectedExtensions = extensionResources === void 0 ? void 0 : selectResourcesByLayers(selectorLayers.extensions, extensionResources);
   const unmatchedSkills = resources.skills === void 0 ? void 0 : unmatchedResourcePatterns(selectorLayers.skills.flatMap((layer) => layer ?? []), resources.skills);
   const unmatchedExtensions = extensionResources === void 0 ? void 0 : unmatchedResourcePatterns(selectorLayers.extensions.flatMap((layer) => layer ?? []), extensionResources);
@@ -3408,6 +3465,19 @@ function callHasTrailingComma(source, call) {
   }
   return current?.type.label === ")" && previous?.type.label === ",";
 }
+function scriptToolReferences(script) {
+  const body = workflowBody(script);
+  if (!body.trim()) return [];
+  const names = /* @__PURE__ */ new Set();
+  const opaque = (node, parent) => {
+    if (node.type === "Identifier" && node.name === "tools") {
+      if (parent?.type === "MemberExpression" && parent.object === node && !parent.computed && parent.property.type === "Identifier") names.add(parent.property.name);
+      else if (!(parent?.type === "Property" && parent.key === node && !parent.computed && !parent.shorthand || parent?.type === "MemberExpression" && parent.property === node && !parent.computed)) return true;
+    }
+    return astChildren(node).some((child) => opaque(child, node));
+  };
+  return opaque(parseWorkflow(body)) ? void 0 : [...names];
+}
 function instrumentWorkflow(script) {
   const body = workflowBody(script);
   if (!body.trim()) return body;
@@ -4013,6 +4083,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);
@@ -4073,7 +4167,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 } });
@@ -4117,6 +4211,13 @@ 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 };
+}
+function toolIdentityPath(identifier, args, identity) {
+  return structuralPath("tool", ...identity.structuralPath, identifier, `args:${jsonDigest(args)}`, String(identity.occurrence));
+}
 function agentHandleTurnPath(handle, turn) {
   return structuralPath("agent", "handle", handle, `turn:${String(turn)}`);
 }
@@ -4409,6 +4510,11 @@ function runWorkflow(script, args = null, bridge = {}, signal) {
           if (!OUTCOME_ERRORS.has(typed.code)) throw typed;
           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");
         value = await bridge.worktree(values[0], controller.signal);
@@ -4480,7 +4586,7 @@ import { basename as basename4, dirname as dirname5, join as join8, resolve as r
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
 import { Compile } from "typebox/compile";
-import { createAgentSession, DefaultPackageManager, DefaultResourceLoader, defineTool, getAgentDir as getAgentDir3, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createAgentSession, createCodemodeExtension, createMcpExtension, createToolSearchExtension, DefaultPackageManager, DefaultResourceLoader, defineTool, getAgentDir as getAgentDir3, ModelRuntime, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 
 // src/pi-runtime-adapter.ts
 var TURN_START_EVENTS = /* @__PURE__ */ new Set(["turn_start", "turn_started", "turnStarted"]);
@@ -5319,16 +5425,25 @@ 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 };
 }
-var extensionDirectory = dirname5(fileURLToPath3(import.meta.url));
-var workflowPackageRoot = basename4(dirname5(extensionDirectory)) === "dist" ? resolve6(extensionDirectory, "../..") : resolve6(extensionDirectory, "..");
-var WORKFLOW_HOST_ENTRIES = /* @__PURE__ */ new Set([
-  canonicalPath(resolve6(workflowPackageRoot, "src/index.ts")),
-  canonicalPath(resolve6(workflowPackageRoot, "dist/src/index.js")),
-  canonicalPath(resolve6(workflowPackageRoot, "starter/index.ts")),
-  canonicalPath(resolve6(workflowPackageRoot, "dist/starter/index.js")),
-  canonicalPath(resolve6(workflowPackageRoot, "subagents/index.ts")),
-  canonicalPath(resolve6(workflowPackageRoot, "dist/subagents/index.js"))
-]);
+var 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 packageRoot2 = dirname5(entryPath);
+  while (packageRoot2 !== dirname5(packageRoot2)) {
+    const packageMetadataPath = join8(packageRoot2, "package.json");
+    if (existsSync(packageMetadataPath)) {
+      try {
+        const metadata = JSON.parse(readFileSync5(packageMetadataPath, "utf8"));
+        if (typeof metadata !== "object" || metadata === null || !("name" in metadata) || !isCorePackageName(metadata.name)) return false;
+        return WORKFLOW_HOST_ENTRY_PATHS.some((entry) => canonicalPath(join8(packageRoot2, entry)) === entryPath);
+      } catch {
+        return false;
+      }
+    }
+    packageRoot2 = dirname5(packageRoot2);
+  }
+  return false;
+}
 var WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 function workflowSystemPromptPath(cwd, agentDir, projectTrusted2) {
   const projectPath = join8(cwd, ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md");
@@ -5361,33 +5476,40 @@ function loadPiPackageDirectory() {
     }
   }).catch((error) => ({ error: `could not load @earendil-works/pi-coding-agent package metadata: ${errorText(error)}` }));
 }
-var nativePromptTemplateModule;
-async function loadNativePromptTemplateModule() {
+var nativeCoreModules = /* @__PURE__ */ new Map();
+async function loadNativeCoreModule(file, label) {
   const packageDirectory = await loadPiPackageDirectory();
-  let promptTemplatePath;
+  let modulePath;
   if (packageDirectory.directory) {
-    const candidate = resolve6(packageDirectory.directory, "dist/core/prompt-templates.js");
-    if (existsSync(candidate)) promptTemplatePath = candidate;
+    const candidate = resolve6(packageDirectory.directory, "dist/core", file);
+    if (existsSync(candidate)) modulePath = candidate;
   }
-  promptTemplatePath ??= resolve6(dirname5(fileURLToPath3(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core/prompt-templates.js");
+  modulePath ??= resolve6(dirname5(fileURLToPath3(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 === void 0) diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: base system prompt options are missing", source: "Pi session" });
   if (typeof expandSkillCommand !== "function") diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: skill expansion is missing", source: "Pi session" });
   if (!Array.isArray(templates)) diagnostics.push({ type: "error", message: "Pi prompt inspection seam is unavailable: prompt templates are missing", source: "Pi session" });
@@ -5412,9 +5534,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 !== void 0 ? await runner.emitBeforeAgentStart(expandedPrompt, void 0, baseSystemPrompt, baseOptions) : void 0;
+    const result = !inputHandled && runner && baseOptions !== void 0 ? await runner.emitBeforeAgentStart(expandedPrompt, void 0, baseOptions) : void 0;
     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 === void 0 ? baseSystemPrompt : await buildSystemPromptForInspection(prepared.systemPromptOptions);
+    return { prompt: text, expandedPrompt, systemPrompt, systemPromptOptions, messages: prepared?.messages ?? [], inputHandled, diagnostics };
   } finally {
     unsubscribe?.();
   }
@@ -5443,6 +5567,17 @@ function flushExtensionProviders(resourceLoader, modelRuntime) {
   runtime.pendingNativeProviderRegistrations = [];
   return failures;
 }
+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 }
+  ];
+}
+var BUILTIN_EXTENSION_PREFIX = "builtin:";
+function isLlamaModel(model) {
+  return model.provider === "llama.cpp";
+}
 async function createLocalPiSessionHandle(input, sessionStartEvent) {
   const agentDir = input.agentDir ?? getAgentDir3();
   const systemPromptSource = workflowSystemPromptPath(input.cwd, agentDir, input.resourcePolicy?.projectTrusted ?? true);
@@ -5455,13 +5590,16 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
   const tools = [.../* @__PURE__ */ 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(void 0, {
       cwd: input.cwd,
@@ -5469,7 +5607,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))];
@@ -5489,7 +5627,7 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
       additionalExtensionPaths: extensionPaths,
       noSkills: true,
       additionalSkillPaths: [.../* @__PURE__ */ new Set([...skillPaths, ...input.additionalSkillPaths ?? []])],
-      ...input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {},
+      extensionFactories,
       ...contextFilesOverride ? { agentsFilesOverride: contextFilesOverride } : {},
       skillsOverride: (base) => {
         const disabledSkills = updateSkillMatches(base.skills);
@@ -5501,17 +5639,17 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     await resourceLoader.reload();
   } 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);
   await modelRuntime.refresh({ allowNetwork: false });
   const model = modelRuntime.getModel(input.model.provider, input.model.model);
   if (!model) {
-    const because = providerFailures.length > 0 ? ` (provider registration failed \u2014 ${providerFailures.join("; ")})` : "";
+    const because = providerFailures.length > 0 ? ` (provider registration failed \u2014 ${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 === void 0 && sessionStartEvent === void 0 ? void 0 : { ...sessionStartEvent ?? { type: "session_start", reason: "startup" }, settings: input.settings ?? Object.freeze({}) };
@@ -5536,13 +5674,13 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     await shutdown("quit").catch(() => void 0);
     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() !== void 0 ? { 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() !== void 0 ? { systemPromptSource: "Pi resource loader" } : {} };
   };
   const managedSession = Object.assign(session, {
     getLeafId: () => manager.getLeafId(),
@@ -6204,7 +6342,7 @@ var WorkflowAgentExecutor = class {
       ...options.contextFiles === void 0 ? {} : { contextFiles: options.contextFiles },
       ...options.effectiveTools === void 0 ? {} : { effectiveTools: options.effectiveTools }
     });
-    return { model: resolved.model ?? this.root.model, ...resolved.requestedModel === void 0 ? {} : { requestedModel: resolved.requestedModel }, tools: resolved.tools ?? [], ...resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}, systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...resolved.contextFiles === void 0 ? {} : { contextFiles: resolved.contextFiles } };
+    return { model: physicalModel(resolved.model ?? this.root.model, this.root.modelAliases, this.root.knownModels, this.root.settingsPath), ...resolved.requestedModel === void 0 ? {} : { requestedModel: resolved.requestedModel }, tools: resolved.tools ?? [], ...resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}, systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...resolved.contextFiles === void 0 ? {} : { contextFiles: resolved.contextFiles } };
   }
   async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
     const executionSignal = signal ?? this.root.runContext?.signal;
@@ -6633,6 +6771,7 @@ var FairAgentScheduler = class {
       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");
         validateAgentOptions(params);
@@ -6643,7 +6782,7 @@ var FairAgentScheduler = class {
         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 === void 0 ? {} : { schema: outputSchema }, ...params.retries === void 0 ? {} : { retries: params.retries }, ...params.timeoutMs === void 0 ? {} : { 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({
@@ -6651,10 +6790,11 @@ var FairAgentScheduler = class {
       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 };
+        return { content: [{ type: "text", text: JSON.stringify(value) }], details: value, structuredContent: value };
       }
     });
     const steerTool = defineTool({
@@ -7257,6 +7397,7 @@ var 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}.`,
@@ -7547,7 +7688,7 @@ function persistedFailure(run, error) {
   return { ...run, error: { code: error.code, message: error.message, ...failedAt ? { failedAt } : {} }, ...failedAt ? { failedAt } : {} };
 }
 function createWorkflowRecovery(deps) {
-  const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted: projectTrusted2, resumeHostContext: resumeHostContext2, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy: frozenResourcePolicy2, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver: deliver2, deliverTerminal, workflowToolUpdate: workflowToolUpdate2, registry, modelSpec: modelSpec2 } = deps;
+  const { pi, home, runs, scheduler, eventPublisher, persistRunState, projectTrusted: projectTrusted2, resumeHostContext: resumeHostContext2, ensureSessionLease, createAgentExecutor, activeSnapshotTools, frozenResourcePolicy: frozenResourcePolicy2, resolveLaunchPrologue, resumeRoles, workflowAgentHandler, shellForRun, toolForRun, resolveWorktree, checkpointBridge, phaseBridge, logBridge, lifecycleFor, createProviderErrorRecovery, cleanupTerminalRun, deliver: deliver2, deliverTerminal, workflowToolUpdate: workflowToolUpdate2, registry, modelSpec: modelSpec2 } = 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) => {
@@ -7619,7 +7760,7 @@ 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 : void 0), 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 : void 0), 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);
@@ -7818,7 +7959,7 @@ function createWorkflowRecovery(deps) {
       await eventPublisher.runStarted(prepared.childRun.store, prepared.childRun.metadata);
       const { hasUI, ui } = recoveryUi(context);
       const recoveryContext = resumeHostContext2(context);
-      const completed = await coldResumeRun(prepared.childRun, hasUI, ui, projectTrusted2(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, projectTrusted2(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;
@@ -9131,6 +9272,15 @@ function formatShellActivity(activeShells, startedAt, spinner2, styles, now) {
   const timing = started && startedAt !== void 0 && !Number.isNaN(started.getTime()) ? ` ${styles.dim(`started=${started.toISOString()} elapsed=${formatWorkflowRuntime(Math.max(0, now - startedAt))}`)}` : "";
   return `${styles.accent(spinner2)} shell ${styles.accent("[running]")} ${styles.dim(`(${String(count)} active)`)}${timing}`;
 }
+function formatToolActivity(run, spinner2, styles, now) {
+  const calls = run.activeTools ?? [];
+  if (!calls.length) return void 0;
+  const counts = /* @__PURE__ */ new Map();
+  for (const { name } of calls) counts.set(name, (counts.get(name) ?? 0) + 1);
+  const names = [...counts].map(([name, count]) => count > 1 ? `${name} \xD7${String(count)}` : name).join(", ");
+  const elapsed = formatWorkflowRuntime(Math.max(0, now - Math.min(...calls.map(({ startedAt }) => startedAt))));
+  return `${styles.accent(spinner2)} tools ${styles.accent("[running]")} ${sanitizeDisplayText(names)} ${styles.dim(`elapsed=${elapsed}`)}`;
+}
 function formatLogTimestamp(timestamp) {
   if (timestamp === void 0 || !Number.isFinite(timestamp)) return "--:--:--";
   const date = new Date(timestamp);
@@ -9211,12 +9361,15 @@ function workflowProgressLines(run, spinner2, styles, now, expanded, width, show
   const scopedShells = (run.activeShellsByPhase?.length ?? 0) > 0;
   const shellActivity = scopedShells ? void 0 : formatShellActivity(run.activeShells, run.activeShellStartedAt, spinner2, styles, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
+  const toolActivity = formatToolActivity(run, spinner2, styles, now);
+  if (toolActivity) lines.push(`  ${toolActivity}`);
   const byId = new Map(run.agents.map((agent) => [agent.id, agent]));
   const position = new Map(run.agents.map((agent, index) => [agent, index]));
   const renderAgents = (agents, nested2) => renderGroupedAgents(agents, ({ agent, depth }, grouped) => {
-    const icon = agentStateGlyph(agent.state, spinner2);
+    const icon = agentStateGlyph(agent.state, "\u25CF");
     const indent = "  ".repeat((grouped ? 2 : 1) + depth);
-    const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : formatAgentActivity(agent, spinner2, styles, now);
+    const idleSpinner = agent.state === "running" && !agentActivityLabel(agent) ? styles.accent(spinner2) : "";
+    const activity = SETTLED_AGENT_STATES.has(agent.state) ? "" : [idleSpinner, formatAgentActivity(agent, spinner2, styles, now)].filter(Boolean).join(" ");
     const name = grouped ? agent.label ?? agent.name : styledAgentBreadcrumb(agent, byId, styles);
     const state2 = progressStyleForState(agent.state, styles);
     const detail = expanded ? formatWorkflowAgentDetail(agent, now) : "";
@@ -9514,7 +9667,7 @@ ${progressText}` : progressText, width);
     invalidate() {
       const displayed = currentRun();
       const now = Date.now();
-      if (!progress || !refresh || displayed.state !== "running" || !displayed.agents.some((agent) => agent.state === "running") && (displayed.activeShells ?? 0) <= 0) return;
+      if (!progress || !refresh || displayed.state !== "running" || !displayed.agents.some((agent) => agent.state === "running") && (displayed.activeShells ?? 0) <= 0 && !displayed.activeTools?.length) return;
       if (progress.refresh || now - progress.lastRefreshAt < WORKFLOW_PROGRESS_REFRESH_MS) return;
       progress.lastRefreshAt = now;
       const inputRun = progress.inputRun;
@@ -9727,6 +9880,8 @@ function formatNavigatorDashboard(run, checkpoints, worktrees, now = Date.now())
   const lines = [header, meta, ...formatCompactBudgetStatus(run)];
   const shellActivity = formatShellActivity(run.activeShells, run.activeShellStartedAt, "\u2826", PLAIN_WORKFLOW_PROGRESS_STYLES, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
+  const toolActivity = formatToolActivity(run, "\u2826", PLAIN_WORKFLOW_PROGRESS_STYLES, now);
+  if (toolActivity) lines.push(`  ${toolActivity}`);
   if (run.error) lines.push(`Error: ${run.error.code}: ${run.error.message}`);
   if (run.events?.length) lines.push(...run.events.filter((event) => event.type === "warning").map((event) => `Warning: ${event.message}`));
   lines.push("");
@@ -9766,6 +9921,8 @@ function formatNavigatorRun(loaded, checkpoints, worktrees, now = Date.now()) {
   ];
   const shellActivity = formatShellActivity(run.activeShells, run.activeShellStartedAt, "\u2826", PLAIN_WORKFLOW_PROGRESS_STYLES, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
+  const toolActivity = formatToolActivity(run, "\u2826", PLAIN_WORKFLOW_PROGRESS_STYLES, now);
+  if (toolActivity) lines.push(`  ${toolActivity}`);
   if (run.error) lines.push(`Run error: ${run.error.code}: ${run.error.message}`);
   if (run.events?.length) lines.push(...run.events.filter((event) => event.type === "warning").map((event) => `Warning: ${event.message}`));
   const aliases = snapshot.modelAliases ?? snapshot.settings.modelAliases;
@@ -9865,6 +10022,8 @@ function formatWorkflowPhaseDashboard(run, snapshot, width, selection = {}, styl
   const scopedShells = (run.activeShellsByPhase?.length ?? 0) > 0;
   const shellActivity = scopedShells ? void 0 : formatShellActivity(run.activeShells, run.activeShellStartedAt, "\u2826", styles, now);
   if (shellActivity) lines.push(`  ${shellActivity}`);
+  const toolActivity = formatToolActivity(run, "\u2826", styles, now);
+  if (toolActivity) lines.push(`  ${toolActivity}`);
   const actionRows = () => {
     const actions = selection.actions;
     if (!actions) return [];
@@ -11101,6 +11260,66 @@ Mutations are available through workflow tools.`, "info");
   });
 }
 
+// src/script-tools.ts
+function scriptToolExcluded(name) {
+  return name === "workflow" || name.startsWith("workflow_") || name.startsWith("subagents_");
+}
+function scriptToolIdentifier(name) {
+  let identifier = "";
+  for (const char of name) identifier += (identifier === "" ? /^[A-Za-z_$]$/ : /^[A-Za-z0-9_$]$/).test(char) ? char : "_";
+  return identifier || "_";
+}
+function scriptToolContext(ctx) {
+  return object(ctx) && typeof ctx.executeTool === "function" && Array.isArray(ctx.tools) ? ctx : void 0;
+}
+function scriptToolIdentifiers(context) {
+  return (context?.tools ?? []).filter(({ name }) => !scriptToolExcluded(name)).map(({ name }) => scriptToolIdentifier(name));
+}
+function scriptTool(context, identifier) {
+  return context.tools.find(({ name }) => !scriptToolExcluded(name) && scriptToolIdentifier(name) === identifier);
+}
+function scriptToolValue(tool, outcome) {
+  const structured = tool.outputSchema === void 0 ? void 0 : outcome.result.structuredContent;
+  const text = outcome.result.content.flatMap((item) => item.type === "text" ? [item.text] : []).join("\n");
+  if (structured === void 0 && outcome.isError) throw new WorkflowError("TOOL_FAILED", `${tool.name}: ${text || "failed"}`);
+  let value;
+  try {
+    value = JSON.parse(JSON.stringify(structured ?? text));
+  } catch (error) {
+    throw new WorkflowError("TOOL_FAILED", `${tool.name} returned a result that is not JSON: ${errorText(error)}`);
+  }
+  if (!jsonValue(value)) throw new WorkflowError("TOOL_FAILED", `${tool.name} returned a result that is not JSON`);
+  if (Buffer.byteLength(JSON.stringify(value)) > RPC_LIMIT_BYTES) throw new WorkflowError("TOOL_FAILED", `${tool.name} returned more than the 10 MB workflow RPC limit`);
+  return value;
+}
+function validateScriptToolReferences(script, context) {
+  const references = scriptToolReferences(script);
+  if (!references?.length) return;
+  if (!context) throw new WorkflowError("UNKNOWN_TOOL", `Workflow scripts can call session tools only when launched by the workflow tool; this launch has none for ${references.map((name) => `tools.${name}`).join(", ")}`);
+  const identifiers = scriptToolIdentifiers(context);
+  const unknown = references.filter((name) => !identifiers.includes(name));
+  if (unknown.length) throw new WorkflowError("UNKNOWN_TOOL", `Workflow script calls tools this session cannot call: ${unknown.map((name) => `tools.${name}`).join(", ")}`);
+  const ambiguous = references.filter((name) => identifiers.indexOf(name) !== identifiers.lastIndexOf(name));
+  if (ambiguous.length) throw new WorkflowError("UNKNOWN_TOOL", `Workflow script calls tools whose names collide after normalization: ${ambiguous.map((name) => `tools.${name}`).join(", ")}`);
+}
+function describeScriptOutput(schema) {
+  if (!object(schema) || schema.type !== "object" || !object(schema.properties)) return schema === void 0 ? void 0 : "a JSON value";
+  const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+  return `\`{ ${Object.keys(schema.properties).map((name) => required.has(name) ? name : `${name}?`).join(", ")} }\``;
+}
+function prepareScriptToolLoadout(loadout) {
+  if (loadout.declared.some(({ name }) => name === "codemode")) return void 0;
+  const callable = new Set(loadout.callable.map(({ name }) => name));
+  const descriptions = {};
+  for (const tool of loadout.declared) {
+    const output = callable.has(tool.name) && !scriptToolExcluded(tool.name) ? describeScriptOutput(tool.outputSchema) : void 0;
+    if (output) descriptions[tool.name] = `${tool.description.trim()}
+
+Workflow scripts: \`tools.${scriptToolIdentifier(tool.name)}(args)\` resolves to ${output}.`;
+  }
+  return { descriptions };
+}
+
 // src/changelog.ts
 import { mkdir as mkdir3, readFile as readFile6 } from "node:fs/promises";
 import { dirname as dirname6, join as join14 } from "node:path";
@@ -11202,7 +11421,7 @@ async function showChangelogNotice(context, agentDir, packageDirectory) {
 }
 
 // src/trajectory.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { open as open2, readFile as readFile7, readdir as readdir5, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
 import { basename as basename5, dirname as dirname7, join as join15, resolve as resolve8 } from "node:path";
@@ -11234,7 +11453,8 @@ var SUBAGENTS_RUN_PARAMETERS = Type2.Object({
   timeoutMs: Type2.Optional(Type2.Union([Type2.Integer({ minimum: 1, description: "Optional execution timeout in milliseconds" }), Type2.Null()]))
 }, { additionalProperties: false });
 var SUBAGENTS_INSPECT_PARAMETERS = Type2.Object({
-  id: Type2.Optional(Type2.String({ description: "Subagent ID; omit to list ordered run summaries" }))
+  id: Type2.Optional(Type2.String({ description: "Subagent ID; omit to list ordered run summaries" })),
+  scope: Type2.Optional(Type2.Union([Type2.Literal("session"), Type2.Literal("all")], { description: "List scope when id is omitted: session (default) lists runs from the current Pi session; all lists every stored run" }))
 }, { additionalProperties: false });
 var SUBAGENTS_ID_PARAMETERS = Type2.Object({
   id: Type2.String({ description: "Subagent ID" })
@@ -11249,6 +11469,21 @@ var SUBAGENTS_STOP_PARAMETERS = Type2.Object({
 var SUBAGENTS_RETRY_PARAMETERS = Type2.Object({
   id: Type2.String({ description: "Failed or stopped subagent ID to retry" })
 }, { additionalProperties: false });
+var SUBAGENT_STATUS_OUTPUT = Type2.Object({
+  id: Type2.String(),
+  state: Type2.String(),
+  sessionId: Type2.Optional(Type2.String()),
+  startedAt: Type2.Optional(Type2.Number()),
+  finishedAt: Type2.Optional(Type2.Number()),
+  attempts: Type2.Optional(Type2.Number()),
+  attemptDetails: Type2.Optional(Type2.Array(Type2.Unknown())),
+  worktree: Type2.Optional(Type2.Object({ path: Type2.String(), branch: Type2.String() })),
+  error: Type2.Optional(Type2.Object({ code: Type2.String(), message: Type2.String() })),
+  progress: Type2.Optional(Type2.Unknown()),
+  value: Type2.Optional(Type2.Unknown())
+});
+var SUBAGENTS_INSPECT_OUTPUT = Type2.Union([SUBAGENT_STATUS_OUTPUT, Type2.Array(Type2.Object({ id: Type2.String(), state: Type2.String() }))]);
+var SUBAGENTS_STEER_OUTPUT = Type2.Object({ id: Type2.String(), accepted: Type2.Boolean() });
 function normalizeSubagentRunRequest(value) {
   if (!Value2.Check(SUBAGENTS_RUN_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", "Invalid subagents_run parameters");
   if (typeof value.worktree === "string" && !value.worktree.trim()) throw new WorkflowError("INVALID_METADATA", "worktree name must be a non-empty string");
@@ -11451,7 +11686,7 @@ function transcriptToolCallId(value) {
   return void 0;
 }
 function isTimingTranscriptEntry(value) {
-  return object(value) && value.type === "custom" && value.customType === "pi-workflows:tool-timing";
+  return object(value) && value.type === "custom" && value.customType === TOOL_TIMING_ENTRY_TYPE;
 }
 function timingToolCallId(value) {
   if (!object(value) || !isTimingTranscriptEntry(value) || !object(value.data)) return void 0;
@@ -11572,7 +11807,7 @@ function withPiToolDescriptions(run) {
 function canonicalExtensionSelector2(selector, base) {
   const negated = selector.startsWith("!");
   const body = negated ? selector.slice(1) : selector;
-  if (body === "*" || body === "**" || body.startsWith("**/")) return selector;
+  if (body === "*" || body === "**" || body.startsWith("**/") || body.startsWith("builtin:")) return selector;
   const resolved = resolve8(base, body);
   if (resourcePatternHasMagic(body)) return `${negated ? "!" : ""}${resolved}`;
   return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
@@ -11647,11 +11882,17 @@ function failedAgentOutput(agent) {
   const status = agent.state === "cancelled" ? "cancelled" : "failed";
   return { status, code: error?.code ?? (status === "cancelled" ? "CANCELLED" : "AGENT_FAILED"), message: error?.message ?? `Agent ${agent.state}` };
 }
+function operationOutput(operation) {
+  const bytes = serializedJsonBytes(operation.value);
+  return bytes > DEFAULT_MAX_BYTES2 ? { status: "truncated", kind: "result", bytes } : { status: "available", value: operation.value, bytes };
+}
+function outputForCall(call, operation) {
+  if (operation !== void 0) return call.kind === "tool" ? { status: "completed" } : operationOutput(operation);
+  if (call.error) return { status: call.error.code === "CANCELLED" ? "cancelled" : "failed", code: call.error.code, ...call.kind === "shell" ? { message: call.error.message ?? "Shell failed" } : {} };
+  return call.finishedAt === void 0 ? { status: "pending" } : { status: "unavailable" };
+}
 function outputForAgent(agent, operation) {
-  if (operation !== void 0) {
-    const bytes = serializedJsonBytes(operation.value);
-    return bytes > DEFAULT_MAX_BYTES2 ? { status: "truncated", kind: "result", bytes } : { status: "available", value: operation.value, bytes };
-  }
+  if (operation !== void 0) return operationOutput(operation);
   if (agent.state === "failed" || agent.state === "cancelled") return failedAgentOutput(agent);
   if (agent.state === "completed") return { status: "unavailable" };
   return { status: "pending" };
@@ -11659,7 +11900,17 @@ function outputForAgent(agent, operation) {
 function applyTrajectoryAgentOutputs(run, operations) {
   const byPath = new Map(operations.map((operation) => [operation.path, operation]));
   const agents = run.agents.map((agent) => ({ ...agent, output: outputForAgent(agent, agent.resultPath === void 0 ? void 0 : byPath.get(agent.resultPath)) }));
-  return { ...run, agents };
+  const scriptCalls = run.scriptCalls?.map((call) => {
+    const recorded = { ...call, output: outputForCall(call, byPath.get(call.path)) };
+    if (call.kind === "tool") {
+      delete recorded.input;
+      delete recorded.inputBytes;
+      if (call.error) recorded.error = { code: call.error.code };
+    }
+    return recorded;
+  });
+  const rest = run;
+  return { ...rest, agents, ...scriptCalls === void 0 ? {} : { scriptCalls } };
 }
 function overlayTrajectoryRun(run, overlay) {
   const overlaid = overlay(run);
@@ -11669,7 +11920,7 @@ function overlayTrajectoryRun(run, overlay) {
     const output = previous?.status === "available" || previous?.status === "truncated" ? previous : outputForAgent(agent, void 0);
     return { ...agent, output };
   });
-  return { ...overlaid, agents };
+  return { ...overlaid, agents, ...run.scriptCalls === void 0 ? {} : { scriptCalls: run.scriptCalls } };
 }
 async function loadTrajectoryRun(store, includeTranscripts = true) {
   const value = await store.load();
@@ -11719,7 +11970,7 @@ function createTrajectoryRunLoader(cwd, sessionId, home = homedir7(), overlay) {
   return createCachedRunLoader(cwd, sessionId, home, (store) => loadTrajectoryRun(store), fileMtime, overlay);
 }
 function transcriptRevision(info) {
-  const digest = createHash3("sha256").update(`${String(info.mtimeNs)}:${String(info.size)}`).digest();
+  const digest = createHash4("sha256").update(`${String(info.mtimeNs)}:${String(info.size)}`).digest();
   return Math.max(1, digest.readUIntBE(0, 6));
 }
 async function transcriptMetadata(path) {
@@ -12002,6 +12253,12 @@ function mainAgentError(error) {
   Object.assign(presented, typed);
   return presented;
 }
+function completionControlValue(result, controlRunId) {
+  const record3 = { ...controlRunId === void 0 ? {} : { runId: controlRunId }, ...result };
+  delete record3.run;
+  delete record3.completion;
+  return record3;
+}
 function completionControlContent(result, controlRunId) {
   const record3 = object(result) ? { ...result } : void 0;
   if (record3 && controlRunId !== void 0 && record3.runId === void 0) record3.runId = controlRunId;
@@ -12047,7 +12304,7 @@ function formatWorkflowPreview(args) {
   return [`workflow ${name}`, typeof args.description === "string" && args.description.trim() ? args.description.trim() : ""].filter(Boolean).join("\n");
 }
 var WORKFLOW_TOOL_LABEL = "Workflow";
-var WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed parallel-to-summary path by default";
+var WORKFLOW_TOOL_DESCRIPTION = "Run a deterministic JavaScript workflow with a named inline or file-backed parallel-to-summary path by default. Scripts call this session's tools as `await tools.<name>(args)`, outside withWorktree: a tool resolves to its text unless its description gives a `tools.<name>(args)` result shape, and failures reject";
 var 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. Provide exactly one of script or scriptPath and a non-empty name. Registered catalog functions are available as globals inside the script; call them there, for example return await someFunction(args). Advanced controls include registered functions, outputSchema, budgets, checkpoints, worktrees, retry/resume, CLI export, and pipelines. 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. Manage runs from the interactive /workflow picker; use workflow_status, workflow_resume, workflow_retry, workflow_stop, and workflow_respond for explicit tool controls. 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 and delivers completion or failure as a follow-up. After failure follow-ups, especially CANCELLED or interrupted runs, call workflow_status({ runId }) before recovery or replacement work, then pass its state as expectedState to workflow_retry/workflow_resume so recovery cannot act on a state that changed. Recovery map: agent(..., { retries }) reruns one agent call in the same run for transient failures; workflow_retry({ runId, expectedState?, foreground? }) replays a failed run into a child; workflow_resume({ runId, expectedState?, budget?, foreground? }) continues a budget_exhausted run; parentRunId on a new launch only borrows named worktrees and never replays or resumes.";
 var WORKFLOW_TOOL_PARAMETERS = Type3.Object({
   name: Type3.String({ description: "Required non-empty workflow name" }),
@@ -12062,6 +12319,19 @@ var WORKFLOW_TOOL_PARAMETERS = Type3.Object({
 }, { additionalProperties: false });
 var WORKFLOW_STATUS_PARAMETERS = Type3.Object({ runId: Type3.String({ description: "Workflow run ID visible in the current project" }) }, { additionalProperties: false });
 var WORKFLOW_RETRY_PARAMETERS = Type3.Object({ runId: Type3.String({ description: "Explicit failed workflow run ID" }), expectedState: Type3.Optional(Type3.String({ description: "Persisted source state observed before recovery" })), foreground: Type3.Optional(Type3.Boolean({ description: "Override the source launch mode for this recovery" })) });
+var WORKFLOW_ERROR_OUTPUT = Type3.Object({ code: Type3.String(), message: Type3.String() });
+var WORKFLOW_LAUNCH_OUTPUT = Type3.Object({ runId: Type3.String(), state: Type3.String(), detached: Type3.Optional(Type3.Boolean()), value: Type3.Optional(Type3.Unknown()) });
+var WORKFLOW_STATUS_OUTPUT = Type3.Object({ runId: Type3.String(), workflowName: Type3.String(), state: Type3.String(), error: Type3.Optional(WORKFLOW_ERROR_OUTPUT), failedAt: Type3.Optional(Type3.String()), budget: Type3.Optional(Type3.Unknown()), usage: Type3.Optional(Type3.Unknown()), phase: Type3.Optional(Type3.String()), delivery: Type3.Optional(Type3.Object({ mode: Type3.String(), state: Type3.String() })), agents: Type3.Array(Type3.Object({ id: Type3.String(), label: Type3.Optional(Type3.String()), path: Type3.String(), state: Type3.String(), lastEventAt: Type3.Optional(Type3.Number()), accounting: Type3.Optional(Type3.Unknown()) })) });
+var WORKFLOW_STOP_OUTPUT = Type3.Object({ runId: Type3.String(), state: Type3.String(), stopped: Type3.Boolean(), reason: Type3.Optional(Type3.String()) });
+var WORKFLOW_RECOVERY_OUTPUT = Type3.Object({ state: Type3.String(), runId: Type3.Optional(Type3.String()), parentRunId: Type3.Optional(Type3.String()), proposalId: Type3.Optional(Type3.String()), value: Type3.Optional(Type3.Unknown()) });
+var WORKFLOW_RESPOND_OUTPUT = Type3.Object({ state: Type3.String(), approved: Type3.Boolean(), reason: Type3.String(), accepted: Type3.Optional(Type3.Boolean()), runId: Type3.Optional(Type3.String()), value: Type3.Optional(Type3.Unknown()) });
+var WORKFLOW_CATALOG_ALIAS_OUTPUT = Type3.Object({ name: Type3.String(), kind: Type3.String(), provenance: Type3.String(), version: Type3.Optional(Type3.String()), headline: Type3.Optional(Type3.String()) });
+var WORKFLOW_CATALOG_OUTPUT = Type3.Union([
+  Type3.Object({ functions: Type3.Array(Type3.Object({ name: Type3.String(), description: Type3.String(), input: Type3.Unknown() })), modelAliasEntries: Type3.Optional(Type3.Array(WORKFLOW_CATALOG_ALIAS_OUTPUT)), settings: Type3.Optional(Type3.Unknown()) }),
+  Type3.Object({ name: Type3.String(), version: Type3.String(), headline: Type3.String(), description: Type3.String(), input: Type3.Unknown(), output: Type3.Unknown() }),
+  WORKFLOW_CATALOG_ALIAS_OUTPUT,
+  Type3.Object({ error: Type3.Object({ code: Type3.String(), name: Type3.String(), message: Type3.String() }) })
+]);
 function workflowToolUpdate(run) {
   const done = run.agents.filter((agent) => SETTLED_AGENT_STATES.has(agent.state)).length;
   return { content: [{ type: "text", text: `Workflow: ${run.workflowName} (${String(done)}/${String(run.agents.length)} done) [${run.state}]` }], details: { runId: run.id, run } };
@@ -12144,7 +12414,42 @@ function modelInventory(root, registry) {
 }
 function resumeHostContext(ctx) {
   const model = object(ctx) && object(ctx.model) && typeof ctx.model.provider === "string" && typeof ctx.model.id === "string" ? { provider: ctx.model.provider, id: ctx.model.id } : void 0;
-  return { model, modelRegistry: contextHostCapabilities(ctx).modelRegistry, deliveryContext: completionContext(ctx) };
+  return { model, modelRegistry: contextHostCapabilities(ctx).modelRegistry, deliveryContext: completionContext(ctx), toolContext: scriptToolContext(ctx) };
+}
+var SCRIPT_CALL_TEXT_LIMIT_BYTES = 16 * 1024;
+function scriptCallInput(input) {
+  const text = JSON.stringify(input);
+  const bytes = Buffer.byteLength(text);
+  return bytes <= SCRIPT_CALL_TEXT_LIMIT_BYTES ? { input } : { input: utf8Prefix(text, SCRIPT_CALL_TEXT_LIMIT_BYTES), inputBytes: bytes };
+}
+function startScriptCall(run, call) {
+  const recorded = { ...call, ...run.phase === void 0 ? {} : { phase: run.phase } };
+  const calls = run.scriptCalls ?? [];
+  return { ...run, scriptCalls: calls.some(({ path }) => path === call.path) ? calls.map((current) => current.path === call.path ? recorded : current) : [...calls, recorded] };
+}
+function finishScriptCall(run, path, error) {
+  const finishedAt = Date.now();
+  return { ...run, scriptCalls: (run.scriptCalls ?? []).map((call) => call.path === path ? { ...call, finishedAt, ...error ? { error: { code: error.code, ...call.kind === "shell" ? { message: utf8Prefix(error.message, SCRIPT_CALL_TEXT_LIMIT_BYTES) } : {} } } : {} } : call) };
+}
+function registerAliasVirtualModels(pi, names, settingsPath) {
+  const register = object(pi) ? asFn(pi.registerVirtualModel) : void 0;
+  if (!register) return;
+  for (const name of names) {
+    const definition = {
+      provider: VIRTUAL_MODEL_PROVIDER,
+      id: name,
+      name: `${name} (workflow alias)`,
+      thinkingLevels: THINKING_LEVELS,
+      route: (request, ctx) => {
+        const aliases = resolveWorkflowSettings(ctx.cwd, projectTrusted(ctx), settingsPath).effective.modelAliases ?? {};
+        const target = resolveModelReference(name, aliases, new Set(ctx.modelRegistry.getAll().map((model2) => `${model2.provider}/${model2.id}`)), settingsPath);
+        const model = ctx.modelRegistry.find(target.provider, target.model);
+        if (!model) throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${name} resolved to ${target.provider}/${target.model}`);
+        return { model, thinkingLevel: request.thinkingLevel };
+      }
+    };
+    Reflect.apply(register, pi, [definition]);
+  }
 }
 async function resolveLaunchAliases(registry, staticAliases, context, availableModels, knownModels, settingsPath) {
   const dynamic = typeof registry.resolveModelAliases === "function" ? await registry.resolveModelAliases(context, new Set(Object.keys(staticAliases))) : {};
@@ -12175,10 +12480,13 @@ function workflowExtension(pi, home, clipboard = copyToClipboard, transport = lo
   });
   let backgroundWidgetEnabled = true;
   try {
-    backgroundWidgetEnabled = loadSettings(workflowSettingsPath(extensionAgentDir)).backgroundWidget ?? true;
+    const globalSettings = loadSettings(workflowSettingsPath(extensionAgentDir));
+    backgroundWidgetEnabled = globalSettings.backgroundWidget ?? true;
+    registerAliasVirtualModels(pi, Object.keys(globalSettings.modelAliases ?? {}), workflowSettingsPath(extensionAgentDir));
   } catch {
   }
   const backgroundWidgetController = widget(pi, backgroundWidgetEnabled);
+  const codemodeTools = loadCodemodeToolsSetting(extensionAgentDir);
   const logBridge = (store, lifecycle, workflowName) => async (message) => {
     const timestamp = Date.now();
     const bounded = utf8Prefix(message, DELIVERY_LIMIT_BYTES);
@@ -12470,7 +12778,10 @@ Choose what to do`, ["Retry", "Change model", "Abort workflow"]);
       if (replayed) return readShellResult(replayed.value);
       const shellStartedAt = Date.now();
       let shellPhaseIndex = -1;
-      const started = await persistRunState(store, metadata, (current) => {
+      const call = { kind: "shell", name: "shell", path, ...scriptCallInput({ command, ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }, ...options.env === void 0 ? {} : { env: Object.keys(options.env) }, ...identity.worktreeOwner ? { worktree: identity.worktreeOwner } : {} }), startedAt: shellStartedAt };
+      let failure;
+      const started = await persistRunState(store, metadata, (run) => {
+        const current = startScriptCall(run, call);
         const history = current.phaseHistory ?? [];
         if (current.phase !== void 0) shellPhaseIndex = current.phaseHistoryIndex ?? (history.length ? history.length - 1 : 0);
         const phaseActivities = [...current.activeShellsByPhase ?? []];
@@ -12486,8 +12797,12 @@ Choose what to do`, ["Retry", "Change model", "Abort workflow"]);
         if (!jsonValue(result)) fail("SHELL_FAILED", "Shell result is not JSON-compatible");
         await store.complete(path, result);
         return result;
+      } catch (error) {
+        failure = asWorkflowError(error);
+        throw error;
       } finally {
-        const stopped = await persistRunState(store, metadata, (current) => {
+        const stopped = await persistRunState(store, metadata, (run) => {
+          const current = finishScriptCall(run, path, failure);
           const phaseActivities = [...current.activeShellsByPhase ?? []];
           const phaseActivityIndex = phaseActivities.findIndex(({ phaseIndex }) => phaseIndex === shellPhaseIndex);
           const phaseActivity = phaseActivities[phaseActivityIndex];
@@ -12507,6 +12822,55 @@ Choose what to do`, ["Retry", "Change model", "Abort workflow"]);
       await lifecycle.leave();
     }
   };
+  const toolForRun = async (store, lifecycle, context, identifier, args, signal, identity) => {
+    await lifecycle.enter();
+    try {
+      const path = toolIdentityPath(identifier, args, identity);
+      const replayed = await store.replay(path);
+      if (replayed) return replayed.value;
+      if (!context) fail("UNKNOWN_TOOL", `tools.${identifier} needs a run launched or recovered by a Pi tool call; runs resumed from /workflow or at session start, and headless launches, only replay journaled tool calls`);
+      const render = async () => {
+        try {
+          const update = runs.get(store.runId)?.update;
+          if (update) update(workflowToolUpdate(withLiveActivities((await store.load()).run)));
+        } catch {
+        }
+      };
+      const record3 = async (update) => {
+        try {
+          await store.updateState(update);
+        } catch {
+        }
+      };
+      let value;
+      try {
+        const tool = scriptTool(context, identifier);
+        if (!tool) fail("UNKNOWN_TOOL", `tools.${identifier} is not a tool this session can call`);
+        const cancelled = () => signal.aborted;
+        if (cancelled()) fail("CANCELLED", "Workflow cancelled");
+        await record3((run) => startScriptCall(run, { kind: "tool", name: tool.name, path, startedAt: Date.now() }));
+        const finished = liveAgents.toolStarted(store.runId, tool.name);
+        try {
+          await render();
+          const outcome = await context.executeTool(tool.name, args, { signal });
+          if (cancelled()) fail("CANCELLED", "Workflow cancelled");
+          value = scriptToolValue(tool, outcome);
+        } finally {
+          finished();
+        }
+      } catch (error) {
+        const failure = error instanceof WorkflowError ? error : new WorkflowError("TOOL_FAILED", `tools.${identifier}: ${errorText(error)}`);
+        await record3((run) => finishScriptCall(run, path, failure));
+        throw failure;
+      }
+      await store.complete(path, value);
+      await record3((run) => finishScriptCall(run, path));
+      await render();
+      return value;
+    } finally {
+      await lifecycle.leave();
+    }
+  };
   const lifecycleFor = (store, state, metadata) => new RunLifecycle(state, async (next, previous, reason) => {
     const run = runs.get(store.runId);
     if (!run) throw new WorkflowError("INTERNAL_ERROR", `Unknown production run: ${store.runId}`);
@@ -12763,16 +13127,18 @@ Respond with workflow_respond.`);
       return decision;
     };
   };
-  const registerControlTool = (name, label, description, parameters, run) => {
+  const registerControlTool = (name, label, description, parameters, outputSchema, run) => {
     pi.registerTool({
       name,
       label,
       description,
       parameters,
+      outputSchema,
+      ...workflowToolExposure(name, codemodeTools),
       async execute(_id, params, signal, _onUpdate, ctx) {
         try {
           const result = await run(params, signal, ctx);
-          return { content: [{ type: "text", text: result.text }], details: result.details };
+          return { content: [{ type: "text", text: result.text }], details: result.details, structuredContent: result.structured };
         } catch (error) {
           throw mainAgentError(error);
         }
@@ -12790,18 +13156,21 @@ Respond with workflow_respond.`);
     "Workflow Respond",
     "Approve or reject one pending workflow checkpoint or budget decision",
     Type3.Object({ runId: Type3.String(), name: Type3.Optional(Type3.String()), proposalId: Type3.Optional(Type3.String()), approved: Type3.Boolean() }, { additionalProperties: false }),
+    WORKFLOW_RESPOND_OUTPUT,
     async (params, signal, ctx) => {
       if (params.proposalId) {
         const result = await recovery.answerBudgetDecision(params.runId, params.proposalId, params.approved, false, ctx, signal);
         if (!result) {
           const denied = { state: "budget_exhausted", approved: false, reason: "proposal_not_pending" };
-          return { text: JSON.stringify(denied), details: denied };
+          return { text: JSON.stringify(denied), details: denied, structured: denied };
         }
-        return { text: completionControlContent(result, params.runId), details: { ...result, reason: params.approved ? "approved" : "rejected" } };
+        const reason = params.approved ? "approved" : "rejected";
+        return { text: completionControlContent(result, params.runId), details: { ...result, reason }, structured: { ...completionControlValue(result, params.runId), reason } };
       }
       if (!params.name) throw new WorkflowError("INVALID_METADATA", "workflow_respond requires name or proposalId");
       const accepted = await answerCheckpoint(params.runId, params.name, params.approved);
-      return { text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response.", details: { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" } };
+      const details = { accepted, state: accepted ? "checkpoint_answered" : "not_pending", approved: params.approved, reason: "checkpoint" };
+      return { text: accepted ? "Checkpoint response accepted." : "Checkpoint is not awaiting a response.", details, structured: details };
     }
   );
   registerControlTool(
@@ -12809,9 +13178,10 @@ Respond with workflow_respond.`);
     "Workflow Stop",
     "Stop an active workflow run by ID",
     Type3.Object({ runId: Type3.String() }, { additionalProperties: false }),
+    WORKFLOW_STOP_OUTPUT,
     async (params) => {
       const result = await stopWorkflowRun(params.runId);
-      return { text: JSON.stringify(result), details: result };
+      return { text: JSON.stringify(result), details: result, structured: result };
     }
   );
   registerControlTool(
@@ -12819,9 +13189,10 @@ Respond with workflow_respond.`);
     "Workflow Status",
     "Read a compact summary of a workflow run in the current project",
     WORKFLOW_STATUS_PARAMETERS,
+    WORKFLOW_STATUS_OUTPUT,
     async (params, _signal, ctx) => {
       const result = await workflowStatusRun(params.runId, ctx);
-      return { text: JSON.stringify(result), details: result };
+      return { text: JSON.stringify(result), details: result, structured: result };
     }
   );
   let catalogRegistered = false;
@@ -12834,13 +13205,15 @@ Respond with workflow_respond.`);
     if (!catalog.functions.length && !hasAliases && !hasSettings) return;
     pi.registerTool({
       name: "workflow_catalog",
+      ...workflowToolExposure("workflow_catalog", codemodeTools),
+      outputSchema: WORKFLOW_CATALOG_OUTPUT,
       label: "Workflow Catalog",
       description: "List reusable workflow functions and model aliases; pass `name` to load one entry in full",
       parameters: Type3.Object({ name: Type3.Optional(Type3.String({ description: "Registered function or model alias name for full detail" })) }, { additionalProperties: false }),
       async execute(_id, params = {}) {
         const context = { cwd, projectTrusted: trustedProject, globalSettingsPath: workflowSettingsPath(extensionAgentDir) };
         const result = params.name === void 0 ? registry.catalogIndex(context) : registry.catalogDetail(params.name, context);
-        return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+        return { content: [{ type: "text", text: JSON.stringify(result) }], details: result, structuredContent: result };
       },
       renderCall(args, theme) {
         const title = theme.fg("toolTitle", theme.bold("workflow_catalog"));
@@ -12869,9 +13242,9 @@ Respond with workflow_respond.`);
     const captured = roleCapture(store, snapshot, definitions, project);
     return { definitions, capture: (role, model) => captured.capture(role, model) };
   };
-  const activeSnapshotTools = (tools, active) => active === "session" ? new Set(tools.filter((tool) => pi.getActiveTools().includes(tool) && tool !== "workflow_catalog")) : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
+  const activeSnapshotTools = (tools, active) => active === "session" ? new Set(tools.filter((tool) => reachableTools(pi).includes(tool) && tool !== "workflow_catalog")) : new Set(tools.filter((tool) => active.has(tool) || tool === "workflow_catalog"));
   const resumeLaunchPrologue = async (input) => {
-    const active = new Set(pi.getActiveTools().filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
+    const active = new Set(reachableTools(pi).filter((tool) => !INTERNAL_WORKFLOW_TOOLS.includes(tool)));
     const missing = input.snapshot.tools.filter((tool) => tool !== "workflow_catalog").find((tool) => !active.has(tool));
     if (missing) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required tool is unavailable: ${missing}`);
     const settingsPath = workflowSettingsPath(extensionAgentDir);
@@ -12961,6 +13334,7 @@ Respond with workflow_respond.`);
     resumeRoles,
     workflowAgentHandler,
     shellForRun,
+    toolForRun,
     resolveWorktree,
     checkpointBridge,
     phaseBridge,
@@ -13035,9 +13409,10 @@ Respond with workflow_respond.`);
     "Workflow Retry",
     "Retry a failed workflow run by replaying its completed structural operations",
     WORKFLOW_RETRY_PARAMETERS,
+    WORKFLOW_RECOVERY_OUTPUT,
     async (params, signal, ctx) => {
       const result = await recovery.retryWorkflowRun(params.runId, ctx, signal, params.foreground, params.expectedState);
-      return { text: completionControlContent(result), details: result };
+      return { text: completionControlContent(result), details: result, structured: completionControlValue(result) };
     }
   );
   registerControlTool(
@@ -13045,9 +13420,10 @@ Respond with workflow_respond.`);
     "Workflow Resume",
     "Resume an exhausted workflow with unchanged or patched aggregate budgets",
     Type3.Object({ runId: Type3.String(), expectedState: Type3.Optional(Type3.String({ description: "Persisted source state observed before recovery" })), budget: Type3.Optional(Type3.Unknown()), foreground: Type3.Optional(Type3.Boolean({ description: "Override the source launch mode for this recovery" })) }, { additionalProperties: false }),
+    WORKFLOW_RECOVERY_OUTPUT,
     async (params, signal, ctx) => {
       const result = await recovery.resumeWorkflowRun(params.runId, params.budget, ctx, signal, params.foreground, true, params.expectedState);
-      return { text: completionControlContent(result), details: result };
+      return { text: completionControlContent(result), details: result, structured: completionControlValue(result) };
     }
   );
   const deliverStaleTerminal = async (store, run) => {
@@ -13179,6 +13555,8 @@ ${content}` };
     description: WORKFLOW_TOOL_DESCRIPTION,
     promptSnippet: WORKFLOW_TOOL_PROMPT_SNIPPET,
     parameters: WORKFLOW_TOOL_PARAMETERS,
+    outputSchema: WORKFLOW_LAUNCH_OUTPUT,
+    prepareLoadout: prepareScriptToolLoadout,
     async execute(toolCallId, params, signal, onUpdate, ctx) {
       let resolveDetached;
       let foregroundStore;
@@ -13188,7 +13566,7 @@ ${content}` };
       }) : void 0;
       const detachedToolResult = (run) => {
         const detached = { runId: run.id, state: "running", detached: true };
-        return { content: [{ type: "text", text: JSON.stringify(detached) }], details: { ...detached, run, preview: `Moved workflow ${run.id} to background.` } };
+        return { content: [{ type: "text", text: JSON.stringify(detached) }], details: { ...detached, run, preview: `Moved workflow ${run.id} to background.` }, structuredContent: detached };
       };
       try {
         const headless = object(ctx) && ctx.headless === true;
@@ -13201,7 +13579,7 @@ ${content}` };
         const inventory = modelInventory(rootModel, modelRegistry);
         const knownModels = inventory.knownModels;
         const availableModels = inventory.availableModels;
-        const rootTools = pi.getActiveTools().filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
+        const rootTools = reachableTools(pi).filter((name) => !INTERNAL_WORKFLOW_TOOLS.includes(name));
         const trustedProject = projectTrusted(ctx);
         const launchCwd = typeof ctx.cwd === "string" ? ctx.cwd : process.cwd();
         const launch = workflowLaunchSettings(launchCwd, trustedProject, settingsPath, params.concurrency);
@@ -13219,6 +13597,8 @@ ${content}` };
         if (trustedProject && launch.resolution.project.extensionSettings !== void 0) registry.validateExtensionSettings(launch.resolution.project.extensionSettings, { source: "project", cwd: ctx.cwd, projectTrusted: true, settingsPath: launch.resolution.projectSettingsPath });
         const validated = validateWorkflowLaunchWithRegistry(params, { cwd: ctx.cwd, agentDir: extensionAgentDir, projectTrusted: trustedProject, availableModels, rootTools: new Set(rootTools), modelAliases, knownModels, settingsPath, ...settings.extensionSettings === void 0 ? {} : { extensionSettings: settings.extensionSettings } }, registry);
         const { script, checked, agentDefinitions, projectAgentDefinitions, roleNames } = validated;
+        const toolContext = scriptToolContext(ctx);
+        validateScriptToolReferences(script, toolContext);
         await ensureSessionLease(ctx.cwd, ctx.sessionManager.getSessionId());
         const runId = randomUUID5();
         const args = params.args ?? null;
@@ -13289,7 +13669,7 @@ ${content}` };
         runs.set(runId, runRecord);
         if (params.foreground && onUpdate) onUpdate(workflowToolUpdate((await store.load()).run));
         scheduler.addRun(runId, settings.concurrency, () => runs.get(runId)?.budget.checkAgentLaunch(), settings.extensionSettings);
-        const execution = runWorkflow(script, args, withWorkflowFunctions({ shell: (command, options, signal2, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal2, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId, (role, model) => capturedRoles.capture(role, model)), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, () => runs.get(runId)?.foreground ?? foregroundAttached, ctx.hasUI ? ctx.ui : void 0, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(store, lifecycle, checked.metadata.name) }, store, runContext, registry, settings.extensionSettings), runController.signal);
+        const execution = runWorkflow(script, args, withWorkflowFunctions({ tool: (identifier, toolArgs, signal2, identity) => toolForRun(store, lifecycle, toolContext, identifier, toolArgs, signal2, identity), shell: (command, options, signal2, identity) => shellForRun(store, checked.metadata, lifecycle, command, options, signal2, identity), agent: workflowAgentHandler(store, checked.metadata, lifecycle, executor, ctx.cwd, runId, (role, model) => capturedRoles.capture(role, model)), worktree: async (owner) => resolveWorktree(store, checked.metadata, owner), checkpoint: checkpointBridge(runId, store, checked.metadata, () => runs.get(runId)?.foreground ?? foregroundAttached, ctx.hasUI ? ctx.ui : void 0, headless), phase: phaseBridge(store, checked.metadata, lifecycle), log: logBridge(store, lifecycle, checked.metadata.name) }, store, runContext, registry, settings.extensionSettings), runController.signal);
         runRecord.execution = execution;
         await eventPublisher.runStarted(store, checked.metadata);
         const finish = execution.result.then(async (value2) => {
@@ -13327,7 +13707,7 @@ ${content}` };
           }, async (error) => {
             await deliveryController.deliverTerminal(store, deliverFailureContent(error), true);
           });
-          return { content: [{ type: "text", text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` } };
+          return { content: [{ type: "text", text: JSON.stringify({ runId, state: "running" }) }], details: { runId, preview: `Started workflow ${runId}.` }, structuredContent: { runId, state: "running" } };
         }
         void completion.then(async (result) => {
           await deliveryController.deliverDetachedTerminal(toolCallId, completionContent("background", result));
@@ -13349,7 +13729,7 @@ ${content}` };
         }
         deliveryController.foregroundDeliveries.delete(toolCallId);
         const run = (await store.load()).run;
-        return { content: [{ type: "text", text: foregroundDelivery.content }, ...foregroundDelivery.inlined ? [{ type: "text", text: `Workflow run ID: ${runId}` }] : []], details: { runId, value, run } };
+        return { content: [{ type: "text", text: foregroundDelivery.content }, ...foregroundDelivery.inlined ? [{ type: "text", text: `Workflow run ID: ${runId}` }] : []], details: { runId, value, run }, structuredContent: { runId, state: "completed", value } };
       } catch (error) {
         if (params.foreground && foregroundStore && completionInstalled) {
           const claim = await deliveryController.claimForegroundDelivery(foregroundStore, toolCallId);
@@ -13429,7 +13809,7 @@ ${content}` };
       return textBlock(isPartial ? "Workflow starting..." : runDetails?.preview ?? (content?.type === "text" ? content.text : "Workflow finished"));
     }
   };
-  pi.registerTool(workflowTool);
+  pi.registerTool({ ...workflowTool, ...workflowToolExposure(workflowTool.name, codemodeTools) });
   registerWorkflowNavigator({ pi, home, clipboard, extensionAgentDir, runs, terminalRunStates, hardTerminalRunStates: HARD_TERMINAL_RUN_STATES, ensureSessionLease, coordinateRunMutation, answerCheckpoint, recovery, stopWorkflowRun, moveForegroundToBackground: deliveryController.moveForegroundToBackground, isForegroundAttached: deliveryController.isForegroundAttached, liveAgents, registry, projectTrusted, resumeHostContext, resumeSelectedWorkflow, reportBlocked: reportWorkflowBlocked, trajectoryProvider, setNavigatorOpen: (open3) => {
     if (open3) backgroundWidgetController.suspend();
     else backgroundWidgetController.resume();
@@ -13458,6 +13838,7 @@ ${content}` };
 }
 var LiveAgentRegistry = class {
   #byRun = /* @__PURE__ */ new Map();
+  #tools = /* @__PURE__ */ new Map();
   get(runId, agentId) {
     return this.#byRun.get(runId)?.get(agentId);
   }
@@ -13486,19 +13867,32 @@ var LiveAgentRegistry = class {
   setEventTime(runId, agentId, timestamp) {
     if (timestamp !== void 0) this.#state(runId, agentId).lastEventAt = timestamp;
   }
+  /** Marks a script tool call in flight until the returned callback runs. */
+  toolStarted(runId, name) {
+    const call = { name, startedAt: Date.now() };
+    const calls = this.#tools.get(runId) ?? /* @__PURE__ */ new Set();
+    this.#tools.set(runId, calls.add(call));
+    return () => {
+      calls.delete(call);
+      if (!calls.size && this.#tools.get(runId) === calls) this.#tools.delete(runId);
+    };
+  }
   deleteRun(runId) {
     this.#byRun.delete(runId);
+    this.#tools.delete(runId);
   }
-  /** Overlays live activity and freshness onto a persisted run; returns the input when nothing is live. */
+  /** Overlays live activity, freshness, and script tool calls onto a persisted run; returns the input when nothing is live. */
   overlay(run) {
+    const tools = this.#tools.get(run.id);
+    const withTools = tools?.size ? { ...run, activeTools: [...tools].map((call) => ({ ...call })) } : run;
     const agents = this.#byRun.get(run.id);
-    if (!agents?.size) return run;
+    if (!agents?.size) return withTools;
     const next = run.agents.map((agent) => {
       const live = agents.get(agent.id);
       if (!live || live.activity === void 0 && live.lastEventAt === void 0) return agent;
       return { ...agent, ...live.activity === void 0 ? {} : { activity: live.activity }, ...live.lastEventAt === void 0 ? {} : { lastEventAt: live.lastEventAt } };
     });
-    return next.some((agent, index) => agent !== run.agents[index]) ? { ...run, agents: next } : run;
+    return next.some((agent, index) => agent !== run.agents[index]) ? { ...withTools, agents: next } : withTools;
   }
   #state(runId, agentId) {
     const agents = this.#byRun.get(runId) ?? /* @__PURE__ */ new Map();
@@ -13835,6 +14229,7 @@ export {
   SessionLease,
   THINKING_LEVELS,
   TOOL_TIMING_ENTRY_TYPE,
+  VIRTUAL_MODEL_PROVIDER,
   WORKFLOW_AGENT_STALL_THRESHOLD_MS,
   WORKFLOW_AGENT_STATE_CHANGED_EVENT,
   WORKFLOW_BLOCKED_EVENT,
@@ -13936,10 +14331,12 @@ export {
   isTurnEnd,
   isWorkflowAuthored,
   isWorkflowErrorCode,
+  jsonDigest,
   jsonObject,
   jsonValue,
   listPersistedSessionIds,
   loadAgentDefinitions,
+  loadCodemodeToolsSetting,
   loadLaunchSnapshot,
   loadProjectAgentDefinitions,
   loadRole,
@@ -13969,6 +14366,7 @@ export {
   parseThinking,
   persistActiveAgentAttempt,
   persistAgentAttempts,
+  physicalModel,
   positiveInteger,
   preflight,
   prepareAgentSetupForInspection,
@@ -13977,6 +14375,7 @@ export {
   progressStyleForState,
   projectSessionsDirectory,
   projectStorageKey,
+  reachableTools,
   readShellResult,
   registerWorkflowExtension,
   registeredWorkflowFunctionSources,
@@ -14002,11 +14401,13 @@ export {
   sameFilesystemPath,
   sanitizeDisplayText,
   saveModelAliases,
+  scriptToolReferences,
   selectResourcesByLayers,
   shellIdentityPath,
   structuralPath,
   sumAccounting,
   themeWorkflowProgressStyles,
+  toolIdentityPath,
   truncateWorkflowProgress,
   unknownModel,
   unmatchedResourcePatterns,
@@ -14042,6 +14443,7 @@ export {
   workflowRoleDirectories,
   workflowScriptArtifact,
   workflowSettingsPath,
+  workflowToolExposure,
   zeroAccounting
 };
 //# sourceMappingURL=index.js.map