@zhongqian97-code/ecode 0.5.32 → 0.5.34

package/dist/ui-VPHPVIS5.js

@@ -0,0 +1,2994 @@
+#!/usr/bin/env node
+const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a){if((w?.message??w)?.includes?.('punycode'))return;_ew(w,...a);};
+import {
+  APPLY_PATCH_TOOL,
+  BASH_TOOL,
+  EDIT_TOOL,
+  GLOB_TOOL,
+  GREP_TOOL,
+  READ_TOOL,
+  TASK_TOOL,
+  TODO_TOOL,
+  WEB_FETCH_TOOL,
+  WRITE_TOOL,
+  applyPatch,
+  createLogger,
+  createProvider,
+  editFile,
+  executeBash,
+  globFiles,
+  grepFiles,
+  handleBashTool,
+  handleTaskTool,
+  isTrustedSkillPath,
+  readFile,
+  resolveActiveProfile,
+  todo,
+  webFetch,
+  writeFile
+} from "./chunk-VM35XIBY.js";
+import {
+  loadJobs,
+  removeJob,
+  upsertJob
+} from "./chunk-JG2IGHYY.js";
+import {
+  createSessionMetadata,
+  generateTitle,
+  getContextLimit,
+  updateSessionMetadata,
+  writeSessionMetadata
+} from "./chunk-O4YFKL3N.js";
+
+// src/ui/index.ts
+import { default as default2 } from "react";
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useState as useState3, useCallback, useRef as useRef2, useEffect as useEffect3, useMemo } from "react";
+import { Box as Box6, useInput as useInput2, useStdout, useStdin } from "ink";
+
+// src/skills/resolver.ts
+function isSkillCommand(input) {
+  return input.length > 1 && input.startsWith("/");
+}
+function parseSkillCommand(input) {
+  const withoutSlash = input.slice(1);
+  const spaceIndex = withoutSlash.search(/\s/);
+  if (spaceIndex === -1) {
+    return { name: withoutSlash, args: "" };
+  }
+  const name = withoutSlash.slice(0, spaceIndex);
+  const args = withoutSlash.slice(spaceIndex).trim();
+  return { name, args };
+}
+
+// src/skills/handler.ts
+function handleSkillInput(input, registry) {
+  if (!isSkillCommand(input)) return { type: "passthrough" };
+  const { name, args } = parseSkillCommand(input);
+  const skill = registry.find(name);
+  if (!skill) {
+    const available = registry.list().map((s) => s.name).join(", ") || "none";
+    return {
+      type: "error",
+      message: `Unknown skill: /${name}. Available: ${available}`
+    };
+  }
+  const content = args ? `${skill.body}
+
+${args}` : skill.body;
+  return { type: "skill", message: { role: "user", content }, skill };
+}
+
+// src/skills/executor.ts
+import { exec } from "child_process";
+import { dirname } from "path";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+var SecurityError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SecurityError";
+  }
+};
+async function runScript(scriptPath, args) {
+  const quotedArgs = args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ");
+  const cmd = quotedArgs ? `${scriptPath} ${quotedArgs}` : scriptPath;
+  const { stdout } = await execAsync(cmd);
+  return stdout;
+}
+async function executePreScript(skill, trustedDirs) {
+  if (!skill.preScript) {
+    throw new Error("No pre script configured for this skill");
+  }
+  const skillDir = dirname(skill.source);
+  if (!isTrustedSkillPath(skillDir, trustedDirs)) {
+    throw new SecurityError(
+      `Untrusted skill path: ${skillDir} is not in trusted dirs`
+    );
+  }
+  return runScript(skill.preScript, []);
+}
+async function executeSkillTool(tool, args, trustedDirs) {
+  const scriptDir = dirname(tool.scriptPath);
+  if (!isTrustedSkillPath(scriptDir, trustedDirs)) {
+    throw new SecurityError(
+      `Untrusted tool script path: ${tool.scriptPath}`
+    );
+  }
+  return runScript(tool.scriptPath, [JSON.stringify(args)]);
+}
+
+// src/ui/StatusBar.tsx
+import { useEffect, useState } from "react";
+import { Box, Text } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var SPINNER_INTERVAL_MS = 80;
+function formatTokenCount(n) {
+  if (n < 1e3) return String(n);
+  return (n / 1e3).toFixed(1) + "k";
+}
+function buildStatusLabel(status, toolName, confirmPrompt) {
+  if (confirmPrompt) {
+    return `[y/n] ${confirmPrompt}`;
+  }
+  switch (status) {
+    case "thinking":
+      return "\u601D\u8003\u4E2D";
+    case "tool_calling":
+      return `\u8C03\u7528\u5DE5\u5177: ${toolName ?? ""}`;
+    case "awaiting_confirm":
+      return "\u7B49\u5F85\u786E\u8BA4";
+    case "idle":
+    default:
+      return "\u7B49\u5F85\u8F93\u5165";
+  }
+}
+function statusIcon(status, confirmPrompt) {
+  if (confirmPrompt) return "";
+  switch (status) {
+    case "thinking":
+      return "\u27F3";
+    case "tool_calling":
+      return "\u2699";
+    case "awaiting_confirm":
+    case "idle":
+    default:
+      return "\u25CE";
+  }
+}
+function StatusBar({
+  status,
+  toolName,
+  confirmPrompt,
+  version,
+  tokenUsage
+}) {
+  const [spinnerIdx, setSpinnerIdx] = useState(0);
+  const isAnimating = !confirmPrompt && (status === "thinking" || status === "tool_calling");
+  useEffect(() => {
+    if (!isAnimating) return;
+    const timer = setInterval(() => {
+      setSpinnerIdx((prev) => (prev + 1) % SPINNER_FRAMES.length);
+    }, SPINNER_INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, [isAnimating]);
+  const label = buildStatusLabel(status, toolName, confirmPrompt);
+  const icon = statusIcon(status, confirmPrompt);
+  const spinner = isAnimating ? SPINNER_FRAMES[spinnerIdx] : " ";
+  const usedStr = formatTokenCount(tokenUsage.used);
+  const limitStr = formatTokenCount(tokenUsage.limit);
+  const ctxStr = `ctx: ${tokenUsage.estimated ? "~" : ""}${usedStr}/${limitStr}`;
+  const versionStr = `v${version}`;
+  return (
+    // 外层 Box：行方向布局，justifyContent="space-between" 实现左右分列
+    // 避免用 string.length 手动计算填充（CJK 双宽字符会导致计算偏差）
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          spinner,
+          " "
+        ] }),
+        confirmPrompt ? (
+          // 确认模式：整体用黄色显示，吸引用户注意
+          /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
+            icon,
+            label
+          ] })
+        ) : status === "thinking" || status === "tool_calling" ? (
+          // 进行中状态：图标用绿色（活跃感），标签用白色（可读性）
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: "green", children: [
+              icon,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "white", children: label })
+          ] })
+        ) : (
+          // 空闲 / 等待确认过渡态：整体淡灰，降低视觉权重
+          /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              icon,
+              " "
+            ] }),
+            /* @__PURE__ */ jsx(Text, { color: "gray", children: label })
+          ] })
+        )
+      ] }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          versionStr,
+          "  "
+        ] }),
+        /* @__PURE__ */ jsx(Text, { color: tokenUsage.estimated ? "yellow" : "cyan", children: ctxStr })
+      ] })
+    ] })
+  );
+}
+
+// src/ui/ConversationHistory.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+
+// src/ui/messageLines.ts
+var TOOL_RESULT_MAX_LINES = 3;
+function wrapText(text, terminalWidth) {
+  const logicalLines = text.split("\n");
+  if (terminalWidth <= 0) return logicalLines;
+  const result = [];
+  for (const line of logicalLines) {
+    if (line.length === 0) {
+      result.push("");
+      continue;
+    }
+    for (let i = 0; i < line.length; i += terminalWidth) {
+      result.push(line.slice(i, i + terminalWidth));
+    }
+  }
+  return result;
+}
+function messageToLines(msg, expandTools, terminalWidth) {
+  if (msg.role === "user") {
+    return wrapText(`> ${msg.content}`, terminalWidth).map((text) => ({
+      text,
+      color: "white"
+    }));
+  }
+  if (msg.role === "assistant") {
+    const lines = [];
+    const aMsg = msg;
+    if (aMsg.reasoning_content && aMsg.reasoning_content.length > 0) {
+      if (expandTools) {
+        lines.push({ text: "<thinking>", color: "gray" });
+        for (const t of wrapText(aMsg.reasoning_content, terminalWidth)) {
+          lines.push({ text: t, dimColor: true });
+        }
+      } else {
+        lines.push({ text: "[+ thinking]", color: "gray" });
+      }
+    }
+    if (aMsg.content && aMsg.content.trim().length > 0) {
+      for (const t of wrapText(aMsg.content, terminalWidth)) {
+        lines.push({ text: t, color: "cyan" });
+      }
+    }
+    if (aMsg.tool_calls && aMsg.tool_calls.length > 0) {
+      if (expandTools) {
+        for (const tc of aMsg.tool_calls) {
+          let argsDisplay = tc.function.arguments;
+          try {
+            const parsed = JSON.parse(tc.function.arguments);
+            if (typeof parsed === "object" && parsed !== null) {
+              argsDisplay = Object.values(parsed).map(String).join(", ");
+            }
+          } catch {
+          }
+          const lineText = `\u2699 \u8C03\u7528\u5DE5\u5177: ${tc.function.name}(${argsDisplay})`;
+          for (const t of wrapText(lineText, terminalWidth)) {
+            lines.push({ text: t, color: "yellow" });
+          }
+        }
+      } else {
+        lines.push({
+          text: `[+ ${aMsg.tool_calls.length} \u4E2A\u5DE5\u5177\u8C03\u7528]`,
+          color: "gray"
+        });
+      }
+    }
+    return lines.length > 0 ? lines : [{ text: "" }];
+  }
+  if (msg.role === "tool") {
+    if (!expandTools) {
+      return [{ text: "[+ \u5DE5\u5177\u7ED3\u679C]", color: "gray" }];
+    }
+    const rawLines = msg.content.split("\n");
+    const truncated = rawLines.length > TOOL_RESULT_MAX_LINES ? rawLines.slice(0, TOOL_RESULT_MAX_LINES - 1).join("\n") + "\n\u2026" : msg.content;
+    return [
+      { text: "[\u5DE5\u5177\u7ED3\u679C]", color: "gray" },
+      ...wrapText(truncated, terminalWidth).map((text) => ({
+        text,
+        color: "gray"
+      }))
+    ];
+  }
+  return [];
+}
+
+// src/ui/ConversationHistory.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ConversationHistory({
+  messages,
+  maxHeight = 20,
+  expandTools = false,
+  terminalWidth = 0,
+  scrollOffset = 0
+}) {
+  const visible = messages.filter(
+    (m) => m.role !== "system"
+  );
+  const allLines = visible.flatMap(
+    (msg) => messageToLines(msg, expandTools, terminalWidth)
+  );
+  const totalLines = allLines.length;
+  const end = Math.max(0, Math.min(totalLines, totalLines - scrollOffset));
+  let start = Math.max(0, end - maxHeight);
+  let linesAbove = start;
+  if (linesAbove > 0 && maxHeight > 1) {
+    start = Math.max(0, end - (maxHeight - 1));
+    linesAbove = start;
+  }
+  const visibleLines = allLines.slice(start, end);
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    linesAbove > 0 && /* @__PURE__ */ jsxs2(Text2, { color: "gray", dimColor: true, children: [
+      "\u2191 ",
+      linesAbove,
+      " \u884C \xB7 PageUp/Down \u6EDA\u52A8"
+    ] }),
+    visibleLines.map((line, idx) => /* @__PURE__ */ jsx2(Text2, { color: line.color, dimColor: line.dimColor, children: line.text }, idx))
+  ] });
+}
+
+// src/ui/Input.tsx
+import { useState as useState2, useEffect as useEffect2, useRef, forwardRef, useImperativeHandle } from "react";
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var CURSOR_CHAR = "\u258C";
+var BLINK_INTERVAL_MS = 530;
+function wordBackward(s, pos) {
+  let i = pos;
+  while (i > 0 && s[i - 1] === " ") {
+    i--;
+  }
+  while (i > 0 && s[i - 1] !== " ") {
+    i--;
+  }
+  return i;
+}
+function wordForward(s, pos) {
+  let i = pos;
+  const len = s.length;
+  while (i < len && s[i] !== " ") {
+    i++;
+  }
+  while (i < len && s[i] === " ") {
+    i++;
+  }
+  return i;
+}
+var Input = forwardRef(function Input2({ isActive, onSubmit, onChange, placeholder }, ref) {
+  const [value, setValue] = useState2("");
+  const [cursorPos, setCursorPos] = useState2(0);
+  const [cursorVisible, setCursorVisible] = useState2(true);
+  const valueRef = useRef(value);
+  valueRef.current = value;
+  const cursorPosRef = useRef(cursorPos);
+  cursorPosRef.current = cursorPos;
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  const onSubmitRef = useRef(onSubmit);
+  onSubmitRef.current = onSubmit;
+  useImperativeHandle(ref, () => ({
+    fill(text) {
+      var _a;
+      valueRef.current = text;
+      cursorPosRef.current = text.length;
+      setValue(text);
+      setCursorPos(text.length);
+      (_a = onChangeRef.current) == null ? void 0 : _a.call(onChangeRef, text);
+    }
+  }));
+  useEffect2(() => {
+    if (!isActive) {
+      setCursorVisible(true);
+      return;
+    }
+    const timer = setInterval(() => {
+      setCursorVisible((prev) => !prev);
+    }, BLINK_INTERVAL_MS);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [isActive]);
+  function setValueSync(newValue) {
+    valueRef.current = newValue;
+    setValue(newValue);
+  }
+  function setCursorPosSync(newPos) {
+    cursorPosRef.current = newPos;
+    setCursorPos(newPos);
+  }
+  useInput(
+    (input, key) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      const v = valueRef.current;
+      const pos = cursorPosRef.current;
+      if (key.return && key.shift) {
+        const newValue = v.slice(0, pos) + "\n" + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos + 1);
+        (_a = onChangeRef.current) == null ? void 0 : _a.call(onChangeRef, newValue);
+        return;
+      }
+      if (key.return) {
+        onSubmitRef.current(v);
+        setValueSync("");
+        setCursorPosSync(0);
+        (_b = onChangeRef.current) == null ? void 0 : _b.call(onChangeRef, "");
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (pos === 0) return;
+        const newValue = v.slice(0, pos - 1) + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos - 1);
+        (_c = onChangeRef.current) == null ? void 0 : _c.call(onChangeRef, newValue);
+        return;
+      }
+      if (key.ctrl) {
+        switch (input) {
+          case "a": {
+            setCursorPosSync(0);
+            return;
+          }
+          case "e": {
+            setCursorPosSync(v.length);
+            return;
+          }
+          case "b": {
+            setCursorPosSync(Math.max(0, pos - 1));
+            return;
+          }
+          case "f": {
+            setCursorPosSync(Math.min(v.length, pos + 1));
+            return;
+          }
+          case "k": {
+            const nextNl = v.indexOf("\n", pos);
+            const lineEnd = nextNl === -1 ? v.length : nextNl;
+            const newValue = v.slice(0, pos) + v.slice(lineEnd);
+            setValueSync(newValue);
+            (_d = onChangeRef.current) == null ? void 0 : _d.call(onChangeRef, newValue);
+            return;
+          }
+          case "u": {
+            const newValue = v.slice(pos);
+            setValueSync(newValue);
+            setCursorPosSync(0);
+            (_e = onChangeRef.current) == null ? void 0 : _e.call(onChangeRef, newValue);
+            return;
+          }
+          case "w": {
+            const newPos = wordBackward(v, pos);
+            const newValue = v.slice(0, newPos) + v.slice(pos);
+            setValueSync(newValue);
+            setCursorPosSync(newPos);
+            (_f = onChangeRef.current) == null ? void 0 : _f.call(onChangeRef, newValue);
+            return;
+          }
+          case "d": {
+            if (pos >= v.length) return;
+            const newValue = v.slice(0, pos) + v.slice(pos + 1);
+            setValueSync(newValue);
+            (_g = onChangeRef.current) == null ? void 0 : _g.call(onChangeRef, newValue);
+            return;
+          }
+          default:
+            return;
+        }
+      }
+      if (key.meta) {
+        if (input === "b") {
+          setCursorPosSync(wordBackward(v, pos));
+          return;
+        }
+        if (input === "f") {
+          setCursorPosSync(wordForward(v, pos));
+          return;
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        setCursorPosSync(Math.max(0, pos - 1));
+        return;
+      }
+      if (key.rightArrow) {
+        setCursorPosSync(Math.min(v.length, pos + 1));
+        return;
+      }
+      if (key.escape || key.upArrow || key.downArrow || key.tab || key.pageUp || key.pageDown) {
+        return;
+      }
+      if (input.length > 0) {
+        const newValue = v.slice(0, pos) + input + v.slice(pos);
+        setValueSync(newValue);
+        setCursorPosSync(pos + input.length);
+        (_h = onChangeRef.current) == null ? void 0 : _h.call(onChangeRef, newValue);
+      }
+    },
+    { isActive }
+  );
+  const isEmpty = value === "";
+  const renderLines = () => {
+    if (isEmpty && placeholder) {
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: "> " }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: placeholder }),
+        isActive && cursorVisible && /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
+      ] });
+    }
+    const lines = value.split("\n");
+    let remaining = cursorPos;
+    let cursorLine = 0;
+    let cursorCol = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const lineLen = lines[i].length;
+      if (remaining <= lineLen) {
+        cursorLine = i;
+        cursorCol = remaining;
+        break;
+      }
+      remaining -= lineLen + 1;
+    }
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: lines.map((line, idx) => {
+      const prefix = idx === 0 ? "> " : "  ";
+      const showCursor = isActive && cursorVisible && idx === cursorLine;
+      if (!showCursor) {
+        return /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
+          /* @__PURE__ */ jsx3(Text3, { children: line })
+        ] }, idx);
+      }
+      const before = line.slice(0, cursorCol);
+      const after = line.slice(cursorCol);
+      if (after.length > 0) {
+        return /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
+          /* @__PURE__ */ jsx3(Text3, { children: before }),
+          /* @__PURE__ */ jsx3(Text3, { inverse: true, children: after[0] }),
+          /* @__PURE__ */ jsx3(Text3, { children: after.slice(1) })
+        ] }, idx);
+      }
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: prefix }),
+        /* @__PURE__ */ jsx3(Text3, { children: before }),
+        /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: CURSOR_CHAR })
+      ] }, idx);
+    }) });
+  };
+  return /* @__PURE__ */ jsx3(Box3, { children: isActive ? renderLines() : /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "> " }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: isEmpty ? placeholder ?? "" : value })
+  ] }) });
+});
+var Input_default = Input;
+
+// src/ui/SkillAutocomplete.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function SkillAutocomplete({
+  suggestions,
+  selectedIndex,
+  isOpen: isOpen3
+}) {
+  if (!isOpen3 || suggestions.length === 0) {
+    return /* @__PURE__ */ jsx4(Fragment2, {});
+  }
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", children: suggestions.map((skill, idx) => {
+    const selected = idx === selectedIndex;
+    return /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: selected ? "cyan" : void 0, bold: selected, children: selected ? "> " : "  " }),
+      /* @__PURE__ */ jsxs4(Text4, { color: selected ? "cyan" : void 0, bold: selected, children: [
+        "/",
+        skill.name
+      ] }),
+      /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+        " \u2014 ",
+        skill.description
+      ] })
+    ] }, skill.name);
+  }) });
+}
+
+// src/ui/FileAutocomplete.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment as Fragment3, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function FileAutocomplete({
+  suggestions,
+  selectedIndex,
+  isOpen: isOpen3
+}) {
+  if (!isOpen3 || suggestions.length === 0) {
+    return /* @__PURE__ */ jsx5(Fragment3, {});
+  }
+  return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", children: suggestions.map((entry, idx) => {
+    const selected = idx === selectedIndex;
+    const label = entry.isDir ? entry.path + "/" : entry.path;
+    return /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { color: selected ? "yellow" : void 0, bold: selected, children: selected ? "> " : "  " }),
+      /* @__PURE__ */ jsx5(Text5, { color: selected ? "yellow" : void 0, bold: selected, children: label })
+    ] }, entry.path);
+  }) });
+}
+
+// src/ui/autocompleteLogic.ts
+function getInitialState() {
+  return { query: "", selectedIndex: 0, dismissed: false };
+}
+function computeSuggestions(skills, state, maxSuggestions = 5) {
+  const { query } = state;
+  if (!query.startsWith("/")) return [];
+  const term = query.slice(1).toLowerCase();
+  if (term.includes(" ")) return [];
+  return skills.filter((s) => s.name.toLowerCase().startsWith(term)).slice(0, maxSuggestions);
+}
+function isOpen(state, suggestions) {
+  return state.query.startsWith("/") && suggestions.length > 0 && !state.dismissed;
+}
+function handleInputChange(_state, newQuery) {
+  return { query: newQuery, selectedIndex: 0, dismissed: false };
+}
+function moveUp(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex - 1 + count) % count };
+}
+function moveDown(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex + 1) % count };
+}
+function dismiss(state) {
+  return { ...state, dismissed: true };
+}
+
+// src/ui/fileCompletion.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git"]);
+function isHidden(name) {
+  return name.startsWith(".");
+}
+async function walkDir(dir, root, results, maxResults) {
+  if (results.length >= maxResults) return;
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (results.length >= maxResults) return;
+    if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
+    const relPath = path.relative(root, path.join(dir, entry.name));
+    if (entry.isDirectory()) {
+      results.push({ path: relPath, isDir: true });
+      await walkDir(path.join(dir, entry.name), root, results, maxResults);
+    } else {
+      results.push({ path: relPath, isDir: false });
+    }
+  }
+}
+async function listFilesForQuery(query, cwd, maxResults = 50) {
+  if (path.isAbsolute(query)) {
+    return listAbsolute(query, maxResults);
+  }
+  const all = [];
+  await walkDir(cwd, cwd, all, maxResults * 4);
+  const filtered = query ? all.filter((e) => e.path.includes(query)) : all;
+  return filtered.slice(0, maxResults);
+}
+async function listAbsolute(query, maxResults) {
+  let dir = query;
+  let filter = "";
+  try {
+    const stat2 = await fs.stat(dir);
+    if (!stat2.isDirectory()) {
+      filter = path.basename(dir);
+      dir = path.dirname(dir);
+    }
+  } catch {
+    filter = path.basename(dir);
+    dir = path.dirname(dir);
+  }
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry.name) || isHidden(entry.name)) continue;
+    if (filter && !entry.name.includes(filter)) continue;
+    results.push({
+      path: path.join(dir, entry.name),
+      isDir: entry.isDirectory()
+    });
+    if (results.length >= maxResults) break;
+  }
+  return results;
+}
+function extractAtQuery(text) {
+  const lastAt = text.lastIndexOf("@");
+  if (lastAt === -1) return null;
+  const after = text.slice(lastAt + 1);
+  const spaceIdx = after.indexOf(" ");
+  if (spaceIdx !== -1) return null;
+  return after;
+}
+async function expandFileRefs(text, cwd) {
+  const atPattern = /@([\w./\-]+)/g;
+  const replacements = [];
+  let match;
+  atPattern.lastIndex = 0;
+  while ((match = atPattern.exec(text)) !== null) {
+    const filePath = match[1];
+    const fullPath = path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
+    let replacement;
+    try {
+      const content = await fs.readFile(fullPath, "utf8");
+      replacement = `\`\`\`
+// @${filePath}
+${content}
+\`\`\``;
+    } catch {
+      replacement = `@${filePath} (not found)`;
+    }
+    replacements.push({ start: match.index, end: match.index + match[0].length, replacement });
+  }
+  if (replacements.length === 0) return text;
+  let result = text;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    const { start, end, replacement } = replacements[i];
+    result = result.slice(0, start) + replacement + result.slice(end);
+  }
+  return result;
+}
+
+// src/ui/fileAutocompleteLogic.ts
+function getInitialState2() {
+  return { query: "", selectedIndex: 0, dismissed: false };
+}
+function handleInputChange2(_state, newText) {
+  return { query: newText, selectedIndex: 0, dismissed: false };
+}
+function isOpen2(state, suggestions) {
+  if (state.dismissed) return false;
+  if (suggestions.length === 0) return false;
+  return extractAtQuery(state.query) !== null;
+}
+function moveUp2(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex - 1 + count) % count };
+}
+function moveDown2(state, count) {
+  return { ...state, selectedIndex: (state.selectedIndex + 1) % count };
+}
+function dismiss2(state) {
+  return { ...state, dismissed: true };
+}
+function confirmSelection(inputText, selectedPath) {
+  const lastAt = inputText.lastIndexOf("@");
+  if (lastAt === -1) return inputText;
+  const prefix = inputText.slice(0, lastAt);
+  return `${prefix}@${selectedPath} `;
+}
+
+// src/ui/mouseInput.ts
+var SGR_MOUSE_RE = /^\x1b\[<(\d+);\d+;\d+[Mm]/;
+function mouseEventLength(data) {
+  const s = typeof data === "string" ? data : data.toString("binary");
+  if (!s) return 0;
+  const sgrMatch = SGR_MOUSE_RE.exec(s);
+  if (sgrMatch) return sgrMatch[0].length;
+  if (s.length >= 6 && s.charCodeAt(0) === 27 && s[1] === "[" && s[2] === "M") return 6;
+  return 0;
+}
+function parseMouseScroll(data) {
+  const s = typeof data === "string" ? data : data.toString("binary");
+  if (!s) return null;
+  const sgrMatch = SGR_MOUSE_RE.exec(s);
+  if (sgrMatch) {
+    const cb = parseInt(sgrMatch[1], 10);
+    if (cb === 64) return { direction: "up" };
+    if (cb === 65) return { direction: "down" };
+    return null;
+  }
+  if (s.length >= 6 && s.charCodeAt(0) === 27 && s[1] === "[" && s[2] === "M") {
+    const buttonByte = s.charCodeAt(3);
+    if (buttonByte === 96) return { direction: "up" };
+    if (buttonByte === 97) return { direction: "down" };
+    return null;
+  }
+  return null;
+}
+
+// src/ui/App.tsx
+import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+
+// src/automation/runtime.ts
+import { randomUUID } from "crypto";
+
+// src/automation/log.ts
+import { readFile as readFile3, appendFile, mkdir } from "fs/promises";
+import { join as join2 } from "path";
+function logFilePath(logDir) {
+  return join2(logDir, "automation-runs.jsonl");
+}
+async function appendRunLog(logDir, entry) {
+  await mkdir(logDir, { recursive: true });
+  await appendFile(logFilePath(logDir), JSON.stringify(entry) + "\n", "utf-8");
+}
+
+// src/automation/runtime.ts
+async function executeJob(job, config) {
+  var _a;
+  if (((_a = job.budget) == null ? void 0 : _a.maxTurns) !== void 0 && job.runCount >= job.budget.maxTurns) {
+    return null;
+  }
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const runId = randomUUID();
+  let summaryText;
+  let errorMsg;
+  let result;
+  try {
+    summaryText = await config.session.run(job.promptTemplate);
+    result = "success";
+  } catch (err) {
+    errorMsg = err instanceof Error ? err.message : String(err);
+    result = "failure";
+  }
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    id: runId,
+    jobId: job.id,
+    startedAt,
+    finishedAt,
+    promptUsed: job.promptTemplate,
+    result,
+    summaryText,
+    error: errorMsg
+  };
+  await appendRunLog(config.logDir, entry);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedJob = {
+    ...job,
+    runCount: job.runCount + 1,
+    failureCount: result === "failure" ? job.failureCount + 1 : job.failureCount,
+    lastRunAt: finishedAt,
+    lastError: errorMsg,
+    updatedAt: now
+  };
+  await upsertJob(config.dataDir, updatedJob);
+  return entry;
+}
+
+// src/automation/goal/evaluator.ts
+function parseVerdict(response) {
+  const scan = (text) => {
+    if (/\bnot_done\b/.test(text)) return "not_done";
+    if (/\bblocked\b/.test(text) && !/\bnot\s+blocked\b/.test(text)) return "blocked";
+    if (/\bdone\b/.test(text) && !/\bnot\s+done\b/.test(text)) return "done";
+    return null;
+  };
+  const firstLine = (response.split("\n")[0] ?? "").trim().toLowerCase();
+  const fromFirstLine = scan(firstLine);
+  if (fromFirstLine !== null) return fromFirstLine;
+  const fromFull = scan(response.toLowerCase());
+  return fromFull ?? "not_done";
+}
+function buildPrompt(input) {
+  return [
+    "You are evaluating whether a goal condition has been met based on a work transcript.",
+    "",
+    `Goal condition: ${input.condition}`,
+    "",
+    "Work transcript:",
+    input.transcript,
+    "",
+    'Reply with one of these verdicts: "done", "not_done", or "blocked".',
+    '"done" means the condition is satisfied.',
+    '"not_done" means the condition is not yet satisfied but work can continue.',
+    '"blocked" means progress is impossible due to an error or blocker.',
+    "After the verdict, explain your reasoning briefly."
+  ].join("\n");
+}
+function createLLMEvaluator(session) {
+  return {
+    async evaluate(input) {
+      try {
+        const prompt = buildPrompt(input);
+        const response = await session.run(prompt);
+        const verdict = parseVerdict(response);
+        return { verdict, reason: response };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { verdict: "blocked", reason: message };
+      }
+    }
+  };
+}
+
+// src/automation/loop/scheduler.ts
+var LoopScheduler = class {
+  options;
+  /** 按 jobId 索引的调度表 */
+  entries = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 初始化调度器，传入初始 job 列表
+   * 每个 job 会被立即纳入调度
+   */
+  start(jobs) {
+    for (const job of jobs) {
+      this.scheduleJob(job);
+    }
+  }
+  /**
+   * 停止所有调度，清除全部挂起的 timer
+   */
+  stop() {
+    for (const entry of this.entries.values()) {
+      if (entry.timerId !== void 0) {
+        clearTimeout(entry.timerId);
+        entry.timerId = void 0;
+      }
+    }
+    this.entries.clear();
+  }
+  /**
+   * 动态添加一个新 job 并立即纳入调度
+   */
+  add(job) {
+    const existing = this.entries.get(job.id);
+    if ((existing == null ? void 0 : existing.timerId) !== void 0) {
+      clearTimeout(existing.timerId);
+    }
+    this.scheduleJob(job);
+  }
+  /**
+   * 按 id 移除 job 并取消其挂起的 timer
+   * id 不存在时静默忽略，不抛出异常
+   */
+  remove(id) {
+    const entry = this.entries.get(id);
+    if (entry === void 0) return;
+    if (entry.timerId !== void 0) {
+      clearTimeout(entry.timerId);
+    }
+    this.entries.delete(id);
+  }
+  /**
+   * 获取指定 job 的下次运行时间（ISO 字符串）
+   * job 不存在时返回 undefined
+   */
+  getNextRunAt(jobId) {
+    const entry = this.entries.get(jobId);
+    if (entry === void 0) return void 0;
+    return new Date(entry.nextRunAtMs).toISOString();
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 私有方法
+  // ──────────────────────────────────────────────────────────────
+  /**
+   * 将 job 纳入调度：
+   * 1. 计算第一次触发的延迟
+   * 2. 若 nextRunAt 已过期，快速推进到下一个未来时间（不补跑）
+   * 3. 挂起 setTimeout
+   */
+  scheduleJob(job) {
+    const now = Date.now();
+    let nextRunAtMs = new Date(job.nextRunAt).getTime();
+    if (nextRunAtMs <= now) {
+      const { intervalMs } = job;
+      nextRunAtMs += intervalMs;
+      while (nextRunAtMs <= now) {
+        nextRunAtMs += intervalMs;
+      }
+    }
+    const entry = {
+      job,
+      nextRunAtMs,
+      timerId: void 0
+    };
+    this.entries.set(job.id, entry);
+    this.arm(entry);
+  }
+  /**
+   * 为 entry 挂起一个 setTimeout，延迟到 entry.nextRunAtMs
+   */
+  arm(entry) {
+    const delay = Math.max(0, entry.nextRunAtMs - Date.now());
+    entry.timerId = setTimeout(() => {
+      void this.fire(entry);
+    }, delay);
+  }
+  /**
+   * job 到期时的触发逻辑：
+   * 1. 检查 TTL，若已过期则不执行、不重新调度
+   * 2. 调用 onJobRun；失败时调用 onJobError
+   * 3. 无论成功失败，均重新调度下一次（TTL 由下次触发时再判断）
+   */
+  async fire(entry) {
+    const { job } = entry;
+    const now = Date.now();
+    if (job.ttlMs !== void 0) {
+      const expiresAt = new Date(job.createdAt).getTime() + job.ttlMs;
+      if (now >= expiresAt) {
+        this.entries.delete(job.id);
+        return;
+      }
+    }
+    try {
+      await this.options.onJobRun(job);
+    } catch (error) {
+      this.options.onJobError(job, error);
+    }
+    const current = this.entries.get(job.id);
+    if (current === void 0) return;
+    current.nextRunAtMs = Date.now() + job.intervalMs;
+    this.arm(current);
+  }
+};
+
+// src/automation/loop/command.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/automation/loop/parse.ts
+var DEFAULT_INTERVAL_MS = 6e5;
+var MIN_INTERVAL_MS = 3e4;
+var UNIT_MS = {
+  s: 1e3,
+  m: 6e4,
+  h: 36e5
+};
+var TIME_TOKEN_RE = /(\d+)\s*([smh])/gi;
+function parseInterval(input) {
+  if (input == null) return { intervalMs: DEFAULT_INTERVAL_MS };
+  const trimmed = input.trim();
+  if (trimmed === "") return { intervalMs: DEFAULT_INTERVAL_MS };
+  if (trimmed.startsWith("-")) return null;
+  const normalized = trimmed.replace(/^every\s+/i, "");
+  if (/^\d+$/.test(normalized)) {
+    const ms = parseInt(normalized, 10) * 1e3;
+    return ms > 0 && ms >= MIN_INTERVAL_MS ? { intervalMs: ms } : null;
+  }
+  if (!/^(\d+\s*[smh])+$/i.test(normalized)) return null;
+  let totalMs = 0;
+  let matchCount = 0;
+  TIME_TOKEN_RE.lastIndex = 0;
+  let match;
+  while ((match = TIME_TOKEN_RE.exec(normalized)) !== null) {
+    const value = parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+    totalMs += value * UNIT_MS[unit];
+    matchCount++;
+  }
+  if (matchCount === 0) return null;
+  if (totalMs <= 0 || totalMs < MIN_INTERVAL_MS) return null;
+  return { intervalMs: totalMs };
+}
+
+// src/automation/loop/command.ts
+function formatInterval(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  if (h > 0 && m === 0 && s === 0) return `${h}h`;
+  if (h > 0 && s === 0) return `${h}h${m}m`;
+  if (h > 0) return `${h}h${m}m${s}s`;
+  if (m > 0 && s === 0) return `${m}m`;
+  if (m > 0) return `${m}m${s}s`;
+  return `${s}s`;
+}
+async function cmdLoop(args, deps) {
+  const trimmed = args.trim();
+  let intervalMs = DEFAULT_INTERVAL_MS;
+  let prompt = trimmed;
+  const spaceIdx = trimmed.indexOf(" ");
+  if (spaceIdx !== -1) {
+    const firstToken = trimmed.slice(0, spaceIdx);
+    const rest = trimmed.slice(spaceIdx + 1);
+    const parsed1 = parseInterval(firstToken);
+    if (parsed1 !== null) {
+      intervalMs = parsed1.intervalMs;
+      prompt = rest.trim();
+    } else {
+      const secondSpaceIdx = rest.indexOf(" ");
+      if (secondSpaceIdx !== -1) {
+        const twoToken = `${firstToken} ${rest.slice(0, secondSpaceIdx)}`;
+        const parsed2 = parseInterval(twoToken);
+        if (parsed2 !== null) {
+          intervalMs = parsed2.intervalMs;
+          prompt = rest.slice(secondSpaceIdx + 1).trim();
+        }
+      } else {
+        const parsed2 = parseInterval(`${firstToken} ${rest}`);
+        if (parsed2 !== null) {
+          intervalMs = parsed2.intervalMs;
+          prompt = "";
+        }
+      }
+    }
+  } else {
+    const parsed = parseInterval(trimmed);
+    if (parsed !== null) {
+      intervalMs = parsed.intervalMs;
+      prompt = "";
+    }
+  }
+  if (!prompt.trim()) {
+    return "\u7528\u6CD5\uFF1A/loop [interval] <prompt>\uFF0C\u4F8B\u5982\uFF1A/loop 10m \u68C0\u67E5 deploy \u72B6\u6001";
+  }
+  const now = /* @__PURE__ */ new Date();
+  const job = {
+    id: randomUUID2(),
+    kind: "loop",
+    title: prompt.slice(0, 60),
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    state: "scheduled",
+    promptTemplate: prompt,
+    intervalMs,
+    nextRunAt: new Date(now.getTime() + intervalMs).toISOString(),
+    autoRunNow: false,
+    runCount: 0,
+    failureCount: 0
+  };
+  await upsertJob(deps.dataDir, job);
+  deps.onSchedule(job);
+  return `\u5DF2\u521B\u5EFA loop job [${job.id.slice(0, 8)}]\uFF0C\u6BCF ${formatInterval(intervalMs)} \u6267\u884C\u4E00\u6B21\uFF1A${prompt}`;
+}
+async function cmdJobs(deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  if (jobs.length === 0) {
+    return "\u6682\u65E0 automation job\u3002\u4F7F\u7528 /loop <interval> <prompt> \u521B\u5EFA\u4E00\u4E2A\u3002";
+  }
+  const lines = jobs.map((j) => {
+    const interval = j.kind === "loop" ? formatInterval(j.intervalMs) : "\u2014";
+    const idPrefix = j.id.slice(0, 8);
+    return `[${idPrefix}] ${interval}  ${j.promptTemplate}  (${j.state})`;
+  });
+  return `\u5F53\u524D job \u5217\u8868\uFF08\u5171 ${jobs.length} \u4E2A\uFF09\uFF1A
+${lines.join("\n")}`;
+}
+async function cmdUnloop(idOrPrefix, deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  const target = jobs.find(
+    (j) => j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
+  );
+  if (target === void 0) {
+    return `\u627E\u4E0D\u5230 job "${idOrPrefix}"\uFF0C\u8BF7\u7528 /jobs \u786E\u8BA4 id\u3002`;
+  }
+  await removeJob(deps.dataDir, target.id);
+  deps.onUnschedule(target.id);
+  return `\u5DF2\u53D6\u6D88 loop job [${target.id.slice(0, 8)}]\uFF1A${target.promptTemplate}`;
+}
+
+// src/automation/goal/command.ts
+import { randomUUID as randomUUID3 } from "crypto";
+async function cmdGoal(args, deps) {
+  const condition = args.trim();
+  if (!condition) {
+    return "\u7528\u6CD5\uFF1A/goal <\u76EE\u6807\u6761\u4EF6>\uFF0C\u4F8B\u5982\uFF1A/goal \u6240\u6709\u6D4B\u8BD5\u901A\u8FC7";
+  }
+  const now = /* @__PURE__ */ new Date();
+  const job = {
+    id: randomUUID3(),
+    kind: "goal",
+    title: condition.slice(0, 60),
+    createdAt: now.toISOString(),
+    updatedAt: now.toISOString(),
+    state: "scheduled",
+    promptTemplate: condition,
+    condition,
+    activeTurnCount: 0,
+    runCount: 0,
+    failureCount: 0,
+    // 快照字段：仅在调用方提供时写入，旧格式兼容（undefined 即不存在）
+    snapshotLogFile: deps.snapshotLogFile,
+    snapshotTurn: deps.snapshotTurn
+  };
+  await upsertJob(deps.dataDir, job);
+  deps.onSchedule(job);
+  return `\u5DF2\u521B\u5EFA goal job [${job.id.slice(0, 8)}]\uFF0C\u76EE\u6807\u6761\u4EF6\uFF1A${condition}`;
+}
+async function cmdUngoal(idOrPrefix, deps) {
+  const jobs = await loadJobs(deps.dataDir);
+  const target = jobs.find(
+    (j) => j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
+  );
+  if (target === void 0) {
+    return `\u627E\u4E0D\u5230 job "${idOrPrefix}"\uFF0C\u8BF7\u7528 /jobs \u786E\u8BA4 id\u3002`;
+  }
+  await removeJob(deps.dataDir, target.id);
+  deps.onUnschedule(target.id);
+  return `\u5DF2\u53D6\u6D88 goal job [${target.id.slice(0, 8)}]\uFF1A${target.promptTemplate}`;
+}
+
+// src/automation/goal/rollback.ts
+function buildRollbackMessage(job) {
+  if (job.snapshotLogFile === void 0 || job.snapshotTurn === void 0) {
+    return "";
+  }
+  return `
+
+\u4E0A\u4E0B\u6587\u53EF\u80FD\u5DF2\u504F\u79BB\u76EE\u6807\uFF0C\u56DE\u6EDA\u5230\u76EE\u6807\u521B\u5EFA\u524D\u7684\u4F4D\u7F6E\uFF1A
+ecode --fork ${job.snapshotLogFile}:${job.snapshotTurn}`;
+}
+
+// src/automation/index.ts
+var AutomationManager = class {
+  constructor(config) {
+    this.config = config;
+    this.scheduler = new LoopScheduler({
+      onJobRun: async (job) => {
+        var _a;
+        const entry = await executeJob(job, {
+          dataDir: config.dataDir,
+          logDir: config.logDir,
+          session: this.createSession()
+        });
+        if (entry) {
+          const status = entry.result === "success" ? "\u2713" : "\u2717";
+          const summary = entry.summaryText ?? entry.error ?? "";
+          (_a = config.onJobResult) == null ? void 0 : _a.call(
+            config,
+            job.id,
+            `[loop ${job.id.slice(0, 8)}] ${status} ${summary}`.trim()
+          );
+        }
+      },
+      onJobError: (job, error) => {
+        var _a;
+        const msg = error instanceof Error ? error.message : String(error);
+        (_a = config.onJobResult) == null ? void 0 : _a.call(config, job.id, `[loop ${job.id.slice(0, 8)}] \u6267\u884C\u9519\u8BEF\uFF1A${msg}`);
+      }
+    });
+  }
+  config;
+  scheduler;
+  /** 按 jobId 索引的 goal runner AbortController */
+  goalRunners = /* @__PURE__ */ new Map();
+  /**
+   * 从持久化存储加载所有 job，启动调度器并恢复 goal runner。
+   * 应在应用启动时调用一次。
+   */
+  async start() {
+    const jobs = await loadJobs(this.config.dataDir);
+    const loopJobs = jobs.filter((j) => j.kind === "loop");
+    const goalJobs = jobs.filter(
+      (j) => j.kind === "goal" && j.state === "scheduled"
+    );
+    this.scheduler.start(loopJobs);
+    for (const job of goalJobs) {
+      this.startGoalRunner(job);
+    }
+  }
+  /**
+   * 停止所有调度：清除 loop timer，中止所有 goal runner。
+   * 应在应用退出时调用。
+   */
+  stop() {
+    this.scheduler.stop();
+    for (const [, controller] of this.goalRunners) {
+      controller.abort();
+    }
+    this.goalRunners.clear();
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 命令处理器（转发到 loop/goal 子模块）
+  // ──────────────────────────────────────────────────────────────
+  async cmdLoop(args) {
+    return cmdLoop(args, {
+      dataDir: this.config.dataDir,
+      onSchedule: (job) => this.scheduler.add(job),
+      onUnschedule: (id) => this.scheduler.remove(id)
+    });
+  }
+  /**
+   * 处理 /goal 命令，可选接收当前会话上下文以支持 blocked 时的自动回滚提示。
+   * sessionContext 由 App.tsx 在用户提交 /goal 时注入（logFile + turnCount）。
+   */
+  async cmdGoal(args, sessionContext) {
+    return cmdGoal(args, {
+      dataDir: this.config.dataDir,
+      snapshotLogFile: sessionContext == null ? void 0 : sessionContext.logFile,
+      snapshotTurn: sessionContext == null ? void 0 : sessionContext.turnCount,
+      onSchedule: (job) => this.startGoalRunner(job),
+      onUnschedule: (id) => this.stopGoalRunner(id)
+    });
+  }
+  async cmdJobs() {
+    return cmdJobs({
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: () => {
+      }
+    });
+  }
+  async cmdUnloop(id) {
+    return cmdUnloop(id, {
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: (jobId) => this.scheduler.remove(jobId)
+    });
+  }
+  async cmdUngoal(id) {
+    return cmdUngoal(id, {
+      dataDir: this.config.dataDir,
+      onSchedule: () => {
+      },
+      onUnschedule: (jobId) => this.stopGoalRunner(jobId)
+    });
+  }
+  // ──────────────────────────────────────────────────────────────
+  // 私有辅助方法
+  // ──────────────────────────────────────────────────────────────
+  /**
+   * 从 ProviderClient 构建 RuntimeSessionHandle。
+   * 将流式 chunk 拼接为完整字符串返回给调用方。
+   */
+  createSession() {
+    const { llmClient } = this.config;
+    return {
+      run: async (prompt) => {
+        let text = "";
+        const msgs = [{ role: "user", content: prompt }];
+        for await (const chunk of llmClient.stream(msgs, [], void 0)) {
+          if (chunk.text) text += chunk.text;
+        }
+        return text;
+      }
+    };
+  }
+  /** 启动 goal job 的执行协程（可被 AbortController 中断） */
+  startGoalRunner(job) {
+    this.stopGoalRunner(job.id);
+    const ac = new AbortController();
+    this.goalRunners.set(job.id, ac);
+    void this.runGoalLoop(job, ac.signal);
+  }
+  /** 中止指定 goal runner */
+  stopGoalRunner(jobId) {
+    const ac = this.goalRunners.get(jobId);
+    if (ac) {
+      ac.abort();
+      this.goalRunners.delete(jobId);
+    }
+  }
+  /**
+   * Goal job 执行循环：
+   * 1. 调用 executeJob（LLM worker 执行一轮）
+   * 2. 用 LLM 评估器判断条件是否满足
+   * 3. done → 标记 completed；blocked → 标记 error；not_done → 等待 5s 后继续
+   * 4. AbortSignal 触发时立即退出
+   */
+  async runGoalLoop(initialJob, signal) {
+    var _a, _b, _c, _d, _e, _f;
+    let job = initialJob;
+    while (!signal.aborted) {
+      const runtimeConfig = {
+        dataDir: this.config.dataDir,
+        logDir: this.config.logDir,
+        session: this.createSession()
+      };
+      const entry = await executeJob(job, runtimeConfig);
+      if (!entry) break;
+      if (signal.aborted) break;
+      const evaluator = createLLMEvaluator(this.createSession());
+      const evaluation = await evaluator.evaluate({
+        condition: job.condition,
+        transcript: entry.summaryText ?? entry.error ?? ""
+      });
+      const updatedJob = {
+        ...job,
+        lastEvaluation: evaluation,
+        activeTurnCount: job.activeTurnCount + 1,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (evaluation.verdict === "done") {
+        const completedJob = {
+          ...updatedJob,
+          state: "completed",
+          achievedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        await upsertJob(this.config.dataDir, completedJob);
+        (_b = (_a = this.config).onJobResult) == null ? void 0 : _b.call(
+          _a,
+          job.id,
+          `[goal ${job.id.slice(0, 8)}] \u76EE\u6807\u5DF2\u8FBE\u6210\uFF1A${evaluation.reason}`
+        );
+        break;
+      }
+      if (evaluation.verdict === "blocked") {
+        const errorJob = { ...updatedJob, state: "error" };
+        await upsertJob(this.config.dataDir, errorJob);
+        const rollback = buildRollbackMessage(errorJob);
+        (_d = (_c = this.config).onJobResult) == null ? void 0 : _d.call(
+          _c,
+          job.id,
+          `[goal ${job.id.slice(0, 8)}] \u6267\u884C\u53D7\u963B\uFF1A${evaluation.reason}${rollback}`
+        );
+        break;
+      }
+      await upsertJob(this.config.dataDir, updatedJob);
+      job = updatedJob;
+      (_f = (_e = this.config).onJobResult) == null ? void 0 : _f.call(
+        _e,
+        job.id,
+        `[goal ${job.id.slice(0, 8)}] \u7B2C ${job.activeTurnCount} \u8F6E\uFF1A\u5C1A\u672A\u5B8C\u6210\uFF0C\u7EE7\u7EED\u6267\u884C\u2026`
+      );
+      await new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, 5e3);
+        signal.addEventListener("abort", () => {
+          clearTimeout(timer);
+          resolve2();
+        }, { once: true });
+      });
+    }
+    this.goalRunners.delete(job.id);
+  }
+};
+
+// src/meta_skill/index.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/meta_skill/task-classifier.ts
+var RULES = {
+  bugfix: [
+    { pattern: /(?<!\w)(bug|fix|修复|修bug|defect|error|crash|exception|broken|fails?|失败|报错|崩溃|异常|问题|故障|incorrect|wrong|不对|不正确)(?!\w)/i, weight: 3 },
+    { pattern: /(?<!\w)(debug|diagnose|诊断|定位|追踪|trace|reproduce|复现)(?!\w)/i, weight: 2 },
+    { pattern: /(?<!\w)(regression|revert|回归|回滚)(?!\w)/i, weight: 1 }
+  ],
+  refactor: [
+    { pattern: /(?<!\w)(refactor|重构|重写|rewrite|restructure|重新设计|clean ?up|清理|整理|simplify|简化|extract|提取|split|拆分)(?!\w)/i, weight: 3 },
+    { pattern: /(?<!\w)(maintainability|可维护|readability|可读性|code smell|技术债|tech debt|coupling|耦合|cohesion|内聚)(?!\w)/i, weight: 2 },
+    { pattern: /(?<!\w)(rename|move|organize|抽象|abstraction)(?!\w)/i, weight: 1 }
+  ],
+  "test-generation": [
+    { pattern: /(?<!\w)(tests?|测试|specs?|单元测试|unit tests?|coverage|覆盖率|vitest|jest|mocha|e2e|integration)(?!\w)/i, weight: 3 },
+    { pattern: /(?<!\w)(assert|验证|verify|tdd|red.green)(?!\w)/i, weight: 2 },
+    { pattern: /(?<!\w)(mock|stub|fixture|测试用例|用例)(?!\w)/i, weight: 1 }
+  ],
+  "code-review": [
+    { pattern: /(?<!\w)(review|审查|审阅|代码审查|audit|安全审计|inspect)(?!\w)/i, weight: 3 },
+    { pattern: /(?<!\w)(quality|质量|best practice|最佳实践|standard|规范|convention|smell)(?!\w)/i, weight: 2 },
+    { pattern: /(?<!\w)(feedback|意见|suggestion|建议|comment|注释)(?!\w)/i, weight: 1 }
+  ],
+  "code-reverse-design": [
+    { pattern: /(?<!\w)(reverse|逆向|理解|understand|architecture|架构|design doc|设计文档|document|文档化|逆向工程)(?!\w)/i, weight: 3 },
+    { pattern: /(?<!\w)(analyze|分析|explore|探索|overview|概览|structure|结构|module|模块|dependency|依赖)(?!\w)/i, weight: 2 },
+    { pattern: /(?<!\w)(prd|需求|规格|diagram|图表|flowchart|流程图)(?!\w)/i, weight: 1 }
+  ]
+};
+var PRIORITY = [
+  "bugfix",
+  "test-generation",
+  "refactor",
+  "code-review",
+  "code-reverse-design"
+];
+function classifyTask(goal, fallback = "code-review") {
+  const scores = {
+    bugfix: 0,
+    refactor: 0,
+    "test-generation": 0,
+    "code-review": 0,
+    "code-reverse-design": 0
+  };
+  for (const [type, rules] of Object.entries(RULES)) {
+    for (const { pattern, weight } of rules) {
+      if (pattern.test(goal)) {
+        scores[type] += weight;
+      }
+    }
+  }
+  let bestType = fallback;
+  let bestScore = 0;
+  for (const type of PRIORITY) {
+    const s = scores[type];
+    if (s > bestScore) {
+      bestScore = s;
+      bestType = type;
+    }
+  }
+  return bestType;
+}
+function isValidTaskType(value) {
+  return ["bugfix", "refactor", "test-generation", "code-review", "code-reverse-design"].includes(value);
+}
+
+// src/meta_skill/skill-survey.ts
+var BASELINE_MAP = {
+  "bugfix": ["diagnose", "tdd"],
+  "refactor": ["search-first", "plan", "improve-codebase-architecture"],
+  "test-generation": ["tdd"],
+  "code-review": ["zoom-out", "search-first", "security-review"],
+  "code-reverse-design": ["zoom-out", "plan", "to-prd"]
+};
+function getBaselineSkills(taskType) {
+  return [...BASELINE_MAP[taskType] ?? []];
+}
+
+// src/meta_skill/workflow-extractor.ts
+var NUMBERED_HEADINGS_RE = /^#{1,4}\s+(?:Step\s+|Phase\s+)?(\d+)[.:\-–—\s]+(.+)$/gim;
+var NUMBERED_LIST_RE = /^\s*(\d+)\.\s+(.{10,})$/gm;
+var MAX_STEPS = 12;
+function extractWorkflowSteps(body) {
+  if (!body.trim()) return [];
+  const headingSteps = extractHeadingSteps(body);
+  if (headingSteps.length >= 2) {
+    return headingSteps.slice(0, MAX_STEPS);
+  }
+  const listSteps = extractListSteps(body);
+  if (listSteps.length >= 2) {
+    return listSteps.slice(0, MAX_STEPS);
+  }
+  return extractParagraphSteps(body);
+}
+function extractHeadingSteps(body) {
+  var _a;
+  const steps = [];
+  let match;
+  NUMBERED_HEADINGS_RE.lastIndex = 0;
+  while ((match = NUMBERED_HEADINGS_RE.exec(body)) !== null) {
+    const text = (_a = match[2]) == null ? void 0 : _a.trim();
+    if (text) steps.push(cleanStepText(text));
+  }
+  return steps;
+}
+function extractListSteps(body) {
+  var _a;
+  const steps = [];
+  NUMBERED_LIST_RE.lastIndex = 0;
+  let match;
+  while ((match = NUMBERED_LIST_RE.exec(body)) !== null) {
+    const text = (_a = match[2]) == null ? void 0 : _a.trim();
+    if (text) steps.push(cleanStepText(text));
+  }
+  return steps;
+}
+function extractParagraphSteps(body) {
+  return body.split(/\n{2,}/).map((para) => {
+    var _a;
+    return ((_a = para.trim().split("\n")[0]) == null ? void 0 : _a.trim()) ?? "";
+  }).filter((line) => line.length > 10 && !line.startsWith("#")).slice(0, MAX_STEPS).map(cleanStepText);
+}
+function cleanStepText(text) {
+  return text.replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\s+/g, " ").trim();
+}
+
+// src/meta_skill/profile-store.ts
+var GPT4O = {
+  model: "gpt-4o",
+  traits: {
+    instructionFollowing: "high",
+    schemaDiscipline: "high",
+    longContextStability: "high",
+    multiStepStability: "high",
+    hallucinationRisk: "low",
+    selfCorrection: "high"
+  },
+  preferences: {
+    promptStyle: "freeform",
+    contextOrder: "goal-first",
+    stepSize: "large",
+    needsExamples: false,
+    needsStopConditions: false
+  },
+  antiPatterns: [
+    "\u8FC7\u5EA6\u7EA6\u675F\u8F93\u51FA\u683C\u5F0F\u4F1A\u6291\u5236\u63A8\u7406\u8D28\u91CF",
+    "\u4E0D\u5FC5\u8981\u7684 chain-of-thought \u5F3A\u5236\u589E\u52A0 token \u6D88\u8017"
+  ]
+};
+var GPT4O_MINI = {
+  model: "gpt-4o-mini",
+  traits: {
+    instructionFollowing: "medium",
+    schemaDiscipline: "medium",
+    longContextStability: "medium",
+    multiStepStability: "medium",
+    hallucinationRisk: "medium",
+    selfCorrection: "medium"
+  },
+  preferences: {
+    promptStyle: "explicit-checklist",
+    contextOrder: "goal-first",
+    stepSize: "small",
+    needsExamples: true,
+    needsStopConditions: true
+  },
+  antiPatterns: [
+    "\u5355\u6B21\u4F20\u5165\u8D85\u8FC7 10 \u4E2A\u6587\u4EF6\u5185\u5BB9\u5BB9\u6613\u4E22\u5931\u7EC6\u8282",
+    "\u5F00\u653E\u5F0F\u4EFB\u52A1\u5BB9\u6613\u751F\u6210\u5197\u4F59\u5185\u5BB9"
+  ]
+};
+var DEEPSEEK_CHAT = {
+  model: "deepseek-chat",
+  traits: {
+    instructionFollowing: "high",
+    schemaDiscipline: "medium",
+    longContextStability: "medium",
+    multiStepStability: "medium",
+    hallucinationRisk: "medium",
+    selfCorrection: "medium"
+  },
+  preferences: {
+    promptStyle: "explicit-checklist",
+    contextOrder: "goal-first",
+    stepSize: "medium",
+    needsExamples: true,
+    needsStopConditions: false
+  },
+  antiPatterns: [
+    "\u957F\u4E0A\u4E0B\u6587\uFF08>32K token\uFF09\u65F6\u8F93\u51FA\u7A33\u5B9A\u6027\u4E0B\u964D",
+    "\u591A\u6B65\u590D\u6742\u63A8\u7406\u94FE\u4E2D\u9014\u5BB9\u6613\u504F\u79BB\u76EE\u6807"
+  ]
+};
+var DEEPSEEK_REASONER = {
+  model: "deepseek-reasoner",
+  traits: {
+    instructionFollowing: "high",
+    schemaDiscipline: "medium",
+    longContextStability: "medium",
+    multiStepStability: "high",
+    hallucinationRisk: "low",
+    selfCorrection: "high"
+  },
+  preferences: {
+    promptStyle: "freeform",
+    contextOrder: "goal-first",
+    stepSize: "large",
+    needsExamples: false,
+    needsStopConditions: false
+  },
+  antiPatterns: [
+    "\u8FC7\u5EA6\u7EA6\u675F\u63A8\u7406\u6B65\u9AA4\u683C\u5F0F\u4F1A\u5E72\u6270\u5185\u90E8\u601D\u8003\u94FE",
+    "\u4E0D\u9002\u5408\u7EAF\u68C0\u7D22\u7C7B\u4EFB\u52A1\uFF08\u63A8\u7406\u5F00\u9500\u8FDC\u5927\u4E8E\u6536\u76CA\uFF09"
+  ]
+};
+var MINIMAX_M25 = {
+  model: "MiniMax-M2.5",
+  traits: {
+    instructionFollowing: "medium",
+    schemaDiscipline: "low",
+    longContextStability: "high",
+    // 百万 token 上下文
+    multiStepStability: "medium",
+    hallucinationRisk: "medium",
+    selfCorrection: "low"
+  },
+  preferences: {
+    promptStyle: "strict-template",
+    contextOrder: "template-first",
+    stepSize: "small",
+    needsExamples: true,
+    needsStopConditions: true
+  },
+  antiPatterns: [
+    "\u81EA\u7531\u683C\u5F0F\u8F93\u51FA\u5BB9\u6613\u4EA7\u751F\u5197\u4F59\u6216\u683C\u5F0F\u6DF7\u4E71",
+    "\u7F3A\u4E4F\u660E\u786E\u505C\u6B62\u6761\u4EF6\u65F6\u5BB9\u6613\u8FC7\u5EA6\u8F93\u51FA",
+    "\u590D\u6742\u63A8\u7406\u94FE\u9700\u8981\u66F4\u7EC6\u7C92\u5EA6\u7684\u6B65\u9AA4\u62C6\u5206"
+  ]
+};
+var MINIMAX_M25_HS = {
+  ...MINIMAX_M25,
+  model: "MiniMax-M2.5-highspeed"
+};
+var CLAUDE_SONNET = {
+  model: "claude-sonnet-4-6",
+  traits: {
+    instructionFollowing: "high",
+    schemaDiscipline: "high",
+    longContextStability: "high",
+    multiStepStability: "high",
+    hallucinationRisk: "low",
+    selfCorrection: "high"
+  },
+  preferences: {
+    promptStyle: "freeform",
+    contextOrder: "goal-first",
+    stepSize: "large",
+    needsExamples: false,
+    needsStopConditions: false
+  },
+  antiPatterns: [
+    "\u8FC7\u5EA6\u6307\u5B9A\u8F93\u51FA\u683C\u5F0F\u53EF\u80FD\u6291\u5236\u81EA\u7136\u63A8\u7406"
+  ]
+};
+var CLAUDE_OPUS = {
+  ...CLAUDE_SONNET,
+  model: "claude-opus-4-7"
+};
+var CLAUDE_HAIKU = {
+  model: "claude-haiku-4-5-20251001",
+  traits: {
+    instructionFollowing: "high",
+    schemaDiscipline: "high",
+    longContextStability: "high",
+    multiStepStability: "medium",
+    hallucinationRisk: "low",
+    selfCorrection: "medium"
+  },
+  preferences: {
+    promptStyle: "explicit-checklist",
+    contextOrder: "goal-first",
+    stepSize: "medium",
+    needsExamples: false,
+    needsStopConditions: false
+  },
+  antiPatterns: [
+    "\u6DF1\u5EA6\u63A8\u7406\u4EFB\u52A1\u8D85\u51FA\u80FD\u529B\u8FB9\u754C\u65F6\u5E94 escalate \u5230 Sonnet/Opus"
+  ]
+};
+var DEFAULT_PROFILE = {
+  model: "unknown",
+  traits: {
+    instructionFollowing: "medium",
+    schemaDiscipline: "medium",
+    longContextStability: "medium",
+    multiStepStability: "medium",
+    hallucinationRisk: "medium",
+    selfCorrection: "medium"
+  },
+  preferences: {
+    promptStyle: "explicit-checklist",
+    contextOrder: "goal-first",
+    stepSize: "small",
+    needsExamples: true,
+    needsStopConditions: true
+  },
+  antiPatterns: []
+};
+var PROFILE_MAP = {
+  "gpt-4o": GPT4O,
+  "gpt-4o-mini": GPT4O_MINI,
+  "deepseek-chat": DEEPSEEK_CHAT,
+  "deepseek-reasoner": DEEPSEEK_REASONER,
+  "MiniMax-M2.5": MINIMAX_M25,
+  "MiniMax-M2.5-highspeed": MINIMAX_M25_HS,
+  "claude-sonnet-4-6": CLAUDE_SONNET,
+  "claude-opus-4-7": CLAUDE_OPUS,
+  "claude-haiku-4-5-20251001": CLAUDE_HAIKU,
+  // 历史别名
+  "claude-3-5-sonnet-20241022": { ...CLAUDE_SONNET, model: "claude-3-5-sonnet-20241022" },
+  "claude-3-5-haiku-20241022": { ...CLAUDE_HAIKU, model: "claude-3-5-haiku-20241022" }
+};
+function getModelProfile(modelName) {
+  const exact = PROFILE_MAP[modelName];
+  if (exact) return exact;
+  for (const [key, profile] of Object.entries(PROFILE_MAP)) {
+    if (modelName.startsWith(key) || key.startsWith(modelName)) {
+      return { ...profile, model: modelName };
+    }
+  }
+  return { ...DEFAULT_PROFILE, model: modelName };
+}
+
+// src/meta_skill/recipe-resolver.ts
+function resolveInputStyle(promptStyle) {
+  return promptStyle;
+}
+function resolveGranularity(stepSize) {
+  switch (stepSize) {
+    case "large":
+      return "large-batch";
+    case "small":
+      return "stepwise";
+    case "medium":
+    default:
+      return "file-level-first";
+  }
+}
+function resolveOutputFormat(promptStyle) {
+  switch (promptStyle) {
+    case "strict-template":
+      return "strict-template";
+    case "explicit-checklist":
+      return "template";
+    case "freeform":
+    default:
+      return "freeform";
+  }
+}
+function resolveContextStrategy(contextOrder) {
+  switch (contextOrder) {
+    case "goal-first":
+      return "\u5148\u7ED9\u51FA\u4EFB\u52A1\u76EE\u6807\uFF0C\u518D\u9644\u4E0A\u4EE3\u7801\u6750\u6599\uFF0C\u6700\u540E\u7EA6\u675F\u8F93\u51FA\u683C\u5F0F";
+    case "template-first":
+      return "\u5148\u7ED9\u51FA\u8F93\u51FA\u6A21\u677F\uFF0C\u518D\u63CF\u8FF0\u4EFB\u52A1\uFF0C\u6700\u540E\u9644\u4E0A\u6750\u6599";
+    default:
+      return "\u5148\u9644\u4E0A\u6240\u6709\u76F8\u5173\u6750\u6599\uFF0C\u518D\u7ED9\u51FA\u4EFB\u52A1\u76EE\u6807";
+  }
+}
+function resolveVerificationStyle(selfCorrection, hallucinationRisk) {
+  if (selfCorrection === "high" && hallucinationRisk === "low") {
+    return "\u81EA\u6821\u9A8C\uFF1A\u8981\u6C42\u6A21\u578B\u5217\u51FA\u7F6E\u4FE1\u5EA6\u4F4E\u7684\u7ED3\u8BBA";
+  }
+  if (hallucinationRisk === "high") {
+    return "\u5F3A\u9A8C\u8BC1\uFF1A\u8981\u6C42\u5F15\u7528\u4EE3\u7801\u884C\u53F7\u4F5C\u4E3A\u6BCF\u6761\u7ED3\u8BBA\u7684\u8BC1\u636E";
+  }
+  return "\u8F7B\u9A8C\u8BC1\uFF1A\u8F93\u51FA\u7ED3\u8BBA\u540E\u7528\u793A\u4F8B\u4EE3\u7801\u7247\u6BB5\u786E\u8BA4";
+}
+function resolveFailureModes(profile, taskType) {
+  const modes = [...profile.antiPatterns];
+  if (profile.traits.longContextStability === "low" || profile.traits.longContextStability === "medium") {
+    modes.push("\u957F\u4E0A\u4E0B\u6587\u65F6\u53EF\u80FD\u4E22\u5931\u65E9\u671F\u6307\u4EE4");
+  }
+  if (profile.traits.multiStepStability === "low") {
+    modes.push("\u591A\u6B65\u63A8\u7406\u4E2D\u9014\u53EF\u80FD\u504F\u79BB\u76EE\u6807");
+  }
+  if (taskType === "bugfix") {
+    modes.push("\u53EF\u80FD\u4FEE\u590D\u75C7\u72B6\u800C\u975E\u6839\u672C\u539F\u56E0");
+    modes.push("\u5728\u7F3A\u4E4F\u5B8C\u6574\u4E0A\u4E0B\u6587\u65F6\u6613\u8BEF\u5224 bug \u6240\u5728\u4F4D\u7F6E");
+  }
+  if (taskType === "code-review") {
+    modes.push("\u53EF\u80FD\u53EA\u5173\u6CE8\u4EE3\u7801\u98CE\u683C\u800C\u5FFD\u7565\u903B\u8F91\u7F3A\u9677");
+    modes.push("\u5BF9\u590D\u6742\u4E1A\u52A1\u903B\u8F91\u7684\u8BC4\u5BA1\u6DF1\u5EA6\u4E0D\u8DB3");
+  }
+  return modes;
+}
+function resolveRepairStrategies(profile) {
+  const strategies = [];
+  if (profile.traits.multiStepStability === "low" || profile.traits.multiStepStability === "medium") {
+    strategies.push("\u5C06\u4EFB\u52A1\u62C6\u5206\u4E3A\u66F4\u5C0F\u7684\u72EC\u7ACB\u6B65\u9AA4\u540E\u9010\u4E00\u91CD\u8BD5");
+  }
+  if (profile.traits.hallucinationRisk === "high") {
+    strategies.push("\u8981\u6C42\u6A21\u578B\u5728\u91CD\u8BD5\u65F6\u4E3A\u6BCF\u6761\u7ED3\u8BBA\u9644\u4E0A\u4EE3\u7801\u884C\u53F7\u5F15\u7528");
+  }
+  if (profile.preferences.needsStopConditions) {
+    strategies.push("\u5728\u91CD\u8BD5 prompt \u4E2D\u8865\u5145\u660E\u786E\u7684\u5B8C\u6210\u5224\u65AD\u6761\u4EF6\uFF0C\u907F\u514D\u6A21\u578B\u65E0\u9650\u5EF6\u4F38");
+  }
+  if (profile.traits.selfCorrection !== "high") {
+    strategies.push("\u81EA\u52A8\u89E6\u53D1\u5916\u90E8 judge \u5BF9\u8F93\u51FA\u8FDB\u884C\u4E8C\u6B21\u6838\u9A8C\uFF0C\u518D\u51B3\u5B9A\u662F\u5426\u63A5\u53D7\u7ED3\u679C");
+  }
+  return strategies;
+}
+function resolveMaxRepeatedFailures(selfCorrection) {
+  return selfCorrection === "high" ? 3 : 2;
+}
+function resolveRecipe(profile, taskType, baselineWorkflow, inheritedSkills) {
+  return {
+    model: profile.model,
+    taskType,
+    inheritedSkills,
+    baselineWorkflow,
+    inputStyle: resolveInputStyle(profile.preferences.promptStyle),
+    contextStrategy: resolveContextStrategy(profile.preferences.contextOrder),
+    granularity: resolveGranularity(profile.preferences.stepSize),
+    outputContract: {
+      format: resolveOutputFormat(profile.preferences.promptStyle),
+      mustCiteEvidence: profile.traits.hallucinationRisk !== "low",
+      mustListUncertainty: profile.traits.selfCorrection !== "high"
+    },
+    verificationStyle: resolveVerificationStyle(
+      profile.traits.selfCorrection,
+      profile.traits.hallucinationRisk
+    ),
+    failureModes: resolveFailureModes(profile, taskType),
+    repairStrategies: resolveRepairStrategies(profile),
+    escalationThreshold: {
+      maxRepeatedFailures: resolveMaxRepeatedFailures(
+        profile.traits.selfCorrection
+      ),
+      criticalFailures: [
+        "\u8F93\u51FA\u4E3A\u7A7A",
+        "\u65E0\u6CD5\u7406\u89E3\u4EFB\u52A1\u76EE\u6807",
+        "\u5FAA\u73AF\u91CD\u590D\u76F8\u540C\u5185\u5BB9\u8D85\u8FC7 2 \u6B21"
+      ]
+    }
+  };
+}
+
+// src/meta_skill/policy-builder.ts
+function buildContextOrder(contextStrategy, granularity, constraints, paths) {
+  const hasConstraints = Boolean(constraints && constraints.length > 0);
+  const hasPaths = Boolean(paths && paths.length > 0);
+  let order;
+  if (contextStrategy.includes("\u5148\u7ED9\u51FA\u4EFB\u52A1\u76EE\u6807")) {
+    order = ["\u4EFB\u52A1\u76EE\u6807"];
+    if (hasConstraints) order.push("\u7EA6\u675F\u6761\u4EF6");
+    if (hasPaths) order.push("\u4EE3\u7801\u6750\u6599");
+    order.push("\u8F93\u51FA\u683C\u5F0F\u8981\u6C42");
+  } else if (contextStrategy.includes("\u5148\u7ED9\u51FA\u8F93\u51FA\u6A21\u677F")) {
+    order = ["\u8F93\u51FA\u683C\u5F0F\u8981\u6C42", "\u4EFB\u52A1\u76EE\u6807"];
+    if (hasConstraints) order.push("\u7EA6\u675F\u6761\u4EF6");
+    if (hasPaths) order.push("\u4EE3\u7801\u6750\u6599");
+  } else {
+    order = [];
+    if (hasPaths) order.push("\u4EE3\u7801\u6750\u6599");
+    order.push("\u4EFB\u52A1\u76EE\u6807");
+    if (hasConstraints) order.push("\u7EA6\u675F\u6761\u4EF6");
+    order.push("\u8F93\u51FA\u683C\u5F0F\u8981\u6C42");
+  }
+  if (granularity === "stepwise") {
+    order = order.filter((item) => item !== "\u4EFB\u52A1\u76EE\u6807");
+    order = ["\u4EFB\u52A1\u76EE\u6807", ...order];
+    if (!order.includes("\u5DE5\u4F5C\u6D41\u6B65\u9AA4")) order.push("\u5DE5\u4F5C\u6D41\u6B65\u9AA4");
+    order = order.filter((item) => item !== "\u8F93\u51FA\u683C\u5F0F\u8981\u6C42");
+    order.push("\u8F93\u51FA\u683C\u5F0F\u8981\u6C42");
+  }
+  return order;
+}
+function resolveMaxMaterials(granularity) {
+  const map = {
+    "large-batch": 10,
+    "file-level-first": 5,
+    "small-batch": 3,
+    stepwise: 2
+  };
+  return map[granularity];
+}
+function buildPolicy(recipe, input) {
+  var _a, _b, _c;
+  const maxSteps = ((_b = (_a = input.runtimeContext) == null ? void 0 : _a.budget) == null ? void 0 : _b.maxSteps) ?? 8;
+  const stepPlan = recipe.baselineWorkflow.slice(0, maxSteps);
+  const mode = stepPlan.length > 1 ? "multi_step" : "single_step";
+  const order = buildContextOrder(
+    recipe.contextStrategy,
+    recipe.granularity,
+    input.task.constraints,
+    (_c = input.task.scope) == null ? void 0 : _c.paths
+  );
+  const maxMaterialsPerStep = resolveMaxMaterials(recipe.granularity);
+  return {
+    mode,
+    stepPlan,
+    selectedSkills: recipe.inheritedSkills,
+    contextPackaging: {
+      order,
+      maxMaterialsPerStep
+    },
+    outputContract: { ...recipe.outputContract },
+    revisionPolicy: {
+      maxRetries: recipe.escalationThreshold.maxRepeatedFailures,
+      retryStyle: recipe.repairStrategies[0] ?? "\u7F29\u51CF\u8F93\u5165\u91CF\u540E\u91CD\u8BD5"
+    },
+    escalationPolicy: {
+      escalateOn: recipe.escalationThreshold.criticalFailures
+    }
+  };
+}
+
+// src/meta_skill/materializer.ts
+function buildTaskCard(policy, profile, input) {
+  const taskType = input.task.type ?? "\uFF08\u672A\u6307\u5B9A\uFF0C\u5F85\u5206\u7C7B\uFF09";
+  const modeLabel = policy.mode === "multi_step" ? "\u591A\u6B65\u6267\u884C" : "\u5355\u6B65\u6267\u884C";
+  const lines = [
+    `# \u4EFB\u52A1\u8BF4\u660E\u5361`,
+    ``,
+    `| \u5B57\u6BB5 | \u503C |`,
+    `|------|-----|`,
+    `| \u6A21\u578B | ${profile.model} |`,
+    `| \u4EFB\u52A1\u7C7B\u578B | ${taskType} |`,
+    `| \u6267\u884C\u6A21\u5F0F | ${modeLabel} |`,
+    ``,
+    `## \u76EE\u6807`,
+    ``,
+    input.task.goal,
+    ``
+  ];
+  if (input.task.constraints && input.task.constraints.length > 0) {
+    lines.push(`## \u7EA6\u675F`);
+    lines.push(``);
+    for (const c of input.task.constraints) {
+      lines.push(`- ${c}`);
+    }
+    lines.push(``);
+  }
+  lines.push(`## \u9009\u7528 Skills`);
+  lines.push(``);
+  if (policy.selectedSkills.length > 0) {
+    for (const skill of policy.selectedSkills) {
+      lines.push(`- ${skill}`);
+    }
+  } else {
+    lines.push(`- \uFF08\u65E0\uFF09`);
+  }
+  lines.push(``);
+  lines.push(`## \u6267\u884C\u6B65\u9AA4`);
+  lines.push(``);
+  policy.stepPlan.forEach((step, idx) => {
+    lines.push(`${idx + 1}. ${step}`);
+  });
+  lines.push(``);
+  lines.push(`## \u8F93\u51FA\u8981\u6C42`);
+  lines.push(``);
+  lines.push(`- \u683C\u5F0F\uFF1A${policy.outputContract.format}`);
+  if (policy.outputContract.mustCiteEvidence) {
+    lines.push(`- \u5FC5\u987B\u5F15\u7528\u4EE3\u7801\u8BC1\u636E`);
+  }
+  if (policy.outputContract.mustListUncertainty) {
+    lines.push(`- \u5FC5\u987B\u5217\u51FA\u4E0D\u786E\u5B9A\u9879`);
+  }
+  return lines.join("\n");
+}
+function buildStrictTemplateWorkerPrompt(policy, input) {
+  const sections = [];
+  sections.push(`\u3010\u4EFB\u52A1\u76EE\u6807\u3011
+${input.task.goal}`);
+  if (input.task.constraints && input.task.constraints.length > 0) {
+    sections.push(
+      `\u3010\u7EA6\u675F\u6761\u4EF6\u3011
+${input.task.constraints.map((c) => `- ${c}`).join("\n")}`
+    );
+  }
+  const stepsText = policy.stepPlan.map((step, i) => `${i + 1}. ${step}`).join("\n");
+  sections.push(
+    `\u3010\u6267\u884C\u6B65\u9AA4\u3011\uFF08\u5FC5\u987B\u6309\u5E8F\uFF0C\u4E0D\u5F97\u8DF3\u6B65\uFF09
+${stepsText}`
+  );
+  const evidenceNote = policy.outputContract.mustCiteEvidence ? "\n- \u6BCF\u9879\u7ED3\u8BBA\u5FC5\u987B\u9644\u4EE3\u7801\u884C\u53F7\u6216\u539F\u6587\u5F15\u7528" : "";
+  const uncertaintyNote = policy.outputContract.mustListUncertainty ? "\n- \u4E0D\u786E\u5B9A\u9879\u987B\u5355\u72EC\u5217\u51FA\uFF0C\u4E0D\u5F97\u6DF7\u5165\u7ED3\u8BBA" : "";
+  sections.push(
+    `\u3010\u8F93\u51FA\u683C\u5F0F\u3011
+\u683C\u5F0F\u8981\u6C42\uFF1A${policy.outputContract.format}${evidenceNote}${uncertaintyNote}`
+  );
+  sections.push(
+    `\u3010\u505C\u6B62\u6761\u4EF6\u3011
+\u5B8C\u6210\u5168\u90E8\u6B65\u9AA4\u4E14\u8F93\u51FA\u6EE1\u8DB3\u683C\u5F0F\u8981\u6C42\u540E\u505C\u6B62\uFF0C\u4E0D\u5F97\u8FFD\u52A0\u989D\u5916\u5185\u5BB9\u3002`
+  );
+  return sections.join("\n\n");
+}
+function buildExplicitChecklistWorkerPrompt(policy, input) {
+  const lines = [];
+  lines.push(`## \u4EFB\u52A1\u76EE\u6807
+
+${input.task.goal}`);
+  if (input.task.constraints && input.task.constraints.length > 0) {
+    lines.push(
+      `
+## \u7EA6\u675F\u6761\u4EF6
+
+${input.task.constraints.map((c) => `- ${c}`).join("\n")}`
+    );
+  }
+  lines.push(`
+## \u6267\u884C\u6B65\u9AA4
+`);
+  for (const step of policy.stepPlan) {
+    lines.push(`- [ ] ${step}`);
+  }
+  lines.push(`
+## \u8F93\u51FA\u683C\u5F0F
+`);
+  lines.push(`- \u683C\u5F0F\uFF1A${policy.outputContract.format}`);
+  if (policy.outputContract.mustCiteEvidence) {
+    lines.push(`- \u6CE8\u610F\uFF1A\u6BCF\u9879\u7ED3\u8BBA\u987B\u9644\u4EE3\u7801\u8BC1\u636E\uFF08\u884C\u53F7\u6216\u539F\u6587\u7247\u6BB5\uFF09`);
+  }
+  return lines.join("\n");
+}
+function buildFreeformWorkerPrompt(policy, input) {
+  const paragraphs = [];
+  paragraphs.push(`\u8BF7\u5B8C\u6210\u4EE5\u4E0B\u4EFB\u52A1\uFF1A${input.task.goal}`);
+  if (input.task.constraints && input.task.constraints.length > 0) {
+    paragraphs.push(
+      `\u6267\u884C\u65F6\u9700\u9075\u5B88\u4EE5\u4E0B\u7EA6\u675F\uFF1A${input.task.constraints.join("\uFF1B")}\u3002`
+    );
+  }
+  paragraphs.push(
+    `\u6267\u884C\u987A\u5E8F\u5982\u4E0B\uFF1A${policy.stepPlan.map((s, i) => `\uFF08${i + 1}\uFF09${s}`).join(" \u2192 ")}\u3002`
+  );
+  const evidencePart = policy.outputContract.mustCiteEvidence ? " \u6BCF\u9879\u7ED3\u8BBA\u9700\u9644\u5F15\u7528\u8BC1\u636E\u3002" : "";
+  const uncertaintyPart = policy.outputContract.mustListUncertainty ? " \u4E0D\u786E\u5B9A\u4E4B\u5904\u8BF7\u5355\u72EC\u5217\u660E\u3002" : "";
+  paragraphs.push(
+    `\u8F93\u51FA\u683C\u5F0F\u4E3A ${policy.outputContract.format}\u3002${evidencePart}${uncertaintyPart}`
+  );
+  return paragraphs.join("\n\n");
+}
+function buildWorkerPrompt(policy, profile, input) {
+  switch (profile.preferences.promptStyle) {
+    case "strict-template":
+      return buildStrictTemplateWorkerPrompt(policy, input);
+    case "explicit-checklist":
+      return buildExplicitChecklistWorkerPrompt(policy, input);
+    case "freeform":
+    default:
+      return buildFreeformWorkerPrompt(policy, input);
+  }
+}
+function buildJudgePrompt(policy, input) {
+  const lines = [
+    `# Judge \u8BC4\u4F30 Prompt`,
+    ``,
+    `\u4F60\u662F\u672C\u8F6E\u4EFB\u52A1\u7684\u9A8C\u8BC1\u65B9\u3002\u8BF7\u6309\u7167\u4EE5\u4E0B\u6E05\u5355\u9010\u9879\u6838\u67E5 worker \u7684\u8F93\u51FA\uFF0C\u7136\u540E\u7ED9\u51FA\u6700\u7EC8\u88C1\u5B9A\u3002`,
+    ``,
+    `## \u6838\u67E5\u6E05\u5355`,
+    ``
+  ];
+  policy.stepPlan.forEach((step, idx) => {
+    lines.push(`- [ ] \u6B65\u9AA4 ${idx + 1} \u5DF2\u5B8C\u6210\uFF1A${step}`);
+  });
+  if (policy.outputContract.mustCiteEvidence) {
+    lines.push(`- [ ] \u6BCF\u9879\u7ED3\u8BBA\u5747\u9644\u6709\u4EE3\u7801\u8BC1\u636E\uFF08\u884C\u53F7\u6216\u539F\u6587\u5F15\u7528\uFF09`);
+  }
+  if (policy.outputContract.mustListUncertainty) {
+    lines.push(`- [ ] \u4E0D\u786E\u5B9A\u9879\u5DF2\u5355\u72EC\u5217\u51FA\uFF0C\u672A\u6DF7\u5165\u7ED3\u8BBA`);
+  }
+  lines.push(
+    `- [ ] \u8F93\u51FA\u683C\u5F0F\u7B26\u5408\u8981\u6C42\uFF08\u671F\u671B\u683C\u5F0F\uFF1A${policy.outputContract.format}\uFF09`
+  );
+  lines.push(``);
+  lines.push(`## \u8BC4\u5206\u7EF4\u5EA6\uFF08\u5404\u7EF4\u5EA6 0\u201310 \u5206\uFF09`);
+  lines.push(``);
+  lines.push(`| \u7EF4\u5EA6 | \u5F97\u5206 | \u8BF4\u660E |`);
+  lines.push(`|------|------|------|`);
+  lines.push(`| \u5B8C\u6574\u6027 | \u2014 | \u6240\u6709\u6B65\u9AA4\u662F\u5426\u5168\u90E8\u5B8C\u6210 |`);
+  lines.push(`| \u8BC1\u636E\u8D28\u91CF | \u2014 | \u5F15\u7528\u662F\u5426\u51C6\u786E\u4E14\u5145\u5206 |`);
+  lines.push(`| \u683C\u5F0F\u89C4\u8303 | \u2014 | \u8F93\u51FA\u662F\u5426\u7B26\u5408\u6307\u5B9A\u683C\u5F0F |`);
+  lines.push(``);
+  lines.push(`## \u6700\u7EC8\u88C1\u5B9A`);
+  lines.push(``);
+  lines.push(`\u4ECE\u4EE5\u4E0B\u4E09\u9879\u4E2D\u9009\u62E9\u4E00\u9879\uFF1A`);
+  lines.push(``);
+  lines.push(`- **pass**\uFF1A\u6240\u6709\u6E05\u5355\u9879\u901A\u8FC7\uFF0C\u4E09\u4E2A\u7EF4\u5EA6\u5747 \u2265 7 \u5206`);
+  lines.push(
+    `- **revise**\uFF1A\u5B58\u5728\u53EF\u4FEE\u590D\u7684\u95EE\u9898\u3002\u8BF7\u5728\u88C1\u5B9A\u540E\u5217\u51FA\u5177\u4F53\u4FEE\u6539\u610F\u89C1\uFF0Cworker \u9700\u5728 ${policy.revisionPolicy.maxRetries} \u6B21\u5185\u5B8C\u6210\u4FEE\u6539\u3002\u4FEE\u590D\u7B56\u7565\uFF1A${policy.revisionPolicy.retryStyle}`
+  );
+  if (policy.escalationPolicy.escalateOn.length > 0) {
+    const triggers = policy.escalationPolicy.escalateOn.join("\u3001");
+    lines.push(
+      `- **escalate**\uFF1A\u9047\u5230\u4EE5\u4E0B\u60C5\u5F62\u65F6\u5FC5\u987B\u5347\u7EA7\uFF0C\u4E0D\u5F97\u5C1D\u8BD5\u4FEE\u590D\uFF1A${triggers}`
+    );
+  } else {
+    lines.push(`- **escalate**\uFF1A\u9047\u5230\u65E0\u6CD5\u901A\u8FC7\u91CD\u8BD5\u4FEE\u590D\u7684\u6839\u672C\u6027\u95EE\u9898\u65F6\u5347\u7EA7`);
+  }
+  lines.push(``);
+  lines.push(`> \u88C1\u5B9A\u683C\u5F0F\uFF1A\u5728\u6587\u672B\u5355\u72EC\u4E00\u884C\u5199 \`verdict: pass\` / \`verdict: revise\` / \`verdict: escalate\`\u3002`);
+  return lines.join("\n");
+}
+function materialize(policy, profile, input) {
+  return {
+    taskCard: buildTaskCard(policy, profile, input),
+    workerPrompt: buildWorkerPrompt(policy, profile, input),
+    judgePrompt: buildJudgePrompt(policy, input)
+  };
+}
+
+// src/meta_skill/learning-store.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+var STORE_PATH = path2.resolve(os.homedir(), ".ecode", "learning-records.jsonl");
+
+// src/meta_skill/index.ts
+function resolveBuiltinSkillsDir() {
+  try {
+    let dir = path3.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 4; i++) {
+      const candidate = path3.join(dir, "skills");
+      if (fs3.existsSync(candidate) && fs3.statSync(candidate).isDirectory()) {
+        const hasSkillContent = fs3.readdirSync(candidate).some(
+          (entry) => fs3.existsSync(path3.join(candidate, entry, "SKILL.md"))
+        );
+        if (hasSkillContent) return candidate;
+      }
+      const parent = path3.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return null;
+}
+function runMetaAlign(input) {
+  const taskType = input.task.type && isValidTaskType(input.task.type) ? input.task.type : classifyTask(input.task.goal);
+  const inheritedSkills = getBaselineSkills(taskType);
+  const builtinSkillsDir = resolveBuiltinSkillsDir();
+  const allSteps = [];
+  for (const skillName of inheritedSkills) {
+    const candidates = [];
+    if (builtinSkillsDir) {
+      candidates.push(path3.join(builtinSkillsDir, skillName, "SKILL.md"));
+      candidates.push(path3.join(builtinSkillsDir, skillName + ".md"));
+    }
+    candidates.push(path3.join(process.cwd(), "skills", skillName, "SKILL.md"));
+    candidates.push(path3.join(process.cwd(), "skills", skillName + ".md"));
+    let body = "";
+    for (const p of candidates) {
+      if (fs3.existsSync(p)) {
+        body = fs3.readFileSync(p, { encoding: "utf-8" });
+        break;
+      }
+    }
+    const steps = extractWorkflowSteps(body);
+    allSteps.push(...steps);
+  }
+  const baselineWorkflow = [...new Set(allSteps)].slice(0, 12);
+  const profile = getModelProfile(input.model.name);
+  const recipe = resolveRecipe(profile, taskType, baselineWorkflow, inheritedSkills);
+  const policy = buildPolicy(recipe, input);
+  const artifacts = materialize(policy, profile, input);
+  const strengths = [];
+  const weaknesses = [];
+  const t = profile.traits;
+  if (t.instructionFollowing === "high") strengths.push("\u6307\u4EE4\u8DDF\u968F\u80FD\u529B\u5F3A");
+  else if (t.instructionFollowing === "low") weaknesses.push("\u6307\u4EE4\u8DDF\u968F\u80FD\u529B\u5F31");
+  if (t.schemaDiscipline === "high") strengths.push("\u7ED3\u6784\u5316\u8F93\u51FA\u9075\u5B88\u7A0B\u5EA6\u9AD8");
+  else if (t.schemaDiscipline === "low") weaknesses.push("\u7ED3\u6784\u5316\u8F93\u51FA\u9075\u5B88\u7A0B\u5EA6\u4F4E");
+  if (t.longContextStability === "high") strengths.push("\u957F\u4E0A\u4E0B\u6587\u7A33\u5B9A\u6027\u597D");
+  else if (t.longContextStability === "low") weaknesses.push("\u957F\u4E0A\u4E0B\u6587\u7A33\u5B9A\u6027\u5DEE");
+  if (t.multiStepStability === "high") strengths.push("\u591A\u6B65\u63A8\u7406\u7A33\u5B9A");
+  else if (t.multiStepStability === "low") weaknesses.push("\u591A\u6B65\u63A8\u7406\u7A33\u5B9A\u6027\u4F4E");
+  if (t.hallucinationRisk === "low") strengths.push("\u5E7B\u89C9\u98CE\u9669\u4F4E");
+  else if (t.hallucinationRisk === "high") weaknesses.push("\u5E7B\u89C9\u98CE\u9669\u9AD8");
+  if (t.selfCorrection === "high") strengths.push("\u81EA\u6211\u7EA0\u9519\u80FD\u529B\u5F3A");
+  else if (t.selfCorrection === "low") weaknesses.push("\u81EA\u6211\u7EA0\u9519\u80FD\u529B\u5F31");
+  const modelProfileSummary = {
+    strengths,
+    weaknesses,
+    promptStyle: profile.preferences.promptStyle
+  };
+  return {
+    resolvedTaskType: taskType,
+    modelProfileSummary,
+    executionPolicy: policy,
+    materializedArtifacts: artifacts,
+    recipeCandidate: {
+      model: recipe.model,
+      taskType: recipe.taskType,
+      inheritedSkills: recipe.inheritedSkills
+    }
+  };
+}
+
+// src/ui/App.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+async function handleAutomationCommand(input, manager, sessionContext) {
+  if (!input.startsWith("/")) return null;
+  const spaceIdx = input.indexOf(" ");
+  const command = spaceIdx === -1 ? input : input.slice(0, spaceIdx);
+  const args = spaceIdx === -1 ? "" : input.slice(spaceIdx + 1);
+  switch (command) {
+    case "/loop":
+      return manager.cmdLoop(args);
+    // 传入会话快照：goal blocked 时可生成 ecode --fork 回滚命令
+    case "/goal":
+      return manager.cmdGoal(args, sessionContext);
+    case "/jobs":
+      return manager.cmdJobs();
+    case "/unloop":
+      return manager.cmdUnloop(args.trim());
+    case "/ungoal":
+      return manager.cmdUngoal(args.trim());
+    default:
+      return null;
+  }
+}
+function handleMetaAlignCommand(input) {
+  if (!input.startsWith("/meta-align")) return null;
+  const parts = input.slice("/meta-align".length).trim().split(/\s+/);
+  if (parts.length === 0 || !parts[0]) {
+    return [
+      "**\u7528\u6CD5\uFF1A** `/meta-align <model> [task-type] [goal]`",
+      "",
+      "**\u793A\u4F8B\uFF1A**",
+      "- `/meta-align gpt-4o bugfix \u4FEE\u590D\u767B\u5F55\u9875\u5D29\u6E83\u95EE\u9898`",
+      "- `/meta-align MiniMax-M2.5 code-review`",
+      "- `/meta-align deepseek-chat \u9006\u5411\u5206\u6790 src/ui \u76EE\u5F55\u7ED3\u6784`"
+    ].join("\n");
+  }
+  const VALID_TASK_TYPES = /* @__PURE__ */ new Set([
+    "bugfix",
+    "refactor",
+    "test-generation",
+    "code-review",
+    "code-reverse-design"
+  ]);
+  const model = parts[0];
+  let taskType;
+  let goalParts;
+  if (parts.length >= 2 && VALID_TASK_TYPES.has(parts[1])) {
+    taskType = parts[1];
+    goalParts = parts.slice(2);
+  } else {
+    goalParts = parts.slice(1);
+  }
+  const goal = goalParts.join(" ") || `\u4F7F\u7528 ${model} \u5B8C\u6210\u4EFB\u52A1`;
+  const alignInput = {
+    model: { name: model },
+    task: {
+      type: taskType,
+      goal
+    }
+  };
+  try {
+    const result = runMetaAlign(alignInput);
+    return formatMetaAlignOutput(result, model);
+  } catch (err) {
+    return `**[meta-align \u9519\u8BEF]** ${String(err)}`;
+  }
+}
+function formatMetaAlignOutput(result, model) {
+  const { resolvedTaskType, modelProfileSummary, executionPolicy, materializedArtifacts } = result;
+  const lines = [
+    `## meta-align \u7ED3\u679C`,
+    ``,
+    `**\u6A21\u578B\uFF1A** ${model}  `,
+    `**\u4EFB\u52A1\u7C7B\u578B\uFF1A** ${resolvedTaskType}  `,
+    `**\u6267\u884C\u6A21\u5F0F\uFF1A** ${executionPolicy.mode === "multi_step" ? "\u591A\u6B65\u6267\u884C" : "\u5355\u6B65\u6267\u884C"}`,
+    ``
+  ];
+  if (modelProfileSummary.strengths.length > 0) {
+    lines.push(`### \u6A21\u578B\u4F18\u52BF`);
+    for (const s of modelProfileSummary.strengths) lines.push(`- ${s}`);
+    lines.push(``);
+  }
+  if (modelProfileSummary.weaknesses.length > 0) {
+    lines.push(`### \u6A21\u578B\u5F31\u70B9`);
+    for (const w of modelProfileSummary.weaknesses) lines.push(`- ${w}`);
+    lines.push(``);
+  }
+  if (executionPolicy.selectedSkills.length > 0) {
+    lines.push(`### \u9009\u7528 Skills`);
+    for (const sk of executionPolicy.selectedSkills) lines.push(`- \`${sk}\``);
+    lines.push(``);
+  }
+  if (executionPolicy.stepPlan.length > 0) {
+    lines.push(`### \u6267\u884C\u6B65\u9AA4`);
+    executionPolicy.stepPlan.forEach((step, i) => lines.push(`${i + 1}. ${step}`));
+    lines.push(``);
+  }
+  lines.push(`### \u4E0A\u4E0B\u6587\u5C01\u88C5\u987A\u5E8F`);
+  executionPolicy.contextPackaging.order.forEach((o, i) => lines.push(`${i + 1}. ${o}`));
+  lines.push(``);
+  lines.push(`### Worker Prompt`);
+  lines.push(``);
+  lines.push("```");
+  lines.push(materializedArtifacts.workerPrompt);
+  lines.push("```");
+  lines.push(``);
+  lines.push(
+    `**Retry \u7B56\u7565\uFF1A** \u6700\u591A ${executionPolicy.revisionPolicy.maxRetries} \u6B21  `,
+    `**Retry \u65B9\u5F0F\uFF1A** ${executionPolicy.revisionPolicy.retryStyle}`
+  );
+  return lines.join("\n");
+}
+function App({ config, version, autoMode = false, registry, trustedSkillDirs = [], initialMessages = [], llmClient }) {
+  const { stdout } = useStdout();
+  const { stdin } = useStdin();
+  const historyMaxHeight = Math.max(5, ((stdout == null ? void 0 : stdout.rows) ?? 24) - 4);
+  const [messages, setMessages] = useState3(initialMessages);
+  const [status, setStatus] = useState3("idle");
+  const contextLimit = getContextLimit(config.model, config.contextLimit);
+  const [tokenUsage, setTokenUsage] = useState3({
+    used: 0,
+    estimated: true,
+    limit: contextLimit
+  });
+  const [toolName, setToolName] = useState3(void 0);
+  const [confirmPrompt, setConfirmPrompt] = useState3(void 0);
+  const [expandTools, setExpandTools] = useState3(false);
+  const [scrollOffset, setScrollOffset] = useState3(0);
+  const [inputHistory, setInputHistory] = useState3([]);
+  const inputHistoryRef = useRef2([]);
+  inputHistoryRef.current = inputHistory;
+  const historyIndexRef = useRef2(-1);
+  const isNavigatingHistoryRef = useRef2(false);
+  const totalLines = useMemo(() => {
+    const visible = messages.filter((m) => m.role !== "system");
+    return visible.reduce(
+      (acc, msg) => acc + messageToLines(msg, expandTools, (stdout == null ? void 0 : stdout.columns) ?? 0).length,
+      0
+    );
+  }, [messages, expandTools, stdout == null ? void 0 : stdout.columns]);
+  const totalLinesRef = useRef2(totalLines);
+  totalLinesRef.current = totalLines;
+  const pendingConfirmRef = useRef2(null);
+  const abortControllerRef = useRef2(null);
+  const llmRef = useRef2(llmClient ?? createProvider(resolveActiveProfile(config)));
+  const automationDataDir = config.logDir ? join4(config.logDir, "automation") : join4(homedir2(), ".config", "ecode", "automation");
+  const automationManagerRef = useRef2(
+    new AutomationManager({
+      dataDir: automationDataDir,
+      logDir: automationDataDir,
+      llmClient: llmRef.current,
+      onJobResult: (_jobId, message) => {
+        setMessages((prev) => [...prev, { role: "assistant", content: message }]);
+      }
+    })
+  );
+  const inputRef = useRef2(null);
+  const [skillTools, setSkillTools] = useState3([]);
+  const skillToolsRef = useRef2([]);
+  skillToolsRef.current = skillTools;
+  const [acState, setAcState] = useState3(getInitialState());
+  const [fileAcState, setFileAcState] = useState3(getInitialState2());
+  const [fileSuggestions, setFileSuggestions] = useState3([]);
+  const loggerRef = useRef2(null);
+  const loggedCountRef = useRef2(0);
+  const sessionMetaRef = useRef2(null);
+  const finalTokensRef = useRef2(0);
+  useEffect3(() => {
+    if (config.logDir) {
+      const now = /* @__PURE__ */ new Date();
+      loggerRef.current = createLogger(config.logDir, now);
+      const meta = createSessionMetadata(loggerRef.current.filePath, config.model);
+      writeSessionMetadata(loggerRef.current.filePath, meta);
+      sessionMetaRef.current = meta;
+    }
+  }, []);
+  useEffect3(() => {
+    if (!loggerRef.current) return;
+    for (let i = loggedCountRef.current; i < messages.length; i++) {
+      const msg = messages[i];
+      loggerRef.current.append({
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        role: msg.role,
+        // content 可能为 null（纯工具调用的 assistant 消息），日志中保留 null
+        content: typeof msg.content === "string" ? msg.content : null,
+        // tool_call_id 只在 tool 角色消息中存在，用于关联工具调用与结果
+        tool_call_id: "tool_call_id" in msg ? msg.tool_call_id : void 0,
+        // tool_calls 只在 assistant 角色消息中存在（当 LLM 决定调用工具时）
+        tool_calls: "tool_calls" in msg ? msg.tool_calls : void 0
+      });
+    }
+    loggedCountRef.current = messages.length;
+  }, [messages]);
+  useEffect3(() => {
+    void automationManagerRef.current.start();
+    return () => {
+      automationManagerRef.current.stop();
+    };
+  }, []);
+  useEffect3(() => {
+    if (!stdin || !stdout) return;
+    stdout.write("\x1B[?1000h\x1B[?1006h");
+    const origEmit = stdin.emit;
+    stdin.emit = function(event, ...args) {
+      if (event === "readable") {
+        const chunk = stdin.read();
+        if (chunk !== null) {
+          const s = typeof chunk === "string" ? chunk : chunk.toString("binary");
+          const mouseLen = mouseEventLength(s);
+          if (mouseLen > 0) {
+            const mouseStr = s.slice(0, mouseLen);
+            const scrollEvent = parseMouseScroll(mouseStr);
+            if (scrollEvent) {
+              if (scrollEvent.direction === "up") {
+                setScrollOffset((prev) => Math.min(prev + 3, Math.max(0, totalLinesRef.current - 1)));
+              } else {
+                setScrollOffset((prev) => Math.max(0, prev - 3));
+              }
+            }
+            const remainder = s.slice(mouseLen);
+            if (remainder.length > 0) {
+              stdin.unshift(
+                typeof chunk === "string" ? remainder : Buffer.from(remainder, "binary")
+              );
+            }
+          } else {
+            stdin.unshift(chunk);
+          }
+        }
+      }
+      return origEmit.apply(stdin, [event, ...args]);
+    };
+    return () => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+      stdin.emit = origEmit;
+    };
+  }, [stdin, stdout]);
+  useEffect3(() => {
+    const atFragment = extractAtQuery(fileAcState.query);
+    if (atFragment === null) {
+      setFileSuggestions([]);
+      return;
+    }
+    let cancelled = false;
+    listFilesForQuery(atFragment, process.cwd()).then((entries) => {
+      if (!cancelled) setFileSuggestions(entries);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [fileAcState.query]);
+  useInput2((input, key) => {
+    var _a, _b, _c, _d, _e;
+    if (key.escape && status === "thinking" && abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      return;
+    }
+    const fileOpen = isOpen2(fileAcState, fileSuggestions);
+    if (fileOpen) {
+      if (key.upArrow) {
+        setFileAcState((prev) => moveUp2(prev, fileSuggestions.length));
+        return;
+      }
+      if (key.downArrow) {
+        setFileAcState((prev) => moveDown2(prev, fileSuggestions.length));
+        return;
+      }
+      if (key.escape) {
+        setFileAcState((prev) => dismiss2(prev));
+        return;
+      }
+      if (key.tab) {
+        const selected = fileSuggestions[fileAcState.selectedIndex];
+        if (selected) {
+          const newText = confirmSelection(fileAcState.query, selected.path);
+          (_a = inputRef.current) == null ? void 0 : _a.fill(newText);
+        }
+        return;
+      }
+    }
+    const skillList = (registry == null ? void 0 : registry.list()) ?? [];
+    const suggestions = computeSuggestions(skillList, acState);
+    const open = isOpen(acState, suggestions);
+    if (open) {
+      if (key.upArrow) {
+        setAcState((prev) => moveUp(prev, suggestions.length));
+        return;
+      }
+      if (key.downArrow) {
+        setAcState((prev) => moveDown(prev, suggestions.length));
+        return;
+      }
+      if (key.escape) {
+        setAcState((prev) => dismiss(prev));
+        return;
+      }
+      if (key.tab) {
+        const selected = suggestions[acState.selectedIndex];
+        if (selected) {
+          (_b = inputRef.current) == null ? void 0 : _b.fill(`/${selected.name} `);
+        }
+        return;
+      }
+    }
+    if (key.tab) {
+      setExpandTools((prev) => !prev);
+      return;
+    }
+    const scrollStep = Math.max(1, Math.floor(historyMaxHeight / 2));
+    if (key.pageUp) {
+      setScrollOffset((prev) => Math.min(prev + scrollStep, Math.max(0, totalLines - 1)));
+      return;
+    }
+    if (key.pageDown) {
+      setScrollOffset((prev) => Math.max(0, prev - scrollStep));
+      return;
+    }
+    if (key.ctrl && input === "v") {
+      setScrollOffset((prev) => Math.max(0, prev - scrollStep));
+      return;
+    }
+    if (key.meta && input === "v") {
+      setScrollOffset((prev) => Math.min(prev + scrollStep, Math.max(0, totalLines - 1)));
+      return;
+    }
+    if (key.ctrl && input === "p") {
+      const history = inputHistoryRef.current;
+      const newIndex = Math.min(historyIndexRef.current + 1, history.length - 1);
+      if (newIndex >= 0 && newIndex < history.length) {
+        historyIndexRef.current = newIndex;
+        isNavigatingHistoryRef.current = true;
+        (_c = inputRef.current) == null ? void 0 : _c.fill(history[newIndex]);
+      }
+      return;
+    }
+    if (key.ctrl && input === "n") {
+      const history = inputHistoryRef.current;
+      if (historyIndexRef.current > 0) {
+        const newIndex = historyIndexRef.current - 1;
+        historyIndexRef.current = newIndex;
+        isNavigatingHistoryRef.current = true;
+        (_d = inputRef.current) == null ? void 0 : _d.fill(history[newIndex]);
+      } else if (historyIndexRef.current === 0) {
+        historyIndexRef.current = -1;
+        isNavigatingHistoryRef.current = true;
+        (_e = inputRef.current) == null ? void 0 : _e.fill("");
+      }
+      return;
+    }
+  });
+  const confirm = useCallback((prompt) => {
+    return new Promise((resolve2) => {
+      setStatus("awaiting_confirm");
+      setConfirmPrompt(prompt);
+      pendingConfirmRef.current = { resolve: resolve2 };
+    });
+  }, []);
+  const runLlmLoop = useCallback(
+    async (history) => {
+      const print = (_text) => {
+      };
+      const deps = {
+        executeBash,
+        confirm,
+        print,
+        dangerousPatterns: config.dangerousPatterns,
+        // autoMode=true 时自动同意 normal 级工具调用，无需用户确认
+        autoApproveNormal: autoMode
+      };
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      let currentMessages = history;
+      let continueLoop = true;
+      let wasAborted = false;
+      while (continueLoop && !wasAborted) {
+        continueLoop = false;
+        setStatus("thinking");
+        let assistantText = "";
+        let assistantReasoning;
+        const toolCalls = [];
+        const dynamicTools = skillToolsRef.current.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.parameters }
+        }));
+        try {
+          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) => {
+                const last = prev[prev.length - 1];
+                if ((last == null ? void 0 : last.role) === "assistant" && !last.tool_calls) {
+                  return [...prev.slice(0, -1), { ...last, content: assistantText }];
+                }
+                return [...prev, { role: "assistant", content: assistantText }];
+              });
+            }
+            if (chunk.done) {
+              if (chunk.toolCalls) toolCalls.push(...chunk.toolCalls);
+              if (chunk.reasoning) assistantReasoning = chunk.reasoning;
+              if (chunk.usage) {
+                setTokenUsage({
+                  used: chunk.usage.totalTokens,
+                  estimated: false,
+                  limit: getContextLimit(config.model, config.contextLimit)
+                });
+                finalTokensRef.current = chunk.usage.totalTokens;
+              }
+            } else {
+              const estimatedUsed = Math.floor(
+                currentMessages.reduce(
+                  (acc, m) => acc + (typeof m.content === "string" ? m.content.length : 0),
+                  0
+                ) * 0.25 + assistantText.length * 0.25
+              );
+              setTokenUsage((prev) => ({ ...prev, used: estimatedUsed, estimated: true }));
+            }
+          }
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError") {
+            if (assistantText) {
+              setMessages((prev) => {
+                const last = prev[prev.length - 1];
+                const partial = { role: "assistant", content: assistantText };
+                return (last == null ? void 0 : last.role) === "assistant" && !last.tool_calls ? [...prev.slice(0, -1), partial] : [...prev, partial];
+              });
+            }
+            wasAborted = true;
+            setStatus("idle");
+            setToolName(void 0);
+            abortControllerRef.current = null;
+            return;
+          }
+          throw err;
+        }
+        if (toolCalls.length > 0) {
+          const assistantMsg = {
+            role: "assistant",
+            // content 可能为空字符串（纯工具调用），存 null 符合 OpenAI API 规范
+            content: assistantText || null,
+            tool_calls: toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function",
+              function: { name: tc.name, arguments: tc.arguments }
+            })),
+            // 仅在存在思考内容时扩展 reasoning_content 字段
+            ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+          };
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            const withoutStreaming = (last == null ? void 0 : last.role) === "assistant" && !last.tool_calls ? prev.slice(0, -1) : prev;
+            return [...withoutStreaming, assistantMsg];
+          });
+          currentMessages = [...currentMessages, assistantMsg];
+          setStatus("tool_calling");
+          for (const tc of toolCalls) {
+            setToolName(tc.name);
+            let toolResult;
+            if (tc.name === "bash") {
+              let args;
+              try {
+                args = JSON.parse(tc.arguments);
+              } catch {
+                args = { command: "" };
+              }
+              toolResult = await handleBashTool(args.command, deps);
+            } else if (tc.name === "read") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await readFile(args);
+            } else if (tc.name === "write") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await writeFile(args);
+            } else if (tc.name === "edit") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await editFile(args);
+            } else if (tc.name === "glob") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await globFiles(args);
+            } else if (tc.name === "grep") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await grepFiles(args);
+            } else if (tc.name === "apply_patch") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await applyPatch(args);
+            } else if (tc.name === "todo") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = todo(args);
+            } else if (tc.name === "task") {
+              const args = JSON.parse(tc.arguments);
+              toolResult = await handleTaskTool(args, {
+                provider: llmRef.current,
+                print: (text) => process.stdout.write(text),
+                logDir: config.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) {
+                let toolArgs = {};
+                try {
+                  toolArgs = JSON.parse(tc.arguments);
+                } catch {
+                }
+                toolResult = await executeSkillTool(skillTool, toolArgs, trustedSkillDirs);
+              } else {
+                toolResult = `Unknown tool: ${tc.name}`;
+              }
+            }
+            const toolMsg = {
+              role: "tool",
+              tool_call_id: tc.id,
+              content: toolResult
+            };
+            setMessages((prev) => [...prev, toolMsg]);
+            currentMessages = [...currentMessages, toolMsg];
+          }
+          continueLoop = true;
+        } else {
+          setMessages((prev) => {
+            const last = prev[prev.length - 1];
+            if ((last == null ? void 0 : last.role) === "assistant" && !last.tool_calls) {
+              const updated = {
+                role: "assistant",
+                content: assistantText,
+                ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+              };
+              return [...prev.slice(0, -1), updated];
+            }
+            return prev;
+          });
+          if (assistantText) {
+            currentMessages = [
+              ...currentMessages,
+              {
+                role: "assistant",
+                content: assistantText,
+                ...assistantReasoning ? { reasoning_content: assistantReasoning } : {}
+              }
+            ];
+          }
+        }
+      }
+      if (loggerRef.current && sessionMetaRef.current) {
+        const prev = sessionMetaRef.current;
+        const updated = {
+          lastActivity: (/* @__PURE__ */ new Date()).toISOString(),
+          totalTokens: finalTokensRef.current,
+          turnCount: prev.turnCount + 1
+        };
+        updateSessionMetadata(loggerRef.current.filePath, updated);
+        sessionMetaRef.current = { ...prev, ...updated };
+      }
+      setStatus("idle");
+      setToolName(void 0);
+      abortControllerRef.current = null;
+    },
+    [confirm, config.dangerousPatterns, autoMode]
+  );
+  const handleSubmit = useCallback(
+    async (text) => {
+      var _a, _b;
+      const trimmed = text.trim();
+      if (status === "awaiting_confirm") {
+        const pending = pendingConfirmRef.current;
+        if (pending) {
+          pendingConfirmRef.current = null;
+          setConfirmPrompt(void 0);
+          setStatus("tool_calling");
+          pending.resolve(trimmed.toLowerCase() === "y");
+        }
+        return;
+      }
+      if (!trimmed) return;
+      setInputHistory((prev) => [trimmed, ...prev.slice(0, 99)]);
+      historyIndexRef.current = -1;
+      setScrollOffset(0);
+      {
+        const automationResult = await handleAutomationCommand(
+          trimmed,
+          automationManagerRef.current,
+          // 注入会话快照：/goal blocked 时用于生成 ecode --fork 回滚命令
+          {
+            logFile: (_a = loggerRef.current) == null ? void 0 : _a.filePath,
+            turnCount: (_b = sessionMetaRef.current) == null ? void 0 : _b.turnCount
+          }
+        );
+        if (automationResult !== null) {
+          setMessages((prev) => [
+            ...prev,
+            { role: "user", content: trimmed },
+            { role: "assistant", content: automationResult }
+          ]);
+          return;
+        }
+      }
+      {
+        const metaAlignResult = handleMetaAlignCommand(trimmed);
+        if (metaAlignResult !== null) {
+          setMessages((prev) => [
+            ...prev,
+            { role: "user", content: trimmed },
+            { role: "assistant", content: metaAlignResult }
+          ]);
+          return;
+        }
+      }
+      if (registry) {
+        const skillResult = handleSkillInput(trimmed, registry);
+        if (skillResult.type === "error") {
+          setMessages((prev) => [
+            ...prev,
+            { role: "assistant", content: skillResult.message }
+          ]);
+          return;
+        }
+        if (skillResult.type === "skill") {
+          const { skill } = skillResult;
+          setSkillTools(skill.tools);
+          if (skill.preScript) {
+            try {
+              await executePreScript(skill, trustedSkillDirs);
+            } catch (preErr) {
+              setMessages((prev) => [
+                ...prev,
+                { role: "assistant", content: `[pre.sh error] ${String(preErr)}` }
+              ]);
+            }
+          }
+          const nextMessages2 = [...messages, skillResult.message];
+          setMessages(nextMessages2);
+          runLlmLoop(nextMessages2).catch((err) => {
+            setStatus("idle");
+            setToolName(void 0);
+            setMessages((prev) => [
+              ...prev,
+              { role: "assistant", content: `[error] ${String(err)}` }
+            ]);
+          });
+          return;
+        }
+      }
+      let content = trimmed;
+      try {
+        content = await expandFileRefs(trimmed, process.cwd());
+      } catch {
+      }
+      const userMsg = { role: "user", content };
+      const nextMessages = [...messages, userMsg];
+      setMessages(nextMessages);
+      if (loggerRef.current && sessionMetaRef.current && !sessionMetaRef.current.title) {
+        const title = generateTitle(content);
+        updateSessionMetadata(loggerRef.current.filePath, { title });
+        sessionMetaRef.current = { ...sessionMetaRef.current, title };
+      }
+      runLlmLoop(nextMessages).catch((err) => {
+        setStatus("idle");
+        setToolName(void 0);
+        setMessages((prev) => [
+          ...prev,
+          { role: "assistant", content: `[error] ${String(err)}` }
+        ]);
+      });
+    },
+    [status, messages, runLlmLoop]
+  );
+  const isInputActive = status === "idle" || status === "awaiting_confirm";
+  const handleInputTextChange = useCallback((text) => {
+    if (isNavigatingHistoryRef.current) {
+      isNavigatingHistoryRef.current = false;
+    } else {
+      historyIndexRef.current = -1;
+    }
+    if (status !== "awaiting_confirm") {
+      setAcState((prev) => handleInputChange(prev, text));
+      setFileAcState((prev) => handleInputChange2(prev, text));
+    }
+  }, [status]);
+  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(
+      ConversationHistory,
+      {
+        messages,
+        expandTools,
+        maxHeight: historyMaxHeight,
+        terminalWidth: stdout == null ? void 0 : stdout.columns,
+        scrollOffset
+      }
+    ) }),
+    /* @__PURE__ */ jsx6(
+      StatusBar,
+      {
+        status,
+        toolName,
+        confirmPrompt,
+        version,
+        tokenUsage
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      SkillAutocomplete,
+      {
+        suggestions: skillSuggestions,
+        selectedIndex: acState.selectedIndex,
+        isOpen: acOpen
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      FileAutocomplete,
+      {
+        suggestions: fileSuggestions,
+        selectedIndex: fileAcState.selectedIndex,
+        isOpen: isOpen2(fileAcState, fileSuggestions)
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      Input_default,
+      {
+        ref: inputRef,
+        isActive: isInputActive,
+        onSubmit: handleSubmit,
+        onChange: handleInputTextChange,
+        placeholder: status === "awaiting_confirm" ? "y / n" : void 0
+      }
+    )
+  ] });
+}
+export {
+  App,
+  default2 as React,
+  render
+};