jinzd-ai-cli 0.4.213 → 0.4.214

package/dist/electron-server.js

@@ -37,7 +37,7 @@ import {
   VERSION,
   buildUserIdentityPrompt,
   runTestsTool
-} from "./chunk-J35V3IAH.js";
+} from "./chunk-JOJA35RK.js";
 import {
   hasSemanticIndex,
   semanticSearch
@@ -61,8 +61,8 @@ import {
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
-import { join as join21, dirname as dirname6, resolve as resolve9, relative as relative4, sep as sep3 } from "path";
-import { existsSync as existsSync27, readFileSync as readFileSync21, readdirSync as readdirSync12, statSync as statSync10, realpathSync } from "fs";
+import { join as join22, dirname as dirname6, resolve as resolve9, relative as relative4, sep as sep3 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync22, readdirSync as readdirSync13, statSync as statSync10, realpathSync } from "fs";
 import { networkInterfaces } from "os";
 
 // src/config/config-manager.ts
@@ -9663,6 +9663,218 @@ function formatResults2(query, data, _requested) {
   return header + "\n" + results.join("\n\n");
 }
 
+// src/agents/agent-config.ts
+import { existsSync as existsSync15, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir6 } 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 (!existsSync15(dir)) return [];
+  const out = [];
+  for (const file of readdirSync7(dir)) {
+    if (!file.endsWith(".json")) continue;
+    const path3 = join10(dir, file);
+    try {
+      const parsed = JSON.parse(readFileSync12(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: join10(configDir ?? join10(homedir6(), CONFIG_DIR_NAME), "agents"),
+    project: join10(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,
@@ -9677,18 +9889,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 {
@@ -9709,6 +9930,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);
@@ -9728,7 +9951,6 @@ var SubAgentExecutor = class {
     }
     return results;
   }
-  // ── 带前缀的终端输出 ──
   printPrefixed(text) {
     for (const line of text.split("\n")) {
       console.log(this.prefix + line);
@@ -9769,7 +9991,7 @@ var SubAgentExecutor = class {
     }
   }
 };
-function buildSubAgentSystemPrompt(task, parentSystemPrompt) {
+function buildSubAgentSystemPrompt(task, agent, parentSystemPrompt) {
   const parts = [];
   if (parentSystemPrompt) {
     parts.push(parentSystemPrompt);
@@ -9777,6 +9999,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**:
@@ -9790,13 +10014,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 ? "..." : ""))
@@ -9819,58 +10049,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",
@@ -9888,7 +10170,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
       }
     },
@@ -9908,10 +10195,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;
@@ -9919,7 +10213,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");
@@ -9931,32 +10226,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("---");
@@ -10187,14 +10487,14 @@ var taskStopTool = {
 
 // src/tools/builtin/git-tools.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync15 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join11 } from "path";
 function assertGitRepo(cwd) {
   let dir = cwd;
   const root = dir.split(/[\\/]/)[0] + (dir.includes("\\") ? "\\" : "/");
   while (dir && dir !== root) {
-    if (existsSync15(join10(dir, ".git"))) return;
-    const parent = join10(dir, "..");
+    if (existsSync16(join11(dir, ".git"))) return;
+    const parent = join11(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -10459,7 +10759,7 @@ ${commitOutput.trim()}`;
 };
 
 // src/tools/builtin/notebook-edit.ts
-import { readFileSync as readFileSync12, existsSync as existsSync16 } from "fs";
+import { readFileSync as readFileSync13, existsSync as existsSync17 } from "fs";
 import { writeFile } from "fs/promises";
 import { resolve as resolve6, extname as extname2 } from "path";
 var notebookEditTool = {
@@ -10514,10 +10814,10 @@ var notebookEditTool = {
     if (extname2(absPath).toLowerCase() !== ".ipynb") {
       throw new ToolError("notebook_edit", "path must point to a .ipynb file");
     }
-    if (!existsSync16(absPath)) {
+    if (!existsSync17(absPath)) {
       throw new ToolError("notebook_edit", `Notebook not found: ${filePath}`);
     }
-    const raw = readFileSync12(absPath, "utf-8");
+    const raw = readFileSync13(absPath, "utf-8");
     const nb = parseNotebook(raw);
     const cellIdx0 = cellIndexRaw - 1;
     undoStack.push(absPath, `notebook_edit (${action}): ${filePath}`);
@@ -10934,8 +11234,8 @@ function estimateToolDefinitionTokens(def) {
 
 // src/tools/registry.ts
 import { pathToFileURL } from "url";
-import { existsSync as existsSync17, mkdirSync as mkdirSync8, readdirSync as readdirSync7 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readdirSync as readdirSync8 } from "fs";
+import { join as join12 } from "path";
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   pluginToolNames = /* @__PURE__ */ new Set();
@@ -11096,7 +11396,7 @@ var ToolRegistry = class {
    * Returns the number of successfully loaded plugins.
    */
   async loadPlugins(pluginsDir, allowPlugins = false) {
-    if (!existsSync17(pluginsDir)) {
+    if (!existsSync18(pluginsDir)) {
       try {
         mkdirSync8(pluginsDir, { recursive: true });
       } catch {
@@ -11105,7 +11405,7 @@ var ToolRegistry = class {
     }
     let files;
     try {
-      files = readdirSync7(pluginsDir).filter((f) => f.endsWith(".js"));
+      files = readdirSync8(pluginsDir).filter((f) => f.endsWith(".js"));
     } catch {
       return 0;
     }
@@ -11122,12 +11422,12 @@ var ToolRegistry = class {
     process.stderr.write(
       `
 [plugins] \u26A0 Loading ${files.length} plugin(s) with FULL system privileges:
-` + files.map((f) => `  + ${join11(pluginsDir, f)}`).join("\n") + "\n\n"
+` + files.map((f) => `  + ${join12(pluginsDir, f)}`).join("\n") + "\n\n"
     );
     let loaded = 0;
     for (const file of files) {
       try {
-        const fileUrl = pathToFileURL(join11(pluginsDir, file)).href;
+        const fileUrl = pathToFileURL(join12(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) {
@@ -11673,11 +11973,11 @@ var McpManager = class {
 };
 
 // src/skills/manager.ts
-import { existsSync as existsSync18, readdirSync as readdirSync8, mkdirSync as mkdirSync9, statSync as statSync7 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync19, readdirSync as readdirSync9, mkdirSync as mkdirSync9, statSync as statSync7 } from "fs";
+import { join as join13 } from "path";
 
 // src/skills/types.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { basename as basename5 } from "path";
 function parseSimpleYaml(yaml) {
   const result = {};
@@ -11699,7 +11999,7 @@ function parseYamlArray(value) {
 function parseSkillFile(filePath) {
   let raw;
   try {
-    raw = readFileSync13(filePath, "utf-8");
+    raw = readFileSync14(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -11742,7 +12042,7 @@ var SkillManager = class {
   /** 发现并加载 skillsDir 下所有 .md 文件，返回加载数量 */
   loadSkills() {
     this.skills.clear();
-    if (!existsSync18(this.skillsDir)) {
+    if (!existsSync19(this.skillsDir)) {
       try {
         mkdirSync9(this.skillsDir, { recursive: true });
       } catch {
@@ -11751,20 +12051,20 @@ var SkillManager = class {
     }
     let entries;
     try {
-      entries = readdirSync8(this.skillsDir);
+      entries = readdirSync9(this.skillsDir);
     } catch {
       return 0;
     }
     for (const entry of entries) {
       let filePath;
-      const fullPath = join12(this.skillsDir, entry);
+      const fullPath = join13(this.skillsDir, entry);
       if (entry.endsWith(".md")) {
         filePath = fullPath;
       } else {
         try {
           if (statSync7(fullPath).isDirectory()) {
-            const skillMd = join12(fullPath, "SKILL.md");
-            if (existsSync18(skillMd)) {
+            const skillMd = join13(fullPath, "SKILL.md");
+            if (existsSync19(skillMd)) {
               filePath = skillMd;
             } else {
               continue;
@@ -11829,7 +12129,7 @@ var SkillManager = class {
 // src/web/tool-executor-web.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { tmpdir as tmpdir2 } from "os";
-import { existsSync as existsSync19, readFileSync as readFileSync14 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync15 } from "fs";
 var ToolExecutorWeb = class _ToolExecutorWeb {
   constructor(registry, ws) {
     this.registry = registry;
@@ -11968,9 +12268,9 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
     if (call.name === "write_file") {
       const filePath = String(call.arguments["path"] ?? "");
       const newContent = String(call.arguments["content"] ?? "");
-      if (filePath && existsSync19(filePath)) {
+      if (filePath && existsSync20(filePath)) {
         try {
-          const old = readFileSync14(filePath, "utf-8");
+          const old = readFileSync15(filePath, "utf-8");
           return renderDiff(old, newContent, { filePath });
         } catch {
         }
@@ -12273,20 +12573,20 @@ var ToolExecutorWeb = class _ToolExecutorWeb {
 };
 
 // src/core/system-prompt-builder.ts
-import { existsSync as existsSync21, readFileSync as readFileSync16 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
+import { join as join15 } from "path";
 
 // src/repl/dev-state.ts
-import { existsSync as existsSync20, readFileSync as readFileSync15, unlinkSync as unlinkSync4, mkdirSync as mkdirSync10 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir6 } from "os";
+import { existsSync as existsSync21, readFileSync as readFileSync16, unlinkSync as unlinkSync4, mkdirSync as mkdirSync10 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir7 } from "os";
 function getDevStatePath() {
-  return join13(homedir6(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
+  return join14(homedir7(), CONFIG_DIR_NAME, DEV_STATE_FILE_NAME);
 }
 function loadDevState() {
   const path3 = getDevStatePath();
-  if (!existsSync20(path3)) return null;
-  const content = readFileSync15(path3, "utf-8").trim();
+  if (!existsSync21(path3)) return null;
+  const content = readFileSync16(path3, "utf-8").trim();
   return content || null;
 }
 
@@ -12344,9 +12644,9 @@ ${ctx.activeSkill.content}`);
   return { stable: stableParts.join("\n\n---\n\n"), volatile };
 }
 function loadMemoryContent(configDir) {
-  const memoryPath = join14(configDir, MEMORY_FILE_NAME);
-  if (!existsSync21(memoryPath)) return null;
-  let content = readFileSync16(memoryPath, "utf-8").trim();
+  const memoryPath = join15(configDir, MEMORY_FILE_NAME);
+  if (!existsSync22(memoryPath)) return null;
+  let content = readFileSync17(memoryPath, "utf-8").trim();
   if (!content) return null;
   if (content.length > MEMORY_MAX_CHARS) {
     content = content.slice(-MEMORY_MAX_CHARS);
@@ -12555,8 +12855,8 @@ function autoTrimSessionIfNeeded(session, sizeLimit = SESSION_SIZE_LIMIT) {
 }
 
 // src/core/context-files.ts
-import { existsSync as existsSync22, readFileSync as readFileSync17 } from "fs";
-import { join as join15, relative as relative3, resolve as resolve7 } from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync18 } from "fs";
+import { join as join16, relative as relative3, resolve as resolve7 } from "path";
 function uniqueNonEmpty(values) {
   const seen = /* @__PURE__ */ new Set();
   const out = [];
@@ -12586,7 +12886,7 @@ function readContextFile(level, filePath, cwd, maxBytes) {
   const name = filePath.split(/[\\/]/).pop() ?? filePath;
   const shown = displayPath(filePath, cwd);
   try {
-    const raw = readFileSync17(filePath);
+    const raw = readFileSync18(filePath);
     const byteCount = raw.byteLength;
     if (byteCount === 0) {
       return {
@@ -12633,8 +12933,8 @@ function readContextFile(level, filePath, cwd, maxBytes) {
 function findFirstContextFile(level, dir, cwd, candidates, maxBytes) {
   const skipped = [];
   for (const candidate of candidates) {
-    const filePath = join15(dir, candidate);
-    if (!existsSync22(filePath)) continue;
+    const filePath = join16(dir, candidate);
+    if (!existsSync23(filePath)) continue;
     const result = readContextFile(level, filePath, cwd, maxBytes);
     if (result.skipped) skipped.push(result.skipped);
     if (result.layer) return { layer: result.layer, skipped };
@@ -12661,7 +12961,7 @@ function loadContextFiles(options) {
       });
       return { layers: [], mergedContent: "", skipped, totalChars: 0, totalBytes: 0, maxBytes, candidates };
     }
-    if (!existsSync22(filePath)) {
+    if (!existsSync23(filePath)) {
       skipped.push({
         level: "single",
         filePath,
@@ -12712,13 +13012,13 @@ function loadContextFiles(options) {
 }
 
 // src/web/session-handler.ts
-import { existsSync as existsSync25, readFileSync as readFileSync19, writeFileSync as writeFileSync2, mkdirSync as mkdirSync11, readdirSync as readdirSync10, statSync as statSync9, createWriteStream } from "fs";
-import { join as join19, resolve as resolve8, dirname as dirname5 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync2, mkdirSync as mkdirSync11, readdirSync as readdirSync11, statSync as statSync9, createWriteStream } from "fs";
+import { join as join20, resolve as resolve8, dirname as dirname5 } from "path";
 
 // src/tools/git-context.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync23 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join17 } from "path";
 function runGit2(cmd, cwd) {
   try {
     return execSync2(`git ${cmd}`, {
@@ -12735,7 +13035,7 @@ function getGitRoot(cwd = process.cwd()) {
   return runGit2("rev-parse --show-toplevel", cwd);
 }
 function getGitContext(cwd = process.cwd()) {
-  if (!existsSync23(join16(cwd, ".git"))) {
+  if (!existsSync24(join17(cwd, ".git"))) {
     const result = runGit2("rev-parse --git-dir", cwd);
     if (!result) return null;
   }
@@ -12864,8 +13164,8 @@ If no security issues found, state "\u2705 No security vulnerabilities detected"
 }
 
 // src/repl/commands/project-init.ts
-import { existsSync as existsSync24, readFileSync as readFileSync18, readdirSync as readdirSync9, statSync as statSync8 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync19, readdirSync as readdirSync10, statSync as statSync8 } from "fs";
+import { join as join18 } from "path";
 var SCAN_SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -12901,7 +13201,7 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     if (depth > maxDepth || count >= maxEntries) return;
     let entries;
     try {
-      entries = readdirSync9(d);
+      entries = readdirSync10(d);
     } catch {
       return;
     }
@@ -12909,11 +13209,11 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     const sorted = filtered.sort((a, b) => {
       let aIsDir = false, bIsDir = false;
       try {
-        aIsDir = statSync8(join17(d, a)).isDirectory();
+        aIsDir = statSync8(join18(d, a)).isDirectory();
       } catch {
       }
       try {
-        bIsDir = statSync8(join17(d, b)).isDirectory();
+        bIsDir = statSync8(join18(d, b)).isDirectory();
       } catch {
       }
       if (aIsDir !== bIsDir) return aIsDir ? -1 : 1;
@@ -12921,7 +13221,7 @@ function scanDirTree(dir, maxDepth = 2, maxEntries = 80) {
     });
     for (let i = 0; i < sorted.length && count < maxEntries; i++) {
       const name = sorted[i];
-      const fullPath = join17(d, name);
+      const fullPath = join18(d, name);
       const isLast = i === sorted.length - 1;
       const connector = isLast ? "+-- " : "|-- ";
       let isDir;
@@ -12948,7 +13248,7 @@ function scanProject(cwd) {
     configFiles: [],
     directoryStructure: ""
   };
-  const check = (file) => existsSync24(join17(cwd, file));
+  const check = (file) => existsSync25(join18(cwd, file));
   const configCandidates = [
     "package.json",
     "tsconfig.json",
@@ -12975,7 +13275,7 @@ function scanProject(cwd) {
     info.type = "node";
     info.language = check("tsconfig.json") ? "TypeScript" : "JavaScript";
     try {
-      const pkg = JSON.parse(readFileSync18(join17(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync19(join18(cwd, "package.json"), "utf-8"));
       const scripts = pkg.scripts ?? {};
       info.buildCommand = scripts.build ? "npm run build" : void 0;
       info.testCommand = scripts.test ? "npm test" : void 0;
@@ -13635,7 +13935,7 @@ function resolveRoleProviders(roles, lookup, defaultProvider, defaultModel, avai
 }
 
 // src/hub/persist.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function discussionToMessages(state2) {
   const out = [];
   const t0 = state2.messages[0]?.timestamp ?? /* @__PURE__ */ new Date();
@@ -13673,7 +13973,7 @@ async function persistDiscussion(state2, config, defaultProvider, defaultModel)
   session.title = `[Hub] ${state2.topic.slice(0, 48)}`.replace(/\n/g, " ");
   session.titleAiGenerated = true;
   await sm.save();
-  return { id: session.id, path: join18(config.getHistoryDir(), `${session.id}.json`) };
+  return { id: session.id, path: join19(config.getHistoryDir(), `${session.id}.json`) };
 }
 
 // src/web/session-handler.ts
@@ -13833,7 +14133,19 @@ var SessionHandler = class {
       costUsd,
       providers: providerList,
       branches,
-      activeBranchId: sess?.activeBranchId ?? "main"
+      activeBranchId: sess?.activeBranchId ?? "main",
+      agents: listAgentRuns().slice(0, 20).map((run) => ({
+        id: run.id,
+        agentName: run.agentName,
+        task: run.task,
+        status: run.status,
+        startedAt: run.startedAt,
+        finishedAt: run.finishedAt,
+        summary: run.summary,
+        error: run.error,
+        toolNames: run.toolNames,
+        agentIndex: run.agentIndex
+      }))
     });
   }
   async handleMessage(raw) {
@@ -14310,6 +14622,7 @@ Details: ${errMsg.split("\n")[0]}
 ${systemPromptVolatile}` : systemPrompt;
           spawnAgentContext.modelParams = modelParams;
           spawnAgentContext.configManager = this.config;
+          spawnAgentContext.providers = this.providers;
           ToolExecutor.currentMessageIndex = this.sessions.current?.messages.length ?? 0;
           return this.toolExecutor.executeAll(toolCalls);
         },
@@ -14904,6 +15217,7 @@ Tokens: in=${this.sessionTokenUsage.inputTokens} out=${this.sessionTokenUsage.ou
             "  /export [md|json]    \u2014 Export conversation",
             "  /skill [name|off|list|reload] \u2014 Manage agent skills",
             "  /memory [show|add|clear] \u2014 Persistent memory management",
+            "  /agent list|switch|stop|summary \u2014 Manage named sub-agents",
             "  /yolo [on|off]       \u2014 Toggle auto-approve (skip confirmations)",
             "  /search <keyword>    \u2014 Search across all session histories",
             "  /undo [list|<n>]     \u2014 Undo file operations",
@@ -15036,6 +15350,66 @@ ${activated.meta.description || ""}` });
         }
         break;
       }
+      case "agent": {
+        const sub = args[0]?.toLowerCase() ?? "summary";
+        if (sub === "list") {
+          const agents = listAgentConfigs(this.config.getConfigDir());
+          const lines = [`Agents (${agents.length})`, ""];
+          for (const agent of agents) {
+            const active = agent.name === getPreferredAgentName() ? " *" : "  ";
+            const model = [agent.provider, agent.model].filter(Boolean).join("/") || "inherit";
+            lines.push(`${active} ${agent.name} [${agent.source ?? "builtin"}] \u2014 ${agent.description ?? ""}`);
+            lines.push(`    model: ${model} \xB7 permission: ${agent.permissionProfile ?? "workspace-write"} \xB7 maxRounds: ${agent.maxToolRounds ?? "inherit"}`);
+          }
+          lines.push("", "Config dirs: ~/.aicli/agents/ and .aicli/agents/");
+          this.send({ type: "info", message: lines.join("\n") });
+          break;
+        }
+        if (sub === "switch") {
+          const name2 = args[1];
+          if (!name2) {
+            this.send({ type: "error", message: "Usage: /agent switch <name>" });
+            break;
+          }
+          const agent = resolveAgentConfig(name2, this.config.getConfigDir());
+          if (!agent) {
+            const available = listAgentConfigs(this.config.getConfigDir()).map((a) => a.name).join(", ");
+            this.send({ type: "error", message: `Unknown agent: ${name2}
+Available: ${available}` });
+            break;
+          }
+          setPreferredAgentName(agent.name);
+          this.send({ type: "info", message: `Preferred spawn_agent role: ${agent.name}` });
+          this.sendStatus();
+          break;
+        }
+        if (sub === "stop") {
+          const target = args[1] ?? "all";
+          const count = requestAgentStop(target);
+          this.send({ type: "info", message: count > 0 ? `Stop requested for ${count} running agent(s).` : "No matching running agents." });
+          this.sendStatus();
+          break;
+        }
+        if (sub === "summary") {
+          const runs2 = listAgentRuns();
+          if (runs2.length === 0) {
+            this.send({ type: "info", message: "No sub-agent runs yet." });
+            break;
+          }
+          const lines = [`Recent agent runs (${runs2.length})`, ""];
+          for (const run of runs2.slice(0, 20)) {
+            lines.push(`${run.id} ${run.status} ${run.agentName} ${run.startedAt}`);
+            lines.push(`  task: ${run.task.slice(0, 120)}${run.task.length > 120 ? "..." : ""}`);
+            if (run.toolNames.length > 0) lines.push(`  tools: ${run.toolNames.join(", ")}`);
+            if (run.summary) lines.push(`  summary: ${run.summary.slice(0, 180)}${run.summary.length > 180 ? "..." : ""}`);
+            if (run.error) lines.push(`  error: ${run.error}`);
+          }
+          this.send({ type: "info", message: lines.join("\n") });
+          break;
+        }
+        this.send({ type: "error", message: "Usage: /agent list|switch <name>|stop <id|all>|summary" });
+        break;
+      }
       // ── /yolo ──────────────────────────────────────────────────────
       case "auto": {
         const sub = args[0]?.toLowerCase() ?? "status";
@@ -15178,9 +15552,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
         let modifiedFiles = 0;
         const diffLines2 = [];
         for (const [filePath, { earliest }] of fileMap) {
-          const currentContent = existsSync25(filePath) ? (() => {
+          const currentContent = existsSync26(filePath) ? (() => {
             try {
-              return readFileSync19(filePath, "utf-8");
+              return readFileSync20(filePath, "utf-8");
             } catch {
               return null;
             }
@@ -15696,7 +16070,7 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       case "test": {
         this.send({ type: "info", message: "\u{1F9EA} Running tests..." });
         try {
-          const { executeTests } = await import("./run-tests-7J3PNWVS.js");
+          const { executeTests } = await import("./run-tests-R6FL6CQ3.js");
           const argStr = args.join(" ").trim();
           let testArgs = {};
           if (argStr) {
@@ -15713,9 +16087,9 @@ ${undoResults.map((r) => `  \u2022 ${r}`).join("\n")}` });
       // ── /init ───────────────────────────────────────────────────────
       case "init": {
         const cwd = process.cwd();
-        const targetPath = join19(cwd, "AICLI.md");
+        const targetPath = join20(cwd, "AICLI.md");
         const force = args.includes("--force");
-        if (existsSync25(targetPath) && !force) {
+        if (existsSync26(targetPath) && !force) {
           this.send({ type: "info", message: `AICLI.md already exists at ${targetPath}
 Use /init --force to overwrite.` });
           break;
@@ -15748,7 +16122,7 @@ Use /context reload to load it.` });
         lines.push("**Config Files:**");
         lines.push(`  Dir: ${configDir}`);
         const checkFile = (label, filePath) => {
-          const exists = existsSync25(filePath);
+          const exists = existsSync26(filePath);
           let extra = "";
           if (exists) {
             try {
@@ -15758,9 +16132,9 @@ Use /context reload to load it.` });
           }
           lines.push(`  ${exists ? "\u2713" : "\u2013"}  ${label.padEnd(14)} ${exists ? filePath + extra : "(not found)"}`);
         };
-        checkFile("config.json", join19(configDir, "config.json"));
-        checkFile("memory.md", join19(configDir, MEMORY_FILE_NAME));
-        checkFile("dev-state.md", join19(configDir, "dev-state.md"));
+        checkFile("config.json", join20(configDir, "config.json"));
+        checkFile("memory.md", join20(configDir, MEMORY_FILE_NAME));
+        checkFile("dev-state.md", join20(configDir, "dev-state.md"));
         lines.push("");
         if (this.mcpManager) {
           lines.push("**MCP Servers:**");
@@ -15948,7 +16322,7 @@ Use /add-dir remove to clear.` : "No directories added.\nUsage: /add-dir <path>
           break;
         }
         const dirPath = resolve8(sub);
-        if (!existsSync25(dirPath)) {
+        if (!existsSync26(dirPath)) {
           this.send({ type: "error", message: `Directory not found: ${dirPath}` });
           break;
         }
@@ -15964,14 +16338,14 @@ It will be included in AI context for subsequent messages.` });
       // ── /commands ───────────────────────────────────────────────────
       case "commands": {
         const configDir = this.config.getConfigDir();
-        const commandsDir = join19(configDir, CUSTOM_COMMANDS_DIR_NAME);
-        if (!existsSync25(commandsDir)) {
+        const commandsDir = join20(configDir, CUSTOM_COMMANDS_DIR_NAME);
+        if (!existsSync26(commandsDir)) {
           this.send({ type: "info", message: `No custom commands directory.
 Create: ${commandsDir}/ with .md files.` });
           break;
         }
         try {
-          const files = readdirSync10(commandsDir).filter((f) => f.endsWith(".md"));
+          const files = readdirSync11(commandsDir).filter((f) => f.endsWith(".md"));
           if (files.length === 0) {
             this.send({ type: "info", message: `No custom commands found in ${commandsDir}
 Add .md files to create commands.` });
@@ -15991,7 +16365,7 @@ Add .md files to create commands.` });
       // ── /plugins ────────────────────────────────────────────────────
       case "plugins": {
         const configDir = this.config.getConfigDir();
-        const pluginsDir = join19(configDir, PLUGINS_DIR_NAME);
+        const pluginsDir = join20(configDir, PLUGINS_DIR_NAME);
         const pluginTools = this.toolRegistry.listPluginTools();
         const lines = [`\u{1F50C} **Plugins:**`, `Dir: ${pluginsDir}`, ""];
         if (pluginTools.length === 0) {
@@ -16188,11 +16562,11 @@ Add .md files to create commands.` });
   }
   memoryShow() {
     const configDir = this.config.getConfigDir();
-    const memPath = join19(configDir, MEMORY_FILE_NAME);
+    const memPath = join20(configDir, MEMORY_FILE_NAME);
     let content = "";
     try {
-      if (existsSync25(memPath)) {
-        content = readFileSync19(memPath, "utf-8");
+      if (existsSync26(memPath)) {
+        content = readFileSync20(memPath, "utf-8");
       }
     } catch (err) {
       process.stderr.write(`[web] Failed to read memory file: ${err instanceof Error ? err.message : err}
@@ -16206,11 +16580,11 @@ Add .md files to create commands.` });
   }
   memoryAdd(text) {
     const configDir = this.config.getConfigDir();
-    const memPath = join19(configDir, MEMORY_FILE_NAME);
+    const memPath = join20(configDir, MEMORY_FILE_NAME);
     try {
       mkdirSync11(configDir, { recursive: true });
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace("T", " ");
-      const previous = existsSync25(memPath) ? readFileSync19(memPath, "utf-8") : "";
+      const previous = existsSync26(memPath) ? readFileSync20(memPath, "utf-8") : "";
       const entry = `
 - [${timestamp}] ${text}
 `;
@@ -16222,7 +16596,7 @@ Add .md files to create commands.` });
   }
   memoryClear() {
     const configDir = this.config.getConfigDir();
-    const memPath = join19(configDir, MEMORY_FILE_NAME);
+    const memPath = join20(configDir, MEMORY_FILE_NAME);
     try {
       atomicWriteFileSync(memPath, "");
       this.send({ type: "info", message: "\u{1F5D1}\uFE0F Persistent memory cleared." });
@@ -16456,8 +16830,8 @@ async function setupProxy(configProxy) {
 }
 
 // src/web/auth.ts
-import { existsSync as existsSync26, readFileSync as readFileSync20, writeFileSync as writeFileSync3, mkdirSync as mkdirSync12, readdirSync as readdirSync11, copyFileSync } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync21, writeFileSync as writeFileSync3, mkdirSync as mkdirSync12, readdirSync as readdirSync12, copyFileSync } from "fs";
+import { join as join21 } from "path";
 import { createHmac, randomBytes, timingSafeEqual, pbkdf2Sync } from "crypto";
 var USERS_FILE = "users.json";
 var TOKEN_EXPIRY_HOURS = 24;
@@ -16472,7 +16846,7 @@ var AuthManager = class {
   db;
   constructor(baseDir) {
     this.baseDir = baseDir;
-    this.usersFile = join20(baseDir, USERS_FILE);
+    this.usersFile = join21(baseDir, USERS_FILE);
     this.db = this.loadOrCreate();
   }
   // ── Public API ─────────────────────────────────────────────────
@@ -16501,9 +16875,9 @@ var AuthManager = class {
     }
     const salt = randomBytes(16).toString("hex");
     const passwordHash = this.hashPassword(password, salt);
-    const dataDir = join20(USERS_DIR, username);
-    const fullDataDir = join20(this.baseDir, dataDir);
-    mkdirSync12(join20(fullDataDir, "history"), { recursive: true });
+    const dataDir = join21(USERS_DIR, username);
+    const fullDataDir = join21(this.baseDir, dataDir);
+    mkdirSync12(join21(fullDataDir, "history"), { recursive: true });
     const user = {
       username,
       passwordHash,
@@ -16618,7 +16992,7 @@ var AuthManager = class {
   getUserDataDir(username) {
     const user = this.db.users.find((u) => u.username === username);
     if (!user) throw new Error(`User not found: ${username}`);
-    return join20(this.baseDir, user.dataDir);
+    return join21(this.baseDir, user.dataDir);
   }
   /** List all usernames */
   listUsers() {
@@ -16654,30 +17028,30 @@ var AuthManager = class {
     const err = this.register(username, password);
     if (err) return err;
     const userDir = this.getUserDataDir(username);
-    const globalConfig = join20(this.baseDir, "config.json");
-    if (existsSync26(globalConfig)) {
+    const globalConfig = join21(this.baseDir, "config.json");
+    if (existsSync27(globalConfig)) {
       try {
-        const content = readFileSync20(globalConfig, "utf-8");
-        writeFileSync3(join20(userDir, "config.json"), content, "utf-8");
+        const content = readFileSync21(globalConfig, "utf-8");
+        writeFileSync3(join21(userDir, "config.json"), content, "utf-8");
       } catch {
       }
     }
-    const globalMemory = join20(this.baseDir, "memory.md");
-    if (existsSync26(globalMemory)) {
+    const globalMemory = join21(this.baseDir, "memory.md");
+    if (existsSync27(globalMemory)) {
       try {
-        const content = readFileSync20(globalMemory, "utf-8");
-        writeFileSync3(join20(userDir, "memory.md"), content, "utf-8");
+        const content = readFileSync21(globalMemory, "utf-8");
+        writeFileSync3(join21(userDir, "memory.md"), content, "utf-8");
       } catch {
       }
     }
-    const globalHistory = join20(this.baseDir, "history");
-    if (existsSync26(globalHistory)) {
+    const globalHistory = join21(this.baseDir, "history");
+    if (existsSync27(globalHistory)) {
       try {
-        const files = readdirSync11(globalHistory).filter((f) => f.endsWith(".json"));
-        const userHistory = join20(userDir, "history");
+        const files = readdirSync12(globalHistory).filter((f) => f.endsWith(".json"));
+        const userHistory = join21(userDir, "history");
         for (const f of files) {
           try {
-            copyFileSync(join20(globalHistory, f), join20(userHistory, f));
+            copyFileSync(join21(globalHistory, f), join21(userHistory, f));
           } catch {
           }
         }
@@ -16688,9 +17062,9 @@ var AuthManager = class {
   }
   // ── Private methods ────────────────────────────────────────────
   loadOrCreate() {
-    if (existsSync26(this.usersFile)) {
+    if (existsSync27(this.usersFile)) {
       try {
-        return JSON.parse(readFileSync20(this.usersFile, "utf-8"));
+        return JSON.parse(readFileSync21(this.usersFile, "utf-8"));
       } catch {
       }
     }
@@ -16807,8 +17181,8 @@ async function startWebServer(options = {}) {
     }
   }
   let skillManager = null;
-  const skillsDir = join21(config.getConfigDir(), SKILLS_DIR_NAME);
-  if (existsSync27(skillsDir)) {
+  const skillsDir = join22(config.getConfigDir(), SKILLS_DIR_NAME);
+  if (existsSync28(skillsDir)) {
     skillManager = new SkillManager(skillsDir, config.get("ui").skillSizeWarn);
     skillManager.loadSkills();
     const count = skillManager.listSkills().length;
@@ -16879,18 +17253,18 @@ async function startWebServer(options = {}) {
     next();
   };
   const moduleDir = getModuleDir();
-  let clientDir = join21(moduleDir, "web", "client");
-  if (!existsSync27(clientDir)) {
-    clientDir = join21(moduleDir, "client");
+  let clientDir = join22(moduleDir, "web", "client");
+  if (!existsSync28(clientDir)) {
+    clientDir = join22(moduleDir, "client");
   }
-  if (!existsSync27(clientDir)) {
-    clientDir = join21(moduleDir, "..", "..", "src", "web", "client");
+  if (!existsSync28(clientDir)) {
+    clientDir = join22(moduleDir, "..", "..", "src", "web", "client");
   }
-  if (!existsSync27(clientDir)) {
-    clientDir = join21(process.cwd(), "src", "web", "client");
+  if (!existsSync28(clientDir)) {
+    clientDir = join22(process.cwd(), "src", "web", "client");
   }
   console.log(`   Static files: ${clientDir}`);
-  app.use("/vendor", express.static(join21(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
+  app.use("/vendor", express.static(join22(clientDir, "vendor"), { maxAge: "1y", immutable: true }));
   app.use(express.static(clientDir));
   app.get("/api/status", (_req, res) => {
     res.json({
@@ -16957,7 +17331,7 @@ async function startWebServer(options = {}) {
   app.get("/api/files", requireAuth, (req, res) => {
     const cwd = process.cwd();
     const prefix = req.query.prefix || "";
-    const targetDir = join21(cwd, prefix);
+    const targetDir = join22(cwd, prefix);
     try {
       const canonicalTarget = realpathSync(resolve9(targetDir));
       const canonicalCwd = realpathSync(resolve9(cwd));
@@ -16971,10 +17345,10 @@ async function startWebServer(options = {}) {
     }
     try {
       const SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "dist-cjs", "release", "__pycache__", ".next", ".nuxt", "coverage", ".cache"]);
-      const entries = readdirSync12(targetDir, { withFileTypes: true });
+      const entries = readdirSync13(targetDir, { withFileTypes: true });
       const files = entries.filter((e) => !SKIP.has(e.name) && !e.name.startsWith(".")).slice(0, 50).map((e) => ({
         name: e.name,
-        path: relative4(cwd, join21(targetDir, e.name)).replace(/\\/g, "/"),
+        path: relative4(cwd, join22(targetDir, e.name)).replace(/\\/g, "/"),
         isDir: e.isDirectory()
       }));
       res.json({ files });
@@ -17010,8 +17384,8 @@ async function startWebServer(options = {}) {
     try {
       const authUser = req._authUser;
       const histDir = authUser ? getUserShared(authUser).config.getHistoryDir() : config.getHistoryDir();
-      const filePath = join21(histDir, `${id}.json`);
-      if (!existsSync27(filePath)) {
+      const filePath = join22(histDir, `${id}.json`);
+      if (!existsSync28(filePath)) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
@@ -17026,7 +17400,7 @@ async function startWebServer(options = {}) {
         res.status(404).json({ error: "Session not found" });
         return;
       }
-      const data = JSON.parse(readFileSync21(filePath, "utf-8"));
+      const data = JSON.parse(readFileSync22(filePath, "utf-8"));
       res.json({ session: data });
     } catch (err) {
       res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
@@ -17039,7 +17413,7 @@ async function startWebServer(options = {}) {
       return;
     }
     const cwd = process.cwd();
-    const fullPath = resolve9(join21(cwd, filePath));
+    const fullPath = resolve9(join22(cwd, filePath));
     try {
       const canonicalFull = realpathSync(fullPath);
       const canonicalCwd = realpathSync(resolve9(cwd));
@@ -17057,7 +17431,7 @@ async function startWebServer(options = {}) {
         res.json({ error: `File too large (${(stat.size / 1024).toFixed(0)} KB, max 512 KB)` });
         return;
       }
-      const content = readFileSync21(fullPath, "utf-8");
+      const content = readFileSync22(fullPath, "utf-8");
       res.json({ content, size: stat.size });
     } catch {
       res.json({ error: "Cannot read file" });
@@ -17312,17 +17686,17 @@ function resolveProjectMcpPath() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join21(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  return existsSync27(configPath) ? configPath : null;
+  const configPath = join22(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  return existsSync28(configPath) ? configPath : null;
 }
 function loadProjectMcpConfig() {
   const cwd = process.cwd();
   const gitRoot = getGitRoot(cwd);
   const projectRoot = gitRoot ?? cwd;
-  const configPath = join21(projectRoot, MCP_PROJECT_CONFIG_NAME);
-  if (!existsSync27(configPath)) return null;
+  const configPath = join22(projectRoot, MCP_PROJECT_CONFIG_NAME);
+  if (!existsSync28(configPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync21(configPath, "utf-8"));
+    const raw = JSON.parse(readFileSync22(configPath, "utf-8"));
     return raw.mcpServers ?? raw;
   } catch {
     return null;