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

package/subagents/src/index.ts

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { defineTool, getAgentDir, type AgentToolResult, type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Value } from "typebox/value";
-import { WorkflowError, loadingRegistry } from "../../src/index.js";
+import { WorkflowError, loadCodemodeToolsSetting, loadingRegistry, reachableTools, workflowToolExposure, type JsonValue } from "../../src/index.js";
 import { clearSubagentManager, setSubagentManager } from "../../src/subagent-manager-handle.js";
 import type { SubagentIdRequest, SubagentInspectRequest, SubagentManager, SubagentManagerContext, SubagentNotification, SubagentsExtension, SubagentsExtensionOptions, SubagentRunRequest, SubagentStatus, SubagentSteerRequest } from "./contracts.js";
 import { createSubagentManager } from "./manager.js";
@@ -9,10 +9,13 @@ import { registerSubagentNavigator } from "./navigator.js";
 import { createSubagentBackgroundWidget, renderSubagentCall, renderSubagentControlCall, renderSubagentControlResult, renderSubagentInspectCall, renderSubagentInspectResult, renderSubagentResult } from "./view.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";
@@ -23,7 +26,7 @@ export { createSubagentManager, createUnavailableSubagentManager } from "./manag
 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">>;
 
 function validateSubagentRunRequest(value: unknown): SubagentRunRequest {
   return normalizeSubagentRunRequest(value);
@@ -55,7 +58,7 @@ function serialize(value: unknown): string {
 }
 
 function toolResult(value: unknown): AgentToolResult<unknown> {
-  return { content: [{ type: "text", text: serialize(value) }], details: value };
+  return { content: [{ type: "text", text: serialize(value) }], details: value, structuredContent: value as JsonValue };
 }
 
 function managerContext(toolCallId: string, signal: AbortSignal | undefined, onUpdate: ((value: AgentToolResult<unknown>) => void) | undefined, context: ExtensionContext): SubagentManagerContext {
@@ -78,6 +81,7 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
         "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)));
       },
@@ -87,8 +91,9 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
     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)));
       },
@@ -100,6 +105,7 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
       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)));
       },
@@ -111,6 +117,7 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
       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)));
       },
@@ -122,6 +129,7 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
       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)));
       },
@@ -133,8 +141,7 @@ export function createSubagentTools(manager: SubagentManager): readonly ToolDefi
 
 function notificationContent(notification: SubagentNotification): string {
   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}" }).`;
 }
@@ -162,7 +169,8 @@ export function createSubagentsExtension(options: SubagentsExtensionOptions = {}
 
 export function registerSubagentsExtension(pi: SubagentsExtensionAPI, options: SubagentsExtensionOptions = {}): SubagentsExtension {
   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: SubagentNotification): void => {
     sendMessage.call(pi, { customType: "subagents", content: notificationContent(notification), display: true, details: notification }, { deliverAs: "steer", triggerTurn: true });
@@ -173,7 +181,8 @@ export function registerSubagentsExtension(pi: SubagentsExtensionAPI, options: S
   const appendEntry = pi.appendEntry;
   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);
-  for (const tool of extension.tools) pi.registerTool(tool);
+  const codemodeTools = loadCodemodeToolsSetting(options.managerDependencies?.agentDir);
+  for (const tool of extension.tools) 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) {
     setSubagentManager(extension.manager);

package/subagents/src/manager.ts

@@ -2,67 +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,
-  type AgentAccounting,
-  type AgentAttempt,
-  type AgentAttemptSummary,
-  type AgentDefinition,
-  type AgentExecutionOptions,
-  type AgentExecutionRoot,
-  type AgentProgress,
-  type AgentToolCallProgress,
-  type JsonSchema,
-  type JsonValue,
-  type ModelSpec,
-  type WorkflowAgentSessionState,
-  type WorkflowExtensionSettings,
-  type WorkflowRunContext,
-  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, type AgentAccounting, type AgentAttempt, type AgentAttemptSummary, type PreparedAgentConfiguration, type AgentExecutionOptions, type AgentExecutionRoot, type AgentProgress, type AgentToolCallProgress, type JsonSchema, type JsonValue, type ModelSpec, type WorkflowAgentSessionState, type WorkflowRunContext, 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,
-  type SubagentInspectRequest,
-  type SubagentLiveness,
-  type SubagentAttemptActionData,
-  type SubagentManager,
-  type SubagentManagerContext,
-  type SubagentManagerDependencies,
-  type SubagentNotification,
-  type SubagentOwnerMarker,
-  type SubagentProgress,
-  type SubagentRunRequest,
-  type SubagentStatus,
-} from "./contracts.js";
+import { SUBAGENT_ATTEMPT_DETAILS_LIMIT, SUBAGENT_MAX_RETRIES, SUBAGENT_SYSTEM_PROMPT_LIMIT, SUBAGENTS_TOOL_NAMES, normalizeSubagentRunRequest, type SubagentInspectRequest, type SubagentLiveness, type SubagentAttemptActionData, type SubagentManager, type SubagentManagerContext, type SubagentManagerDependencies, type SubagentNotification, type SubagentOwnerMarker, type SubagentProgress, type SubagentRunRequest, type SubagentStatus } from "./contracts.js";
 import { createRunStoreWorktreeAdapter, defaultWorktreeHome, type SubagentWorktreeContext, type SubagentWorktreeHandle } from "./worktree.js";
 
 const WORKFLOW_NAME = "subagents";
@@ -77,12 +21,7 @@ const MAX_PERSISTED_ATTEMPT_ARRAY_ITEMS = SUBAGENT_MAX_RETRIES + 1;
 const MAX_PERSISTED_ATTEMPT_STRING_CHARS = 4096;
 const MAX_PERSISTED_ATTEMPT_LOCATOR_CHARS = 16 * 1024;
 const SUBAGENT_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-type StandaloneExternalConfiguration = Readonly<{
-  projectTrusted: boolean;
-  globalExtensionSettings?: Readonly<WorkflowExtensionSettings>;
-  projectExtensionSettings?: Readonly<WorkflowExtensionSettings>;
-  agentDefinitions: Readonly<Record<string, AgentDefinition>>;
-}>;
+type StandaloneExternalConfiguration = Readonly<PreparedAgentConfiguration>;
 class InvalidPersistedSubagentStatusError extends WorkflowError {
   constructor() { super("INTERNAL_ERROR", "Persisted subagent status is invalid"); }
 }
@@ -169,22 +108,11 @@ function rootModel(context: Readonly<SubagentManagerContext>): ModelSpec {
   const thinking = context.extensionContext.thinkingLevel;
   return { provider: model.provider, model: model.id, ...(thinking === undefined ? {} : { thinking }) };
 }
-function standaloneExtensionSettingsPath(cwd: string, agentDir: string, trustedProject: boolean, external: StandaloneExternalConfiguration): string {
-  return trustedProject && external.projectExtensionSettings !== undefined ? workflowProjectSettingsPath(cwd) : workflowSettingsPath(agentDir);
-}
-function validateStandaloneExtensionSources(context: Readonly<SubagentManagerContext>, external: StandaloneExternalConfiguration, registry: ReturnType<typeof loadingRegistry>, agentDir: string): void {
-  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: Readonly<SubagentManagerContext>, dependencies: Readonly<SubagentManagerDependencies>, signal: AbortSignal, runId: string, worktree: SubagentWorktreeHandle | undefined, external: StandaloneExternalConfiguration): AgentExecutionRoot {
+function executionRoot(context: Readonly<SubagentManagerContext>, dependencies: Readonly<SubagentManagerDependencies>, signal: AbortSignal, runId: string, worktree: SubagentWorktreeHandle | undefined): AgentExecutionRoot {
   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);
@@ -207,11 +135,13 @@ function executionRoot(context: Readonly<SubagentManagerContext>, dependencies:
     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,
@@ -221,9 +151,10 @@ function executionRoot(context: Readonly<SubagentManagerContext>, dependencies:
     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),
@@ -240,12 +171,11 @@ async function addDynamicAliases(context: Readonly<SubagentManagerContext>, sign
   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: Readonly<SubagentRunRequest>, onAttempt: NonNullable<AgentExecutionOptions["onAttempt"]>, onProgress: NonNullable<AgentExecutionOptions["onProgress"]>): AgentExecutionOptions {
-  const role = request.role;
-  const label = request.label ?? roleNameOf(role) ?? "subagent";
+  const label = request.label ?? "subagent";
   return {
     label,
     workflowName: WORKFLOW_NAME,
@@ -254,11 +184,11 @@ function executionOptions(request: Readonly<SubagentRunRequest>, onAttempt: NonN
     ...(request.skills === undefined ? {} : { skills: request.skills }),
     ...(request.extensions === undefined ? {} : { extensions: request.extensions }),
     ...(request.contextFiles === undefined ? {} : { contextFiles: request.contextFiles as NonNullable<AgentExecutionOptions["contextFiles"]> }),
-    ...(role === undefined ? {} : { role }),
     ...(request.worktree === undefined ? {} : { worktreeOwner: structuralPath("worktree", "named", request.worktree) }),
     ...(request.outputSchema === undefined ? {} : { schema: request.outputSchema as JsonSchema }),
     ...(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))) as Record<string, JsonValue>,
     onAttempt,
     onProgress,
   };
@@ -398,32 +328,8 @@ function checkedRequest(request: unknown): SubagentRunRequest {
   return normalizeSubagentRunRequest(request);
 }
 function decodePersistedStandaloneExternalConfiguration(value: unknown): StandaloneExternalConfiguration | undefined {
-  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)) return undefined;
-  const agentDefinitions = Object.create(null) as Record<string, AgentDefinition>;
-  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: Readonly<SubagentManagerContext>, dependencies: Readonly<SubagentManagerDependencies>): StandaloneExternalConfiguration {
-  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)),
-  });
+  if (!object(value) || value.version !== 1) return undefined;
+  return decodePreparedAgentConfiguration(value.configuration);
 }
 
 function checkedId(request: Readonly<{ id: string }>): string {
@@ -719,7 +625,7 @@ function emitUpdate(run: LiveRun): void {
   try { run.observe?.(publicStatus(live, true, true)); } catch { /* A widget failure is display-only. */ }
 }
 
-async function createRunStorage(root: string, id: string, request: Readonly<SubagentRunRequest>, status: PersistedSubagentStatus, external: StandaloneExternalConfiguration): Promise<string> {
+async function createRunStorage(root: string, id: string, request: Readonly<SubagentRunRequest>, status: PersistedSubagentStatus, external: StandaloneExternalConfiguration | undefined): Promise<string> {
   await secureDirectory(root);
   const directory = runDirectory(root, id);
   let created = false;
@@ -728,7 +634,7 @@ async function createRunStorage(root: string, id: string, request: Readonly<Suba
     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;
   } catch (error) {
@@ -918,6 +824,7 @@ function unavailable(operation: string): { ok: false; error: { code: "SUBAGENTS_
 
 class PersistentSubagentManager implements SubagentManager {
   private readonly activeRuns = new Map<string, LiveRun>();
+  private readonly pendingStarts = new Set<Promise<void>>();
   private activeRunCount = 0;
   private readonly terminalSummaries = new Map<string, TerminalSummary>();
   private readonly reconciliationErrors = new Map<string, WorkflowError>();
@@ -968,8 +875,8 @@ class PersistentSubagentManager implements SubagentManager {
     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 = randomUUID();
     const startedAt = Date.now();
     const sessionId = context.extensionContext.sessionManager.getSessionId();
@@ -982,13 +889,23 @@ class PersistentSubagentManager implements SubagentManager {
     this.activeRunCount += 1;
     const controller = new AbortController();
     const initialStatus: PersistedSubagentStatus = { id, sessionId, state: "running", startedAt, owner: { ...owner } };
+    let finishStart!: () => void;
+    const pendingStart = new Promise<void>((resolve) => { finishStart = resolve; });
+    this.pendingStarts.add(pendingStart);
     let directory: string;
     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;
       if (error instanceof WorkflowError) throw error;
       throw internalStorageError(error, `Unable to start subagent ${id}`);
+    } finally {
+      this.pendingStarts.delete(pendingStart);
+      finishStart();
     }
     const current: { run?: LiveRun } = {};
     let resolveTerminal!: (result: ForegroundResult) => void;
@@ -1019,12 +936,9 @@ class PersistentSubagentManager implements SubagentManager {
           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: SteerHandler): void => {
         const run = current.run;
         if (run) this.registerSteerHandler(run, handler);
@@ -1066,6 +980,13 @@ class PersistentSubagentManager implements SubagentManager {
         if (run.state !== "running") 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);
     });
@@ -1113,9 +1034,9 @@ class PersistentSubagentManager implements SubagentManager {
       }
       return inspection;
     }
-    return this.inspectList();
+    return this.inspectList(request.scope === "all" ? undefined : context.extensionContext.sessionManager.getSessionId());
   }
-  private async inspectList(): Promise<unknown> {
+  private async inspectList(sessionId: string | undefined): Promise<unknown> {
     const root = storageDirectory(this.dependencies);
     await secureDirectory(root);
     const entries = await readdir(root, { withFileTypes: true });
@@ -1127,7 +1048,7 @@ class PersistentSubagentManager implements SubagentManager {
       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) continue;
+        if (status.startedAt === undefined || (sessionId !== undefined && status.sessionId !== sessionId)) continue;
         statuses.push({ status, startedAt: status.startedAt });
       } catch (error) {
         if (error instanceof WorkflowError && (error.code === "RUN_NOT_FOUND" || error instanceof InvalidPersistedSubagentStatusError)) continue;
@@ -1176,11 +1097,11 @@ class PersistentSubagentManager implements SubagentManager {
 
   async dispose(): Promise<void> {
     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;
@@ -1533,9 +1454,8 @@ class PersistentSubagentManager implements SubagentManager {
     const notify = this.dependencies.notify;
     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: SubagentNotification = { id: run.id, label, role, state: run.state as "completed" | "failed", ...(run.error === undefined ? {} : { error: run.error }) };
+    const label = run.request.label?.trim() || "subagent";
+    const notification: SubagentNotification = { id: run.id, label, state: run.state as "completed" | "failed", ...(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/subagents/src/navigator.ts

@@ -71,16 +71,10 @@ async function inspectEntry(manager: SubagentManager, storageDirectory: string,
   };
 }
 
-function requestRole(request: SubagentRunRequest | undefined): string {
-  const role: unknown = 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: string): string { return id.length > 12 ? id.slice(0, 8) : id; }
 function entryName(entry: NavigatorEntry): string {
-  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: readonly NavigatorEntry[]): string[] {
@@ -113,7 +107,7 @@ function usageAccounting(status: SubagentStatus): SubagentProgress["accounting"]
   return status.progress?.accounting;
 }
 function detailPresentation(inspection: Inspection): AgentDetailPresentation {
-  const { status, request } = inspection.entry;
+  const { status } = inspection.entry;
   const attempt = latestAttempt(status);
   const state = status.progress?.state;
   const activity = status.progress?.activity;
@@ -122,14 +116,12 @@ function detailPresentation(inspection: Inspection): AgentDetailPresentation {
   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 }),
@@ -186,8 +178,7 @@ function standaloneActionContext(manager: SubagentManager, inspection: Inspectio
   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: string, level: "info" | "warning" | "error" = "info") => { context.ui.notify(message, level); },
     confirm: (title: string, message: string) => context.ui.confirm(title, message),