jinzd-ai-cli 0.4.213 → 0.4.214

package/dist/{chunk-THNECAAY.js → chunk-R5CJD2AB.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-T2NL5ZIA.js";
 import {
   runTestsTool
-} from "./chunk-UDMU4FUF.js";
+} from "./chunk-TR6MSPSS.js";
 import {
   runTool
-} from "./chunk-7NTFMLJJ.js";
+} from "./chunk-YMFGGCUP.js";
 import {
   getDangerLevel,
   isFileWriteTool,
@@ -26,7 +26,7 @@ import {
   SUBAGENT_ALLOWED_TOOLS,
   SUBAGENT_DEFAULT_MAX_ROUNDS,
   SUBAGENT_MAX_ROUNDS_LIMIT
-} from "./chunk-IWLVH32D.js";
+} from "./chunk-DBYMX2ZC.js";
 import {
   fileCheckpoints
 } from "./chunk-4BKXL7SM.js";
@@ -4896,6 +4896,218 @@ function formatResults2(query, data, _requested) {
   return header + "\n" + results.join("\n\n");
 }
 
+// src/agents/agent-config.ts
+import { existsSync as existsSync12, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir4 } from "os";
+var READ_ONLY_TOOLS2 = /* @__PURE__ */ new Set([
+  "read_file",
+  "list_dir",
+  "grep_files",
+  "glob_files",
+  "web_fetch",
+  "google_search",
+  "write_todos",
+  "find_symbol",
+  "get_outline",
+  "find_references",
+  "search_code"
+]);
+var BUILTIN_AGENTS = [
+  {
+    name: "explorer",
+    description: "Read-only code exploration and evidence gathering.",
+    permissionProfile: "read-only",
+    allowedTools: [...READ_ONLY_TOOLS2],
+    maxToolRounds: 10,
+    contextPolicy: "task-only",
+    system: "Act as a read-only explorer. Inspect code, collect evidence, and do not modify files.",
+    source: "builtin"
+  },
+  {
+    name: "worker",
+    description: "Implementation and focused fixes within sub-agent safety limits.",
+    permissionProfile: "workspace-write",
+    maxToolRounds: 15,
+    contextPolicy: "task-only",
+    system: "Act as a focused implementation worker. Keep edits scoped and report changed files.",
+    source: "builtin"
+  },
+  {
+    name: "reviewer",
+    description: "Code review focused on bugs, regressions, and missing tests.",
+    permissionProfile: "read-only",
+    allowedTools: [...READ_ONLY_TOOLS2],
+    maxToolRounds: 12,
+    contextPolicy: "task-only",
+    system: "Act as a code reviewer. Lead with concrete findings, file evidence, and residual risks.",
+    source: "builtin"
+  },
+  {
+    name: "security",
+    description: "Security audit with read-only evidence collection.",
+    permissionProfile: "read-only",
+    allowedTools: [...READ_ONLY_TOOLS2],
+    maxToolRounds: 12,
+    contextPolicy: "task-only",
+    system: "Act as a security reviewer. Look for trust-boundary, injection, filesystem, network, and secret-handling issues.",
+    source: "builtin"
+  },
+  {
+    name: "tester",
+    description: "Test planning and regression analysis without direct shell execution.",
+    permissionProfile: "read-only",
+    allowedTools: [...READ_ONLY_TOOLS2],
+    maxToolRounds: 12,
+    contextPolicy: "task-only",
+    system: "Act as a tester. Inspect tests, identify coverage gaps, and propose precise regression checks.",
+    source: "builtin"
+  }
+];
+function normalizeName(name) {
+  return name.trim().toLowerCase();
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function parseAgentConfig(raw, source, path3) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  if (typeof obj.name !== "string" || obj.name.trim() === "") return null;
+  const cfg = {
+    name: obj.name.trim(),
+    source,
+    path: path3
+  };
+  if (typeof obj.description === "string") cfg.description = obj.description;
+  if (typeof obj.provider === "string") cfg.provider = obj.provider;
+  if (typeof obj.model === "string") cfg.model = obj.model;
+  if (typeof obj.system === "string") cfg.system = obj.system;
+  if (typeof obj.instructions === "string") cfg.instructions = obj.instructions;
+  if (typeof obj.systemInstructions === "string") cfg.systemInstructions = obj.systemInstructions;
+  if (isStringArray(obj.allowedTools)) cfg.allowedTools = obj.allowedTools;
+  if (isStringArray(obj.blockedTools)) cfg.blockedTools = obj.blockedTools;
+  if (typeof obj.permissionProfile === "string") cfg.permissionProfile = obj.permissionProfile;
+  if (typeof obj.maxToolRounds === "number" && Number.isFinite(obj.maxToolRounds)) cfg.maxToolRounds = obj.maxToolRounds;
+  if (typeof obj.contextPolicy === "string") cfg.contextPolicy = obj.contextPolicy;
+  return cfg;
+}
+function loadAgentDir(dir, source) {
+  if (!existsSync12(dir)) return [];
+  const out = [];
+  for (const file of readdirSync6(dir)) {
+    if (!file.endsWith(".json")) continue;
+    const path3 = join7(dir, file);
+    try {
+      const parsed = JSON.parse(readFileSync9(path3, "utf-8"));
+      const cfg = parseAgentConfig(parsed, source, path3);
+      if (cfg) out.push(cfg);
+    } catch {
+    }
+  }
+  return out;
+}
+function getAgentDirs(configDir, cwd = process.cwd()) {
+  return {
+    user: join7(configDir ?? join7(homedir4(), CONFIG_DIR_NAME), "agents"),
+    project: join7(cwd, CONFIG_DIR_NAME, "agents")
+  };
+}
+function listAgentConfigs(configDir, cwd = process.cwd()) {
+  const dirs = getAgentDirs(configDir, cwd);
+  const byName = /* @__PURE__ */ new Map();
+  for (const cfg of BUILTIN_AGENTS) byName.set(normalizeName(cfg.name), { ...cfg });
+  for (const cfg of loadAgentDir(dirs.user, "user")) byName.set(normalizeName(cfg.name), cfg);
+  for (const cfg of loadAgentDir(dirs.project, "project")) byName.set(normalizeName(cfg.name), cfg);
+  return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolveAgentConfig(name, configDir, cwd = process.cwd()) {
+  const target = normalizeName(name);
+  return listAgentConfigs(configDir, cwd).find((cfg) => normalizeName(cfg.name) === target);
+}
+function getAgentInstructions(agent) {
+  return agent.system ?? agent.systemInstructions ?? agent.instructions;
+}
+function getEffectiveAgentTools(agent) {
+  let allowed = new Set(SUBAGENT_ALLOWED_TOOLS);
+  if (agent.permissionProfile === "read-only") {
+    allowed = new Set([...allowed].filter((name) => READ_ONLY_TOOLS2.has(name)));
+  }
+  if (agent.allowedTools && agent.allowedTools.length > 0) {
+    const requested = new Set(agent.allowedTools);
+    allowed = new Set([...allowed].filter((name) => requested.has(name)));
+  }
+  if (agent.blockedTools && agent.blockedTools.length > 0) {
+    for (const name of agent.blockedTools) allowed.delete(name);
+  }
+  return allowed;
+}
+function getEffectiveMaxRounds(requestedMaxRounds, agent) {
+  const agentMax = agent.maxToolRounds && agent.maxToolRounds > 0 ? Math.round(agent.maxToolRounds) : SUBAGENT_MAX_ROUNDS_LIMIT;
+  return Math.min(requestedMaxRounds, agentMax, SUBAGENT_MAX_ROUNDS_LIMIT);
+}
+
+// src/agents/agent-runtime.ts
+var nextId = 1;
+var preferredAgentName = "worker";
+var runs = [];
+var MAX_RUNS = 50;
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function startAgentRun(input) {
+  const run = {
+    id: `agent-${nextId++}`,
+    agentName: input.agentName,
+    task: input.task,
+    status: "running",
+    startedAt: nowIso(),
+    toolNames: [],
+    agentIndex: input.agentIndex,
+    stopRequested: false
+  };
+  runs.unshift(run);
+  if (runs.length > MAX_RUNS) runs.splice(MAX_RUNS);
+  return run;
+}
+function recordAgentTool(runId, toolName) {
+  const run = runs.find((r) => r.id === runId);
+  if (!run) return;
+  if (!run.toolNames.includes(toolName)) run.toolNames.push(toolName);
+}
+function finishAgentRun(runId, status, summary, error) {
+  const run = runs.find((r) => r.id === runId);
+  if (!run) return;
+  run.status = status;
+  run.finishedAt = nowIso();
+  if (summary) run.summary = summary;
+  if (error) run.error = error;
+}
+function listAgentRuns() {
+  return runs.map((run) => ({ ...run, toolNames: [...run.toolNames] }));
+}
+function requestAgentStop(idOrAll) {
+  const target = idOrAll.trim().toLowerCase();
+  let count = 0;
+  for (const run of runs) {
+    if (run.status !== "running") continue;
+    if (target === "all" || run.id.toLowerCase() === target) {
+      run.stopRequested = true;
+      count++;
+    }
+  }
+  return count;
+}
+function isAgentStopRequested(runId) {
+  return runs.find((r) => r.id === runId)?.stopRequested ?? false;
+}
+function setPreferredAgentName(name) {
+  preferredAgentName = name.trim() || "worker";
+}
+function getPreferredAgentName() {
+  return preferredAgentName;
+}
+
 // src/tools/builtin/spawn-agent.ts
 var spawnAgentContext = {
   provider: null,
@@ -4910,18 +5122,27 @@ function agentPrefix(agentIndex) {
   return theme.dim(`  \u2503${agentIndex} `);
 }
 var SubAgentExecutor = class {
-  constructor(registry, agentIndex = null) {
+  constructor(registry, agentIndex = null, runId) {
     this.registry = registry;
+    this.runId = runId;
     this.prefix = agentPrefix(agentIndex);
   }
   round = 0;
   totalRounds = 0;
   prefix = PREFIX;
+  toolNames = [];
   setRoundInfo(current, total) {
     this.round = current;
     this.totalRounds = total;
   }
   async execute(call) {
+    if (this.runId && isAgentStopRequested(this.runId)) {
+      return {
+        callId: call.id,
+        content: "Sub-agent stop requested.",
+        isError: true
+      };
+    }
     const tool = this.registry.get(call.name);
     if (!tool) {
       return {
@@ -4942,6 +5163,8 @@ var SubAgentExecutor = class {
       };
     }
     this.printToolCall(call, dangerLevel);
+    if (!this.toolNames.includes(call.name)) this.toolNames.push(call.name);
+    if (this.runId) recordAgentTool(this.runId, call.name);
     try {
       const rawContent = await runTool(tool, call.arguments, call.name);
       const content = truncateOutput(rawContent, call.name);
@@ -4961,7 +5184,6 @@ var SubAgentExecutor = class {
     }
     return results;
   }
-  // ── 带前缀的终端输出 ──
   printPrefixed(text) {
     for (const line of text.split("\n")) {
       console.log(this.prefix + line);
@@ -5002,7 +5224,7 @@ var SubAgentExecutor = class {
     }
   }
 };
-function buildSubAgentSystemPrompt(task, parentSystemPrompt) {
+function buildSubAgentSystemPrompt(task, agent, parentSystemPrompt) {
   const parts = [];
   if (parentSystemPrompt) {
     parts.push(parentSystemPrompt);
@@ -5010,6 +5232,8 @@ function buildSubAgentSystemPrompt(task, parentSystemPrompt) {
   parts.push(
     `# Sub-Agent Mode
 
+**Agent Role**: ${agent.name}${agent.description ? ` \u2014 ${agent.description}` : ""}
+
 You are a focused sub-agent delegated by the main agent to complete a specific task.
 
 **Your Task**:
@@ -5023,13 +5247,19 @@ ${task}
 5. Destructive operations (rm -rf etc.) will be automatically blocked
 6. Be efficient, minimize unnecessary tool call rounds`
   );
+  const agentInstructions = getAgentInstructions(agent);
+  if (agentInstructions) {
+    parts.push(`# Agent Instructions
+
+${agentInstructions}`);
+  }
   return parts.join("\n\n---\n\n");
 }
-function printSubAgentHeader(task, maxRounds, agentIndex = null) {
+function printSubAgentHeader(task, maxRounds, agentName, agentIndex = null) {
   const prefix = agentPrefix(agentIndex);
   console.log();
   console.log(theme.dim("  \u250F\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
-  const label = agentIndex !== null ? `\u{1F916} Sub-Agent #${agentIndex} Spawned` : "\u{1F916} Sub-Agent Spawned";
+  const label = agentIndex !== null ? `\u{1F916} Sub-Agent #${agentIndex} Spawned (${agentName})` : `\u{1F916} Sub-Agent Spawned (${agentName})`;
   console.log(prefix + theme.toolCall(label));
   console.log(
     prefix + theme.dim("Task: ") + (task.slice(0, 120) + (task.length > 120 ? "..." : ""))
@@ -5052,58 +5282,110 @@ function printSubAgentFooter(usage, agentIndex = null) {
   console.log(theme.dim("  \u2517\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
   console.log();
 }
-async function runSubAgent(task, maxRounds, agentIndex, ctx) {
+function summarizeContent(content) {
+  const flat = content.replace(/\s+/g, " ").trim();
+  return flat.length > 500 ? flat.slice(0, 497) + "..." : flat;
+}
+function extractEvidence(content, toolNames) {
+  const evidence = /* @__PURE__ */ new Set();
+  if (toolNames.length > 0) evidence.add(`Tools: ${toolNames.join(", ")}`);
+  const matches = content.match(/(?:[\w.-]+[\\/])+[\w.-]+\.(?:ts|tsx|js|jsx|json|md|css|html|py|go|rs|yml|yaml)/g) ?? [];
+  for (const match of matches.slice(0, 8)) evidence.add(match);
+  return [...evidence].slice(0, 10);
+}
+function formatAgentResult(input) {
+  const lines = [input.title, "", `**Agent**: ${input.agentName}`];
+  if (input.task) lines.push(`**Task**: ${input.task}`);
+  lines.push("", "### Summary", input.summary || "(no summary)", "", "### Key Evidence");
+  if (input.evidence.length > 0) {
+    for (const item of input.evidence) lines.push(`- ${item}`);
+  } else {
+    lines.push("- No structured evidence extracted.");
+  }
+  lines.push("", "### Tools Used");
+  lines.push(input.toolNames.length > 0 ? input.toolNames.join(", ") : "No tools used.");
+  lines.push("", "### Full Result", input.content, "");
+  lines.push(`*Tokens: ${input.usage.inputTokens} in / ${input.usage.outputTokens} out*`);
+  return lines;
+}
+async function runSubAgent(task, maxRounds, agentIndex, ctx, agent) {
   if (!ctx.provider) {
     throw new ToolError("spawn_agent", "provider not initialized (context not injected)");
   }
+  const providerFromConfig = agent.provider && ctx.providers?.has(agent.provider) ? ctx.providers.get(agent.provider) : void 0;
+  const provider = providerFromConfig ?? ctx.provider;
+  const model = agent.model ?? (providerFromConfig?.info?.defaultModel ?? ctx.model);
+  const run = startAgentRun({
+    agentName: agent.name,
+    task,
+    agentIndex: agentIndex ?? void 0
+  });
+  const effectiveTools = getEffectiveAgentTools(agent);
   const subRegistry = new ToolRegistry();
   for (const tool of subRegistry.listAll()) {
-    if (!SUBAGENT_ALLOWED_TOOLS.has(tool.definition.name)) {
+    if (!SUBAGENT_ALLOWED_TOOLS.has(tool.definition.name) || !effectiveTools.has(tool.definition.name)) {
       subRegistry.unregister(tool.definition.name);
     }
   }
-  const subExecutor = new SubAgentExecutor(subRegistry, agentIndex);
+  const subExecutor = new SubAgentExecutor(subRegistry, agentIndex, run.id);
   const subMessages = [
     { role: "user", content: task, timestamp: /* @__PURE__ */ new Date() }
   ];
-  const subSystemPrompt = buildSubAgentSystemPrompt(task, ctx.systemPrompt);
+  const subSystemPrompt = buildSubAgentSystemPrompt(task, agent, ctx.systemPrompt);
   const toolDefs = subRegistry.getDefinitions();
-  printSubAgentHeader(task, maxRounds, agentIndex);
-  const loop = await runLeanAgentLoop({
-    provider: ctx.provider,
-    messages: subMessages,
-    model: ctx.model,
-    maxRounds,
-    chatParams: {
-      temperature: ctx.modelParams.temperature,
-      maxTokens: ctx.modelParams.maxTokens,
-      timeout: ctx.modelParams.timeout,
-      thinking: ctx.modelParams.thinking
-    },
-    executeTools: (calls) => subExecutor.executeAll(calls),
-    systemPromptForRound: () => subSystemPrompt,
-    toolDefsForRound: () => toolDefs,
-    onRoundStart: (round) => {
-      subExecutor.setRoundInfo(round + 1, maxRounds);
-      if (ctx.configManager) {
-        googleSearchContext.configManager = ctx.configManager;
-      }
-    },
-    onRoundsExhausted: () => `(Sub-agent reached maximum rounds (${maxRounds}) without producing a final response)`,
-    onError: (errMsg) => {
-      process.stderr.write(`
+  printSubAgentHeader(task, maxRounds, agent.name, agentIndex);
+  try {
+    const loop = await runLeanAgentLoop({
+      provider,
+      messages: subMessages,
+      model,
+      maxRounds,
+      chatParams: {
+        temperature: ctx.modelParams.temperature,
+        maxTokens: ctx.modelParams.maxTokens,
+        timeout: ctx.modelParams.timeout,
+        thinking: ctx.modelParams.thinking
+      },
+      executeTools: (calls) => subExecutor.executeAll(calls),
+      systemPromptForRound: () => subSystemPrompt,
+      toolDefsForRound: () => toolDefs,
+      onRoundStart: (round) => {
+        subExecutor.setRoundInfo(round + 1, maxRounds);
+        if (ctx.configManager) {
+          googleSearchContext.configManager = ctx.configManager;
+        }
+      },
+      onRoundsExhausted: () => `(Sub-agent reached maximum rounds (${maxRounds}) without producing a final response)`,
+      onError: (errMsg) => {
+        process.stderr.write(`
 [spawn_agent] Error in sub-agent loop: ${errMsg}
 `);
-      return `(Sub-agent error: ${errMsg})`;
-    }
-  });
-  printSubAgentFooter(loop.usage, agentIndex);
-  return { content: loop.content, usage: loop.usage };
+        return `(Sub-agent error: ${errMsg})`;
+      }
+    });
+    printSubAgentFooter(loop.usage, agentIndex);
+    const summary = summarizeContent(loop.content);
+    const evidence = extractEvidence(loop.content, subExecutor.toolNames);
+    const stopped = isAgentStopRequested(run.id);
+    finishAgentRun(run.id, stopped ? "stopped" : "ok", summary);
+    return {
+      content: loop.content,
+      usage: loop.usage,
+      toolNames: subExecutor.toolNames,
+      summary,
+      evidence,
+      agentName: agent.name
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    finishAgentRun(run.id, "error", void 0, message);
+    throw err;
+  }
 }
 var spawnAgentTool = {
   definition: {
     name: "spawn_agent",
-    description: "Delegate subtask(s) to independent sub-agent(s). Each sub-agent has its own conversation context and agentic tool-call loop, with access to bash, file read/write, edit, search, etc., but cannot interact with the user or spawn more sub-agents. Suitable for independently completable subtasks like: refactoring a module, writing tests, researching a technical approach, or implementing a specific feature. Pass `task` for a single sub-agent, or `tasks` (array) to run multiple sub-agents IN PARALLEL. Parallel mode is ideal for independent research/analysis tasks \u2014 network-bound API calls overlap while the main thread stays responsive. Returns a summary of each sub-agent result.",
+    description: "Delegate subtask(s) to independent named agents. Each sub-agent has its own conversation context and agentic tool-call loop, inherits the parent safety boundary, and can only narrow the sub-agent tool whitelist. Pass `agent` to select a built-in or configured role. Built-ins: explorer, worker, reviewer, security, tester. Pass `task` for a single sub-agent, or `tasks` (array) to run multiple sub-agents IN PARALLEL. Returns summary, key evidence, and tools used for each sub-agent result.",
     parameters: {
       task: {
         type: "string",
@@ -5121,7 +5403,12 @@ var spawnAgentTool = {
       },
       max_rounds: {
         type: "number",
-        description: "Max tool-call rounds per sub-agent (1-15, default 10). Applied to each sub-agent in parallel mode.",
+        description: "Max tool-call rounds per sub-agent (1-30, default 15). Agent config can only reduce this value.",
+        required: false
+      },
+      agent: {
+        type: "string",
+        description: "Agent role name from built-ins or ~/.aicli/agents / .aicli/agents JSON configs. Built-ins: explorer, worker, reviewer, security, tester.",
         required: false
       }
     },
@@ -5141,10 +5428,17 @@ var spawnAgentTool = {
       Math.max(Math.round(rawMaxRounds), 1),
       SUBAGENT_MAX_ROUNDS_LIMIT
     );
+    const requestedAgentName = typeof args["agent"] === "string" && args["agent"].trim() ? args["agent"].trim() : getPreferredAgentName();
     const ctx = spawnAgentContext;
     if (!ctx.provider) {
       throw new ToolError("spawn_agent", "provider not initialized (context not injected)");
     }
+    const agent = resolveAgentConfig(requestedAgentName, ctx.configManager?.getConfigDir());
+    if (!agent) {
+      const available = listAgentConfigs(ctx.configManager?.getConfigDir()).map((cfg) => cfg.name).join(", ");
+      throw new ToolError("spawn_agent", `unknown agent "${requestedAgentName}". Available agents: ${available}`);
+    }
+    const effectiveMaxRounds = getEffectiveMaxRounds(maxRounds, agent);
     const hookConfig = ctx.configManager?.get("hooks") ?? void 0;
     const hookConfigDir = ctx.configManager?.getConfigDir() ?? process.cwd();
     const taskCount = singleTask ? 1 : tasksArr.length;
@@ -5152,7 +5446,8 @@ var spawnAgentTool = {
       task: singleTask || void 0,
       tasks: tasksArr.length > 0 ? tasksArr : void 0,
       taskCount,
-      maxRounds
+      maxRounds: effectiveMaxRounds,
+      agent: agent.name
     };
     const startDecisions = runLifecycleHooks(hookConfig, "SubagentStart", hookPayload, hookConfigDir);
     const startDeny = startDecisions.find((d) => d.action === "deny");
@@ -5164,32 +5459,37 @@ var spawnAgentTool = {
     subAgentGuard.active = true;
     try {
       if (singleTask) {
-        const { content, usage } = await runSubAgent(singleTask, maxRounds, null, ctx);
+        const result = await runSubAgent(singleTask, effectiveMaxRounds, null, ctx, agent);
         subagentStatus = "ok";
-        return [
-          "## Sub-Agent Result",
-          "",
-          content,
-          "",
-          "---",
-          `Token usage: ${usage.inputTokens} input, ${usage.outputTokens} output`
-        ].join("\n");
+        return formatAgentResult({
+          title: "## Sub-Agent Result",
+          content: result.content,
+          usage: result.usage,
+          toolNames: result.toolNames,
+          summary: result.summary,
+          evidence: result.evidence,
+          agentName: result.agentName
+        }).join("\n");
       }
       console.log();
-      console.log(theme.toolCall(`\u{1F916} Spawning ${tasksArr.length} sub-agents in parallel...`));
+      console.log(theme.toolCall(`\u{1F916} Spawning ${tasksArr.length} sub-agents in parallel as ${agent.name}...`));
       const results = await Promise.all(
-        tasksArr.map((t, i) => runSubAgent(t, maxRounds, i + 1, ctx))
+        tasksArr.map((t, i) => runSubAgent(t, effectiveMaxRounds, i + 1, ctx, agent))
       );
       const totalIn = results.reduce((s, r) => s + r.usage.inputTokens, 0);
       const totalOut = results.reduce((s, r) => s + r.usage.outputTokens, 0);
       const lines = [`## Parallel Sub-Agent Results (${results.length} agents)`, ""];
       results.forEach((r, i) => {
-        lines.push(`### Sub-Agent #${i + 1}`);
-        lines.push(`**Task**: ${tasksArr[i].slice(0, 200)}${tasksArr[i].length > 200 ? "..." : ""}`);
-        lines.push("");
-        lines.push(r.content);
-        lines.push("");
-        lines.push(`*Tokens: ${r.usage.inputTokens} in / ${r.usage.outputTokens} out*`);
+        lines.push(...formatAgentResult({
+          title: `### Sub-Agent #${i + 1}`,
+          task: `${tasksArr[i].slice(0, 200)}${tasksArr[i].length > 200 ? "..." : ""}`,
+          content: r.content,
+          usage: r.usage,
+          toolNames: r.toolNames,
+          summary: r.summary,
+          evidence: r.evidence,
+          agentName: r.agentName
+        }));
         lines.push("");
       });
       lines.push("---");
@@ -5420,14 +5720,14 @@ var taskStopTool = {
 
 // src/tools/builtin/git-tools.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync12 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join8 } from "path";
 function assertGitRepo(cwd) {
   let dir = cwd;
   const root = dir.split(/[\\/]/)[0] + (dir.includes("\\") ? "\\" : "/");
   while (dir && dir !== root) {
-    if (existsSync12(join7(dir, ".git"))) return;
-    const parent = join7(dir, "..");
+    if (existsSync13(join8(dir, ".git"))) return;
+    const parent = join8(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -5692,7 +5992,7 @@ ${commitOutput.trim()}`;
 };
 
 // src/tools/builtin/notebook-edit.ts
-import { readFileSync as readFileSync9, existsSync as existsSync13 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync14 } from "fs";
 import { writeFile } from "fs/promises";
 import { resolve as resolve6, extname as extname2 } from "path";
 var notebookEditTool = {
@@ -5747,10 +6047,10 @@ var notebookEditTool = {
     if (extname2(absPath).toLowerCase() !== ".ipynb") {
       throw new ToolError("notebook_edit", "path must point to a .ipynb file");
     }
-    if (!existsSync13(absPath)) {
+    if (!existsSync14(absPath)) {
       throw new ToolError("notebook_edit", `Notebook not found: ${filePath}`);
     }
-    const raw = readFileSync9(absPath, "utf-8");
+    const raw = readFileSync10(absPath, "utf-8");
     const nb = parseNotebook(raw);
     const cellIdx0 = cellIndexRaw - 1;
     undoStack.push(absPath, `notebook_edit (${action}): ${filePath}`);
@@ -6167,8 +6467,8 @@ function estimateToolDefinitionTokens(def) {
 
 // src/tools/registry.ts
 import { pathToFileURL } from "url";
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync as readdirSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readdirSync as readdirSync7 } from "fs";
+import { join as join9 } from "path";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   pluginToolNames = /* @__PURE__ */ new Set();
@@ -6329,7 +6629,7 @@ var ToolRegistry = class {
    * Returns the number of successfully loaded plugins.
    */
   async loadPlugins(pluginsDir, allowPlugins = false) {
-    if (!existsSync14(pluginsDir)) {
+    if (!existsSync15(pluginsDir)) {
       try {
         mkdirSync5(pluginsDir, { recursive: true });
       } catch {
@@ -6338,7 +6638,7 @@ var ToolRegistry = class {
     }
     let files;
     try {
-      files = readdirSync6(pluginsDir).filter((f) => f.endsWith(".js"));
+      files = readdirSync7(pluginsDir).filter((f) => f.endsWith(".js"));
     } catch {
       return 0;
     }
@@ -6355,12 +6655,12 @@ var ToolRegistry = class {
     process.stderr.write(
       `
 [plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
-` + files.map((f) => `  + ${join8(pluginsDir, f)}`).join("\n") + "\n\n"
+` + files.map((f) => `  + ${join9(pluginsDir, f)}`).join("\n") + "\n\n"
     );
     let loaded = 0;
     for (const file of files) {
       try {
-        const fileUrl = pathToFileURL(join8(pluginsDir, file)).href;
+        const fileUrl = pathToFileURL(join9(pluginsDir, file)).href;
         const mod = await import(fileUrl);
         const tool = mod.tool ?? mod.default?.tool ?? mod.default;
         if (!tool || typeof tool.execute !== "function" || !tool.definition?.name) {
@@ -6421,6 +6721,12 @@ export {
   cleanupRejectedTeeFile,
   askUserContext,
   googleSearchContext,
+  listAgentConfigs,
+  resolveAgentConfig,
+  listAgentRuns,
+  requestAgentStop,
+  setPreferredAgentName,
+  getPreferredAgentName,
   spawnAgentContext,
   estimateTokens,
   ToolRegistry

package/dist/{chunk-UDMU4FUF.js → chunk-TR6MSPSS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TEST_TIMEOUT
-} from "./chunk-IWLVH32D.js";
+} from "./chunk-DBYMX2ZC.js";
 
 // src/tools/builtin/run-tests.ts
 import { execSync, spawnSync } from "child_process";

package/dist/{chunk-MRGWPCFQ.js → chunk-YFHF3PVB.js}

@@ -8,7 +8,7 @@ import {
   CONFIG_FILE_NAME,
   HISTORY_DIR_NAME,
   PLUGINS_DIR_NAME
-} from "./chunk-IWLVH32D.js";
+} from "./chunk-DBYMX2ZC.js";
 import {
   atomicWriteFileSync
 } from "./chunk-IW3Q7AE5.js";