@narumitw/pi-subagents 2.0.1 → 2.0.3

package/dist/chunks/config-ui-3IBMHTQB.ts

@@ -0,0 +1,1146 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import "./chunk-SCZ33MYW.ts";
+import {
+  formatStatefulAgentLine
+} from "./chunk-F5YWVHQX.ts";
+import "./chunk-P7OH4XMF.ts";
+import "./chunk-N7BLVXKK.ts";
+import "./chunk-ONDTY4EL.ts";
+import "./chunk-O4VO6JUJ.ts";
+import {
+  discoverAgents
+} from "./chunk-PSK43Y6A.ts";
+import "./chunk-RSUXZD6S.ts";
+import {
+  applyStatefulLimitSetting,
+  completionLabel,
+  consultResourceLabel,
+  consultationCwdLabel,
+  currentWorkflow,
+  delegationCwdLabel,
+  formatDetachedLimitSummary,
+  formatEmptyStatefulRuntime,
+  formatManagerSummary,
+  helpLines,
+  showSubagentHelp,
+  showSubagentStatus,
+  showWorkflowPreview,
+  statefulLimitInputScreen,
+  statefulLimitListScreen,
+  statusLines,
+  workflowLabel
+} from "./chunk-EFBPISNT.ts";
+import "./chunk-KMGKCEO4.ts";
+import {
+  sameToolSet,
+  uniqueToolNames,
+  updateAgentSettingsPatch,
+  updateAgentToolsSetting,
+  updateBlockingMaxParallelTasksSetting,
+  updateCompletionDeliverySetting,
+  updateConsultResourceSetting,
+  updateCwdPolicySetting,
+  updateDelegationWorkflowSetting,
+  updateStatefulTransportSetting
+} from "./chunk-7QPPBBXZ.ts";
+import {
+  hasOwn,
+  inspectBlockingParallelLimitSettings,
+  inspectCompletionDeliverySettings,
+  inspectConsultResourceSettings,
+  inspectCwdPolicySettings,
+  inspectDelegationWorkflowSettings,
+  inspectStatefulTransportSettings,
+  readSubagentSettings
+} from "./chunk-QBORTI4W.ts";
+import {
+  isStatefulLimitField
+} from "./chunk-7OBINKFM.ts";
+import "./chunk-DPPVEQAM.ts";
+import "./chunk-434NII74.ts";
+import "./chunk-C4L6P266.ts";
+import "./chunk-QDVGH2X7.ts";
+import "./chunk-BFK2Z4ZF.ts";
+import {
+  safeTerminalLine
+} from "./chunk-SWGQLFSD.ts";
+import "./chunk-I2FAK44T.ts";
+import {
+  MAX_BLOCKING_PARALLEL_CONCURRENCY,
+  MAX_CONFIGURABLE_PARALLEL_TASKS,
+  MAX_SUBAGENT_TIMEOUT_MS
+} from "./chunk-H3FP6DLR.ts";
+import "./chunk-RRR66UWR.ts";
+import "./chunk-S2IWVK3J.ts";
+
+// src/execution-ui.ts
+function executionAgentPickerScreen(agents) {
+  const configured = readSubagentSettings()?.agents ?? {};
+  return {
+    kind: "actions",
+    title: "Agent Execution Defaults",
+    lines: ["Choose an agent to edit its inherited model, thinking, or timeout."],
+    items: [
+      ...agents.map((agent) => {
+        const value = configured[agent.name];
+        return {
+          id: agent.name,
+          label: safeTerminalLine(agent.name),
+          description: safeTerminalLine(
+            `${agent.source} \xB7 model ${value?.model ?? agent.model ?? "inherited"} \xB7 thinking ${value?.thinkingLevel ?? agent.thinkingLevel ?? "inherited"} \xB7 timeout ${value?.timeoutMs ?? agent.timeoutMs ?? "inherited"}`
+          ),
+          action: "pick-execution-agent"
+        };
+      }),
+      { id: "back", label: "Back", action: "back" }
+    ],
+    hint: "back"
+  };
+}
+function executionAgentScreen(agent) {
+  if (!agent) {
+    return {
+      kind: "actions",
+      title: "Agent Execution Defaults",
+      lines: ["No agent selected."],
+      items: [{ id: "back", label: "Back", action: "back" }],
+      hint: "back"
+    };
+  }
+  const configured = readSubagentSettings()?.agents?.[agent.name];
+  return {
+    kind: "actions",
+    title: `${safeTerminalLine(agent.name)} execution`,
+    lines: [
+      `Model: ${safeTerminalLine(configured?.model ?? agent.model ?? "inherited")}`,
+      `Thinking: ${configured?.thinkingLevel ?? agent.thinkingLevel ?? "inherited"}`,
+      `Timeout: ${configured?.timeoutMs ?? agent.timeoutMs ?? "inherited"}`,
+      "Explicit tool-call values remain authoritative."
+    ],
+    items: [
+      { id: "thinking", label: "Thinking level", to: "execution-thinking" },
+      { id: "model", label: "Model", to: "execution-model" },
+      { id: "timeout", label: "Timeout", to: "execution-timeout" },
+      {
+        id: "reset",
+        label: "Reset execution defaults",
+        description: "Restore frontmatter or Pi inheritance without changing tools",
+        action: "reset-agent-execution"
+      },
+      { id: "back", label: "Back", action: "back" }
+    ],
+    hint: "back"
+  };
+}
+function executionThinkingScreen(agent) {
+  const configured = agent ? readSubagentSettings()?.agents?.[agent.name] : void 0;
+  return {
+    kind: "settings",
+    title: agent ? `${safeTerminalLine(agent.name)} thinking` : "Agent thinking",
+    items: agent ? [
+      {
+        id: "thinking",
+        label: "Default thinking level",
+        description: "Explicit spawn or blocking call values still win.",
+        currentValue: configured?.thinkingLevel ?? agent.thinkingLevel ?? "Inherited",
+        values: ["Inherited", "off", "minimal", "low", "medium", "high", "xhigh", "max"],
+        action: "set-agent-thinking"
+      }
+    ] : [],
+    hint: "back"
+  };
+}
+function executionModelScreen(agent, ctx) {
+  const configured = agent ? readSubagentSettings()?.agents?.[agent.name] : void 0;
+  const models = ctx.modelRegistry.getAvailable().map((model) => `${model.provider}/${model.id}`).sort((left, right) => left.localeCompare(right)).slice(0, 100);
+  return {
+    kind: "actions",
+    title: agent ? `${safeTerminalLine(agent.name)} model` : "Agent model",
+    lines: [
+      `Current: ${safeTerminalLine(configured?.model ?? agent?.model ?? "inherited")}`,
+      "Choose a session-available model or enter a custom Pi model pattern."
+    ],
+    items: agent ? [
+      {
+        id: "model:__inherited__",
+        label: "Inherited",
+        description: "Use frontmatter or active Pi model resolution",
+        action: "set-agent-model"
+      },
+      ...models.map((model) => ({
+        id: `model:${model}`,
+        label: safeTerminalLine(model),
+        action: "set-agent-model"
+      })),
+      {
+        id: "custom",
+        label: "Custom model pattern",
+        description: "Enter provider/model, a model pattern, or an optional :thinking suffix",
+        to: "execution-model-input"
+      },
+      { id: "back", label: "Back", action: "back" }
+    ] : [],
+    hint: "back"
+  };
+}
+function executionModelInputScreen(agent) {
+  const configured = agent ? readSubagentSettings()?.agents?.[agent.name] : void 0;
+  return {
+    kind: "input",
+    title: agent ? `${safeTerminalLine(agent.name)} model` : "Agent model",
+    lines: [
+      `Current: ${safeTerminalLine(configured?.model ?? agent?.model ?? "inherited")}`,
+      "Enter a Pi CLI model pattern, including an optional :thinking suffix.",
+      "Use Reset execution defaults to restore inheritance."
+    ],
+    placeholder: "provider/model or model pattern",
+    action: "set-agent-model",
+    hint: "back"
+  };
+}
+function executionTimeoutInputScreen(agent) {
+  const configured = agent ? readSubagentSettings()?.agents?.[agent.name] : void 0;
+  return {
+    kind: "input",
+    title: agent ? `${safeTerminalLine(agent.name)} timeout` : "Agent timeout",
+    lines: [
+      `Current: ${configured?.timeoutMs ?? agent?.timeoutMs ?? "inherited"}`,
+      `Allowed: 1-${MAX_SUBAGENT_TIMEOUT_MS} milliseconds.`,
+      "Use Reset execution defaults to restore inheritance."
+    ],
+    placeholder: "Timeout in milliseconds",
+    action: "set-agent-timeout",
+    hint: "back"
+  };
+}
+function applyAgentThinking(agent, value, ctx) {
+  if (!agent) return { kind: "rejected" };
+  const thinkingLevel = value === "Inherited" ? void 0 : value;
+  if (thinkingLevel !== void 0 && !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(thinkingLevel)) {
+    return { kind: "rejected" };
+  }
+  return saveAgentPatch(agent.name, { thinkingLevel }, ctx, "thinking level");
+}
+function applyAgentModel(agent, value, ctx) {
+  if (!agent) return { kind: "rejected" };
+  if (value === void 0) return saveAgentPatch(agent.name, { model: void 0 }, ctx, "model");
+  const model = value.trim();
+  if (!model || Buffer.byteLength(model, "utf8") > 1024 || hasTerminalControl(model)) {
+    ctx.ui.notify("Model must contain 1-1024 UTF-8 bytes on one line.", "warning");
+    return { kind: "rejected" };
+  }
+  return saveAgentPatch(agent.name, { model }, ctx, "model");
+}
+function applyAgentTimeout(agent, value, ctx) {
+  if (!agent) return { kind: "rejected" };
+  const normalized = value?.trim() ?? "";
+  if (!/^\d+$/u.test(normalized)) {
+    ctx.ui.notify("Timeout must be a whole number of milliseconds.", "warning");
+    return { kind: "rejected" };
+  }
+  const timeoutMs = Number(normalized);
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_SUBAGENT_TIMEOUT_MS) {
+    ctx.ui.notify(`Timeout must be between 1 and ${MAX_SUBAGENT_TIMEOUT_MS}.`, "warning");
+    return { kind: "rejected" };
+  }
+  return saveAgentPatch(agent.name, { timeoutMs }, ctx, "timeout");
+}
+function resetAgentExecution(agent, ctx) {
+  if (!agent) return { kind: "rejected" };
+  return saveAgentPatch(
+    agent.name,
+    { model: void 0, thinkingLevel: void 0, timeoutMs: void 0 },
+    ctx,
+    "execution defaults"
+  );
+}
+function saveAgentPatch(name, patch, ctx, label) {
+  try {
+    updateAgentSettingsPatch({ [name]: patch });
+    ctx.ui.notify(`${safeTerminalLine(name)} ${label} saved.`, "info");
+    return { kind: "back" };
+  } catch (error) {
+    ctx.ui.notify(
+      `${safeTerminalLine(name)} ${label} was not saved: ${formatError(error)}`,
+      "error"
+    );
+    return { kind: "rejected" };
+  }
+}
+function hasTerminalControl(value) {
+  return [...value].some((character) => {
+    const code = character.codePointAt(0) ?? 0;
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+function formatError(error) {
+  return safeTerminalLine(error instanceof Error ? error.message : String(error));
+}
+
+// src/parallel-limit-ui.ts
+function blockingParallelLimitScreen(runtime) {
+  const limit = inspectBlockingParallelLimitSettings();
+  return {
+    kind: "input",
+    title: "Maximum Parallel Workers",
+    lines: [
+      `Current: ${runtime.getMaxParallelTasks()} worker tasks per blocking call`,
+      `Allowed: 1-${MAX_CONFIGURABLE_PARALLEL_TASKS}`,
+      `Parallel execution still starts at most ${MAX_BLOCKING_PARALLEL_CONCURRENCY} workers at once.`,
+      safeTerminalText(limit.path)
+    ],
+    placeholder: "Enter a whole number",
+    action: "set-parallel-limit",
+    hint: "back"
+  };
+}
+function applyBlockingParallelLimitSetting(value, ctx, runtime) {
+  const normalized = value?.trim() ?? "";
+  if (!/^\d+$/u.test(normalized)) {
+    notifyValidationError(ctx);
+    return { kind: "rejected" };
+  }
+  const next = Number(normalized);
+  if (!Number.isSafeInteger(next) || next < 1 || next > MAX_CONFIGURABLE_PARALLEL_TASKS) {
+    notifyValidationError(ctx);
+    return { kind: "rejected" };
+  }
+  const configured = inspectBlockingParallelLimitSettings();
+  if (configured.error) {
+    ctx.ui.notify(
+      `Subagent settings cannot be edited: ${safeTerminalText(configured.error)}`,
+      "error"
+    );
+    return { kind: "rejected" };
+  }
+  const previousRuntime = runtime.getMaxParallelTasks();
+  const runtimeChanged = next !== previousRuntime;
+  const settingsChanged = next !== configured.value;
+  if (!runtimeChanged && !settingsChanged) return { kind: "back" };
+  if (runtimeChanged) {
+    try {
+      runtime.setMaxParallelTasks(next);
+    } catch (error) {
+      ctx.ui.notify(
+        `Parallel-worker limit was not applied; user settings are unchanged: ${formatError2(error)}`,
+        "error"
+      );
+      return { kind: "rejected" };
+    }
+  }
+  if (settingsChanged) {
+    try {
+      updateBlockingMaxParallelTasksSetting(next);
+    } catch (saveError) {
+      if (runtimeChanged) {
+        try {
+          runtime.setMaxParallelTasks(previousRuntime);
+        } catch (rollbackError) {
+          ctx.ui.notify(
+            `Subagent settings were not saved, and the runtime rollback failed: ${formatError2(new AggregateError([saveError, rollbackError]))}`,
+            "error"
+          );
+          return { kind: "rejected" };
+        }
+      }
+      ctx.ui.notify(
+        "Subagent settings were not saved; the previous runtime limit was restored.",
+        "error"
+      );
+      return { kind: "rejected" };
+    }
+  }
+  ctx.ui.notify(
+    `${settingsChanged ? "Saved and " : ""}applied: maximum ${next} parallel workers per blocking call.`,
+    "info"
+  );
+  return { kind: "back" };
+}
+function notifyValidationError(ctx) {
+  ctx.ui.notify(
+    `Maximum parallel workers must be a whole number from 1 to ${MAX_CONFIGURABLE_PARALLEL_TASKS}.`,
+    "warning"
+  );
+}
+function safeTerminalText(value) {
+  return value.replace(/[\u0000-\u001f\u007f-\u009f]/gu, "?");
+}
+function formatError2(error) {
+  return safeTerminalText(error instanceof Error ? error.message : String(error));
+}
+
+// src/transport-ui.ts
+var TRANSPORT_OPTIONS = [
+  {
+    value: "subprocess",
+    label: "Fresh subprocess",
+    description: "Compatibility path with a fresh isolated Pi process for every turn."
+  },
+  {
+    value: "in-process",
+    label: "In process",
+    description: "Lowest follow-up overhead for built-in tools, with shared memory and crash boundary."
+  },
+  {
+    value: "rpc",
+    label: "Persistent RPC process",
+    description: "Retain native history in one isolated Pi process per active retained agent."
+  },
+  {
+    value: "auto",
+    label: "Automatic",
+    description: "Read-only built-ins use in-process, write-capable built-ins use RPC, and custom tools use subprocess."
+  }
+];
+function transportSettingsScreen(runtime) {
+  const configured = inspectStatefulTransportSettings();
+  const current = runtime.getRuntimeStatus();
+  return {
+    kind: "actions",
+    title: configured.error ? "Detached Transport \xB7 Read only" : "Detached Transport",
+    lines: [
+      `Current session: ${transportLabel(current.transport)}`,
+      `Configured after reload: ${transportLabel(configured.value)} (${configured.source})`,
+      "Transport isolation is not a filesystem or network sandbox.",
+      "RPC v1 disables child extensions and supports built-in Pi tools only.",
+      ...configured.error ? [
+        `Settings cannot be edited: ${safeTerminalLine(configured.error)}`,
+        `Repair ${safeTerminalLine(configured.path)} and retry.`
+      ] : []
+    ],
+    items: [
+      ...configured.error ? [] : TRANSPORT_OPTIONS.map((option) => ({
+        id: option.value,
+        label: option.label,
+        description: option.description,
+        action: "set-transport"
+      })),
+      { id: "back", label: "Back", action: "back" }
+    ],
+    hint: "back"
+  };
+}
+async function applyTransportSetting(value, ctx, runtime, signal, isCurrent) {
+  if (!isTransport(value)) return { kind: "rejected" };
+  const before = inspectStatefulTransportSettings();
+  if (before.error) return { kind: "rejected" };
+  if (value === before.value) return { kind: "stay" };
+  const status = runtime.getRuntimeStatus();
+  if (status.retainedAgents > 0) {
+    ctx.ui.notify(
+      `Cannot change transport while ${status.retainedAgents} detached agent${status.retainedAgents === 1 ? " is" : "s are"} retained. Clear Current agents first.`,
+      "warning"
+    );
+    return { kind: "rejected" };
+  }
+  const option = TRANSPORT_OPTIONS.find((candidate) => candidate.value === value);
+  const confirmed = await ctx.ui.confirm(
+    `Use ${transportLabel(value)} after reload?`,
+    `${option?.description ?? ""}
+
+This saves the setting but does not reload Pi automatically.`,
+    { signal }
+  );
+  if (signal.aborted || !isCurrent()) return { kind: "close" };
+  if (!confirmed) return { kind: "rejected" };
+  const after = inspectStatefulTransportSettings();
+  if (after.error || after.value !== before.value || after.source !== before.source) {
+    ctx.ui.notify("Transport settings changed while confirming; review again.", "warning");
+    return { kind: "rejected" };
+  }
+  if (runtime.getRuntimeStatus().retainedAgents > 0) {
+    ctx.ui.notify(
+      "Detached agents appeared while confirming; clear them before changing transport.",
+      "warning"
+    );
+    return { kind: "rejected" };
+  }
+  try {
+    updateStatefulTransportSetting(value);
+    ctx.ui.notify(`Saved ${transportLabel(value)}. Run /reload when ready.`, "info");
+    return { kind: "stay" };
+  } catch (error) {
+    ctx.ui.notify(
+      `Transport was not saved; the previous setting remains: ${safeTerminalLine(error instanceof Error ? error.message : String(error))}`,
+      "error"
+    );
+    return { kind: "rejected" };
+  }
+}
+function responsivenessSetupScreen(runtime) {
+  const current = runtime.getRuntimeStatus();
+  const configured = inspectStatefulTransportSettings();
+  return {
+    kind: "actions",
+    title: "Responsiveness Setup",
+    lines: [
+      `Current transport: ${transportLabel(current.transport)}`,
+      `Configured transport: ${transportLabel(configured.value)}`,
+      "Transport, completion delivery, and thinking defaults are separate explicit choices.",
+      "Use Automatic to reduce retained follow-up startup while keeping custom-tool compatibility."
+    ],
+    items: [
+      {
+        id: "auto",
+        label: "Preview Automatic transport",
+        description: "Choose a deterministic transport before each retained agent starts",
+        action: "set-transport"
+      },
+      { id: "transport", label: "Compare all transports", to: "transport" },
+      {
+        id: "completion",
+        label: "Completion delivery",
+        description: "Choose separately whether an idle root resumes for synthesis",
+        to: "settings"
+      },
+      { id: "back", label: "Back", action: "back" }
+    ],
+    hint: "back"
+  };
+}
+function transportLabel(value) {
+  return TRANSPORT_OPTIONS.find((option) => option.value === value)?.label ?? value;
+}
+function isTransport(value) {
+  return ["subprocess", "in-process", "rpc", "auto"].includes(value);
+}
+
+// src/config-ui.ts
+var SUBCOMMANDS = [
+  { value: "settings", label: "settings", description: "Configure subagent user settings" },
+  { value: "status", label: "status", description: "Show effective subagent settings" },
+  { value: "help", label: "help", description: "Show subagent settings help" }
+];
+var TOOL_VIEWPORT_SIZE = 10;
+function registerSubagentConfigLifecycle(pi) {
+  const owner = { generation: 0, controller: new AbortController() };
+  pi.on("session_start", () => {
+    owner.generation += 1;
+    owner.controller.abort(new DOMException("Subagent session replaced", "AbortError"));
+    owner.controller = new AbortController();
+  });
+  pi.on("session_shutdown", () => {
+    owner.generation += 1;
+    owner.controller.abort(new DOMException("Subagent session shut down", "AbortError"));
+  });
+  return owner;
+}
+function registerSubagentConfigCommand(pi, runtime, owner = registerSubagentConfigLifecycle(pi)) {
+  registerSubagentPrimaryCommand(pi, runtime, owner);
+}
+function registerSubagentPrimaryCommand(pi, runtime, owner) {
+  pi.registerCommand("subagents", {
+    description: "Manage current-session subagents and user settings",
+    getArgumentCompletions(prefix) {
+      const normalized = prefix.trim().toLowerCase();
+      const matches = SUBCOMMANDS.filter((item) => item.value.startsWith(normalized));
+      return matches.length > 0 ? matches : null;
+    },
+    async handler(args, ctx) {
+      const subcommand = args.trim().toLowerCase();
+      if (!subcommand) {
+        await showSubagentManager(pi, ctx, runtime, owner);
+        return;
+      }
+      switch (subcommand) {
+        case "settings":
+          await showSubagentSettings(ctx, runtime, owner);
+          return;
+        case "status":
+          showSubagentStatus(ctx, runtime);
+          return;
+        case "help":
+          showSubagentHelp(ctx, runtime);
+          return;
+        default:
+          if (ctx.mode === "tui" || ctx.hasUI) {
+            ctx.ui.notify(`Unknown /subagents subcommand: ${subcommand}`, "warning");
+          }
+      }
+    }
+  });
+}
+async function showSubagentManager(pi, ctx, runtime, owner) {
+  if (ctx.mode !== "tui") {
+    showSubagentStatus(ctx, runtime);
+    return;
+  }
+  const generation = owner.generation;
+  const isCurrent = () => generation === owner.generation && !owner.controller.signal.aborted;
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (!isCurrent()) return;
+  let availableAgents = discoverAgents(ctx.cwd, "user", readSubagentSettings() ?? {}).agents;
+  let toolDraft;
+  let selectedExecutionAgent;
+  let selectedStatefulLimit = "maxAgents";
+  const menu = defineMenu({
+    start: "main",
+    screens: {
+      main: () => {
+        const status = runtime.getRuntimeStatus();
+        const workflow = inspectDelegationWorkflowSettings();
+        return {
+          kind: "actions",
+          title: "Subagents",
+          lines: formatManagerSummary(runtime, status, workflow).split("\n"),
+          items: [
+            {
+              id: "workflow",
+              label: "Change delegation",
+              description: "Choose async only (recommended) or a compatibility workflow",
+              to: "workflow"
+            },
+            {
+              id: "agents",
+              label: "Current agents",
+              description: `${status.activeAgents} active \xB7 ${status.retainedAgents} retained`,
+              to: "agents"
+            },
+            {
+              id: "settings",
+              label: "Settings",
+              description: "Configure targets, trusted resources, and async completion",
+              to: "settings"
+            },
+            {
+              id: "advanced",
+              label: "Advanced settings",
+              description: "Agent permissions, parallel limit, runtime details, and settings path",
+              to: "advanced"
+            },
+            { id: "help", label: "Help", to: "help" }
+          ],
+          hint: "close"
+        };
+      },
+      workflow: () => {
+        const snapshot = inspectDelegationWorkflowSettings();
+        const active = currentWorkflow(runtime, runtime.getRuntimeStatus());
+        return {
+          kind: "actions",
+          title: "Change Delegation",
+          lines: [
+            `Current: ${workflowLabel(active)}`,
+            "Recommended: Async only keeps the main agent responsive and omits blocking delegation and consultation.",
+            "Final-answer-dependent detached work needs automatic resume.",
+            ...snapshot.value !== active ? [`Configured after reload: ${workflowLabel(snapshot.value)}`] : [],
+            ...snapshot.error ? [
+              `Settings cannot be edited: ${safeTerminalLine(snapshot.error)}`,
+              `Repair ${safeTerminalLine(snapshot.path)} and retry.`
+            ] : []
+          ],
+          items: snapshot.error ? [] : [
+            {
+              id: "async-only",
+              label: "Async only \xB7 Recommended",
+              description: "Detached lifecycle plus inspection; omit blocking and consultation",
+              action: "set-workflow"
+            },
+            {
+              id: "all",
+              label: "All delegation methods",
+              description: "Compatibility: async, blocking, inspection, and consultation",
+              action: "set-workflow"
+            },
+            {
+              id: "blocking-only",
+              label: "Blocking only",
+              description: "Compatibility: blocking and consultation without async lifecycle",
+              action: "set-workflow"
+            }
+          ],
+          hint: "back"
+        };
+      },
+      agents: () => {
+        const agents = runtime.listAgents();
+        const status = runtime.getRuntimeStatus();
+        return {
+          kind: "actions",
+          title: "Current-session Subagents",
+          lines: agents.length ? agents.map(formatStatefulAgentLine) : [formatEmptyStatefulRuntime(status)],
+          items: [
+            ...agents.length > 0 ? [
+              {
+                id: "clear",
+                label: "Clear current-session agents",
+                description: "Close and delete retained agents for this session",
+                action: "clear-agents"
+              }
+            ] : [],
+            { id: "back", label: "Back", action: "back" }
+          ],
+          hint: "back"
+        };
+      },
+      settings: () => subagentSettingsScreen(runtime),
+      advanced: () => {
+        const limit = inspectBlockingParallelLimitSettings();
+        return {
+          kind: "actions",
+          title: "Advanced Subagent Settings",
+          items: [
+            {
+              id: "agent-tools",
+              label: "Agent tool permissions",
+              description: "Customize persistent per-agent tool allow-lists",
+              action: "load-agent-picker"
+            },
+            {
+              id: "status",
+              label: "Runtime details",
+              description: "Show transport, configured source, and settings path",
+              to: "status"
+            },
+            {
+              id: "parallel-limit",
+              label: "Maximum parallel workers",
+              description: `Current: ${runtime.getMaxParallelTasks()} per blocking call`,
+              to: "parallel-limit",
+              disabled: limit.error !== void 0,
+              disabledReason: limit.error ? `Repair ${safeTerminalLine(limit.path)} before editing this setting` : void 0
+            },
+            {
+              id: "stateful-limits",
+              label: "Detached agent limits",
+              description: formatDetachedLimitSummary(runtime.getRuntimeStatus()),
+              to: "stateful-limits"
+            },
+            {
+              id: "performance",
+              label: "Performance and execution",
+              description: "Transport, responsiveness, and agent defaults",
+              to: "performance"
+            },
+            { id: "back", label: "Back", action: "back" }
+          ],
+          hint: "back"
+        };
+      },
+      performance: () => ({
+        kind: "actions",
+        title: "Performance and Execution",
+        items: [
+          {
+            id: "responsiveness",
+            label: "Responsiveness setup",
+            description: "Preview automatic retained transport and completion guidance",
+            to: "responsiveness"
+          },
+          { id: "transport", label: "Detached transport", to: "transport" },
+          {
+            id: "agents",
+            label: "Agent execution defaults",
+            description: "Model, thinking level, and timeout",
+            to: "execution-agent-picker"
+          },
+          { id: "back", label: "Back", action: "back" }
+        ],
+        hint: "back"
+      }),
+      responsiveness: () => responsivenessSetupScreen(runtime),
+      transport: () => transportSettingsScreen(runtime),
+      "execution-agent-picker": () => executionAgentPickerScreen(availableAgents),
+      "execution-agent": () => executionAgentScreen(selectedExecutionAgent),
+      "execution-thinking": () => executionThinkingScreen(selectedExecutionAgent),
+      "execution-model": () => executionModelScreen(selectedExecutionAgent, ctx),
+      "execution-model-input": () => executionModelInputScreen(selectedExecutionAgent),
+      "execution-timeout": () => executionTimeoutInputScreen(selectedExecutionAgent),
+      "parallel-limit": () => blockingParallelLimitScreen(runtime),
+      "stateful-limits": () => statefulLimitListScreen(runtime),
+      "stateful-limit-input": () => statefulLimitInputScreen(selectedStatefulLimit, runtime),
+      status: () => ({
+        kind: "detail",
+        title: "Subagent runtime details",
+        lines: statusLines(runtime),
+        hint: "back"
+      }),
+      help: () => ({
+        kind: "detail",
+        title: "Subagents help",
+        lines: helpLines(runtime),
+        hint: "back"
+      }),
+      "agent-picker": () => {
+        const settings = readSubagentSettings() ?? {};
+        const configured = settings.agents ?? {};
+        return {
+          kind: "actions",
+          title: "Subagent Tool Configuration",
+          lines: ["Select an agent to configure its allowed tools."],
+          items: availableAgents.map((agent) => {
+            const override = configured[agent.name];
+            const hasOverride = override ? hasOwn(override, "tools") : false;
+            const summary = hasOverride ? override?.tools && override.tools.length > 0 ? override.tools.join(", ") : "none" : "defaults";
+            return {
+              id: agent.name,
+              label: safeTerminalLine(agent.name),
+              description: safeTerminalLine(`${agent.source} \xB7 tools: ${summary}`),
+              action: "pick-agent"
+            };
+          }),
+          hint: "back"
+        };
+      },
+      "tool-draft": () => ({
+        kind: "multiSelect",
+        title: toolDraft ? `${safeTerminalLine(toolDraft.agentName)} tools` : "Agent tools",
+        enableSearch: true,
+        lines: toolDraft ? [
+          `Source: ${safeTerminalLine(toolDraft.agentSource)}`,
+          "Toggle a draft, then Save changes."
+        ] : ["No agent selected."],
+        viewportSize: TOOL_VIEWPORT_SIZE,
+        items: toolDraft?.orderedTools.map((name) => {
+          const available = toolDraft?.allTools.includes(name) ?? false;
+          return {
+            id: name,
+            label: safeTerminalLine(name),
+            description: available ? "Available tool" : "Configured tool is not currently loaded",
+            searchText: available ? "available tool" : "configured unavailable preserved",
+            selected: toolDraft?.selected.has(name) ?? false,
+            disabled: !available,
+            disabledReason: available ? void 0 : "Unavailable; preserved until explicitly changed in JSON"
+          };
+        }) ?? [],
+        action: "toggle-tool",
+        actions: [
+          { id: "save", label: "Save changes", action: "save-tools" },
+          { id: "discard", label: "Discard draft", action: "discard-tools" }
+        ],
+        hint: "back",
+        doneLabel: "Close without saving"
+      })
+    },
+    actions: {
+      "set-workflow": async ({ itemId, signal }) => {
+        if (!isWorkflow(itemId)) return { kind: "rejected" };
+        const snapshot = inspectDelegationWorkflowSettings();
+        if (snapshot.error) return { kind: "rejected" };
+        const active = currentWorkflow(runtime, runtime.getRuntimeStatus());
+        if (itemId === active && itemId === snapshot.value) {
+          ctx.ui.notify(`Delegation already uses ${workflowLabel(itemId)}.`, "info");
+          return { kind: "stay" };
+        }
+        const requiresReload = itemId !== active;
+        if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) {
+          return { kind: "rejected" };
+        }
+        if (!await showWorkflowPreview(ctx, active, itemId, requiresReload, signal)) {
+          return signal.aborted || !isCurrent() ? { kind: "close" } : { kind: "rejected" };
+        }
+        if (signal.aborted || !isCurrent()) return { kind: "close" };
+        if (requiresReload && blockReloadWithRetainedAgents(ctx, runtime)) {
+          return { kind: "rejected" };
+        }
+        try {
+          updateDelegationWorkflowSetting(itemId);
+        } catch (error) {
+          ctx.ui.notify(
+            `Delegation settings were not saved: ${formatError3(error)}. The current workflow is unchanged.`,
+            "error"
+          );
+          return { kind: "rejected" };
+        }
+        if (!requiresReload) {
+          ctx.ui.notify(
+            `Saved ${workflowLabel(itemId)}. The current tool surface already matches.`,
+            "info"
+          );
+          return { kind: "stay" };
+        }
+        ctx.ui.notify(
+          `Saved ${workflowLabel(itemId)}. Reloading subagent tools\u2026 If the tool surface does not refresh, run /reload.`,
+          "info"
+        );
+        await ctx.reload();
+        return { kind: "close" };
+      },
+      "clear-agents": async ({ signal }) => {
+        const agents = runtime.listAgents();
+        if (agents.length === 0) return { kind: "stay" };
+        const confirmed = await ctx.ui.confirm(
+          "Clear current-session subagents?",
+          `Close and delete ${agents.length} retained agent${agents.length === 1 ? "" : "s"}?`,
+          { signal }
+        );
+        if (signal.aborted || !isCurrent()) return { kind: "close" };
+        if (!confirmed) return { kind: "rejected" };
+        if (runtime.listAgents().map((agent) => agent.id).join("\0") !== agents.map((agent) => agent.id).join("\0")) {
+          ctx.ui.notify(
+            "Detached agents changed while confirming; review the list again.",
+            "warning"
+          );
+          return { kind: "rejected" };
+        }
+        const cleared = await runtime.clearAgents();
+        if (signal.aborted || !isCurrent()) return { kind: "close" };
+        ctx.ui.notify(
+          `Cleared ${cleared} current-session subagent${cleared === 1 ? "" : "s"}.`,
+          "info"
+        );
+        return { kind: "stay" };
+      },
+      "set-transport": async ({ itemId, signal }) => applyTransportSetting(itemId, ctx, runtime, signal, isCurrent),
+      "pick-execution-agent": async ({ itemId }) => {
+        selectedExecutionAgent = availableAgents.find((agent) => agent.name === itemId);
+        return selectedExecutionAgent ? { kind: "to", screen: "execution-agent" } : { kind: "rejected" };
+      },
+      "set-agent-thinking": async ({ value }) => applyAgentThinking(selectedExecutionAgent, value, ctx),
+      "set-agent-model": async ({ itemId, value }) => {
+        const selected = value ?? (itemId.startsWith("model:") ? itemId.slice(6) : void 0);
+        return applyAgentModel(
+          selectedExecutionAgent,
+          selected === "__inherited__" ? void 0 : selected,
+          ctx
+        );
+      },
+      "set-agent-timeout": async ({ value }) => applyAgentTimeout(selectedExecutionAgent, value, ctx),
+      "reset-agent-execution": async () => resetAgentExecution(selectedExecutionAgent, ctx),
+      "set-parallel-limit": async ({ value }) => applyBlockingParallelLimitSetting(value, ctx, runtime),
+      "pick-stateful-limit": async ({ itemId }) => {
+        if (!isStatefulLimitField(itemId)) return { kind: "rejected" };
+        selectedStatefulLimit = itemId;
+        return { kind: "to", screen: "stateful-limit-input" };
+      },
+      "set-stateful-limit": async ({ value, signal }) => applyStatefulLimitSetting(selectedStatefulLimit, value, ctx, runtime, {
+        signal,
+        isCurrent
+      }),
+      "set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
+      "set-consult-resources": async ({ value }) => applyConsultResourceSetting(value, ctx, runtime),
+      "set-consultation-cwd": async ({ value }) => applyConsultationCwdSetting(value, ctx, runtime),
+      "set-delegation-cwd": async ({ value }) => applyDelegationCwdSetting(value, ctx, runtime),
+      "load-agent-picker": async () => {
+        availableAgents = discoverAgents(ctx.cwd, "user", readSubagentSettings() ?? {}).agents;
+        if (availableAgents.length === 0) {
+          ctx.ui.notify("No agents found", "warning");
+          return { kind: "rejected" };
+        }
+        return { kind: "to", screen: "agent-picker" };
+      },
+      "pick-agent": async ({ itemId }) => {
+        const agent = availableAgents.find((candidate) => candidate.name === itemId);
+        if (!agent) return { kind: "rejected" };
+        const settings = readSubagentSettings() ?? {};
+        const configured = settings.agents?.[agent.name];
+        const configuredTools = configured && hasOwn(configured, "tools") ? configured.tools ?? [] : void 0;
+        const defaults = discoverAgents(ctx.cwd, "user").agents.find(
+          (candidate) => candidate.name === agent.name
+        )?.tools;
+        const allTools = uniqueToolNames(pi.getAllTools().map((tool) => tool.name)).sort(
+          (a, b) => a.localeCompare(b)
+        );
+        const selected = uniqueToolNames(configuredTools ?? defaults ?? allTools);
+        const selectedSet = new Set(selected);
+        toolDraft = {
+          agentName: agent.name,
+          agentSource: agent.source,
+          allTools,
+          defaultTools: defaults,
+          orderedTools: [...selected, ...allTools.filter((name) => !selectedSet.has(name))],
+          selected: selectedSet
+        };
+        return { kind: "to", screen: "tool-draft" };
+      },
+      "toggle-tool": async ({ itemId, selected }) => {
+        if (!toolDraft?.allTools.includes(itemId)) return { kind: "rejected" };
+        if (selected) toolDraft.selected.add(itemId);
+        else toolDraft.selected.delete(itemId);
+        return { kind: "stay" };
+      },
+      "save-tools": async () => {
+        if (!toolDraft) return { kind: "rejected" };
+        const selected = toolDraft.orderedTools.filter((name) => toolDraft?.selected.has(name));
+        const restoredDefaults = toolDraft.defaultTools === void 0 ? sameToolSet(selected, toolDraft.allTools) : sameToolSet(selected, toolDraft.defaultTools);
+        try {
+          updateAgentToolsSetting(toolDraft.agentName, restoredDefaults ? void 0 : selected);
+        } catch (error) {
+          ctx.ui.notify(`Agent tool settings were not saved: ${formatError3(error)}`, "error");
+          return { kind: "rejected" };
+        }
+        ctx.ui.notify(
+          restoredDefaults ? `${safeTerminalLine(toolDraft.agentName)}: defaults restored` : `${safeTerminalLine(toolDraft.agentName)}: ${selected.length} tool${selected.length === 1 ? "" : "s"} configured`,
+          "info"
+        );
+        toolDraft = void 0;
+        return { kind: "back" };
+      },
+      "discard-tools": async () => {
+        toolDraft = void 0;
+        return { kind: "back" };
+      },
+      back: async () => ({ kind: "back" })
+    }
+  });
+  await runMenu(ctx, menu, {
+    getState: () => void 0,
+    signal: owner.controller.signal,
+    isCurrent
+  });
+}
+async function showSubagentSettings(ctx, runtime, owner) {
+  const snapshot = inspectConsultResourceSettings();
+  if (ctx.mode !== "tui") {
+    if (ctx.hasUI) {
+      ctx.ui.notify(
+        `User settings apply to this and future sessions. Edit settings manually: ${safeTerminalLine(snapshot.path)}`,
+        "info"
+      );
+    }
+    return;
+  }
+  const generation = owner.generation;
+  const isCurrent = () => generation === owner.generation && !owner.controller.signal.aborted;
+  const { defineMenu, runMenu } = await import("@narumitw/pi-tui-kit");
+  if (!isCurrent()) return;
+  const menu = defineMenu({
+    start: "settings",
+    screens: { settings: () => subagentSettingsScreen(runtime) },
+    actions: {
+      "set-completion": async ({ value }) => applyCompletionSetting(value, ctx, runtime),
+      "set-consult-resources": async ({ value }) => applyConsultResourceSetting(value, ctx, runtime),
+      "set-consultation-cwd": async ({ value }) => applyConsultationCwdSetting(value, ctx, runtime),
+      "set-delegation-cwd": async ({ value }) => applyDelegationCwdSetting(value, ctx, runtime)
+    }
+  });
+  await runMenu(ctx, menu, {
+    getState: () => void 0,
+    signal: owner.controller.signal,
+    isCurrent
+  });
+}
+function subagentSettingsScreen(runtime) {
+  const completion = inspectCompletionDeliverySettings();
+  const consult = inspectConsultResourceSettings();
+  const cwdPolicy = inspectCwdPolicySettings();
+  const error = completion.error ?? consult.error ?? cwdPolicy.error;
+  return {
+    kind: "settings",
+    title: error ? "Subagent User Settings \xB7 Read only" : "Subagent User Settings",
+    lines: [
+      "Applies now and to future sessions",
+      "Target and trust settings control startup resources, not filesystem access or sandboxing.",
+      "Manage folder trust with Pi /trust; restart Pi after changing it.",
+      safeTerminalLine(consult.path),
+      ...error ? [`Settings cannot be edited: ${safeTerminalLine(error)}`] : []
+    ],
+    items: error ? [] : [
+      {
+        id: "consultationCwd",
+        label: "Read-only consultation target",
+        description: "Untrusted external targets inherit no target/project resources; agent and package read-only prompts remain.",
+        currentValue: consultationCwdLabel(runtime.getConsultationCwdPolicy()),
+        values: ["Anywhere \xB7 untrusted targets inherit nothing", "Current workspace only"],
+        action: "set-consultation-cwd"
+      },
+      {
+        id: "delegationCwd",
+        label: "General delegation target",
+        description: "Controls starting directories, not absolute paths, shell commands, or OS permissions.",
+        currentValue: delegationCwdLabel(runtime.getDelegationCwdPolicy()),
+        values: [
+          "Current or saved-trusted folders",
+          "Current workspace only",
+          "Anywhere \xB7 normal Pi permissions"
+        ],
+        action: "set-delegation-cwd"
+      },
+      {
+        id: "consultResources",
+        label: "Consultation resources for trusted targets",
+        description: "Choose which trusted context, system, skill, and prompt resources a consultation inherits.",
+        currentValue: consultResourceLabel(runtime.getConsultResourcePolicy()),
+        values: ["Project context only", "No inherited resources", "All trusted resources"],
+        action: "set-consult-resources"
+      },
+      {
+        id: "completionDelivery",
+        label: "When async work finishes",
+        description: "Wait for your next turn, or request one synthesis turn after the root settles.",
+        currentValue: completionLabel(runtime.getCompletionDelivery()),
+        values: ["Wait until my next turn", "Resume automatically when finished"],
+        action: "set-completion"
+      }
+    ]
+  };
+}
+function applyCompletionSetting(value, ctx, runtime) {
+  const previous = runtime.getCompletionDelivery();
+  const next = value === "Resume automatically when finished" ? "auto-resume" : "next-turn";
+  if (next === previous) return { kind: "stay" };
+  try {
+    updateCompletionDeliverySetting(next);
+    runtime.setCompletionDelivery(next);
+    ctx.ui.notify(`Saved and applied: ${completionLabel(next)}.`, "info");
+    return { kind: "stay" };
+  } catch (error) {
+    ctx.ui.notify(`Subagent settings were not saved: ${formatError3(error)}`, "error");
+    return { kind: "rejected" };
+  }
+}
+function applyConsultResourceSetting(value, ctx, runtime) {
+  const previous = runtime.getConsultResourcePolicy();
+  const next = value === "No inherited resources" ? "none" : value === "All trusted resources" ? "all" : "project-context";
+  if (next === previous) return { kind: "stay" };
+  try {
+    updateConsultResourceSetting(next);
+    runtime.setConsultResourcePolicy(next);
+    ctx.ui.notify(`Saved and applied: ${consultResourceLabel(next)}.`, "info");
+    return { kind: "stay" };
+  } catch (error) {
+    ctx.ui.notify(`Subagent settings were not saved: ${formatError3(error)}`, "error");
+    return { kind: "rejected" };
+  }
+}
+function applyConsultationCwdSetting(value, ctx, runtime) {
+  const previous = runtime.getConsultationCwdPolicy();
+  const next = value === "Current workspace only" ? "current-workspace" : "anywhere";
+  if (next === previous) return { kind: "stay" };
+  try {
+    updateCwdPolicySetting("consultation", next);
+    runtime.setConsultationCwdPolicy(next);
+    ctx.ui.notify(`Saved and applied: ${consultationCwdLabel(next)}.`, "info");
+    return { kind: "stay" };
+  } catch (error) {
+    ctx.ui.notify(`Subagent settings were not saved: ${formatError3(error)}`, "error");
+    return { kind: "rejected" };
+  }
+}
+function applyDelegationCwdSetting(value, ctx, runtime) {
+  const previous = runtime.getDelegationCwdPolicy();
+  const next = value === "Current workspace only" ? "current-workspace" : value === "Anywhere \xB7 normal Pi permissions" ? "anywhere" : "trusted-targets";
+  if (next === previous) return { kind: "stay" };
+  try {
+    updateCwdPolicySetting("delegation", next);
+    runtime.setDelegationCwdPolicy(next);
+    ctx.ui.notify(`Saved and applied: ${delegationCwdLabel(next)}.`, "info");
+    return { kind: "stay" };
+  } catch (error) {
+    ctx.ui.notify(`Subagent settings were not saved: ${formatError3(error)}`, "error");
+    return { kind: "rejected" };
+  }
+}
+function blockReloadWithRetainedAgents(ctx, runtime) {
+  const status = runtime.getRuntimeStatus();
+  if (status.retainedAgents === 0) return false;
+  ctx.ui.notify(
+    `Cannot reload while ${status.retainedAgents} detached subagent${status.retainedAgents === 1 ? " is" : "s are"} retained (${status.activeAgents} active). Open Current agents and clear them after their work is safe to discard, then change delegation.`,
+    "warning"
+  );
+  return true;
+}
+function isWorkflow(value) {
+  return value === "all" || value === "async-only" || value === "blocking-only";
+}
+function formatError3(error) {
+  return safeTerminalLine(error instanceof Error ? error.message : String(error));
+}
+export {
+  registerSubagentConfigCommand,
+  registerSubagentConfigLifecycle,
+  showSubagentManager,
+  showSubagentSettings
+};
+//# sourceMappingURL=config-ui-3IBMHTQB.ts.map