@esso0428/pi-subagents 0.17.31 → 0.17.33

package/src/agent-types.ts

@@ -28,6 +28,11 @@ const agents = new Map<string, AgentConfig>();
 
 /** When true, DEFAULT_AGENTS are skipped during registration. */
 let disableDefaults = false;
+/** Optional top-level fallback; nested resolution never consults this value. */
+let fallbackSubagent: string | undefined;
+export const NO_FALLBACK = "none";
+export function getFallbackSubagent(): string | undefined { return fallbackSubagent; }
+export function setFallbackSubagent(value: string | undefined): void { fallbackSubagent = value; }
 
 /** Check whether default agents are disabled. */
 export function isDefaultsDisabled(): boolean { return disableDefaults; }
@@ -40,20 +45,18 @@ export function setDefaultsDisabled(b: boolean): void { disableDefaults = b; }
  * Starts with DEFAULT_AGENTS, then overlays user agents (overrides defaults with same name).
  * Disabled agents (enabled === false) are kept in the registry but excluded from spawning.
  */
-export function registerAgents(userAgents: Map<string, AgentConfig>): void {
-  agents.clear();
-
-  // Start with defaults (unless disabled via settings)
+export function buildAgentRegistry(userAgents: Map<string, AgentConfig>): Map<string, AgentConfig> {
+  const registry = new Map<string, AgentConfig>();
   if (!disableDefaults) {
-    for (const [name, config] of DEFAULT_AGENTS) {
-      agents.set(name, config);
-    }
+    for (const [name, config] of DEFAULT_AGENTS) registry.set(name, config);
   }
+  for (const [name, config] of userAgents) registry.set(name, config);
+  return registry;
+}
 
-  // Overlay user agents (overrides defaults with same name)
-  for (const [name, config] of userAgents) {
-    agents.set(name, config);
-  }
+export function registerAgents(userAgents: Map<string, AgentConfig>): void {
+  agents.clear();
+  for (const [name, config] of buildAgentRegistry(userAgents)) agents.set(name, config);
 }
 
 /**
@@ -67,16 +70,86 @@ export function applyNicoOverrides(): void {
   applyNicoOverridesToMap(agents, overrides, defaultModel);
 }
 
-/** Case-insensitive key resolution. */
-function resolveKey(name: string): string | undefined {
-  if (agents.has(name)) return name;
+/** Case-insensitive key resolution within a registry. */
+function resolveKeyIn(registry: Map<string, AgentConfig>, name: string): string | undefined {
+  if (registry.has(name)) return name;
   const lower = name.toLowerCase();
-  for (const key of agents.keys()) {
+  for (const key of registry.keys()) {
     if (key.toLowerCase() === lower) return key;
   }
   return undefined;
 }
 
+/** Case-insensitive key resolution. */
+function resolveKey(name: string): string | undefined {
+  return resolveKeyIn(agents, name);
+}
+
+/** Resolve a type name case-insensitively within a private registry. */
+export function resolveTypeIn(registry: Map<string, AgentConfig>, name: string): string | undefined {
+  return resolveKeyIn(registry, name);
+}
+
+/** Get an agent config from a private registry. */
+export function getAgentConfigIn(registry: Map<string, AgentConfig>, name: string): AgentConfig | undefined {
+  const key = resolveKeyIn(registry, name);
+  return key ? registry.get(key) : undefined;
+}
+
+/** Get all enabled agent types from a private registry. */
+export function getAvailableTypesIn(registry: Map<string, AgentConfig>): string[] {
+  return [...registry.entries()]
+    .filter(([_, config]) => config.enabled !== false)
+    .map(([name]) => name);
+}
+
+/** Check whether a type resolves to one enabled registry entry. */
+export function isValidTypeIn(registry: Map<string, AgentConfig>, type: string): boolean {
+  return resolveEnabledTypeIn(registry, type) !== undefined;
+}
+
+/** Resolve exactly one enabled type without applying the top-level fallback policy. */
+export function resolveEnabledTypeIn(
+  registry: Map<string, AgentConfig>,
+  requested: unknown,
+): string | undefined {
+  const raw = typeof requested === "string" ? requested.trim() : "";
+  if (!raw) return undefined;
+  const exact = registry.has(raw) ? raw : undefined;
+  if (exact !== undefined) return registry.get(exact)?.enabled === false ? undefined : exact;
+  const matches = [...registry.keys()].filter(key => key.toLowerCase() === raw.toLowerCase());
+  return matches.length === 1 && registry.get(matches[0])?.enabled !== false ? matches[0] : undefined;
+}
+
+export type SpawnTypeResolution =
+  | { ok: true; type: string; fellBackFrom?: string }
+  | { ok: false; message: string };
+
+/** Resolve a top-level caller type, retaining the historical general-purpose fallback. */
+export function resolveSpawnTypeIn(registry: Map<string, AgentConfig>, requested: unknown): SpawnTypeResolution {
+  const raw = typeof requested === "string" ? requested.trim() : "";
+  const available = () => getAvailableTypesIn(registry).join(", ") || "(none)";
+  const key = resolveEnabledTypeIn(registry, raw);
+  if (key !== undefined) return { ok: true, type: key };
+  const reason = raw ? `Unknown or disabled agent type: "${raw}".` : "No agent type given.";
+  const configured = fallbackSubagent?.trim();
+  if (configured?.toLowerCase() === NO_FALLBACK) {
+    return { ok: false, message: `${reason} Available: ${available()}.` };
+  }
+  if (configured) {
+    const fallback = resolveEnabledTypeIn(registry, configured);
+    if (fallback === undefined) {
+      return { ok: false, message: `${reason} The configured fallbackSubagent "${configured}" is itself unknown or disabled. Available: ${available()}.` };
+    }
+    return { ok: true, type: fallback, fellBackFrom: raw };
+  }
+  return { ok: true, type: "general-purpose", fellBackFrom: raw };
+}
+
+export function resolveSpawnType(requested: unknown): SpawnTypeResolution {
+  return resolveSpawnTypeIn(agents, requested);
+}
+
 /** Resolve a type name case-insensitively. Returns the canonical key or undefined. */
 export function resolveType(name: string): string | undefined {
   return resolveKey(name);

package/src/child-context.ts

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+/** Marks resource loading/session construction performed for a child session. */
+const childSessionContext = new AsyncLocalStorage<boolean>();
+
+export function inChildSessionContext(): boolean {
+  return childSessionContext.getStore() === true;
+}
+
+export function runInChildSessionContext<T>(fn: () => Promise<T>): Promise<T> {
+  return childSessionContext.run(true, fn);
+}

package/src/custom-agents.ts

@@ -73,6 +73,7 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
       persistSession: fm.persist_session != null ? fm.persist_session === true : undefined,
       outputTranscript: fm.output_transcript != null ? fm.output_transcript !== false : undefined,
       sessionDir: str(fm.session_dir),
+      allowedSubagents: parseAllowedSubagents(fm.allowed_subagents),
       systemPrompt: body.trim(),
       promptMode: fm.prompt_mode === "append" ? "append" : "replace",
       inheritContext: fm.inherit_context != null ? fm.inherit_context === true : undefined,
@@ -146,6 +147,17 @@ function csvListOptional(val: unknown): string[] | undefined {
   return parseCsvField(val);
 }
 
+/**
+ * Parse the nested-delegation allowlist. Omitted/empty/"none"/false disables
+ * nested tools; true, "all", and "*" allow every enabled agent type.
+ */
+function parseAllowedSubagents(val: unknown): "all" | string[] | undefined {
+  if (typeof val === "boolean") return val ? "all" : undefined;
+  const items = parseCsvField(val);
+  if (!items) return undefined;
+  return items.some(item => item === "*" || item.toLowerCase() === "all") ? "all" : items;
+}
+
 /**
  * Parse a memory scope field.
  * omitted → undefined; "user"/"project"/"local" → MemoryScope.

package/src/index.ts

@@ -20,13 +20,15 @@ import { agentHistoryLocator, createAgentHistoryPath, readAgentHistory, readAgen
 import { buildAgentStatusMenuEntries, canOpenActiveAgent, canOpenAgentHistory, formatAgentHistoryOption, splitAgentRecords } from "./agent-history-list.js";
 import { AgentManager } from "./agent-manager.js";
 import { getAgentConversation, getDefaultMaxTurns, getGraceTurns, normalizeMaxTurns, SUBAGENT_TOOL_NAMES, setDefaultMaxTurns, setGraceTurns, steerAgent } from "./agent-runner.js";
-import { applyNicoOverrides, BUILTIN_TOOL_NAMES, getAgentConfig, getAllTypes, getAvailableTypes, isDefaultsDisabled, registerAgents, resolveType, setDefaultsDisabled } from "./agent-types.js";
+import { applyNicoOverrides, BUILTIN_TOOL_NAMES, getAgentConfig, getAllTypes, getAvailableTypes, isDefaultsDisabled, registerAgents, resolveSpawnType, setDefaultsDisabled, setFallbackSubagent } from "./agent-types.js";
 import { type RpcHandle, registerRpcHandlers } from "./cross-extension-rpc.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import { isModelInScope, readEnabledModels, resolveEnabledModels } from "./enabled-models.js";
 import { GroupJoinManager } from "./group-join.js";
 import { resolveAgentInvocationConfig, resolveJoinMode } from "./invocation-config.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
+import { isScopeModelsEnabled, setScopeModelsEnabled } from "./model-scope.js";
+import { getMaxSubagentDepth, setMaxSubagentDepth } from "./nested-tools.js";
 import { createOutputFilePath, streamToOutputFile, writeInitialEntry } from "./output-file.js";
 import { SubagentScheduler } from "./schedule.js";
 import { resolveStorePath, ScheduleStore } from "./schedule-store.js";
@@ -425,6 +427,13 @@ export default function (pi: ExtensionAPI) {
 
   // Background completion: route through group join or send individual nudge
   const manager = new AgentManager((record) => {
+    // Nested children report through their owner: they remain visible in the
+    // widget but never emit a second top-level event, history entry, or nudge.
+    if (record.parentAgentId) {
+      widget.markFinished(record.id);
+      widget.update();
+      return;
+    }
     // Emit lifecycle event based on terminal status
     const isError = record.status === "error" || record.status === "stopped" || record.status === "aborted";
     const eventData = buildEventData(record);
@@ -484,6 +493,12 @@ export default function (pi: ExtensionAPI) {
     // 'delivered' → group callback already fired
     widget.update();
   }, undefined, (record) => {
+    // Nested children are already represented under their owner in the widget.
+    if (record.parentAgentId) {
+      widget.ensureTimer();
+      widget.update();
+      return;
+    }
     // Emit started event when agent transitions to running (including from queue)
     pi.events.emit("subagents:started", {
       id: record.id,
@@ -493,6 +508,7 @@ export default function (pi: ExtensionAPI) {
     widget.ensureTimer();
     widget.update();
   }, (record, info) => {
+    if (record.parentAgentId) return;
     // Emit compacted event when agent's session compacts (preserves count on record).
     pi.events.emit("subagents:compacted", {
       id: record.id,
@@ -701,9 +717,6 @@ export default function (pi: ExtensionAPI) {
   // Off by default; opt-in via `/agents → Settings`. See docstring on
   // SubagentsSettings.scopeModels for the hard-error vs warn-and-proceed
   // policy and its rationale.
-  let scopeModelsEnabled = false;
-  function isScopeModelsEnabled(): boolean { return scopeModelsEnabled; }
-  function setScopeModelsEnabled(enabled: boolean): void { scopeModelsEnabled = enabled; }
 
   // ---- Disable default agents configuration ----
   // When enabled, the three hardcoded default agents (general-purpose, Explore,
@@ -823,6 +836,8 @@ export default function (pi: ExtensionAPI) {
   applyAndEmitLoaded(
     {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
+      setMaxSubagentDepth,
+      setFallbackSubagent,
       setDefaultMaxTurns,
       setGraceTurns,
       setDefaultJoinMode,
@@ -1147,8 +1162,9 @@ Terse command-style prompts produce shallow, generic work.
       reloadCustomAgents();
 
       const rawType = params.subagent_type as SubagentType;
-      const resolved = resolveType(rawType);
-      const subagentType = resolved ?? "general-purpose";
+      const resolution = resolveSpawnType(rawType);
+      if (!resolution.ok) return textResult(resolution.message);
+      const subagentType = resolution.type;
 
       const displayName = getDisplayName(subagentType);
 
@@ -2336,6 +2352,7 @@ ${systemPrompt}
   function snapshotSettings(): SubagentsSettings {
     return {
       maxConcurrent: manager.getMaxConcurrent(),
+      maxSubagentDepth: getMaxSubagentDepth(),
       // 0 = unlimited — per SubagentsSettings.defaultMaxTurns docstring and
       // normalizeMaxTurns() in agent-runner.ts (which maps 0 → undefined).
       defaultMaxTurns: getDefaultMaxTurns() ?? 0,
@@ -2350,11 +2367,12 @@ ${systemPrompt}
     };
   }
 
-  const NUMERIC_IDS = new Set(["maxConcurrent", "defaultMaxTurns", "graceTurns"]);
+  const NUMERIC_IDS = new Set(["maxConcurrent", "maxSubagentDepth", "defaultMaxTurns", "graceTurns"]);
 
   async function showSettings(ctx: ExtensionCommandContext) {
     function buildItems(): SettingItem[] {
       const mc = manager.getMaxConcurrent();
+      const depth = getMaxSubagentDepth();
       const dmt = getDefaultMaxTurns() ?? 0;
       const gt = getGraceTurns();
 
@@ -2366,6 +2384,13 @@ ${systemPrompt}
           currentValue: String(mc),
           values: [String(mc)],
         },
+        {
+          id: "maxSubagentDepth",
+          label: "Max nested depth",
+          description: "Maximum nested delegation depth (0 = disabled, Enter to type)",
+          currentValue: String(depth),
+          values: [String(depth)],
+        },
         {
           id: "defaultMaxTurns",
           label: "Default max turns",
@@ -2439,6 +2464,12 @@ ${systemPrompt}
           manager.setMaxConcurrent(n);
           notifyApplied(ctx, `Max concurrency set to ${n}`);
         }
+      } else if (id === "maxSubagentDepth") {
+        const n = parseInt(value, 10);
+        if (n >= 0) {
+          setMaxSubagentDepth(n);
+          notifyApplied(ctx, `Max nested depth set to ${n}`);
+        }
       } else if (id === "defaultMaxTurns") {
         const n = parseInt(value, 10);
         if (n === 0) {

package/src/model-scope.ts

@@ -0,0 +1,35 @@
+/** Shared model-scope policy for top-level and nested spawns. */
+
+import { isModelInScope, type ModelRegistryRef, readEnabledModels, resolveEnabledModels } from "./enabled-models.js";
+
+let scopeModelsEnabled = false;
+
+export function isScopeModelsEnabled(): boolean { return scopeModelsEnabled; }
+export function setScopeModelsEnabled(enabled: boolean): void { scopeModelsEnabled = enabled; }
+
+export type ModelScopeVerdict =
+  | { kind: "ok" }
+  | { kind: "error"; message: string }
+  | { kind: "warn"; message: string };
+
+export function checkModelScope(args: {
+  model: { provider: string; id: string } | undefined;
+  cwd: string;
+  modelRegistry: ModelRegistryRef;
+  callerSupplied: boolean;
+  agentLabel: string;
+  modelInput?: string;
+}): ModelScopeVerdict {
+  const { model, cwd, modelRegistry, callerSupplied, agentLabel, modelInput } = args;
+  if (!scopeModelsEnabled || !model) return { kind: "ok" };
+  const allowed = resolveEnabledModels(readEnabledModels(cwd), modelRegistry, cwd);
+  if (!allowed || isModelInScope(model, allowed)) return { kind: "ok" };
+  if (callerSupplied) {
+    const list = [...allowed].sort().map(item => `  ${item}`).join("\n");
+    return { kind: "error", message: `Model not in scope: "${modelInput}".\n\nAllowed models (from enabledModels):\n${list}` };
+  }
+  return {
+    kind: "warn",
+    message: `Agent "${agentLabel}" using out-of-scope model "${modelInput ?? `${model.provider}/${model.id}`}"`,
+  };
+}