@zhongqian97-code/ecode 0.5.8 → 0.5.10

package/dist/index.js

@@ -3,11 +3,11 @@ const _ew=process.emitWarning.bind(process);process.emitWarning=function(w,...a)
 
 // src/index.ts
 import { createRequire } from "module";
-import { resolve as resolve4, dirname as dirname7 } from "path";
-import { fileURLToPath } from "url";
+import { resolve as resolve5, dirname as dirname9 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import React4 from "react";
 import { render } from "ink";
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 
 // src/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -540,13 +540,13 @@ function classifyCommand(cmd, dangerPatterns, _depth = 0) {
 import { exec } from "child_process";
 var DEFAULT_TIMEOUT_MS = 3e4;
 function executeBash(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     exec(cmd, { timeout: timeoutMs }, (err, stdout, stderr) => {
       if (err) {
         const exitCode = err.code ?? 1;
-        resolve5({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
+        resolve6({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode });
       } else {
-        resolve5({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode: 0 });
+        resolve6({ stdout: stdout ?? "", stderr: stderr ?? "", exitCode: 0 });
       }
     });
   });
@@ -571,13 +571,13 @@ var READ_TOOL = {
   }
 };
 async function readFile2(params) {
-  const { path: path9, offset = 0, limit } = params;
+  const { path: path11, offset = 0, limit } = params;
   let raw;
   try {
-    raw = await fs.readFile(path9, "utf8");
+    raw = await fs.readFile(path11, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path9}: ${msg}`;
+    return `Error reading ${path11}: ${msg}`;
   }
   const lines = raw.split("\n");
   const sliced = limit !== void 0 ? lines.slice(offset, offset + limit) : lines.slice(offset);
@@ -633,28 +633,28 @@ var EDIT_TOOL = {
   }
 };
 async function editFile(params) {
-  const { path: path9, old_string, new_string } = params;
+  const { path: path11, old_string, new_string } = params;
   let content;
   try {
-    content = await fs3.readFile(path9, "utf8");
+    content = await fs3.readFile(path11, "utf8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error reading ${path9}: ${msg}`;
+    return `Error reading ${path11}: ${msg}`;
   }
   const count = countOccurrences(content, old_string);
   if (count === 0) {
-    return `Error: old_string not found in ${path9}`;
+    return `Error: old_string not found in ${path11}`;
   }
   if (count > 1) {
-    return `Error: old_string appears ${count} times in ${path9} (ambiguous \u2014 add more context)`;
+    return `Error: old_string appears ${count} times in ${path11} (ambiguous \u2014 add more context)`;
   }
   const updated = content.replace(old_string, new_string);
   try {
-    await fs3.writeFile(path9, updated, "utf8");
-    return `Edited ${path9}`;
+    await fs3.writeFile(path11, updated, "utf8");
+    return `Edited ${path11}`;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    return `Error writing ${path9}: ${msg}`;
+    return `Error writing ${path11}: ${msg}`;
   }
 }
 function countOccurrences(haystack, needle) {
@@ -2169,8 +2169,8 @@ function parseMouseScroll(data) {
 }
 
 // src/ui/App.tsx
-import { homedir as homedir2 } from "os";
-import { join as join10 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join11 } from "path";
 
 // src/automation/store.ts
 import { readFile as readFile8, writeFile as writeFile5, mkdir as mkdir2 } from "fs/promises";
@@ -2268,11 +2268,17 @@ async function executeJob(job, config2) {
 
 // src/automation/goal/evaluator.ts
 function parseVerdict(response) {
-  const lower = response.toLowerCase();
-  if (lower.includes("not_done")) return "not_done";
-  if (lower.includes("blocked")) return "blocked";
-  if (lower.includes("done")) return "done";
-  return "not_done";
+  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 [
@@ -2492,6 +2498,15 @@ async function cmdLoop(args, deps) {
       intervalMs = parsed.intervalMs;
       prompt = trimmed.slice(spaceIdx + 1).trim();
     }
+  } 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 = {
@@ -2542,6 +2557,9 @@ async function cmdUnloop(idOrPrefix, deps) {
 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(),
@@ -2784,11 +2802,11 @@ var AutomationManager = class {
         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((resolve5) => {
-        const timer = setTimeout(resolve5, 5e3);
+      await new Promise((resolve6) => {
+        const timer = setTimeout(resolve6, 5e3);
         signal.addEventListener("abort", () => {
           clearTimeout(timer);
-          resolve5();
+          resolve6();
         }, { once: true });
       });
     }
@@ -2874,6 +2892,801 @@ function generateTitle(firstUserMessage) {
   return oneLine.length > 50 ? oneLine.slice(0, 47) + "..." : oneLine;
 }
 
+// src/meta_skill/index.ts
+import * as fs11 from "fs";
+import * as path9 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) {
+  const steps = [];
+  let match;
+  NUMBERED_HEADINGS_RE.lastIndex = 0;
+  while ((match = NUMBERED_HEADINGS_RE.exec(body)) !== null) {
+    const text = match[2]?.trim();
+    if (text) steps.push(cleanStepText(text));
+  }
+  return steps;
+}
+function extractListSteps(body) {
+  const steps = [];
+  NUMBERED_LIST_RE.lastIndex = 0;
+  let match;
+  while ((match = NUMBERED_LIST_RE.exec(body)) !== null) {
+    const text = match[2]?.trim();
+    if (text) steps.push(cleanStepText(text));
+  }
+  return steps;
+}
+function extractParagraphSteps(body) {
+  return body.split(/\n{2,}/).map((para) => para.trim().split("\n")[0]?.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) {
+  const maxSteps = input.runtimeContext?.budget?.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,
+    input.task.scope?.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 fs10 from "fs";
+import * as path8 from "path";
+import * as os from "os";
+var STORE_PATH = path8.resolve(os.homedir(), ".ecode", "learning-records.jsonl");
+
+// src/meta_skill/index.ts
+function resolveBuiltinSkillsDir() {
+  try {
+    let dir = path9.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 4; i++) {
+      const candidate = path9.join(dir, "skills");
+      if (fs11.existsSync(candidate) && fs11.statSync(candidate).isDirectory()) {
+        return candidate;
+      }
+      const parent = path9.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 builtinSkillsDir2 = resolveBuiltinSkillsDir();
+  const allSteps = [];
+  for (const skillName of inheritedSkills) {
+    const candidates = [];
+    if (builtinSkillsDir2) {
+      candidates.push(path9.join(builtinSkillsDir2, skillName, "SKILL.md"));
+      candidates.push(path9.join(builtinSkillsDir2, skillName + ".md"));
+    }
+    candidates.push(path9.join(process.cwd(), "skills", skillName, "SKILL.md"));
+    candidates.push(path9.join(process.cwd(), "skills", skillName + ".md"));
+    let body = "";
+    for (const p of candidates) {
+      if (fs11.existsSync(p)) {
+        body = fs11.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) {
@@ -2897,6 +3710,95 @@ async function handleAutomationCommand(input, manager, sessionContext) {
       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: config2, version: version2, autoMode: autoMode2 = false, registry: registry2, trustedSkillDirs: trustedSkillDirs2 = [], initialMessages: initialMessages2 = [], llmClient }) {
   const { stdout } = useStdout();
   const { stdin } = useStdin();
@@ -2930,7 +3832,7 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
   const pendingConfirmRef = useRef2(null);
   const abortControllerRef = useRef2(null);
   const llmRef = useRef2(llmClient ?? createProvider(resolveActiveProfile(config2)));
-  const automationDataDir = config2.logDir ? join10(config2.logDir, "automation") : join10(homedir2(), ".config", "ecode", "automation");
+  const automationDataDir = config2.logDir ? join11(config2.logDir, "automation") : join11(homedir3(), ".config", "ecode", "automation");
   const automationManagerRef = useRef2(
     new AutomationManager({
       dataDir: automationDataDir,
@@ -3136,10 +4038,10 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
     }
   });
   const confirm = useCallback((prompt) => {
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       setStatus("awaiting_confirm");
       setConfirmPrompt(prompt);
-      pendingConfirmRef.current = { resolve: resolve5 };
+      pendingConfirmRef.current = { resolve: resolve6 };
     });
   }, []);
   const runLlmLoop = useCallback(
@@ -3370,6 +4272,17 @@ function App({ config: config2, version: version2, autoMode: autoMode2 = false,
           return;
         }
       }
+      {
+        const metaAlignResult = handleMetaAlignCommand(trimmed);
+        if (metaAlignResult !== null) {
+          setMessages((prev) => [
+            ...prev,
+            { role: "user", content: trimmed },
+            { role: "assistant", content: metaAlignResult }
+          ]);
+          return;
+        }
+      }
       if (registry2) {
         const skillResult = handleSkillInput(trimmed, registry2);
         if (skillResult.type === "error") {
@@ -3651,19 +4564,19 @@ async function runPipe(prompt, llm, out = process.stdout, systemPrompt) {
   }
 }
 function readStdin() {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
       data += chunk;
     });
-    process.stdin.on("end", () => resolve5(data.trim()));
+    process.stdin.on("end", () => resolve6(data.trim()));
     process.stdin.on("error", reject);
   });
 }
 
 // src/sessions/command.ts
-import * as path8 from "path";
+import * as path10 from "path";
 function cmdSessionsList(logDir) {
   const sessions = listSessions(logDir);
   if (sessions.length === 0) return "(no sessions found)";
@@ -3685,13 +4598,13 @@ function cmdSessionsInspect(logDir, idOrPrefix) {
 function cmdSessionsReplay(logDir, idOrPrefix) {
   const session = findSession(logDir, idOrPrefix);
   if (!session) return `Session not found: ${idOrPrefix}`;
-  const logPath = path8.join(logDir, session.logFile);
+  const logPath = path10.join(logDir, session.logFile);
   return `ecode --replay ${logPath}`;
 }
 function cmdSessionsFork(logDir, idOrPrefix, turn) {
   const session = findSession(logDir, idOrPrefix);
   if (!session) return `Session not found: ${idOrPrefix}`;
-  const logPath = path8.join(logDir, session.logFile);
+  const logPath = path10.join(logDir, session.logFile);
   const turnStr = turn !== void 0 ? turn : session.turnCount;
   return `ecode --fork ${logPath}:${turnStr}`;
 }
@@ -3705,7 +4618,7 @@ function formatInspect(session, logDir) {
     `last active:  ${new Date(session.lastActivity).toLocaleString()}`,
     `turns:        ${session.turnCount}`,
     `tokens:       ${session.totalTokens.toLocaleString()}`,
-    `log file:     ${path8.join(logDir, session.logFile)}`
+    `log file:     ${path10.join(logDir, session.logFile)}`
   ].join("\n");
 }
 
@@ -3811,7 +4724,7 @@ if (!finalConfig.apiKey) {
 var initialMessages = [];
 if (replayFile) {
   try {
-    const raw = readFileSync3(replayFile, "utf-8");
+    const raw = readFileSync5(replayFile, "utf-8");
     initialMessages = parseReplayLog(raw);
   } catch (err) {
     console.error(`Error reading replay file: ${err}`);
@@ -3819,17 +4732,17 @@ if (replayFile) {
   }
 } else if (forkSpec) {
   try {
-    const raw = readFileSync3(forkSpec.file, "utf-8");
+    const raw = readFileSync5(forkSpec.file, "utf-8");
     initialMessages = truncateToTurn(parseReplayLog(raw), forkSpec.turn);
   } catch (err) {
     console.error(`Error reading fork file: ${err}`);
     process.exit(1);
   }
 }
-var __dirname = dirname7(fileURLToPath(import.meta.url));
-var builtinSkillsDir = resolve4(__dirname, "../skills");
-var userSkillsDir = resolve4(process.env.HOME ?? "~", ".ecode/skills");
-var projectSkillsDir = resolve4(process.cwd(), ".ecode/skills");
+var __dirname = dirname9(fileURLToPath2(import.meta.url));
+var builtinSkillsDir = resolve5(__dirname, "../skills");
+var userSkillsDir = resolve5(process.env.HOME ?? "~", ".ecode/skills");
+var projectSkillsDir = resolve5(process.cwd(), ".ecode/skills");
 var registry = new SkillRegistry();
 for (const dir of [builtinSkillsDir, userSkillsDir, projectSkillsDir]) {
   const skills = await loadSkillsFromDir(dir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhongqian97-code/ecode",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "A minimal Claude Code clone with REPL interface and bash tool calling",
   "type": "module",
   "author": "zhongqian97-code",