@zhongqian97-code/ecode 0.5.15 → 0.5.17

package/dist/index.js

@@ -7,10 +7,10 @@ import { resolve as resolve5, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import React4 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync5 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 
 // src/config.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var MODEL_CONTEXT_LIMITS = {
@@ -642,13 +642,13 @@ var READ_TOOL = {
   }
 };
 async function readFile2(params) {
-  const { path: path11, offset = 0, limit } = params;
+  const { path: path12, offset = 0, limit } = params;
   let raw;
   try {
-    raw = await fs.readFile(path11, "utf8");
+    raw = await fs.readFile(path12, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path11}: ${msg}`;
+    return `Error reading ${path12}: ${msg}`;
   }
   const lines = raw.split("\n");
   const sliced = limit !== void 0 ? lines.slice(offset, offset + limit) : lines.slice(offset);
@@ -704,28 +704,28 @@ var EDIT_TOOL = {
   }
 };
 async function editFile(params) {
-  const { path: path11, old_string, new_string } = params;
+  const { path: path12, old_string, new_string } = params;
   let content;
   try {
-    content = await fs3.readFile(path11, "utf8");
+    content = await fs3.readFile(path12, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path11}: ${msg}`;
+    return `Error reading ${path12}: ${msg}`;
   }
   const count = countOccurrences(content, old_string);
   if (count === 0) {
-    return `Error: old_string not found in ${path11}`;
+    return `Error: old_string not found in ${path12}`;
   }
   if (count > 1) {
-    return `Error: old_string appears ${count} times in ${path11} (ambiguous \u2014 add more context)`;
+    return `Error: old_string appears ${count} times in ${path12} (ambiguous \u2014 add more context)`;
   }
   const updated = content.replace(old_string, new_string);
   try {
-    await fs3.writeFile(path11, updated, "utf8");
-    return `Edited ${path11}`;
+    await fs3.writeFile(path12, updated, "utf8");
+    return `Edited ${path12}`;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error writing ${path11}: ${msg}`;
+    return `Error writing ${path12}: ${msg}`;
   }
 }
 function countOccurrences(haystack, needle) {
@@ -1276,19 +1276,96 @@ function todo(params) {
   }
 }
 
-// src/sessions/metadata.ts
-import * as crypto from "crypto";
+// src/tools/task.ts
+import * as crypto3 from "crypto";
+import * as path7 from "path";
+
+// src/subagent/runtime.ts
+async function runSubagentRuntime(options) {
+  const { messages: initial, tools, provider, maxTurns, executeToolCall: executeToolCall2, onOutput } = options;
+  const messages = [...initial];
+  let turnCount = 0;
+  while (turnCount < maxTurns) {
+    turnCount++;
+    let assistantText = "";
+    const toolCalls = [];
+    for await (const chunk of provider.stream(messages, tools)) {
+      if (chunk.text) {
+        assistantText += chunk.text;
+        onOutput?.(chunk.text);
+      }
+      if (chunk.done && chunk.toolCalls) {
+        toolCalls.push(...chunk.toolCalls);
+      }
+    }
+    if (toolCalls.length === 0) {
+      messages.push({ role: "assistant", content: assistantText });
+      return { success: true, finalText: assistantText, turnCount };
+    }
+    messages.push({
+      role: "assistant",
+      content: assistantText || null,
+      tool_calls: toolCalls.map((tc) => ({
+        id: tc.id,
+        type: "function",
+        function: { name: tc.name, arguments: tc.arguments }
+      }))
+    });
+    for (const tc of toolCalls) {
+      const result = await executeToolCall2(tc);
+      messages.push({ role: "tool", tool_call_id: tc.id, content: result });
+    }
+  }
+  return {
+    success: false,
+    finalText: "",
+    turnCount,
+    error: `Subagent exceeded max turns (${maxTurns})`
+  };
+}
+
+// src/logger.ts
 import * as fs7 from "fs";
 import * as path5 from "path";
+function createLogger(logDir, sessionStart) {
+  fs7.mkdirSync(logDir, { recursive: true });
+  const filename = sessionStart.toISOString().replace(/:/g, "-").replace(/\..+/, "") + ".jsonl";
+  const filePath = path5.join(logDir, filename);
+  return {
+    filePath,
+    /**
+     * 将单条日志条目序列化为 JSON 并同步追加到文件（末尾加换行符）。
+     *
+     * 使用 appendFileSync 而非 appendFile（异步版本）的原因：
+     * 进程崩溃或 Ctrl-C 退出时，异步写操作可能尚未完成，导致最后几条记录丢失。
+     * 同步写入虽然阻塞事件循环，但日志条目通常很小（< 1KB），延迟可忽略。
+     *
+     * 写入失败时输出到 stderr 而非抛出异常，防止日志错误中断正常业务流程。
+     */
+    append(entry) {
+      try {
+        fs7.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+      } catch (err) {
+        process.stderr.write(`[logger] Failed to write log entry: ${err}
+`);
+      }
+    }
+  };
+}
+
+// src/sessions/metadata.ts
+import * as crypto2 from "crypto";
+import * as fs8 from "fs";
+import * as path6 from "path";
 function metadataPathFromLogFile(logFilePath2) {
-  const base = path5.basename(logFilePath2, ".jsonl");
-  const dir = path5.dirname(logFilePath2);
-  return path5.join(dir, `${base}-session.json`);
+  const base = path6.basename(logFilePath2, ".jsonl");
+  const dir = path6.dirname(logFilePath2);
+  return path6.join(dir, `${base}-session.json`);
 }
 function createSessionMetadata(logFilePath2, model) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
-    id: crypto.randomUUID(),
+    id: crypto2.randomUUID(),
     startTime: now,
     lastActivity: now,
     cwd: process.cwd(),
@@ -1296,13 +1373,13 @@ function createSessionMetadata(logFilePath2, model) {
     title: "",
     turnCount: 0,
     totalTokens: 0,
-    logFile: path5.basename(logFilePath2)
+    logFile: path6.basename(logFilePath2)
   };
 }
 function writeSessionMetadata(logFilePath2, metadata) {
   const metaPath = metadataPathFromLogFile(logFilePath2);
   try {
-    fs7.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + "\n");
+    fs8.writeFileSync(metaPath, JSON.stringify(metadata, null, 2) + "\n");
   } catch (err) {
     process.stderr.write(`[sessions] Failed to write metadata: ${err}
 `);
@@ -1310,7 +1387,7 @@ function writeSessionMetadata(logFilePath2, metadata) {
 }
 function readSessionMetadata(metaFilePath) {
   try {
-    const raw = fs7.readFileSync(metaFilePath, "utf-8");
+    const raw = fs8.readFileSync(metaFilePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -1320,7 +1397,7 @@ function updateSessionMetadata(logFilePath2, partial) {
   const metaPath = metadataPathFromLogFile(logFilePath2);
   let existing = null;
   try {
-    const raw = fs7.readFileSync(metaPath, "utf-8");
+    const raw = fs8.readFileSync(metaPath, "utf-8");
     existing = JSON.parse(raw);
   } catch {
     return;
@@ -1329,11 +1406,11 @@ function updateSessionMetadata(logFilePath2, partial) {
 }
 function listSessions(logDir) {
   try {
-    const files = fs7.readdirSync(logDir);
+    const files = fs8.readdirSync(logDir);
     const metaFiles = files.filter((f) => f.endsWith("-session.json"));
     const sessions = [];
     for (const file of metaFiles) {
-      const meta = readSessionMetadata(path5.join(logDir, file));
+      const meta = readSessionMetadata(path6.join(logDir, file));
       if (meta) sessions.push(meta);
     }
     return sessions.sort(
@@ -1354,101 +1431,54 @@ function generateTitle(firstUserMessage) {
   return oneLine.length > 50 ? oneLine.slice(0, 47) + "..." : oneLine;
 }
 
-// src/logger.ts
-import * as fs8 from "fs";
-import * as path6 from "path";
-function createLogger(logDir, sessionStart) {
-  fs8.mkdirSync(logDir, { recursive: true });
-  const filename = sessionStart.toISOString().replace(/:/g, "-").replace(/\..+/, "") + ".jsonl";
-  const filePath = path6.join(logDir, filename);
-  return {
-    filePath,
-    /**
-     * 将单条日志条目序列化为 JSON 并同步追加到文件（末尾加换行符）。
-     *
-     * 使用 appendFileSync 而非 appendFile（异步版本）的原因：
-     * 进程崩溃或 Ctrl-C 退出时，异步写操作可能尚未完成，导致最后几条记录丢失。
-     * 同步写入虽然阻塞事件循环，但日志条目通常很小（< 1KB），延迟可忽略。
-     *
-     * 写入失败时输出到 stderr 而非抛出异常，防止日志错误中断正常业务流程。
-     */
-    append(entry) {
-      try {
-        fs8.appendFileSync(filePath, JSON.stringify(entry) + "\n");
-      } catch (err) {
-        process.stderr.write(`[logger] Failed to write log entry: ${err}
-`);
-      }
-    }
-  };
-}
-
 // src/tools/task.ts
 var TASK_TOOL = {
   type: "function",
   function: {
     name: "task",
-    description: "\u628A\u4E00\u4E2A\u5B50\u4EFB\u52A1\u59D4\u6258\u7ED9\u9694\u79BB\u7684\u5B50 agent\u3002\u9002\u5408\u4EE3\u7801\u8C03\u7814\u3001\u5C40\u90E8\u5B9E\u73B0\u3001\u6587\u4EF6\u4FEE\u6539\u6216\u7ED3\u679C\u6C47\u603B\u3002\u8FD4\u56DE\u5355\u6761\u6700\u7EC8\u7ED3\u679C\u3002",
+    description: "Delegate a well-defined subtask to an isolated child agent. The child agent runs its own agentic loop, executes tools, and returns a single result. Use this when a subtask is independent, well-scoped, and benefits from a clean context.",
     parameters: {
       type: "object",
       properties: {
         description: {
           type: "string",
-          description: "3-8 \u4E2A\u8BCD\u7684\u77ED\u63CF\u8FF0\uFF0C\u7528\u4E8E\u6807\u8BC6\u8FD9\u4E2A\u5B50\u4EFB\u52A1\u3002"
+          description: "Short title for the subtask (used in logs and status output)."
         },
         prompt: {
           type: "string",
-          description: "\u4EA4\u7ED9\u5B50 agent \u7684\u5B8C\u6574\u4EFB\u52A1\u8BF4\u660E\u3002"
+          description: "Full task instructions for the child agent."
         },
         context: {
           type: "string",
-          description: "\u53EF\u9009\u3002\u989D\u5916\u8865\u5145\u7ED9\u5B50 agent \u7684\u4E0A\u4E0B\u6587\u8BF4\u660E\u3002"
+          description: "Optional additional context to pass to the child agent."
         },
-        model: {
+        cwd: {
           type: "string",
-          description: "\u53EF\u9009\u3002\u8986\u76D6\u5B50 agent \u4F7F\u7528\u7684\u6A21\u578B\u3002"
+          description: "Working directory for the child agent (defaults to current directory)."
         },
-        cwd: {
+        model: {
           type: "string",
-          description: "\u53EF\u9009\u3002\u5B50 agent \u7684\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u7EE7\u627F\u5F53\u524D process.cwd()\u3002"
+          description: "Optional model override for the child agent."
         },
         max_turns: {
           type: "number",
-          description: "\u53EF\u9009\u3002\u5B50 agent \u6700\u591A\u53EF\u6267\u884C\u591A\u5C11\u8F6E\u5DE5\u5177\u5FAA\u73AF\uFF0C\u9ED8\u8BA4 8\u3002"
+          description: "Maximum agentic loop turns for the child agent (default: 8)."
         }
       },
       required: ["description", "prompt"]
     }
   }
 };
-var SUBAGENT_SYSTEM_PROMPT = [
-  DEFAULT_SYSTEM_PROMPT,
-  "",
-  "You are a focused subagent working for another ecode session.",
-  "Finish the delegated task independently when possible.",
-  "Use tools directly instead of asking the human for routine lookups.",
-  "Return a concise final result for the parent agent.",
-  "If blocked, clearly state the blocker and the smallest next step."
-].join("\n");
-var BASH_TOOL = {
-  type: "function",
-  function: {
-    name: "bash",
-    description: "Execute a shell command and return its output.",
-    parameters: {
-      type: "object",
-      properties: {
-        command: { type: "string", description: "The shell command to run." }
-      },
-      required: ["command"]
-    }
-  }
-};
+var SUBAGENT_SYSTEM_PROMPT = `You are a focused subagent executing a delegated task on behalf of a parent agent.
+
+Rules:
+- Complete the task independently using the tools available to you.
+- Do not ask the human clarifying questions for routine operations \u2014 make reasonable decisions.
+- When done, return a clear, concise result.
+- If you are blocked, describe the blocker and the minimum next step needed.
+- You cannot delegate tasks to other agents.`;
 var SUBAGENT_TOOLS = [
-  {
-    type: BASH_TOOL.type,
-    function: BASH_TOOL.function
-  },
+  BASH_TOOL,
   READ_TOOL,
   WRITE_TOOL,
   EDIT_TOOL,
@@ -1457,223 +1487,399 @@ var SUBAGENT_TOOLS = [
   APPLY_PATCH_TOOL,
   TODO_TOOL
 ];
-function clip(text, maxChars) {
-  return text.length <= maxChars ? text : `${text.slice(0, maxChars - 3)}...`;
-}
-function messageToContextLine(msg) {
-  if (msg.role === "system") return null;
-  if (msg.role === "user") return `user: ${clip(msg.content, 500)}`;
-  if (msg.role === "tool") return `tool(${msg.tool_call_id}): ${clip(msg.content, 700)}`;
-  const parts = [];
-  if (msg.content) parts.push(clip(msg.content, 700));
-  if (msg.tool_calls?.length) {
-    parts.push(
-      `[tool_calls: ${msg.tool_calls.map((tc) => tc.function.name).join(", ")}]`
-    );
+async function handleTaskTool(args, deps) {
+  const { description, prompt, context, max_turns = 8 } = args;
+  const { provider, print = () => void 0, logDir } = deps;
+  const taskId = crypto3.randomUUID().slice(0, 8);
+  let logger;
+  if (logDir) {
+    logger = createLogger(logDir, /* @__PURE__ */ new Date());
+    const meta = createSessionMetadata(logger.filePath, "subagent");
+    writeSessionMetadata(logger.filePath, {
+      ...meta,
+      title: `[subagent] ${description}`
+    });
   }
-  return `assistant: ${parts.join(" ")}`.trim();
-}
-function buildParentContext(parentMessages, extraContext) {
-  const lines = [];
-  if (extraContext?.trim()) {
-    lines.push("## Caller-provided context");
-    lines.push(extraContext.trim());
+  const userContent = context ? `Context:
+${context}
+
+Task:
+${prompt}` : prompt;
+  const messages = [
+    { role: "system", content: SUBAGENT_SYSTEM_PROMPT },
+    { role: "user", content: userContent }
+  ];
+  if (logger) {
+    logger.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), role: "user", content: userContent });
+  }
+  const bashDeps = {
+    executeBash,
+    confirm: async () => false,
+    // danger commands will be denied
+    print,
+    autoApproveNormal: true
+  };
+  const executeToolCall2 = async (tc) => {
+    let result;
+    if (tc.name === "bash") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await handleBashTool(tcArgs.command, bashDeps);
+    } else if (tc.name === "read") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await readFile2(tcArgs);
+    } else if (tc.name === "write") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await writeFile2(tcArgs);
+    } else if (tc.name === "edit") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await editFile(tcArgs);
+    } else if (tc.name === "glob") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await globFiles(tcArgs);
+    } else if (tc.name === "grep") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await grepFiles(tcArgs);
+    } else if (tc.name === "apply_patch") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = await applyPatch(tcArgs);
+    } else if (tc.name === "todo") {
+      const tcArgs = JSON.parse(tc.arguments);
+      result = todo(tcArgs);
+    } else {
+      result = `Unknown tool: ${tc.name}`;
+    }
+    if (logger) {
+      logger.append({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        role: "tool",
+        content: result,
+        tool_call_id: tc.id
+      });
+    }
+    return result;
+  };
+  const runtime = await runSubagentRuntime({
+    messages,
+    tools: SUBAGENT_TOOLS,
+    provider,
+    maxTurns: max_turns,
+    executeToolCall: executeToolCall2,
+    onOutput: (text) => print(text)
+  });
+  if (logger) {
+    logger.append({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      role: "assistant",
+      content: runtime.finalText || runtime.error || null
+    });
+    updateSessionMetadata(logger.filePath, {
+      lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+      turnCount: runtime.turnCount,
+      title: `[subagent] ${description}`
+    });
   }
-  const tail = (parentMessages ?? []).slice(-8).map(messageToContextLine).filter((line) => Boolean(line));
-  if (tail.length > 0) {
-    if (lines.length > 0) lines.push("");
-    lines.push("## Recent parent-session context");
-    lines.push(...tail);
+  const logLine = logger ? `log_file: ${path7.basename(logger.filePath)}
+` : "";
+  if (!runtime.success) {
+    return [
+      `task_id: ${taskId}`,
+      `description: ${description}`,
+      logLine.trim(),
+      "",
+      `<task_result>`,
+      `Error: ${runtime.error ?? "Subagent failed"}`,
+      `</task_result>`
+    ].filter((l) => l !== "" || l === "").join("\n").replace(/\n{3,}/g, "\n\n");
   }
-  if (lines.length === 0) return void 0;
-  return clip(lines.join("\n"), 4e3);
-}
-function appendLog(logger, entry) {
-  if (!logger) return;
-  logger.append({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
-}
-var SKIP_MESSAGE = "Command skipped by user.";
-async function runNonInteractiveBash(command, autoApproveNormal) {
-  const cls = classifyCommand(command);
-  if (cls === "danger") return SKIP_MESSAGE;
-  if (cls === "normal" && !autoApproveNormal) return SKIP_MESSAGE;
-  const result = await executeBash(command);
-  let output = "";
-  if (result.stdout) output += result.stdout;
-  if (result.stderr) output += result.stderr;
-  if (result.exitCode !== 0) output += `
-[exit code: ${result.exitCode}]`;
-  return output || "(no output)";
+  return [
+    `task_id: ${taskId}`,
+    `description: ${description}`,
+    logLine.trim(),
+    "",
+    `<task_result>`,
+    runtime.finalText,
+    `</task_result>`
+  ].join("\n").replace(/\n{3,}/g, "\n\n");
 }
-async function executeSubagentToolCall(name, args, autoApproveNormal) {
-  if (name === "bash") {
-    let parsed;
-    try {
-      parsed = JSON.parse(args);
-    } catch {
-      parsed = { command: "" };
+
+// src/tools/web_fetch.ts
+var WEB_FETCH_TOOL = {
+  type: "function",
+  function: {
+    name: "web_fetch",
+    description: "Fetch a URL and extract its text content. Supports HTML, plain text and markdown pages. Returns a structured response with headers and extracted content.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The URL to fetch (http or https only)." },
+        extract_mode: {
+          type: "string",
+          enum: ["text", "markdown"],
+          description: "How to extract content from HTML: 'markdown' (default) preserves headings/lists as markdown, 'text' strips all tags."
+        },
+        max_chars: {
+          type: "number",
+          description: "Maximum characters to return (default 20000, max 100000)."
+        },
+        timeout_ms: {
+          type: "number",
+          description: "Request timeout in milliseconds (default 20000, min 1000, max 60000)."
+        }
+      },
+      required: ["url"]
     }
-    return runNonInteractiveBash(parsed.command, autoApproveNormal);
-  }
-  if (name === "read") {
-    return readFile2(JSON.parse(args));
-  }
-  if (name === "write") {
-    return writeFile2(JSON.parse(args));
   }
-  if (name === "edit") {
-    return editFile(JSON.parse(args));
-  }
-  if (name === "glob") {
-    return globFiles(JSON.parse(args));
-  }
-  if (name === "grep") {
-    return grepFiles(JSON.parse(args));
-  }
-  if (name === "apply_patch") {
-    return applyPatch(JSON.parse(args));
-  }
-  if (name === "todo") {
-    return todo(JSON.parse(args));
+};
+var CACHE_TTL = 6e5;
+var CACHE_MAX = 64;
+var cache = /* @__PURE__ */ new Map();
+function cacheGet(key) {
+  const entry = cache.get(key);
+  if (!entry) return void 0;
+  if (Date.now() - entry.at > CACHE_TTL) {
+    cache.delete(key);
+    return void 0;
+  }
+  return entry.result;
+}
+function cacheSet(key, result) {
+  if (cache.size >= CACHE_MAX) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) cache.delete(oldest);
+  }
+  cache.set(key, { at: Date.now(), result });
+}
+function isPrivateHost(hostname) {
+  if (hostname === "localhost" || hostname === "0.0.0.0" || hostname === "::1") return true;
+  if (hostname.endsWith(".local")) return true;
+  const v4 = hostname.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+  if (v4) {
+    const [, a, b] = v4.map(Number);
+    if (a === 127) return true;
+    if (a === 10) return true;
+    if (a === 192 && b === 168) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 0) return true;
   }
-  return `Unknown tool: ${name}`;
+  return false;
 }
-async function runTaskTool(params, deps) {
-  const maxTurns = Math.max(1, Math.min(32, params.max_turns ?? 8));
-  const contextBlock = buildParentContext(deps.parentMessages, params.context);
-  const originalCwd = process.cwd();
-  const childCwd = params.cwd ?? originalCwd;
-  const profile = resolveActiveProfile(deps.config);
-  const llm = deps.llm ?? createProvider({
-    ...profile,
-    model: params.model ?? profile.model
-  });
-  const messages = [{ role: "system", content: SUBAGENT_SYSTEM_PROMPT }];
-  if (contextBlock) {
-    messages.push({
-      role: "user",
-      content: "Parent session context for this delegated task:\n\n" + contextBlock
-    });
-  }
-  messages.push({ role: "user", content: params.prompt });
-  let logger = null;
-  let sessionMeta = null;
-  if (deps.config.logDir) {
-    logger = createLogger(deps.config.logDir, /* @__PURE__ */ new Date());
-    sessionMeta = createSessionMetadata(
-      logger.filePath,
-      params.model ?? profile.model
-    );
-    sessionMeta.title = generateTitle(`[subagent] ${params.description}`);
-    writeSessionMetadata(logger.filePath, sessionMeta);
-  }
-  for (const msg of messages) {
-    appendLog(logger, {
-      role: msg.role,
-      content: "content" in msg ? msg.content : null
-    });
-  }
-  const autoApproveNormal = deps.autoApproveNormal ?? true;
+function validateWebFetchUrl(rawUrl) {
+  let parsed;
   try {
-    process.chdir(childCwd);
-    for (let turn = 0; turn < maxTurns; turn++) {
-      let assistantText = "";
-      let assistantReasoning;
-      const toolCalls = [];
-      for await (const chunk of llm.stream(messages, SUBAGENT_TOOLS)) {
-        if (chunk.text) assistantText += chunk.text;
-        if (chunk.done) {
-          if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
-          if (chunk.reasoning) assistantReasoning = chunk.reasoning;
-        }
-      }
-      if (toolCalls.length === 0) {
-        if (assistantText) {
-          messages.push({
-            role: "assistant",
-            content: assistantText,
-            ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
-          });
-          appendLog(logger, { role: "assistant", content: assistantText });
-        }
-        if (logger) {
-          updateSessionMetadata(logger.filePath, {
-            lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
-            turnCount: turn + 1
-          });
-        }
-        const taskId = sessionMeta?.id ?? "ephemeral";
-        return [
-          `task_id: ${taskId}`,
-          `description: ${params.description}`,
-          `model: ${params.model ?? profile.model}`,
-          logger ? `log_file: ${logger.filePath}` : void 0,
-          "",
-          "<task_result>",
-          assistantText || "(no final text)",
-          "</task_result>"
-        ].filter((line) => line !== void 0).join("\n");
+    parsed = new URL(rawUrl);
+  } catch {
+    return { ok: false, error: `invalid URL: ${rawUrl}` };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return { ok: false, error: `unsupported protocol: ${parsed.protocol}` };
+  }
+  if (parsed.username || parsed.password) {
+    return { ok: false, error: "URL must not contain credentials" };
+  }
+  if (isPrivateHost(parsed.hostname)) {
+    return { ok: false, error: `host is private/local: ${parsed.hostname}` };
+  }
+  return { ok: true, parsed };
+}
+function rootHost(hostname) {
+  const parts = hostname.split(".");
+  return parts.length > 2 ? parts.slice(-2).join(".") : hostname;
+}
+function isSameOrWwwHost(a, b) {
+  if (a === b) return true;
+  const ra = rootHost(a);
+  const rb = rootHost(b);
+  return ra === rb && (a === `www.${ra}` || b === `www.${ra}` || a === ra || b === ra);
+}
+function extractHtmlText(html, mode) {
+  let s = html;
+  s = s.replace(/<script[\s\S]*?<\/script>/gi, "");
+  s = s.replace(/<style[\s\S]*?<\/style>/gi, "");
+  s = s.replace(/<!--[\s\S]*?-->/g, "");
+  if (mode === "markdown") {
+    s = s.replace(/<pre[^>]*>\s*<code[^>]*>([\s\S]*?)<\/code>\s*<\/pre>/gi, (_, code) => {
+      const decoded = decodeEntities(code);
+      return `
+
+\`\`\`
+${decoded}
+\`\`\`
+
+`;
+    });
+    s = s.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, (_, code) => `\`${code}\``);
+    for (let n = 1; n <= 6; n++) {
+      const hashes = "#".repeat(n);
+      s = s.replace(new RegExp(`<h${n}[^>]*>`, "gi"), `
+
+${hashes} `);
+      s = s.replace(new RegExp(`</h${n}>`, "gi"), "\n\n");
+    }
+    s = s.replace(/<li[^>]*>/gi, "\n- ");
+  } else {
+    for (let n = 1; n <= 6; n++) {
+      s = s.replace(new RegExp(`<h${n}[^>]*>`, "gi"), "\n\n");
+      s = s.replace(new RegExp(`</h${n}>`, "gi"), "\n\n");
+    }
+    s = s.replace(/<li[^>]*>/gi, "\n");
+  }
+  s = s.replace(/<\/p>/gi, "\n\n");
+  s = s.replace(/<p[^>]*>/gi, "\n\n");
+  s = s.replace(/<\/div>/gi, "\n");
+  s = s.replace(/<br\s*\/?>/gi, "\n");
+  s = s.replace(/<\/li>/gi, "\n");
+  s = s.replace(/<[^>]+>/g, "");
+  s = decodeEntities(s);
+  s = s.replace(/[ \t]+/g, " ");
+  s = s.replace(/\n{3,}/g, "\n\n");
+  return s.trim();
+}
+function decodeEntities(s) {
+  return s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function statusText(status) {
+  const map = {
+    200: "OK",
+    201: "Created",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    429: "Too Many Requests",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable"
+  };
+  return map[status] ?? String(status);
+}
+async function fetchWithRedirects(url, timeoutMs, signal) {
+  let current = url;
+  let hops = 0;
+  const MAX_REDIRECTS = 5;
+  const originalHost = new URL(url).hostname;
+  while (hops <= MAX_REDIRECTS) {
+    const response = await fetch(current, {
+      redirect: "manual",
+      signal,
+      headers: {
+        Accept: "text/html, text/plain, text/markdown, application/xhtml+xml, */*",
+        "User-Agent": "ecode-web-fetch/0.1"
       }
-      const assistantMsg = {
-        role: "assistant",
-        content: assistantText || null,
-        tool_calls: toolCalls.map((tc) => ({
-          id: tc.id,
-          type: "function",
-          function: { name: tc.name, arguments: tc.arguments }
-        })),
-        ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
-      };
-      messages.push(assistantMsg);
-      appendLog(logger, {
-        role: "assistant",
-        content: assistantText || null,
-        tool_calls: assistantMsg.tool_calls
-      });
-      for (const tc of toolCalls) {
-        const toolResult = await executeSubagentToolCall(tc.name, tc.arguments, autoApproveNormal);
-        const finalResult = toolResult || SKIP_MESSAGE;
-        messages.push({ role: "tool", tool_call_id: tc.id, content: finalResult });
-        appendLog(logger, {
-          role: "tool",
-          content: finalResult,
-          tool_call_id: tc.id
-        });
+    });
+    const status = response.status;
+    if (status >= 300 && status < 400) {
+      const location = response.headers.get("location");
+      if (!location) {
+        return { response, finalUrl: current };
       }
-      if (logger) {
-        updateSessionMetadata(logger.filePath, {
-          lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
-          turnCount: turn + 1
-        });
+      const nextUrl = new URL(location, current).toString();
+      const nextHost = new URL(nextUrl).hostname;
+      if (!isSameOrWwwHost(originalHost, nextHost)) {
+        throw new Error(`redirect to different host is not allowed automatically (-> ${nextUrl})`);
       }
+      current = nextUrl;
+      hops++;
+      continue;
     }
-    return [
-      `description: ${params.description}`,
-      `model: ${params.model ?? profile.model}`,
-      logger ? `log_file: ${logger.filePath}` : void 0,
-      "",
-      "<task_result>",
-      `Subagent stopped after reaching max_turns=${maxTurns} without producing a final answer.`,
-      "</task_result>"
-    ].filter((line) => line !== void 0).join("\n");
+    return { response, finalUrl: current };
+  }
+  throw new Error(`too many redirects (> ${MAX_REDIRECTS})`);
+}
+async function webFetch(params) {
+  const {
+    url,
+    extract_mode = "markdown",
+    max_chars: rawMaxChars = 2e4,
+    timeout_ms: rawTimeout = 2e4
+  } = params;
+  const maxChars = Math.min(Math.max(rawMaxChars, 1), 1e5);
+  const timeoutMs = Math.min(Math.max(rawTimeout, 1e3), 6e4);
+  const validation = validateWebFetchUrl(url);
+  if (!validation.ok) {
+    return `Error fetching ${url}: ${validation.error}`;
+  }
+  const cacheKey = `${url}:${extract_mode}:${maxChars}`;
+  const cached = cacheGet(cacheKey);
+  if (cached !== void 0) return cached;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  let finalUrl;
+  try {
+    ({ response, finalUrl } = await fetchWithRedirects(url, timeoutMs, controller.signal));
   } catch (err) {
+    clearTimeout(timer);
+    if (err instanceof Error && err.name === "AbortError") {
+      return `Error fetching ${url}: request timed out after ${timeoutMs}ms`;
+    }
     const msg = err instanceof Error ? err.message : String(err);
-    return [
-      `description: ${params.description}`,
-      logger ? `log_file: ${logger.filePath}` : void 0,
-      "",
-      "<task_result>",
-      `Subagent failed: ${msg}`,
-      "</task_result>"
-    ].filter((line) => line !== void 0).join("\n");
+    return `Error fetching ${url}: ${msg}`;
   } finally {
-    process.chdir(originalCwd);
+    clearTimeout(timer);
+  }
+  if (response.url) {
+    let resolvedHost;
+    try {
+      resolvedHost = new URL(response.url).hostname;
+    } catch {
+      resolvedHost = validation.parsed.hostname;
+    }
+    if (!isSameOrWwwHost(validation.parsed.hostname, resolvedHost)) {
+      return `Error fetching ${url}: redirect to different host is not allowed automatically (-> ${response.url})`;
+    }
   }
+  const status = response.status;
+  const contentTypeHeader = response.headers.get("content-type") ?? "";
+  const mimeType = contentTypeHeader.split(";")[0].trim().toLowerCase();
+  if (status >= 400) {
+    return `Error fetching ${url}: HTTP ${status} ${statusText(status)}`;
+  }
+  const supportedTypes = ["text/html", "text/plain", "text/markdown", "application/xhtml+xml"];
+  if (mimeType && !supportedTypes.includes(mimeType)) {
+    return `Error fetching ${url}: unsupported content-type ${mimeType}`;
+  }
+  let body;
+  try {
+    body = await response.text();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Error fetching ${url}: failed to read response body: ${msg}`;
+  }
+  let extracted;
+  if (mimeType === "text/plain" || mimeType === "text/markdown") {
+    extracted = body;
+  } else {
+    extracted = extractHtmlText(body, extract_mode);
+  }
+  const truncated = extracted.length > maxChars;
+  const content = truncated ? extracted.slice(0, maxChars) : extracted;
+  const result = [
+    `URL: ${url}`,
+    `Final-URL: ${finalUrl}`,
+    `Status: ${status} ${statusText(status)}`,
+    `Content-Type: ${contentTypeHeader || "(none)"}`,
+    `Bytes: ${body.length}`,
+    `Extract-Mode: ${extract_mode}`,
+    `Truncated: ${truncated ? "yes" : "no"}`,
+    "",
+    "<content>",
+    content,
+    "</content>"
+  ].join("\n");
+  cacheSet(cacheKey, result);
+  return result;
 }
 
 // src/repl.ts
-var SKIP_MESSAGE2 = "Command skipped by user.";
-var BASH_TOOL2 = {
+var SKIP_MESSAGE = "Command skipped by user.";
+var BASH_TOOL = {
   type: "function",
   function: {
     name: "bash",
@@ -1694,16 +1900,16 @@ async function handleBashTool(command, deps) {
     if (!autoApproveNormal) {
       const ok = await confirm(`Execute command: ${command}
 Proceed? (y/n) `);
-      if (!ok) return SKIP_MESSAGE2;
+      if (!ok) return SKIP_MESSAGE;
     }
   } else if (cls === "danger") {
     print(`\u26A0\uFE0F  DANGEROUS COMMAND: ${command}`);
     const first = await confirm("Are you sure? (y/n) ");
-    if (!first) return SKIP_MESSAGE2;
+    if (!first) return SKIP_MESSAGE;
     const second = await confirm(
       "Confirm again \u2014 this is destructive. Continue? (y/n) "
     );
-    if (!second) return SKIP_MESSAGE2;
+    if (!second) return SKIP_MESSAGE;
   }
   const result = await deps.executeBash(command);
   let output = "";
@@ -1730,12 +1936,12 @@ function parseSkillCommand(input) {
 }
 
 // src/skills/handler.ts
-function handleSkillInput(input, registry2) {
+function handleSkillInput(input, registry) {
   if (!isSkillCommand(input)) return { type: "passthrough" };
   const { name, args } = parseSkillCommand(input);
-  const skill = registry2.find(name);
+  const skill = registry.find(name);
   if (!skill) {
-    const available = registry2.list().map((s) => s.name).join(", ") || "none";
+    const available = registry.list().map((s) => s.name).join(", ") || "none";
     return {
       type: "error",
       message: `Unknown skill: /${name}. Available: ${available}`
@@ -1754,7 +1960,7 @@ import { promisify } from "util";
 
 // src/skills/loader.ts
 import { readFile as readFile6, readdir as readdir3, stat as stat3 } from "fs/promises";
-import { join as join6, dirname as dirname4, basename as basename2, resolve as resolve3, sep as sep3 } from "path";
+import { join as join6, dirname as dirname4, basename as basename3, resolve as resolve3, sep as sep3 } from "path";
 function parseFrontmatter(content) {
   const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
   const match = FRONTMATTER_RE.exec(content);
@@ -1827,7 +2033,7 @@ async function loadSkillFile(skillMdPath) {
   const content = await readFile6(skillMdPath, "utf-8");
   const { data, body } = parseFrontmatter(content);
   const skillDir = dirname4(skillMdPath);
-  const dirName = basename2(skillDir);
+  const dirName = basename3(skillDir);
   const [tools, hasPreScript, hasPostScript] = await Promise.all([
     loadTools(skillDir),
     fileExists(join6(skillDir, "pre.sh")),
@@ -2446,7 +2652,7 @@ function dismiss(state) {
 
 // src/ui/fileCompletion.ts
 import * as fs9 from "fs/promises";
-import * as path7 from "path";
+import * as path8 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
 function isHidden(name) {
   return name.startsWith(".");
@@ -2462,17 +2668,17 @@ async function walkDir2(dir, root, results, maxResults) {
   for (const entry of entries) {
     if (results.length >= maxResults) return;
     if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
-    const relPath = path7.relative(root, path7.join(dir, entry.name));
+    const relPath = path8.relative(root, path8.join(dir, entry.name));
     if (entry.isDirectory()) {
       results.push({ path: relPath, isDir: true });
-      await walkDir2(path7.join(dir, entry.name), root, results, maxResults);
+      await walkDir2(path8.join(dir, entry.name), root, results, maxResults);
     } else {
       results.push({ path: relPath, isDir: false });
     }
   }
 }
 async function listFilesForQuery(query, cwd, maxResults = 50) {
-  if (path7.isAbsolute(query)) {
+  if (path8.isAbsolute(query)) {
     return listAbsolute(query, maxResults);
   }
   const all = [];
@@ -2486,12 +2692,12 @@ async function listAbsolute(query, maxResults) {
   try {
     const stat5 = await fs9.stat(dir);
     if (!stat5.isDirectory()) {
-      filter = path7.basename(dir);
-      dir = path7.dirname(dir);
+      filter = path8.basename(dir);
+      dir = path8.dirname(dir);
     }
   } catch {
-    filter = path7.basename(dir);
-    dir = path7.dirname(dir);
+    filter = path8.basename(dir);
+    dir = path8.dirname(dir);
   }
   let entries;
   try {
@@ -2504,7 +2710,7 @@ async function listAbsolute(query, maxResults) {
     if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
     if (filter && !entry.name.includes(filter)) continue;
     results.push({
-      path: path7.join(dir, entry.name),
+      path: path8.join(dir, entry.name),
       isDir: entry.isDirectory()
     });
     if (results.length >= maxResults) break;
@@ -2526,7 +2732,7 @@ async function expandFileRefs(text, cwd) {
   atPattern.lastIndex = 0;
   while ((match = atPattern.exec(text)) !== null) {
     const filePath = match[1];
-    const fullPath = path7.isAbsolute(filePath) ? filePath : path7.join(cwd, filePath);
+    const fullPath = path8.isAbsolute(filePath) ? filePath : path8.join(cwd, filePath);
     let replacement;
     try {
       const content = await fs9.readFile(fullPath, "utf8");
@@ -2648,7 +2854,7 @@ async function removeJob(dataDir, id) {
 }
 
 // src/automation/runtime.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 
 // src/automation/log.ts
 import { readFile as readFile9, appendFile, mkdir as mkdir3 } from "fs/promises";
@@ -2667,7 +2873,7 @@ async function executeJob(job, config2) {
     return null;
   }
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const runId = randomUUID2();
+  const runId = randomUUID3();
   let summaryText;
   let errorMsg;
   let result;
@@ -2874,7 +3080,7 @@ var LoopScheduler = class {
 };
 
 // src/automation/loop/command.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // src/automation/loop/parse.ts
 var DEFAULT_INTERVAL_MS = 6e5;
@@ -2965,7 +3171,7 @@ async function cmdLoop(args, deps) {
   }
   const now = /* @__PURE__ */ new Date();
   const job = {
-    id: randomUUID3(),
+    id: randomUUID4(),
     kind: "loop",
     title: prompt.slice(0, 60),
     createdAt: now.toISOString(),
@@ -3009,7 +3215,7 @@ async function cmdUnloop(idOrPrefix, deps) {
 }
 
 // src/automation/goal/command.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 async function cmdGoal(args, deps) {
   const condition = args.trim();
   if (!condition) {
@@ -3017,7 +3223,7 @@ async function cmdGoal(args, deps) {
   }
   const now = /* @__PURE__ */ new Date();
   const job = {
-    id: randomUUID4(),
+    id: randomUUID5(),
     kind: "goal",
     title: condition.slice(0, 60),
     createdAt: now.toISOString(),
@@ -3271,7 +3477,7 @@ var AutomationManager = class {
 
 // src/meta_skill/index.ts
 import * as fs11 from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 import { fileURLToPath } from "url";
 
 // src/meta_skill/task-classifier.ts
@@ -3982,23 +4188,23 @@ function materialize(policy, profile, input) {
 
 // src/meta_skill/learning-store.ts
 import * as fs10 from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 import * as os from "os";
-var STORE_PATH = path8.resolve(os.homedir(), ".ecode", "learning-records.jsonl");
+var STORE_PATH = path9.resolve(os.homedir(), ".ecode", "learning-records.jsonl");
 
 // src/meta_skill/index.ts
 function resolveBuiltinSkillsDir() {
   try {
-    let dir = path9.dirname(fileURLToPath(import.meta.url));
+    let dir = path10.dirname(fileURLToPath(import.meta.url));
     for (let i = 0; i < 4; i++) {
-      const candidate = path9.join(dir, "skills");
+      const candidate = path10.join(dir, "skills");
       if (fs11.existsSync(candidate) && fs11.statSync(candidate).isDirectory()) {
         const hasSkillContent = fs11.readdirSync(candidate).some(
-          (entry) => fs11.existsSync(path9.join(candidate, entry, "SKILL.md"))
+          (entry) => fs11.existsSync(path10.join(candidate, entry, "SKILL.md"))
         );
         if (hasSkillContent) return candidate;
       }
-      const parent = path9.dirname(dir);
+      const parent = path10.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -4009,16 +4215,16 @@ function resolveBuiltinSkillsDir() {
 function runMetaAlign(input) {
   const taskType = input.task.type && isValidTaskType(input.task.type) ? input.task.type : classifyTask(input.task.goal);
   const inheritedSkills = getBaselineSkills(taskType);
-  const builtinSkillsDir2 = resolveBuiltinSkillsDir();
+  const builtinSkillsDir = resolveBuiltinSkillsDir();
   const allSteps = [];
   for (const skillName of inheritedSkills) {
     const candidates = [];
-    if (builtinSkillsDir2) {
-      candidates.push(path9.join(builtinSkillsDir2, skillName, "SKILL.md"));
-      candidates.push(path9.join(builtinSkillsDir2, skillName + ".md"));
+    if (builtinSkillsDir) {
+      candidates.push(path10.join(builtinSkillsDir, skillName, "SKILL.md"));
+      candidates.push(path10.join(builtinSkillsDir, skillName + ".md"));
     }
-    candidates.push(path9.join(process.cwd(), "skills", skillName, "SKILL.md"));
-    candidates.push(path9.join(process.cwd(), "skills", skillName + ".md"));
+    candidates.push(path10.join(process.cwd(), "skills", skillName, "SKILL.md"));
+    candidates.push(path10.join(process.cwd(), "skills", skillName + ".md"));
     let body = "";
     for (const p of candidates) {
       if (fs11.existsSync(p)) {
@@ -4179,11 +4385,11 @@ function formatMetaAlignOutput(result, model) {
   );
   return lines.join("\n");
 }
-function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, trustedSkillDirs: trustedSkillDirs2 = [], initialMessages: initialMessages2 = [], llmClient }) {
+function App({ config: config2, version: version2, autoMode: autoMode2 = false, registry, trustedSkillDirs = [], initialMessages = [], llmClient }) {
   const { stdout } = useStdout();
   const { stdin } = useStdin();
   const historyMaxHeight = Math.max(5, (stdout?.rows ?? 24) - 4);
-  const [messages, setMessages] = useState3(initialMessages2);
+  const [messages, setMessages] = useState3(initialMessages);
   const [status, setStatus] = useState3("idle");
   const contextLimit = getContextLimit(config2.model, config2.contextLimit);
   const [tokenUsage, setTokenUsage] = useState3({
@@ -4347,7 +4553,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
         return;
       }
     }
-    const skillList = registry2?.list() ?? [];
+    const skillList = registry?.list() ?? [];
     const suggestions = computeSuggestions(skillList, acState);
     const open = isOpen(acState, suggestions);
     if (open) {
@@ -4452,7 +4658,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           function: { name: t.name, description: t.description, parameters: t.parameters }
         }));
         try {
-          for await (const chunk of llmRef.current.stream(currentMessages, [BASH_TOOL2, READ_TOOL, WRITE_TOOL, EDIT_TOOL, GLOB_TOOL, GREP_TOOL, APPLY_PATCH_TOOL, TODO_TOOL, TASK_TOOL, ...dynamicTools], abortController.signal)) {
+          for await (const chunk of llmRef.current.stream(currentMessages, [BASH_TOOL, READ_TOOL, WRITE_TOOL, EDIT_TOOL, GLOB_TOOL, GREP_TOOL, APPLY_PATCH_TOOL, TODO_TOOL, TASK_TOOL, WEB_FETCH_TOOL, ...dynamicTools], abortController.signal)) {
             if (chunk.text) {
               assistantText += chunk.text;
               setMessages((prev) => {
@@ -4555,11 +4761,14 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
               toolResult = todo(args);
             } else if (tc.name === "task") {
               const args = JSON.parse(tc.arguments);
-              toolResult = await runTaskTool(args, {
-                config: config2,
-                parentMessages: currentMessages,
-                autoApproveNormal: autoMode2
+              toolResult = await handleTaskTool(args, {
+                provider: llmRef.current,
+                print: (text) => process.stdout.write(text),
+                logDir: config2.logDir
               });
+            } else if (tc.name === "web_fetch") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await webFetch(args);
             } else {
               const skillTool = skillToolsRef.current.find((t) => t.name === tc.name);
               if (skillTool) {
@@ -4568,7 +4777,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
                   toolArgs = JSON.parse(tc.arguments);
                 } catch {
                 }
-                toolResult = await executeSkillTool(skillTool, toolArgs, trustedSkillDirs2);
+                toolResult = await executeSkillTool(skillTool, toolArgs, trustedSkillDirs);
               } else {
                 toolResult = `Unknown tool: ${tc.name}`;
               }
@@ -4670,8 +4879,8 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           return;
         }
       }
-      if (registry2) {
-        const skillResult = handleSkillInput(trimmed, registry2);
+      if (registry) {
+        const skillResult = handleSkillInput(trimmed, registry);
         if (skillResult.type === "error") {
           setMessages((prev) => [
             ...prev,
@@ -4684,7 +4893,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           setSkillTools(skill.tools);
           if (skill.preScript) {
             try {
-              await executePreScript(skill, trustedSkillDirs2);
+              await executePreScript(skill, trustedSkillDirs);
             } catch (preErr) {
               setMessages((prev) => [
                 ...prev,
@@ -4741,7 +4950,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
       setFileAcState((prev) => handleInputChange2(prev, text));
     }
   }, [status]);
-  const skillSuggestions = registry2 ? computeSuggestions(registry2.list(), acState) : [];
+  const skillSuggestions = registry ? computeSuggestions(registry.list(), acState) : [];
   const acOpen = isOpen(acState, skillSuggestions);
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: "100%", children: [
     /* @__PURE__ */ jsx6(Box6, { flexGrow: 1, flexDirection: "column", justifyContent: "flex-end", children: /* @__PURE__ */ jsx6(
@@ -4876,7 +5085,7 @@ var SkillRegistry = class {
 
 // src/pipe.ts
 var PIPE_SYSTEM_PROMPT = "You are a helpful assistant running in headless pipe mode. You have access to read-only file tools (read, glob, grep). Answer concisely and accurately. Follow the user's requested language, format, and length exactly. Do not reveal chain-of-thought or emit raw <think> / </think> tags in the final answer; if you must refer to them, describe them in plain language instead.";
-var PIPE_TOOLS = [READ_TOOL, GLOB_TOOL, GREP_TOOL];
+var PIPE_TOOLS = [READ_TOOL, GLOB_TOOL, GREP_TOOL, WEB_FETCH_TOOL];
 function emit(out, event) {
   out.write(JSON.stringify(event) + "\n");
 }
@@ -4893,6 +5102,10 @@ async function executeToolCall(name, args) {
     const parsed = JSON.parse(args);
     return grepFiles(parsed);
   }
+  if (name === "web_fetch") {
+    const parsed = JSON.parse(args);
+    return webFetch(parsed);
+  }
   return `Unknown tool: ${name}`;
 }
 async function runPipe(prompt, llm, out = process.stdout, systemPrompt) {
@@ -4963,7 +5176,7 @@ function readStdin() {
 }
 
 // src/sessions/command.ts
-import * as path10 from "path";
+import * as path11 from "path";
 function cmdSessionsList(logDir) {
   const sessions = listSessions(logDir);
   if (sessions.length === 0) return "(no sessions found)";
@@ -4985,13 +5198,13 @@ function cmdSessionsInspect(logDir, idOrPrefix) {
 function cmdSessionsReplay(logDir, idOrPrefix) {
   const session = findSession(logDir, idOrPrefix);
   if (!session) return `Session not found: ${idOrPrefix}`;
-  const logPath = path10.join(logDir, session.logFile);
+  const logPath = path11.join(logDir, session.logFile);
   return `ecode --replay ${logPath}`;
 }
 function cmdSessionsFork(logDir, idOrPrefix, turn) {
   const session = findSession(logDir, idOrPrefix);
   if (!session) return `Session not found: ${idOrPrefix}`;
-  const logPath = path10.join(logDir, session.logFile);
+  const logPath = path11.join(logDir, session.logFile);
   const turnStr = turn !== void 0 ? turn : session.turnCount;
   return `ecode --fork ${logPath}:${turnStr}`;
 }
@@ -5005,15 +5218,777 @@ function formatInspect(session, logDir) {
     `last active:  ${new Date(session.lastActivity).toLocaleString()}`,
     `turns:        ${session.turnCount}`,
     `tokens:       ${session.totalTokens.toLocaleString()}`,
-    `log file:     ${path10.join(logDir, session.logFile)}`
+    `log file:     ${path11.join(logDir, session.logFile)}`
   ].join("\n");
 }
 
+// src/web/server.ts
+import Fastify from "fastify";
+import cors from "@fastify/cors";
+import websocket from "@fastify/websocket";
+
+// src/web/auth.ts
+import { randomUUID as randomUUID6 } from "crypto";
+function generateAccessToken() {
+  return randomUUID6();
+}
+function createAuthHook(token) {
+  return function authHook(request, reply, done) {
+    const incoming = request.headers["x-ecode-token"];
+    if (incoming !== token) {
+      reply.code(401).send({ success: false, error: "Unauthorized" });
+      return;
+    }
+    done();
+  };
+}
+
+// src/web/routes/status.ts
+async function statusRoutes(app, opts) {
+  app.get(
+    "/api/status",
+    async (_request, _reply) => {
+      const runningSessions = opts.manager.listRunning().length;
+      return {
+        version: opts.version,
+        cwd: process.cwd(),
+        model: opts.config.model,
+        logDir: opts.config.logDir,
+        defaultProvider: opts.config.defaultProvider,
+        runningSessions
+      };
+    }
+  );
+}
+
+// src/web/routes/sessions.ts
+import { readFileSync as readFileSync5, existsSync as existsSync4 } from "fs";
+import { join as join13 } from "path";
+async function sessionsRoutes(app, opts) {
+  app.get("/api/sessions", async (_request, reply) => {
+    if (!opts.config.logDir) {
+      return reply.send([]);
+    }
+    return listSessions(opts.config.logDir);
+  });
+  app.get(
+    "/api/sessions/:id/messages",
+    async (request, reply) => {
+      const { id } = request.params;
+      if (!opts.config.logDir) {
+        return reply.code(404).send({ success: false, error: "Log directory not configured" });
+      }
+      const session = findSession(opts.config.logDir, id);
+      if (!session) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+      }
+      const logFilePath2 = join13(opts.config.logDir, session.logFile);
+      if (!existsSync4(logFilePath2)) {
+        return reply.code(404).send({ success: false, error: `Log file not found: ${session.logFile}` });
+      }
+      try {
+        const content = readFileSync5(logFilePath2, "utf-8");
+        return reply.header("Content-Type", "text/plain; charset=utf-8").send(content);
+      } catch (_err) {
+        return reply.code(404).send({ success: false, error: `Log file not found: ${session.logFile}` });
+      }
+    }
+  );
+  app.get(
+    "/api/sessions/:id/replay-command",
+    async (request, reply) => {
+      const { id } = request.params;
+      if (!opts.config.logDir) {
+        return reply.code(404).send({ success: false, error: "Log directory not configured" });
+      }
+      const logDir = opts.config.logDir;
+      const session = findSession(logDir, id);
+      if (!session) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+      }
+      const command = cmdSessionsReplay(logDir, id);
+      return reply.send({ success: true, command });
+    }
+  );
+  app.get(
+    "/api/sessions/:id/fork-command",
+    async (request, reply) => {
+      const { id } = request.params;
+      if (!opts.config.logDir) {
+        return reply.code(404).send({ success: false, error: "Log directory not configured" });
+      }
+      const logDir = opts.config.logDir;
+      const session = findSession(logDir, id);
+      if (!session) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+      }
+      let turn;
+      if (request.query.turn !== void 0) {
+        const parsed = parseInt(request.query.turn, 10);
+        if (isNaN(parsed)) {
+          return reply.code(400).send({ success: false, error: `Invalid turn value: ${request.query.turn}` });
+        }
+        turn = parsed;
+      }
+      const command = cmdSessionsFork(logDir, id, turn);
+      return reply.send({ success: true, command });
+    }
+  );
+}
+
+// src/web/routes/config.ts
+function toSafeConfig(cfg) {
+  const { apiKey: _stripped, ...safe } = cfg;
+  return safe;
+}
+async function configRoutes(app, opts) {
+  app.get("/api/config", async (_request, _reply) => {
+    const { apiKey: _stripped, ...safeConfig } = opts.config;
+    return safeConfig;
+  });
+  app.put(
+    "/api/config",
+    async (request, reply) => {
+      const body = request.body;
+      if (typeof body !== "object" || body === null || Array.isArray(body)) {
+        return reply.status(400).send(toSafeConfig(opts.config));
+      }
+      const merged = { ...opts.config, ...body };
+      opts.save?.(merged);
+      Object.assign(opts.config, merged);
+      return toSafeConfig(merged);
+    }
+  );
+}
+
+// src/web/routes/automation.ts
+async function automationRoutes(app, opts) {
+  app.get(
+    "/api/automation/jobs",
+    async (_request, reply) => {
+      if (!opts.config.logDir) {
+        return reply.send([]);
+      }
+      const jobs = await loadJobs(opts.config.logDir);
+      return jobs;
+    }
+  );
+  app.post(
+    "/api/automation/jobs/:id/pause",
+    async (request, reply) => {
+      const logDir = opts.config.logDir;
+      if (!logDir) {
+        return reply.status(404).send({ error: "logDir not configured" });
+      }
+      const { id } = request.params;
+      const jobs = await loadJobs(logDir);
+      const job = jobs.find((j) => j.id === id);
+      if (!job) {
+        return reply.status(404).send({ error: "job not found" });
+      }
+      if (job.state === "paused") {
+        return reply.status(409).send({ error: "job is already paused" });
+      }
+      const updated = {
+        ...job,
+        state: "paused",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await upsertJob(logDir, updated);
+      return reply.status(200).send({ success: true });
+    }
+  );
+  app.post(
+    "/api/automation/jobs/:id/resume",
+    async (request, reply) => {
+      const logDir = opts.config.logDir;
+      if (!logDir) {
+        return reply.status(404).send({ error: "logDir not configured" });
+      }
+      const { id } = request.params;
+      const jobs = await loadJobs(logDir);
+      const job = jobs.find((j) => j.id === id);
+      if (!job) {
+        return reply.status(404).send({ error: "job not found" });
+      }
+      if (job.state !== "paused") {
+        return reply.status(409).send({ error: "job is not paused" });
+      }
+      const updated = {
+        ...job,
+        state: "scheduled",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await upsertJob(logDir, updated);
+      return reply.status(200).send({ success: true });
+    }
+  );
+  app.delete(
+    "/api/automation/jobs/:id",
+    async (request, reply) => {
+      const logDir = opts.config.logDir;
+      if (!logDir) {
+        return reply.status(404).send({ error: "logDir not configured" });
+      }
+      const { id } = request.params;
+      const removed = await removeJob(logDir, id);
+      if (!removed) {
+        return reply.status(404).send({ error: "job not found" });
+      }
+      return reply.status(200).send({ success: true });
+    }
+  );
+}
+
+// src/web/routes/chat.ts
+var BUSY_STATUSES = /* @__PURE__ */ new Set(["thinking", "tool_calling", "awaiting_confirm"]);
+async function chatRoutes(app, opts) {
+  const { manager } = opts;
+  app.post("/api/chat/sessions", async (request, reply) => {
+    const body = request.body ?? {};
+    const sessionOpts = {};
+    if (typeof body.systemPrompt === "string") {
+      sessionOpts.systemPrompt = body.systemPrompt;
+    }
+    const runtime = await manager.createSession(sessionOpts);
+    return reply.code(201).send({ success: true, session: runtime.snapshot() });
+  });
+  app.post("/api/chat/sessions/:id/submit", async (request, reply) => {
+    const { id } = request.params;
+    const body = request.body ?? {};
+    if (typeof body.message !== "string" || body.message.trim() === "") {
+      return reply.code(400).send({ success: false, error: "message is required and must be a non-empty string" });
+    }
+    const session = manager.getSession(id);
+    if (!session) {
+      return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+    }
+    if (BUSY_STATUSES.has(session.status)) {
+      return reply.code(409).send({ success: false, error: `Session is busy: ${session.status}` });
+    }
+    session.submit(body.message).catch((err) => {
+      app.log.error({ err, sessionId: id }, "submit \u610F\u5916\u5931\u8D25");
+    });
+    return reply.code(202).send({ success: true, queued: true });
+  });
+  app.post(
+    "/api/chat/sessions/:id/interrupt",
+    async (request, reply) => {
+      const { id } = request.params;
+      const session = manager.getSession(id);
+      if (!session) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+      }
+      session.interrupt();
+      return reply.send({ success: true });
+    }
+  );
+  app.post(
+    "/api/chat/sessions/:id/approve",
+    async (request, reply) => {
+      const { id } = request.params;
+      const body = request.body ?? {};
+      if (typeof body.requestId !== "string") {
+        return reply.code(400).send({ success: false, error: "requestId is required and must be a string" });
+      }
+      if (typeof body.approved !== "boolean") {
+        return reply.code(400).send({ success: false, error: "approved is required and must be a boolean" });
+      }
+      const session = manager.getSession(id);
+      if (!session) {
+        return reply.code(404).send({ success: false, error: `Session not found: ${id}` });
+      }
+      if (session.status !== "awaiting_confirm") {
+        return reply.code(409).send({
+          success: false,
+          error: `Session is not awaiting confirmation: ${session.status}`
+        });
+      }
+      session.approve(body.requestId, body.approved);
+      return reply.send({ success: true });
+    }
+  );
+}
+
+// src/web/ws/session-hub.ts
+async function sessionHubRoutes(app, opts) {
+  app.get(
+    "/api/ws/sessions/:id",
+    { websocket: true },
+    (socket, request) => {
+      const { id } = request.params;
+      const session = opts.manager.getSession(id);
+      if (!session) {
+        socket.close(4404, "session not found");
+        return;
+      }
+      const unsubscribe = session.subscribe((event) => {
+        if (socket.readyState === socket.OPEN) {
+          socket.send(JSON.stringify(event));
+        }
+      });
+      socket.on("close", () => {
+        unsubscribe();
+      });
+      socket.on("message", (_msg) => {
+      });
+    }
+  );
+}
+
+// src/web/server.ts
+async function buildServer(opts) {
+  const app = Fastify({ logger: false });
+  await app.register(cors, { origin: true });
+  await app.register(websocket);
+  const authHook = createAuthHook(opts.token);
+  app.addHook("preHandler", function(request, reply, done) {
+    if (request.url === "/health") {
+      done();
+      return;
+    }
+    authHook(request, reply, done);
+  });
+  app.get("/health", async () => ({ ok: true }));
+  await app.register(statusRoutes, {
+    config: opts.config,
+    manager: opts.manager,
+    version: opts.version
+  });
+  await app.register(sessionsRoutes, { config: opts.config });
+  await app.register(configRoutes, { config: opts.config });
+  await app.register(automationRoutes, { config: opts.config });
+  await app.register(chatRoutes, { config: opts.config, manager: opts.manager });
+  await app.register(sessionHubRoutes, { manager: opts.manager });
+  return app;
+}
+
+// src/runtime/events.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Set();
+  /** 发布事件，同步调用所有当前订阅者 */
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  /** 添加事件监听器，返回取消订阅函数 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** 当前订阅者数量（测试用） */
+  get size() {
+    return this.listeners.size;
+  }
+  /** 清除所有订阅者 */
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/runtime/approvals.ts
+var ApprovalQueue = class {
+  pending = /* @__PURE__ */ new Map();
+  /**
+   * 发起一个审批请求，返回 Promise。
+   * 调用方 await 此 Promise，直到 resolve() 被外部调用。
+   */
+  request(kind, prompt) {
+    const id = crypto.randomUUID();
+    const promise = new Promise((resolve6) => {
+      this.pending.set(id, {
+        meta: { id, kind, prompt },
+        resolve: resolve6
+      });
+    });
+    return { id, promise };
+  }
+  /**
+   * 外部（CLI readline / Web API）调用此方法来解决一个待处理请求。
+   * 若 id 不存在则静默忽略。
+   */
+  resolve(id, approved) {
+    const entry = this.pending.get(id);
+    if (!entry) return;
+    this.pending.delete(id);
+    entry.resolve(approved);
+  }
+  /** 获取所有待处理请求的只读视图（Web API 用于 GET 查询） */
+  listPending() {
+    return [...this.pending.values()].map((e) => e.meta);
+  }
+  /** 取消所有待处理请求（中断会话时调用），全部视为拒绝 */
+  cancelAll() {
+    for (const entry of this.pending.values()) {
+      entry.resolve(false);
+    }
+    this.pending.clear();
+  }
+  get size() {
+    return this.pending.size;
+  }
+};
+
+// src/runtime/session.ts
+var SESSION_TOOLS = [
+  BASH_TOOL,
+  READ_TOOL,
+  WRITE_TOOL,
+  EDIT_TOOL,
+  GLOB_TOOL,
+  GREP_TOOL,
+  APPLY_PATCH_TOOL,
+  TODO_TOOL,
+  TASK_TOOL,
+  WEB_FETCH_TOOL
+];
+var SessionRuntime = class {
+  id;
+  _status = "idle";
+  bus = new EventBus();
+  approvals = new ApprovalQueue();
+  llm;
+  messages;
+  config;
+  model;
+  abortController = null;
+  _turnCount = 0;
+  _totalTokens = 0;
+  startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+  title = "New Session";
+  constructor(config2, opts = {}) {
+    this.id = opts.sessionId ?? crypto.randomUUID();
+    this.config = config2;
+    this.llm = opts.llm ?? createProvider(resolveActiveProfile(config2));
+    this.model = config2.model;
+    const systemContent = opts.systemPrompt ?? (config2.systemPrompt ?? DEFAULT_SYSTEM_PROMPT);
+    this.messages = systemContent ? [{ role: "system", content: systemContent }] : [];
+    if (opts.initialMessages) {
+      this.messages.push(...opts.initialMessages);
+    }
+  }
+  get status() {
+    return this._status;
+  }
+  /** 订阅事件流，返回取消订阅函数（调用方负责在不需要时取消以防内存泄漏） */
+  subscribe(listener) {
+    return this.bus.subscribe(listener);
+  }
+  /**
+   * 提交用户输入，驱动一轮完整的 agentic 循环。
+   *
+   * 流程：
+   * 1. 将用户消息写入历史
+   * 2. 启动 AbortController（供 interrupt() 使用）
+   * 3. 运行 agentic 循环直到：纯文本回复 / 中断 / 错误
+   * 4. 更新计数器并发出 session.idle
+   */
+  async submit(userInput) {
+    this.messages.push({ role: "user", content: userInput });
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    try {
+      await this.runAgenticLoop(signal);
+    } catch {
+      if (!signal.aborted) {
+        this._status = "error";
+        this.bus.emit({ type: "session.error", sessionId: this.id, error: "Unexpected error in agentic loop" });
+      }
+      return;
+    } finally {
+      this.abortController = null;
+    }
+    this._turnCount++;
+    this.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    this._status = "idle";
+    this.bus.emit({ type: "session.idle", sessionId: this.id });
+  }
+  /**
+   * agentic 循环：持续调用 LLM 并处理工具调用，直到模型给出纯文本回复。
+   *
+   * 每次迭代：
+   * 1. 调用 LLM 流并实时发出 message.delta 事件
+   * 2. 若收到工具调用 → 执行工具 → 追加历史 → 继续循环
+   * 3. 若无工具调用 → 追加 assistant 消息 → 退出循环
+   */
+  async runAgenticLoop(signal) {
+    while (!signal.aborted) {
+      this._status = "thinking";
+      const messageId = crypto.randomUUID();
+      const uiMsg = {
+        id: messageId,
+        role: "assistant",
+        content: null,
+        toolCalls: [],
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.bus.emit({ type: "message.created", message: uiMsg });
+      let assistantText = "";
+      let assistantReasoning;
+      let lastReasoningDetails;
+      let lastUsage;
+      const toolCalls = [];
+      for await (const chunk of this.llm.stream(this.messages, SESSION_TOOLS, signal)) {
+        if (signal.aborted) break;
+        if (chunk.text) {
+          this.bus.emit({ type: "message.delta", messageId, text: chunk.text });
+          assistantText += chunk.text;
+        }
+        if (chunk.reasoning) {
+          this.bus.emit({ type: "message.reasoning", messageId, text: chunk.reasoning });
+        }
+        if (chunk.done) {
+          if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
+          if (chunk.usage) lastUsage = chunk.usage;
+          if (chunk.reasoning) assistantReasoning = chunk.reasoning;
+          if (chunk.reasoningDetails) lastReasoningDetails = chunk.reasoningDetails;
+        }
+      }
+      if (signal.aborted) break;
+      this.bus.emit({ type: "message.completed", messageId, usage: lastUsage });
+      if (lastUsage) {
+        this._totalTokens += lastUsage.totalTokens;
+      }
+      if (toolCalls.length > 0) {
+        this._status = "tool_calling";
+        this.messages.push({
+          role: "assistant",
+          content: assistantText || null,
+          tool_calls: toolCalls.map((tc) => ({
+            id: tc.id,
+            type: "function",
+            function: { name: tc.name, arguments: tc.arguments }
+          })),
+          ...assistantReasoning ? { reasoning_content: assistantReasoning } : {},
+          ...lastReasoningDetails ? { reasoning_details: lastReasoningDetails } : {}
+        });
+        for (const tc of toolCalls) {
+          if (signal.aborted) break;
+          this.bus.emit({ type: "tool.started", callId: tc.id, toolName: tc.name, argsPreview: tc.arguments });
+          const toolResult = await this.executeToolCall(tc, signal);
+          this.bus.emit({ type: "tool.completed", callId: tc.id, toolName: tc.name, output: toolResult });
+          this.messages.push({ role: "tool", tool_call_id: tc.id, content: toolResult });
+        }
+      } else {
+        if (assistantText) {
+          this.messages.push({
+            role: "assistant",
+            content: assistantText,
+            ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+          });
+        }
+        break;
+      }
+    }
+  }
+  /**
+   * 执行单个工具调用并返回结果字符串。
+   *
+   * bash 工具：先通过 ApprovalQueue 请求用户确认（normal/danger 级别），
+   * 再执行并将 stdout/stderr/exitCode 格式化为字符串返回。
+   * 其他工具：直接执行，不需要审批流程。
+   */
+  async executeToolCall(tc, signal) {
+    const { name, arguments: args } = tc;
+    try {
+      if (name === "bash") {
+        const parsed = JSON.parse(args);
+        const cls = classifyCommand(parsed.command, this.config.dangerousPatterns);
+        if (cls === "normal" || cls === "danger") {
+          this._status = "awaiting_confirm";
+          const kind = cls === "danger" ? "danger" : "normal";
+          const prompt = cls === "danger" ? `\u26A0\uFE0F DANGEROUS COMMAND: ${parsed.command}` : `Execute command: ${parsed.command}
+Proceed?`;
+          const { id: reqId, promise } = this.approvals.request(kind, prompt);
+          this.bus.emit({ type: "approval.requested", requestId: reqId, kind, prompt });
+          const approved = await promise;
+          this._status = "tool_calling";
+          if (!approved) return SKIP_MESSAGE;
+        }
+        if (signal.aborted) return SKIP_MESSAGE;
+        const result = await executeBash(parsed.command);
+        let output = "";
+        if (result.stdout) output += result.stdout;
+        if (result.stderr) output += result.stderr;
+        if (result.exitCode !== 0) output += `
+[exit code: ${result.exitCode}]`;
+        return output || "(no output)";
+      }
+      if (name === "read") {
+        const parsed = JSON.parse(args);
+        return await readFile2(parsed);
+      }
+      if (name === "write") {
+        const parsed = JSON.parse(args);
+        return await writeFile2(parsed);
+      }
+      if (name === "edit") {
+        const parsed = JSON.parse(args);
+        return await editFile(parsed);
+      }
+      if (name === "glob") {
+        const parsed = JSON.parse(args);
+        return await globFiles(parsed);
+      }
+      if (name === "grep") {
+        const parsed = JSON.parse(args);
+        return await grepFiles(parsed);
+      }
+      if (name === "apply_patch") {
+        const parsed = JSON.parse(args);
+        return await applyPatch(parsed);
+      }
+      if (name === "todo") {
+        const parsed = JSON.parse(args);
+        return todo(parsed);
+      }
+      if (name === "task") {
+        const parsed = JSON.parse(args);
+        return await handleTaskTool(parsed, {
+          provider: this.llm,
+          print: () => {
+          },
+          logDir: this.config.logDir
+        });
+      }
+      if (name === "web_fetch") {
+        const parsed = JSON.parse(args);
+        return await webFetch(parsed);
+      }
+      return `Unknown tool: ${name}`;
+    } catch (err) {
+      return `Tool error: ${String(err)}`;
+    }
+  }
+  /**
+   * 中断当前正在进行的生成。
+   *
+   * 通过 AbortController 通知流式生成停止，
+   * 同时取消所有待处理的审批（防止 await promise 永久阻塞）。
+   * 在 idle 状态调用是安全的（无 active controller 时静默忽略中断）。
+   */
+  interrupt() {
+    this.abortController?.abort();
+    this.approvals.cancelAll();
+    this._status = "idle";
+    this.bus.emit({ type: "session.interrupted", sessionId: this.id });
+  }
+  /** 审批或拒绝一个待处理的确认请求（由 Web API 或 CLI readline 调用） */
+  approve(requestId, approved) {
+    this.approvals.resolve(requestId, approved);
+    this.bus.emit({ type: "approval.resolved", requestId, approved });
+  }
+  /** 返回当前会话的只读快照（用于列表展示和 WebSocket 初始状态同步） */
+  snapshot() {
+    return {
+      id: this.id,
+      title: this.title,
+      model: this.model,
+      status: this._status,
+      turnCount: this._turnCount,
+      totalTokens: this._totalTokens,
+      startedAt: this.startedAt,
+      lastActivity: this.lastActivity
+    };
+  }
+};
+
+// src/runtime/manager.ts
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  config;
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 创建新会话，注册到内存 Map 并返回 ISessionRuntime */
+  async createSession(opts = {}) {
+    const runtime = new SessionRuntime(this.config, opts);
+    this.sessions.set(runtime.id, runtime);
+    return runtime;
+  }
+  /**
+   * 按 ID 恢复已有会话。
+   * 当前实现仅从内存 Map 查找；若进程重启后需要恢复，
+   * 可扩展为从 sessions/metadata.ts 加载历史消息重建会话。
+   */
+  async resumeSession(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing) return existing;
+    throw new Error(`Session not found: ${sessionId}`);
+  }
+  /** 按 ID 查找会话，不存在时返回 undefined（不抛错） */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  /** 返回所有活跃会话的快照列表（只读，用于列表展示） */
+  listRunning() {
+    return [...this.sessions.values()].map((s) => s.snapshot());
+  }
+};
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version } = require2("../package.json");
 var VERSION = version;
 var rawArgs = process.argv.slice(2);
+function isHelpFlag(arg) {
+  return arg === "-h" || arg === "--help" || arg === "-help";
+}
+function renderRootHelp() {
+  return `ecode \u2014 terminal + web AI coding assistant
+
+Usage:
+  ecode [options]
+  ecode sessions <subcommand> [args]
+  ecode web [options]
+
+Options:
+  -h, --help, -help         Show help
+  -v, --version             Show version
+  --auto                    Auto-approve normal shell commands
+  --log-dir <dir>           Override JSONL log directory
+  --replay <file>           Replay a session log
+  --fork <file:turn>        Fork a session log at a turn
+  --pipe                    Read prompt from stdin and output JSONL
+
+Commands:
+  sessions                  Inspect, replay, and fork logged sessions
+  web                       Start the web admin server
+
+Run \`ecode sessions -h\` or \`ecode web -h\` for command-specific help.`;
+}
+function renderSessionsHelp() {
+  return `Usage: ecode sessions <list|inspect|replay|fork> [args...]
+
+  list                     \u5217\u51FA\u6240\u6709\u5386\u53F2\u4F1A\u8BDD
+  inspect <id>             \u663E\u793A\u4F1A\u8BDD\u8BE6\u60C5
+  replay  <id>             \u8F93\u51FA\u7528\u4E8E\u56DE\u653E\u7684\u547D\u4EE4
+  fork    <id> [turn]      \u8F93\u51FA\u7528\u4E8E\u5206\u53C9\u5230\u6307\u5B9A\u8F6E\u6B21\u7684\u547D\u4EE4`;
+}
+function renderWebHelp() {
+  return `Usage: ecode web [options]
+
+Options:
+  -h, --help, -help         Show help
+  --host <host>             Bind host (default: 127.0.0.1)
+  --port <port>             Bind port (default: 4310)`;
+}
+if (isHelpFlag(rawArgs[0])) {
+  console.log(renderRootHelp());
+  process.exit(0);
+}
+if (rawArgs[0] === "sessions" && (!rawArgs[1] || isHelpFlag(rawArgs[1]))) {
+  console.log(renderSessionsHelp());
+  process.exit(0);
+}
+if (rawArgs[0] === "web" && isHelpFlag(rawArgs[1])) {
+  console.log(renderWebHelp());
+  process.exit(0);
+}
 var autoMode = false;
 var cliLogDir;
 var replayFile;
@@ -5102,61 +6077,103 @@ if (rawArgs[0] === "sessions") {
   console.log(output);
   process.exit(0);
 }
-if (!finalConfig.apiKey) {
-  console.error(
-    "Error: no API key configured.\nSet ECODE_API_KEY or add apiKey to ~/.ecode/config.json"
-  );
-  process.exit(1);
-}
-var initialMessages = [];
-if (replayFile) {
-  try {
-    const raw = readFileSync5(replayFile, "utf-8");
-    initialMessages = parseReplayLog(raw);
-  } catch (err) {
-    console.error(`Error reading replay file: ${err}`);
-    process.exit(1);
-  }
-} else if (forkSpec) {
-  try {
-    const raw = readFileSync5(forkSpec.file, "utf-8");
-    initialMessages = truncateToTurn(parseReplayLog(raw), forkSpec.turn);
-  } catch (err) {
-    console.error(`Error reading fork file: ${err}`);
-    process.exit(1);
+if (rawArgs[0] === "web") {
+  let webPort = 4310;
+  let webHost = "127.0.0.1";
+  for (let i = 1; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    const next = rawArgs[i + 1];
+    if (arg === "--port" && next && !next.startsWith("-")) {
+      const parsed = parseInt(next, 10);
+      if (!isNaN(parsed)) webPort = parsed;
+      i++;
+    } else if (arg === "--host" && next && !next.startsWith("-")) {
+      webHost = next;
+      i++;
+    }
   }
-}
-var __dirname = dirname9(fileURLToPath2(import.meta.url));
-var builtinSkillsDir = resolve5(__dirname, "../skills");
-var userSkillsDir = resolve5(process.env.HOME ?? "~", ".ecode/skills");
-var projectSkillsDir = resolve5(process.cwd(), ".ecode/skills");
-var registry = new SkillRegistry();
-for (const dir of [builtinSkillsDir, userSkillsDir, projectSkillsDir]) {
-  const skills = await loadSkillsFromDir(dir);
-  for (const skill of skills) registry.register(skill);
-}
-var trustedSkillDirs = [builtinSkillsDir, userSkillsDir, projectSkillsDir];
-if (pipeMode) {
-  const prompt = await readStdin();
-  const llm = createProvider(resolveActiveProfile(finalConfig));
-  await runPipe(prompt, llm);
-  process.exit(0);
-}
-if (process.stdout.isTTY) {
-  process.stdout.write("\x1B[?1049h");
-  const exitAltScreen = () => process.stdout.write("\x1B[?1049l");
-  process.on("exit", exitAltScreen);
-  process.on("SIGINT", () => {
-    exitAltScreen();
-    process.exit(0);
+  const token = generateAccessToken();
+  const manager = new SessionManager(finalConfig);
+  const server = await buildServer({
+    config: finalConfig,
+    manager,
+    token,
+    version: VERSION
   });
-  process.on("SIGTERM", () => {
-    exitAltScreen();
+  await server.listen({ port: webPort, host: webHost });
+  const displayHost = webHost === "0.0.0.0" ? "localhost" : webHost;
+  console.log(`
+ecode web admin started`);
+  console.log(`  URL:   http://${displayHost}:${webPort}`);
+  console.log(`  Token: ${token}`);
+  console.log(`
+Press Ctrl+C to stop.
+`);
+  process.on("SIGINT", async () => {
+    await server.close();
     process.exit(0);
   });
-  process.on("SIGHUP", () => {
-    exitAltScreen();
+  process.on("SIGTERM", async () => {
+    await server.close();
     process.exit(0);
   });
+} else {
+  if (!finalConfig.apiKey) {
+    console.error(
+      "Error: no API key configured.\nSet ECODE_API_KEY or add apiKey to ~/.ecode/config.json"
+    );
+    process.exit(1);
+  }
+  let initialMessages = [];
+  if (replayFile) {
+    try {
+      const raw = readFileSync6(replayFile, "utf-8");
+      initialMessages = parseReplayLog(raw);
+    } catch (err) {
+      console.error(`Error reading replay file: ${err}`);
+      process.exit(1);
+    }
+  } else if (forkSpec) {
+    try {
+      const raw = readFileSync6(forkSpec.file, "utf-8");
+      initialMessages = truncateToTurn(parseReplayLog(raw), forkSpec.turn);
+    } catch (err) {
+      console.error(`Error reading fork file: ${err}`);
+      process.exit(1);
+    }
+  }
+  const __dirname = dirname9(fileURLToPath2(import.meta.url));
+  const builtinSkillsDir = resolve5(__dirname, "../skills");
+  const userSkillsDir = resolve5(process.env.HOME ?? "~", ".ecode/skills");
+  const projectSkillsDir = resolve5(process.cwd(), ".ecode/skills");
+  const registry = new SkillRegistry();
+  for (const dir of [builtinSkillsDir, userSkillsDir, projectSkillsDir]) {
+    const skills = await loadSkillsFromDir(dir);
+    for (const skill of skills) registry.register(skill);
+  }
+  const trustedSkillDirs = [builtinSkillsDir, userSkillsDir, projectSkillsDir];
+  if (pipeMode) {
+    const prompt = await readStdin();
+    const llm = createProvider(resolveActiveProfile(finalConfig));
+    await runPipe(prompt, llm);
+    process.exit(0);
+  }
+  if (process.stdout.isTTY) {
+    process.stdout.write("\x1B[?1049h");
+    const exitAltScreen = () => process.stdout.write("\x1B[?1049l");
+    process.on("exit", exitAltScreen);
+    process.on("SIGINT", () => {
+      exitAltScreen();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      exitAltScreen();
+      process.exit(0);
+    });
+    process.on("SIGHUP", () => {
+      exitAltScreen();
+      process.exit(0);
+    });
+  }
+  render(React4.createElement(App, { config: finalConfig, version: VERSION, autoMode, registry, trustedSkillDirs, initialMessages }));
 }
-render(React4.createElement(App, { config: finalConfig, version: VERSION, autoMode, registry, trustedSkillDirs, initialMessages }));