@marcoscale98/pi-extensible-workflows 5.19.1-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",
@@ -37,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 };
@@ -58,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) {
@@ -156,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;
@@ -214,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`);
@@ -285,6 +280,10 @@ function resolveModelReference(value, aliases = {}, knownModels, settingsPath) {
   };
   return resolveReference(value, []);
 }
+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])];
@@ -295,10 +294,6 @@ function physicalModel(spec, aliases = {}, knownModels, settingsPath) {
   const target = resolveModelReference(spec.model, aliases, knownModels, settingsPath);
   return spec.thinking === void 0 ? target : { ...target, thinking: spec.thinking };
 }
-function modelCapability(value, aliases, knownModels, settingsPath) {
-  const parsed = typeof value === "string" ? resolveModelReference(value, aliases, knownModels, settingsPath) : value;
-  return `${parsed.provider}/${parsed.model}`;
-}
 var RESOURCE_PATTERN_OPTIONS = { dot: true, nonegate: true, nocomment: true };
 function resourcePatternBody(pattern) {
   return pattern.startsWith("!") ? pattern.slice(1) : pattern;
@@ -349,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, "_");
 }
@@ -363,11 +359,21 @@ function canonicalPath(path) {
   }
 }
 function extensionIdentity(path) {
-  return path.startsWith("builtin:") ? path : canonicalPath(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");
 }
@@ -395,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";
@@ -426,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));
     }
   }
 }
@@ -492,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");
@@ -582,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;
@@ -716,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 },
@@ -737,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 },
@@ -745,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 }
   };
@@ -785,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;
@@ -827,7 +817,6 @@ 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);
@@ -836,7 +825,7 @@ function decodeAgent(value) {
   const toolCalls = value.toolCalls === void 0 ? void 0 : decodeArray(value.toolCalls, decodeAgentToolCall);
   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 (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 },
@@ -853,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,
@@ -1001,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,
@@ -1020,9 +1006,7 @@ function decodeLaunchSnapshot(value) {
     ...phases === void 0 ? {} : { phases },
     models,
     tools,
-    agentTypes,
-    ...roles === void 0 ? {} : { roles },
-    ...projectRoles === void 0 ? {} : { projectRoles },
+    agentConfigurations,
     schemas
   };
 }
@@ -1103,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;
 }
@@ -1124,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;
@@ -1135,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()) {
@@ -1173,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;
@@ -1195,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 });
@@ -1216,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;
   }
@@ -1231,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;
@@ -1239,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;
@@ -1259,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();
@@ -1272,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 {
@@ -1320,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) {
@@ -1332,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 });
@@ -1364,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 });
     }
@@ -1394,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;
   }
@@ -1408,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;
     });
@@ -1518,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");
@@ -1564,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;
     });
@@ -1580,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;
     });
@@ -1705,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);
     }
@@ -1761,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 {
@@ -1804,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) {
@@ -1821,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]);
@@ -1866,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;
   }
@@ -1947,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");
@@ -1975,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 === "*" || value.startsWith("builtin:")) return value;
-  let expanded = value === "~" ? homedir3() : value.startsWith("~/") || value.startsWith("~\\") ? join3(homedir3(), value.slice(2)) : value;
-  if (expanded.startsWith("file://")) expanded = fileURLToPath(expanded);
+  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)) {
@@ -2044,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`);
@@ -2070,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);
@@ -2147,41 +2171,21 @@ function loadSettingsOverrides(path) {
 }
 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) {
@@ -2198,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
+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);
@@ -2242,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;
@@ -2264,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;
@@ -2276,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) {
@@ -2298,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}`);
@@ -2307,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];
@@ -2339,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 };
@@ -2398,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)}`);
       }
     }
@@ -2417,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));
   }
@@ -2484,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() {
@@ -2504,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("**/") || body.startsWith("builtin:")) 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) => extensionIdentity(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";
@@ -2918,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")));
@@ -3135,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, createCodemodeExtension, createMcpExtension, createToolSearchExtension, 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"]);
@@ -3423,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;
   };
@@ -3456,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();
@@ -3659,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;
@@ -3894,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;
@@ -3984,40 +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 WORKFLOW_HOST_ENTRY_PATHS = ["src/index.ts", "dist/src/index.js", "starter/index.ts", "dist/starter/index.js", "subagents/index.ts", "dist/subagents/index.js"];
 function isWorkflowHostEntry(path) {
   const entryPath = canonicalPath(path);
-  let packageRoot2 = dirname5(entryPath);
-  while (packageRoot2 !== dirname5(packageRoot2)) {
-    const packageMetadataPath = join6(packageRoot2, "package.json");
+  let packageRoot2 = dirname3(entryPath);
+  while (packageRoot2 !== dirname3(packageRoot2)) {
+    const packageMetadataPath = join5(packageRoot2, "package.json");
     if (existsSync(packageMetadataPath)) {
       try {
-        const metadata = JSON.parse(readFileSync4(packageMetadataPath, "utf8"));
+        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(join6(packageRoot2, entry)) === entryPath);
+        return WORKFLOW_HOST_ENTRY_PATHS.some((entry) => canonicalPath(join5(packageRoot2, entry)) === entryPath);
       } catch {
         return false;
       }
     }
-    packageRoot2 = dirname5(packageRoot2);
+    packageRoot2 = dirname3(packageRoot2);
   }
   return false;
 }
-var WORKFLOW_DIRECTORY = "pi-extensible-workflows";
+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);
   });
 }
@@ -4043,10 +3823,10 @@ async function loadNativeCoreModule(file, label2) {
   const packageDirectory = await loadPiPackageDirectory();
   let modulePath;
   if (packageDirectory.directory) {
-    const candidate = resolve5(packageDirectory.directory, "dist/core", file);
+    const candidate = resolve4(packageDirectory.directory, "dist/core", file);
     if (existsSync(candidate)) modulePath = candidate;
   }
-  modulePath ??= resolve5(dirname5(fileURLToPath3(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core", file);
+  modulePath ??= resolve4(dirname3(fileURLToPath3(import.meta.resolve("@earendil-works/pi-coding-agent"))), "core", file);
   const packageDirectoryError = packageDirectory.error ? ` Package directory lookup failed: ${packageDirectory.error}` : "";
   let loaded = nativeCoreModules.get(file);
   if (!loaded) {
@@ -4137,14 +3917,43 @@ 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;
@@ -4160,25 +3969,23 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     const resolved = await packageManager.resolve();
     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 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,
@@ -4189,12 +3996,13 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
       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 });
@@ -4212,7 +4020,7 @@ async function createLocalPiSessionHandle(input, sessionStartEvent) {
     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) => {
@@ -4575,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]);
 }
@@ -4597,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;
@@ -4654,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 = [];
@@ -4703,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 }),
@@ -4745,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" } : {} });
@@ -4807,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) {
@@ -4839,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: physicalModel(resolved.model ?? this.root.model, this.root.modelAliases, this.root.knownModels, this.root.settingsPath), ...resolved.requestedModel === void 0 ? {} : { requestedModel: resolved.requestedModel }, tools: resolved.tools ?? [], ...resolved.overrideSystemPrompt ? { systemPrompt: resolved.prompt } : {}, systemPromptAppend: resolved.overrideSystemPrompt ? "" : resolved.prompt, ...resolved.contextFiles === void 0 ? {} : { contextFiles: resolved.contextFiles } };
+      ...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) {
@@ -4907,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) {
@@ -4936,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 };
@@ -4968,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 });
@@ -5008,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);
@@ -5043,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,
@@ -5051,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,
@@ -5137,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 };
 }
@@ -5148,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();
@@ -5355,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)}`],
@@ -5398,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] ?? ""}`;
@@ -5443,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();
       });
     },
@@ -5475,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",
@@ -5500,15 +5379,15 @@ 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" })),
   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" }))
@@ -5542,7 +5421,7 @@ var SUBAGENT_STATUS_OUTPUT = Type2.Object({
 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";
@@ -5758,11 +5637,11 @@ 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,
@@ -5785,7 +5664,7 @@ function syntheticSnapshot(context) {
     ...context.worktreePostCreateCommandSource === void 0 ? {} : { settingsSources: { concurrency: "subagents", modelAliases: "subagents", worktreePostCreateCommand: context.worktreePostCreateCommandSource } },
     models: [],
     tools: [],
-    agentTypes: [],
+    agentConfigurations: {},
     schemas: []
   };
 }
@@ -5824,7 +5703,7 @@ function createRunStoreWorktreeAdapter(home) {
   };
 }
 function defaultWorktreeHome(storageDirectory3) {
-  return join8(storageDirectory3, ".worktrees");
+  return join7(storageDirectory3, ".worktrees");
 }
 
 // subagents/src/manager.ts
@@ -5864,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);
@@ -5902,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,
@@ -5916,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),
@@ -5934,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,
@@ -5947,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 });
@@ -6058,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 {
@@ -6129,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}`);
@@ -6465,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) {
@@ -6647,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();
@@ -6690,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 () => {
@@ -6743,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);
@@ -6789,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);
     });
@@ -6896,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;
@@ -7231,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(() => {
@@ -7281,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) {
@@ -7305,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 {};
@@ -7338,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);
@@ -7386,7 +7241,7 @@ 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 activity = status.progress?.activity;
@@ -7395,14 +7250,12 @@ function detailPresentation(inspection) {
   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,
     ...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 },
@@ -7454,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);
@@ -7524,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;
@@ -7555,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";
   }
@@ -7979,24 +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 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";
 }
@@ -8186,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,
@@ -8209,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 ")}`));
@@ -8346,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) {
@@ -8470,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}" }).`;
 }
@@ -8488,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));