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

package/dist/subagents/src/contracts.d.ts

@@ -13,10 +13,10 @@ export declare const SUBAGENTS_RUN_PARAMETERS: Type.TObject<{
     label: Type.TOptional<Type.TString>;
     model: Type.TOptional<Type.TString>;
     tools: Type.TOptional<Type.TArray<Type.TString>>;
+    excludeTools: Type.TOptional<Type.TArray<Type.TString>>;
     skills: Type.TOptional<Type.TArray<Type.TString>>;
     extensions: Type.TOptional<Type.TArray<Type.TString>>;
     contextFiles: Type.TOptional<Type.TArray<Type.TString>>;
-    role: Type.TOptional<Type.TString>;
     worktree: Type.TOptional<Type.TString>;
     outputSchema: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
     retries: Type.TOptional<Type.TInteger>;
@@ -24,6 +24,7 @@ export declare const SUBAGENTS_RUN_PARAMETERS: Type.TObject<{
 }>;
 export declare const SUBAGENTS_INSPECT_PARAMETERS: Type.TObject<{
     id: Type.TOptional<Type.TString>;
+    scope: Type.TOptional<Type.TUnion<[Type.TLiteral<"session">, Type.TLiteral<"all">]>>;
 }>;
 export declare const SUBAGENTS_ID_PARAMETERS: Type.TObject<{
     id: Type.TString;
@@ -38,37 +39,54 @@ export declare const SUBAGENTS_STOP_PARAMETERS: Type.TObject<{
 export declare const SUBAGENTS_RETRY_PARAMETERS: Type.TObject<{
     id: Type.TString;
 }>;
-export declare const SUBAGENTS_TOOL_SCHEMAS: {
-    readonly subagents_run: Type.TObject<{
-        prompt: Type.TString;
-        mode: Type.TOptional<Type.TUnion<[Type.TLiteral<"background">, Type.TLiteral<"foreground">]>>;
-        label: Type.TOptional<Type.TString>;
-        model: Type.TOptional<Type.TString>;
-        tools: Type.TOptional<Type.TArray<Type.TString>>;
-        skills: Type.TOptional<Type.TArray<Type.TString>>;
-        extensions: Type.TOptional<Type.TArray<Type.TString>>;
-        contextFiles: Type.TOptional<Type.TArray<Type.TString>>;
-        role: Type.TOptional<Type.TString>;
-        worktree: Type.TOptional<Type.TString>;
-        outputSchema: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
-        retries: Type.TOptional<Type.TInteger>;
-        timeoutMs: Type.TOptional<Type.TUnion<[Type.TInteger, Type.TNull]>>;
-    }>;
-    readonly subagents_inspect: Type.TObject<{
-        id: Type.TOptional<Type.TString>;
-    }>;
-    readonly subagents_steer: Type.TObject<{
-        id: Type.TString;
+export declare const SUBAGENT_STATUS_OUTPUT: Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+    sessionId: Type.TOptional<Type.TString>;
+    startedAt: Type.TOptional<Type.TNumber>;
+    finishedAt: Type.TOptional<Type.TNumber>;
+    attempts: Type.TOptional<Type.TNumber>;
+    attemptDetails: Type.TOptional<Type.TArray<Type.TUnknown>>;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        branch: Type.TString;
+    }>>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TString;
+        message: Type.TString;
+    }>>;
+    progress: Type.TOptional<Type.TUnknown>;
+    value: Type.TOptional<Type.TUnknown>;
+}>;
+export declare const SUBAGENTS_INSPECT_OUTPUT: Type.TUnion<[Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+    sessionId: Type.TOptional<Type.TString>;
+    startedAt: Type.TOptional<Type.TNumber>;
+    finishedAt: Type.TOptional<Type.TNumber>;
+    attempts: Type.TOptional<Type.TNumber>;
+    attemptDetails: Type.TOptional<Type.TArray<Type.TUnknown>>;
+    worktree: Type.TOptional<Type.TObject<{
+        path: Type.TString;
+        branch: Type.TString;
+    }>>;
+    error: Type.TOptional<Type.TObject<{
+        code: Type.TString;
         message: Type.TString;
-    }>;
-    readonly subagents_stop: Type.TObject<{
-        id: Type.TString;
-    }>;
-    readonly subagents_retry: Type.TObject<{
-        id: Type.TString;
-    }>;
+    }>>;
+    progress: Type.TOptional<Type.TUnknown>;
+    value: Type.TOptional<Type.TUnknown>;
+}>, Type.TArray<Type.TObject<{
+    id: Type.TString;
+    state: Type.TString;
+}>>]>;
+export declare const SUBAGENTS_STEER_OUTPUT: Type.TObject<{
+    id: Type.TString;
+    accepted: Type.TBoolean;
+}>;
+export type SubagentRunRequest = Static<typeof SUBAGENTS_RUN_PARAMETERS> & {
+    readonly [key: string]: unknown;
 };
-export type SubagentRunRequest = Static<typeof SUBAGENTS_RUN_PARAMETERS>;
 export declare function normalizeSubagentRunRequest(value: unknown): SubagentRunRequest;
 export type SubagentInspectRequest = Static<typeof SUBAGENTS_INSPECT_PARAMETERS>;
 export type SubagentIdRequest = Static<typeof SUBAGENTS_ID_PARAMETERS>;
@@ -101,7 +119,6 @@ export interface SubagentStatus {
 export interface SubagentNotification {
     readonly id: string;
     readonly label?: string;
-    readonly role?: string;
     readonly state: "completed" | "failed";
     readonly error?: {
         readonly code: string;

package/dist/subagents/src/contracts.js

@@ -22,17 +22,18 @@ export const SUBAGENTS_RUN_PARAMETERS = Type.Object({
     label: Type.Optional(Type.String({ description: "Optional display label for the subagent" })),
     model: Type.Optional(Type.String({ description: "Optional model as provider/model:thinking or alias[:thinking]" })),
     tools: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered tool selectors; candidates start enabled and !* restricts the set" })),
+    excludeTools: Type.Optional(Type.Array(Type.String(), { description: "Optional exact tool names removed after preparation; no patterns, cannot remove workflow_result" })),
     skills: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered skill selectors; candidates start enabled and !* restricts the set" })),
     extensions: Type.Optional(Type.Array(Type.String(), { description: "Optional ordered extension selectors; candidates start enabled and !* restricts the set" })),
     contextFiles: Type.Optional(Type.Array(Type.String(), { description: "Optional context-file scopes: global, project, cwd" })),
-    role: Type.Optional(Type.String({ description: "Workflow role name" })),
     worktree: Type.Optional(Type.String({ description: "Optional named worktree; requires a clean working tree" })),
     outputSchema: Type.Optional(Type.Record(Type.String(), Type.Unknown(), { description: "Optional JSON schema for the result" })),
     retries: Type.Optional(Type.Integer({ minimum: 0, maximum: SUBAGENT_MAX_RETRIES, description: "Optional retry count; at most 255 retries" })),
     timeoutMs: Type.Optional(Type.Union([Type.Integer({ minimum: 1, description: "Optional execution timeout in milliseconds" }), Type.Null()])),
-}, { additionalProperties: false });
+}, { additionalProperties: true });
 export const SUBAGENTS_INSPECT_PARAMETERS = Type.Object({
     id: Type.Optional(Type.String({ description: "Subagent ID; omit to list ordered run summaries" })),
+    scope: Type.Optional(Type.Union([Type.Literal("session"), Type.Literal("all")], { description: "List scope when id is omitted: session (default) lists runs from the current Pi session; all lists every stored run" })),
 }, { additionalProperties: false });
 export const SUBAGENTS_ID_PARAMETERS = Type.Object({
     id: Type.String({ description: "Subagent ID" }),
@@ -47,13 +48,23 @@ export const SUBAGENTS_STOP_PARAMETERS = Type.Object({
 export const SUBAGENTS_RETRY_PARAMETERS = Type.Object({
     id: Type.String({ description: "Failed or stopped subagent ID to retry" }),
 }, { additionalProperties: false });
-export const SUBAGENTS_TOOL_SCHEMAS = {
-    subagents_run: SUBAGENTS_RUN_PARAMETERS,
-    subagents_inspect: SUBAGENTS_INSPECT_PARAMETERS,
-    subagents_steer: SUBAGENTS_STEER_PARAMETERS,
-    subagents_stop: SUBAGENTS_STOP_PARAMETERS,
-    subagents_retry: SUBAGENTS_RETRY_PARAMETERS,
-};
+// Structured results codemode scripts receive instead of the JSON text; nested records stay loose so they cannot drift from persistence.
+export const SUBAGENT_STATUS_OUTPUT = Type.Object({
+    id: Type.String(),
+    state: Type.String(),
+    sessionId: Type.Optional(Type.String()),
+    startedAt: Type.Optional(Type.Number()),
+    finishedAt: Type.Optional(Type.Number()),
+    attempts: Type.Optional(Type.Number()),
+    attemptDetails: Type.Optional(Type.Array(Type.Unknown())),
+    worktree: Type.Optional(Type.Object({ path: Type.String(), branch: Type.String() })),
+    error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String() })),
+    progress: Type.Optional(Type.Unknown()),
+    value: Type.Optional(Type.Unknown()),
+});
+// One run when id is given, otherwise the ordered run summaries; the summaries stay short in the codemode description.
+export const SUBAGENTS_INSPECT_OUTPUT = Type.Union([SUBAGENT_STATUS_OUTPUT, Type.Array(Type.Object({ id: Type.String(), state: Type.String() }))]);
+export const SUBAGENTS_STEER_OUTPUT = Type.Object({ id: Type.String(), accepted: Type.Boolean() });
 export function normalizeSubagentRunRequest(value) {
     if (!Value.Check(SUBAGENTS_RUN_PARAMETERS, value))
         throw new WorkflowError("INVALID_METADATA", "Invalid subagents_run parameters");

package/dist/subagents/src/index.d.ts

@@ -5,7 +5,7 @@ export { attemptValue, statusValue, subagentErrorValue } from "./decode.js";
 export { createSubagentManager, createUnavailableSubagentManager } from "./manager.js";
 export { createRunStoreWorktreeAdapter, defaultWorktreeHome } from "./worktree.js";
 export type { SubagentWorktreeAdapter, SubagentWorktreeContext, SubagentWorktreeHandle, SubagentWorktreeRunStore } from "./worktree.js";
-type SubagentsExtensionAPI = Pick<ExtensionAPI, "registerTool"> & Partial<Pick<ExtensionAPI, "getActiveTools" | "on" | "sendMessage" | "registerCommand" | "appendEntry" | "registerEntryRenderer">>;
+type SubagentsExtensionAPI = Pick<ExtensionAPI, "registerTool"> & Partial<Pick<ExtensionAPI, "events" | "getActiveTools" | "getAllTools" | "on" | "sendMessage" | "registerCommand" | "appendEntry" | "registerEntryRenderer">>;
 export declare function createSubagentTools(manager: SubagentManager): readonly ToolDefinition[];
 export declare function createSubagentsExtension(options?: SubagentsExtensionOptions, activeTools?: () => readonly string[], notify?: (notification: SubagentNotification) => void | Promise<void>, onStatus?: (status: Readonly<SubagentStatus>, request: Readonly<SubagentRunRequest>) => void, onResourceWarning?: (message: string) => void): SubagentsExtension;
 export declare function registerSubagentsExtension(pi: SubagentsExtensionAPI, options?: SubagentsExtensionOptions): SubagentsExtension;

package/dist/subagents/src/index.js

@@ -1,12 +1,12 @@
 import { join } from "node:path";
 import { defineTool, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { Value } from "typebox/value";
-import { WorkflowError, loadingRegistry } from "../../src/index.js";
+import { WorkflowError, loadCodemodeToolsSetting, loadingRegistry, reachableTools, workflowToolExposure } from "../../src/index.js";
 import { clearSubagentManager, setSubagentManager } from "../../src/subagent-manager-handle.js";
 import { createSubagentManager } from "./manager.js";
 import { registerSubagentNavigator } from "./navigator.js";
 import { createSubagentBackgroundWidget, renderSubagentCall, renderSubagentControlCall, renderSubagentControlResult, renderSubagentInspectCall, renderSubagentInspectResult, renderSubagentResult } from "./view.js";
-import { normalizeSubagentRunRequest, SUBAGENTS_ID_PARAMETERS, SUBAGENTS_INSPECT_PARAMETERS, SUBAGENTS_RETRY_PARAMETERS, SUBAGENTS_RUN_PARAMETERS, SUBAGENTS_STEER_PARAMETERS, SUBAGENTS_STOP_PARAMETERS, } from "./contracts.js";
+import { normalizeSubagentRunRequest, SUBAGENT_STATUS_OUTPUT, SUBAGENTS_ID_PARAMETERS, SUBAGENTS_INSPECT_OUTPUT, SUBAGENTS_INSPECT_PARAMETERS, SUBAGENTS_RETRY_PARAMETERS, SUBAGENTS_RUN_PARAMETERS, SUBAGENTS_STEER_OUTPUT, SUBAGENTS_STEER_PARAMETERS, SUBAGENTS_STOP_PARAMETERS, } from "./contracts.js";
 export * from "./contracts.js";
 export { attemptValue, statusValue, subagentErrorValue } from "./decode.js";
 export { createSubagentManager, createUnavailableSubagentManager } from "./manager.js";
@@ -41,7 +41,7 @@ function serialize(value) {
     }
 }
 function toolResult(value) {
-    return { content: [{ type: "text", text: serialize(value) }], details: value };
+    return { content: [{ type: "text", text: serialize(value) }], details: value, structuredContent: value };
 }
 function managerContext(toolCallId, signal, onUpdate, context) {
     return {
@@ -63,6 +63,7 @@ export function createSubagentTools(manager) {
                 "Do not poll a running ID; use subagents_inspect({ id }) when you need its current status or terminal result.",
             ],
             parameters: SUBAGENTS_RUN_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.run(validateSubagentRunRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -72,8 +73,9 @@ export function createSubagentTools(manager) {
         defineTool({
             name: "subagents_inspect",
             label: "Subagents Inspect",
-            description: "Inspect durable subagent runs. Omit id for ordered run summaries, or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
+            description: "Inspect durable subagent runs. Omit id for ordered run summaries of the current session (scope all for every session), or provide id for detailed status, progress, activity, accounting, tool calls, timestamps, worktree metadata, and a terminal value or error when available.",
             parameters: SUBAGENTS_INSPECT_PARAMETERS,
+            outputSchema: SUBAGENTS_INSPECT_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.inspect(validateSubagentInspectRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -85,6 +87,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Steer",
             description: "Send a message to a running subagent. The message is queued safely if its steering handler is not ready; settled runs cannot be steered.",
             parameters: SUBAGENTS_STEER_PARAMETERS,
+            outputSchema: SUBAGENTS_STEER_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.steer(validateSubagentSteerRequest(params), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -96,6 +99,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Stop",
             description: "Stop one running subagent, abort its active session, persist state \"stopped\", and clean its worktree without affecting sibling runs.",
             parameters: SUBAGENTS_STOP_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.stop(validateSubagentIdRequest(params, "subagents_stop"), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -107,6 +111,7 @@ export function createSubagentTools(manager) {
             label: "Subagents Retry",
             description: "Start a fresh run from a failed or stopped subagent's persisted request. The new run gets a new ID and preserves its original background or foreground mode.",
             parameters: SUBAGENTS_RETRY_PARAMETERS,
+            outputSchema: SUBAGENT_STATUS_OUTPUT,
             async execute(toolCallId, params, signal, onUpdate, context) {
                 return toolResult(await manager.retry(validateSubagentIdRequest(params, "subagents_retry"), managerContext(toolCallId, signal, onUpdate, context)));
             },
@@ -117,8 +122,7 @@ export function createSubagentTools(manager) {
 }
 function notificationContent(notification) {
     const label = notification.label?.trim();
-    const role = notification.role?.trim() || "none";
-    const identity = label ? `${label} role=${role} (${notification.id})` : `${notification.id} role=${role}`;
+    const identity = label ? `${label} (${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}" }).`;
@@ -145,7 +149,8 @@ export function createSubagentsExtension(options = {}, activeTools, notify, onSt
 }
 export function registerSubagentsExtension(pi, options = {}) {
     const getActiveTools = pi.getActiveTools;
-    const activeTools = getActiveTools === undefined ? undefined : () => getActiveTools.call(pi);
+    const getAllTools = pi.getAllTools;
+    const activeTools = getActiveTools === undefined ? undefined : () => reachableTools({ getActiveTools: () => getActiveTools.call(pi), ...(getAllTools === undefined ? {} : { getAllTools: () => getAllTools.call(pi) }) });
     const sendMessage = pi.sendMessage;
     const notify = sendMessage === undefined ? undefined : (notification) => {
         sendMessage.call(pi, { customType: "subagents", content: notificationContent(notification), display: true, details: notification }, { deliverAs: "steer", triggerTurn: true });
@@ -157,8 +162,9 @@ export function registerSubagentsExtension(pi, options = {}) {
     const widget = createSubagentBackgroundWidget({ ...(appendEntry === undefined ? {} : { appendEntry: (customType, data) => { appendEntry.call(pi, customType, data); } }), ...(pi.registerEntryRenderer === undefined ? {} : { registerEntryRenderer: pi.registerEntryRenderer.bind(pi) }) });
     const extension = createSubagentsExtension(options, activeTools, notify, (status, request) => { widget.update(status, request); const registry = loadingRegistry(); if (typeof registry.observeSubagentStatus === "function")
         registry.observeSubagentStatus(status, request); }, onResourceWarning);
+    const codemodeTools = loadCodemodeToolsSetting(options.managerDependencies?.agentDir);
     for (const tool of extension.tools)
-        pi.registerTool(tool);
+        pi.registerTool({ ...tool, ...workflowToolExposure(tool.name, codemodeTools) });
     if (pi.registerCommand !== undefined)
         registerSubagentNavigator(pi.registerCommand.bind(pi), extension.manager, storageDirectory(options), options.clipboard);
     if (pi.on !== undefined) {

package/dist/subagents/src/manager.js

@@ -2,12 +2,11 @@ import { randomUUID } from "node:crypto";
 import { chmod, link, mkdir, open, readFile, readdir, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { addAccounting, deepFreeze, errorCode, errorText, finiteNumber, isNodeError, isThinkingLevel, jsonValue, object, loadingRegistry, localAgentTransport, resolveAgentResourcePolicy, resolveWorkflowSettings, roleNameOf, sanitizeDisplayText, sumAccounting, structuralPath, validateModelAliasAvailability, WorkflowAgentExecutor, WorkflowError, workflowProjectSettingsPath, workflowSettingsPath, SerialLane, } from "../../src/index.js";
-import { decodeAgentDefinition, decodeWorkflowExtensions } from "../../src/decoders.js";
-import { loadAgentDefinitions } from "../../src/roles.js";
+import { addAccounting, errorCode, errorText, finiteNumber, isNodeError, isThinkingLevel, jsonValue, object, loadingRegistry, localAgentTransport, resolveAgentResourcePolicy, resolveWorkflowSettings, sanitizeDisplayText, sumAccounting, structuralPath, validateModelAliasAvailability, WorkflowAgentExecutor, WorkflowError, workflowSettingsPath, SerialLane } from "../../src/index.js";
+import { decodePreparedAgentConfiguration } from "../../src/decoders.js";
 import { atomicJson, json as readJson, processAlive } from "../../src/persistence.js";
 import { accountingValue, activityValue, legacyAccountingValue, worktreeValue } from "./decode.js";
-import { SUBAGENT_ATTEMPT_DETAILS_LIMIT, SUBAGENT_MAX_RETRIES, SUBAGENT_SYSTEM_PROMPT_LIMIT, SUBAGENTS_TOOL_NAMES, normalizeSubagentRunRequest, } from "./contracts.js";
+import { SUBAGENT_ATTEMPT_DETAILS_LIMIT, SUBAGENT_MAX_RETRIES, SUBAGENT_SYSTEM_PROMPT_LIMIT, SUBAGENTS_TOOL_NAMES, normalizeSubagentRunRequest } from "./contracts.js";
 import { createRunStoreWorktreeAdapter, defaultWorktreeHome } from "./worktree.js";
 const WORKFLOW_NAME = "subagents";
 const STORAGE_DIRECTORY = "subagents";
@@ -44,25 +43,11 @@ function rootModel(context) {
     const thinking = context.extensionContext.thinkingLevel;
     return { provider: model.provider, model: model.id, ...(thinking === undefined ? {} : { thinking }) };
 }
-function standaloneExtensionSettingsPath(cwd, agentDir, trustedProject, external) {
-    return trustedProject && external.projectExtensionSettings !== undefined ? 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 !== undefined)
-        registry.validateExtensionSettings(external.globalExtensionSettings, { source: "global", cwd, projectTrusted: trustedProject, settingsPath: globalSettingsPath });
-    if (trustedProject && external.projectExtensionSettings !== undefined)
-        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 ?? getAgentDir();
     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);
@@ -85,11 +70,15 @@ function executionRoot(context, dependencies, signal, runId, worktree, external)
         signal,
     };
     const registry = loadingRegistry();
-    validateStandaloneExtensionSources(context, external, registry, agentDir);
-    const extensionSettings = trustedProject && external.projectExtensionSettings !== undefined ? external.projectExtensionSettings : external.globalExtensionSettings;
-    const extensionSettingsPath = standaloneExtensionSettingsPath(extensionContext.cwd, agentDir, trustedProject, external);
+    if (settings.global.extensionSettings !== undefined)
+        registry.validateExtensionSettings(settings.global.extensionSettings, { source: "global", cwd: extensionContext.cwd, projectTrusted: trustedProject, settingsPath: settings.globalSettingsPath });
+    if (trustedProject && settings.project.extensionSettings !== undefined)
+        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,
@@ -99,9 +88,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),
@@ -118,11 +108,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 ?? new Set(), availableModels: root.availableModels ?? new Set(), signal }, new Set(Object.keys(staticAliases)));
     validateModelAliasAvailability(dynamicAliases, Object.keys(dynamicAliases), root.availableModels ?? new Set(), root.knownModels ?? 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 label = request.label ?? roleNameOf(role) ?? "subagent";
+    const label = request.label ?? "subagent";
     return {
         label,
         workflowName: WORKFLOW_NAME,
@@ -131,11 +120,11 @@ function executionOptions(request, onAttempt, onProgress) {
         ...(request.skills === undefined ? {} : { skills: request.skills }),
         ...(request.extensions === undefined ? {} : { extensions: request.extensions }),
         ...(request.contextFiles === undefined ? {} : { contextFiles: request.contextFiles }),
-        ...(role === undefined ? {} : { role }),
         ...(request.worktree === undefined ? {} : { worktreeOwner: structuralPath("worktree", "named", request.worktree) }),
         ...(request.outputSchema === undefined ? {} : { schema: request.outputSchema }),
         ...(request.retries === undefined ? {} : { retries: request.retries }),
         ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
+        agentOptions: Object.fromEntries(Object.entries(request).filter(([key]) => !["prompt", "mode", "worktree"].includes(key))),
         onAttempt,
         onProgress,
     };
@@ -326,36 +315,9 @@ function checkedRequest(request) {
     return normalizeSubagentRunRequest(request);
 }
 function decodePersistedStandaloneExternalConfiguration(value) {
-    if (!object(value) || !jsonValue(value) || typeof value.projectTrusted !== "boolean")
-        return undefined;
-    const globalExtensionSettings = value.globalExtensionSettings === undefined ? undefined : decodeWorkflowExtensions(value.globalExtensionSettings);
-    const projectExtensionSettings = value.projectExtensionSettings === undefined ? undefined : decodeWorkflowExtensions(value.projectExtensionSettings);
-    if (value.globalExtensionSettings !== undefined && globalExtensionSettings === undefined || value.projectExtensionSettings !== undefined && projectExtensionSettings === undefined)
-        return undefined;
-    if (!object(value.agentDefinitions))
+    if (!object(value) || value.version !== 1)
         return undefined;
-    const agentDefinitions = Object.create(null);
-    for (const [name, definition] of Object.entries(value.agentDefinitions)) {
-        const decoded = decodeAgentDefinition(definition);
-        if (decoded === undefined)
-            return undefined;
-        agentDefinitions[name] = decoded;
-    }
-    return deepFreeze({ projectTrusted: value.projectTrusted, ...(globalExtensionSettings === undefined ? {} : { globalExtensionSettings }), ...(projectExtensionSettings === undefined ? {} : { projectExtensionSettings }), agentDefinitions });
-}
-function standaloneExternalConfiguration(context, dependencies) {
-    const cwd = context.extensionContext.cwd;
-    const trustedProject = context.extensionContext.isProjectTrusted();
-    const agentDir = dependencies.agentDir ?? getAgentDir();
-    const resolution = resolveWorkflowSettings(cwd, trustedProject, workflowSettingsPath(agentDir));
-    const globalExtensionSettings = resolution.global.extensionSettings;
-    const projectExtensionSettings = resolution.project.extensionSettings;
-    return deepFreeze({
-        projectTrusted: trustedProject,
-        ...(globalExtensionSettings === undefined ? {} : { globalExtensionSettings: structuredClone(globalExtensionSettings) }),
-        ...(projectExtensionSettings === undefined ? {} : { projectExtensionSettings: structuredClone(projectExtensionSettings) }),
-        agentDefinitions: structuredClone(loadAgentDefinitions(cwd, agentDir, trustedProject)),
-    });
+    return decodePreparedAgentConfiguration(value.configuration);
 }
 function checkedId(request) {
     if (typeof request.id !== "string" || !validSubagentId(request.id))
@@ -715,7 +677,8 @@ async function createRunStorage(root, id, request, status, external) {
         created = true;
         await chmod(directory, 0o700);
         await atomicJson(requestPath(directory), request);
-        await atomicJson(configurationPath(directory), external);
+        if (external !== undefined)
+            await atomicJson(configurationPath(directory), { version: 1, configuration: external });
         await atomicJson(statusPath(directory), status);
         return directory;
     }
@@ -935,6 +898,7 @@ function unavailable(operation) {
 class PersistentSubagentManager {
     dependencies;
     activeRuns = new Map();
+    pendingStarts = new Set();
     activeRunCount = 0;
     terminalSummaries = new Map();
     reconciliationErrors = new Map();
@@ -991,8 +955,8 @@ class PersistentSubagentManager {
             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())
+        const external = frozenExternal;
+        if (external?.projectTrusted && !context.extensionContext.isProjectTrusted())
             throw new WorkflowError("RESUME_INCOMPATIBLE", "Cannot retry standalone configuration from an untrusted project");
         const id = randomUUID();
         const startedAt = Date.now();
@@ -1009,9 +973,16 @@ class PersistentSubagentManager {
         this.activeRunCount += 1;
         const controller = new AbortController();
         const initialStatus = { id, sessionId, state: "running", startedAt, owner: { ...owner } };
+        let finishStart;
+        const pendingStart = new Promise((resolve) => { finishStart = resolve; });
+        this.pendingStarts.add(pendingStart);
         let directory;
         try {
             directory = await createRunStorage(storageDirectory(this.dependencies), id, snapshot, initialStatus, external);
+            if (this.disposePromise !== undefined || context.signal?.aborted) {
+                await atomicJson(statusPath(directory), reconciledStatus(initialStatus, "stopped", Date.now()));
+                throw new WorkflowError("CANCELLED", "Subagent cancelled");
+            }
         }
         catch (error) {
             this.activeRunCount -= 1;
@@ -1019,6 +990,10 @@ class PersistentSubagentManager {
                 throw error;
             throw internalStorageError(error, `Unable to start subagent ${id}`);
         }
+        finally {
+            this.pendingStarts.delete(pendingStart);
+            finishStart();
+        }
         const current = {};
         let resolveTerminal;
         const terminal = new Promise((resolve) => { resolveTerminal = resolve; });
@@ -1049,13 +1024,9 @@ class PersistentSubagentManager {
                     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 !== undefined || 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 === undefined;
-            if (current.run)
-                current.run.executorOwnsSession = executorOwnership.default;
             const setSteer = (handler) => {
                 const run = current.run;
                 if (run)
@@ -1106,6 +1077,15 @@ class PersistentSubagentManager {
                     return;
                 emitUpdate(run);
             }, (progress) => this.recordProgress(current.run, progress));
+            if (external !== undefined)
+                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 === undefined;
+            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);
@@ -1156,9 +1136,9 @@ class PersistentSubagentManager {
             }
             return inspection;
         }
-        return this.inspectList();
+        return this.inspectList(request.scope === "all" ? undefined : context.extensionContext.sessionManager.getSessionId());
     }
-    async inspectList() {
+    async inspectList(sessionId) {
         const root = storageDirectory(this.dependencies);
         await secureDirectory(root);
         const entries = await readdir(root, { withFileTypes: true });
@@ -1172,7 +1152,7 @@ class PersistentSubagentManager {
             try {
                 const active = this.activeRuns.get(entry.name);
                 const status = publicStatus(active ? persistedStatus(active) : this.terminalSummaries.get(entry.name) ?? await loadPersistedStatus(root, entry.name, false));
-                if (status.startedAt === undefined)
+                if (status.startedAt === undefined || (sessionId !== undefined && status.sessionId !== sessionId))
                     continue;
                 statuses.push({ status, startedAt: status.startedAt });
             }
@@ -1228,11 +1208,11 @@ class PersistentSubagentManager {
     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 = undefined;
@@ -1610,9 +1590,8 @@ class PersistentSubagentManager {
         if (!notify || run.notificationSent || run.disposed)
             return;
         run.notificationSent = true;
-        const role = roleNameOf(run.request.role) ?? "none";
-        const label = run.request.label?.trim() || (role === "none" ? "subagent" : role);
-        const notification = { id: run.id, label, role, state: run.state, ...(run.error === undefined ? {} : { error: run.error }) };
+        const label = run.request.label?.trim() || "subagent";
+        const notification = { id: run.id, label, state: run.state, ...(run.error === undefined ? {} : { error: run.error }) };
         const pending = Promise.resolve().then(() => notify(notification));
         this.notificationPromises.add(pending);
         void pending.then(() => { this.notificationPromises.delete(pending); }, () => { this.notificationPromises.delete(pending); });

package/dist/subagents/src/navigator.js

@@ -60,17 +60,9 @@ async function inspectEntry(manager, storageDirectory, entry, context) {
         entry: { status: inspected.status, ...(request.request === undefined ? {} : { request: request.request }), ...(request.error === undefined ? {} : { requestError: request.error }) },
     };
 }
-function requestRole(request) {
-    const role = request?.role;
-    if (typeof role === "string" && role.trim())
-        return role.trim();
-    const override = objectValue(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);
 }
 /** Names for a list of runs; a repeated name carries its short ID, as in the `/workflow` picker, so every row stays unique. */
 function listNames(entries) {
@@ -108,7 +100,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;
@@ -117,14 +109,12 @@ function detailPresentation(inspection) {
     const lastEventAt = status.progress?.lastEventAt;
     const attempts = status.attempts ?? attempt?.attempt;
     const accounting = usageAccounting(status);
-    const role = requestRole(request);
     const error = status.error ?? attempt?.error;
     return {
         state: status.state,
         ...(activity === undefined ? {} : { activity: { kind: activity.kind, text: boundedText(activity.text) } }),
         ...(lastEventAt === undefined ? {} : { lastEventAt }),
         ...(model === undefined ? {} : { model: { provider: boundedText(model.provider, 256), model: boundedText(model.model, 256), ...(model.thinking === undefined ? {} : { thinking: model.thinking }) } }),
-        ...(role === "none" ? {} : { role: boundedText(role, 256) }),
         ...(tools === undefined ? {} : { tools: tools.slice(0, 256).map((tool) => boundedText(tool, 256)) }),
         ...(attempts === undefined ? {} : { attempts }),
         ...(status.startedAt === undefined ? {} : { startedAt: status.startedAt }),
@@ -178,8 +168,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 : undefined;
     const label = request?.label?.trim();
-    const role = requestRole(request);
-    const name = label || (role === "none" ? "subagent" : role);
+    const name = label || "subagent";
     const ui = {
         notify: (message, level = "info") => { context.ui.notify(message, level); },
         confirm: (title, message) => context.ui.confirm(title, message),

package/dist/subagents/src/view.d.ts

@@ -42,7 +42,6 @@ type SubagentReceipt = {
     readonly label: string;
     readonly state: string;
     readonly model?: string;
-    readonly role?: string;
     readonly tools?: readonly string[];
     readonly input: number;
     readonly output: number;
@@ -65,6 +64,7 @@ export declare function createSubagentBackgroundWidget(host?: ReceiptHost): {
 };
 export declare function renderSubagentInspectCall(args: {
     id?: string;
+    scope?: string;
 }, theme: Theme): {
     render(width: number): string[];
     invalidate(): void;