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

package/dist/subagents/index.js

@@ -1,7 +1,7 @@
 // subagents/src/index.ts
-import { join as join11 } from "node:path";
-import { defineTool as defineTool2, getAgentDir as getAgentDir8 } from "@earendil-works/pi-coding-agent";
-import { Value as Value3 } from "typebox/value";
+import { join as join10 } from "node:path";
+import { defineTool as defineTool2, getAgentDir as getAgentDir7 } from "@earendil-works/pi-coding-agent";
+import { Value as Value4 } from "typebox/value";
 
 // src/types.ts
 var RUN_STATES = ["queued", "running", "pausing", "paused", "awaiting_input", "completed", "failed", "stopped", "interrupted", "budget_exhausted"];
@@ -16,7 +16,7 @@ var ERROR_CODES = [
   "INVALID_SCHEMA",
   "UNKNOWN_MODEL",
   "UNKNOWN_TOOL",
-  "UNKNOWN_AGENT_TYPE",
+  "UNKNOWN_AGENT",
   "RUN_OWNED",
   "RUN_NOT_FOUND",
   "REGISTRY_FROZEN",
@@ -28,6 +28,7 @@ var ERROR_CODES = [
   "AGENT_FAILED",
   "AGENT_RESULT_COLLECTED",
   "RESULT_INVALID",
+  "TOOL_FAILED",
   "CANCELLED",
   "WORKER_UNRESPONSIVE",
   "WORKTREE_FAILED",
@@ -36,15 +37,12 @@ var ERROR_CODES = [
   "INTERNAL_ERROR"
 ];
 var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-function roleNameOf(value) {
-  return typeof value === "string" ? value : void 0;
-}
-var BUDGET_DIMENSIONS = ["tokens", "costUsd", "durationMs", "agentLaunches"];
-var BUDGET_EVENT_TYPES = ["soft_crossed", "hard_overrun", "hard_exhausted", "adjustment_requested", "adjustment_approved", "adjustment_rejected"];
 var CONTEXT_FILE_SCOPES = ["global", "project", "cwd"];
 function isContextFileScope(value) {
   return CONTEXT_FILE_SCOPES.some((scope) => scope === value);
 }
+var BUDGET_DIMENSIONS = ["tokens", "costUsd", "durationMs", "agentLaunches"];
+var BUDGET_EVENT_TYPES = ["soft_crossed", "hard_overrun", "hard_exhausted", "adjustment_requested", "adjustment_approved", "adjustment_rejected"];
 var WORKFLOW_AGENT_STALL_THRESHOLD_MS = 10 * 60 * 1e3;
 function zeroAccounting() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
@@ -57,7 +55,7 @@ function sumAccounting(values) {
   for (const value of values) total = addAccounting(total, value);
   return total;
 }
-var LAUNCH_SNAPSHOT_IDENTITY_VERSION = 5;
+var LAUNCH_SNAPSHOT_IDENTITY_VERSION = 6;
 var WORKFLOW_ERROR_BRAND = /* @__PURE__ */ Symbol.for("pi-extensible-workflows.workflow-error");
 var WorkflowError = class extends Error {
   constructor(code, message) {
@@ -155,15 +153,8 @@ function jsonValue(value, seen = /* @__PURE__ */ new Set()) {
   seen.delete(value);
   return valid;
 }
-function mergeWorkflowExtensionSettings(...layers) {
-  const merged = {};
-  let present = false;
-  for (const layer of layers) {
-    if (layer === void 0) continue;
-    present = true;
-    for (const [namespace, value] of Object.entries(layer)) Object.defineProperty(merged, namespace, { value: structuredClone(value), enumerable: true, configurable: true, writable: true });
-  }
-  return present ? deepFreeze(merged) : void 0;
+function jsonObject(value) {
+  return jsonValue(value) && object(value);
 }
 function positiveInteger(value) {
   return typeof value === "number" && Number.isInteger(value) && value > 0;
@@ -213,11 +204,16 @@ function parseThinking(value) {
   return isThinkingLevel(value) ? value : void 0;
 }
 function parseModelReference(value) {
-  const match = /^([^/:\s]+)\/([^:\s]+)(?::([^:\s]+))?$/.exec(value);
+  const match = /^([^/:\s]+)\/([^\s]+)$/.exec(value);
   if (!match?.[1] || !match[2]) fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
-  const thinking = match[3];
-  if (thinking !== void 0 && !isThinkingLevel(thinking)) fail("UNKNOWN_MODEL", `Invalid thinking level: ${thinking}`);
-  return { provider: match[1], model: match[2], ...thinking !== void 0 ? { thinking } : {} };
+  const reference = match[2];
+  const separator = reference.lastIndexOf(":");
+  const suffix = separator === -1 ? void 0 : reference.slice(separator + 1);
+  if (suffix === "") fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+  const thinking = suffix !== void 0 && isThinkingLevel(suffix) ? suffix : void 0;
+  const model = thinking === void 0 ? reference : reference.slice(0, separator);
+  if (model === "") fail("UNKNOWN_MODEL", `Invalid model spec: ${value}`);
+  return { provider: match[1], model, ...thinking === void 0 ? {} : { thinking } };
 }
 function assertModelThinking(value, path = "model") {
   if (value.includes("/") && parseModelReference(value).thinking === void 0) fail("INVALID_METADATA", `${path} must be provider/model:thinking`);
@@ -288,6 +284,16 @@ function modelCapability(value, aliases, knownModels, settingsPath) {
   const parsed = typeof value === "string" ? resolveModelReference(value, aliases, knownModels, settingsPath) : value;
   return `${parsed.provider}/${parsed.model}`;
 }
+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 };
+}
 var RESOURCE_PATTERN_OPTIONS = { dot: true, nonegate: true, nocomment: true };
 function resourcePatternBody(pattern) {
   return pattern.startsWith("!") ? pattern.slice(1) : pattern;
@@ -338,8 +344,9 @@ function validateSchema(schema, at = "schema") {
 // src/paths.ts
 import { createHash } from "node:crypto";
 import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import { basename, join, resolve } from "node:path";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 function safePart(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
@@ -351,9 +358,22 @@ function canonicalPath(path) {
     return absolute;
   }
 }
+function extensionIdentity(path) {
+  return path.startsWith("builtin:") ? path : canonicalPath(path.startsWith("file:") ? fileURLToPath(path) : path);
+}
 function sameFilesystemPath(left, right) {
   return canonicalPath(left) === canonicalPath(right);
 }
+function piResourcePath(path, cwd) {
+  if (path.startsWith("<") || path.startsWith("builtin:")) return path;
+  const trimmed = path.trim();
+  const expanded = trimmed === "~" ? homedir() : trimmed.startsWith("~/") ? join(homedir(), trimmed.slice(2)) : /^file:\/\//.test(trimmed) ? fileURLToPath(trimmed) : trimmed;
+  return isAbsolute(expanded) ? resolve(expanded) : resolve(cwd, expanded);
+}
+function piResourceContains(root, path) {
+  const relativePath = relative(resolve(root), resolve(path));
+  return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+}
 function workflowProjectSettingsPath(cwd) {
   return join(cwd, ".pi", "pi-extensible-workflows", "settings.json");
 }
@@ -381,17 +401,6 @@ function budgetUsage(value) {
 // src/validation.ts
 import * as acorn from "acorn";
 
-// src/roles.ts
-import { readFileSync as readFileSync3, readdirSync, statSync } from "node:fs";
-import { basename as basename3, dirname as dirname4, extname, join as join5, resolve as resolve4 } from "node:path";
-import { getAgentDir as getAgentDir2, parseFrontmatter } from "@earendil-works/pi-coding-agent";
-
-// src/registry.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { basename as basename2, dirname as dirname3, isAbsolute, join as join4 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { Value } from "typebox/value";
-
 // src/io.ts
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
@@ -412,7 +421,7 @@ async function renameWithRetry(from, to) {
     } catch (error) {
       const delayMs = RENAME_RETRY_DELAYS_MS[attempt];
       if (!retryableRenameError(error) || delayMs === void 0) throw error;
-      await new Promise((resolve6) => setTimeout(resolve6, delayMs));
+      await new Promise((resolve5) => setTimeout(resolve5, delayMs));
     }
   }
 }
@@ -478,7 +487,9 @@ async function git(cwd, args, extraEnv = {}) {
 }
 
 // src/session-lease.ts
+import { execFileSync } from "node:child_process";
 import { link, mkdir, open, readFile as readFile2, readdir, rename as rename2, rm as rm2, stat } from "node:fs/promises";
+import { join as join2 } from "node:path";
 
 // src/decoders.ts
 var INVALID_PERSISTED_VALUE = /* @__PURE__ */ Symbol("invalid persisted value");
@@ -568,32 +579,19 @@ function decodeAgentResourceSelectors(value) {
 function decodeContextFileScopes(value) {
   return decodeArray(value, (scope) => isContextFileScope(scope) ? scope : void 0);
 }
-function decodeAgentDefinition(value) {
-  if (!object(value)) return void 0;
-  const prompt = optionalString(value.prompt);
-  const description = optionalString(value.description);
-  const model = optionalString(value.model);
-  const thinking = value.thinking;
-  const tools = value.tools === void 0 ? void 0 : decodeStringArray(value.tools);
-  const skills = value.skills === void 0 ? void 0 : decodeStringArray(value.skills);
-  const extensions = value.extensions === void 0 ? void 0 : decodeStringArray(value.extensions);
-  const overrideSystemPrompt = optionalBoolean(value.overrideSystemPrompt);
+function decodePreparedAgentConfiguration(value) {
+  if (!object(value) || !jsonValue(value) || typeof value.projectTrusted !== "boolean" || typeof value.systemPromptAppend !== "string") return void 0;
+  const model = decodeModelSpec(value.model);
+  const tools = decodeStringArray(value.tools);
+  const skills = decodeStringArray(value.skills);
+  const extensions = decodeStringArray(value.extensions);
+  const settings = decodeWorkflowExtensions(value.settings);
   const contextFiles = value.contextFiles === void 0 ? void 0 : decodeContextFileScopes(value.contextFiles);
-  const extensionSettings = value.extensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.extensionSettings);
-  if (prompt === INVALID_PERSISTED_VALUE || description === INVALID_PERSISTED_VALUE || model === INVALID_PERSISTED_VALUE || overrideSystemPrompt === INVALID_PERSISTED_VALUE) return void 0;
-  if (thinking !== void 0 && !isThinkingLevel(thinking) || value.tools !== void 0 && !tools || value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.contextFiles !== void 0 && !contextFiles || value.extensionSettings !== void 0 && !extensionSettings) return void 0;
-  const foldedModel = typeof model === "string" && thinking !== void 0 && !model.includes(":") ? `${model}:${thinking}` : model;
-  return {
-    ...prompt === void 0 ? {} : { prompt },
-    ...description === void 0 ? {} : { description },
-    ...foldedModel === void 0 ? {} : { model: foldedModel },
-    ...tools === void 0 ? {} : { tools },
-    ...skills === void 0 ? {} : { skills },
-    ...extensions === void 0 ? {} : { extensions },
-    ...overrideSystemPrompt === void 0 ? {} : { overrideSystemPrompt },
-    ...contextFiles === void 0 ? {} : { contextFiles },
-    ...extensionSettings === void 0 ? {} : { extensionSettings }
-  };
+  const label2 = optionalString(value.label);
+  const systemPrompt = optionalString(value.systemPrompt);
+  const excludeTools = value.excludeTools === void 0 ? void 0 : decodeStringArray(value.excludeTools);
+  if (!model || !tools || !skills || !extensions || !settings || label2 === INVALID_PERSISTED_VALUE || systemPrompt === INVALID_PERSISTED_VALUE || value.contextFiles !== void 0 && !contextFiles || value.excludeTools !== void 0 && !excludeTools) return void 0;
+  return { model, tools, skills, extensions, settings, projectTrusted: value.projectTrusted, systemPromptAppend: value.systemPromptAppend, ...contextFiles === void 0 ? {} : { contextFiles }, ...excludeTools === void 0 ? {} : { excludeTools }, ...label2 === void 0 ? {} : { label: label2 }, ...systemPrompt === void 0 ? {} : { systemPrompt } };
 }
 function decodeWorkflowMetadata(value) {
   if (!object(value) || typeof value.name !== "string") return void 0;
@@ -702,17 +700,22 @@ function decodeScheduledAgentOptions(value) {
   const parentBreadcrumb = optionalString(value.parentBreadcrumb);
   const worktreeOwner = optionalString(value.worktreeOwner);
   const model = optionalString(value.model);
-  const role = typeof value.role === "string" ? value.role : void 0;
   const contextFiles = value.contextFiles === void 0 ? void 0 : decodeContextFileScopes(value.contextFiles);
   const schema = value.schema === void 0 ? void 0 : decodeJsonObject(value.schema);
   const retries = optionalNumber(value.retries);
   const timeoutMs = value.timeoutMs;
+  if (value.projectTrusted !== void 0 && typeof value.projectTrusted !== "boolean") return void 0;
+  const rawCapabilities = value.capabilities;
+  const capabilities = rawCapabilities === void 0 ? void 0 : object(rawCapabilities) ? { tools: decodeStringArray(rawCapabilities.tools), skills: decodeStringArray(rawCapabilities.skills), extensions: decodeStringArray(rawCapabilities.extensions) } : void 0;
+  if (rawCapabilities !== void 0 && (!capabilities?.tools || !capabilities.skills || !capabilities.extensions)) return void 0;
+  const configuration = value.configuration === void 0 ? void 0 : decodePreparedAgentConfiguration(value.configuration);
+  if (value.configuration !== void 0 && configuration === void 0) return void 0;
   const agentOptions = value.agentOptions === void 0 ? void 0 : decodeJsonObject(value.agentOptions);
   const agentIdentity = value.agentIdentity === void 0 ? void 0 : decodeIdentity(value.agentIdentity);
   const sessionPath = optionalString(value.sessionPath);
   const continuity = value.continuity === void 0 ? void 0 : isAgentContinuity(value.continuity) ? value.continuity : INVALID_PERSISTED_VALUE;
   const extensionSettings = value.extensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.extensionSettings);
-  if (sessionPath === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || requestedLabel === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || model === INVALID_PERSISTED_VALUE || value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.role !== void 0 && typeof value.role !== "string" || value.contextFiles !== void 0 && !contextFiles || value.schema !== void 0 && !schema || retries === INVALID_PERSISTED_VALUE || retries !== void 0 && !integer(retries) || timeoutMs !== void 0 && timeoutMs !== null && !finiteNumber(timeoutMs) || value.agentOptions !== void 0 && !agentOptions || value.agentIdentity !== void 0 && !agentIdentity || value.extensionSettings !== void 0 && !extensionSettings) return void 0;
+  if (sessionPath === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || requestedLabel === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || model === INVALID_PERSISTED_VALUE || value.skills !== void 0 && !skills || value.extensions !== void 0 && !extensions || value.contextFiles !== void 0 && !contextFiles || value.schema !== void 0 && !schema || retries === INVALID_PERSISTED_VALUE || retries !== void 0 && !integer(retries) || timeoutMs !== void 0 && timeoutMs !== null && !finiteNumber(timeoutMs) || value.agentOptions !== void 0 && !agentOptions || value.agentIdentity !== void 0 && !agentIdentity || value.extensionSettings !== void 0 && !extensionSettings) return void 0;
   return {
     label: value.label,
     ...requestedLabel === void 0 ? {} : { requestedLabel },
@@ -723,7 +726,6 @@ function decodeScheduledAgentOptions(value) {
     ...extensions === void 0 ? {} : { extensions },
     ...worktreeOwner === void 0 ? {} : { worktreeOwner },
     ...model === void 0 ? {} : { model },
-    ...role === void 0 ? {} : { role },
     ...contextFiles === void 0 ? {} : { contextFiles },
     ...schema === void 0 ? {} : { schema },
     ...retries === void 0 ? {} : { retries },
@@ -731,6 +733,9 @@ function decodeScheduledAgentOptions(value) {
     ...sessionPath === void 0 ? {} : { sessionPath },
     ...continuity === void 0 ? {} : { continuity },
     ...agentOptions === void 0 ? {} : { agentOptions },
+    ...configuration === void 0 ? {} : { configuration },
+    ...value.projectTrusted === void 0 ? {} : { projectTrusted: value.projectTrusted },
+    ...capabilities?.tools && capabilities.skills && capabilities.extensions ? { capabilities: { tools: capabilities.tools, skills: capabilities.skills, extensions: capabilities.extensions } } : {},
     ...agentIdentity === void 0 ? {} : { agentIdentity },
     ...extensionSettings === void 0 ? {} : { extensionSettings }
   };
@@ -771,11 +776,10 @@ function decodeAgentResourceInspection(value) {
   const sources = sourceRecord === void 0 ? void 0 : {
     global: decodeAgentResourceSelectors(sourceRecord.global),
     project: decodeAgentResourceSelectors(sourceRecord.project),
-    ...sourceRecord.role === void 0 ? {} : { role: decodeAgentResourceSelectors(sourceRecord.role) },
     ...sourceRecord.call === void 0 ? {} : { call: decodeAgentResourceSelectors(sourceRecord.call) }
   };
-  if (!selectors || !skills || !extensions || !tools || !unmatchedSkills || !unmatchedExtensions || !unmatchedTools || rawSources !== void 0 && (!sources || !sources.global || !sources.project || sources.role === void 0 && sourceRecord?.role !== void 0 || sources.call === void 0 && sourceRecord?.call !== void 0)) return void 0;
-  return { selectors: { skills: [...selectors.skills ?? []], extensions: [...selectors.extensions ?? []], tools: [...selectors.tools ?? []] }, skills, extensions, tools, unmatchedSkills, unmatchedExtensions, unmatchedTools, ...sources === void 0 ? {} : { selectorSources: { global: sources.global ?? {}, project: sources.project ?? {}, ...sources.role === void 0 ? {} : { role: sources.role }, ...sources.call === void 0 ? {} : { call: sources.call } } } };
+  if (!selectors || !skills || !extensions || !tools || !unmatchedSkills || !unmatchedExtensions || !unmatchedTools || rawSources !== void 0 && (!sources || !sources.global || !sources.project || sources.call === void 0 && sourceRecord?.call !== void 0)) return void 0;
+  return { selectors: { skills: [...selectors.skills ?? []], extensions: [...selectors.extensions ?? []], tools: [...selectors.tools ?? []] }, skills, extensions, tools, unmatchedSkills, unmatchedExtensions, unmatchedTools, ...sources === void 0 ? {} : { selectorSources: { global: sources.global ?? {}, project: sources.project ?? {}, ...sources.call === void 0 ? {} : { call: sources.call } } } };
 }
 function decodeAgentSetupSummary(value) {
   if (!object(value) || typeof value.cwd !== "string") return void 0;
@@ -813,17 +817,16 @@ function decodeAgent(value) {
   const worktreeOwner = optionalString(value.worktreeOwner);
   const handle = optionalString(value.handle);
   const continuity = value.continuity === void 0 ? void 0 : isAgentContinuity(value.continuity) ? value.continuity : INVALID_PERSISTED_VALUE;
-  const role = optionalString(value.role);
   const requestedModel = optionalString(value.requestedModel);
   const startedAt = optionalNumber(value.startedAt);
   const durationMs = optionalNumber(value.durationMs);
   const attemptDetails = value.attemptDetails === void 0 ? void 0 : decodeArray(value.attemptDetails, decodeAgentAttempt);
   const accounting2 = value.accounting === void 0 ? void 0 : decodeAgentAccounting(value.accounting);
   const toolCalls = value.toolCalls === void 0 ? void 0 : decodeArray(value.toolCalls, decodeAgentToolCall);
-  const activity2 = value.activity === void 0 ? void 0 : decodeAgentActivity(value.activity);
+  const activity = value.activity === void 0 ? void 0 : decodeAgentActivity(value.activity);
   const lastEventAt = optionalNumber(value.lastEventAt);
-  if (systemPrompt === INVALID_PERSISTED_VALUE || prompt === INVALID_PERSISTED_VALUE || label2 === INVALID_PERSISTED_VALUE || parentId === INVALID_PERSISTED_VALUE || resultPath2 === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || role === INVALID_PERSISTED_VALUE || requestedModel === INVALID_PERSISTED_VALUE || startedAt === INVALID_PERSISTED_VALUE || durationMs === INVALID_PERSISTED_VALUE || lastEventAt === INVALID_PERSISTED_VALUE || handle === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || handle !== void 0 && !positiveInteger(value.turn)) return void 0;
-  if (!model || !tools || value.structuralPath !== void 0 && !structuralPath2 || value.attemptDetails !== void 0 && !attemptDetails || value.accounting !== void 0 && !accounting2 || value.toolCalls !== void 0 && !toolCalls || value.activity !== void 0 && !activity2) return void 0;
+  if (systemPrompt === INVALID_PERSISTED_VALUE || prompt === INVALID_PERSISTED_VALUE || label2 === INVALID_PERSISTED_VALUE || parentId === INVALID_PERSISTED_VALUE || resultPath2 === INVALID_PERSISTED_VALUE || parentBreadcrumb === INVALID_PERSISTED_VALUE || worktreeOwner === INVALID_PERSISTED_VALUE || requestedModel === INVALID_PERSISTED_VALUE || startedAt === INVALID_PERSISTED_VALUE || durationMs === INVALID_PERSISTED_VALUE || lastEventAt === INVALID_PERSISTED_VALUE || handle === INVALID_PERSISTED_VALUE || continuity === INVALID_PERSISTED_VALUE || handle !== void 0 && !positiveInteger(value.turn)) return void 0;
+  if (!model || !tools || value.structuralPath !== void 0 && !structuralPath2 || value.attemptDetails !== void 0 && !attemptDetails || value.accounting !== void 0 && !accounting2 || value.toolCalls !== void 0 && !toolCalls || value.activity !== void 0 && !activity) return void 0;
   return {
     ...systemPrompt === void 0 ? {} : { systemPrompt },
     ...prompt === void 0 ? {} : { prompt },
@@ -839,7 +842,6 @@ function decodeAgent(value) {
     ...worktreeOwner === void 0 ? {} : { worktreeOwner },
     ...handle === void 0 ? {} : { handle, turn: value.turn },
     ...continuity === void 0 ? {} : { continuity },
-    ...role === void 0 ? {} : { role },
     ...requestedModel === void 0 ? {} : { requestedModel },
     model,
     tools,
@@ -849,7 +851,7 @@ function decodeAgent(value) {
     ...attemptDetails === void 0 ? {} : { attemptDetails },
     ...accounting2 === void 0 ? {} : { accounting: accounting2 },
     ...toolCalls === void 0 ? {} : { toolCalls },
-    ...activity2 === void 0 ? {} : { activity: activity2 },
+    ...activity === void 0 ? {} : { activity },
     ...lastEventAt === void 0 ? {} : { lastEventAt }
   };
 }
@@ -897,6 +899,22 @@ function decodeRunEvent(value) {
   if (timestamp2 === INVALID_PERSISTED_VALUE) return void 0;
   return { type: value.type, message: value.message, ...timestamp2 === void 0 ? {} : { timestamp: timestamp2 } };
 }
+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;
@@ -926,6 +944,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 {
@@ -944,6 +964,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 },
@@ -968,13 +989,11 @@ function decodeLaunchSnapshot(value) {
   const phases = value.phases === void 0 ? void 0 : decodeStringArray(value.phases);
   const models = decodeStringArray(value.models);
   const tools = decodeStringArray(value.tools);
-  const agentTypes = decodeStringArray(value.agentTypes);
-  const roles = value.roles === void 0 ? void 0 : decodeRecord(value.roles, decodeAgentDefinition);
-  const projectRoles = value.projectRoles === void 0 ? void 0 : decodeStringArray(value.projectRoles);
+  const agentConfigurations = decodeRecord(value.agentConfigurations, decodePreparedAgentConfiguration);
   const schemas = decodeArray(value.schemas, decodeJsonObject);
-  if (identityVersion === INVALID_PERSISTED_VALUE || value.identityVersion !== void 0 && !integer(identityVersion) || launchMode !== void 0 && !isLaunchMode(launchMode) || args === void 0 || !metadata || !settings || value.settingsSources !== void 0 && !settingsSources || value.budget !== void 0 && !budget || settingsPath === INVALID_PERSISTED_VALUE || value.modelAliases !== void 0 && !modelAliases || value.phases !== void 0 && !phases || !models || !tools || !agentTypes || value.roles !== void 0 && !roles || value.projectRoles !== void 0 && !projectRoles || !schemas) return void 0;
+  if (identityVersion !== LAUNCH_SNAPSHOT_IDENTITY_VERSION || launchMode !== void 0 && !isLaunchMode(launchMode) || args === void 0 || !metadata || !settings || value.settingsSources !== void 0 && !settingsSources || value.budget !== void 0 && !budget || settingsPath === INVALID_PERSISTED_VALUE || value.modelAliases !== void 0 && !modelAliases || value.phases !== void 0 && !phases || !models || !tools || !agentConfigurations || !schemas) return void 0;
   return {
-    ...identityVersion === void 0 ? {} : { identityVersion },
+    identityVersion: LAUNCH_SNAPSHOT_IDENTITY_VERSION,
     ...launchMode === void 0 ? {} : { launchMode },
     script: value.script,
     args,
@@ -987,9 +1006,7 @@ function decodeLaunchSnapshot(value) {
     ...phases === void 0 ? {} : { phases },
     models,
     tools,
-    agentTypes,
-    ...roles === void 0 ? {} : { roles },
-    ...projectRoles === void 0 ? {} : { projectRoles },
+    agentConfigurations,
     schemas
   };
 }
@@ -1070,18 +1087,43 @@ function decodeSystemPromptArtifact(value) {
 }
 
 // src/session-lease.ts
-async function processAlive(pid, startedAt) {
+var START_MARGIN_MS = 6e4;
+var clockTicks;
+function clockTickRate() {
+  if (clockTicks !== void 0) return clockTicks;
+  try {
+    const rate = Number(execFileSync("getconf", ["CLK_TCK"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
+    clockTicks = Number.isInteger(rate) && rate > 0 ? rate : 100;
+  } catch {
+    clockTicks = 100;
+  }
+  return clockTicks;
+}
+async function linuxProcessStart(pid, procRoot) {
+  try {
+    const text = await readFile2(join2(procRoot, String(pid), "stat"), "utf8");
+    const close = text.lastIndexOf(")");
+    const ticks = close < 0 ? Number.NaN : Number(text.slice(close + 2).split(" ")[19]);
+    const btime = /^btime (\d+)$/m.exec(await readFile2(join2(procRoot, "stat"), "utf8"))?.[1];
+    if (btime === void 0 || !Number.isInteger(ticks) || ticks < 0) return void 0;
+    return Number(btime) * 1e3 + ticks / clockTickRate() * 1e3;
+  } catch {
+    return void 0;
+  }
+}
+async function processAlive(pid, startedAt, procRoot = "/proc") {
   try {
     process.kill(pid, 0);
   } catch (error) {
     return !isNodeError(error, "ESRCH");
   }
-  if (startedAt !== void 0 && process.platform === "linux") {
-    try {
-      if ((await stat(`/proc/${String(pid)}`)).ctimeMs > startedAt) return false;
-    } catch (error) {
-      if (isNodeError(error, "ENOENT")) return false;
-    }
+  if (startedAt === void 0 || process.platform !== "linux") return true;
+  const start = await linuxProcessStart(pid, procRoot);
+  if (start !== void 0) return start <= startedAt + START_MARGIN_MS;
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    return !isNodeError(error, "ESRCH");
   }
   return true;
 }
@@ -1091,7 +1133,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
 import { access, mkdir as mkdir2, readdir as readdir2, readFile as readFile3, realpath, rename as rename3, rm as rm3, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { dirname, join as join2, relative, resolve as resolve2, sep } from "node:path";
+import { dirname, join as join3, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 var executeFile = promisify2(execFile2);
 var WORKTREE_POST_CREATE_TIMEOUT_MS = 6e4;
@@ -1102,36 +1144,36 @@ var SYSTEM_PROMPT_BODIES = "bodies";
 var SYSTEM_PROMPT_SEQUENCE = "sequence";
 var SYSTEM_PROMPT_ARTIFACT = { version: 2, format: "append-only", storage: SYSTEM_PROMPT_STORAGE };
 function summaryArtifacts(directory) {
-  return { runDirectory: directory, statePath: join2(directory, "state.json"), journalPath: join2(directory, "journal.json"), snapshotPath: join2(directory, "snapshot.json"), workflowPath: join2(directory, "workflow.js"), resultPath: join2(directory, "result.json"), summaryPath: join2(directory, "summary.json") };
+  return { runDirectory: directory, statePath: join3(directory, "state.json"), journalPath: join3(directory, "journal.json"), snapshotPath: join3(directory, "snapshot.json"), workflowPath: join3(directory, "workflow.js"), resultPath: join3(directory, "result.json"), summaryPath: join3(directory, "summary.json") };
 }
 function summaryFromRun(run, directory, journal, previous, fallbackCreatedAt, now = (/* @__PURE__ */ new Date()).toISOString()) {
   const createdAt = typeof previous?.createdAt === "string" ? previous.createdAt : fallbackCreatedAt;
   const failedAt = run.failedAt ?? run.error?.failedAt;
   const replayablePaths = [.../* @__PURE__ */ new Set([...run.retry?.completedPaths ?? [], ...Object.keys(journal.completed)])];
   const incompletePaths = [.../* @__PURE__ */ new Set([...run.retry?.incompletePaths ?? [], ...failedAt ? [failedAt] : []])];
-  return { schemaVersion: 1, runId: run.id, sessionId: run.sessionId, workflowName: run.workflowName, state: run.state, createdAt, updatedAt: now, ...previous?.terminalAt || HARD_TERMINAL_RUN_STATES.has(run.state) ? { terminalAt: previous?.terminalAt ?? now } : {}, usage: budgetUsage(run.usage), agents: run.agents.map(({ id, name, label: label2, state, role, attempts }) => ({ id, name, ...label2 ? { label: label2 } : {}, state, ...role ? { role } : {}, attempts })), ...run.error ? { error: run.error } : {}, ...failedAt ? { failedAt } : {}, replayablePaths, incompletePaths, artifacts: summaryArtifacts(directory) };
+  return { schemaVersion: 1, runId: run.id, sessionId: run.sessionId, workflowName: run.workflowName, state: run.state, createdAt, updatedAt: now, ...previous?.terminalAt || HARD_TERMINAL_RUN_STATES.has(run.state) ? { terminalAt: previous?.terminalAt ?? now } : {}, usage: budgetUsage(run.usage), agents: run.agents.map(({ id, name, label: label2, state, attempts }) => ({ id, name, ...label2 ? { label: label2 } : {}, state, attempts })), ...run.error ? { error: run.error } : {}, ...failedAt ? { failedAt } : {}, replayablePaths, incompletePaths, artifacts: summaryArtifacts(directory) };
 }
 function systemPromptStoragePath(directory) {
-  return join2(directory, SYSTEM_PROMPT_STORAGE);
+  return join3(directory, SYSTEM_PROMPT_STORAGE);
 }
 function systemPromptRecordsPath(directory) {
-  return join2(systemPromptStoragePath(directory), SYSTEM_PROMPT_RECORDS);
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_RECORDS);
 }
 function systemPromptBodiesPath(directory) {
-  return join2(systemPromptStoragePath(directory), SYSTEM_PROMPT_BODIES);
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_BODIES);
 }
 function systemPromptSequencePath(directory) {
-  return join2(systemPromptStoragePath(directory), SYSTEM_PROMPT_SEQUENCE);
+  return join3(systemPromptStoragePath(directory), SYSTEM_PROMPT_SEQUENCE);
 }
 function systemPromptRecordName(sequence) {
   return `${String(sequence).padStart(20, "0")}.json`;
 }
 async function createSystemPromptStorage(directory, writeArtifact) {
   const storage = systemPromptStoragePath(directory);
-  await mkdir2(join2(storage, SYSTEM_PROMPT_RECORDS), { recursive: true, mode: 448 });
-  await mkdir2(join2(storage, SYSTEM_PROMPT_BODIES), { recursive: true, mode: 448 });
+  await mkdir2(join3(storage, SYSTEM_PROMPT_RECORDS), { recursive: true, mode: 448 });
+  await mkdir2(join3(storage, SYSTEM_PROMPT_BODIES), { recursive: true, mode: 448 });
   await atomicWriteFile(systemPromptSequencePath(directory), "0\n");
-  if (writeArtifact) await atomicJson(join2(directory, "system-prompts.json"), SYSTEM_PROMPT_ARTIFACT);
+  if (writeArtifact) await atomicJson(join3(directory, "system-prompts.json"), SYSTEM_PROMPT_ARTIFACT);
 }
 var RunStore = class _RunStore {
   constructor(cwd, sessionId, runId, home = homedir2()) {
@@ -1140,7 +1182,7 @@ var RunStore = class _RunStore {
     this.runId = runId;
     this.home = home;
     this.cwd = resolve2(cwd);
-    this.directory = join2(runsDirectory(this.cwd, sessionId, home), safePart(runId));
+    this.directory = join3(runsDirectory(this.cwd, sessionId, home), safePart(runId));
   }
   cwd;
   sessionId;
@@ -1162,19 +1204,19 @@ var RunStore = class _RunStore {
   }
   async create(run, snapshot) {
     this.#assertRunIdentity(run, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
-    const temporary = join2(dirname(this.directory), `.${safePart(this.runId)}.${String(process.pid)}.${randomUUID2()}.tmp`);
+    const temporary = join3(dirname(this.directory), `.${safePart(this.runId)}.${String(process.pid)}.${randomUUID2()}.tmp`);
     await mkdir2(dirname(this.directory), { recursive: true, mode: 448 });
     await mkdir2(temporary, { mode: 448 });
     try {
-      await writeFile2(join2(temporary, "workflow.js"), snapshot.script, { encoding: "utf8", mode: 384 });
-      await atomicJson(join2(temporary, "snapshot.json"), snapshot);
-      await atomicJson(join2(temporary, "journal.json"), { completed: {}, awaiting: {}, decisions: {} });
-      await atomicJson(join2(temporary, "ownership.json"), []);
-      await atomicJson(join2(temporary, "worktrees.json"), []);
-      await atomicJson(join2(temporary, "borrowed-worktrees.json"), []);
-      await atomicJson(join2(temporary, "state.json"), run);
+      await writeFile2(join3(temporary, "workflow.js"), snapshot.script, { encoding: "utf8", mode: 384 });
+      await atomicJson(join3(temporary, "snapshot.json"), snapshot);
+      await atomicJson(join3(temporary, "journal.json"), { completed: {}, awaiting: {}, decisions: {} });
+      await atomicJson(join3(temporary, "ownership.json"), []);
+      await atomicJson(join3(temporary, "worktrees.json"), []);
+      await atomicJson(join3(temporary, "borrowed-worktrees.json"), []);
+      await atomicJson(join3(temporary, "state.json"), run);
       await createSystemPromptStorage(temporary, true);
-      await atomicJson(join2(temporary, "summary.json"), summaryFromRun(run, this.directory, { completed: {} }, void 0, (/* @__PURE__ */ new Date()).toISOString()));
+      await atomicJson(join3(temporary, "summary.json"), summaryFromRun(run, this.directory, { completed: {} }, void 0, (/* @__PURE__ */ new Date()).toISOString()));
       await rename3(temporary, this.directory);
     } catch (error) {
       await rm3(temporary, { recursive: true, force: true });
@@ -1183,12 +1225,12 @@ var RunStore = class _RunStore {
   }
   async refreshSummary() {
     const write = this.summaryLane.run(async () => {
-      const run = decodePersistedRun(await json(join2(this.directory, "state.json")), true);
-      const journal = decodeJournal(await json(join2(this.directory, "journal.json")));
-      const previous = await json(join2(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
+      const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
+      const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
+      const previous = await json(join3(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
       if (!run || !journal) throw new Error("Persisted run or journal is invalid");
-      const fallbackCreatedAt = await stat2(join2(this.directory, "state.json")).then((value) => new Date(value.mtimeMs).toISOString());
-      await atomicJson(join2(this.directory, "summary.json"), summaryFromRun(run, this.directory, journal, previous, fallbackCreatedAt));
+      const fallbackCreatedAt = await stat2(join3(this.directory, "state.json")).then((value) => new Date(value.mtimeMs).toISOString());
+      await atomicJson(join3(this.directory, "summary.json"), summaryFromRun(run, this.directory, journal, previous, fallbackCreatedAt));
     });
     await write;
   }
@@ -1198,7 +1240,7 @@ var RunStore = class _RunStore {
   }
   async isComplete() {
     try {
-      await Promise.all([access(join2(this.directory, "snapshot.json")), access(join2(this.directory, "journal.json")), access(join2(this.directory, "ownership.json")), access(join2(this.directory, "state.json"))]);
+      await Promise.all([access(join3(this.directory, "snapshot.json")), access(join3(this.directory, "journal.json")), access(join3(this.directory, "ownership.json")), access(join3(this.directory, "state.json"))]);
       return true;
     } catch {
       return false;
@@ -1206,18 +1248,18 @@ var RunStore = class _RunStore {
   }
   async load() {
     await this.stateLane.run(async () => void 0);
-    const rawRun = await json(join2(this.directory, "state.json"));
+    const rawRun = await json(join3(this.directory, "state.json"));
     const run = decodePersistedRun(rawRun, true);
     if (!run) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run is invalid");
     this.#assertRunIdentity(run, "RESUME_INCOMPATIBLE", "Persisted run belongs to another cwd or Pi session");
     if (!object(rawRun) || !Array.isArray(rawRun.agentSessions) || Object.hasOwn(rawRun, "nativeSessions")) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run uses an unsupported agent session format");
-    const snapshot = decodeLaunchSnapshot(await json(join2(this.directory, "snapshot.json")));
+    const snapshot = decodeLaunchSnapshot(await json(join3(this.directory, "snapshot.json")));
     if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted launch snapshot is invalid");
     return { run, snapshot: loadLaunchSnapshot(snapshot) };
   }
   async loadStatus() {
     await this.stateLane.run(async () => void 0);
-    const run = decodePersistedRun(await json(join2(this.directory, "state.json")), true);
+    const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
     if (!run) throw new WorkflowError("RUN_NOT_FOUND", "Persisted run is invalid");
     this.#assertRunIdentity(run, "RUN_NOT_FOUND", "Persisted run does not belong to this project");
     return run;
@@ -1226,11 +1268,11 @@ var RunStore = class _RunStore {
     await this.stateLane.run(async () => void 0);
     await this.journalLane.run(async () => void 0);
     await this.summaryLane.run(async () => void 0);
-    const run = decodePersistedRun(await json(join2(this.directory, "state.json")), true);
-    const journal = decodeJournal(await json(join2(this.directory, "journal.json")));
-    const previous = await json(join2(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
+    const run = decodePersistedRun(await json(join3(this.directory, "state.json")), true);
+    const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
+    const previous = await json(join3(this.directory, "summary.json")).then(decodeSummaryProjection).catch(() => void 0);
     if (!run || !journal) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run or journal is invalid");
-    const [stateStat, journalStat] = await Promise.all([stat2(join2(this.directory, "state.json")), stat2(join2(this.directory, "journal.json"))]);
+    const [stateStat, journalStat] = await Promise.all([stat2(join3(this.directory, "state.json")), stat2(join3(this.directory, "journal.json"))]);
     const fallbackCreatedAt = new Date(stateStat.mtimeMs).toISOString();
     const previousUpdatedAt = previous?.updatedAt === void 0 ? Number.NaN : Date.parse(previous.updatedAt);
     const updatedAt = new Date(Math.max(stateStat.mtimeMs, journalStat.mtimeMs, Number.isNaN(previousUpdatedAt) ? 0 : previousUpdatedAt)).toISOString();
@@ -1239,41 +1281,55 @@ var RunStore = class _RunStore {
   async saveState(run) {
     const write = this.stateLane.run(async () => {
       this.#assertRunIdentity(run, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
-      await atomicJson(join2(this.directory, "state.json"), run);
+      await atomicJson(join3(this.directory, "state.json"), run);
       this.refreshSummaryBestEffort();
     });
     await write;
   }
   async updateState(update) {
     const write = this.stateLane.run(async () => {
-      const current = decodePersistedRun(await json(join2(this.directory, "state.json")));
+      const current = decodePersistedRun(await json(join3(this.directory, "state.json")));
       if (!current) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted run is invalid");
       this.#assertRunIdentity(current, "RESUME_INCOMPATIBLE", "Persisted run belongs to another cwd or Pi session");
       const result = await update(current);
       this.#assertRunIdentity(result, "INTERNAL_ERROR", "Run identity does not match its session-scoped store");
-      await atomicJson(join2(this.directory, "state.json"), result);
+      await atomicJson(join3(this.directory, "state.json"), result);
       this.refreshSummaryBestEffort();
       return result;
     });
     return write;
   }
+  async saveAgentConfiguration(key, configuration) {
+    await this.launchSnapshotLane.run(async () => {
+      const snapshot = decodeLaunchSnapshot(await json(join3(this.directory, "snapshot.json")));
+      if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
+      await atomicJson(join3(this.directory, "snapshot.json"), { ...snapshot, agentConfigurations: { ...snapshot.agentConfigurations, [key]: configuration } });
+    });
+  }
+  async setLaunchMode(launchMode) {
+    await this.launchSnapshotLane.run(async () => {
+      const snapshot = decodeLaunchSnapshot(await json(join3(this.directory, "snapshot.json")));
+      if (!snapshot) throw new WorkflowError("RESUME_INCOMPATIBLE", "Workflow launch snapshot identity version is incompatible");
+      await atomicJson(join3(this.directory, "snapshot.json"), { ...snapshot, launchMode });
+    });
+  }
   async saveSnapshot(snapshot) {
-    const write = this.launchSnapshotLane.run(() => atomicJson(join2(this.directory, "snapshot.json"), snapshot));
+    const write = this.launchSnapshotLane.run(() => atomicJson(join3(this.directory, "snapshot.json"), snapshot));
     await write;
   }
   async appendEvent(event) {
     await this.updateState((run) => ({ ...run, events: [...run.events ?? [], ...event.type !== "log" && run.events?.some((current) => current.type === event.type && current.message === event.message) ? [] : [event]] }));
   }
   async saveOwnership(nodes) {
-    await atomicJson(join2(this.directory, "ownership.json"), nodes);
+    await atomicJson(join3(this.directory, "ownership.json"), nodes);
   }
   async loadOwnership() {
-    const nodes = decodeOwnershipRecords(await json(join2(this.directory, "ownership.json")));
+    const nodes = decodeOwnershipRecords(await json(join3(this.directory, "ownership.json")));
     if (!nodes) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted ownership records are invalid");
     return nodes;
   }
   systemPromptPath() {
-    return join2(this.directory, "system-prompts.json");
+    return join3(this.directory, "system-prompts.json");
   }
   async readSystemPromptArtifact() {
     try {
@@ -1287,7 +1343,7 @@ var RunStore = class _RunStore {
   }
   async appendSystemPromptV2(entry) {
     const sha256 = createHash2("sha256").update(entry.prompt).digest("hex");
-    const bodyPath = join2(systemPromptBodiesPath(this.directory), sha256);
+    const bodyPath = join3(systemPromptBodiesPath(this.directory), sha256);
     try {
       await access(bodyPath);
     } catch (error) {
@@ -1299,7 +1355,7 @@ var RunStore = class _RunStore {
     const sequence = previous + 1;
     await atomicWriteFile(systemPromptSequencePath(this.directory), `${String(sequence)}
 `);
-    await atomicJson(join2(systemPromptRecordsPath(this.directory), systemPromptRecordName(sequence)), { sessionId: entry.sessionId, attempt: entry.attempt, turn: entry.turn, sha256 });
+    await atomicJson(join3(systemPromptRecordsPath(this.directory), systemPromptRecordName(sequence)), { sessionId: entry.sessionId, attempt: entry.attempt, turn: entry.turn, sha256 });
   }
   async migrateSystemPrompts(legacy) {
     await rm3(systemPromptStoragePath(this.directory), { recursive: true, force: true });
@@ -1331,14 +1387,14 @@ var RunStore = class _RunStore {
       const recordSequence = Number(match[1]);
       if (!Number.isSafeInteger(recordSequence) || recordSequence < 1) throw new Error("Persisted system-prompt records are invalid");
       highest = Math.max(highest, recordSequence);
-      const record2 = await json(join2(systemPromptRecordsPath(this.directory), name));
+      const record2 = await json(join3(systemPromptRecordsPath(this.directory), name));
       if (!object(record2)) throw new Error("Persisted system-prompt record is invalid");
       const sessionId = record2.sessionId;
       const attempt = record2.attempt;
       const turn = record2.turn;
       const sha256 = record2.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(join2(systemPromptBodiesPath(this.directory), sha256), "utf8");
+      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");
       entries.push({ sessionId, attempt, turn, sha256, prompt });
     }
@@ -1361,7 +1417,7 @@ var RunStore = class _RunStore {
     throw new Error("Persisted system prompts are invalid");
   }
   async #decodeJournal() {
-    const journal = decodeJournal(await json(join2(this.directory, "journal.json")));
+    const journal = decodeJournal(await json(join3(this.directory, "journal.json")));
     if (!journal) throw new WorkflowError("RESUME_INCOMPATIBLE", "Persisted journal is invalid");
     return journal;
   }
@@ -1375,7 +1431,7 @@ var RunStore = class _RunStore {
       const journal = await this.#decodeJournal();
       journal.awaiting ??= {};
       const result = await update(journal);
-      await atomicJson(join2(this.directory, "journal.json"), journal);
+      await atomicJson(join3(this.directory, "journal.json"), journal);
       this.refreshSummaryBestEffort();
       return result;
     });
@@ -1485,10 +1541,10 @@ var RunStore = class _RunStore {
   }
   expectedWorktree(owner) {
     const key = this.#worktreeKey(owner);
-    return { path: join2(this.directory, "worktrees", key), branch: `pi-extensible-workflows/${safePart(this.runId)}/${key}` };
+    return { path: join3(this.directory, "worktrees", key), branch: `pi-extensible-workflows/${safePart(this.runId)}/${key}` };
   }
   markerPath(owner) {
-    return join2(this.directory, `worktree-${this.#worktreeKey(owner)}.creating`);
+    return join3(this.directory, `worktree-${this.#worktreeKey(owner)}.creating`);
   }
   namedWorktreeOwner(name) {
     if (!name.trim()) throw new WorkflowError("WORKTREE_FAILED", "Named worktree names must be non-empty");
@@ -1531,13 +1587,13 @@ var RunStore = class _RunStore {
   }
   structuralWorktree(owner, record2) {
     const expected = this.expectedWorktree(owner);
-    const relativePath = relative(this.directory, record2.path);
-    const relativeCwd = relative(record2.path, record2.cwd);
-    if (record2.owner !== owner || resolve2(record2.path) !== expected.path || record2.branch !== expected.branch || relativePath === ".." || relativePath.startsWith(`..${sep}`) || relativeCwd === ".." || relativeCwd.startsWith(`..${sep}`)) throw new Error(`Invalid worktree record for ${owner}`);
+    const relativePath = relative2(this.directory, record2.path);
+    const relativeCwd = relative2(record2.path, record2.cwd);
+    if (record2.owner !== owner || resolve2(record2.path) !== expected.path || record2.branch !== expected.branch || relativePath === ".." || relativePath.startsWith(`..${sep2}`) || relativeCwd === ".." || relativeCwd.startsWith(`..${sep2}`)) throw new Error(`Invalid worktree record for ${owner}`);
     return record2;
   }
   async #loadWorktreeRecords(missingOk = true) {
-    const rawRecords = await json(join2(this.directory, "worktrees.json")).catch((error) => {
+    const rawRecords = await json(join3(this.directory, "worktrees.json")).catch((error) => {
       if (missingOk && isNodeError(error, "ENOENT")) return [];
       throw error;
     });
@@ -1547,7 +1603,7 @@ var RunStore = class _RunStore {
   }
   async borrowedWorktreeRecords(wait = true) {
     if (wait) await this.borrowedWorktreeLane.run(async () => void 0);
-    const rawRecords = await json(join2(this.directory, "borrowed-worktrees.json")).catch((error) => {
+    const rawRecords = await json(join3(this.directory, "borrowed-worktrees.json")).catch((error) => {
       if (isNodeError(error, "ENOENT")) return [];
       throw error;
     });
@@ -1672,11 +1728,11 @@ var RunStore = class _RunStore {
         const reference = this.structuralWorktree(owner, record2);
         paths.add(resolve2(reference.path));
       }
-      const entries = await readdir2(join2(this.directory, "worktrees"), { withFileTypes: true }).catch((error) => {
+      const entries = await readdir2(join3(this.directory, "worktrees"), { withFileTypes: true }).catch((error) => {
         if (isNodeError(error, "ENOENT")) return [];
         throw error;
       });
-      for (const entry of entries) if (!entry.isDirectory() || entry.isSymbolicLink() || !paths.has(resolve2(join2(this.directory, "worktrees", entry.name)))) throw new Error(`Unrecorded worktree artifact: ${join2(this.directory, "worktrees", entry.name)}`);
+      for (const entry of entries) if (!entry.isDirectory() || entry.isSymbolicLink() || !paths.has(resolve2(join3(this.directory, "worktrees", entry.name)))) throw new Error(`Unrecorded worktree artifact: ${join3(this.directory, "worktrees", entry.name)}`);
     } catch (error) {
       throw coerceWorkflowError("WORKTREE_FAILED", error);
     }
@@ -1728,7 +1784,7 @@ var RunStore = class _RunStore {
   }
   async cleanupOrphanWorktrees() {
     const entries = await readdir2(this.directory).catch(() => []);
-    for (const entry of entries.filter((name) => name.endsWith(".creating"))) await this.cleanupMarker(join2(this.directory, entry));
+    for (const entry of entries.filter((name) => name.endsWith(".creating"))) await this.cleanupMarker(join3(this.directory, entry));
   }
   async validateWorktree(owner, cwd) {
     try {
@@ -1771,8 +1827,8 @@ var RunStore = class _RunStore {
       try {
         const root = (await git(this.cwd, ["rev-parse", "--show-toplevel"])).trim();
         const [canonicalRoot, canonicalCwd] = await Promise.all([realpath(root), realpath(this.cwd)]);
-        const launchRelative = relative(canonicalRoot, canonicalCwd);
-        if (launchRelative === ".." || launchRelative.startsWith(`..${sep}`)) throw new Error("launch cwd is outside the repository");
+        const launchRelative = relative2(canonicalRoot, canonicalCwd);
+        if (launchRelative === ".." || launchRelative.startsWith(`..${sep2}`)) throw new Error("launch cwd is outside the repository");
         await this.cleanupMarker(markerPath);
         const dirty = (await git(root, ["status", "--porcelain", "--untracked-files=normal"])).trim();
         if (dirty) {
@@ -1788,7 +1844,7 @@ var RunStore = class _RunStore {
           throw new Error("repository has no commits");
         }
         await mkdir2(dirname(path), { recursive: true, mode: 448 });
-        const record2 = { owner, path, branch, cwd: join2(path, launchRelative), base: commit };
+        const record2 = { owner, path, branch, cwd: join3(path, launchRelative), base: commit };
         await atomicJson(markerPath, { owner, path, branch, base: commit });
         markerWritten = true;
         await git(root, ["branch", branch, commit]);
@@ -1833,7 +1889,7 @@ var RunStore = class _RunStore {
         return;
       }
       records.push(binding);
-      await atomicJson(join2(this.directory, "borrowed-worktrees.json"), records);
+      await atomicJson(join3(this.directory, "borrowed-worktrees.json"), records);
     });
     await write;
   }
@@ -1914,12 +1970,12 @@ var RunStore = class _RunStore {
     return changed;
   }
   async saveResult(value) {
-    const path = join2(this.directory, "result.json");
+    const path = join3(this.directory, "result.json");
     await atomicPrettyJson(path, value);
     return path;
   }
   async resultBytes() {
-    return (await stat2(join2(this.directory, "result.json"))).size;
+    return (await stat2(join3(this.directory, "result.json"))).size;
   }
   async delete(confirmed) {
     if (!confirmed) throw new WorkflowError("CANCELLED", "Run deletion requires confirmation");
@@ -1942,19 +1998,20 @@ var RunStore = class _RunStore {
 
 // src/settings.ts
 import { mkdirSync, readFileSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2, join as join3, resolve as resolve3 } from "node:path";
-import { fileURLToPath } from "node:url";
+import { dirname as dirname2, join as join4 } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-var ROLE_DIRECTORY = "pi-extensible-workflows";
+import { homedir as homedir3 } from "node:os";
+import { resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var WORKFLOW_DIRECTORY = "pi-extensible-workflows";
 var DEFAULT_SETTINGS = Object.freeze({ concurrency: 8, backgroundWidget: true });
 function workflowSettingsPath(agentDir = getAgentDir()) {
-  return join3(agentDir, ROLE_DIRECTORY, "settings.json");
+  return join4(agentDir, WORKFLOW_DIRECTORY, "settings.json");
 }
 function normalizedResourcePath(value, settingsPath) {
-  if (value === "*") return value;
-  let expanded = value === "~" ? homedir3() : value.startsWith("~/") || value.startsWith("~\\") ? join3(homedir3(), value.slice(2)) : value;
-  if (expanded.startsWith("file://")) expanded = fileURLToPath(expanded);
+  if (value === "*" || value.startsWith("builtin:")) return value;
+  let expanded = value === "~" ? homedir3() : value.startsWith("~/") || value.startsWith("~\\") ? join4(homedir3(), value.slice(2)) : value;
+  if (expanded.startsWith("file://")) expanded = fileURLToPath2(expanded);
   const resolved = resolve3(dirname2(settingsPath), expanded);
   if (expanded === "**" || expanded.startsWith("**/") || expanded.startsWith("**\\")) return expanded;
   if (resourcePatternHasMagic(expanded)) {
@@ -2011,18 +2068,19 @@ function selectorsFromSettings(settings) {
 function selectorSet(value) {
   return { skills: [...value?.skills ?? []], extensions: [...value?.extensions ?? []], ...value?.tools === void 0 ? {} : { tools: [...value.tools] } };
 }
-function validateContextFileScopes(value, rolePath) {
+function validateContextFileScopes(value, sourcePath) {
   if (value === void 0) return void 0;
-  if (!Array.isArray(value) || !value.every(isContextFileScope)) fail("INVALID_METADATA", `${rolePath}.contextFiles must be an array containing only global, project, or cwd`);
+  if (!Array.isArray(value) || !value.every(isContextFileScope)) fail("INVALID_METADATA", `${sourcePath}.contextFiles must be an array containing only global, project, or cwd`);
   return [...value];
 }
 function validateWorkflowExtensionSettings(value, settingsPath, errorCode2 = "INVALID_SETTINGS") {
   if (value === void 0) return void 0;
+  if (!object(value) || !jsonValue(value)) fail(errorCode2, `${settingsPath}.extensionSettings must be a JSON object`);
+  for (const namespace of Object.keys(value)) if (!validWorkflowExtensionNamespace(namespace)) fail(errorCode2, `${settingsPath}.extensionSettings contains an invalid namespace: ${namespace}`);
+  const generic = value;
   const base = `${settingsPath}.extensionSettings`;
-  if (!object(value)) fail(errorCode2, `${base} must be an object`);
   const normalized = {};
-  for (const [namespace, raw] of Object.entries(value)) {
-    if (!validWorkflowExtensionNamespace(namespace)) fail(errorCode2, `${base} contains an invalid namespace: ${namespace}`);
+  for (const [namespace, raw] of Object.entries(generic)) {
     if (namespace === "herdr") {
       if (!object(raw)) fail(errorCode2, `${base}.herdr must be an object`);
       if (Object.keys(raw).some((key) => key !== "enableFullyInspectableMode")) fail(errorCode2, `${base}.herdr contains an unsupported setting`);
@@ -2037,7 +2095,6 @@ function validateWorkflowExtensionSettings(value, settingsPath, errorCode2 = "IN
       normalized.trajectory = Object.freeze({ ...raw.port === void 0 ? {} : { port: raw.port } });
       continue;
     }
-    if (!jsonValue(raw)) fail(errorCode2, `${base}.${namespace} must be JSON-compatible`);
     normalized[namespace] = structuredClone(raw);
   }
   return deepFreeze(normalized);
@@ -2064,7 +2121,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}`);
@@ -2072,6 +2129,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");
@@ -2082,6 +2141,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 },
@@ -2094,46 +2154,38 @@ 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);
 }
 function resolveWorkflowSettings(cwd, projectTrusted, globalSettingsPath = workflowSettingsPath()) {
   const projectSettingsPath = workflowProjectSettingsPath(cwd);
-  const global = loadSettings(globalSettingsPath);
-  const project = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
-  const projectHas = (key) => Object.prototype.hasOwnProperty.call(project, key);
-  const sourceFor = (key) => projectHas(key) ? projectSettingsPath : globalSettingsPath;
-  const globalSelectors = selectorsFromSettings(global);
-  const projectSelectors = selectorsFromSettings(project);
-  const effectiveSelectors = selectorSet({
-    skills: [...globalSelectors.skills ?? [], ...projectSelectors.skills ?? []],
-    extensions: [...globalSelectors.extensions ?? [], ...projectSelectors.extensions ?? []],
-    ...globalSelectors.tools === void 0 && projectSelectors.tools === void 0 ? {} : { tools: [...globalSelectors.tools ?? [], ...projectSelectors.tools ?? []] }
-  });
-  const hasExtensionSelectors = global.extensions !== void 0 || project.extensions !== void 0;
-  const extensionSettings = projectHas("extensionSettings") ? project.extensionSettings : global.extensionSettings;
-  const sources = {
-    concurrency: projectHas("concurrency") ? projectSettingsPath : globalSettingsPath,
-    modelAliases: projectHas("modelAliases") ? projectSettingsPath : globalSettingsPath,
-    skills: sourceFor("skills"),
-    extensions: sourceFor("extensions"),
-    tools: sourceFor("tools"),
-    ...extensionSettings === void 0 ? {} : { extensionSettings: projectHas("extensionSettings") ? projectSettingsPath : globalSettingsPath },
-    ...project.retention === void 0 && global.retention === void 0 ? {} : { retention: project.retention === void 0 ? globalSettingsPath : projectSettingsPath },
-    ...projectHas("worktreePostCreateCommand") || global.worktreePostCreateCommand !== void 0 ? { worktreePostCreateCommand: projectHas("worktreePostCreateCommand") ? projectSettingsPath : globalSettingsPath } : {}
-  };
+  const consumerGlobal = loadSettings(globalSettingsPath);
+  const consumerProject = projectTrusted ? loadSettingsOverrides(projectSettingsPath) : Object.freeze({});
+  const global = consumerGlobal;
+  const project = consumerProject;
+  const selectorSources = { global: selectorsFromSettings(global), project: selectorsFromSettings(project) };
   const effective = Object.freeze({
-    concurrency: project.concurrency ?? global.concurrency,
-    backgroundWidget: global.backgroundWidget ?? true,
-    ...projectHas("modelAliases") ? { modelAliases: project.modelAliases } : global.modelAliases === void 0 ? {} : { modelAliases: global.modelAliases },
-    ...effectiveSelectors.skills.length ? { skills: effectiveSelectors.skills } : global.skills !== void 0 || project.skills !== void 0 ? { skills: effectiveSelectors.skills } : {},
-    ...hasExtensionSelectors ? { extensions: effectiveSelectors.extensions } : {},
-    ...extensionSettings === void 0 ? {} : { extensionSettings },
-    ...effectiveSelectors.tools?.length ? { tools: effectiveSelectors.tools } : global.tools !== void 0 || project.tools !== void 0 ? { tools: effectiveSelectors.tools } : {},
-    ...(project.retention ?? global.retention) === void 0 ? {} : { retention: project.retention ?? global.retention },
-    ...projectHas("worktreePostCreateCommand") ? { worktreePostCreateCommand: project.worktreePostCreateCommand } : global.worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand: global.worktreePostCreateCommand }
+    ...global,
+    ...project,
+    skills: [...global.skills ?? [], ...project.skills ?? []],
+    extensions: [...global.extensions ?? [], ...project.extensions ?? []],
+    ...global.tools === void 0 && project.tools === void 0 ? {} : { tools: [...global.tools ?? [], ...project.tools ?? []] }
   });
-  return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources };
+  const sources = { concurrency: project.concurrency === void 0 ? globalSettingsPath : projectSettingsPath, modelAliases: project.modelAliases === void 0 ? globalSettingsPath : projectSettingsPath };
+  for (const key of ["skills", "extensions", "tools", "extensionSettings", "retention", "worktreePostCreateCommand"]) if (effective[key] !== void 0) sources[key] = project[key] === void 0 ? globalSettingsPath : projectSettingsPath;
+  return { globalSettingsPath, projectSettingsPath, projectTrusted, global, project, effective, sources, selectorSources };
 }
 function validateModelAliasAvailability(aliases, names, availableModels, knownModels, settingsPath) {
   for (const name of names) {
@@ -2150,42 +2202,63 @@ function resolveAgentResourcePolicy(cwd, projectTrusted, globalSettingsPath = wo
   const global = selectorSet(selectorsFromSettings(resolved.global));
   const project = selectorSet(selectorsFromSettings(resolved.project));
   const effective = selectorSet(selectorsFromSettings(resolved.effective));
-  return { globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted, global, project, effective, unmatchedSkills: [], unmatchedExtensions: [], unmatchedTools: [], selectorSources: { global: selectorsFromSettings(resolved.global), project: selectorsFromSettings(resolved.project) } };
+  return { globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted, global, project, effective, unmatchedSkills: [], unmatchedExtensions: [], unmatchedTools: [], selectorSources: resolved.selectorSources };
+}
+function canonicalExtensionSelector(selector, cwd) {
+  const negated = selector.startsWith("!");
+  return `${negated ? "!" : ""}${normalizedResourcePath(negated ? selector.slice(1) : selector, join4(cwd, "settings.json"))}`;
+}
+
+// src/validation.ts
+var AGENT_OPTION_KEYS = /* @__PURE__ */ new Set(["label", "model", "tools", "excludeTools", "skills", "extensions", "contextFiles", "outputSchema", "retries", "timeoutMs"]);
+function isCoreAgentOption(key) {
+  return AGENT_OPTION_KEYS.has(key);
+}
+function validateAgentOption(key, value) {
+  switch (key) {
+    case "label":
+      if (typeof value !== "string" || !value.trim()) fail("INVALID_METADATA", "agent label must be a non-empty string");
+      break;
+    case "model":
+      if (typeof value !== "string" || !value.trim()) fail("INVALID_METADATA", "agent model must be a non-empty string");
+      assertModelThinking(value, "agent model");
+      break;
+    case "tools":
+    case "skills":
+    case "extensions":
+      validateSelectorList(value, "agent options", key, "INVALID_METADATA", key !== "extensions");
+      break;
+    case "excludeTools":
+      if (!Array.isArray(value) || value.some((tool) => typeof tool !== "string" || !tool.trim() || tool !== tool.trim() || tool.startsWith("!") || resourcePatternHasMagic(tool))) fail("INVALID_METADATA", "agent excludeTools must be an array of exact tool names");
+      if (value.includes("workflow_result")) fail("INVALID_METADATA", "agent excludeTools cannot remove workflow_result");
+      break;
+    case "contextFiles":
+      validateContextFileScopes(value, "agent options");
+      break;
+    case "outputSchema":
+      validateSchema(value, "agent outputSchema");
+      break;
+    case "retries":
+      if (typeof value !== "number" || !Number.isInteger(value) || value < 0) fail("INVALID_METADATA", "agent retries must be a non-negative integer");
+      break;
+    case "timeoutMs":
+      if (value !== null && !positiveInteger(value)) fail("INVALID_METADATA", "agent timeoutMs must be null or a positive integer");
+      break;
+  }
+}
+function validateAgentOptions(value) {
+  if (!object(value) || !jsonValue(value)) fail("INVALID_METADATA", "agent options must be a JSON object");
+  if (Object.prototype.hasOwnProperty.call(value, "thinking")) fail("INVALID_METADATA", "agent thinking is not supported; use model provider/model:thinking");
+  for (const [key, option] of Object.entries(value)) if (AGENT_OPTION_KEYS.has(key)) validateAgentOption(key, option);
+  return value;
 }
 
 // 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"]);
+import { Value } from "typebox/value";
+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._-]*$/;
-function normalizeRoleDirectory(value) {
-  try {
-    if (value instanceof URL) {
-      if (value.protocol !== "file:") fail("INVALID_METADATA", "Workflow role directories require file URLs or absolute filesystem paths");
-      return fileURLToPath2(value);
-    }
-    if (typeof value === "string") {
-      if (value.startsWith("file:")) return fileURLToPath2(value);
-      if (isAbsolute(value)) return value;
-    }
-  } catch (error) {
-    fail("INVALID_METADATA", `Invalid workflow role directory: ${errorText(error)}`);
-  }
-  fail("INVALID_METADATA", "Workflow role directories require file URLs or absolute filesystem paths");
-}
-function isBuiltinRoleDirectory(path) {
-  const canonical = canonicalPath(path);
-  const starterDirectory = dirname3(canonical);
-  if (basename2(canonical) !== "roles" || basename2(starterDirectory) !== "starter") return false;
-  const distributionDirectory = dirname3(starterDirectory);
-  const packageRoot2 = basename2(distributionDirectory) === "dist" ? dirname3(distributionDirectory) : distributionDirectory;
-  try {
-    const metadata = JSON.parse(readFileSync2(join4(packageRoot2, "package.json"), "utf8"));
-    return object(metadata) && isCorePackageName(metadata.name);
-  } catch {
-    return false;
-  }
-}
 function catalogSchema(schema, at) {
   validateSchema(schema, at);
   return structuredClone(schema);
@@ -2194,9 +2267,9 @@ var WorkflowRegistry = class {
   #extensions = /* @__PURE__ */ new Set();
   #functionSources = /* @__PURE__ */ new Map();
   #globals = /* @__PURE__ */ new Map();
+  #preparationHooks = /* @__PURE__ */ new Map();
   #hooks = /* @__PURE__ */ new Map();
   #agentAttemptActions = /* @__PURE__ */ new Map();
-  #roleDirectories = /* @__PURE__ */ new Map();
   #modelAliases = /* @__PURE__ */ new Map();
   #settingsValidators = /* @__PURE__ */ new Set();
   #frozen = false;
@@ -2216,9 +2289,10 @@ var WorkflowRegistry = class {
   register(extension2) {
     if (this.#frozen) fail("REGISTRY_FROZEN", "Workflow extension registration is closed after session_start");
     if (object(extension2) && Object.prototype.hasOwnProperty.call(extension2, "workflows")) fail("INVALID_METADATA", "Separate registered workflow definitions were removed; register a function with input and output schemas instead");
-    if (!object(extension2) || Object.keys(extension2).some((key) => !["version", "headline", "description", "source", "dependencies", "validateSettings", "functions", "modelAliases", "agentSetupHooks", "agentAttemptActions", "roleDirectories"].includes(key)) || typeof extension2.version !== "string" || !SEMVER.test(extension2.version) || typeof extension2.headline !== "string" || !extension2.headline.trim()) fail("INVALID_METADATA", "Workflow extensions require a semantic version and non-empty headline");
+    if (!object(extension2) || Object.keys(extension2).some((key) => !["version", "headline", "description", "source", "dependencies", "validateSettings", "functions", "modelAliases", "agentPreparationHooks", "agentSetupHooks", "agentAttemptActions"].includes(key)) || typeof extension2.version !== "string" || !SEMVER.test(extension2.version) || typeof extension2.headline !== "string" || !extension2.headline.trim()) fail("INVALID_METADATA", "Workflow extensions require a semantic version and non-empty headline");
     const functions = extension2.functions ?? {};
     const modelAliases = extension2.modelAliases ?? {};
+    const agentPreparationHooks = extension2.agentPreparationHooks ?? {};
     const agentSetupHooks = extension2.agentSetupHooks ?? {};
     const agentAttemptActions = extension2.agentAttemptActions ?? {};
     const source = extension2.source;
@@ -2228,10 +2302,7 @@ var WorkflowRegistry = class {
     if (validateSettings !== void 0 && typeof validateSettings !== "function") fail("INVALID_METADATA", "Workflow extension validateSettings must be a function");
     if (source !== void 0 && (typeof source !== "string" || !source.trim())) fail("INVALID_METADATA", "Workflow extension source must be a non-empty module URL");
     if (dependencyValues !== void 0 && (!Array.isArray(dependencyValues) || dependencyValues.some((dependency) => typeof dependency !== "string" || dependency.trim() !== dependency || !PACKAGE_NAME.test(dependency)) || new Set(dependencyValues).size !== dependencyValues.length)) fail("INVALID_METADATA", "Workflow extension dependencies must be unique, non-empty package names");
-    const roleDirectoryValues = extension2.roleDirectories === void 0 ? [] : extension2.roleDirectories;
-    if (!Array.isArray(roleDirectoryValues)) fail("INVALID_METADATA", "Workflow extension roleDirectories must be an array");
-    const roleDirectories = [...new Set(Array.from(roleDirectoryValues, (value) => normalizeRoleDirectory(value)))];
-    if (!object(functions) || !object(modelAliases) || !object(agentSetupHooks) || !object(agentAttemptActions) || Object.keys(functions).length === 0 && Object.keys(modelAliases).length === 0 && Object.keys(agentSetupHooks).length === 0 && Object.keys(agentAttemptActions).length === 0 && roleDirectories.length === 0 && validateSettings === void 0) fail("INVALID_METADATA", "Workflow extensions require functions, model aliases, agent setup hooks, agent attempt actions, role directories, or a settings validator");
+    if (!object(functions) || !object(modelAliases) || !object(agentPreparationHooks) || !object(agentSetupHooks) || !object(agentAttemptActions) || Object.keys(functions).length === 0 && Object.keys(modelAliases).length === 0 && Object.keys(agentPreparationHooks).length === 0 && Object.keys(agentSetupHooks).length === 0 && Object.keys(agentAttemptActions).length === 0 && validateSettings === void 0) fail("INVALID_METADATA", "Workflow extensions require functions, model aliases, agent preparation hooks, agent setup hooks, agent attempt actions, or a settings validator");
     const names = Object.keys(functions);
     if (new Set(names).size !== names.length) fail("GLOBAL_COLLISION", "Global name collision inside extension");
     for (const name of names) {
@@ -2250,6 +2321,11 @@ var WorkflowRegistry = class {
       if (!object(alias) || Object.keys(alias).some((key) => key !== "resolve") || typeof alias.resolve !== "function") fail("INVALID_METADATA", `Invalid model alias resolver: ${name}`);
       if (this.#modelAliases.has(name)) fail("DUPLICATE_NAME", `Model alias already registered: ${name}`);
     }
+    for (const [name, hook] of Object.entries(agentPreparationHooks)) {
+      if (!IDENTIFIER.test(name) || !object(hook) || Object.keys(hook).some((key) => !["priority", "optionsSchema", "prepare"].includes(key)) || typeof hook.prepare !== "function" || hook.priority !== void 0 && (typeof hook.priority !== "number" || !Number.isFinite(hook.priority))) fail("INVALID_METADATA", `Invalid agent preparation hook: ${name}`);
+      if (this.#preparationHooks.has(name)) fail("DUPLICATE_NAME", `Agent preparation hook already registered: ${name}`);
+      if (hook.optionsSchema !== void 0) validateSchema(hook.optionsSchema, `${name} options schema`);
+    }
     for (const [name, hook] of Object.entries(agentSetupHooks)) {
       if (!IDENTIFIER.test(name) || !object(hook) || Object.keys(hook).some((key) => !["priority", "setup"].includes(key)) || typeof hook.setup !== "function" || hook.priority !== void 0 && (typeof hook.priority !== "number" || !Number.isFinite(hook.priority))) fail("INVALID_METADATA", `Invalid agent setup hook: ${name}`);
       if (this.#hooks.has(name)) fail("DUPLICATE_NAME", `Agent setup hook already registered: ${name}`);
@@ -2259,16 +2335,20 @@ var WorkflowRegistry = class {
       if (action.visibleStandalone !== void 0 !== (action.runStandalone !== void 0)) fail("INVALID_METADATA", `Standalone agent attempt actions require visibleStandalone and runStandalone: ${name}`);
       if (this.#agentAttemptActions.has(name)) fail("DUPLICATE_NAME", `Agent attempt action already registered: ${name}`);
     }
-    const stored = deepFreeze({ ...extension2, functions, modelAliases, agentSetupHooks, agentAttemptActions, ...roleDirectories.length ? { roleDirectories } : {} });
+    const stored = deepFreeze({ ...extension2, functions, modelAliases, agentPreparationHooks, agentSetupHooks, agentAttemptActions });
     if (source !== void 0) for (const name of names) this.#functionSources.set(name, Object.freeze({ module: source, export: "default", dependencies: Object.freeze([...dependencies]) }));
     this.#extensions.add(stored);
-    for (const directory of roleDirectories) if (!this.#roleDirectories.has(directory)) this.#roleDirectories.set(directory, deepFreeze({ path: directory, extension: { version: extension2.version, headline: extension2.headline }, ...isBuiltinRoleDirectory(directory) ? { builtin: true } : {} }));
     for (const name of names) this.#globals.set(name, name);
     for (const [name, alias] of Object.entries(modelAliases)) this.#modelAliases.set(name, { name, version: extension2.version, headline: extension2.headline, resolve: alias.resolve });
+    for (const [name, hook] of Object.entries(agentPreparationHooks)) this.#preparationHooks.set(name, { name, priority: hook.priority ?? 10, prepare: hook.prepare, ...hook.optionsSchema === void 0 ? {} : { optionsSchema: structuredClone(hook.optionsSchema) }, ...source === void 0 ? {} : { source } });
     for (const [name, hook] of Object.entries(agentSetupHooks)) this.#hooks.set(name, { name, priority: hook.priority ?? 10, setup: hook.setup });
     for (const [name, action] of Object.entries(agentAttemptActions)) this.#agentAttemptActions.set(name, action);
     if (validateSettings !== void 0) this.#settingsValidators.add({ headline: extension2.headline, validate: validateSettings });
   }
+  /** Every registration's headline and declared module provenance, for hosts that must prove which extension made it. */
+  registrations() {
+    return [...this.#extensions].map(({ headline, source }) => Object.freeze({ headline, ...source === void 0 ? {} : { source } }));
+  }
   function(name) {
     if (!IDENTIFIER.test(name)) fail("MISSING_WORKFLOW", `Registered functions require an unqualified name: ${name}`);
     const fn = [...this.#extensions].find((extension2) => extension2.functions?.[name])?.functions?.[name];
@@ -2291,7 +2371,7 @@ var WorkflowRegistry = class {
     let source = "global settings";
     try {
       const resolved = context ? resolveWorkflowSettings(context.cwd, context.projectTrusted, context.globalSettingsPath) : void 0;
-      aliases = resolved?.effective.modelAliases ?? loadSettings().modelAliases;
+      aliases = resolved?.effective.modelAliases ?? (context ? loadSettings().modelAliases : resolveWorkflowSettings(process.cwd(), false).effective.modelAliases);
       if (resolved) {
         source = resolved.projectTrusted && [resolved.sources.modelAliases, resolved.sources.skills, resolved.sources.extensions, resolved.sources.tools].some((path) => path === resolved.projectSettingsPath) ? "trusted project settings" : "global settings";
         settings = { concurrency: resolved.effective.concurrency, backgroundWidget: resolved.effective.backgroundWidget ?? true, modelAliases: resolved.effective.modelAliases ?? {}, skills: resolved.effective.skills ?? [], extensions: Array.isArray(resolved.effective.extensions) ? resolved.effective.extensions : [], tools: resolved.effective.tools ?? [], ...resolved.effective.extensionSettings === void 0 ? {} : { extensionSettings: resolved.effective.extensionSettings }, ...resolved.effective.worktreePostCreateCommand === void 0 ? {} : { worktreePostCreateCommand: resolved.effective.worktreePostCreateCommand }, globalSettingsPath: resolved.globalSettingsPath, projectSettingsPath: resolved.projectSettingsPath, projectTrusted: resolved.projectTrusted, sources: resolved.sources };
@@ -2350,7 +2430,7 @@ var WorkflowRegistry = class {
       try {
         validate(frozenSettings, Object.freeze({ ...context }));
       } catch (error) {
-        const location = context.source === "role" && context.role ? `role ${context.role}` : context.source;
+        const location = context.source;
         fail("INVALID_SETTINGS", `Invalid extension settings (${headline}; ${location}): ${errorText(error)}`);
       }
     }
@@ -2369,18 +2449,15 @@ var WorkflowRegistry = class {
     journal.put(path, stored);
     return structuredClone(stored);
   }
+  agentPreparationHooks() {
+    return [...this.#preparationHooks.values()].sort(byPriorityThenName);
+  }
   agentSetupHooks() {
     return [...this.#hooks.values()].sort(byPriorityThenName);
   }
   agentAttemptActions() {
     return Object.freeze(Object.fromEntries(this.#agentAttemptActions.entries()));
   }
-  roleDirectories() {
-    return [...this.#roleDirectories.keys()];
-  }
-  roleDirectoryRegistrations() {
-    return [...this.#roleDirectories.values()];
-  }
   modelAliases() {
     return [...this.#modelAliases.values()].sort((left, right) => left.name.localeCompare(right.name));
   }
@@ -2436,10 +2513,10 @@ function createWorkflowRegistryApi(registry) {
     },
     modelAliases: () => registry.modelAliases(),
     resolveModelAliases: (...args) => registry.resolveModelAliases(...args),
-    roleDirectories: () => registry.roleDirectories(),
-    roleDirectoryRegistrations: () => registry.roleDirectoryRegistrations(),
+    agentPreparationHooks: () => registry.agentPreparationHooks(),
     agentSetupHooks: () => registry.agentSetupHooks(),
-    agentAttemptActions: () => registry.agentAttemptActions()
+    agentAttemptActions: () => registry.agentAttemptActions(),
+    registrations: () => registry.registrations()
   };
 }
 function workflowRegistryHost() {
@@ -2456,310 +2533,11 @@ function loadingRegistry() {
   return workflowRegistryHost().api;
 }
 beginWorkflowExtensionLoading();
-function registeredWorkflowRoleDirectoryRegistrations() {
-  const registrations = loadingRegistry().roleDirectoryRegistrations;
-  return typeof registrations === "function" ? registrations() : [];
-}
-
-// src/roles.ts
-var ROLE_DIRECTORY2 = "pi-extensible-workflows";
-var roleDefinitionPaths = /* @__PURE__ */ new WeakMap();
-function parseRoleMarkdown(content, strict = false, rolePath) {
-  if (!strict) {
-    if (!content.startsWith("---\n")) return { prompt: content };
-    const end = content.indexOf("\n---", 4);
-    if (end < 0) return { prompt: content };
-    const meta = {};
-    for (const line of content.slice(4, end).split("\n")) {
-      const match = /^(model|tools|skills|extensions|description|overrideSystemPrompt|override_system_prompt|is_system_prompt|contextFiles|extensionSettings|disabledAgentResources|thinking)\s*:\s*(.+)$/.exec(line.trim());
-      if (match?.[1] === "disabledAgentResources") fail("INVALID_METADATA", "disabledAgentResources is no longer supported; use skills, extensions, and tools selectors");
-      if (match?.[1] === "thinking") fail("INVALID_METADATA", "Role thinking is not supported; put it on model as provider/model:thinking");
-      if (match?.[1] && match[2]) meta[match[1]] = match[2].trim();
-    }
-    const unquote = (v) => v.replace(/^['"]|['"]$/g, "");
-    const parseList = (value) => value === void 0 ? void 0 : value.replace(/^\[|\]$/g, "").split(",").map((entry) => unquote(entry.trim())).filter(Boolean);
-    const tools2 = parseList(meta.tools);
-    const skills2 = parseList(meta.skills);
-    const extensions2 = parseList(meta.extensions);
-    let extensionSettings2;
-    if (meta.extensionSettings !== void 0) {
-      try {
-        extensionSettings2 = JSON.parse(meta.extensionSettings);
-      } catch (error) {
-        fail("INVALID_METADATA", `Invalid role extensionSettings: ${errorText(error)}`);
-      }
-    }
-    const rolePathValue2 = rolePath ?? "<role>";
-    const normalizedExtensionSettings2 = validateWorkflowExtensionSettings(extensionSettings2, rolePathValue2, "INVALID_METADATA");
-    const definition2 = { prompt: content.slice(end + 4).replace(/^\n/, "") };
-    if (meta.model) {
-      const model2 = unquote(meta.model);
-      assertModelThinking(model2, "Role model");
-      definition2.model = model2;
-    }
-    if (meta.description) definition2.description = unquote(meta.description);
-    if (tools2) definition2.tools = tools2;
-    if (skills2) definition2.skills = skills2;
-    if (extensions2) definition2.extensions = extensions2;
-    if (normalizedExtensionSettings2 !== void 0) definition2.extensionSettings = normalizedExtensionSettings2;
-    const overrideSystemPrompt2 = meta.overrideSystemPrompt ?? meta.override_system_prompt ?? meta.is_system_prompt;
-    const contextFiles2 = meta.contextFiles ? meta.contextFiles.replace(/^\[|\]$/g, "").split(",").map((scope) => unquote(scope.trim())).filter(Boolean) : void 0;
-    const normalizedContextFiles2 = validateContextFileScopes(contextFiles2, "role");
-    if (overrideSystemPrompt2) definition2.overrideSystemPrompt = overrideSystemPrompt2 === "true";
-    if (normalizedContextFiles2) definition2.contextFiles = normalizedContextFiles2;
-    return definition2;
-  }
-  const normalized = content.replace(/\r\n?/g, "\n");
-  if (normalized.startsWith("---\n") && normalized.indexOf("\n---", 3) < 0) fail("INVALID_METADATA", "Role frontmatter is missing its closing delimiter");
-  let parsed;
-  try {
-    parsed = parseFrontmatter(content);
-  } catch (error) {
-    fail("INVALID_METADATA", `Invalid role frontmatter: ${errorText(error)}`);
-  }
-  if (!object(parsed.frontmatter)) fail("INVALID_METADATA", "Role frontmatter must be an object");
-  const { model, tools, skills, extensions, extensionSettings, description, contextFiles } = parsed.frontmatter;
-  if (Object.prototype.hasOwnProperty.call(parsed.frontmatter, "disabledAgentResources")) fail("INVALID_METADATA", "disabledAgentResources is no longer supported; use skills, extensions, and tools selectors");
-  if (Object.prototype.hasOwnProperty.call(parsed.frontmatter, "thinking")) fail("INVALID_METADATA", "Role thinking is not supported; put it on model as provider/model:thinking");
-  const overrideSystemPrompt = parsed.frontmatter.overrideSystemPrompt ?? parsed.frontmatter.override_system_prompt ?? parsed.frontmatter.is_system_prompt;
-  if (model !== void 0 && (typeof model !== "string" || model.trim() === "")) fail("INVALID_METADATA", "Role model must be a non-empty string");
-  if (description !== void 0 && (typeof description !== "string" || description.trim() === "" || description.length > 1024 || /[\r\n]/.test(description))) fail("INVALID_METADATA", "Role description must be a non-empty single-line string of at most 1024 characters");
-  if (overrideSystemPrompt !== void 0 && typeof overrideSystemPrompt !== "boolean") fail("INVALID_METADATA", "Role overrideSystemPrompt must be a boolean");
-  const normalizedContextFiles = validateContextFileScopes(contextFiles, rolePath ?? "<role>");
-  const rolePathValue = rolePath ?? "<role>";
-  const normalizedTools = validateSelectorList(tools, rolePathValue, "tools", "INVALID_METADATA");
-  const normalizedSkills = validateSelectorList(skills, rolePathValue, "skills", "INVALID_METADATA");
-  const normalizedExtensions = validateSelectorList(extensions, rolePathValue, "extensions", "INVALID_METADATA");
-  const normalizedExtensionSettings = validateWorkflowExtensionSettings(extensionSettings, rolePathValue, "INVALID_METADATA");
-  const normalizedDescription = typeof description === "string" ? description.trim() : void 0;
-  const normalizedModel = typeof model === "string" ? model.trim() : void 0;
-  if (normalizedModel !== void 0) assertModelThinking(normalizedModel, "Role model");
-  const definition = { prompt: parsed.body };
-  if (normalizedDescription !== void 0) definition.description = normalizedDescription;
-  if (normalizedModel !== void 0) definition.model = normalizedModel;
-  if (normalizedTools !== void 0) definition.tools = normalizedTools;
-  if (normalizedSkills !== void 0) definition.skills = normalizedSkills;
-  if (normalizedExtensions !== void 0) definition.extensions = normalizedExtensions;
-  if (normalizedExtensionSettings !== void 0) definition.extensionSettings = normalizedExtensionSettings;
-  if (typeof overrideSystemPrompt === "boolean") definition.overrideSystemPrompt = overrideSystemPrompt;
-  if (normalizedContextFiles !== void 0) definition.contextFiles = normalizedContextFiles;
-  return definition;
-}
-function workflowRoleDirectories(agentDir = getAgentDir2()) {
-  return [join5(agentDir, ROLE_DIRECTORY2, "roles")];
-}
-function projectRoleDirectories(root) {
-  return [join5(root, ROLE_DIRECTORY2, "roles")];
-}
-function roleDirectorySources(dirs) {
-  const seen = /* @__PURE__ */ new Set();
-  return dirs.flatMap((value) => {
-    const source = typeof value === "string" ? { path: value } : { path: value.path, extension: value.extension, ...value.builtin === true ? { builtin: true } : {} };
-    if (seen.has(source.path)) return [];
-    seen.add(source.path);
-    return [source];
-  });
-}
-function roleDirectoryLabel(source, extension2 = true) {
-  return source.extension ? `Extension "${source.extension.headline}" (${source.extension.version})` : extension2 ? "Registered workflow extension" : "Standard workflow";
-}
-function isRoleFile(dir, entry) {
-  if (extname(entry.name) !== ".md") return false;
-  if (entry.isFile()) return true;
-  if (!entry.isSymbolicLink()) return false;
-  try {
-    return statSync(join5(dir, entry.name)).isFile();
-  } catch (error) {
-    if (isNodeError(error, "ENOENT")) return false;
-    throw error;
-  }
-}
-function scanRoleFiles(dirs, extension2) {
-  const files = [];
-  for (const source of roleDirectorySources(dirs)) {
-    let entries;
-    try {
-      entries = readdirSync(source.path, { withFileTypes: true });
-    } catch (error) {
-      if (!extension2 && isNodeError(error, "ENOENT")) continue;
-      fail("INVALID_METADATA", `${roleDirectoryLabel(source, extension2)} role directory "${source.path}" could not be scanned: ${errorText(error)}`);
-    }
-    for (const entry of entries) if (isRoleFile(source.path, entry)) files.push({ name: basename3(entry.name, ".md"), path: join5(source.path, entry.name), source });
-  }
-  return files.sort((left, right) => left.name.localeCompare(right.name) || left.path.localeCompare(right.path));
-}
-function roleEntries(dirs, extension2) {
-  const files = scanRoleFiles(dirs, extension2);
-  const starterFiles = files.filter(({ source }) => source.builtin === true);
-  const regularFiles = files.filter(({ source }) => source.builtin !== true);
-  if (extension2) {
-    const byName = /* @__PURE__ */ new Map();
-    for (const file of regularFiles) byName.set(file.name, [...byName.get(file.name) ?? [], file]);
-    for (const [name, matches] of byName) if (matches.length > 1) fail("INVALID_METADATA", `Duplicate extension role "${name}": ${matches.map(({ path, source }) => `${roleDirectoryLabel(source)} role directory "${source.path}" (${path})`).join("; ")}`);
-  }
-  const read = (roleFiles) => Object.fromEntries(roleFiles.map(({ name, path, source }) => {
-    try {
-      const definition = parseRoleMarkdown(readFileSync3(path, "utf8"), true, path);
-      roleDefinitionPaths.set(definition, path);
-      return [name, { name, path, source, definition }];
-    } catch (error) {
-      if (extension2) fail("INVALID_METADATA", `${roleDirectoryLabel(source)} role directory "${source.path}" contains invalid role "${name}" at "${path}": ${errorText(error)}`);
-      throw error;
-    }
-  }));
-  return extension2 ? { ...read(starterFiles), ...read(regularFiles) } : read(files);
-}
-function discoveryInput(input) {
-  return { cwd: input.cwd, agentDir: input.agentDir ?? getAgentDir2(), projectTrusted: input.projectTrusted ?? true, extensionRoleDirectories: input.extensionRoleDirectories ?? registeredWorkflowRoleDirectoryRegistrations() };
-}
-function discoveredRoleEntries(input) {
-  const resolved = discoveryInput(input);
-  return {
-    ...roleEntries(resolved.extensionRoleDirectories, true),
-    ...roleEntries(workflowRoleDirectories(resolved.agentDir), false),
-    ...resolved.projectTrusted ? roleEntries(projectRoleDirectories(join5(resolved.cwd, ".pi")), false) : {}
-  };
-}
-function discoverRoles(input) {
-  return deepFreeze(Object.fromEntries(Object.entries(discoveredRoleEntries(input)).map(([name, entry]) => [name, entry.definition])));
-}
-function loadAgentDefinitions(cwd, agentDir = getAgentDir2(), projectTrusted = true, extensionRoleDirectories = registeredWorkflowRoleDirectoryRegistrations()) {
-  return discoverRoles({ cwd, agentDir, projectTrusted, extensionRoleDirectories });
-}
-function canonicalExtensionSelector(selector, base = process.cwd()) {
-  const negated = selector.startsWith("!");
-  const body = negated ? selector.slice(1) : selector;
-  if (body === "*" || body === "**" || body.startsWith("**/")) return selector;
-  const resolved = resolve4(base, body);
-  if (resourcePatternHasMagic(body)) return `${negated ? "!" : ""}${resolved}`;
-  return `${negated ? "!" : ""}${canonicalPath(resolved)}`;
-}
-function selectorsFromSettings2(settings) {
-  return { ...settings.skills === void 0 ? {} : { skills: settings.skills }, ...settings.extensions === void 0 ? {} : { extensions: settings.extensions }, ...settings.tools === void 0 ? {} : { tools: settings.tools } };
-}
-function rootToolNames(value) {
-  return value === void 0 ? void 0 : value instanceof Set ? [...value] : [...value];
-}
-function roleDefinitionFor(name, options) {
-  if (name === void 0) return {};
-  if (options.definition !== void 0) {
-    const path = roleDefinitionPaths.get(options.definition);
-    return { definition: options.definition, ...path === void 0 ? {} : { path } };
-  }
-  if (options.definitions?.[name] !== void 0) {
-    const definition = options.definitions[name];
-    const path = roleDefinitionPaths.get(definition);
-    return { definition, ...path === void 0 ? {} : { path } };
-  }
-  const entries = discoveredRoleEntries(options);
-  const entry = entries[name];
-  if (!entry) fail("UNKNOWN_AGENT_TYPE", `Unknown agent role: ${name}`);
-  return entry;
-}
-function resolveRole(name, options) {
-  const { definition, path } = roleDefinitionFor(name, options);
-  const settings = options.selectorSources === void 0 ? resolveWorkflowSettings(options.cwd, options.projectTrusted ?? true, options.settingsPath ?? workflowSettingsPath(options.agentDir ?? getAgentDir2())) : void 0;
-  const baseSources = options.selectorSources ?? { global: selectorsFromSettings2(settings?.global ?? {}), project: selectorsFromSettings2(settings?.project ?? {}) };
-  const canonicalSources = (sources) => ({
-    ...sources,
-    global: { ...sources.global, ...sources.global.extensions === void 0 ? {} : { extensions: sources.global.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) } },
-    project: { ...sources.project, ...sources.project.extensions === void 0 ? {} : { extensions: sources.project.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) } },
-    ...sources.role === void 0 ? {} : { role: { ...sources.role, ...sources.role.extensions === void 0 ? {} : { extensions: sources.role.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) } } },
-    ...sources.call === void 0 ? {} : { call: { ...sources.call, ...sources.call.extensions === void 0 ? {} : { extensions: sources.call.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) } } }
-  });
-  const roleLayer = definition?.skills !== void 0 || definition?.extensions !== void 0 || definition?.tools !== void 0 ? { ...definition.skills === void 0 ? {} : { skills: definition.skills }, ...definition.extensions === void 0 ? {} : { extensions: definition.extensions.map((selector) => canonicalExtensionSelector(selector, path ? dirname4(path) : options.cwd)) }, ...definition.tools === void 0 ? {} : { tools: definition.tools } } : baseSources.role;
-  const callLayer = options.skills !== void 0 || options.extensions !== void 0 || options.tools !== void 0 ? { ...options.skills === void 0 ? {} : { skills: options.skills }, ...options.extensions === void 0 ? {} : { extensions: options.extensions.map((selector) => canonicalExtensionSelector(selector, options.cwd)) }, ...options.tools === void 0 ? {} : { tools: options.tools } } : baseSources.call;
-  const selectorSources = canonicalSources({ global: baseSources.global, project: baseSources.project, ...roleLayer === void 0 ? {} : { role: roleLayer }, ...callLayer === void 0 ? {} : { call: callLayer } });
-  const callSelectors = selectorSources.call;
-  const roleSelectors = selectorSources.role;
-  const selectorLayers = {
-    skills: [selectorSources.global.skills, selectorSources.project.skills, roleSelectors?.skills, callSelectors?.skills],
-    extensions: [selectorSources.global.extensions, selectorSources.project.extensions, roleSelectors?.extensions, callSelectors?.extensions],
-    tools: [selectorSources.global.tools, selectorSources.project.tools, roleSelectors?.tools, callSelectors?.tools]
-  };
-  const resources = options.resources ?? {};
-  const candidateTools = options.inheritedTools ?? rootToolNames(options.rootTools) ?? resources.tools;
-  const tools = options.effectiveTools ?? (candidateTools === void 0 ? void 0 : selectResourcesByLayers(selectorLayers.tools, candidateTools));
-  const rootTools = rootToolNames(options.rootTools);
-  if (rootTools !== void 0) {
-    const outsideEffectiveTool = options.effectiveTools?.find((tool) => !candidateTools?.includes(tool));
-    if (outsideEffectiveTool) fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideEffectiveTool}`);
-    const outsideCallTool = (options.tools ?? []).find((tool) => !tool.startsWith("!") && !resourcePatternHasMagic(tool) && !candidateTools?.includes(tool));
-    if (outsideCallTool) fail("UNKNOWN_TOOL", `Tool is outside the launching session boundary: ${outsideCallTool}`);
-    const outsideRootTool = tools?.find((tool) => !rootTools.includes(tool));
-    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((extension2) => canonicalPath(extension2));
-  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);
-  const unmatchedTools = candidateTools === void 0 ? void 0 : unmatchedResourcePatterns(selectorLayers.tools.flatMap((layer) => layer ?? []), candidateTools);
-  const aliases = options.modelAliases ?? settings?.effective.modelAliases ?? {};
-  const requestedModel = options.model ?? (definition?.model && definition.thinking && !definition.model.includes(":") ? `${definition.model}:${definition.thinking}` : definition?.model);
-  const blockedAlias = requestedModel?.split(":", 1)[0];
-  if (requestedModel !== void 0 && blockedAlias && options.blockedAliases?.has(blockedAlias) && !modelAliasName(requestedModel, aliases)) {
-    const target = options.blockedAliasTargets?.[blockedAlias];
-    fail("UNKNOWN_MODEL", `Unknown model alias ${requestedModel}${target ? ` resolved to ${target}` : ""}${options.settingsPath ? ` (settings: ${options.settingsPath})` : ""}`);
-  }
-  let model = options.modelOverride;
-  if (model === void 0 && requestedModel !== void 0) {
-    assertModelThinking(requestedModel);
-    model = resolveModelReference(requestedModel, aliases, options.knownModels ?? options.availableModels, options.settingsPath ?? settings?.sources.modelAliases);
-  }
-  if (model === void 0) model = options.rootModel;
-  const availableModels = options.knownModels ?? options.availableModels ?? (options.rootModel === void 0 ? void 0 : /* @__PURE__ */ new Set([modelCapability(options.rootModel)]));
-  if (model !== void 0 && availableModels !== void 0 && !availableModels.has(modelCapability(model))) fail("UNKNOWN_MODEL", `Unknown model${requestedModel ? ` ${requestedModel} resolved to ${modelCapability(model)}` : ""}${options.settingsPath ? ` (settings: ${options.settingsPath})` : ""}`);
-  const prompt = definition?.prompt ?? "";
-  const overrideSystemPrompt = definition?.overrideSystemPrompt === true;
-  const contextFiles = options.contextFiles ?? definition?.contextFiles;
-  return { ...name === void 0 ? {} : { name }, ...definition === void 0 ? {} : { definition }, ...model === void 0 ? {} : { model }, ...modelAliasName(requestedModel ?? "", aliases) && requestedModel ? { requestedModel } : {}, ...tools === void 0 ? {} : { tools }, prompt, overrideSystemPrompt, systemPrompt: { mode: overrideSystemPrompt ? "override" : "append", text: prompt }, ...contextFiles === void 0 ? {} : { contextFiles: [...contextFiles] }, ...definition?.extensionSettings === void 0 ? {} : { extensionSettings: definition.extensionSettings }, selectorSources, selectorLayers, ...selectedSkills === void 0 ? {} : { selectedSkills }, ...selectedExtensions === void 0 ? {} : { selectedExtensions }, ...unmatchedSkills === void 0 ? {} : { unmatchedSkills }, ...unmatchedExtensions === void 0 ? {} : { unmatchedExtensions }, ...unmatchedTools === void 0 ? {} : { unmatchedTools } };
-}
-
-// src/validation.ts
-var AGENT_OPTION_KEYS = /* @__PURE__ */ new Set(["label", "model", "tools", "skills", "extensions", "contextFiles", "role", "outputSchema", "retries", "timeoutMs"]);
-function validateAgentOption(key, value, aliases, knownModels, settingsPath) {
-  switch (key) {
-    case "label":
-      if (typeof value !== "string" || !value.trim()) fail("INVALID_METADATA", "agent label must be a non-empty string");
-      break;
-    case "model":
-      if (typeof value !== "string" || !value.trim()) fail("INVALID_METADATA", "agent model must be a non-empty string");
-      assertModelThinking(value, "agent model");
-      if (aliases !== void 0) resolveModelReference(value, aliases, knownModels, settingsPath);
-      break;
-    case "tools":
-    case "skills":
-    case "extensions":
-      validateSelectorList(value, "agent options", key, "INVALID_METADATA", key !== "extensions");
-      break;
-    case "contextFiles":
-      validateContextFileScopes(value, "agent options");
-      break;
-    case "role":
-      if (typeof value !== "string" || !value.trim()) fail("INVALID_METADATA", "agent role must be a non-empty string");
-      break;
-    case "outputSchema":
-      validateSchema(value, "agent outputSchema");
-      break;
-    case "retries":
-      if (typeof value !== "number" || !Number.isInteger(value) || value < 0) fail("INVALID_METADATA", "agent retries must be a non-negative integer");
-      break;
-    case "timeoutMs":
-      if (value !== null && !positiveInteger(value)) fail("INVALID_METADATA", "agent timeoutMs must be null or a positive integer");
-      break;
-  }
-}
-function validateAgentOptions(value) {
-  if (!object(value) || !jsonValue(value)) fail("INVALID_METADATA", "agent options must be a JSON object");
-  if (Object.prototype.hasOwnProperty.call(value, "thinking")) fail("INVALID_METADATA", "agent thinking is not supported; use model provider/model:thinking");
-  for (const [key, option] of Object.entries(value)) if (AGENT_OPTION_KEYS.has(key)) validateAgentOption(key, option);
-  return value;
-}
 
 // src/execution.ts
 var RPC_LIMIT_BYTES = 10 * 1024 * 1024;
 var HEARTBEAT_INTERVAL_MS = 1e3;
+var FUNCTION_HANDLE_PREFIX = "function-handle";
 var WORK_RESULT_BRAND = "__workResult";
 var childSource = String.raw`
 "use strict";
@@ -2870,15 +2648,13 @@ const internalAgent = (...values) => {
   void result.then(() => agentInflight.delete(occurrenceKey), () => agentInflight.delete(occurrenceKey));
   return guardedAgentResult(result);
 };
-const AGENT_HANDLE_KEYS = ["name", "role", "model", "tools", "skills", "extensions", "contextFiles", "label"];
 const agentHandleNames = new Set();
 const agentHandleInflight = new Set();
 const internalAgentCreate = (...values) => {
   if (values.length !== 1 || !values[0] || typeof values[0] !== "object" || Array.isArray(values[0])) throw workError("INVALID_METADATA", "agent.create requires one options object");
   const options = values[0];
   const name = named(options.name, "agent.create");
-  const unsupported = Object.keys(options).find(key => !AGENT_HANDLE_KEYS.includes(key));
-  if (unsupported) throw workError("INVALID_METADATA", "agent.create option is unsupported: " + unsupported);
+  if (name.startsWith("${FUNCTION_HANDLE_PREFIX}/")) throw workError("INVALID_METADATA", "Agent handle names may not start with ${FUNCTION_HANDLE_PREFIX}/");
   if (agentHandleNames.has(name)) throw workError("INVALID_METADATA", "Duplicate agent handle name: " + name);
   agentHandleNames.add(name);
   const config = Object.freeze(Object.fromEntries(Object.entries(options).filter(([key]) => key !== "name")));
@@ -2993,6 +2769,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);
@@ -3053,7 +2853,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 } });
@@ -3063,20 +2863,28 @@ Promise.resolve().then(() => new vm.Script("(async(__pi_extensible_workflows_age
   .catch(error => send({ type: "error", error: workerError(error) }))
   .finally(() => clearInterval(heartbeat));
 `;
+function agentHandleTurnPath(handle, turn) {
+  return structuralPath("agent", "handle", handle, `turn:${String(turn)}`);
+}
+function agentIdentityPath(identity) {
+  if (identity.handle !== void 0 && identity.turn !== void 0) return agentHandleTurnPath(identity.handle, identity.turn);
+  return structuralPath("agent", ...identity.structuralPath, `callsite:${identity.callSite}`, `occurrence:${String(identity.occurrence)}`);
+}
 
 // src/host.ts
 import { Type as Type3 } from "@earendil-works/pi-ai";
-import { copyToClipboard, getAgentDir as getAgentDir5, ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, getAgentDir as getAgentDir4, ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
 
 // src/agent-execution.ts
-import { existsSync, realpathSync as realpathSync2, readFileSync as readFileSync4 } from "node:fs";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
 import { copyFile } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename4, dirname as dirname5, join as join6, resolve as resolve5 } from "node:path";
+import { basename as basename2, dirname as dirname3, join as join5, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { Type } from "@earendil-works/pi-ai";
+import { Value as Value2 } from "typebox/value";
 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 getAgentDir2, ModelRuntime, SessionManager, SettingsManager, loadSkills } from "@earendil-works/pi-coding-agent";
 
 // src/pi-runtime-adapter.ts
 var TURN_START_EVENTS = /* @__PURE__ */ new Set(["turn_start", "turn_started", "turnStarted"]);
@@ -3233,14 +3041,14 @@ function createRuntimeHandoffAdapter(handoff) {
 function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
   const neutralHandoff = createRuntimeHandoffAdapter(handoff);
   const toolCalls = /* @__PURE__ */ new Map();
-  let activity2;
+  let activity;
   let streamText = "";
   let lastEventAt;
   let lastReportedEventAt;
   let disposed = false;
   let toolCallsView = [];
   const progressAt = (persist, stateOverride, toolCallsValue3, activityValue2, eventAtValue) => ({ usage: runtimeUsage(session), toolCalls: toolCallsValue3, state: stateOverride ?? stateFromSession(session), ...activityValue2 === void 0 ? {} : { activity: activityValue2 }, ...eventAtValue === void 0 ? {} : { lastEventAt: eventAtValue }, persist });
-  const snapshot = (persist) => progressAt(persist, void 0, [...toolCalls.values()], activity2, lastEventAt);
+  const snapshot = (persist) => progressAt(persist, void 0, [...toolCalls.values()], activity, lastEventAt);
   return {
     handoff: neutralHandoff,
     observe(event) {
@@ -3251,7 +3059,7 @@ function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
       const eventState = event.state === void 0 ? void 0 : runtimeState(event.state);
       let report = false;
       let persist = false;
-      const previousActivity = activity2;
+      const previousActivity = activity;
       let eventToolCalls = toolCallsView;
       if (event.type === "state_changed") {
         report = true;
@@ -3259,7 +3067,7 @@ function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
       }
       if (event.type === "message_start" && event.message?.role === "assistant") {
         streamText = "";
-        activity2 = { kind: "text", text: "" };
+        activity = { kind: "text", text: "" };
         report = true;
       }
       if (event.type === "message_update") {
@@ -3267,14 +3075,14 @@ function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
         if (updateType === "thinking_start" || updateType === "text_start") streamText = "";
         const delta = event.assistantMessageEvent?.delta;
         if ((updateType === "thinking_delta" || updateType === "text_delta") && delta) streamText = `${streamText}${delta}`.replace(/\s+/g, " ").slice(-MAX_ACTIVITY_TEXT_CHARS);
-        if (updateType && ["thinking_start", "thinking_delta", "thinking_end"].includes(updateType)) activity2 = { kind: "reasoning", text: streamText };
-        else if (updateType && ["text_start", "text_delta", "text_end", "toolcall_start", "toolcall_delta", "toolcall_end"].includes(updateType)) activity2 = { kind: "text", text: streamText };
-        report = previousActivity?.kind !== activity2?.kind;
+        if (updateType && ["thinking_start", "thinking_delta", "thinking_end"].includes(updateType)) activity = { kind: "reasoning", text: streamText };
+        else if (updateType && ["text_start", "text_delta", "text_end", "toolcall_start", "toolcall_delta", "toolcall_end"].includes(updateType)) activity = { kind: "text", text: streamText };
+        report = previousActivity?.kind !== activity?.kind;
       }
       if (event.type === "message_end") {
         streamText = "";
-        activity2 = void 0;
-        report = !sameActivity(previousActivity, activity2);
+        activity = void 0;
+        report = !sameActivity(previousActivity, activity);
         if (event.message?.role === "assistant") {
           persist = true;
           report = true;
@@ -3283,24 +3091,24 @@ function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
       if (event.type === "tool_execution_start" && event.toolCallId && event.toolName) {
         toolCalls.set(event.toolCallId, { id: event.toolCallId, name: event.toolName, state: "running" });
         toolCallsView = [...toolCalls.values()];
-        activity2 = { kind: "tool", text: event.toolName };
+        activity = { kind: "tool", text: event.toolName };
         report = true;
       }
       if (event.type === "tool_execution_update" && event.toolName) {
-        activity2 = { kind: "tool", text: event.toolName };
-        report = !sameActivity(previousActivity, activity2);
+        activity = { kind: "tool", text: event.toolName };
+        report = !sameActivity(previousActivity, activity);
       }
       let removeToolCallId;
       if (event.type === "tool_execution_end" && event.toolCallId && event.toolName) {
         toolCalls.set(event.toolCallId, { id: event.toolCallId, name: event.toolName, state: event.isError ? "failed" : "completed" });
         eventToolCalls = [...toolCalls.values()];
-        if (activity2?.kind === "tool" && activity2.text === event.toolName) activity2 = void 0;
+        if (activity?.kind === "tool" && activity.text === event.toolName) activity = void 0;
         report = true;
         removeToolCallId = event.toolCallId;
       }
       if (removeToolCallId === void 0) eventToolCalls = toolCallsView;
       if (!report && (lastReportedEventAt === void 0 || eventAt - lastReportedEventAt >= 1e3)) report = true;
-      const eventActivity = activity2;
+      const eventActivity = activity;
       let materialized;
       const result = { event, get progress() {
         return materialized ??= progressAt(persist, eventState, eventToolCalls, eventActivity, eventAt);
@@ -3317,7 +3125,7 @@ function createPiRuntimeSessionAdapter(session, handoff, clock = Date.now) {
       disposed = true;
       toolCalls.clear();
       toolCallsView = [];
-      activity2 = void 0;
+      activity = void 0;
     }
   };
 }
@@ -3351,8 +3159,8 @@ function createLiveSessionHandoff() {
   let request;
   const waitForBoundary = () => {
     if (!turnActive) return Promise.resolve();
-    boundary ??= new Promise((resolve6) => {
-      resolveBoundary = resolve6;
+    boundary ??= new Promise((resolve5) => {
+      resolveBoundary = resolve5;
     });
     return boundary;
   };
@@ -3384,11 +3192,11 @@ function createLiveSessionHandoff() {
       if (request) return request;
       if (isReleased()) return;
       state = "handoff-pending";
-      takeover = new Promise((resolve6) => {
-        resolveTakeover = resolve6;
+      takeover = new Promise((resolve5) => {
+        resolveTakeover = resolve5;
       });
-      resume = new Promise((resolve6) => {
-        resolveResume = resolve6;
+      resume = new Promise((resolve5) => {
+        resolveResume = resolve5;
       });
       request = (async () => {
         await waitForBoundary();
@@ -3587,9 +3395,9 @@ var PiRuntimeAgentRunner = class {
     let structuredResult;
     const resultTool = prepared.resultTool;
     if (!resultTool) throw new WorkflowError("INTERNAL_ERROR", "Workflow agent session is missing its workflow_result tool");
-    const preparedForSession = preparedForRuntimeRequest(prepared, request.customTools, request.signal, (value) => {
+    const preparedForSession = Object.freeze({ ...preparedForRuntimeRequest(prepared, request.customTools, request.signal, (value) => {
       structuredResult = value;
-    }, resultTool);
+    }, resultTool), ...request.turnControl ? { turnControl: request.turnControl } : {} });
     const callbacks = this.#options.callbacks;
     const handoff = this.#options.handoff;
     let adapter;
@@ -3822,6 +3630,7 @@ var PiRuntimeAgentRunner = class {
       throwIfProgressFailed();
       beginTurn(false);
       throwIfTurnPolicyFailed();
+      if (request.turnControl && !session.turnControlDelivered) await activeSession.steer(request.turnControl);
       await promptAndRecover(request.task, true);
       completeTurn(hasResult() || !hasToolCall(lastAssistant), false, true);
       if (turnPolicyFailure) throw turnPolicyFailure;
@@ -3912,31 +3721,83 @@ function parseModel(value, fallback, aliases = {}, knownModels, settingsPath) {
   assertModelThinking(value);
   return resolveModelReference(value, aliases, knownModels, settingsPath);
 }
+async function authorizedResources(root, cwd, options) {
+  const agentDir = root.agentDir ?? getAgentDir2();
+  const trusted = root.projectTrusted ?? false;
+  const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: false });
+  settingsManager.setProjectTrusted(trusted);
+  const resolved = await new DefaultPackageManager({ cwd, agentDir, settingsManager, builtinExtensions: ["codemode", "tool-search", "mcp"] }).resolve();
+  const extensions = resolved.extensions.filter(({ enabled, metadata }) => enabled && (trusted || metadata.scope !== "project")).map(({ path }) => extensionIdentity(path));
+  const skillPaths = resolved.skills.filter(({ enabled, metadata }) => enabled && (trusted || metadata.scope !== "project")).map(({ path }) => path);
+  const skills = loadSkills({ cwd, agentDir, skillPaths: [...skillPaths, ...root.additionalSkillPaths ?? []], includeDefaults: false }).skills.map(({ name }) => name);
+  const parent = options.capabilities;
+  return { tools: [...root.tools].filter((tool) => options.effectiveTools === void 0 || options.effectiveTools.includes(tool)).filter((tool) => parent === void 0 || parent.tools.includes(tool)), skills: [...new Set(skills)].filter((name) => parent === void 0 || parent.skills.includes(name)), extensions: [...new Set(extensions)].filter((path) => parent === void 0 || parent.extensions.includes(path)) };
+}
+function validatePreparedConfiguration(root, configuration, capabilities, cwd, resumed) {
+  const code = resumed ? "RESUME_INCOMPATIBLE" : "INVALID_METADATA";
+  if (!jsonObject(configuration) || typeof configuration.projectTrusted !== "boolean" || typeof configuration.systemPromptAppend !== "string" || configuration.systemPrompt !== void 0 && typeof configuration.systemPrompt !== "string") throw new WorkflowError(code, "Invalid prepared agent configuration");
+  if (configuration.projectTrusted && !root.projectTrusted) throw new WorkflowError("RESUME_INCOMPATIBLE", "Prepared agent configuration lost project trust");
+  if (!object(configuration.model) || typeof configuration.model.provider !== "string" || typeof configuration.model.model !== "string") throw new WorkflowError(code, "Invalid prepared model");
+  const model = resolveModelReference(`${configuration.model.provider}/${configuration.model.model}${configuration.model.thinking === void 0 ? "" : `:${configuration.model.thinking}`}`);
+  if (root.availableModels !== void 0 && !root.availableModels.has(modelCapability(model))) throw new WorkflowError(resumed ? "RESUME_INCOMPATIBLE" : "UNKNOWN_MODEL", `Required model is unavailable: ${modelCapability(model)}`);
+  const tools = validateSelectorList(configuration.tools, "configuration", "tools", "INVALID_METADATA", false);
+  if (tools === void 0) throw new WorkflowError(code, "Prepared tools are missing");
+  const missing = tools.find((tool) => !capabilities.tools.includes(tool));
+  if (missing) throw new WorkflowError(resumed ? "RESUME_INCOMPATIBLE" : "UNKNOWN_TOOL", `Required tool is unavailable: ${missing}`);
+  const excludeTools = configuration.excludeTools;
+  try {
+    validateAgentOptions({ excludeTools });
+  } catch {
+    throw new WorkflowError(code, "Invalid prepared excludeTools");
+  }
+  if (!Array.isArray(excludeTools) || tools.some((tool) => excludeTools.includes(tool))) throw new WorkflowError(code, "Prepared excludeTools contradict the prepared tools");
+  validateSelectorList(configuration.skills, "configuration", "skills", "INVALID_METADATA", false);
+  validateSelectorList(configuration.extensions, "configuration", "extensions", "INVALID_METADATA", false);
+  if (resumed) for (const key of ["skills", "extensions"]) {
+    const selectors = configuration[key];
+    const selected = selectors.slice(selectors.lastIndexOf("!*") + 1);
+    const missing2 = selected.find((name) => !capabilities[key].includes(name));
+    if (missing2) throw new WorkflowError("RESUME_INCOMPATIBLE", `Required ${key} capability is unavailable: ${missing2}`);
+  }
+  validateContextFileScopes(configuration.contextFiles, "configuration");
+  validateWorkflowExtensionSettings(configuration.settings, "configuration", "INVALID_METADATA");
+  root.validateExtensionSettings?.(configuration.settings, { source: "effective", cwd, projectTrusted: root.projectTrusted ?? false });
+  return deepFreeze(structuredClone(configuration));
+}
 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" ? resolve5(extensionDirectory, "../..") : resolve5(extensionDirectory, "..");
-var WORKFLOW_HOST_ENTRIES = /* @__PURE__ */ new Set([
-  canonicalPath(resolve5(workflowPackageRoot, "src/index.ts")),
-  canonicalPath(resolve5(workflowPackageRoot, "dist/src/index.js")),
-  canonicalPath(resolve5(workflowPackageRoot, "starter/index.ts")),
-  canonicalPath(resolve5(workflowPackageRoot, "dist/starter/index.js")),
-  canonicalPath(resolve5(workflowPackageRoot, "subagents/index.ts")),
-  canonicalPath(resolve5(workflowPackageRoot, "dist/subagents/index.js"))
-]);
-var WORKFLOW_DIRECTORY = "pi-extensible-workflows";
+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 = dirname3(entryPath);
+  while (packageRoot2 !== dirname3(packageRoot2)) {
+    const packageMetadataPath = join5(packageRoot2, "package.json");
+    if (existsSync(packageMetadataPath)) {
+      try {
+        const metadata = JSON.parse(readFileSync2(packageMetadataPath, "utf8"));
+        if (typeof metadata !== "object" || metadata === null || !("name" in metadata) || !isCorePackageName(metadata.name)) return false;
+        return WORKFLOW_HOST_ENTRY_PATHS.some((entry) => canonicalPath(join5(packageRoot2, entry)) === entryPath);
+      } catch {
+        return false;
+      }
+    }
+    packageRoot2 = dirname3(packageRoot2);
+  }
+  return false;
+}
+var WORKFLOW_DIRECTORY2 = "pi-extensible-workflows";
 function workflowSystemPromptPath(cwd, agentDir, projectTrusted) {
-  const projectPath = join6(cwd, ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md");
+  const projectPath = join5(cwd, ".pi", WORKFLOW_DIRECTORY2, "SYSTEM.md");
   if (projectTrusted && existsSync(projectPath)) return projectPath;
-  const globalPaths = [join6(homedir4(), ".pi", WORKFLOW_DIRECTORY, "SYSTEM.md"), join6(agentDir, WORKFLOW_DIRECTORY, "SYSTEM.md")];
+  const globalPaths = [join5(homedir4(), ".pi", WORKFLOW_DIRECTORY2, "SYSTEM.md"), join5(agentDir, WORKFLOW_DIRECTORY2, "SYSTEM.md")];
   return globalPaths.find((path) => existsSync(path));
 }
 function filterContextFiles(base, scopes, cwd, agentDir) {
   const globalPath = canonicalPath(agentDir);
   const cwdPath = canonicalPath(cwd);
   return base.filter(({ path }) => {
-    const resolvedPath = canonicalPath(dirname5(path));
+    const resolvedPath = canonicalPath(dirname3(path));
     return scopes.some((scope) => scope === "global" ? resolvedPath === globalPath : scope === "cwd" ? resolvedPath === cwdPath : resolvedPath !== globalPath && resolvedPath !== cwdPath);
   });
 }
@@ -3957,33 +3818,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, label2) {
   const packageDirectory = await loadPiPackageDirectory();
-  let promptTemplatePath;
+  let modulePath;
   if (packageDirectory.directory) {
-    const candidate = resolve5(packageDirectory.directory, "dist/core/prompt-templates.js");
-    if (existsSync(candidate)) promptTemplatePath = candidate;
+    const candidate = resolve4(packageDirectory.directory, "dist/core", file);
+    if (existsSync(candidate)) modulePath = candidate;
   }
-  promptTemplatePath ??= resolve5(dirname5(fileURLToPath3(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core/prompt-templates.js");
+  modulePath ??= resolve4(dirname3(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 ${label2}.${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" });
@@ -4008,73 +3876,116 @@ 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?.();
   }
 }
 function flushExtensionProviders(resourceLoader, modelRuntime) {
-  const { runtime: runtime2 } = resourceLoader.getExtensions();
+  const { runtime } = resourceLoader.getExtensions();
   const failures = [];
-  for (const { name, config } of runtime2.pendingProviderRegistrations) {
+  for (const { name, config } of runtime.pendingProviderRegistrations) {
     try {
       modelRuntime.registerProvider(name, config);
     } catch (error) {
       failures.push(`${name}: ${errorText(error)}`);
     }
   }
-  runtime2.pendingProviderRegistrations = [];
-  for (const { provider } of runtime2.pendingNativeProviderRegistrations) {
+  runtime.pendingProviderRegistrations = [];
+  for (const { provider } of runtime.pendingNativeProviderRegistrations) {
     try {
       modelRuntime.registerNativeProvider(provider);
     } catch (error) {
       failures.push(`${provider.id || "native provider"}: ${errorText(error)}`);
     }
   }
-  runtime2.pendingNativeProviderRegistrations = [];
+  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";
+}
+var WorkflowResourceLoader = class extends DefaultResourceLoader {
+  constructor(loaderCwd, options) {
+    super(options);
+    this.loaderCwd = loaderCwd;
+  }
+  loaderCwd;
+  extensionSkillPaths = [];
+  async reload(...args) {
+    this.extensionSkillPaths.length = 0;
+    await super.reload(...args);
+  }
+  extendResources(paths) {
+    this.extensionSkillPaths.push(...(paths.skillPaths ?? []).map(({ path }) => piResourcePath(path, this.loaderCwd)));
+    super.extendResources(paths);
+  }
+};
+function discoveredSkillSelectors(selectors, inventory) {
+  if (selectors === void 0 || inventory === void 0) return selectors;
+  const frozen = /* @__PURE__ */ new Set();
+  let index = selectors.length;
+  for (const name of [...inventory].reverse().concat("!*")) {
+    do
+      index -= 1;
+    while (index >= 0 && selectors[index] !== name);
+    if (index < 0) return selectors;
+    frozen.add(index);
+  }
+  return selectors.filter((_selector, position) => !frozen.has(position));
+}
 async function createLocalPiSessionHandle(input, sessionStartEvent) {
-  const agentDir = input.agentDir ?? getAgentDir3();
+  const agentDir = input.agentDir ?? getAgentDir2();
   const systemPromptSource = workflowSystemPromptPath(input.cwd, agentDir, input.resourcePolicy?.projectTrusted ?? true);
   const systemPromptOptions = input.systemPrompt !== void 0 ? { systemPromptOverride: () => input.systemPrompt } : systemPromptSource !== void 0 ? { systemPrompt: systemPromptSource } : {};
   const contextFilesOverride = input.contextFiles === void 0 ? void 0 : (base) => ({ ...base, agentsFiles: filterContextFiles(base.agentsFiles, input.contextFiles ?? [], input.cwd, agentDir) });
-  const manager = input.sessionManager ?? (input.sessionPath ? SessionManager.open(input.sessionPath, join6(agentDir, "sessions"), input.cwd) : input.agentDir ? SessionManager.create(input.cwd, join6(agentDir, "sessions")) : SessionManager.create(input.cwd));
+  const manager = input.sessionManager ?? (input.sessionPath ? SessionManager.open(input.sessionPath, join5(agentDir, "sessions"), input.cwd) : input.agentDir ? SessionManager.create(input.cwd, join5(agentDir, "sessions")) : SessionManager.create(input.cwd));
   if (!input.sessionPath) manager.appendSessionInfo(input.sessionLabel);
-  const modelRuntime = await ModelRuntime.create({ authPath: join6(agentDir, "auth.json"), modelsPath: join6(agentDir, "models.json") });
+  const modelRuntime = await ModelRuntime.create({ authPath: join5(agentDir, "auth.json"), modelsPath: join5(agentDir, "models.json") });
   const customTools = [...input.customTools ?? [], ...input.resultTool ? [input.resultTool] : []];
   const tools = [.../* @__PURE__ */ new Set([...input.tools, ...customTools.map(({ name }) => name)])];
   let settingsManager;
   let resourceLoader;
+  const builtins = builtinExtensions();
+  const builtinNames = builtins.flatMap((extension2) => typeof extension2 === "function" ? [] : [extension2.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,
-      selectorSources,
-      resources: { extensions: discoveredExtensions }
-    });
-    const selectedExtensions = selection.selectedExtensions ?? [];
-    const extensionPaths = selectedExtensions.filter((path) => !WORKFLOW_HOST_ENTRIES.has(path));
+    const selectedExtensions = selectResourcesByLayers(resourceSelectorLayers(selectorSources, "extensions"), discoveredExtensions).filter((path) => policy.capabilities === void 0 || policy.capabilities.extensions.includes(path));
+    const extensionPaths = selectedExtensions.filter((path) => path.startsWith(BUILTIN_EXTENSION_PREFIX) || !isWorkflowHostEntry(path));
     policy.selectedExtensions = selectedExtensions;
-    policy.unmatchedExtensions = selection.unmatchedExtensions ?? [];
+    policy.unmatchedExtensions = unmatchedResourcePatterns(policy.effective.extensions, discoveredExtensions);
     const skillPaths = [...new Set(resolved.skills.filter(({ enabled, metadata }) => enabled && (policy.projectTrusted || metadata.scope !== "project")).map(({ path }) => path))];
-    const updateSkillMatches = (skills) => {
+    const updateSkillMatches = (skills, extensionSkillPaths) => {
       const names = [...new Set(skills.map(({ name }) => name))];
-      const selected = resolveRole(void 0, { cwd: input.cwd, selectorSources, resources: { skills: names } });
-      const selectedSkills = selected.selectedSkills ?? [];
+      const discovered = new Set(skills.filter(({ filePath }) => extensionSkillPaths.some((path) => piResourceContains(path, filePath))).map(({ name }) => name));
+      const [global, project, call] = resourceSelectorLayers(selectorSources, "skills");
+      const selectedStatic = selectResourcesByLayers([global, project, call], names.filter((name) => !discovered.has(name))).filter((name) => policy.capabilities === void 0 || policy.capabilities.skills.includes(name));
+      const selectedDiscovered = selectResourcesByLayers([discoveredSkillSelectors(global, policy.capabilities?.skills), project, call], [...discovered]).filter((name) => policy.parentSkills === void 0 || policy.parentSkills.includes(name));
+      const selectedSkills = [...selectedStatic, ...selectedDiscovered];
       policy.selectedSkills = selectedSkills;
-      policy.unmatchedSkills = selected.unmatchedSkills ?? [];
+      policy.unmatchedSkills = unmatchedResourcePatterns(policy.effective.skills, names);
       return new Set(names.filter((name) => !selectedSkills.includes(name)));
     };
-    resourceLoader = new DefaultResourceLoader({
+    const workflowLoader = new WorkflowResourceLoader(input.cwd, {
       cwd: input.cwd,
       agentDir,
       settingsManager,
@@ -4082,33 +3993,34 @@ 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);
+        const disabledSkills = updateSkillMatches(base.skills, workflowLoader.extensionSkillPaths);
         return { ...base, skills: base.skills.filter(({ name }) => !disabledSkills.has(name)) };
       },
       ...input.systemPromptAppend ? { appendSystemPromptOverride: (base) => [...base, input.systemPromptAppend ?? ""] } : {},
       ...systemPromptOptions
     });
+    resourceLoader = workflowLoader;
     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({}) };
-  const { session } = await createAgentSession({ ...input.options ?? {}, cwd: input.cwd, agentDir, modelRuntime, model, settingsManager, ...input.model.thinking ? { thinkingLevel: input.model.thinking } : {}, tools, ...customTools.length ? { customTools } : {}, ...input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}, resourceLoader, ...effectiveSessionStartEvent ? { sessionStartEvent: effectiveSessionStartEvent } : {}, sessionManager: manager });
+  const { session } = await createAgentSession({ cwd: input.cwd, agentDir, modelRuntime, model, settingsManager, ...input.model.thinking ? { thinkingLevel: input.model.thinking } : {}, tools, ...customTools.length ? { customTools } : {}, ...input.extensionFactories?.length ? { extensionFactories: input.extensionFactories } : {}, resourceLoader, ...effectiveSessionStartEvent ? { sessionStartEvent: effectiveSessionStartEvent } : {}, sessionManager: manager });
   const nativeDispose = session.dispose.bind(session);
   let disposal;
   const shutdown = (reason, targetSessionFile) => {
@@ -4129,13 +4041,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(),
@@ -4471,6 +4383,10 @@ async function createLocalWorkflowAgentSession(prepared, context) {
   return session;
 }
 var localAgentTransport = Object.freeze({ id: "local", createSession: createLocalWorkflowAgentSession });
+function excludedToolNames(options) {
+  const own = options.agentOptions?.excludeTools;
+  return /* @__PURE__ */ new Set([...options.inheritedExcludeTools ?? [], ...Array.isArray(own) ? own.filter((tool) => typeof tool === "string") : []]);
+}
 function changedOption(options, baseline, key) {
   return JSON.stringify(options[key]) !== JSON.stringify(baseline[key]);
 }
@@ -4493,7 +4409,7 @@ function resourcePolicySummary(policy, tools = policy.selectedTools ?? []) {
 }
 var RESOURCE_SELECTOR_KEYS = ["skills", "extensions", "tools"];
 function resourceSelectorLayers(sources, key) {
-  return [sources.global[key], sources.project[key], sources.role?.[key], sources.call?.[key]];
+  return [sources.global[key], sources.project[key], sources.call?.[key]];
 }
 function selectorListWidened(ceiling, candidate) {
   let candidateIndex = 0;
@@ -4550,32 +4466,32 @@ function appendResourcePolicyNarrowing(ceiling, candidate) {
   };
 }
 function packageRoot(start) {
-  let current = dirname5(realpathSync2(start));
+  let current = dirname3(canonicalPath(start));
   for (; ; ) {
-    const candidates = [current, join6(current, "..", "@earendil-works", "pi-coding-agent"), join6(current, "..", "pi-coding-agent")];
+    const candidates = [current, join5(current, "..", "@earendil-works", "pi-coding-agent"), join5(current, "..", "pi-coding-agent")];
     for (const candidate of candidates) {
-      const packageJsonPath = join6(candidate, "package.json");
+      const packageJsonPath = join5(candidate, "package.json");
       if (!existsSync(packageJsonPath)) continue;
-      const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+      const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       if (object(packageJson) && typeof packageJson.name === "string" && packageJson.name === "@earendil-works/pi-coding-agent") return candidate;
     }
-    const parent = dirname5(current);
+    const parent = dirname3(current);
     if (parent === current) return void 0;
     current = parent;
   }
 }
 function piPackageEntrypoint(root) {
-  const packageJson = JSON.parse(readFileSync4(join6(root, "package.json"), "utf8"));
+  const packageJson = JSON.parse(readFileSync2(join5(root, "package.json"), "utf8"));
   if (!object(packageJson)) throw new Error("the @earendil-works/pi-coding-agent package does not declare a pi CLI");
   const bin = packageJson.bin;
   const cli = typeof bin === "string" ? bin : object(bin) && typeof bin.pi === "string" ? bin.pi : void 0;
   if (!cli) throw new Error("the @earendil-works/pi-coding-agent package does not declare a pi CLI");
-  const entrypoint = resolve5(root, cli);
+  const entrypoint = resolve4(root, cli);
   if (!existsSync(entrypoint)) throw new Error(`the originating Pi CLI entrypoint is unavailable: ${entrypoint}`);
   return entrypoint;
 }
 async function resolvePiRuntime() {
-  const executableName = basename4(process.execPath).toLowerCase();
+  const executableName = basename2(process.execPath).toLowerCase();
   const bunBinary = ["$bunfs", "~BUN", "%7EBUN"].some((marker) => import.meta.url.includes(marker)) || Boolean(process.versions.bun && !["bun", "bun.exe"].includes(executableName));
   if (bunBinary) return { runtime: Object.freeze({ executable: process.execPath }) };
   const errors = [];
@@ -4599,19 +4515,12 @@ async function resolvePiRuntime() {
   }
 }
 var piRuntimeResolution = resolvePiRuntime();
-function workflowAgentPrompt(task, options, attempt, previousError) {
-  const basePrompt = [`Workflow: ${options.workflowName}`, `Agent: ${options.label}`, options.phase ? `Phase: ${options.phase}` : "", options.parent ? `Parent: ${options.parent}` : "", "You own this task and any direct child agents you create. Return child results to your parent; do not leave descendants running.", options.schema ? "Call workflow_result exactly once with the final result matching its schema. Do not return prose as the final result." : 'Call workflow_result exactly once with { result: "final response" } to submit the final response. Do not return prose as the final result.', attempt > 1 ? `Retry attempt ${String(attempt)}. Previous state: ${options.retryState ?? previousError ?? "failed attempt"}` : ""].filter(Boolean).join("\n");
-  const instruction = options.budget?.instruction();
-  return `${basePrompt}
-
-Task:
-${task}${instruction ? `
-
-${instruction}` : ""}`;
+function attemptControlText(options, attempt, previousError) {
+  return [attempt > 1 ? `Retry attempt ${String(attempt)}. Previous state: ${options.retryState ?? previousError ?? "failed attempt"}` : "", options.budget?.instruction() ?? ""].filter(Boolean).join("\n");
 }
 async function preparedAgentSession(input, initialPrompt) {
   const { runtime: piRuntime, error: piRuntimeError } = await piRuntimeResolution;
-  const systemPromptPath = input.systemPrompt === void 0 ? workflowSystemPromptPath(input.cwd, input.agentDir ?? getAgentDir3(), input.resourcePolicy?.projectTrusted ?? true) : void 0;
+  const systemPromptPath = input.systemPrompt === void 0 ? workflowSystemPromptPath(input.cwd, input.agentDir ?? getAgentDir2(), input.resourcePolicy?.projectTrusted ?? true) : void 0;
   const prepared = {
     cwd: input.cwd,
     model: Object.freeze({ ...input.model }),
@@ -4641,49 +4550,30 @@ function agentSetupSummary(setup, hookNames) {
   return { hookNames: [...hookNames], model: { provider: model.provider, model: model.model, ...model.thinking ? { thinking: model.thinking } : {} }, tools: [...setup.sessionInput.tools, ...setup.sessionInput.resultTool ? [setup.sessionInput.resultTool.name] : []], cwd: setup.sessionInput.cwd, ...setup.sessionInput.resourcePolicy ? { resourceSelectors: resourcePolicySummary(setup.sessionInput.resourcePolicy, setup.sessionInput.tools) } : {} };
 }
 async function attemptSessionInput(source, attempt) {
-  const target = join6(dirname5(source), `${basename4(source, ".jsonl")}-attempt-${String(attempt)}.jsonl`);
+  const target = join5(dirname3(source), `${basename2(source, ".jsonl")}-attempt-${String(attempt)}.jsonl`);
   await copyFile(source, target);
   return target;
 }
-async function prepareAgentSetup(root, transport, task, options, resolved, cwd, attempt, signal, customTools, resultTool, inspection = false, previousError) {
+async function prepareAgentSetup(root, transport, task, options, resolved, cwd, attempt, signal, customTools, resultTool, inspection = false) {
   const setupSignal = signal ?? root.runContext?.signal ?? new AbortController().signal;
   const baselineOptions = structuredClone(options.agentOptions ?? {});
   const baseResourcePolicy = await root.agentResourcePolicy?.();
-  const roleName2 = typeof options.role === "string" ? options.role : void 0;
-  const roleDefinition = roleName2 ? root.agentDefinitions?.[roleName2] : void 0;
-  const roleSelectors = roleDefinition ? {
-    ...roleDefinition.skills === void 0 ? {} : { skills: roleDefinition.skills },
-    ...roleDefinition.extensions === void 0 ? {} : { extensions: roleDefinition.extensions.map((selector) => canonicalExtensionSelector(selector, cwd)) },
-    ...roleDefinition.tools === void 0 ? {} : { tools: roleDefinition.tools }
-  } : void 0;
-  const selectorValue = (key, fallback) => {
-    const value = baselineOptions[key];
-    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) return value;
-    return options.agentOptions === void 0 ? fallback : void 0;
+  const configuration = options.configuration;
+  const resourcePolicy = {
+    ...baseResourcePolicy ?? { globalSettingsPath: "", projectSettingsPath: "", projectTrusted: root.projectTrusted ?? false, global: { skills: [], extensions: [] }, project: { skills: [], extensions: [] }, unmatchedSkills: [], unmatchedExtensions: [] },
+    projectTrusted: configuration?.projectTrusted ?? root.projectTrusted ?? baseResourcePolicy?.projectTrusted ?? false,
+    effective: { skills: configuration?.skills ?? [], extensions: configuration?.extensions ?? [], tools: resolved.tools },
+    selectorSources: { global: { skills: configuration?.skills ?? [], extensions: configuration?.extensions ?? [], tools: resolved.tools }, project: {} },
+    ...options.capabilities ? { capabilities: options.capabilities } : {},
+    ...options.parentSkills ? { parentSkills: [...options.parentSkills] } : {},
+    selectedTools: resolved.tools
   };
-  const rawCallSkills = selectorValue("skills", options.skills);
-  const rawCallExtensions = selectorValue("extensions", options.extensions)?.map((selector) => canonicalExtensionSelector(selector, cwd));
-  const rawCallTools = selectorValue("tools", options.tools);
-  const callSelectors = { ...rawCallSkills === void 0 ? {} : { skills: rawCallSkills }, ...rawCallExtensions === void 0 ? {} : { extensions: rawCallExtensions }, ...rawCallTools === void 0 ? {} : { tools: rawCallTools } };
-  const resourcePolicy = baseResourcePolicy ? {
-    ...baseResourcePolicy,
-    effective: {
-      skills: [...baseResourcePolicy.effective.skills, ...roleSelectors?.skills ?? [], ...rawCallSkills ?? []],
-      extensions: [...baseResourcePolicy.effective.extensions, ...roleSelectors?.extensions ?? [], ...rawCallExtensions ?? []],
-      ...baseResourcePolicy.effective.tools === void 0 && roleSelectors?.tools === void 0 && rawCallTools === void 0 ? {} : { tools: [...baseResourcePolicy.effective.tools ?? [], ...roleSelectors?.tools ?? [], ...rawCallTools ?? []] }
-    },
-    selectorSources: { global: baseResourcePolicy.selectorSources.global, project: baseResourcePolicy.selectorSources.project, ...roleSelectors ? { role: roleSelectors } : {}, ...Object.keys(callSelectors).length ? { call: callSelectors } : {} }
-  } : void 0;
-  if (resourcePolicy) {
-    resourcePolicy.selectedTools = resolved.tools;
-    resourcePolicy.unmatchedTools = unmatchedResourcePatterns(resourceSelectorLayers(resourcePolicy.selectorSources, "tools").flatMap((layer) => layer ?? []), [...root.tools]);
-  }
-  const resourcePolicyCeiling = resourcePolicy ? structuredClone(resourcePolicy) : void 0;
+  const resourcePolicyCeiling = structuredClone(resourcePolicy);
   const sessionPath = options.sessionPath === void 0 || inspection ? options.sessionPath : await attemptSessionInput(options.sessionPath, attempt);
-  const extensionSettings = mergeWorkflowExtensionSettings(options.inheritedExtensionSettings ?? root.extensionSettings, roleDefinition?.extensionSettings) ?? Object.freeze({});
-  root.validateExtensionSettings?.(extensionSettings, { source: roleName2 === void 0 ? "effective" : "role", cwd, projectTrusted: resourcePolicy?.projectTrusted ?? true, ...root.extensionSettingsPath ?? root.settingsPath ? { settingsPath: root.extensionSettingsPath ?? root.settingsPath } : {}, ...roleName2 === void 0 ? {} : { role: roleName2 } });
+  const extensionSettings = configuration?.settings ?? options.inheritedExtensionSettings ?? root.extensionSettings ?? Object.freeze({});
+  root.validateExtensionSettings?.(extensionSettings, { source: "effective", cwd, projectTrusted: resourcePolicy.projectTrusted, ...root.extensionSettingsPath ?? root.settingsPath ? { settingsPath: root.extensionSettingsPath ?? root.settingsPath } : {} });
   if (options.agentNodeId !== void 0) root.onAgentSettings?.(options.agentNodeId, extensionSettings);
-  const sessionInput = { cwd, model: { ...resolved.model }, tools: [...resolved.tools], sessionLabel: `${options.workflowName}:${options.label}:attempt-${String(attempt)}`, ...sessionPath ? { sessionPath } : {}, ...root.agentDir ? { agentDir: root.agentDir } : {}, ...root.additionalSkillPaths?.length ? { additionalSkillPaths: [...root.additionalSkillPaths] } : {}, ...resolved.contextFiles === void 0 ? {} : { contextFiles: [...resolved.contextFiles] }, ...customTools.length ? { customTools: [...customTools] } : {}, ...resultTool ? { resultTool } : {}, ...resolved.systemPrompt !== void 0 ? { systemPrompt: resolved.systemPrompt } : {}, systemPromptAppend: resolved.systemPromptAppend, ...resourcePolicy ? { resourcePolicy } : {}, settings: extensionSettings, options: structuredClone(baselineOptions) };
+  const sessionInput = { cwd, model: { ...resolved.model }, tools: [...resolved.tools], sessionLabel: `${options.workflowName}:${options.label}:attempt-${String(attempt)}`, ...sessionPath ? { sessionPath } : {}, ...root.agentDir ? { agentDir: root.agentDir } : {}, ...root.additionalSkillPaths?.length ? { additionalSkillPaths: [...root.additionalSkillPaths] } : {}, ...resolved.contextFiles === void 0 ? {} : { contextFiles: [...resolved.contextFiles] }, ...customTools.length ? { customTools: [...customTools] } : {}, ...resultTool ? { resultTool } : {}, ...resolved.systemPrompt !== void 0 ? { systemPrompt: resolved.systemPrompt } : {}, systemPromptAppend: resolved.systemPromptAppend, resourcePolicy, settings: extensionSettings, options: structuredClone(baselineOptions) };
   const setup = { prompt: task, options: sessionInput.options ?? {}, sessionInput, prepared: await preparedAgentSession(sessionInput, task), transport };
   const base = fallbackSetupContext(root, options, setupSignal);
   const context = Object.freeze({ run: base.run, identity: base.identity, attempt, signal: setupSignal, settings: extensionSettings, ...base.tuiIndex === void 0 ? {} : { tuiIndex: base.tuiIndex }, ...base.tuiLabel === void 0 ? {} : { tuiLabel: base.tuiLabel }, ...inspection ? { mode: "inspection" } : {} });
@@ -4703,19 +4593,42 @@ async function prepareAgentSetup(root, transport, task, options, resolved, cwd,
   try {
     if (resourcePolicyWidened(resourcePolicyCeiling, setup.sessionInput.resourcePolicy)) throw new WorkflowError("INVALID_METADATA", "Agent setup widened the prepared resource policy");
     appendResourcePolicyNarrowing(resourcePolicyCeiling, setup.sessionInput.resourcePolicy);
+    if (setup.sessionInput.resourcePolicy) {
+      const policy = setup.sessionInput.resourcePolicy;
+      policy.effective.extensions = policy.effective.extensions.map((selector) => canonicalExtensionSelector(selector, cwd));
+      for (const layer of [policy.selectorSources.global, policy.selectorSources.project, policy.selectorSources.call]) if (layer?.extensions !== void 0) layer.extensions = layer.extensions.map((selector) => canonicalExtensionSelector(selector, cwd));
+      if (resourcePolicyCeiling.parentSkills === void 0) Reflect.deleteProperty(policy, "parentSkills");
+      else policy.parentSkills = [...resourcePolicyCeiling.parentSkills];
+    }
     setup.sessionInput.options = setup.options;
     if (changedOption(setup.options, baselineOptions, "model") && typeof setup.options.model === "string") setup.sessionInput.model = parseModel(setup.options.model, setup.sessionInput.model, root.modelAliases, root.knownModels ?? root.availableModels, root.settingsPath);
     if (changedOption(setup.options, baselineOptions, "tools") && Array.isArray(setup.options.tools) && setup.options.tools.every((tool) => typeof tool === "string")) setup.sessionInput.tools = [...setup.options.tools];
-    if (changedOption(setup.options, baselineOptions, "cwd") && typeof setup.options.cwd === "string") setup.sessionInput.cwd = setup.options.cwd;
+    if (changedOption(setup.options, baselineOptions, "cwd") || !sameFilesystemPath(cwd, setup.sessionInput.cwd)) throw new WorkflowError("INVALID_METADATA", "Agent setup cannot change cwd");
+    if (!root.availableModels?.has(modelCapability(setup.sessionInput.model)) && root.availableModels !== void 0) throw new WorkflowError("UNKNOWN_MODEL", "Agent setup selected an unavailable model");
+    const shadowed = (setup.sessionInput.customTools ?? []).map(({ name }) => name).find((name) => root.tools.has(name) && !resolved.tools.includes(name));
+    if (shadowed) throw new WorkflowError("UNKNOWN_TOOL", `Custom tool reintroduces a tool outside the prepared agent policy: ${shadowed}`);
+    const excludedTools = new Set(configuration?.excludeTools ?? excludedToolNames(options));
+    const excludedCustomTools = (setup.sessionInput.customTools ?? []).filter(({ name }) => excludedTools.has(name)).map(({ name }) => name);
+    if (excludedCustomTools.length) {
+      setup.sessionInput.customTools = setup.sessionInput.customTools?.filter(({ name }) => !excludedTools.has(name)) ?? [];
+      setup.sessionInput.tools = setup.sessionInput.tools.filter((tool) => root.tools.has(tool) || !excludedCustomTools.includes(tool));
+    }
+    for (const tool of excludedTools) if (!options.inheritedExcludeTools?.includes(tool) && !root.tools.has(tool) && !excludedCustomTools.includes(tool)) root.onResourceWarning?.(`excludeTools names no root or custom tool of this agent: ${tool}`);
     const customToolNames = /* @__PURE__ */ new Set([...(setup.sessionInput.customTools ?? []).map(({ name }) => name), ...setup.sessionInput.resultTool ? [setup.sessionInput.resultTool.name] : []]);
     const widened = setup.sessionInput.tools.find((tool) => !resolved.tools.includes(tool) && !customToolNames.has(tool));
     const outsideTool = widened ?? setup.sessionInput.tools.find((tool) => !root.tools.has(tool) && !customToolNames.has(tool));
     if (outsideTool) throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the prepared agent policy: ${outsideTool}`);
+    if (setup.sessionInput.resourcePolicy) {
+      const policy = setup.sessionInput.resourcePolicy;
+      setup.sessionInput.tools = selectResourcesByLayers(resourceSelectorLayers(policy.selectorSources, "tools"), setup.sessionInput.tools);
+      if (policy.projectTrusted !== resourcePolicyCeiling.projectTrusted) policy.capabilities = await authorizedResources({ ...root, projectTrusted: policy.projectTrusted }, cwd, options);
+    }
+    if (!setup.sessionInput.tools.includes("agent")) setup.sessionInput.customTools = setup.sessionInput.customTools?.filter(({ name }) => name !== "agent" && name !== "get_subagent_result" && name !== "steer_subagent") ?? [];
   } catch (error) {
     setup.prepared = await preparedAgentSession(setup.sessionInput, task);
     return { setup, summary: agentSetupSummary(setup, hookNames), failure: { error } };
   }
-  setup.prepared = await preparedAgentSession(setup.sessionInput, inspection ? task : workflowAgentPrompt(setup.prompt, options, attempt, previousError));
+  setup.prepared = await preparedAgentSession(setup.sessionInput, inspection ? task : setup.prompt);
   return { setup, summary: agentSetupSummary(setup, hookNames) };
 }
 function attemptRecord(transport, attempt, session, setup, stats, result, error) {
@@ -4735,54 +4648,93 @@ var WorkflowAgentExecutor = class {
   }
   root;
   transport;
-  warnedRoleTools = /* @__PURE__ */ new Set();
   setRunContext(runContext) {
     this.root.runContext = runContext;
   }
   resolve(options, inheritedTools) {
-    const roleName2 = typeof options.role === "string" ? options.role : void 0;
-    const roleDefinition = roleName2 ? this.root.agentDefinitions?.[roleName2] : void 0;
-    if (roleName2 && !roleDefinition) throw new WorkflowError("UNKNOWN_AGENT_TYPE", `Unknown agent role: ${roleName2}`);
-    if (inheritedTools === void 0) for (const pattern of roleDefinition?.tools ?? []) {
-      const body = pattern.startsWith("!") ? pattern.slice(1) : pattern;
-      if (!pattern.startsWith("!") && !resourcePatternHasMagic(pattern) && !this.root.tools.has(body)) {
-        const key = `${roleName2 ?? "agent"}:${body}`;
-        if (!this.warnedRoleTools.has(key)) {
-          this.warnedRoleTools.add(key);
-          this.root.onResourceWarning?.(`Tool not available in this session for role ${roleName2 ?? "agent"}: ${body}. The agent runs without it.`);
-        }
-      }
-    }
-    const resolved = resolveRole(roleName2, {
-      cwd: this.root.cwd,
-      ...roleDefinition === void 0 ? {} : { definition: roleDefinition },
-      ...this.root.agentDefinitions === void 0 ? {} : { definitions: this.root.agentDefinitions },
-      ...this.root.agentDir === void 0 ? {} : { agentDir: this.root.agentDir },
-      selectorSources: { global: this.root.resourceSelectors ?? {}, project: {} },
-      ...this.root.modelAliases === void 0 ? {} : { modelAliases: this.root.modelAliases },
-      ...this.root.knownModels === void 0 ? {} : { knownModels: this.root.knownModels },
-      ...this.root.availableModels === void 0 ? {} : { availableModels: this.root.availableModels },
-      ...this.root.blockedAliases === void 0 ? {} : { blockedAliases: this.root.blockedAliases },
-      ...this.root.blockedAliasTargets === void 0 ? {} : { blockedAliasTargets: this.root.blockedAliasTargets },
-      ...this.root.settingsPath === void 0 ? {} : { settingsPath: this.root.settingsPath },
-      rootModel: this.root.model,
-      rootTools: this.root.tools,
-      ...inheritedTools === void 0 ? {} : { inheritedTools },
+    if (options.configuration) return { ...options.configuration, ...options.modelOverride ? { model: options.modelOverride } : {} };
+    const ceiling = inheritedTools ?? [...this.root.tools];
+    for (const pattern of options.tools ?? []) if (!pattern.startsWith("!") && !resourcePatternHasMagic(pattern) && !ceiling.includes(pattern)) throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the prepared agent policy: ${pattern}`);
+    const tools = options.effectiveTools ?? selectResourcesByLayers([this.root.resourceSelectors?.tools, options.tools], [...inheritedTools ?? this.root.tools]);
+    const missing = tools.find((tool) => !ceiling.includes(tool));
+    if (missing) throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the prepared agent policy: ${missing}`);
+    const model = options.modelOverride ?? parseModel(options.model, this.root.model, this.root.modelAliases, this.root.knownModels, this.root.settingsPath);
+    return { model: physicalModel(model, this.root.modelAliases, this.root.knownModels, this.root.settingsPath), tools, systemPromptAppend: "", ...options.contextFiles === void 0 ? {} : { contextFiles: options.contextFiles } };
+  }
+  async prepare(options, cwd = this.root.cwd, signal = this.root.runContext?.signal ?? new AbortController().signal, mode = "execution") {
+    const root = { ...this.root, projectTrusted: Boolean(this.root.projectTrusted) && options.projectTrusted !== false };
+    const policy = await this.root.agentResourcePolicy?.();
+    const capabilities = await authorizedResources(root, cwd, options);
+    const persistedKey = options.parent !== void 0 ? options.agentNodeId : options.agentIdentity?.handle !== void 0 ? `handle:${options.agentIdentity.handle}` : options.agentIdentity ? agentIdentityPath(options.agentIdentity) : options.agentNodeId;
+    const stored = options.configuration ?? (mode === "execution" && persistedKey && this.root.runStore?.load ? (await this.root.runStore.load()).snapshot.agentConfigurations[persistedKey] : void 0);
+    if (stored) {
+      if (stored.excludeTools === void 0) throw new WorkflowError("RESUME_INCOMPATIBLE", "Prepared agent configuration predates frozen excludeTools; relaunch the workflow");
+      return validatePreparedConfiguration(root, stored, capabilities, cwd, true);
+    }
+    const original = deepFreeze(structuredClone(validateAgentOptions(options.agentOptions ?? {
       ...options.model === void 0 ? {} : { model: options.model },
-      ...options.modelOverride === void 0 ? {} : { modelOverride: options.modelOverride },
-      ...options.tools === void 0 ? {} : { tools: options.tools },
-      ...options.skills === void 0 ? {} : { skills: options.skills },
-      ...options.extensions === void 0 ? {} : { extensions: options.extensions },
-      ...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 } };
+      ...options.tools === void 0 ? {} : { tools: [...options.tools] },
+      ...options.skills === void 0 ? {} : { skills: [...options.skills] },
+      ...options.extensions === void 0 ? {} : { extensions: [...options.extensions] },
+      ...options.contextFiles === void 0 ? {} : { contextFiles: [...options.contextFiles] }
+    })));
+    const dynamicModelAliasNames = this.root.dynamicModelAliasNames;
+    const defaults = deepFreeze({ model: { ...this.root.model }, modelAliases: { ...this.root.modelAliases }, ...dynamicModelAliasNames === void 0 ? {} : { dynamicModelAliasNames: [...dynamicModelAliasNames] }, selectorSources: structuredClone(policy?.selectorSources ?? { global: this.root.resourceSelectors ?? {}, project: {} }), settings: structuredClone(options.inheritedExtensionSettings ?? this.root.extensionSettings ?? {}) });
+    const context = Object.freeze({ options: original, cwd, projectCwd: this.root.cwd, agentDir: this.root.agentDir ?? getAgentDir2(), projectTrusted: root.projectTrusted, defaults, capabilities: deepFreeze(structuredClone(capabilities)), knownModels: new Set(this.root.knownModels), availableModels: new Set(this.root.availableModels), signal, mode });
+    const configuration = {
+      ...typeof original.label === "string" ? { label: original.label } : {},
+      ...typeof original.model === "string" ? { model: original.model } : {},
+      tools: [...policy?.effective.tools ?? this.root.resourceSelectors?.tools ?? [], ...options.tools ?? []],
+      skills: [...policy?.effective.skills ?? this.root.resourceSelectors?.skills ?? [], ...options.skills ?? []],
+      extensions: [...policy?.effective.extensions ?? this.root.resourceSelectors?.extensions ?? [], ...(options.extensions ?? []).map((selector) => canonicalExtensionSelector(selector, cwd))],
+      ...options.contextFiles === void 0 ? {} : { contextFiles: [...options.contextFiles] },
+      systemPromptAppend: "",
+      settings: structuredClone(defaults.settings)
+    };
+    for (const key of ["tools", "skills", "extensions"]) if (Array.isArray(original[key])) {
+      const selectors = validateSelectorList(original[key], "agent options", key, "INVALID_METADATA", false) ?? [];
+      configuration[key] = [...policy?.effective[key] ?? this.root.resourceSelectors?.[key] ?? [], ...selectors.map((selector) => key === "extensions" ? canonicalExtensionSelector(selector, cwd) : selector)];
+    }
+    if (original.contextFiles !== void 0) configuration.contextFiles = [...validateContextFileScopes(original.contextFiles, "agent options") ?? []];
+    const hooks = [...this.root.agentPreparationHooks ?? []].sort(byPriorityThenName);
+    const load = this.root.extensionLoad;
+    if (load?.errors.length) {
+      const loaded = new Set(load.loaded.map(extensionIdentity));
+      const declared = new Set(hooks.flatMap(({ optionsSchema, source }) => source !== void 0 && loaded.has(extensionIdentity(source)) && object(optionsSchema?.properties) ? Object.keys(optionsSchema.properties) : []));
+      const unowned = Object.keys(original).find((key) => !isCoreAgentOption(key) && !declared.has(key));
+      if (unowned !== void 0) throw new WorkflowError("INVALID_METADATA", `Agent option ${unowned} has no owner proven to have loaded while extensions failed to load: ${load.errors.join("; ")}`);
+    }
+    for (const hook of hooks) if (hook.optionsSchema !== void 0 && !Value2.Check(hook.optionsSchema, original)) throw new WorkflowError("INVALID_METADATA", `Agent options do not match preparation schema: ${hook.name}`);
+    if (typeof original.model === "string" && this.root.blockedAliases?.has(original.model.split(":")[0] ?? "")) throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${original.model} resolved to ${this.root.blockedAliasTargets?.[original.model.split(":")[0] ?? ""] ?? "an unavailable target"}`);
+    for (const hook of hooks) {
+      if (signal.aborted) throw new WorkflowError("CANCELLED", "Agent preparation cancelled");
+      await hook.prepare(configuration, context);
+    }
+    if (signal.aborted) throw new WorkflowError("CANCELLED", "Agent preparation cancelled");
+    const { model: preparedModel, ...preparedOptions } = configuration;
+    validateAgentOptions(preparedOptions);
+    if (preparedModel !== void 0 && (typeof preparedModel !== "string" || !preparedModel.trim())) throw new WorkflowError("INVALID_METADATA", "Prepared agent model must be a non-empty string");
+    if (preparedModel && this.root.blockedAliases?.has(preparedModel.split(":")[0] ?? "")) throw new WorkflowError("UNKNOWN_MODEL", `Unknown model alias ${preparedModel} resolved to ${this.root.blockedAliasTargets?.[preparedModel.split(":")[0] ?? ""] ?? "an unavailable target"}`);
+    configuration.extensions = configuration.extensions.map((selector) => canonicalExtensionSelector(selector, cwd));
+    const model = physicalModel(preparedModel === void 0 ? this.root.model : resolveModelReference(preparedModel, this.root.modelAliases, this.root.knownModels, this.root.settingsPath), this.root.modelAliases, this.root.knownModels, this.root.settingsPath);
+    const excludedTools = excludedToolNames({ agentOptions: original, ...options.inheritedExcludeTools ? { inheritedExcludeTools: options.inheritedExcludeTools } : {} });
+    const tools = selectResourcesByLayers([configuration.tools], capabilities.tools).filter((tool) => !excludedTools.has(tool));
+    for (const pattern of validateSelectorList(original.tools, "agent options", "tools", "INVALID_METADATA", false) ?? []) if (!pattern.startsWith("!") && !resourcePatternHasMagic(pattern) && !capabilities.tools.includes(pattern)) throw new WorkflowError("UNKNOWN_TOOL", `Tool is outside the prepared agent policy: ${pattern}`);
+    for (const pattern of unmatchedResourcePatterns(configuration.tools, capabilities.tools)) this.root.onResourceWarning?.(`Tool selector currently matches no authorized tool: ${pattern}`);
+    const skills = selectResourcesByLayers([configuration.skills], capabilities.skills);
+    const extensions = selectResourcesByLayers([configuration.extensions], capabilities.extensions);
+    const concrete = validatePreparedConfiguration(root, { ...configuration, model, tools, excludeTools: [...excludedTools], skills: [...configuration.skills, "!*", ...skills], extensions: [...configuration.extensions, "!*", ...extensions], projectTrusted: context.projectTrusted }, capabilities, cwd, false);
+    if (mode === "execution") {
+      if (persistedKey && this.root.runStore?.saveAgentConfiguration) await this.root.runStore.saveAgentConfiguration(persistedKey, concrete);
+      await options.onConfiguration?.(concrete);
+    }
+    return concrete;
   }
   async execute(task, options, signal, customTools = [], setSteer, beforeRetry) {
     const executionSignal = signal ?? this.root.runContext?.signal;
     if (!Number.isInteger(options.retries ?? 0) || (options.retries ?? 0) < 0) throw new WorkflowError("INVALID_METADATA", "retries must be a non-negative integer");
     if (options.timeoutMs !== void 0 && options.timeoutMs !== null && (!Number.isInteger(options.timeoutMs) || options.timeoutMs <= 0)) throw new WorkflowError("INVALID_METADATA", "timeoutMs must be null or a positive integer");
-    let resolved = this.resolve(options);
+    let resolved;
     let recoveryModel;
     let cwd;
     if (options.parent) {
@@ -4803,6 +4755,16 @@ var WorkflowAgentExecutor = class {
       if (options.cwd) throw new WorkflowError("INVALID_METADATA", "Only child agents or worktree scopes may provide a cwd");
       cwd = this.root.cwd;
     }
+    const configuration = await this.prepare(options, cwd, executionSignal);
+    const parentSkills = options.parent === void 0 ? void 0 : options.capabilities?.skills;
+    options = { ...options, label: configuration.label ?? options.label, configuration, ...parentSkills ? { parentSkills } : {}, capabilities: { tools: configuration.tools, skills: configuration.skills.slice(configuration.skills.lastIndexOf("!*") + 1), extensions: configuration.extensions.slice(configuration.extensions.lastIndexOf("!*") + 1) } };
+    resolved = this.resolve(options);
+    if (!resolved.tools.includes("agent")) customTools = customTools.filter(({ name }) => name !== "agent" && name !== "get_subagent_result" && name !== "steer_subagent");
+    let publishLoadedSkills;
+    customTools = customTools.map((tool) => tool.name !== "agent" ? tool : { ...tool, execute: (...args) => {
+      publishLoadedSkills?.();
+      return tool.execute(...args);
+    } });
     const attempts = [];
     let maxAttempts = (options.retries ?? 0) + 1;
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
@@ -4832,7 +4794,7 @@ var WorkflowAgentExecutor = class {
       const resultTool = defineTool({
         name: "workflow_result",
         label: "Workflow Result",
-        description: "Submit the terminal workflow result",
+        description: options.schema ? "Submit the terminal workflow result. Call exactly once to finish the current task or message, with a value matching the required schema. Do not return prose as the final result." : 'Submit the terminal workflow result. Call exactly once to finish the current task or message, with { result: "final response" }. Do not return prose as the final result.',
         parameters: resultSchema.Type(),
         async execute(_id, value) {
           if (!resultSchema.Check(value) || !jsonValue(value)) return { content: [{ type: "text", text: "Result does not match the required schema." }], details: {}, isError: true };
@@ -4864,11 +4826,23 @@ var WorkflowAgentExecutor = class {
       } : void 0;
       try {
         setupFailed = true;
-        const prepared = await prepareAgentSetup(this.root, this.transport, task, options, resolved, cwd, attempt, attemptSignal, customTools, resultTool, false, attempts.at(-1)?.error?.message);
+        const prepared = await prepareAgentSetup(this.root, this.transport, task, options, resolved, cwd, attempt, attemptSignal, customTools, resultTool, false);
         setup = prepared.setup;
         const attemptSetup = prepared.setup;
         setupSummary = prepared.summary;
         if (prepared.failure) throw prepared.failure.error;
+        let attemptCapabilities;
+        if (options.agentNodeId !== void 0) {
+          const policy = setup.prepared.resourcePolicy;
+          const sources = policy?.selectorSources;
+          const capabilities = policy?.capabilities ?? options.capabilities;
+          attemptCapabilities = {
+            tools: setup.prepared.tools,
+            skills: selectResourcesByLayers(sources ? resourceSelectorLayers(sources, "skills") : [], capabilities?.skills ?? []),
+            extensions: selectResourcesByLayers(sources ? resourceSelectorLayers(sources, "extensions") : [], capabilities?.extensions ?? [])
+          };
+          this.root.onAgentCapabilities?.(options.agentNodeId, attemptCapabilities, policy?.projectTrusted ?? false);
+        }
         setupFailed = false;
         if (attemptSignal.aborted) throw new WorkflowError("CANCELLED", "Agent cancelled");
         await options.onAttempt?.({ attempt, transport: attemptSetup.transport.id, accounting: zeroAccounting(), setup: setupSummary });
@@ -4904,6 +4878,12 @@ var WorkflowAgentExecutor = class {
                 }
               }
               if (policy) setupSummary = { ...setupSummary, resourceSelectors: { ...resourcePolicySummary(policy, attemptSetup.sessionInput.tools), ...inspection ? { skills: [...inspection.skills], extensions: [...inspection.extensions] } : {} } };
+              const nodeId = options.agentNodeId, selected = attemptCapabilities, live = session;
+              publishLoadedSkills = nodeId === void 0 || selected === void 0 || live?.getResourceInspection === void 0 ? void 0 : () => {
+                const loaded = live.getResourceInspection?.();
+                if (loaded) this.root.onAgentCapabilities?.(nodeId, { ...selected, skills: [...loaded.skills] }, attemptSetup.prepared.resourcePolicy?.projectTrusted ?? false);
+              };
+              publishLoadedSkills?.();
             },
             onBeforeComplete: async () => {
               if (options.worktreeOwner) await runStore?.snapshotWorktree(options.worktreeOwner);
@@ -4939,6 +4919,7 @@ var WorkflowAgentExecutor = class {
         const runtimeRun = { id: transportBase.run.runId, namespaceId: transportBase.run.sessionId, workflowName: transportBase.run.workflow.name };
         const providerRecovery = options.providerErrorRecovery;
         const runtimeAgent = { id: transportBase.identity.callSite, structuralPath: [...transportBase.identity.structuralPath], ...options.parent ? { parentId: options.parent } : {} };
+        const attemptControl = attemptControlText(options, attempt, attempts.at(-1)?.error?.message);
         const runtimeRequest = {
           task: setup.prepared.initialPrompt ?? setup.prompt,
           cwd: setup.prepared.cwd,
@@ -4947,6 +4928,7 @@ var WorkflowAgentExecutor = class {
           // Pi sessions execute the prepared native definitions; the executor does not duplicate them as neutral request tools.
           customTools: [],
           ...options.schema ? { resultSchema: options.schema } : {},
+          ...attemptControl ? { turnControl: attemptControl } : {},
           run: runtimeRun,
           agent: runtimeAgent,
           signal: attemptSignal,
@@ -5033,7 +5015,7 @@ import { SettingsManager as SettingsManager2, truncateToVisualLines as truncateT
 import { spawn } from "node:child_process";
 import { mkdtemp, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
 function workflowPromptArtifact(prompt) {
   return { extension: ".md", content: prompt };
 }
@@ -5044,23 +5026,23 @@ function workflowResultArtifact(value) {
 async function spawnWorkflowEditor(command, path) {
   const [editor, ...editorArgs] = command.split(" ");
   if (!editor) return null;
-  return new Promise((resolve6) => {
+  return new Promise((resolve5) => {
     try {
       const child = spawn(editor, [...editorArgs, path], { stdio: "inherit", shell: process.platform === "win32" });
       child.once("error", () => {
-        resolve6(null);
+        resolve5(null);
       });
       child.once("close", (code) => {
-        resolve6(code);
+        resolve5(code);
       });
     } catch {
-      resolve6(null);
+      resolve5(null);
     }
   });
 }
 async function openWorkflowArtifact(tui, command, artifact) {
-  const directory = await mkdtemp(join7(tmpdir(), "pi-workflow-editor-"));
-  const path = join7(directory, `artifact${artifact.extension}`);
+  const directory = await mkdtemp(join6(tmpdir(), "pi-workflow-editor-"));
+  const path = join6(directory, `artifact${artifact.extension}`);
   try {
     await writeFile3(path, artifact.content, { encoding: "utf8", mode: 384 });
     tui.stop();
@@ -5172,6 +5154,15 @@ function formatWorkflowRuntime(durationMs) {
   const remainingMinutes = minutes % 60;
   return `${String(hours)}h${remainingMinutes ? ` ${String(remainingMinutes)}m` : ""}`;
 }
+function textBlock(text) {
+  return {
+    render(width) {
+      return text.split("\n").map((line) => truncateToWidth2(line, Math.max(1, width), "\u2026"));
+    },
+    invalidate() {
+    }
+  };
+}
 var ANSI_SGR_SOURCE = `${String.fromCharCode(27)}\\[[0-9;]*m`;
 var ANSI_SGR = new RegExp(ANSI_SGR_SOURCE);
 function themeWorkflowProgressStyles(theme) {
@@ -5215,13 +5206,13 @@ function elapsedDurationMs(agent, end) {
   return agent.startedAt === void 0 || !Number.isFinite(agent.startedAt) ? void 0 : Math.max(0, end - agent.startedAt);
 }
 function agentActivityLabel(agent) {
-  const activity2 = agent.activity;
-  if (activity2?.kind === "reasoning" || activity2?.kind === "text") {
-    const name = activity2.kind === "reasoning" ? "reasoning" : "responding";
-    const text = sanitizeDisplayText(activity2.text);
+  const activity = agent.activity;
+  if (activity?.kind === "reasoning" || activity?.kind === "text") {
+    const name = activity.kind === "reasoning" ? "reasoning" : "responding";
+    const text = sanitizeDisplayText(activity.text);
     return text && text !== name ? `${name} \xB7 ${text}` : name;
   }
-  if (activity2?.kind === "tool") return sanitizeDisplayText(activity2.text);
+  if (activity?.kind === "tool") return sanitizeDisplayText(activity.text);
   return sanitizeDisplayText([...agent.toolCalls ?? []].reverse().find(({ state }) => state === "running")?.name ?? "");
 }
 function formatAccountingValue(value) {
@@ -5242,7 +5233,6 @@ function formatAgentDetail(agent, styles = PLAIN_WORKFLOW_PROGRESS_STYLES, now =
     `State: ${state(agent.state)}`,
     ...agent.structuralPath?.length ? [`Structural path: ${agent.structuralPath.join(" > ")}`] : [],
     ...model === void 0 ? [] : [`Model: ${model}`],
-    `Role: ${agent.role ?? "(none)"}`,
     `Tools: ${tools}`,
     ...agent.attempts !== void 0 && Number.isFinite(agent.attempts) && agent.attempts > 1 ? [`Attempts: ${String(agent.attempts)}`] : [],
     ...duration === void 0 ? [] : [`Duration: ${formatWorkflowRuntime(duration)}`],
@@ -5285,7 +5275,9 @@ function formatNavigatorColumns(sidebar, detail, width, layout = {}) {
   if (safeWidth >= 80) {
     const sidebarWidth = Math.min(42, Math.max(24, Math.floor((safeWidth - 3) * 0.38)));
     const left2 = sidebar.flatMap((line) => wrapNavigatorLine(line, sidebarWidth));
-    const right = detail.flatMap((line) => wrapNavigatorLine(line, safeWidth - sidebarWidth - 3));
+    const wrapped = detail.flatMap((line) => wrapNavigatorLine(line, safeWidth - sidebarWidth - 3));
+    const shift = Math.min(Math.max(0, layout.detailOffset ?? 0), Math.max(0, left2.length - wrapped.length));
+    const right = [...Array(shift).fill(""), ...wrapped];
     return Array.from({ length: Math.max(left2.length, right.length) }, (_, index) => {
       const cell = left2[index] ?? "";
       return `${cell}${" ".repeat(Math.max(0, sidebarWidth - visibleWidth2(cell)))} | ${right[index] ?? ""}`;
@@ -5330,8 +5322,8 @@ function createInlineConfirm(requestRender) {
   return {
     ask(title, message) {
       answer(false);
-      return new Promise((resolve6) => {
-        pending = { title, message, yes: true, resolve: resolve6 };
+      return new Promise((resolve5) => {
+        pending = { title, message, yes: true, resolve: resolve5 };
         requestRender();
       });
     },
@@ -5362,11 +5354,11 @@ function createInlineConfirm(requestRender) {
 }
 
 // src/trajectory.ts
-import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DefaultPackageManager as DefaultPackageManager2, getAgentDir as getAgentDir4, SettingsManager as SettingsManager3, DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2 } from "@earendil-works/pi-coding-agent";
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, DefaultPackageManager as DefaultPackageManager2, getAgentDir as getAgentDir3, SettingsManager as SettingsManager3, DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2 } from "@earendil-works/pi-coding-agent";
 
 // subagents/src/contracts.ts
 import { Type as Type2 } from "@earendil-works/pi-ai";
-import { Value as Value2 } from "typebox/value";
+import { Value as Value3 } from "typebox/value";
 var SUBAGENTS_TOOL_NAMES = [
   "subagents_run",
   "subagents_inspect",
@@ -5387,17 +5379,18 @@ var SUBAGENTS_RUN_PARAMETERS = Type2.Object({
   label: Type2.Optional(Type2.String({ description: "Optional display label for the subagent" })),
   model: Type2.Optional(Type2.String({ description: "Optional model as provider/model:thinking or alias[:thinking]" })),
   tools: Type2.Optional(Type2.Array(Type2.String(), { description: "Optional ordered tool selectors; candidates start enabled and !* restricts the set" })),
+  excludeTools: Type2.Optional(Type2.Array(Type2.String(), { description: "Optional exact tool names removed after preparation; no patterns, cannot remove workflow_result" })),
   skills: Type2.Optional(Type2.Array(Type2.String(), { description: "Optional ordered skill selectors; candidates start enabled and !* restricts the set" })),
   extensions: Type2.Optional(Type2.Array(Type2.String(), { description: "Optional ordered extension selectors; candidates start enabled and !* restricts the set" })),
   contextFiles: Type2.Optional(Type2.Array(Type2.String(), { description: "Optional context-file scopes: global, project, cwd" })),
-  role: Type2.Optional(Type2.String({ description: "Workflow role name" })),
   worktree: Type2.Optional(Type2.String({ description: "Optional named worktree; requires a clean working tree" })),
   outputSchema: Type2.Optional(Type2.Record(Type2.String(), Type2.Unknown(), { description: "Optional JSON schema for the result" })),
   retries: Type2.Optional(Type2.Integer({ minimum: 0, maximum: SUBAGENT_MAX_RETRIES, description: "Optional retry count; at most 255 retries" })),
   timeoutMs: Type2.Optional(Type2.Union([Type2.Integer({ minimum: 1, description: "Optional execution timeout in milliseconds" }), Type2.Null()]))
-}, { additionalProperties: false });
+}, { additionalProperties: true });
 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" })
@@ -5412,15 +5405,23 @@ 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 SUBAGENTS_TOOL_SCHEMAS = {
-  subagents_run: SUBAGENTS_RUN_PARAMETERS,
-  subagents_inspect: SUBAGENTS_INSPECT_PARAMETERS,
-  subagents_steer: SUBAGENTS_STEER_PARAMETERS,
-  subagents_stop: SUBAGENTS_STOP_PARAMETERS,
-  subagents_retry: SUBAGENTS_RETRY_PARAMETERS
-};
+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 (!Value3.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");
   const snapshot = structuredClone(value);
   snapshot.mode ??= "background";
@@ -5510,8 +5511,8 @@ function progressValue(value) {
   const accounting2 = accountingValue(record2.accounting);
   const toolCalls = toolCallsValue(record2.toolCalls);
   if (!accounting2 || !toolCalls) return void 0;
-  const activity2 = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
-  if (record2.activity !== void 0 && activity2 === void 0) return void 0;
+  const activity = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
+  if (record2.activity !== void 0 && activity === void 0) return void 0;
   const rawState = record2.state;
   let state;
   if (rawState !== void 0) {
@@ -5525,16 +5526,16 @@ function progressValue(value) {
   }
   const lastEventAt = record2.lastEventAt;
   if (lastEventAt !== void 0 && !nonnegativeInteger(lastEventAt)) return void 0;
-  return { accounting: accounting2, toolCalls, ...state === void 0 ? {} : { state }, ...activity2 === void 0 ? {} : { activity: activity2 }, ...lastEventAt === void 0 ? {} : { lastEventAt } };
+  return { accounting: accounting2, toolCalls, ...state === void 0 ? {} : { state }, ...activity === void 0 ? {} : { activity }, ...lastEventAt === void 0 ? {} : { lastEventAt } };
 }
 function legacyProgressValue(record2) {
   const accounting2 = legacyAccountingValue(record2);
   const toolCalls = record2.toolCalls === void 0 ? [] : toolCallsValue(record2.toolCalls);
   if (!accounting2 || !toolCalls) return void 0;
-  const activity2 = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
+  const activity = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
   const lastEventAt = record2.lastEventAt;
-  if (record2.activity !== void 0 && activity2 === void 0 || lastEventAt !== void 0 && !nonnegativeInteger(lastEventAt)) return void 0;
-  return { accounting: accounting2, toolCalls, ...activity2 === void 0 ? {} : { activity: activity2 }, ...lastEventAt === void 0 ? {} : { lastEventAt } };
+  if (record2.activity !== void 0 && activity === void 0 || lastEventAt !== void 0 && !nonnegativeInteger(lastEventAt)) return void 0;
+  return { accounting: accounting2, toolCalls, ...activity === void 0 ? {} : { activity }, ...lastEventAt === void 0 ? {} : { lastEventAt } };
 }
 function attemptValue(value) {
   const record2 = objectValue(value);
@@ -5618,15 +5619,29 @@ 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() }) })
+]);
+var SCRIPT_CALL_TEXT_LIMIT_BYTES = 16 * 1024;
 
 // subagents/src/manager.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { chmod, link as link2, mkdir as mkdir3, open as open2, readFile as readFile4, readdir as readdir3, rename as rename4, rm as rm5, stat as stat3 } from "node:fs/promises";
-import { join as join9 } from "node:path";
-import { getAgentDir as getAgentDir6 } from "@earendil-works/pi-coding-agent";
+import { join as join8 } from "node:path";
+import { getAgentDir as getAgentDir5 } from "@earendil-works/pi-coding-agent";
 
 // subagents/src/worktree.ts
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 function syntheticRun(context) {
   return {
     id: context.runId,
@@ -5649,7 +5664,7 @@ function syntheticSnapshot(context) {
     ...context.worktreePostCreateCommandSource === void 0 ? {} : { settingsSources: { concurrency: "subagents", modelAliases: "subagents", worktreePostCreateCommand: context.worktreePostCreateCommandSource } },
     models: [],
     tools: [],
-    agentTypes: [],
+    agentConfigurations: {},
     schemas: []
   };
 }
@@ -5688,7 +5703,7 @@ function createRunStoreWorktreeAdapter(home) {
   };
 }
 function defaultWorktreeHome(storageDirectory3) {
-  return join8(storageDirectory3, ".worktrees");
+  return join7(storageDirectory3, ".worktrees");
 }
 
 // subagents/src/manager.ts
@@ -5728,22 +5743,11 @@ function rootModel(context) {
   const thinking = context.extensionContext.thinkingLevel;
   return { provider: model.provider, model: model.id, ...thinking === void 0 ? {} : { thinking } };
 }
-function standaloneExtensionSettingsPath(cwd, agentDir, trustedProject, external) {
-  return trustedProject && external.projectExtensionSettings !== void 0 ? workflowProjectSettingsPath(cwd) : workflowSettingsPath(agentDir);
-}
-function validateStandaloneExtensionSources(context, external, registry, agentDir) {
-  const cwd = context.extensionContext.cwd;
-  const globalSettingsPath = workflowSettingsPath(agentDir);
-  const trustedProject = context.extensionContext.isProjectTrusted();
-  if (external.globalExtensionSettings !== void 0) registry.validateExtensionSettings(external.globalExtensionSettings, { source: "global", cwd, projectTrusted: trustedProject, settingsPath: globalSettingsPath });
-  if (trustedProject && external.projectExtensionSettings !== void 0) registry.validateExtensionSettings(external.projectExtensionSettings, { source: "project", cwd, projectTrusted: true, settingsPath: workflowProjectSettingsPath(cwd) });
-}
-function executionRoot(context, dependencies, signal, runId, worktree, external) {
+function executionRoot(context, dependencies, signal, runId, worktree) {
   const extensionContext = context.extensionContext;
   const model = rootModel(context);
-  const agentDir = dependencies.agentDir ?? getAgentDir6();
+  const agentDir = dependencies.agentDir ?? getAgentDir5();
   const currentTrustedProject = extensionContext.isProjectTrusted();
-  if (external.projectTrusted && !currentTrustedProject) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot retry standalone configuration from an untrusted project");
   const trustedProject = currentTrustedProject;
   const settingsPath = workflowSettingsPath(agentDir);
   const settings = resolveWorkflowSettings(extensionContext.cwd, trustedProject, settingsPath);
@@ -5766,11 +5770,13 @@ function executionRoot(context, dependencies, signal, runId, worktree, external)
     signal
   };
   const registry = loadingRegistry();
-  validateStandaloneExtensionSources(context, external, registry, agentDir);
-  const extensionSettings = trustedProject && external.projectExtensionSettings !== void 0 ? external.projectExtensionSettings : external.globalExtensionSettings;
-  const extensionSettingsPath = standaloneExtensionSettingsPath(extensionContext.cwd, agentDir, trustedProject, external);
+  if (settings.global.extensionSettings !== void 0) registry.validateExtensionSettings(settings.global.extensionSettings, { source: "global", cwd: extensionContext.cwd, projectTrusted: trustedProject, settingsPath: settings.globalSettingsPath });
+  if (trustedProject && settings.project.extensionSettings !== void 0) registry.validateExtensionSettings(settings.project.extensionSettings, { source: "project", cwd: extensionContext.cwd, projectTrusted: true, settingsPath: settings.projectSettingsPath });
+  const extensionSettings = settings.effective.extensionSettings;
+  const extensionSettingsPath = settings.sources.extensionSettings ?? settingsPath;
   return {
     cwd: extensionContext.cwd,
+    projectTrusted: trustedProject,
     model,
     tools,
     resourceSelectors: resourcePolicy.effective,
@@ -5780,9 +5786,10 @@ function executionRoot(context, dependencies, signal, runId, worktree, external)
     availableModels,
     knownModels,
     ...Object.keys(staticAliases).length ? { modelAliases: staticAliases } : {},
+    dynamicModelAliasNames: [],
     settingsPath: settings.sources.modelAliases,
     extensionSettingsPath,
-    agentDefinitions: external.agentDefinitions,
+    agentPreparationHooks: registry.agentPreparationHooks(),
     agentSetupHooks: registry.agentSetupHooks(),
     validateExtensionSettings: registry.validateExtensionSettings,
     agentResourcePolicy: () => structuredClone(resourcePolicy),
@@ -5798,11 +5805,10 @@ async function addDynamicAliases(context, signal, root) {
   const trustedProject = resourcePolicy?.projectTrusted ?? context.extensionContext.isProjectTrusted();
   const dynamicAliases = await registry.resolveModelAliases({ cwd: context.extensionContext.cwd, projectTrusted: trustedProject, rootModel: root.model, knownModels: root.knownModels ?? /* @__PURE__ */ new Set(), availableModels: root.availableModels ?? /* @__PURE__ */ new Set(), signal }, new Set(Object.keys(staticAliases)));
   validateModelAliasAvailability(dynamicAliases, Object.keys(dynamicAliases), root.availableModels ?? /* @__PURE__ */ new Set(), root.knownModels ?? /* @__PURE__ */ new Set(), root.settingsPath);
-  return { ...root, modelAliases: { ...dynamicAliases, ...staticAliases } };
+  return { ...root, modelAliases: { ...dynamicAliases, ...staticAliases }, dynamicModelAliasNames: Object.keys(dynamicAliases) };
 }
 function executionOptions(request, onAttempt, onProgress) {
-  const role = request.role;
-  const label2 = request.label ?? roleNameOf(role) ?? "subagent";
+  const label2 = request.label ?? "subagent";
   return {
     label: label2,
     workflowName: WORKFLOW_NAME,
@@ -5811,35 +5817,35 @@ function executionOptions(request, onAttempt, onProgress) {
     ...request.skills === void 0 ? {} : { skills: request.skills },
     ...request.extensions === void 0 ? {} : { extensions: request.extensions },
     ...request.contextFiles === void 0 ? {} : { contextFiles: request.contextFiles },
-    ...role === void 0 ? {} : { role },
     ...request.worktree === void 0 ? {} : { worktreeOwner: structuralPath("worktree", "named", request.worktree) },
     ...request.outputSchema === void 0 ? {} : { schema: request.outputSchema },
     ...request.retries === void 0 ? {} : { retries: request.retries },
     ...request.timeoutMs === void 0 ? {} : { timeoutMs: request.timeoutMs },
+    agentOptions: Object.fromEntries(Object.entries(request).filter(([key]) => !["prompt", "mode", "worktree"].includes(key))),
     onAttempt,
     onProgress
   };
 }
 function storageDirectory(dependencies) {
-  return dependencies.storageDir ?? join9(dependencies.agentDir ?? getAgentDir6(), STORAGE_DIRECTORY);
+  return dependencies.storageDir ?? join8(dependencies.agentDir ?? getAgentDir5(), STORAGE_DIRECTORY);
 }
 function runDirectory(root, id) {
-  return join9(root, id);
+  return join8(root, id);
 }
 function requestPath(directory) {
-  return join9(directory, "request.json");
+  return join8(directory, "request.json");
 }
 function configurationPath(directory) {
-  return join9(directory, CONFIGURATION_FILE);
+  return join8(directory, CONFIGURATION_FILE);
 }
 function statusPath(directory) {
-  return join9(directory, "status.json");
+  return join8(directory, "status.json");
 }
 function resultPath(directory) {
-  return join9(directory, "result.json");
+  return join8(directory, "result.json");
 }
 function failurePath(directory) {
-  return join9(directory, "failure.json");
+  return join8(directory, "failure.json");
 }
 async function secureDirectory(directory) {
   await mkdir3(directory, { recursive: true, mode: 448 });
@@ -5922,7 +5928,7 @@ async function releaseOwnerMarker(path, token) {
 }
 async function acquireStorageOwner(root, owner, liveness) {
   await secureDirectory(root);
-  const path = join9(root, OWNER_FILE);
+  const path = join8(root, OWNER_FILE);
   for (let attempt = 0; attempt < MAX_STORAGE_OWNER_ATTEMPTS; attempt += 1) {
     const marker = { ...owner, acquiredAt: Date.now() };
     try {
@@ -5993,32 +5999,8 @@ function checkedRequest(request) {
   return normalizeSubagentRunRequest(request);
 }
 function decodePersistedStandaloneExternalConfiguration(value) {
-  if (!object(value) || !jsonValue(value) || typeof value.projectTrusted !== "boolean") return void 0;
-  const globalExtensionSettings = value.globalExtensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.globalExtensionSettings);
-  const projectExtensionSettings = value.projectExtensionSettings === void 0 ? void 0 : decodeWorkflowExtensions(value.projectExtensionSettings);
-  if (value.globalExtensionSettings !== void 0 && globalExtensionSettings === void 0 || value.projectExtensionSettings !== void 0 && projectExtensionSettings === void 0) return void 0;
-  if (!object(value.agentDefinitions)) return void 0;
-  const agentDefinitions = /* @__PURE__ */ Object.create(null);
-  for (const [name, definition] of Object.entries(value.agentDefinitions)) {
-    const decoded = decodeAgentDefinition(definition);
-    if (decoded === void 0) return void 0;
-    agentDefinitions[name] = decoded;
-  }
-  return deepFreeze({ projectTrusted: value.projectTrusted, ...globalExtensionSettings === void 0 ? {} : { globalExtensionSettings }, ...projectExtensionSettings === void 0 ? {} : { projectExtensionSettings }, agentDefinitions });
-}
-function standaloneExternalConfiguration(context, dependencies) {
-  const cwd = context.extensionContext.cwd;
-  const trustedProject = context.extensionContext.isProjectTrusted();
-  const agentDir = dependencies.agentDir ?? getAgentDir6();
-  const resolution = resolveWorkflowSettings(cwd, trustedProject, workflowSettingsPath(agentDir));
-  const globalExtensionSettings = resolution.global.extensionSettings;
-  const projectExtensionSettings = resolution.project.extensionSettings;
-  return deepFreeze({
-    projectTrusted: trustedProject,
-    ...globalExtensionSettings === void 0 ? {} : { globalExtensionSettings: structuredClone(globalExtensionSettings) },
-    ...projectExtensionSettings === void 0 ? {} : { projectExtensionSettings: structuredClone(projectExtensionSettings) },
-    agentDefinitions: structuredClone(loadAgentDefinitions(cwd, agentDir, trustedProject))
-  });
+  if (!object(value) || value.version !== 1) return void 0;
+  return decodePreparedAgentConfiguration(value.configuration);
 }
 function checkedId(request) {
   if (typeof request.id !== "string" || !validSubagentId(request.id)) throw new WorkflowError("RUN_NOT_FOUND", `Unknown subagent ${request.id}`);
@@ -6203,8 +6185,8 @@ function isPreparedSession(value) {
   const textFields = ["initialPrompt", "agentDir", "systemPromptPath", "systemPromptAppend", "piRuntimeError"];
   if (textFields.some((field) => record2[field] !== void 0 && typeof record2[field] !== "string")) return false;
   if (record2.systemPrompt !== void 0 && (typeof record2.systemPrompt !== "string" || record2.systemPrompt.length > SUBAGENT_SYSTEM_PROMPT_LIMIT)) return false;
-  const runtime2 = recordValue(record2.piRuntime);
-  if (record2.piRuntime !== void 0 && (!runtime2 || typeof runtime2.executable !== "string" || !runtime2.executable.trim() || runtime2.entrypoint !== void 0 && (typeof runtime2.entrypoint !== "string" || !runtime2.entrypoint.trim()))) return false;
+  const runtime = recordValue(record2.piRuntime);
+  if (record2.piRuntime !== void 0 && (!runtime || typeof runtime.executable !== "string" || !runtime.executable.trim() || runtime.entrypoint !== void 0 && (typeof runtime.entrypoint !== "string" || !runtime.entrypoint.trim()))) return false;
   return true;
 }
 function isLiveSessionHandoff(value) {
@@ -6238,19 +6220,19 @@ function progressValue2(value) {
   const toolCalls = toolCallsValue2(record2.toolCalls);
   const state = record2.state === void 0 ? void 0 : sessionStateValue(record2.state);
   if (!accounting2 || !toolCalls || record2.state !== void 0 && state === void 0) return void 0;
-  const activity2 = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
-  if (record2.activity !== void 0 && activity2 === void 0) return void 0;
+  const activity = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
+  if (record2.activity !== void 0 && activity === void 0) return void 0;
   if (record2.lastEventAt !== void 0 && (!Number.isSafeInteger(record2.lastEventAt) || record2.lastEventAt < 0)) return void 0;
-  return { accounting: accounting2, toolCalls, ...state === void 0 ? {} : { state }, ...activity2 === void 0 ? {} : { activity: activity2 }, ...record2.lastEventAt === void 0 ? {} : { lastEventAt: record2.lastEventAt } };
+  return { accounting: accounting2, toolCalls, ...state === void 0 ? {} : { state }, ...activity === void 0 ? {} : { activity }, ...record2.lastEventAt === void 0 ? {} : { lastEventAt: record2.lastEventAt } };
 }
 function legacyProgressValue2(record2) {
   const accounting2 = legacyAccountingValue(record2);
   const toolCalls = record2.toolCalls === void 0 ? [] : toolCallsValue2(record2.toolCalls);
   if (!accounting2 || !toolCalls) return void 0;
-  const activity2 = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
-  if (record2.activity !== void 0 && activity2 === void 0) return void 0;
+  const activity = record2.activity === void 0 ? void 0 : activityValue(record2.activity);
+  if (record2.activity !== void 0 && activity === void 0) return void 0;
   if (record2.lastEventAt !== void 0 && (!Number.isSafeInteger(record2.lastEventAt) || record2.lastEventAt < 0)) return void 0;
-  return { accounting: accounting2, toolCalls, ...activity2 === void 0 ? {} : { activity: activity2 }, ...record2.lastEventAt === void 0 ? {} : { lastEventAt: record2.lastEventAt } };
+  return { accounting: accounting2, toolCalls, ...activity === void 0 ? {} : { activity }, ...record2.lastEventAt === void 0 ? {} : { lastEventAt: record2.lastEventAt } };
 }
 function worktreeContextValue(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
@@ -6329,7 +6311,7 @@ async function createRunStorage(root, id, request, status, external) {
     created = true;
     await chmod(directory, 448);
     await atomicJson(requestPath(directory), request);
-    await atomicJson(configurationPath(directory), external);
+    if (external !== void 0) await atomicJson(configurationPath(directory), { version: 1, configuration: external });
     await atomicJson(statusPath(directory), status);
     return directory;
   } catch (error) {
@@ -6511,6 +6493,7 @@ var PersistentSubagentManager = class {
   }
   dependencies;
   activeRuns = /* @__PURE__ */ new Map();
+  pendingStarts = /* @__PURE__ */ new Set();
   activeRunCount = 0;
   terminalSummaries = /* @__PURE__ */ new Map();
   reconciliationErrors = /* @__PURE__ */ new Map();
@@ -6554,32 +6537,44 @@ var PersistentSubagentManager = class {
     await this.ensureInitialized();
     if (this.disposed) throw new WorkflowError("CANCELLED", "Subagent manager is disposed");
     if (context.signal?.aborted) throw new WorkflowError("CANCELLED", "Subagent cancelled");
-    const external = frozenExternal ?? standaloneExternalConfiguration(context, this.dependencies);
-    if (external.projectTrusted && !context.extensionContext.isProjectTrusted()) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot retry standalone configuration from an untrusted project");
+    const external = frozenExternal;
+    if (external?.projectTrusted && !context.extensionContext.isProjectTrusted()) throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot retry standalone configuration from an untrusted project");
     const id = randomUUID3();
     const startedAt = Date.now();
     const sessionId = context.extensionContext.sessionManager.getSessionId();
     if (!sessionId.trim()) throw new WorkflowError("INTERNAL_ERROR", "Current Pi session identity is unavailable");
     const owner = this.runOwner;
     if (!owner) throw new WorkflowError("INTERNAL_ERROR", "Subagent storage owner identity is unavailable");
-    const settings = resolveWorkflowSettings(context.extensionContext.cwd, context.extensionContext.isProjectTrusted(), workflowSettingsPath(this.dependencies.agentDir ?? getAgentDir6()));
+    const settings = resolveWorkflowSettings(context.extensionContext.cwd, context.extensionContext.isProjectTrusted(), workflowSettingsPath(this.dependencies.agentDir ?? getAgentDir5()));
     const concurrency = settings.effective.concurrency;
     if (this.activeRunCount >= concurrency) throw new WorkflowError("AGENT_FAILED", `Subagent concurrency limit reached (${String(this.activeRunCount)}/${String(concurrency)} active runs); no queue is maintained. Retry after an active run settles.`);
     this.activeRunCount += 1;
     const controller = new AbortController();
     const initialStatus = { id, sessionId, state: "running", startedAt, owner: { ...owner } };
+    let finishStart;
+    const pendingStart = new Promise((resolve5) => {
+      finishStart = resolve5;
+    });
+    this.pendingStarts.add(pendingStart);
     let directory;
     try {
       directory = await createRunStorage(storageDirectory(this.dependencies), id, snapshot, initialStatus, external);
+      if (this.disposePromise !== void 0 || context.signal?.aborted) {
+        await atomicJson(statusPath(directory), reconciledStatus(initialStatus, "stopped", Date.now()));
+        throw new WorkflowError("CANCELLED", "Subagent cancelled");
+      }
     } catch (error) {
       this.activeRunCount -= 1;
       if (error instanceof WorkflowError) throw error;
       throw internalStorageError(error, `Unable to start subagent ${id}`);
+    } finally {
+      this.pendingStarts.delete(pendingStart);
+      finishStart();
     }
     const current = {};
     let resolveTerminal;
-    const terminal = new Promise((resolve6) => {
-      resolveTerminal = resolve6;
+    const terminal = new Promise((resolve5) => {
+      resolveTerminal = resolve5;
     });
     const executorOwnership = { default: true };
     const execution = Promise.resolve().then(async () => {
@@ -6607,12 +6602,9 @@ var PersistentSubagentManager = class {
           throw new WorkflowError("CANCELLED", "Subagent cancelled");
         }
       }
-      const baseRoot = executionRoot(context, this.dependencies, controller.signal, id, worktree, external);
-      const root = loadingRegistry().modelAliases().length === 0 ? baseRoot : await addDynamicAliases(context, controller.signal, baseRoot);
+      const baseRoot = executionRoot(context, this.dependencies, controller.signal, id, worktree);
+      const root = external !== void 0 || loadingRegistry().modelAliases().length === 0 ? baseRoot : await addDynamicAliases(context, controller.signal, baseRoot);
       const transport = this.dependencies.transport ?? localAgentTransport;
-      const injectedExecutor = this.dependencies.createExecutor?.(root, transport);
-      executorOwnership.default = injectedExecutor === void 0;
-      if (current.run) current.run.executorOwnsSession = executorOwnership.default;
       const setSteer = (handler) => {
         const run2 = current.run;
         if (run2) this.registerSteerHandler(run2, handler);
@@ -6653,6 +6645,13 @@ var PersistentSubagentManager = class {
         if (run2.state !== "running") return;
         emitUpdate(run2);
       }, (progress) => this.recordProgress(current.run, progress));
+      if (external !== void 0) options.configuration = structuredClone(external);
+      options.onConfiguration = (configuration) => atomicJson(configurationPath(directory), { version: 1, configuration });
+      const cwd = worktree?.cwd ?? root.cwd;
+      options.configuration = await new WorkflowAgentExecutor(root, transport).prepare(options, cwd, controller.signal);
+      const injectedExecutor = this.dependencies.createExecutor?.({ ...root, extensionSettings: options.configuration.settings }, transport);
+      executorOwnership.default = injectedExecutor === void 0;
+      if (current.run) current.run.executorOwnsSession = executorOwnership.default;
       if (injectedExecutor) return injectedExecutor.execute(snapshot.prompt, options, controller.signal, setSteer);
       return new WorkflowAgentExecutor(root, transport).execute(snapshot.prompt, options, controller.signal, [], setSteer);
     });
@@ -6703,9 +6702,9 @@ var PersistentSubagentManager = class {
       }
       return inspection;
     }
-    return this.inspectList();
+    return this.inspectList(request.scope === "all" ? void 0 : context.extensionContext.sessionManager.getSessionId());
   }
-  async inspectList() {
+  async inspectList(sessionId) {
     const root = storageDirectory(this.dependencies);
     await secureDirectory(root);
     const entries = await readdir3(root, { withFileTypes: true });
@@ -6716,7 +6715,7 @@ var PersistentSubagentManager = class {
       try {
         const active = this.activeRuns.get(entry.name);
         const status = publicStatus(active ? persistedStatus(active) : this.terminalSummaries.get(entry.name) ?? await loadPersistedStatus(root, entry.name, false));
-        if (status.startedAt === void 0) continue;
+        if (status.startedAt === void 0 || sessionId !== void 0 && status.sessionId !== sessionId) continue;
         statuses.push({ status, startedAt: status.startedAt });
       } catch (error) {
         if (error instanceof WorkflowError && (error.code === "RUN_NOT_FOUND" || error instanceof InvalidPersistedSubagentStatusError)) continue;
@@ -6760,11 +6759,11 @@ var PersistentSubagentManager = class {
   }
   async dispose() {
     if (this.disposePromise) return this.disposePromise;
+    this.disposed = true;
     this.disposePromise = (async () => {
       await this.initialization;
-      this.disposed = true;
       const runs = [...this.activeRuns.values()];
-      await Promise.allSettled(runs.map((run) => this.stopRun(run, true)));
+      await Promise.allSettled([...this.pendingStarts, ...runs.map((run) => this.stopRun(run, true))]);
       await Promise.allSettled([...this.notificationPromises]);
       const owner = this.storageOwner;
       this.storageOwner = void 0;
@@ -7095,9 +7094,8 @@ var PersistentSubagentManager = class {
     const notify = this.dependencies.notify;
     if (!notify || run.notificationSent || run.disposed) return;
     run.notificationSent = true;
-    const role = roleNameOf(run.request.role) ?? "none";
-    const label2 = run.request.label?.trim() || (role === "none" ? "subagent" : role);
-    const notification = { id: run.id, label: label2, role, state: run.state, ...run.error === void 0 ? {} : { error: run.error } };
+    const label2 = run.request.label?.trim() || "subagent";
+    const notification = { id: run.id, label: label2, state: run.state, ...run.error === void 0 ? {} : { error: run.error } };
     const pending = Promise.resolve().then(() => notify(notification));
     this.notificationPromises.add(pending);
     void pending.then(() => {
@@ -7145,8 +7143,8 @@ function createSubagentManager(dependencies = {}) {
 
 // subagents/src/navigator.ts
 import { readFile as readFile5 } from "node:fs/promises";
-import { join as join10 } from "node:path";
-import { copyToClipboard as copyToClipboard2, getAgentDir as getAgentDir7, SettingsManager as SettingsManager4 } from "@earendil-works/pi-coding-agent";
+import { join as join9 } from "node:path";
+import { copyToClipboard as copyToClipboard2, getAgentDir as getAgentDir6, SettingsManager as SettingsManager4 } from "@earendil-works/pi-coding-agent";
 import { Editor, truncateToWidth as truncateToWidth3 } from "@earendil-works/pi-tui";
 var MAX_DETAIL_TEXT = 4e3;
 function objectValue2(value) {
@@ -7169,7 +7167,7 @@ function managerContext(context, waitForForeground = true, includeAttemptMetadat
 async function loadRequest(storageDirectory3, id) {
   if (!safeRunId(id)) return {};
   try {
-    const value = JSON.parse(await readFile5(join10(storageDirectory3, id, "request.json"), "utf8"));
+    const value = JSON.parse(await readFile5(join9(storageDirectory3, id, "request.json"), "utf8"));
     return { request: normalizeSubagentRunRequest(value) };
   } catch (error) {
     if (isFileNotFound(error)) return {};
@@ -7202,18 +7200,11 @@ async function inspectEntry(manager, storageDirectory3, entry, context) {
     entry: { status: inspected.status, ...request.request === void 0 ? {} : { request: request.request }, ...request.error === void 0 ? {} : { requestError: request.error } }
   };
 }
-function requestRole(request) {
-  const role = request?.role;
-  if (typeof role === "string" && role.trim()) return role.trim();
-  const override = objectValue2(role);
-  return typeof override?.name === "string" && override.name.trim() ? override.name.trim() : "none";
-}
 function shortId(id) {
   return id.length > 12 ? id.slice(0, 8) : id;
 }
 function entryName(entry) {
-  const role = requestRole(entry.request);
-  return boundedText(entry.request?.label?.trim() || (role === "none" ? shortId(entry.status.id) : role), 256);
+  return boundedText(entry.request?.label?.trim() || shortId(entry.status.id), 256);
 }
 function listNames(entries) {
   const names = entries.map(entryName);
@@ -7228,8 +7219,8 @@ function pickerLabels(entries) {
     const name = names[index] ?? "";
     const model = status.progress?.state?.model;
     const cost = formatCost(status.progress?.accounting.cost);
-    const runtime2 = status.startedAt === void 0 ? "" : ` runtime=${formatWorkflowRuntime((status.finishedAt ?? Date.now()) - status.startedAt)}`;
-    return `${runStateGlyph(status.state, "\u2826")} ${name}  ${status.state}${model ? `  ${boundedText(model.model, 256)}${model.thinking ? `:${model.thinking}` : ""}` : ""}${cost ? ` ${cost}` : ""}${runtime2}`;
+    const runtime = status.startedAt === void 0 ? "" : ` runtime=${formatWorkflowRuntime((status.finishedAt ?? Date.now()) - status.startedAt)}`;
+    return `${runStateGlyph(status.state, "\u2826")} ${name}  ${status.state}${model ? `  ${boundedText(model.model, 256)}${model.thinking ? `:${model.thinking}` : ""}` : ""}${cost ? ` ${cost}` : ""}${runtime}`;
   });
 }
 function boundedText(value, limit = MAX_DETAIL_TEXT) {
@@ -7250,23 +7241,21 @@ function usageAccounting(status) {
   return status.progress?.accounting;
 }
 function detailPresentation(inspection) {
-  const { status, request } = inspection.entry;
+  const { status } = inspection.entry;
   const attempt = latestAttempt(status);
   const state = status.progress?.state;
-  const activity2 = status.progress?.activity;
+  const activity = status.progress?.activity;
   const model = state?.model ?? attempt?.setup.model;
   const tools = state?.tools ?? attempt?.setup.tools;
   const lastEventAt = status.progress?.lastEventAt;
   const attempts = status.attempts ?? attempt?.attempt;
   const accounting2 = usageAccounting(status);
-  const role = requestRole(request);
   const error = status.error ?? attempt?.error;
   return {
     state: status.state,
-    ...activity2 === void 0 ? {} : { activity: { kind: activity2.kind, text: boundedText(activity2.text) } },
+    ...activity === void 0 ? {} : { activity: { kind: activity.kind, text: boundedText(activity.text) } },
     ...lastEventAt === void 0 ? {} : { lastEventAt },
     ...model === void 0 ? {} : { model: { provider: boundedText(model.provider, 256), model: boundedText(model.model, 256), ...model.thinking === void 0 ? {} : { thinking: model.thinking } } },
-    ...role === "none" ? {} : { role: boundedText(role, 256) },
     ...tools === void 0 ? {} : { tools: tools.slice(0, 256).map((tool) => boundedText(tool, 256)) },
     ...attempts === void 0 ? {} : { attempts },
     ...status.startedAt === void 0 ? {} : { startedAt: status.startedAt },
@@ -7318,8 +7307,7 @@ function standaloneActionContext(manager, inspection, context) {
   const session = attempt.session;
   const live = liveData?.liveSession && session && liveData.liveSession.reference.transport === session.transport && liveData.liveSession.reference.sessionId === session.sessionId ? liveData.liveSession : void 0;
   const label2 = request?.label?.trim();
-  const role = requestRole(request);
-  const name = label2 || (role === "none" ? "subagent" : role);
+  const name = label2 || "subagent";
   const ui = {
     notify: (message, level = "info") => {
       context.ui.notify(message, level);
@@ -7388,7 +7376,7 @@ function retryResult(value) {
   return record2 && typeof record2.id === "string" && record2.id.trim() && record2.state === "running" ? { id: record2.id, state: "running" } : void 0;
 }
 async function openNavigatorArtifact(context, tui, artifact, label2) {
-  const command = SettingsManager4.create(context.cwd, getAgentDir7(), { projectTrusted: context.isProjectTrusted() }).getExternalEditorCommand();
+  const command = SettingsManager4.create(context.cwd, getAgentDir6(), { projectTrusted: context.isProjectTrusted() }).getExternalEditorCommand();
   if (!command) {
     context.ui.notify(`Cannot open ${label2}: no external editor is configured.`, "warning");
     return;
@@ -7419,7 +7407,7 @@ async function performAction(manager, storageDirectory3, entry, action, context,
     return "unchanged";
   }
   if (action === "Copy run path") {
-    await clipboard(join10(storageDirectory3, fresh.entry.status.id));
+    await clipboard(join9(storageDirectory3, fresh.entry.status.id));
     context.ui.notify("Copied run path.", "info");
     return "unchanged";
   }
@@ -7843,33 +7831,15 @@ var TERMINAL_STATES = /* @__PURE__ */ new Set(["completed", "failed", "stopped"]
 var MAX_INSPECT_VALUE_CHARS = 4e3;
 var MAX_INSPECT_TOOL_CALLS = 32;
 var MAX_BACKGROUND_WIDGET_ROWS = 10;
-function textBlock2(text) {
-  return {
-    render(width) {
-      return text.split("\n").map((line) => truncateToWidth4(line, Math.max(1, width), "\u2026"));
-    },
-    invalidate() {
-    }
-  };
-}
-function roleName(value) {
-  if (typeof value === "string") return value.trim() || void 0;
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-  const name = value.name;
-  return typeof name === "string" ? name.trim() || void 0 : void 0;
-}
 function modeName(value) {
   return value === "background" || value === "foreground" ? value : void 0;
 }
 function requestMetadata(args, metadataAvailable) {
   const mode = modeName(args.mode) ?? (metadataAvailable ? "background" : void 0);
-  const role = metadataAvailable ? roleName(args.role) ?? "none" : void 0;
-  return [mode === void 0 ? void 0 : `mode=${mode}`, role === void 0 ? void 0 : `role=${role}`].filter((value) => value !== void 0).join(" ");
+  return [mode === void 0 ? void 0 : `mode=${mode}`].filter((value) => value !== void 0).join(" ");
 }
 function label(args) {
   if (typeof args.label === "string" && args.label.trim()) return args.label.trim();
-  const role = roleName(args.role);
-  if (role) return role;
   if (typeof args.id === "string" && args.id) return args.id.slice(0, 8);
   return "subagent";
 }
@@ -7893,17 +7863,6 @@ function statusValue2(value) {
   if (typeof record2.id !== "string" || record2.state !== "running" && record2.state !== "completed" && record2.state !== "failed" && record2.state !== "stopped") return void 0;
   return value;
 }
-function runtime(startedAt, finishedAt, now) {
-  if (startedAt === void 0) return "";
-  const seconds = Math.max(0, Math.floor(((finishedAt ?? now) - startedAt) / 1e3));
-  if (seconds < 60) return `${String(seconds)}s`;
-  const minutes = Math.floor(seconds / 60);
-  const remainingSeconds = seconds % 60;
-  if (minutes < 60) return `${String(minutes)}m${remainingSeconds ? ` ${String(remainingSeconds)}s` : ""}`;
-  const hours = Math.floor(minutes / 60);
-  const remainingMinutes = minutes % 60;
-  return `${String(hours)}h${remainingMinutes ? ` ${String(remainingMinutes)}m` : ""}`;
-}
 function stateGlyph(state, spinner2) {
   if (state === "running") return spinner2;
   return state === "completed" ? "\u2713" : "\u2717";
@@ -7912,23 +7871,6 @@ function stateColor(state) {
   if (state === "running") return "accent";
   return state === "completed" ? "success" : "error";
 }
-function activity(status) {
-  if (status.state !== "running") return void 0;
-  const current = status.progress?.activity;
-  if (current?.kind === "reasoning" || current?.kind === "text") {
-    const name = current.kind === "reasoning" ? "reasoning" : "responding";
-    const text = sanitizeDisplayText(current.text);
-    return text && text !== name ? `${name} \xB7 ${text}` : name;
-  }
-  if (current?.kind === "tool") return sanitizeDisplayText(current.text);
-  return sanitizeDisplayText([...status.progress?.toolCalls ?? []].reverse().find(({ state }) => state === "running")?.name ?? "");
-}
-function stalledDuration2(status, now) {
-  const lastEventAt = status.progress?.lastEventAt;
-  if (status.state !== "running" || lastEventAt === void 0 || !Number.isFinite(lastEventAt)) return void 0;
-  const duration = now - lastEventAt;
-  return duration >= WORKFLOW_AGENT_STALL_THRESHOLD_MS ? duration : void 0;
-}
 function usageStats(status) {
   const value = status.progress?.accounting;
   return value ? [formatTokens(value.input + value.output), formatCost(value.cost)].filter(Boolean).join(" \xB7 ") : "";
@@ -7954,15 +7896,15 @@ function boundedValue(value) {
 }
 function formatSubagentProgress(status, args, theme, spinner2, now, expanded) {
   const color = stateColor(status.state);
-  const elapsed = runtime(status.startedAt, status.finishedAt, now);
+  const elapsed = status.startedAt === void 0 ? "" : formatWorkflowRuntime((status.finishedAt ?? now) - status.startedAt);
   const metadata = requestMetadata(args, args.id === void 0);
   const stats = usageStats(status);
   const lines = [
-    `${theme.fg(color, stateGlyph(status.state, spinner2))} ${theme.bold(theme.fg("accent", `Subagent: ${label({ ...args, id: status.id })}`))} ${theme.fg(color, `[${status.state}]`)}${metadata ? ` ${theme.fg("dim", metadata)}` : ""}${stats ? ` ${stats}` : ""}${elapsed ? ` runtime=${elapsed}` : ""}`
+    `${theme.fg(color, stateGlyph(status.state, "\u25CF"))} ${theme.bold(theme.fg("accent", `Subagent: ${label({ ...args, id: status.id })}`))} ${theme.fg(color, `[${status.state}]`)}${metadata ? ` ${theme.fg("dim", metadata)}` : ""}${stats ? ` ${stats}` : ""}${elapsed ? ` runtime=${elapsed}` : ""}`
   ];
-  const current = activity(status);
-  const stalled = stalledDuration2(status, now);
-  if (current) lines.push(`  ${theme.fg("accent", spinner2)} ${theme.fg("dim", current)}${stalled === void 0 ? "" : ` ${theme.fg("warning", `- stalled? ${formatStalledDuration(stalled)}`)}`}`);
+  const current = status.state === "running" ? agentActivityLabel(status.progress ?? {}) : void 0;
+  const stalled = stalledDuration({ ...status.progress, state: status.state }, now);
+  if (current || status.state === "running") lines.push(`  ${theme.fg("accent", spinner2)}${current ? ` ${theme.fg("dim", current)}` : ""}${stalled === void 0 ? "" : ` ${theme.fg("warning", `- stalled? ${formatStalledDuration(stalled)}`)}`}`);
   else if (stalled !== void 0) lines.push(`  ${theme.fg("warning", `stalled? ${formatStalledDuration(stalled)}`)}`);
   if (status.error) lines.push(`  ${theme.fg("error", `${status.error.code}: ${status.error.message}`)}`);
   if (expanded) {
@@ -8028,7 +7970,7 @@ function subagentProgressBlock(status, args, theme, freezeAt) {
     render(width) {
       const now = TERMINAL_STATES.has(current.state) ? frozenAt : Date.now();
       if (!TERMINAL_STATES.has(current.state)) frozenAt = now;
-      const frame = SPINNER2[Math.floor(now / 80) % SPINNER2.length] ?? "\u25C7";
+      const frame = SPINNER2[Math.floor(now / REPAINT_MS) % SPINNER2.length] ?? "\u25C7";
       return formatSubagentProgress(current, args, currentTheme, frame, now, expanded).split("\n").map((line) => truncateToWidth4(line, Math.max(1, width), "\u2026"));
     },
     invalidate() {
@@ -8046,14 +7988,14 @@ function renderSubagentResult(result, options, theme, context) {
   if (status?.state === "running" && options.isPartial && !state.subagentSpinner) {
     state.subagentSpinner = setInterval(() => {
       context.invalidate();
-    }, 80);
+    }, REPAINT_MS);
     state.subagentSpinner.unref();
   } else if ((!options.isPartial || status?.state !== "running") && state.subagentSpinner) {
     clearInterval(state.subagentSpinner);
     delete state.subagentSpinner;
   }
-  if (!status || context.isError) return textBlock2(resultText(result));
-  if (!options.isPartial && status.state === "running") return textBlock2(formatSubagentLaunch(status, context.args, theme, options.expanded));
+  if (!status || context.isError) return textBlock(resultText(result));
+  if (!options.isPartial && status.state === "running") return textBlock(formatSubagentLaunch(status, context.args, theme, options.expanded));
   if (TERMINAL_STATES.has(status.state)) state.subagentProgressFrozenAt ??= Date.now();
   else delete state.subagentProgressFrozenAt;
   let component = state.subagentProgressComponent;
@@ -8087,14 +8029,12 @@ var RECEIPT_ENTRY_TYPE = "piewf-subagent-receipt";
 function receiptFor(status, request) {
   const accounting2 = status.progress?.accounting;
   const model = modelName(status);
-  const role = roleName(request.role);
   const tools = status.progress?.state?.tools ?? status.attemptDetails?.at(-1)?.setup.tools;
   return {
     id: status.id,
     label: label({ ...request, id: status.id }),
     state: status.state,
     ...model ? { model } : {},
-    ...role === void 0 ? {} : { role },
     ...tools === void 0 ? {} : { tools: [...tools] },
     input: accounting2?.input ?? 0,
     output: accounting2?.output ?? 0,
@@ -8110,7 +8050,7 @@ function renderSubagentReceipt(data, expanded, theme) {
   const headline = [formatTokens(data.input + data.output), formatCost(data.costUsd) || "$0.00", formatElapsed(data.durationMs), data.state].filter(Boolean).join(" \xB7 ");
   const lines = [`${glyph} ${theme.bold(sanitizeDisplayText(data.label))} ${theme.fg("muted", headline)}`];
   if (!expanded) return lines;
-  const meta = [data.model ?? "", data.role ? `role ${data.role}` : "", data.attempts > 1 ? `${String(data.attempts)} attempts` : "", data.tools?.join(" ") ?? ""].filter(Boolean);
+  const meta = [data.model ?? "", data.attempts > 1 ? `${String(data.attempts)} attempts` : "", data.tools?.join(" ") ?? ""].filter(Boolean);
   if (meta.length > 0) lines.push(theme.fg("muted", `   ${meta.join(" \xB7 ")}`));
   const split = [data.input ? `in ${formatTokens(data.input)}` : "", data.output ? `out ${formatTokens(data.output)}` : "", data.cacheRead ? `cache ${formatTokens(data.cacheRead)}` : ""].filter(Boolean);
   if (split.length > 0) lines.push(theme.fg("muted", `   ${split.join(" \xB7 ")}`));
@@ -8175,7 +8115,7 @@ function createSubagentBackgroundWidget(host = {}) {
       showing = true;
       timer = setInterval(() => {
         requestRender?.();
-      }, 80);
+      }, REPAINT_MS);
       timer.unref();
     } catch {
       hide();
@@ -8211,35 +8151,35 @@ function createSubagentBackgroundWidget(host = {}) {
 }
 function renderSubagentInspectCall(args, theme) {
   const title = theme.fg("toolTitle", theme.bold("subagents_inspect"));
-  return textBlock2(args.id ? `${title} ${theme.fg("accent", args.id)}` : `${title} ${theme.fg("muted", "all")}`);
+  return textBlock(args.id ? `${title} ${theme.fg("accent", args.id)}` : `${title} ${theme.fg("muted", args.scope === "all" ? "all" : "session")}`);
 }
 function renderSubagentInspectResult(result, options, theme, args) {
   const status = statusValue2(result.details);
-  if (status) return textBlock2(formatSubagentInspection(status, args, result.details, theme, options.expanded));
+  if (status) return textBlock(formatSubagentInspection(status, args, result.details, theme, options.expanded));
   if (Array.isArray(result.details)) {
     const statuses = result.details.map(statusValue2).filter((value) => value !== void 0);
     const lines = [theme.bold(theme.fg("accent", `Subagents (${String(statuses.length)})`)), ...statuses.map((entry) => {
       const color = stateColor(entry.state);
       return `  ${theme.fg(color, stateGlyph(entry.state, "\u25C7"))} ${entry.id.slice(0, 8)} ${theme.fg(color, `[${entry.state}]`)}`;
     })];
-    return textBlock2(lines.join("\n"));
+    return textBlock(lines.join("\n"));
   }
-  return textBlock2(resultText(result));
+  return textBlock(resultText(result));
 }
 function renderSubagentControlCall(name, args, theme) {
   const title = theme.fg("toolTitle", theme.bold(name));
   const message = args.message ? ` ${theme.fg("dim", args.message)}` : "";
-  return textBlock2(`${title} ${theme.fg("accent", args.id)}${message}`);
+  return textBlock(`${title} ${theme.fg("accent", args.id)}${message}`);
 }
 function renderSubagentControlResult(result, theme) {
   const status = statusValue2(result.details);
   if (status) {
     const color = stateColor(status.state);
-    return textBlock2(`${theme.fg(color, stateGlyph(status.state, "\u25C7"))} ${status.id.slice(0, 8)} ${theme.fg(color, `[${status.state}]`)}`);
+    return textBlock(`${theme.fg(color, stateGlyph(status.state, "\u25C7"))} ${status.id.slice(0, 8)} ${theme.fg(color, `[${status.state}]`)}`);
   }
   const record2 = typeof result.details === "object" && result.details !== null && !Array.isArray(result.details) ? result.details : void 0;
-  if (record2 && typeof record2.id === "string") return textBlock2(`${theme.fg("success", "\u2713")} ${record2.id.slice(0, 8)}`);
-  return textBlock2(resultText(result));
+  if (record2 && typeof record2.id === "string") return textBlock(`${theme.fg("success", "\u2713")} ${record2.id.slice(0, 8)}`);
+  return textBlock(resultText(result));
 }
 
 // subagents/src/index.ts
@@ -8247,15 +8187,15 @@ function validateSubagentRunRequest(value) {
   return normalizeSubagentRunRequest(value);
 }
 function validateSubagentIdRequest(value, operation) {
-  if (!Value3.Check(SUBAGENTS_ID_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", `Invalid ${operation} parameters`);
+  if (!Value4.Check(SUBAGENTS_ID_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", `Invalid ${operation} parameters`);
   return value;
 }
 function validateSubagentInspectRequest(value) {
-  if (!Value3.Check(SUBAGENTS_INSPECT_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", "Invalid subagents_inspect parameters");
+  if (!Value4.Check(SUBAGENTS_INSPECT_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", "Invalid subagents_inspect parameters");
   return value;
 }
 function validateSubagentSteerRequest(value) {
-  if (!Value3.Check(SUBAGENTS_STEER_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", "Invalid subagents_steer parameters");
+  if (!Value4.Check(SUBAGENTS_STEER_PARAMETERS, value)) throw new WorkflowError("INVALID_METADATA", "Invalid subagents_steer parameters");
   return value;
 }
 function serialize(value) {
@@ -8268,7 +8208,7 @@ function serialize(value) {
   }
 }
 function toolResult(value) {
-  return { content: [{ type: "text", text: serialize(value) }], details: value };
+  return { content: [{ type: "text", text: serialize(value) }], details: value, structuredContent: value };
 }
 function managerContext2(toolCallId, signal, onUpdate, context) {
   return {
@@ -8292,6 +8232,7 @@ function createSubagentTools(manager) {
         "Do not poll a running ID; use subagents_inspect({ id }) when you need its current status or terminal result."
       ],
       parameters: SUBAGENTS_RUN_PARAMETERS,
+      outputSchema: SUBAGENT_STATUS_OUTPUT,
       async execute(toolCallId, params, signal, onUpdate, context) {
         return toolResult(await manager.run(validateSubagentRunRequest(params), managerContext2(toolCallId, signal, onUpdate, context)));
       },
@@ -8305,8 +8246,9 @@ function createSubagentTools(manager) {
     defineTool2({
       name: "subagents_inspect",
       label: "Subagents Inspect",
-      description: "Inspect durable subagent runs. Omit id for ordered run summaries, or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
+      description: "Inspect durable subagent runs. Omit id for ordered run summaries of the current session (scope all for every session), or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
       parameters: SUBAGENTS_INSPECT_PARAMETERS,
+      outputSchema: SUBAGENTS_INSPECT_OUTPUT,
       async execute(toolCallId, params, signal, onUpdate, context) {
         return toolResult(await manager.inspect(validateSubagentInspectRequest(params), managerContext2(toolCallId, signal, onUpdate, context)));
       },
@@ -8322,6 +8264,7 @@ function createSubagentTools(manager) {
       label: "Subagents Steer",
       description: "Send a message to a running subagent. The message is queued safely if its steering handler is not ready; settled runs cannot be steered.",
       parameters: SUBAGENTS_STEER_PARAMETERS,
+      outputSchema: SUBAGENTS_STEER_OUTPUT,
       async execute(toolCallId, params, signal, onUpdate, context) {
         return toolResult(await manager.steer(validateSubagentSteerRequest(params), managerContext2(toolCallId, signal, onUpdate, context)));
       },
@@ -8337,6 +8280,7 @@ function createSubagentTools(manager) {
       label: "Subagents Stop",
       description: 'Stop one running subagent, abort its active session, persist state "stopped", and clean its worktree without affecting sibling runs.',
       parameters: SUBAGENTS_STOP_PARAMETERS,
+      outputSchema: SUBAGENT_STATUS_OUTPUT,
       async execute(toolCallId, params, signal, onUpdate, context) {
         return toolResult(await manager.stop(validateSubagentIdRequest(params, "subagents_stop"), managerContext2(toolCallId, signal, onUpdate, context)));
       },
@@ -8352,6 +8296,7 @@ function createSubagentTools(manager) {
       label: "Subagents Retry",
       description: "Start a fresh run from a failed or stopped subagent's persisted request. The new run gets a new ID and preserves its original background or foreground mode.",
       parameters: SUBAGENTS_RETRY_PARAMETERS,
+      outputSchema: SUBAGENT_STATUS_OUTPUT,
       async execute(toolCallId, params, signal, onUpdate, context) {
         return toolResult(await manager.retry(validateSubagentIdRequest(params, "subagents_retry"), managerContext2(toolCallId, signal, onUpdate, context)));
       },
@@ -8366,8 +8311,7 @@ function createSubagentTools(manager) {
 }
 function notificationContent(notification) {
   const label2 = notification.label?.trim();
-  const role = notification.role?.trim() || "none";
-  const identity = label2 ? `${label2} role=${role} (${notification.id})` : `${notification.id} role=${role}`;
+  const identity = label2 ? `${label2} (${notification.id})` : notification.id;
   if (notification.state === "completed") return `Subagent ${identity} completed. Inspect it with subagents_inspect({ id: "${notification.id}" }).`;
   return `Subagent ${identity} failed: ${notification.error?.message ?? "unknown error"}. Inspect it with subagents_inspect({ id: "${notification.id}" }).`;
 }
@@ -8384,7 +8328,7 @@ function managerDependencies(options, activeTools, notify, onStatus, onResourceW
 }
 function storageDirectory2(options) {
   const dependencies = options.managerDependencies;
-  return dependencies?.storageDir ?? join11(dependencies?.agentDir ?? getAgentDir8(), "subagents");
+  return dependencies?.storageDir ?? join10(dependencies?.agentDir ?? getAgentDir7(), "subagents");
 }
 function createSubagentsExtension(options = {}, activeTools, notify, onStatus, onResourceWarning) {
   const manager = options.manager ?? createSubagentManager(managerDependencies(options, activeTools, notify, onStatus, onResourceWarning));
@@ -8393,7 +8337,8 @@ function createSubagentsExtension(options = {}, activeTools, notify, onStatus, o
 }
 function registerSubagentsExtension(pi, options = {}) {
   const getActiveTools = pi.getActiveTools;
-  const activeTools = getActiveTools === void 0 ? void 0 : () => getActiveTools.call(pi);
+  const getAllTools = pi.getAllTools;
+  const activeTools = getActiveTools === void 0 ? void 0 : () => reachableTools({ getActiveTools: () => getActiveTools.call(pi), ...getAllTools === void 0 ? {} : { getAllTools: () => getAllTools.call(pi) } });
   const sendMessage = pi.sendMessage;
   const notify = sendMessage === void 0 ? void 0 : (notification) => {
     sendMessage.call(pi, { customType: "subagents", content: notificationContent(notification), display: true, details: notification }, { deliverAs: "steer", triggerTurn: true });
@@ -8410,7 +8355,8 @@ function registerSubagentsExtension(pi, options = {}) {
     const registry = loadingRegistry();
     if (typeof registry.observeSubagentStatus === "function") registry.observeSubagentStatus(status, request);
   }, onResourceWarning);
-  for (const tool of extension2.tools) pi.registerTool(tool);
+  const codemodeTools = loadCodemodeToolsSetting(options.managerDependencies?.agentDir);
+  for (const tool of extension2.tools) pi.registerTool({ ...tool, ...workflowToolExposure(tool.name, codemodeTools) });
   if (pi.registerCommand !== void 0) registerSubagentNavigator(pi.registerCommand.bind(pi), extension2.manager, storageDirectory2(options), options.clipboard);
   if (pi.on !== void 0) {
     setSubagentManager(extension2.manager);
@@ -8433,15 +8379,17 @@ function extension(pi, options = {}) {
 }
 export {
   SUBAGENTS_ID_PARAMETERS,
+  SUBAGENTS_INSPECT_OUTPUT,
   SUBAGENTS_INSPECT_PARAMETERS,
   SUBAGENTS_RETRY_PARAMETERS,
   SUBAGENTS_RUN_PARAMETERS,
+  SUBAGENTS_STEER_OUTPUT,
   SUBAGENTS_STEER_PARAMETERS,
   SUBAGENTS_STOP_PARAMETERS,
   SUBAGENTS_TOOL_NAMES,
-  SUBAGENTS_TOOL_SCHEMAS,
   SUBAGENT_ATTEMPT_DETAILS_LIMIT,
   SUBAGENT_MAX_RETRIES,
+  SUBAGENT_STATUS_OUTPUT,
   SUBAGENT_SYSTEM_PROMPT_LIMIT,
   attemptValue,
   createRunStoreWorktreeAdapter,