hamster-wheel-cli 0.1.0 → 0.2.0-beta.1

package/dist/cli.js

@@ -35,6 +35,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var import_node_child_process = require("child_process");
+var import_fs_extra12 = __toESM(require("fs-extra"));
 var import_commander = require("commander");
 
 // src/config.ts
@@ -201,7 +202,8 @@ function buildPrConfig(options) {
     title: options.prTitle,
     bodyPath: options.prBody,
     draft: options.draft,
-    reviewers: options.reviewers
+    reviewers: options.reviewers,
+    autoMerge: options.autoMerge
   };
 }
 function buildWebhookConfig(options) {
@@ -236,7 +238,8 @@ function buildLoopConfig(options, cwd) {
     runE2e: options.runE2e,
     autoCommit: options.autoCommit,
     autoPush: options.autoPush,
-    skipInstall: options.skipInstall
+    skipInstall: options.skipInstall,
+    skipQuality: options.skipQuality
   };
 }
 function defaultNotesPath() {
@@ -367,12 +370,79 @@ function parseTomlString(raw) {
   }
   return null;
 }
+function parseTomlKeyValue(line) {
+  const equalIndex = findUnquotedIndex(line, "=");
+  if (equalIndex <= 0) return null;
+  const key = line.slice(0, equalIndex).trim();
+  const valuePart = line.slice(equalIndex + 1).trim();
+  if (!key || !valuePart) return null;
+  const parsedValue = parseTomlString(valuePart);
+  if (parsedValue === null) return null;
+  return { key, value: parsedValue };
+}
 function normalizeShortcutName(name) {
   const trimmed = name.trim();
   if (!trimmed) return null;
   if (/\s/.test(trimmed)) return null;
   return trimmed;
 }
+function normalizeAliasName(name) {
+  return normalizeShortcutName(name);
+}
+function formatTomlString(value) {
+  const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${escaped}"`;
+}
+function updateAliasContent(content, name, command) {
+  const lines = content.split(/\r?\n/);
+  const entryLine = `${name} = ${formatTomlString(command)}`;
+  let currentSection = null;
+  let aliasStart = -1;
+  let aliasEnd = lines.length;
+  for (let i = 0; i < lines.length; i += 1) {
+    const match = /^\s*\[(.+?)\]\s*$/.exec(lines[i]);
+    if (!match) continue;
+    if (currentSection === "alias" && aliasStart >= 0 && aliasEnd === lines.length) {
+      aliasEnd = i;
+    }
+    currentSection = match[1].trim();
+    if (currentSection === "alias") {
+      aliasStart = i;
+    }
+  }
+  if (aliasStart < 0) {
+    const trimmed = content.trimEnd();
+    const prefix = trimmed.length > 0 ? `${trimmed}
+
+` : "";
+    return `${prefix}[alias]
+${entryLine}
+`;
+  }
+  let replaced = false;
+  for (let i = aliasStart + 1; i < aliasEnd; i += 1) {
+    const parsed = parseTomlKeyValue(stripTomlComment(lines[i]).trim());
+    if (!parsed) continue;
+    if (parsed.key === name) {
+      lines[i] = entryLine;
+      replaced = true;
+      break;
+    }
+  }
+  if (!replaced) {
+    lines.splice(aliasEnd, 0, entryLine);
+  }
+  const output = lines.join("\n");
+  return output.endsWith("\n") ? output : `${output}
+`;
+}
+async function upsertAliasEntry(name, command, filePath = getGlobalConfigPath()) {
+  const exists = await import_fs_extra2.default.pathExists(filePath);
+  const content = exists ? await import_fs_extra2.default.readFile(filePath, "utf8") : "";
+  const nextContent = updateAliasContent(content, name, command);
+  await import_fs_extra2.default.mkdirp(import_node_path3.default.dirname(filePath));
+  await import_fs_extra2.default.writeFile(filePath, nextContent, "utf8");
+}
 function parseGlobalConfig(content) {
   const lines = content.split(/\r?\n/);
   let currentSection = null;
@@ -386,14 +456,9 @@ function parseGlobalConfig(content) {
       continue;
     }
     if (currentSection !== "shortcut") continue;
-    const equalIndex = findUnquotedIndex(line, "=");
-    if (equalIndex <= 0) continue;
-    const key = line.slice(0, equalIndex).trim();
-    const valuePart = line.slice(equalIndex + 1).trim();
-    if (!key || !valuePart) continue;
-    const parsedValue = parseTomlString(valuePart);
-    if (parsedValue === null) continue;
-    shortcut[key] = parsedValue;
+    const parsed = parseTomlKeyValue(line);
+    if (!parsed) continue;
+    shortcut[parsed.key] = parsed.value;
   }
   const name = normalizeShortcutName(shortcut.name ?? "");
   const command = (shortcut.command ?? "").trim();
@@ -407,6 +472,43 @@ function parseGlobalConfig(content) {
     }
   };
 }
+function parseAliasEntries(content) {
+  const lines = content.split(/\r?\n/);
+  let currentSection = null;
+  const entries = [];
+  const names = /* @__PURE__ */ new Set();
+  for (const rawLine of lines) {
+    const line = stripTomlComment(rawLine).trim();
+    if (!line) continue;
+    const sectionMatch = /^\[(.+)\]$/.exec(line);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1].trim();
+      continue;
+    }
+    if (currentSection !== "alias") continue;
+    const parsed = parseTomlKeyValue(line);
+    if (!parsed) continue;
+    const name = normalizeShortcutName(parsed.key);
+    const command = parsed.value.trim();
+    if (!name || !command) continue;
+    if (names.has(name)) continue;
+    names.add(name);
+    entries.push({
+      name,
+      command,
+      source: "alias"
+    });
+  }
+  const shortcut = parseGlobalConfig(content).shortcut;
+  if (shortcut && !names.has(shortcut.name)) {
+    entries.push({
+      name: shortcut.name,
+      command: shortcut.command,
+      source: "shortcut"
+    });
+  }
+  return entries;
+}
 async function loadGlobalConfig(logger) {
   const filePath = getGlobalConfigPath();
   const exists = await import_fs_extra2.default.pathExists(filePath);
@@ -669,9 +771,10 @@ async function commitAll(message, cwd, logger) {
   });
   if (commit.exitCode !== 0) {
     logger.warn(`git commit \u8DF3\u8FC7\u6216\u5931\u8D25: ${commit.stderr}`);
-    return;
+    return false;
   }
   logger.success("\u5DF2\u63D0\u4EA4\u5F53\u524D\u53D8\u66F4");
+  return true;
 }
 async function pushBranch(branchName, cwd, logger) {
   const push = await runCommand("git", ["push", "-u", "origin", branchName], {
@@ -709,7 +812,30 @@ async function removeWorktree(worktreePath, repoRoot, logger) {
 function generateBranchName() {
   const now = /* @__PURE__ */ new Date();
   const stamp = `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, "0")}${now.getDate().toString().padStart(2, "0")}-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
-  return `wheel-aii/${stamp}`;
+  return `wheel-ai/${stamp}`;
+}
+function guessBranchType(task) {
+  const text = task.toLowerCase();
+  if (/fix|bug|修复|错误|异常|问题/.test(text)) return "fix";
+  if (/docs|readme|changelog|文档/.test(text)) return "docs";
+  if (/test|e2e|单测|测试/.test(text)) return "test";
+  if (/refactor|重构/.test(text)) return "refactor";
+  if (/chore|构建|依赖|配置/.test(text)) return "chore";
+  return "feat";
+}
+function slugifyTask(task) {
+  const slug = task.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.slice(0, 40);
+}
+function buildTimestampSlug(now) {
+  const stamp = `${now.getFullYear()}${(now.getMonth() + 1).toString().padStart(2, "0")}${now.getDate().toString().padStart(2, "0")}-${now.getHours().toString().padStart(2, "0")}${now.getMinutes().toString().padStart(2, "0")}`;
+  return `auto-${stamp}`;
+}
+function generateBranchNameFromTask(task, now = /* @__PURE__ */ new Date()) {
+  const slug = slugifyTask(task);
+  const type = guessBranchType(task);
+  const suffix = slug || buildTimestampSlug(now);
+  return `${type}/${suffix}`;
 }
 
 // src/logs.ts
@@ -797,8 +923,192 @@ async function removeCurrentRegistry(logFile) {
   await writeJsonFile(getCurrentRegistryPath(), registry);
 }
 
-// src/logs-viewer.ts
+// src/alias-viewer.ts
 var import_fs_extra4 = __toESM(require("fs-extra"));
+function getTerminalSize() {
+  const rows = process.stdout.rows ?? 24;
+  const columns = process.stdout.columns ?? 80;
+  return { rows, columns };
+}
+function truncateLine(line, width) {
+  if (width <= 0) return "";
+  if (line.length <= width) return line;
+  return line.slice(0, width);
+}
+function getPageSize(rows) {
+  return Math.max(1, rows - 2);
+}
+function buildAliasLabel(entry) {
+  if (entry.source === "shortcut") {
+    return `${entry.name}\uFF08shortcut\uFF09`;
+  }
+  return entry.name;
+}
+function buildHeader(state, columns) {
+  const total = state.aliases.length;
+  const title = `\u522B\u540D\u5217\u8868\uFF08${total} \u6761\uFF09\uFF5C\u2191/\u2193 \u9009\u62E9  q \u9000\u51FA`;
+  return truncateLine(title, columns);
+}
+function buildStatus(state, columns) {
+  if (state.aliases.length === 0) {
+    if (state.lastError) {
+      return truncateLine(`\u8BFB\u53D6\u5931\u8D25\uFF1A${state.lastError}`, columns);
+    }
+    if (state.missingConfig) {
+      return truncateLine(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${getGlobalConfigPath()}`, columns);
+    }
+    return truncateLine("\u672A\u53D1\u73B0 alias \u914D\u7F6E", columns);
+  }
+  const entry = state.aliases[state.selectedIndex];
+  const sourceText = entry.source === "shortcut" ? "\uFF08shortcut\uFF09" : "";
+  return truncateLine(`\u547D\u4EE4${sourceText}\uFF1A${entry.command}`, columns);
+}
+function buildListLine(entry, selected, columns) {
+  const marker = selected ? ">" : " ";
+  return truncateLine(`${marker} ${buildAliasLabel(entry)}`, columns);
+}
+function ensureListOffset(state, pageSize) {
+  const total = state.aliases.length;
+  if (total === 0) {
+    state.listOffset = 0;
+    state.selectedIndex = 0;
+    return;
+  }
+  const maxOffset = Math.max(0, total - pageSize);
+  if (state.selectedIndex < state.listOffset) {
+    state.listOffset = state.selectedIndex;
+  }
+  if (state.selectedIndex >= state.listOffset + pageSize) {
+    state.listOffset = state.selectedIndex - pageSize + 1;
+  }
+  state.listOffset = Math.min(Math.max(state.listOffset, 0), maxOffset);
+}
+function render(state) {
+  const { rows, columns } = getTerminalSize();
+  const pageSize = getPageSize(rows);
+  const header = buildHeader(state, columns);
+  ensureListOffset(state, pageSize);
+  if (state.aliases.length === 0) {
+    const filler = Array.from({ length: pageSize }, () => "");
+    const status2 = buildStatus(state, columns);
+    const content2 = [header, ...filler, status2].join("\n");
+    process.stdout.write(`\x1B[2J\x1B[H${content2}`);
+    return;
+  }
+  const start = state.listOffset;
+  const slice = state.aliases.slice(start, start + pageSize);
+  const lines = slice.map((entry, index) => {
+    const selected = start + index === state.selectedIndex;
+    return buildListLine(entry, selected, columns);
+  });
+  while (lines.length < pageSize) {
+    lines.push("");
+  }
+  const status = buildStatus(state, columns);
+  const content = [header, ...lines, status].join("\n");
+  process.stdout.write(`\x1B[2J\x1B[H${content}`);
+}
+function shouldExit(input) {
+  if (input === "") return true;
+  if (input.toLowerCase() === "q") return true;
+  return false;
+}
+function isArrowUp(input) {
+  return input.includes("\x1B[A");
+}
+function isArrowDown(input) {
+  return input.includes("\x1B[B");
+}
+function setupCleanup(cleanup) {
+  const exitHandler = () => {
+    cleanup();
+  };
+  const signalHandler = () => {
+    cleanup();
+    process.exit(0);
+  };
+  process.on("SIGINT", signalHandler);
+  process.on("SIGTERM", signalHandler);
+  process.on("exit", exitHandler);
+}
+function clampIndex(value, total) {
+  if (total <= 0) return 0;
+  return Math.min(Math.max(value, 0), total - 1);
+}
+async function runAliasViewer() {
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    console.log("\u5F53\u524D\u7EC8\u7AEF\u4E0D\u652F\u6301\u4EA4\u4E92\u5F0F alias\u3002");
+    return;
+  }
+  const state = {
+    aliases: [],
+    selectedIndex: 0,
+    listOffset: 0,
+    missingConfig: false
+  };
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    process.stdout.write("\x1B[?25h");
+  };
+  setupCleanup(cleanup);
+  process.stdout.write("\x1B[?25l");
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  const loadAliases = async () => {
+    const filePath = getGlobalConfigPath();
+    const exists = await import_fs_extra4.default.pathExists(filePath);
+    if (!exists) {
+      state.aliases = [];
+      state.selectedIndex = 0;
+      state.lastError = void 0;
+      state.missingConfig = true;
+      return;
+    }
+    try {
+      const content = await import_fs_extra4.default.readFile(filePath, "utf8");
+      state.aliases = parseAliasEntries(content);
+      state.selectedIndex = clampIndex(state.selectedIndex, state.aliases.length);
+      state.lastError = void 0;
+      state.missingConfig = false;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.aliases = [];
+      state.selectedIndex = 0;
+      state.lastError = message;
+      state.missingConfig = false;
+    }
+  };
+  await loadAliases();
+  render(state);
+  process.stdin.on("data", (data) => {
+    const input = data.toString("utf8");
+    if (shouldExit(input)) {
+      cleanup();
+      process.exit(0);
+    }
+    if (isArrowUp(input)) {
+      state.selectedIndex = clampIndex(state.selectedIndex - 1, state.aliases.length);
+      render(state);
+      return;
+    }
+    if (isArrowDown(input)) {
+      state.selectedIndex = clampIndex(state.selectedIndex + 1, state.aliases.length);
+      render(state);
+    }
+  });
+  process.stdout.on("resize", () => {
+    render(state);
+  });
+}
+
+// src/logs-viewer.ts
+var import_fs_extra5 = __toESM(require("fs-extra"));
 var import_node_path6 = __toESM(require("path"));
 function isRunMetadata(value) {
   if (!value || typeof value !== "object") return false;
@@ -811,10 +1121,10 @@ function buildLogMetaPath(logsDir, logFile) {
 }
 async function readLogMetadata(logsDir, logFile) {
   const metaPath = buildLogMetaPath(logsDir, logFile);
-  const exists = await import_fs_extra4.default.pathExists(metaPath);
+  const exists = await import_fs_extra5.default.pathExists(metaPath);
   if (!exists) return void 0;
   try {
-    const content = await import_fs_extra4.default.readFile(metaPath, "utf8");
+    const content = await import_fs_extra5.default.readFile(metaPath, "utf8");
     const parsed = JSON.parse(content);
     return isRunMetadata(parsed) ? parsed : void 0;
   } catch {
@@ -832,10 +1142,10 @@ function buildRunningLogKeys(registry) {
   return keys;
 }
 async function loadLogEntries(logsDir, registry) {
-  const exists = await import_fs_extra4.default.pathExists(logsDir);
+  const exists = await import_fs_extra5.default.pathExists(logsDir);
   if (!exists) return [];
   const running = buildRunningLogKeys(registry);
-  const names = await import_fs_extra4.default.readdir(logsDir);
+  const names = await import_fs_extra5.default.readdir(logsDir);
   const entries = [];
   for (const name of names) {
     if (import_node_path6.default.extname(name).toLowerCase() !== ".log") continue;
@@ -843,7 +1153,7 @@ async function loadLogEntries(logsDir, registry) {
     const filePath = import_node_path6.default.join(logsDir, name);
     let stat;
     try {
-      stat = await import_fs_extra4.default.stat(filePath);
+      stat = await import_fs_extra5.default.stat(filePath);
     } catch {
       continue;
     }
@@ -859,12 +1169,12 @@ async function loadLogEntries(logsDir, registry) {
   }
   return entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
-function getTerminalSize() {
+function getTerminalSize2() {
   const rows = process.stdout.rows ?? 24;
   const columns = process.stdout.columns ?? 80;
   return { rows, columns };
 }
-function truncateLine(line, width) {
+function truncateLine2(line, width) {
   if (width <= 0) return "";
   if (line.length <= width) return line;
   return line.slice(0, width);
@@ -886,12 +1196,12 @@ function formatBytes(size) {
   const mb = kb / 1024;
   return `${mb.toFixed(1)}MB`;
 }
-function getPageSize(rows) {
+function getPageSize2(rows) {
   return Math.max(1, rows - 2);
 }
 async function readLogLines(logFile) {
   try {
-    const content = await import_fs_extra4.default.readFile(logFile, "utf8");
+    const content = await import_fs_extra5.default.readFile(logFile, "utf8");
     const normalized = content.replace(/\r\n?/g, "\n");
     const lines = normalized.split("\n");
     return lines.length > 0 ? lines : [""];
@@ -903,36 +1213,36 @@ async function readLogLines(logFile) {
 function buildListHeader(state, columns) {
   const total = state.logs.length;
   const title = `\u65E5\u5FD7\u5217\u8868\uFF08${total} \u6761\uFF09\uFF5C\u2191/\u2193 \u9009\u62E9  Enter \u67E5\u770B  q \u9000\u51FA`;
-  return truncateLine(title, columns);
+  return truncateLine2(title, columns);
 }
 function buildListStatus(state, columns) {
   if (state.logs.length === 0) {
     const text = state.lastError ? `\u52A0\u8F7D\u5931\u8D25\uFF1A${state.lastError}` : "\u6682\u65E0\u53EF\u67E5\u770B\u7684\u65E5\u5FD7";
-    return truncateLine(text, columns);
+    return truncateLine2(text, columns);
   }
   const entry = state.logs[state.selectedIndex];
   const meta = entry.meta;
   const detail = meta ? `\u9879\u76EE ${meta.path}` : `\u6587\u4EF6 ${entry.fileName}`;
   const suffix = state.lastError ? ` \uFF5C \u52A0\u8F7D\u5931\u8D25\uFF1A${state.lastError}` : "";
-  return truncateLine(`${detail}${suffix}`, columns);
+  return truncateLine2(`${detail}${suffix}`, columns);
 }
-function buildListLine(entry, selected, columns) {
+function buildListLine2(entry, selected, columns) {
   const marker = selected ? ">" : " ";
   const time = formatTimestamp(entry.mtimeMs);
   const metaInfo = entry.meta ? `\u8F6E\u6B21 ${entry.meta.round} \uFF5C Token ${entry.meta.tokenUsed}` : `\u5927\u5C0F ${formatBytes(entry.size)}`;
-  return truncateLine(`${marker} ${entry.fileName} \uFF5C ${time} \uFF5C ${metaInfo}`, columns);
+  return truncateLine2(`${marker} ${entry.fileName} \uFF5C ${time} \uFF5C ${metaInfo}`, columns);
 }
 function buildViewHeader(entry, columns) {
-  const title = `\u65E5\u5FD7\u67E5\u770B\uFF5C${entry.fileName}\uFF5C\u2191/\u2193 \u7FFB\u9875  b \u8FD4\u56DE  q \u9000\u51FA`;
-  return truncateLine(title, columns);
+  const title = `\u65E5\u5FD7\u67E5\u770B\uFF5C${entry.fileName}\uFF5C\u2191/\u2193 \u4E0A\u4E0B 1 \u884C  PageUp/PageDown \u7FFB\u9875  b \u8FD4\u56DE  q \u9000\u51FA`;
+  return truncateLine2(title, columns);
 }
 function buildViewStatus(entry, page, columns) {
   const meta = entry.meta;
   const metaInfo = meta ? `\u8F6E\u6B21 ${meta.round} \uFF5C Token ${meta.tokenUsed} \uFF5C \u9879\u76EE ${meta.path}` : `\u6587\u4EF6 ${entry.fileName}`;
   const status = `\u9875 ${page.current}/${page.total} \uFF5C ${metaInfo}`;
-  return truncateLine(status, columns);
+  return truncateLine2(status, columns);
 }
-function ensureListOffset(state, pageSize) {
+function ensureListOffset2(state, pageSize) {
   const total = state.logs.length;
   if (total === 0) {
     state.listOffset = 0;
@@ -949,10 +1259,10 @@ function ensureListOffset(state, pageSize) {
   state.listOffset = Math.min(Math.max(state.listOffset, 0), maxOffset);
 }
 function renderList(state) {
-  const { rows, columns } = getTerminalSize();
-  const pageSize = getPageSize(rows);
+  const { rows, columns } = getTerminalSize2();
+  const pageSize = getPageSize2(rows);
   const header = buildListHeader(state, columns);
-  ensureListOffset(state, pageSize);
+  ensureListOffset2(state, pageSize);
   if (state.logs.length === 0) {
     const filler = Array.from({ length: pageSize }, () => "");
     const status2 = buildListStatus(state, columns);
@@ -964,7 +1274,7 @@ function renderList(state) {
   const slice = state.logs.slice(start, start + pageSize);
   const lines = slice.map((entry, index) => {
     const selected = start + index === state.selectedIndex;
-    return buildListLine(entry, selected, columns);
+    return buildListLine2(entry, selected, columns);
   });
   while (lines.length < pageSize) {
     lines.push("");
@@ -974,28 +1284,30 @@ function renderList(state) {
   process.stdout.write(`\x1B[2J\x1B[H${content}`);
 }
 function renderView(view) {
-  const { rows, columns } = getTerminalSize();
-  const pageSize = getPageSize(rows);
+  const { rows, columns } = getTerminalSize2();
+  const pageSize = getPageSize2(rows);
   const header = buildViewHeader(view.entry, columns);
-  const maxOffset = Math.max(0, Math.ceil(view.lines.length / pageSize) - 1);
-  view.pageOffset = Math.min(Math.max(view.pageOffset, 0), maxOffset);
-  const start = view.pageOffset * pageSize;
-  const pageLines = view.lines.slice(start, start + pageSize).map((line) => truncateLine(line, columns));
+  const maxOffset = Math.max(0, view.lines.length - pageSize);
+  view.lineOffset = Math.min(Math.max(view.lineOffset, 0), maxOffset);
+  const start = view.lineOffset;
+  const pageLines = view.lines.slice(start, start + pageSize).map((line) => truncateLine2(line, columns));
   while (pageLines.length < pageSize) {
     pageLines.push("");
   }
-  const status = buildViewStatus(view.entry, { current: view.pageOffset + 1, total: Math.max(1, maxOffset + 1) }, columns);
+  const totalPages = Math.max(1, Math.ceil(view.lines.length / pageSize));
+  const currentPage = Math.min(totalPages, Math.floor(view.lineOffset / pageSize) + 1);
+  const status = buildViewStatus(view.entry, { current: currentPage, total: totalPages }, columns);
   const content = [header, ...pageLines, status].join("\n");
   process.stdout.write(`\x1B[2J\x1B[H${content}`);
 }
-function render(state) {
+function render2(state) {
   if (state.mode === "view" && state.view) {
     renderView(state.view);
     return;
   }
   renderList(state);
 }
-function shouldExit(input) {
+function shouldExit2(input) {
   if (input === "") return true;
   if (input.toLowerCase() === "q") return true;
   return false;
@@ -1003,16 +1315,22 @@ function shouldExit(input) {
 function isEnter(input) {
   return input.includes("\r") || input.includes("\n");
 }
-function isArrowUp(input) {
+function isArrowUp2(input) {
   return input.includes("\x1B[A");
 }
-function isArrowDown(input) {
+function isArrowDown2(input) {
   return input.includes("\x1B[B");
 }
+function isPageUp(input) {
+  return input.includes("\x1B[5~");
+}
+function isPageDown(input) {
+  return input.includes("\x1B[6~");
+}
 function isEscape(input) {
   return input === "\x1B";
 }
-function setupCleanup(cleanup) {
+function setupCleanup2(cleanup) {
   const exitHandler = () => {
     cleanup();
   };
@@ -1024,7 +1342,7 @@ function setupCleanup(cleanup) {
   process.on("SIGTERM", signalHandler);
   process.on("exit", exitHandler);
 }
-function clampIndex(value, total) {
+function clampIndex2(value, total) {
   if (total <= 0) return 0;
   return Math.min(Math.max(value, 0), total - 1);
 }
@@ -1050,7 +1368,7 @@ async function runLogsViewer() {
     }
     process.stdout.write("\x1B[?25h");
   };
-  setupCleanup(cleanup);
+  setupCleanup2(cleanup);
   process.stdout.write("\x1B[?25l");
   process.stdin.setRawMode(true);
   process.stdin.resume();
@@ -1059,7 +1377,7 @@ async function runLogsViewer() {
     try {
       const registry = await readCurrentRegistry();
       state.logs = await loadLogEntries(logsDir, registry);
-      state.selectedIndex = clampIndex(state.selectedIndex, state.logs.length);
+      state.selectedIndex = clampIndex2(state.selectedIndex, state.logs.length);
       state.lastError = void 0;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -1076,37 +1394,37 @@ async function runLogsViewer() {
     state.view = {
       entry,
       lines: ["\u52A0\u8F7D\u4E2D\u2026"],
-      pageOffset: 0
+      lineOffset: 0
     };
-    render(state);
+    render2(state);
     const lines = await readLogLines(entry.filePath);
-    const pageSize = getPageSize(getTerminalSize().rows);
-    const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
+    const pageSize = getPageSize2(getTerminalSize2().rows);
+    const maxOffset = Math.max(0, lines.length - pageSize);
     state.view = {
       entry,
       lines,
-      pageOffset: maxOffset
+      lineOffset: maxOffset
     };
     loading = false;
-    render(state);
+    render2(state);
   };
   await loadLogs();
-  render(state);
+  render2(state);
   process.stdin.on("data", (data) => {
     const input = data.toString("utf8");
-    if (shouldExit(input)) {
+    if (shouldExit2(input)) {
       cleanup();
       process.exit(0);
     }
     if (state.mode === "list") {
-      if (isArrowUp(input)) {
-        state.selectedIndex = clampIndex(state.selectedIndex - 1, state.logs.length);
-        render(state);
+      if (isArrowUp2(input)) {
+        state.selectedIndex = clampIndex2(state.selectedIndex - 1, state.logs.length);
+        render2(state);
         return;
       }
-      if (isArrowDown(input)) {
-        state.selectedIndex = clampIndex(state.selectedIndex + 1, state.logs.length);
-        render(state);
+      if (isArrowDown2(input)) {
+        state.selectedIndex = clampIndex2(state.selectedIndex + 1, state.logs.length);
+        render2(state);
         return;
       }
       if (isEnter(input)) {
@@ -1116,63 +1434,267 @@ async function runLogsViewer() {
       return;
     }
     if (state.mode === "view" && state.view) {
-      if (isArrowUp(input)) {
-        state.view.pageOffset -= 1;
-        render(state);
+      if (isArrowUp2(input)) {
+        state.view.lineOffset -= 1;
+        render2(state);
+        return;
+      }
+      if (isArrowDown2(input)) {
+        state.view.lineOffset += 1;
+        render2(state);
         return;
       }
-      if (isArrowDown(input)) {
-        state.view.pageOffset += 1;
-        render(state);
+      if (isPageUp(input)) {
+        const pageSize = getPageSize2(getTerminalSize2().rows);
+        state.view.lineOffset -= pageSize;
+        render2(state);
+        return;
+      }
+      if (isPageDown(input)) {
+        const pageSize = getPageSize2(getTerminalSize2().rows);
+        state.view.lineOffset += pageSize;
+        render2(state);
         return;
       }
       if (input.toLowerCase() === "b" || isEscape(input)) {
         state.mode = "list";
         state.view = void 0;
-        render(state);
+        render2(state);
         return;
       }
     }
   });
   process.stdout.on("resize", () => {
-    render(state);
+    render2(state);
   });
 }
 
 // src/loop.ts
-var import_fs_extra7 = __toESM(require("fs-extra"));
-var import_node_path8 = __toESM(require("path"));
+var import_fs_extra9 = __toESM(require("fs-extra"));
+var import_node_path9 = __toESM(require("path"));
 
 // src/ai.ts
-function buildPrompt(input) {
-  const sections = [
+function compactLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function buildBranchNamePrompt(input) {
+  return [
+    "# \u89D2\u8272",
+    "\u4F60\u662F\u8D44\u6DF1\u5DE5\u7A0B\u5E08\uFF0C\u9700\u8981\u6839\u636E\u4EFB\u52A1\u751F\u6210\u89C4\u8303\u7684 git \u5206\u652F\u540D\u3002",
+    "# \u89C4\u5219",
+    "- \u8F93\u51FA\u683C\u5F0F\u4EC5\u9650\u4E25\u683C JSON\uFF08\u4E0D\u8981 markdown\u3001\u4E0D\u8981\u4EE3\u7801\u5757\u3001\u4E0D\u8981\u89E3\u91CA\uFF09\u3002",
+    "- \u5206\u652F\u540D\u683C\u5F0F\uFF1A<type>/<slug>\u3002",
+    "- type \u53EF\u9009\uFF1Afeat\u3001fix\u3001docs\u3001refactor\u3001chore\u3001test\u3002",
+    "- slug \u4F7F\u7528\u5C0F\u5199\u82F1\u6587\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\uFF0C\u957F\u5EA6 3~40\uFF0C\u907F\u514D\u7A7A\u683C\u4E0E\u4E2D\u6587\u3002",
+    "# \u8F93\u51FA JSON",
+    '{"branch":"..."}',
+    "# \u4EFB\u52A1\u63CF\u8FF0",
+    compactLine(input.task) || "\uFF08\u7A7A\uFF09"
+  ].join("\n\n");
+}
+function buildPlanningPrompt(input) {
+  return [
     "# \u80CC\u666F\u4EFB\u52A1",
     input.task,
+    "# \u5206\u652F\u4FE1\u606F",
+    input.branchName ? `\u8BA1\u5212\u4F7F\u7528\u5206\u652F\uFF1A${input.branchName}` : "\u672A\u6307\u5B9A\u5206\u652F\u540D\uFF0C\u8BF7\u6309\u4EFB\u52A1\u8BED\u4E49\u7ED9\u51FA\u5EFA\u8BAE",
     "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
     input.workflowGuide,
-    "# \u5F53\u524D\u6301\u4E45\u5316\u8BA1\u5212",
-    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF0C\u9996\u8F6E\u8BF7\u751F\u6210\u53EF\u6267\u884C\u8BA1\u5212\u5E76\u5199\u5165 plan \u6587\u4EF6\uFF09",
-    "# \u5386\u53F2\u8FED\u4EE3\u4E0E\u8BB0\u5FC6",
-    input.notes || "\uFF08\u9996\u6B21\u6267\u884C\uFF0C\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
     "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
     [
-      "1. \u81EA\u6211\u68C0\u67E5\u5E76\u8865\u5168\u9700\u6C42\uFF1B\u660E\u786E\u4EA4\u4ED8\u7269\u4E0E\u9A8C\u6536\u6807\u51C6\u3002",
-      "2. \u66F4\u65B0/\u7EC6\u5316\u8BA1\u5212\uFF0C\u5FC5\u8981\u65F6\u5728 plan \u6587\u4EF6\u4E2D\u91CD\u5199\u4EFB\u52A1\u6811\u4E0E\u4F18\u5148\u7EA7\u3002",
-      "3. \u8BBE\u8BA1\u5F00\u53D1\u6B65\u9AA4\u5E76\u76F4\u63A5\u751F\u6210\u4EE3\u7801\uFF08\u65E0\u9700\u518D\u6B21\u8BF7\u6C42\u786E\u8BA4\uFF09\u3002",
-      "4. \u8FDB\u884C\u4EE3\u7801\u81EA\u5BA1\uFF0C\u7ED9\u51FA\u98CE\u9669\u4E0E\u6539\u8FDB\u6E05\u5355\u3002",
-      "5. \u751F\u6210\u5355\u5143\u6D4B\u8BD5\u4E0E e2e \u6D4B\u8BD5\u4EE3\u7801\u5E76\u7ED9\u51FA\u8FD0\u884C\u547D\u4EE4\uFF1B\u5982\u679C\u73AF\u5883\u5141\u8BB8\u53EF\u76F4\u63A5\u8FD0\u884C\u547D\u4EE4\u3002",
-      "6. \u7EF4\u62A4\u6301\u4E45\u5316\u8BB0\u5FC6\u6587\u4EF6\uFF1A\u6458\u8981\u672C\u8F6E\u5173\u952E\u7ED3\u8BBA\u3001\u9057\u7559\u95EE\u9898\u3001\u4E0B\u4E00\u6B65\u5EFA\u8BAE\u3002",
-      "7. \u51C6\u5907\u63D0\u4EA4 PR \u6240\u9700\u7684\u6807\u9898\u4E0E\u63CF\u8FF0\uFF08\u542B\u53D8\u66F4\u6458\u8981\u3001\u6D4B\u8BD5\u7ED3\u679C\u3001\u98CE\u9669\uFF09\u3002",
-      "8. \u5F53\u6240\u6709\u76EE\u6807\u5B8C\u6210\u65F6\uFF0C\u5728\u8F93\u51FA\u4E2D\u52A0\u5165\u6807\u8BB0 <<DONE>> \u4EE5\u4FBF\u5916\u5C42\u505C\u6B62\u5FAA\u73AF\u3002"
+      "1. \u5206\u6790\u4EFB\u52A1\u8F93\u5165/\u8F93\u51FA/\u7EA6\u675F/\u9A8C\u6536\u6807\u51C6\uFF0C\u5FC5\u8981\u65F6\u8865\u5145\u5408\u7406\u5047\u8BBE\uFF08\u5199\u5165 notes\uFF09\u3002",
+      "2. \u82E5 plan.md \u5DF2\u5B58\u5728\uFF0C\u8BF7\u5224\u65AD\u662F\u5426\u5408\u7406\uFF1B\u5408\u7406\u5219\u4E0D\u4FEE\u6539\uFF0C\u4E0D\u5408\u7406\u5219\u4F18\u5316\u6216\u91CD\u5199\u3002",
+      "3. \u8BA1\u5212\u53EA\u5305\u542B\u5F00\u53D1\u76F8\u5173\u4EFB\u52A1\uFF08\u8BBE\u8BA1/\u5B9E\u73B0/\u91CD\u6784/\u914D\u7F6E/\u6587\u6863\u66F4\u65B0\uFF09\uFF0C\u4E0D\u8981\u5305\u542B\u6D4B\u8BD5\u3001\u81EA\u5BA1\u3001PR\u3001\u63D0\u4EA4\u7B49\u5185\u5BB9\u3002",
+      "4. \u8BA1\u5212\u9879\u9700\u53EF\u6267\u884C\u3001\u9897\u7C92\u5EA6\u6E05\u6670\uFF0C\u5DF2\u5B8C\u6210\u9879\u4F7F\u7528 \u2705 \u6807\u8BB0\u3002",
+      "5. \u66F4\u65B0 memory/plan.md \u4E0E memory/notes.md \u540E\u7ED3\u675F\u672C\u8F6E\u3002"
     ].join("\n")
-  ];
-  return sections.join("\n\n");
+  ].join("\n\n");
 }
-function pickNumber(pattern, text) {
-  const match = pattern.exec(text);
-  if (!match || match.length < 2) return void 0;
-  const value = Number.parseInt(match[match.length - 1], 10);
-  return Number.isNaN(value) ? void 0 : value;
+function buildPlanItemPrompt(input) {
+  return [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u672C\u8F6E\u8981\u6267\u884C\u7684\u8BA1\u5212\u9879\uFF08\u4EC5\u6B64\u4E00\u6761\uFF09",
+    input.item,
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u53EA\u6267\u884C\u4E0A\u8FF0\u8BA1\u5212\u9879\uFF0C\u907F\u514D\u63D0\u524D\u5904\u7406\u5176\u5B83\u8BA1\u5212\u9879\u3002",
+      "2. \u5B8C\u6210\u540E\u7ACB\u5373\u5728 plan.md \u4E2D\u5C06\u8BE5\u9879\u6807\u8BB0\u4E3A \u2705\u3002",
+      "3. \u5FC5\u8981\u65F6\u53EF\u5BF9\u8BA1\u5212\u9879\u8FDB\u884C\u5FAE\u8C03\uFF0C\u4F46\u4ECD\u9700\u786E\u4FDD\u5F53\u524D\u9879\u5B8C\u6210\u3002",
+      "4. \u672C\u8F6E\u4E0D\u6267\u884C\u6D4B\u8BD5\u6216\u8D28\u91CF\u68C0\u67E5\u3002",
+      "5. \u5C06\u8FDB\u5C55\u3001\u5173\u952E\u6539\u52A8\u4E0E\u98CE\u9669\u5199\u5165 notes\u3002"
+    ].join("\n")
+  ].join("\n\n");
+}
+function buildQualityPrompt(input) {
+  return [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u672C\u8F6E\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5",
+    input.commands.length > 0 ? input.commands.map((cmd) => `- ${cmd}`).join("\n") : "\u672A\u68C0\u6D4B\u5230\u53EF\u6267\u884C\u7684\u8D28\u91CF\u68C0\u67E5\u547D\u4EE4\u3002",
+    input.results ? `# \u547D\u4EE4\u6267\u884C\u7ED3\u679C
+${input.results}` : "",
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u672C\u8F6E\u4EC5\u8FDB\u884C\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5\uFF0C\u4E0D\u8981\u4FEE\u590D\u95EE\u9898\u3002",
+      "2. \u82E5\u51FA\u73B0\u5931\u8D25\uFF0C\u8BB0\u5F55\u5931\u8D25\u8981\u70B9\uFF0C\u7B49\u5F85\u4E0B\u4E00\u8F6E\u4FEE\u590D\u3002",
+      "3. \u5C06\u7ED3\u8BBA\u4E0E\u98CE\u9669\u5199\u5165 notes\u3002"
+    ].join("\n")
+  ].filter(Boolean).join("\n\n");
+}
+function buildFixPrompt(input) {
+  return [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
+    `# \u9700\u8981\u4FEE\u590D\u7684\u95EE\u9898\uFF08${input.stage}\uFF09`,
+    input.errors || "\uFF08\u65E0\u9519\u8BEF\u4FE1\u606F\uFF09",
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u805A\u7126\u4FEE\u590D\u5F53\u524D\u95EE\u9898\uFF0C\u4E0D\u8981\u6269\u5C55\u8303\u56F4\u3002",
+      "2. \u4FEE\u590D\u5B8C\u6210\u540E\u66F4\u65B0 notes\uFF0C\u8BF4\u660E\u4FEE\u6539\u70B9\u4E0E\u5F71\u54CD\u3002",
+      "3. \u5982\u9700\u8C03\u6574\u8BA1\u5212\uFF0C\u8BF7\u540C\u6B65\u66F4\u65B0 plan.md\u3002"
+    ].join("\n")
+  ].join("\n\n");
+}
+function buildTestPrompt(input) {
+  return [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u672C\u8F6E\u6D4B\u8BD5\u547D\u4EE4",
+    input.commands.length > 0 ? input.commands.map((cmd) => `- ${cmd}`).join("\n") : "\u672A\u914D\u7F6E\u6D4B\u8BD5\u547D\u4EE4\u3002",
+    input.results ? `# \u6D4B\u8BD5\u7ED3\u679C
+${input.results}` : "",
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u672C\u8F6E\u4EC5\u6267\u884C\u6D4B\u8BD5\uFF0C\u4E0D\u8981\u4FEE\u590D\u95EE\u9898\u3002",
+      "2. \u82E5\u51FA\u73B0\u5931\u8D25\uFF0C\u8BB0\u5F55\u5931\u8D25\u8981\u70B9\uFF0C\u7B49\u5F85\u4E0B\u4E00\u8F6E\u4FEE\u590D\u3002",
+      "3. \u5C06\u6D4B\u8BD5\u7ED3\u8BBA\u5199\u5165 notes\u3002"
+    ].join("\n")
+  ].filter(Boolean).join("\n\n");
+}
+function buildDocsPrompt(input) {
+  return [
+    "# \u80CC\u666F\u4EFB\u52A1",
+    input.task,
+    "# \u5DE5\u4F5C\u6D41\u7A0B\u57FA\u7EBF\uFF08\u4F9B AI \u81EA\u4E3B\u6267\u884C\uFF09",
+    input.workflowGuide,
+    "# \u5F53\u524D\u8BA1\u5212",
+    input.plan || "\uFF08\u6682\u65E0\u8BA1\u5212\uFF09",
+    "# \u5386\u53F2\u8BB0\u5FC6",
+    input.notes || "\uFF08\u6682\u65E0\u5386\u53F2\uFF09",
+    "# \u672C\u8F6E\u6267\u884C\u8981\u6C42",
+    [
+      "1. \u6839\u636E\u672C\u6B21\u6539\u52A8\u66F4\u65B0\u7248\u672C\u53F7\u3001CHANGELOG\u3001README\u3001docs \u7B49\u76F8\u5173\u6587\u6863\u3002",
+      "2. \u4EC5\u66F4\u65B0\u786E\u6709\u53D8\u5316\u7684\u6587\u6863\uFF0C\u4FDD\u6301\u4E2D\u6587\u8BF4\u660E\u3002",
+      "3. \u5C06\u66F4\u65B0\u6458\u8981\u5199\u5165 notes\u3002"
+    ].join("\n")
+  ].join("\n\n");
+}
+function extractJson(text) {
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1].trim();
+  const start = text.indexOf("{");
+  const end = text.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    return text.slice(start, end + 1).trim();
+  }
+  return null;
+}
+var BRANCH_TYPES = ["feat", "fix", "docs", "refactor", "chore", "test"];
+var BRANCH_TYPE_ALIASES = {
+  feature: "feat",
+  features: "feat",
+  bugfix: "fix",
+  hotfix: "fix",
+  doc: "docs",
+  documentation: "docs",
+  refactoring: "refactor",
+  chores: "chore",
+  tests: "test"
+};
+function isBranchType(value) {
+  return BRANCH_TYPES.includes(value);
+}
+function normalizeBranchType(value) {
+  const trimmed = value.trim().toLowerCase();
+  if (!trimmed) return null;
+  if (isBranchType(trimmed)) return trimmed;
+  return BRANCH_TYPE_ALIASES[trimmed] ?? null;
+}
+function normalizeBranchSlug(value) {
+  const cleaned = value.toLowerCase().replace(/\s+/g, "-").replace(/_/g, "-").replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  if (!cleaned) return null;
+  const trimmed = cleaned.slice(0, 40);
+  if (trimmed.length < 3) return null;
+  return trimmed;
+}
+function normalizeBranchNameCandidate(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const lowered = trimmed.toLowerCase();
+  const parts = lowered.split("/").filter((part) => part.length > 0);
+  const hasExplicitType = lowered.includes("/") && parts.length >= 2;
+  const rawType = hasExplicitType ? parts.shift() ?? "" : "";
+  const rawSlug = hasExplicitType ? parts.join("-") : lowered;
+  const type = rawType ? normalizeBranchType(rawType) : "feat";
+  if (!type) return null;
+  const slug = normalizeBranchSlug(rawSlug);
+  if (!slug) return null;
+  return `${type}/${slug}`;
+}
+function parseBranchName(output) {
+  const jsonText = extractJson(output);
+  if (jsonText) {
+    try {
+      const parsed = JSON.parse(jsonText);
+      const raw = typeof parsed.branch === "string" ? parsed.branch : typeof parsed.branchName === "string" ? parsed.branchName : typeof parsed["\u5206\u652F"] === "string" ? parsed["\u5206\u652F"] : typeof parsed["\u5206\u652F\u540D"] === "string" ? parsed["\u5206\u652F\u540D"] : null;
+      if (raw) {
+        const normalized = normalizeBranchNameCandidate(raw);
+        if (normalized) return normalized;
+      }
+    } catch {
+    }
+  }
+  const lineMatch = output.match(/(?:branch(?:name)?|分支名|分支)\s*[:：]\s*([^\s]+)/i);
+  if (lineMatch?.[1]) {
+    const normalized = normalizeBranchNameCandidate(lineMatch[1]);
+    if (normalized) return normalized;
+  }
+  return null;
+}
+function pickNumber(pattern, text) {
+  const match = pattern.exec(text);
+  if (!match || match.length < 2) return void 0;
+  const value = Number.parseInt(match[match.length - 1], 10);
+  return Number.isNaN(value) ? void 0 : value;
 }
 function parseTokenUsage(logs) {
   const total = pickNumber(/total[_\s]tokens:\s*(\d+)/i, logs);
@@ -1244,8 +1766,9 @@ async function runAi(prompt, ai, logger, cwd) {
   };
 }
 function formatIterationRecord(record) {
+  const title = record.stage ? `### \u8FED\u4EE3 ${record.iteration} \uFF5C ${record.timestamp} \uFF5C ${record.stage}` : `### \u8FED\u4EE3 ${record.iteration} \uFF5C ${record.timestamp}`;
   const lines = [
-    `### \u8FED\u4EE3 ${record.iteration} \uFF5C ${record.timestamp}`,
+    title,
     "",
     "#### \u63D0\u793A\u4E0A\u4E0B\u6587",
     "```",
@@ -1258,6 +1781,19 @@ function formatIterationRecord(record) {
     "```",
     ""
   ];
+  if (record.checkResults && record.checkResults.length > 0) {
+    lines.push("#### \u8D28\u91CF\u68C0\u67E5\u7ED3\u679C");
+    record.checkResults.forEach((result) => {
+      const status = result.success ? "\u2705 \u901A\u8FC7" : "\u274C \u5931\u8D25";
+      lines.push(`${status} \uFF5C ${result.name} \uFF5C \u547D\u4EE4: ${result.command} \uFF5C \u9000\u51FA\u7801: ${result.exitCode}`);
+      if (!result.success) {
+        lines.push("```");
+        lines.push(result.stderr || result.stdout || "\uFF08\u65E0\u8F93\u51FA\uFF09");
+        lines.push("```");
+        lines.push("");
+      }
+    });
+  }
   if (record.testResults && record.testResults.length > 0) {
     lines.push("#### \u6D4B\u8BD5\u7ED3\u679C");
     record.testResults.forEach((result) => {
@@ -1277,7 +1813,7 @@ function formatIterationRecord(record) {
 
 // src/deps.ts
 var import_node_path7 = __toESM(require("path"));
-var import_fs_extra5 = __toESM(require("fs-extra"));
+var import_fs_extra6 = __toESM(require("fs-extra"));
 function parsePackageManagerField(value) {
   if (!value) return null;
   const normalized = value.trim().toLowerCase();
@@ -1375,20 +1911,20 @@ function extractPackageManagerField(value) {
 }
 async function readPackageManagerHints(cwd, logger) {
   const packageJsonPath = import_node_path7.default.join(cwd, "package.json");
-  const hasPackageJson = await import_fs_extra5.default.pathExists(packageJsonPath);
+  const hasPackageJson = await import_fs_extra6.default.pathExists(packageJsonPath);
   if (!hasPackageJson) return null;
   let packageManagerField;
   try {
-    const packageJson = await import_fs_extra5.default.readJson(packageJsonPath);
+    const packageJson = await import_fs_extra6.default.readJson(packageJsonPath);
     packageManagerField = extractPackageManagerField(packageJson);
   } catch (error) {
     logger.warn(`\u8BFB\u53D6 package.json \u5931\u8D25\uFF0C\u5C06\u6539\u7528\u9501\u6587\u4EF6\u5224\u65AD\u5305\u7BA1\u7406\u5668: ${String(error)}`);
   }
   const [hasYarnLock, hasPnpmLock, hasNpmLock, hasNpmShrinkwrap] = await Promise.all([
-    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "yarn.lock")),
-    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "pnpm-lock.yaml")),
-    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "package-lock.json")),
-    import_fs_extra5.default.pathExists(import_node_path7.default.join(cwd, "npm-shrinkwrap.json"))
+    import_fs_extra6.default.pathExists(import_node_path7.default.join(cwd, "yarn.lock")),
+    import_fs_extra6.default.pathExists(import_node_path7.default.join(cwd, "pnpm-lock.yaml")),
+    import_fs_extra6.default.pathExists(import_node_path7.default.join(cwd, "package-lock.json")),
+    import_fs_extra6.default.pathExists(import_node_path7.default.join(cwd, "npm-shrinkwrap.json"))
   ]);
   return {
     packageManagerField,
@@ -1592,9 +2128,25 @@ async function listFailedRuns(branch, cwd, logger) {
     return [];
   }
 }
+async function enableAutoMerge(target, cwd, logger) {
+  const targetValue = String(target);
+  const args = ["pr", "merge", targetValue, "--auto", "--merge"];
+  const result = await runCommand("gh", args, {
+    cwd,
+    logger,
+    verboseLabel: "gh",
+    verboseCommand: `gh ${args.join(" ")}`
+  });
+  if (result.exitCode !== 0) {
+    logger.warn(`\u542F\u7528\u81EA\u52A8\u5408\u5E76\u5931\u8D25: ${result.stderr || result.stdout}`);
+    return false;
+  }
+  logger.success("\u5DF2\u542F\u7528 PR \u81EA\u52A8\u5408\u5E76");
+  return true;
+}
 
 // src/logger.ts
-var import_fs_extra6 = __toESM(require("fs-extra"));
+var import_fs_extra7 = __toESM(require("fs-extra"));
 var wrap = (code) => (value) => `\x1B[${code}m${value}\x1B[0m`;
 var colors = {
   blue: wrap("34"),
@@ -1613,7 +2165,7 @@ var Logger = class {
     this.logFileErrored = false;
     if (this.logFile) {
       try {
-        import_fs_extra6.default.ensureFileSync(this.logFile);
+        import_fs_extra7.default.ensureFileSync(this.logFile);
       } catch (error) {
         this.disableFileWithError(error);
       }
@@ -1653,7 +2205,7 @@ var Logger = class {
   writeFileLine(line) {
     if (!this.logFileEnabled || !this.logFile) return;
     try {
-      import_fs_extra6.default.appendFileSync(this.logFile, `${line}
+      import_fs_extra7.default.appendFileSync(this.logFile, `${line}
 `, "utf8");
     } catch (error) {
       this.disableFileWithError(error);
@@ -1679,6 +2231,70 @@ var Logger = class {
 };
 var defaultLogger = new Logger();
 
+// src/plan.ts
+var ITEM_PATTERN = /^(\s*)([-*+]|\d+\.)\s+(.*)$/;
+function isCompleted(content) {
+  if (content.includes("\u2705")) return true;
+  if (/\[[xX]\]/.test(content)) return true;
+  return false;
+}
+function normalizeText(content) {
+  return content.replace(/\[[xX ]\]\s*/g, "").replace(/✅/g, "").trim();
+}
+function parsePlanItems(plan) {
+  const lines = plan.split(/\r?\n/);
+  const items = [];
+  lines.forEach((line, index) => {
+    const match = line.match(ITEM_PATTERN);
+    if (!match) return;
+    const content = match[3] ?? "";
+    const text = normalizeText(content);
+    if (!text) return;
+    items.push({
+      index,
+      raw: line,
+      text,
+      completed: isCompleted(content)
+    });
+  });
+  return items;
+}
+function getPendingPlanItems(plan) {
+  return parsePlanItems(plan).filter((item) => !item.completed);
+}
+
+// src/quality.ts
+var import_fs_extra8 = __toESM(require("fs-extra"));
+var import_node_path8 = __toESM(require("path"));
+function hasScript(scripts, name) {
+  return typeof scripts[name] === "string" && scripts[name].trim().length > 0;
+}
+async function detectQualityCommands(workDir) {
+  const packagePath = import_node_path8.default.join(workDir, "package.json");
+  const exists = await import_fs_extra8.default.pathExists(packagePath);
+  if (!exists) return [];
+  const pkg = await import_fs_extra8.default.readJson(packagePath);
+  const scripts = typeof pkg === "object" && pkg && typeof pkg.scripts === "object" ? pkg.scripts ?? {} : {};
+  const commands = [];
+  const seen = /* @__PURE__ */ new Set();
+  const append = (name, command) => {
+    if (seen.has(name)) return;
+    if (!hasScript(scripts, name)) return;
+    commands.push({ name, command });
+    seen.add(name);
+  };
+  append("lint", "yarn lint");
+  append("lint:ci", "yarn lint:ci");
+  append("lint:check", "yarn lint:check");
+  append("typecheck", "yarn typecheck");
+  append("format:check", "yarn format:check");
+  append("format:ci", "yarn format:ci");
+  if (!hasScript(scripts, "format:check") && !hasScript(scripts, "format:ci")) {
+    append("format", "yarn format");
+  }
+  return commands;
+}
+
 // src/runtime-tracker.ts
 async function safeWrite(logFile, metadata, logger) {
   try {
@@ -1703,14 +2319,15 @@ async function safeRemove(logFile, logger) {
   }
 }
 async function createRunTracker(options) {
-  const { logFile, command, path: path10, logger } = options;
+  const { logFile, command, path: path12, logger } = options;
   if (!logFile) return null;
   const update = async (round, tokenUsed) => {
     const metadata = {
       command,
       round,
       tokenUsed,
-      path: path10
+      path: path12,
+      pid: process.pid
     };
     await safeWrite(logFile, metadata, logger);
   };
@@ -1725,14 +2342,14 @@ async function createRunTracker(options) {
 
 // src/summary.ts
 var REQUIRED_SECTIONS = ["# \u53D8\u66F4\u6458\u8981", "# \u6D4B\u8BD5\u7ED3\u679C", "# \u98CE\u9669\u4E0E\u56DE\u6EDA"];
-function normalizeText(text) {
+function normalizeText2(text) {
   return text.replace(/\r\n?/g, "\n");
 }
-function compactLine(text) {
+function compactLine2(text) {
   return text.replace(/\s+/g, " ").trim();
 }
 function trimTail(text, limit, emptyFallback) {
-  const normalized = normalizeText(text).trim();
+  const normalized = normalizeText2(text).trim();
   if (!normalized) return emptyFallback;
   if (normalized.length <= limit) return normalized;
   return `\uFF08\u5185\u5BB9\u8FC7\u957F\uFF0C\u4FDD\u7559\u6700\u540E ${limit} \u5B57\u7B26\uFF09
@@ -1759,7 +2376,7 @@ function buildSummaryLinesFromCommit(commitTitle, commitBody) {
   return [`- ${summary}`];
 }
 function stripCommitType(title) {
-  const trimmed = compactLine(title);
+  const trimmed = compactLine2(title);
   if (!trimmed) return "\u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
   const match = trimmed.match(/^[^:]+:\s*(.+)$/);
   return match?.[1]?.trim() || trimmed;
@@ -1798,7 +2415,7 @@ function buildSummaryPrompt(input) {
     "# \u8F93\u51FA JSON",
     '{"commitTitle":"...","commitBody":"...","prTitle":"...","prBody":"..."}',
     "# \u8F93\u5165\u4FE1\u606F",
-    `\u4EFB\u52A1: ${compactLine(input.task) || "\uFF08\u7A7A\uFF09"}`,
+    `\u4EFB\u52A1: ${compactLine2(input.task) || "\uFF08\u7A7A\uFF09"}`,
     `\u5206\u652F: ${input.branchName ?? "\uFF08\u672A\u77E5\uFF09"}`,
     "\u8BA1\u5212\uFF08\u8282\u9009\uFF09:",
     planSnippet,
@@ -1823,7 +2440,7 @@ function pickString(record, keys) {
   }
   return null;
 }
-function extractJson(text) {
+function extractJson2(text) {
   const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
   if (fenced?.[1]) return fenced[1].trim();
   const start = text.indexOf("{");
@@ -1834,21 +2451,21 @@ function extractJson(text) {
   return null;
 }
 function normalizeTitle(title) {
-  return compactLine(title);
+  return compactLine2(title);
 }
 function normalizeBody(body) {
   if (!body) return void 0;
-  const normalized = normalizeText(body).trim();
+  const normalized = normalizeText2(body).trim();
   return normalized.length > 0 ? normalized : void 0;
 }
 function extractBulletLines(text) {
   if (!text) return [];
-  const lines = normalizeText(text).split("\n").map((line) => line.trim()).filter(Boolean);
+  const lines = normalizeText2(text).split("\n").map((line) => line.trim()).filter(Boolean);
   const bullets = lines.filter((line) => line.startsWith("- ") || line.startsWith("* "));
   return bullets.map((line) => line.startsWith("* ") ? `- ${line.slice(2).trim()}` : line);
 }
 function parseDeliverySummary(output) {
-  const jsonText = extractJson(output);
+  const jsonText = extractJson2(output);
   if (!jsonText) return null;
   try {
     const parsed = JSON.parse(jsonText);
@@ -1872,7 +2489,7 @@ function parseDeliverySummary(output) {
     const normalizedCommitTitle = normalizeTitle(commitTitle);
     const normalizedPrTitle = normalizeTitle(prTitle);
     const normalizedCommitBody = normalizeBody(commitBody);
-    const normalizedPrBody = normalizeText(prBody).trim();
+    const normalizedPrBody = normalizeText2(prBody).trim();
     if (!normalizedCommitTitle || !normalizedPrTitle || !normalizedPrBody) return null;
     return {
       commitTitle: normalizedCommitTitle,
@@ -1885,7 +2502,7 @@ function parseDeliverySummary(output) {
   }
 }
 function buildFallbackSummary(input) {
-  const taskLine = compactLine(input.task);
+  const taskLine = compactLine2(input.task);
   const shortTask = taskLine.length > 50 ? `${taskLine.slice(0, 50)}...` : taskLine;
   const baseTitle = shortTask || "\u66F4\u65B0\u8FED\u4EE3\u4EA7\u51FA";
   const title = `chore: ${baseTitle}`;
@@ -1900,7 +2517,7 @@ function buildFallbackSummary(input) {
   };
 }
 function ensurePrBodySections(prBody, fallback) {
-  const normalized = normalizeText(prBody).trim();
+  const normalized = normalizeText2(prBody).trim();
   const hasAll = REQUIRED_SECTIONS.every((section) => normalized.includes(section));
   if (hasAll) return normalized;
   const summaryLines = buildSummaryLinesFromCommit(fallback.commitTitle, fallback.commitBody);
@@ -1972,13 +2589,18 @@ async function ensureWorkflowFiles(workflowFiles) {
   await ensureFile(workflowFiles.planFile, "# \u8BA1\u5212\n");
   await ensureFile(workflowFiles.notesFile, "# \u6301\u4E45\u5316\u8BB0\u5FC6\n");
 }
-var MAX_TEST_LOG_LENGTH = 4e3;
-function trimOutput(output, limit = MAX_TEST_LOG_LENGTH) {
+var MAX_LOG_LENGTH = 4e3;
+function trimOutput(output, limit = MAX_LOG_LENGTH) {
   if (!output) return "";
   if (output.length <= limit) return output;
   return `${output.slice(0, limit)}
 \u2026\u2026\uFF08\u8F93\u51FA\u5DF2\u622A\u65AD\uFF0C\u539F\u59CB\u957F\u5EA6 ${output.length} \u5B57\u7B26\uFF09`;
 }
+function truncateText(text, limit = 24) {
+  const trimmed = text.trim();
+  if (trimmed.length <= limit) return trimmed;
+  return `${trimmed.slice(0, limit)}...`;
+}
 async function safeCommandOutput(command, args, cwd, logger, label, verboseCommand) {
   const result = await runCommand(command, args, {
     cwd,
@@ -2016,6 +2638,66 @@ async function runSingleTest(kind, command, cwd, logger) {
     stderr: trimOutput(result.stderr.trim())
   };
 }
+async function runQualityChecks(commands, cwd, logger) {
+  const results = [];
+  for (const item of commands) {
+    logger.info(`\u6267\u884C\u8D28\u91CF\u68C0\u67E5: ${item.command}`);
+    const result = await runCommand("bash", ["-lc", item.command], {
+      cwd,
+      logger,
+      verboseLabel: "shell",
+      verboseCommand: `bash -lc "${item.command}"`
+    });
+    results.push({
+      name: item.name,
+      command: item.command,
+      success: result.exitCode === 0,
+      exitCode: result.exitCode,
+      stdout: trimOutput(result.stdout.trim()),
+      stderr: trimOutput(result.stderr.trim())
+    });
+  }
+  return results;
+}
+function buildCheckResultSummary(results) {
+  if (results.length === 0) return "\uFF08\u672A\u6267\u884C\u8D28\u91CF\u68C0\u67E5\uFF09";
+  return results.map((result) => {
+    const status = result.success ? "\u901A\u8FC7" : `\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`;
+    const output = result.success ? "" : `
+${result.stderr || result.stdout || "\uFF08\u65E0\u8F93\u51FA\uFF09"}`;
+    return `- ${result.name}: ${status}\uFF5C\u547D\u4EE4: ${result.command}${output}`;
+  }).join("\n");
+}
+function buildFailedCheckSummary(results) {
+  return buildCheckResultSummary(results.filter((result) => !result.success));
+}
+function buildTestResultSummary(results) {
+  if (results.length === 0) return "\uFF08\u672A\u6267\u884C\u6D4B\u8BD5\uFF09";
+  return results.map((result) => {
+    const label = result.kind === "unit" ? "\u5355\u5143\u6D4B\u8BD5" : "e2e \u6D4B\u8BD5";
+    const status = result.success ? "\u901A\u8FC7" : `\u5931\u8D25\uFF08\u9000\u51FA\u7801 ${result.exitCode}\uFF09`;
+    const output = result.success ? "" : `
+${result.stderr || result.stdout || "\uFF08\u65E0\u8F93\u51FA\uFF09"}`;
+    return `- ${label}: ${status}\uFF5C\u547D\u4EE4: ${result.command}${output}`;
+  }).join("\n");
+}
+function buildFailedTestSummary(results) {
+  return buildTestResultSummary(results.filter((result) => !result.success));
+}
+function formatSystemRecord(stage, detail, timestamp) {
+  return [
+    `### \u8BB0\u5F55 \uFF5C ${timestamp} \uFF5C ${stage}`,
+    "",
+    detail,
+    ""
+  ].join("\n");
+}
+function shouldSkipQuality(content, cliSkip) {
+  if (cliSkip) return true;
+  const normalized = content.replace(/\s+/g, "");
+  if (!normalized) return false;
+  return normalized.includes("\u4E0D\u8981\u68C0\u67E5\u4EE3\u7801\u8D28\u91CF") || normalized.includes("\u4E0D\u68C0\u67E5\u4EE3\u7801\u8D28\u91CF") || normalized.includes("\u8DF3\u8FC7\u4EE3\u7801\u8D28\u91CF");
+}
 async function runTests(config, workDir, logger) {
   const results = [];
   if (config.runTests && config.tests.unitCommand) {
@@ -2028,10 +2710,26 @@ async function runTests(config, workDir, logger) {
   }
   return results;
 }
+async function runTestsSafely(config, workDir, logger) {
+  try {
+    return await runTests(config, workDir, logger);
+  } catch (error) {
+    const errorMessage = String(error);
+    logger.warn(`\u6D4B\u8BD5\u6267\u884C\u5F02\u5E38: ${errorMessage}`);
+    return [{
+      kind: "unit",
+      command: config.tests.unitCommand ?? "\u672A\u77E5\u6D4B\u8BD5\u547D\u4EE4",
+      success: false,
+      exitCode: -1,
+      stdout: "",
+      stderr: trimOutput(errorMessage)
+    }];
+  }
+}
 function reRootPath(filePath, repoRoot, workDir) {
-  const relative = import_node_path8.default.relative(repoRoot, filePath);
+  const relative = import_node_path9.default.relative(repoRoot, filePath);
   if (relative.startsWith("..")) return filePath;
-  return import_node_path8.default.join(workDir, relative);
+  return import_node_path9.default.join(workDir, relative);
 }
 function reRootWorkflowFiles(workflowFiles, repoRoot, workDir) {
   if (repoRoot === workDir) return workflowFiles;
@@ -2042,10 +2740,10 @@ function reRootWorkflowFiles(workflowFiles, repoRoot, workDir) {
   };
 }
 function buildBodyFile(workDir) {
-  return import_node_path8.default.join(workDir, "memory", "pr-body.md");
+  return import_node_path9.default.join(workDir, "memory", "pr-body.md");
 }
 async function writePrBody(bodyPath, content, appendExisting) {
-  await import_fs_extra7.default.mkdirp(import_node_path8.default.dirname(bodyPath));
+  await import_fs_extra9.default.mkdirp(import_node_path9.default.dirname(bodyPath));
   let finalContent = content.trim();
   if (appendExisting) {
     const existing = await readFileSafe(bodyPath);
@@ -2058,7 +2756,7 @@ async function writePrBody(bodyPath, content, appendExisting) {
 ${finalContent}`;
     }
   }
-  await import_fs_extra7.default.writeFile(bodyPath, `${finalContent}
+  await import_fs_extra9.default.writeFile(bodyPath, `${finalContent}
 `, "utf8");
 }
 async function cleanupWorktreeIfSafe(context) {
@@ -2095,20 +2793,20 @@ async function runLoop(config) {
   const logger = new Logger({ verbose: config.verbose, logFile: config.logFile });
   const repoRoot = await getRepoRoot(config.cwd, logger);
   logger.debug(`\u4ED3\u5E93\u6839\u76EE\u5F55: ${repoRoot}`);
-  const worktreeResult = config.git.useWorktree ? await ensureWorktree(config.git, repoRoot, logger) : { path: repoRoot, created: false };
-  const workDir = worktreeResult.path;
-  const worktreeCreated = worktreeResult.created;
-  logger.debug(`\u5DE5\u4F5C\u76EE\u5F55: ${workDir}`);
-  const commandLine = formatCommandLine(process.argv);
-  const runTracker = await createRunTracker({
-    logFile: config.logFile,
-    command: commandLine,
-    path: workDir,
-    logger
-  });
   let branchName = config.git.branchName;
+  let workDir = repoRoot;
+  let worktreeCreated = false;
+  const commandLine = formatCommandLine(process.argv);
+  let runTracker = null;
+  let accumulatedUsage = null;
+  let lastTestResults = null;
+  let lastAiOutput = "";
   let lastRound = 0;
   let runError = null;
+  let prInfo = null;
+  let prFailed = false;
+  let sessionIndex = 0;
+  const preWorktreeRecords = [];
   const notifyWebhook = async (event, iteration, stage) => {
     const payload = buildWebhookPayload({
       event,
@@ -2120,15 +2818,46 @@ async function runLoop(config) {
     await sendWebhookNotifications(config.webhooks, payload, logger);
   };
   try {
-    if (!branchName) {
-      try {
-        branchName = await getCurrentBranch(workDir, logger);
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.warn(`\u8BFB\u53D6\u5206\u652F\u540D\u5931\u8D25\uFF0Cwebhook \u4E2D\u5C06\u7F3A\u5931\u5206\u652F\u4FE1\u606F\uFF1A${message}`);
+    await notifyWebhook("task_start", 0, "\u4EFB\u52A1\u5F00\u59CB");
+    if (config.git.useWorktree && !branchName) {
+      const branchPrompt = buildBranchNamePrompt({ task: config.task });
+      await notifyWebhook("iteration_start", sessionIndex + 1, "\u5206\u652F\u540D\u751F\u6210");
+      logger.info("\u5206\u652F\u540D\u751F\u6210\u63D0\u793A\u6784\u5EFA\u5B8C\u6210\uFF0C\u8C03\u7528 AI CLI...");
+      const aiResult = await runAi(branchPrompt, config.ai, logger, repoRoot);
+      accumulatedUsage = mergeTokenUsage(accumulatedUsage, aiResult.usage);
+      lastAiOutput = aiResult.output;
+      sessionIndex += 1;
+      lastRound = sessionIndex;
+      const record = formatIterationRecord({
+        iteration: sessionIndex,
+        stage: "\u5206\u652F\u540D\u751F\u6210",
+        prompt: branchPrompt,
+        aiOutput: aiResult.output,
+        timestamp: isoNow()
+      });
+      preWorktreeRecords.push(record);
+      const parsed = parseBranchName(aiResult.output);
+      if (parsed) {
+        branchName = parsed;
+        logger.info(`AI \u751F\u6210\u5206\u652F\u540D\uFF1A${branchName}`);
+      } else {
+        branchName = generateBranchNameFromTask(config.task);
+        logger.warn(`\u672A\u89E3\u6790\u5230 AI \u5206\u652F\u540D\uFF0C\u4F7F\u7528\u515C\u5E95\u5206\u652F\uFF1A${branchName}`);
       }
     }
-    await notifyWebhook("task_start", 0, "\u4EFB\u52A1\u5F00\u59CB");
+    const worktreeResult = config.git.useWorktree ? await ensureWorktree({ ...config.git, branchName }, repoRoot, logger) : { path: repoRoot, created: false };
+    workDir = worktreeResult.path;
+    worktreeCreated = worktreeResult.created;
+    logger.debug(`\u5DE5\u4F5C\u76EE\u5F55: ${workDir}`);
+    runTracker = await createRunTracker({
+      logFile: config.logFile,
+      command: commandLine,
+      path: workDir,
+      logger
+    });
+    if (runTracker && sessionIndex > 0) {
+      await runTracker.update(sessionIndex, accumulatedUsage?.totalTokens ?? 0);
+    }
     if (config.skipInstall) {
       logger.info("\u5DF2\u8DF3\u8FC7\u4F9D\u8D56\u68C0\u67E5");
     } else {
@@ -2136,79 +2865,203 @@ async function runLoop(config) {
     }
     const workflowFiles = reRootWorkflowFiles(config.workflowFiles, repoRoot, workDir);
     await ensureWorkflowFiles(workflowFiles);
+    if (preWorktreeRecords.length > 0) {
+      for (const record of preWorktreeRecords) {
+        await appendSection(workflowFiles.notesFile, record);
+      }
+      logger.success(`\u5DF2\u5199\u5165\u5206\u652F\u540D\u751F\u6210\u8BB0\u5F55\u81F3 ${workflowFiles.notesFile}`);
+    }
     const planContent = await readFileSafe(workflowFiles.planFile);
     if (planContent.trim().length === 0) {
       logger.warn("plan \u6587\u4EF6\u4E3A\u7A7A\uFF0C\u5EFA\u8BAE AI \u9996\u8F6E\u751F\u6210\u8BA1\u5212");
     }
+    if (!branchName) {
+      try {
+        branchName = await getCurrentBranch(workDir, logger);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn(`\u8BFB\u53D6\u5206\u652F\u540D\u5931\u8D25\uFF0Cwebhook \u4E2D\u5C06\u7F3A\u5931\u5206\u652F\u4FE1\u606F\uFF1A${message}`);
+      }
+    }
     const aiConfig = config.ai;
-    let accumulatedUsage = null;
-    let lastTestResults = null;
-    let lastAiOutput = "";
-    let prInfo = null;
-    let prFailed = false;
-    for (let i = 1; i <= config.iterations; i += 1) {
-      await notifyWebhook("iteration_start", i, `\u5F00\u59CB\u7B2C ${i} \u8F6E\u8FED\u4EE3`);
-      const workflowGuide = await readFileSafe(workflowFiles.workflowDoc);
-      const plan = await readFileSafe(workflowFiles.planFile);
-      const notes = await readFileSafe(workflowFiles.notesFile);
-      logger.debug(`\u52A0\u8F7D\u63D0\u793A\u4E0A\u4E0B\u6587\uFF0C\u957F\u5EA6\uFF1Aworkflow=${workflowGuide.length}, plan=${plan.length}, notes=${notes.length}`);
-      const prompt = buildPrompt({
-        task: config.task,
-        workflowGuide,
-        plan,
-        notes,
-        iteration: i
-      });
-      logger.debug(`\u7B2C ${i} \u8F6E\u63D0\u793A\u957F\u5EA6: ${prompt.length}`);
-      logger.info(`\u7B2C ${i} \u8F6E\u63D0\u793A\u6784\u5EFA\u5B8C\u6210\uFF0C\u8C03\u7528 AI CLI...`);
-      const aiResult = await runAi(prompt, aiConfig, logger, workDir);
+    const loadContext = async () => ({
+      workflowGuide: await readFileSafe(workflowFiles.workflowDoc),
+      plan: await readFileSafe(workflowFiles.planFile),
+      notes: await readFileSafe(workflowFiles.notesFile)
+    });
+    const runAiSession = async (stage, prompt, extras) => {
+      sessionIndex += 1;
+      await notifyWebhook("iteration_start", sessionIndex, stage);
+      logger.info(`${stage} \u63D0\u793A\u6784\u5EFA\u5B8C\u6210\uFF0C\u8C03\u7528 AI CLI...`);
+      const aiResult = await runAi(prompt, aiConfig, logger, extras?.cwd ?? workDir);
       accumulatedUsage = mergeTokenUsage(accumulatedUsage, aiResult.usage);
       lastAiOutput = aiResult.output;
-      const hitStop = aiResult.output.includes(config.stopSignal);
-      let testResults = [];
-      const shouldRunTests = config.runTests || config.runE2e;
-      if (shouldRunTests) {
-        try {
-          testResults = await runTests(config, workDir, logger);
-        } catch (error) {
-          const errorMessage = String(error);
-          logger.warn(`\u6D4B\u8BD5\u6267\u884C\u5F02\u5E38: ${errorMessage}`);
-          testResults = [{
-            kind: "unit",
-            command: config.tests.unitCommand ?? "\u672A\u77E5\u6D4B\u8BD5\u547D\u4EE4",
-            success: false,
-            exitCode: -1,
-            stdout: "",
-            stderr: trimOutput(errorMessage)
-          }];
-        }
-      }
       const record = formatIterationRecord({
-        iteration: i,
+        iteration: sessionIndex,
+        stage,
         prompt,
         aiOutput: aiResult.output,
         timestamp: isoNow(),
-        testResults
+        testResults: extras?.testResults,
+        checkResults: extras?.checkResults
       });
       await appendSection(workflowFiles.notesFile, record);
-      logger.success(`\u5DF2\u5C06\u7B2C ${i} \u8F6E\u8F93\u51FA\u5199\u5165 ${workflowFiles.notesFile}`);
+      logger.success(`\u5DF2\u5C06${stage}\u8F93\u51FA\u5199\u5165 ${workflowFiles.notesFile}`);
+      lastRound = sessionIndex;
+      await runTracker?.update(sessionIndex, accumulatedUsage?.totalTokens ?? 0);
+    };
+    {
+      const { workflowGuide, plan, notes } = await loadContext();
+      const planningPrompt = buildPlanningPrompt({
+        task: config.task,
+        workflowGuide,
+        plan,
+        notes,
+        branchName
+      });
+      await runAiSession("\u8BA1\u5212\u751F\u6210", planningPrompt);
+    }
+    let refreshedPlan = await readFileSafe(workflowFiles.planFile);
+    if (/(测试|test|e2e|单测)/i.test(refreshedPlan)) {
+      logger.warn("\u68C0\u6D4B\u5230 plan \u4E2D\u53EF\u80FD\u5305\u542B\u6D4B\u8BD5\u76F8\u5173\u4E8B\u9879\uFF0C\u5EFA\u8BAE\u4FDD\u7559\u5F00\u53D1\u5185\u5BB9\u5E76\u79FB\u9664\u6D4B\u8BD5\u9879\u3002");
+    }
+    let pendingItems = getPendingPlanItems(refreshedPlan);
+    if (pendingItems.length === 0) {
+      logger.info("\u8BA1\u5212\u6682\u65E0\u5F85\u6267\u884C\u9879\uFF0C\u8DF3\u8FC7\u8BA1\u5212\u6267\u884C\u5FAA\u73AF");
+      const record = formatSystemRecord("\u8BA1\u5212\u6267\u884C", "\u672A\u53D1\u73B0\u5F85\u6267\u884C\u8BA1\u5212\u9879\uFF0C\u5DF2\u8DF3\u8FC7\u6267\u884C\u5FAA\u73AF\u3002", isoNow());
+      await appendSection(workflowFiles.notesFile, record);
+    }
+    let planRounds = 0;
+    while (pendingItems.length > 0) {
+      if (planRounds >= config.iterations) {
+        throw new Error("\u8BA1\u5212\u6267\u884C\u8FBE\u5230\u6700\u5927\u8FED\u4EE3\u6B21\u6570\uFF0C\u4ECD\u6709\u672A\u5B8C\u6210\u9879");
+      }
+      const lastItem = pendingItems[pendingItems.length - 1];
+      const { workflowGuide, plan, notes } = await loadContext();
+      const itemPrompt = buildPlanItemPrompt({
+        task: config.task,
+        workflowGuide,
+        plan,
+        notes,
+        item: lastItem.text
+      });
+      await runAiSession(`\u6267\u884C\u8BA1\u5212\u9879\uFF1A${truncateText(lastItem.text)}`, itemPrompt);
+      planRounds += 1;
+      refreshedPlan = await readFileSafe(workflowFiles.planFile);
+      pendingItems = getPendingPlanItems(refreshedPlan);
+    }
+    const agentsContent = await readFileSafe(import_node_path9.default.join(workDir, "AGENTS.md"));
+    const skipQuality = shouldSkipQuality(agentsContent, config.skipQuality);
+    if (skipQuality) {
+      const record = formatSystemRecord("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5", "\u5DF2\u6309\u914D\u7F6E/AGENTS.md \u8DF3\u8FC7\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5\u3002", isoNow());
+      await appendSection(workflowFiles.notesFile, record);
+      logger.info("\u5DF2\u8DF3\u8FC7\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5");
+    } else {
+      const qualityCommands = await detectQualityCommands(workDir);
+      if (qualityCommands.length === 0) {
+        const record = formatSystemRecord("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5", "\u672A\u68C0\u6D4B\u5230\u53EF\u6267\u884C\u7684\u8D28\u91CF\u68C0\u67E5\u547D\u4EE4\uFF0C\u5DF2\u8DF3\u8FC7\u3002", isoNow());
+        await appendSection(workflowFiles.notesFile, record);
+        logger.info("\u672A\u68C0\u6D4B\u5230\u8D28\u91CF\u68C0\u67E5\u547D\u4EE4\uFF0C\u8DF3\u8FC7\u8BE5\u9636\u6BB5");
+      } else {
+        let qualityResults = await runQualityChecks(qualityCommands, workDir, logger);
+        const { workflowGuide, plan, notes } = await loadContext();
+        const qualityPrompt = buildQualityPrompt({
+          task: config.task,
+          workflowGuide,
+          plan,
+          notes,
+          commands: qualityCommands.map((item) => item.command),
+          results: buildCheckResultSummary(qualityResults)
+        });
+        await runAiSession("\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5", qualityPrompt, { checkResults: qualityResults });
+        let hasQualityFailure = qualityResults.some((result) => !result.success);
+        let fixRounds = 0;
+        while (hasQualityFailure) {
+          if (fixRounds >= config.iterations) {
+            throw new Error("\u4EE3\u7801\u8D28\u91CF\u4FEE\u590D\u8FBE\u5230\u6700\u5927\u8F6E\u6B21\uFF0C\u4ECD\u672A\u901A\u8FC7");
+          }
+          const latest = await loadContext();
+          const fixPrompt = buildFixPrompt({
+            task: config.task,
+            workflowGuide: latest.workflowGuide,
+            plan: latest.plan,
+            notes: latest.notes,
+            stage: "\u4EE3\u7801\u8D28\u91CF",
+            errors: buildFailedCheckSummary(qualityResults)
+          });
+          await runAiSession("\u4EE3\u7801\u8D28\u91CF\u4FEE\u590D", fixPrompt);
+          fixRounds += 1;
+          qualityResults = await runQualityChecks(qualityCommands, workDir, logger);
+          hasQualityFailure = qualityResults.some((result) => !result.success);
+          const recheckRecord = formatSystemRecord("\u4EE3\u7801\u8D28\u91CF\u590D\u6838", buildCheckResultSummary(qualityResults), isoNow());
+          await appendSection(workflowFiles.notesFile, recheckRecord);
+        }
+      }
+    }
+    if (config.runTests || config.runE2e) {
+      let testResults = await runTestsSafely(config, workDir, logger);
       lastTestResults = testResults;
-      lastRound = i;
-      await runTracker?.update(i, accumulatedUsage?.totalTokens ?? 0);
-      const hasTestFailure = testResults.some((result) => !result.success);
-      if (hitStop && !hasTestFailure) {
-        logger.info(`\u68C0\u6D4B\u5230\u505C\u6B62\u6807\u8BB0 ${config.stopSignal}\uFF0C\u63D0\u524D\u7ED3\u675F\u5FAA\u73AF`);
-        break;
+      const testCommands = [];
+      if (config.runTests && config.tests.unitCommand) {
+        testCommands.push(config.tests.unitCommand);
       }
-      if (hitStop && hasTestFailure) {
-        logger.info(`\u68C0\u6D4B\u5230\u505C\u6B62\u6807\u8BB0 ${config.stopSignal}\uFF0C\u4F46\u6D4B\u8BD5\u5931\u8D25\uFF0C\u7EE7\u7EED\u8FDB\u5165\u4E0B\u4E00\u8F6E\u4FEE\u590D`);
+      if (config.runE2e && config.tests.e2eCommand) {
+        testCommands.push(config.tests.e2eCommand);
       }
+      const { workflowGuide, plan, notes } = await loadContext();
+      const testPrompt = buildTestPrompt({
+        task: config.task,
+        workflowGuide,
+        plan,
+        notes,
+        commands: testCommands,
+        results: buildTestResultSummary(testResults)
+      });
+      await runAiSession("\u6D4B\u8BD5\u6267\u884C", testPrompt, { testResults });
+      let hasTestFailure = testResults.some((result) => !result.success);
+      let fixRounds = 0;
+      while (hasTestFailure) {
+        if (fixRounds >= config.iterations) {
+          throw new Error("\u6D4B\u8BD5\u4FEE\u590D\u8FBE\u5230\u6700\u5927\u8F6E\u6B21\uFF0C\u4ECD\u672A\u901A\u8FC7");
+        }
+        const latest = await loadContext();
+        const fixPrompt = buildFixPrompt({
+          task: config.task,
+          workflowGuide: latest.workflowGuide,
+          plan: latest.plan,
+          notes: latest.notes,
+          stage: "\u6D4B\u8BD5",
+          errors: buildFailedTestSummary(testResults)
+        });
+        await runAiSession("\u6D4B\u8BD5\u4FEE\u590D", fixPrompt, { testResults });
+        fixRounds += 1;
+        testResults = await runTestsSafely(config, workDir, logger);
+        lastTestResults = testResults;
+        hasTestFailure = testResults.some((result) => !result.success);
+        const recheckRecord = formatSystemRecord("\u6D4B\u8BD5\u590D\u6838", buildTestResultSummary(testResults), isoNow());
+        await appendSection(workflowFiles.notesFile, recheckRecord);
+      }
+    } else {
+      const record = formatSystemRecord("\u6D4B\u8BD5\u6267\u884C", "\u672A\u5F00\u542F\u5355\u5143\u6D4B\u8BD5\u6216 e2e \u6D4B\u8BD5\uFF0C\u5DF2\u8DF3\u8FC7\u3002", isoNow());
+      await appendSection(workflowFiles.notesFile, record);
+      logger.info("\u672A\u5F00\u542F\u6D4B\u8BD5\u9636\u6BB5");
+    }
+    {
+      const { workflowGuide, plan, notes } = await loadContext();
+      const docsPrompt = buildDocsPrompt({
+        task: config.task,
+        workflowGuide,
+        plan,
+        notes
+      });
+      await runAiSession("\u6587\u6863\u66F4\u65B0", docsPrompt);
     }
     const lastTestFailed = lastTestResults?.some((result) => !result.success) ?? false;
     if (lastTestFailed) {
       logger.warn("\u5B58\u5728\u672A\u901A\u8FC7\u7684\u6D4B\u8BD5\uFF0C\u5DF2\u8DF3\u8FC7\u81EA\u52A8\u63D0\u4EA4/\u63A8\u9001/PR");
     }
     let deliverySummary = null;
+    const deliveryNotes = [];
     const shouldPrepareDelivery = !lastTestFailed && (config.autoCommit || config.pr.enable);
     if (shouldPrepareDelivery) {
       const [gitStatus, diffStat] = await Promise.all([
@@ -2238,53 +3091,107 @@ async function runLoop(config) {
       if (!deliverySummary) {
         deliverySummary = buildFallbackSummary({ task: config.task, testResults: lastTestResults });
       }
+      if (deliverySummary) {
+        deliveryNotes.push(`\u4EA4\u4ED8\u6458\u8981\uFF1A\u63D0\u4EA4 ${deliverySummary.commitTitle}\uFF5CPR ${deliverySummary.prTitle}`);
+      }
     }
     await runTracker?.update(lastRound, accumulatedUsage?.totalTokens ?? 0);
-    if (config.autoCommit && !lastTestFailed) {
-      const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
-      const commitMessage = {
-        title: summary.commitTitle,
-        body: summary.commitBody
-      };
-      await commitAll(commitMessage, workDir, logger).catch((error) => {
-        logger.warn(String(error));
-      });
-    }
-    if (config.autoPush && branchName && !lastTestFailed) {
-      await pushBranch(branchName, workDir, logger).catch((error) => {
-        logger.warn(String(error));
-      });
+    if (config.autoCommit) {
+      if (lastTestFailed) {
+        deliveryNotes.push("\u81EA\u52A8\u63D0\u4EA4\uFF1A\u5DF2\u8DF3\u8FC7\uFF08\u6D4B\u8BD5\u672A\u901A\u8FC7\uFF09");
+      } else {
+        const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
+        const commitMessage = {
+          title: summary.commitTitle,
+          body: summary.commitBody
+        };
+        try {
+          const committed = await commitAll(commitMessage, workDir, logger);
+          deliveryNotes.push(committed ? `\u81EA\u52A8\u63D0\u4EA4\uFF1A\u5DF2\u63D0\u4EA4\uFF08${commitMessage.title}\uFF09` : "\u81EA\u52A8\u63D0\u4EA4\uFF1A\u672A\u751F\u6210\u63D0\u4EA4\uFF08\u53EF\u80FD\u65E0\u53D8\u66F4\u6216\u63D0\u4EA4\u5931\u8D25\uFF09");
+        } catch (error) {
+          deliveryNotes.push(`\u81EA\u52A8\u63D0\u4EA4\uFF1A\u5931\u8D25\uFF08${String(error)}\uFF09`);
+        }
+      }
+    } else {
+      deliveryNotes.push("\u81EA\u52A8\u63D0\u4EA4\uFF1A\u672A\u5F00\u542F");
     }
-    if (config.pr.enable && branchName && !lastTestFailed) {
-      logger.info("\u5F00\u59CB\u521B\u5EFA PR...");
-      const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
-      const prTitleCandidate = config.pr.title?.trim() || summary.prTitle;
-      const prBodyContent = ensurePrBodySections(summary.prBody, {
-        commitTitle: summary.commitTitle,
-        commitBody: summary.commitBody,
-        testResults: lastTestResults
-      });
-      const bodyFile = config.pr.bodyPath ?? buildBodyFile(workDir);
-      await writePrBody(bodyFile, prBodyContent, Boolean(config.pr.bodyPath));
-      const createdPr = await createPr(branchName, { ...config.pr, title: prTitleCandidate, bodyPath: bodyFile }, workDir, logger);
-      prInfo = createdPr;
-      if (createdPr) {
-        logger.success(`PR \u5DF2\u521B\u5EFA: ${createdPr.url}`);
-        const failedRuns = await listFailedRuns(branchName, workDir, logger);
-        if (failedRuns.length > 0) {
-          failedRuns.forEach((run) => {
-            logger.warn(`Actions \u5931\u8D25: ${run.name} (${run.status}/${run.conclusion ?? "unknown"}) ${run.url}`);
-          });
+    if (config.autoPush) {
+      if (lastTestFailed) {
+        deliveryNotes.push("\u81EA\u52A8\u63A8\u9001\uFF1A\u5DF2\u8DF3\u8FC7\uFF08\u6D4B\u8BD5\u672A\u901A\u8FC7\uFF09");
+      } else if (!branchName) {
+        deliveryNotes.push("\u81EA\u52A8\u63A8\u9001\uFF1A\u5DF2\u8DF3\u8FC7\uFF08\u7F3A\u5C11\u5206\u652F\u540D\uFF09");
+      } else {
+        try {
+          await pushBranch(branchName, workDir, logger);
+          deliveryNotes.push(`\u81EA\u52A8\u63A8\u9001\uFF1A\u5DF2\u63A8\u9001\uFF08${branchName}\uFF09`);
+        } catch (error) {
+          deliveryNotes.push(`\u81EA\u52A8\u63A8\u9001\uFF1A\u5931\u8D25\uFF08${String(error)}\uFF09`);
         }
+      }
+    } else {
+      deliveryNotes.push("\u81EA\u52A8\u63A8\u9001\uFF1A\u672A\u5F00\u542F");
+    }
+    if (config.pr.enable) {
+      if (lastTestFailed) {
+        deliveryNotes.push("PR \u521B\u5EFA\uFF1A\u5DF2\u8DF3\u8FC7\uFF08\u6D4B\u8BD5\u672A\u901A\u8FC7\uFF09");
+      } else if (!branchName) {
+        deliveryNotes.push("PR \u521B\u5EFA\uFF1A\u5DF2\u8DF3\u8FC7\uFF08\u7F3A\u5C11\u5206\u652F\u540D\uFF09");
       } else {
-        prFailed = true;
-        logger.error("PR \u521B\u5EFA\u5931\u8D25\uFF0C\u8BE6\u89C1\u4E0A\u65B9 gh \u8F93\u51FA");
+        logger.info("\u5F00\u59CB\u521B\u5EFA PR...");
+        const summary = deliverySummary ?? buildFallbackSummary({ task: config.task, testResults: lastTestResults });
+        const prTitleCandidate = config.pr.title?.trim() || summary.prTitle;
+        const prBodyContent = ensurePrBodySections(summary.prBody, {
+          commitTitle: summary.commitTitle,
+          commitBody: summary.commitBody,
+          testResults: lastTestResults
+        });
+        const bodyFile = config.pr.bodyPath ?? buildBodyFile(workDir);
+        await writePrBody(bodyFile, prBodyContent, Boolean(config.pr.bodyPath));
+        const createdPr = await createPr(branchName, { ...config.pr, title: prTitleCandidate, bodyPath: bodyFile }, workDir, logger);
+        prInfo = createdPr;
+        if (createdPr) {
+          logger.success(`PR \u5DF2\u521B\u5EFA: ${createdPr.url}`);
+          deliveryNotes.push(`PR \u521B\u5EFA\uFF1A\u5DF2\u5B8C\u6210\uFF08${createdPr.url}\uFF09`);
+          if (config.pr.autoMerge) {
+            const target = createdPr.number > 0 ? createdPr.number : createdPr.url;
+            const merged = await enableAutoMerge(target, workDir, logger);
+            if (merged) {
+              deliveryNotes.push("PR \u81EA\u52A8\u5408\u5E76\uFF1A\u5DF2\u542F\u7528");
+            } else {
+              deliveryNotes.push("PR \u81EA\u52A8\u5408\u5E76\uFF1A\u542F\u7528\u5931\u8D25");
+              prFailed = true;
+            }
+          } else {
+            deliveryNotes.push("PR \u81EA\u52A8\u5408\u5E76\uFF1A\u672A\u5F00\u542F");
+          }
+          const failedRuns = await listFailedRuns(branchName, workDir, logger);
+          if (failedRuns.length > 0) {
+            failedRuns.forEach((run) => {
+              logger.warn(`Actions \u5931\u8D25: ${run.name} (${run.status}/${run.conclusion ?? "unknown"}) ${run.url}`);
+            });
+          }
+        } else {
+          prFailed = true;
+          deliveryNotes.push("PR \u521B\u5EFA\uFF1A\u5931\u8D25\uFF08\u8BE6\u89C1 gh \u8F93\u51FA\uFF09");
+          logger.error("PR \u521B\u5EFA\u5931\u8D25\uFF0C\u8BE6\u89C1\u4E0A\u65B9 gh \u8F93\u51FA");
+        }
       }
-    } else if (branchName && !config.pr.enable) {
+    } else if (branchName) {
       logger.info("\u672A\u5F00\u542F PR \u521B\u5EFA\uFF08--pr \u672A\u4F20\uFF09\uFF0C\u5C1D\u8BD5\u67E5\u770B\u5DF2\u6709 PR");
       const existingPr = await viewPr(branchName, workDir, logger);
       prInfo = existingPr;
-      if (existingPr) logger.info(`\u5DF2\u6709 PR: ${existingPr.url}`);
+      if (existingPr) {
+        logger.info(`\u5DF2\u6709 PR: ${existingPr.url}`);
+        deliveryNotes.push(`PR \u521B\u5EFA\uFF1A\u672A\u5F00\u542F\uFF08\u5DF2\u5B58\u5728 PR\uFF1A${existingPr.url}\uFF09`);
+      } else {
+        deliveryNotes.push("PR \u521B\u5EFA\uFF1A\u672A\u5F00\u542F\uFF08\u672A\u68C0\u6D4B\u5230\u5DF2\u6709 PR\uFF09");
+      }
+    } else {
+      deliveryNotes.push("PR \u521B\u5EFA\uFF1A\u672A\u5F00\u542F\uFF08\u7F3A\u5C11\u5206\u652F\u540D\uFF09");
+    }
+    if (deliveryNotes.length > 0) {
+      const record = formatSystemRecord("\u63D0\u4EA4\u4E0EPR", deliveryNotes.join("\n"), isoNow());
+      await appendSection(workflowFiles.notesFile, record);
     }
     if (accumulatedUsage) {
       const input = accumulatedUsage.inputTokens ?? "-";
@@ -2307,6 +3214,7 @@ async function runLoop(config) {
       });
     }
     logger.success(`wheel-ai \u8FED\u4EE3\u6D41\u7A0B\u7ED3\u675F\uFF5CToken \u603B\u8BA1 ${accumulatedUsage?.totalTokens ?? "\u672A\u77E5"}`);
+    return { branchName };
   } catch (error) {
     runError = error instanceof Error ? error.message : String(error);
     throw error;
@@ -2317,23 +3225,164 @@ async function runLoop(config) {
   }
 }
 
+// src/multi-task.ts
+var import_node_path10 = __toESM(require("path"));
+var MODE_ALIASES = {
+  relay: "relay",
+  serial: "serial",
+  "serial-continue": "serial-continue",
+  parallel: "parallel",
+  \u63A5\u529B\u6A21\u5F0F: "relay",
+  \u63A5\u529B: "relay",
+  \u4E32\u884C\u6267\u884C: "serial",
+  \u4E32\u884C: "serial",
+  \u4E32\u884C\u6267\u884C\u4F46\u662F\u5931\u8D25\u4E5F\u7EE7\u7EED: "serial-continue",
+  \u4E32\u884C\u7EE7\u7EED: "serial-continue",
+  \u5E76\u884C\u6267\u884C: "parallel",
+  \u5E76\u884C: "parallel"
+};
+function parseMultiTaskMode(raw) {
+  if (!raw) return "relay";
+  const trimmed = raw.trim();
+  if (!trimmed) return "relay";
+  const resolved = MODE_ALIASES[trimmed];
+  if (!resolved) {
+    throw new Error(`\u672A\u77E5 multi-task \u6A21\u5F0F: ${raw}`);
+  }
+  return resolved;
+}
+function normalizeTaskList(input) {
+  if (Array.isArray(input)) {
+    return input.map((task) => task.trim()).filter((task) => task.length > 0);
+  }
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    return trimmed.length > 0 ? [trimmed] : [];
+  }
+  return [];
+}
+function buildBranchNameSeries(branchInput, total) {
+  if (total <= 0) return [];
+  if (!branchInput) {
+    return Array.from({ length: total }, () => void 0);
+  }
+  const baseName = branchInput;
+  const names = [baseName];
+  for (let i = 1; i < total; i += 1) {
+    names.push(`${baseName}-${i + 1}`);
+  }
+  return names;
+}
+function appendPathSuffix(filePath, suffix) {
+  const parsed = import_node_path10.default.parse(filePath);
+  const nextName = parsed.name ? `${parsed.name}-${suffix}` : suffix;
+  return import_node_path10.default.join(parsed.dir, `${nextName}${parsed.ext}`);
+}
+function deriveIndexedPath(basePath, index, total, label) {
+  if (!basePath) return void 0;
+  if (total <= 1 || index === 0) return basePath;
+  return appendPathSuffix(basePath, `${label}-${index + 1}`);
+}
+function buildTaskPlans(input) {
+  const total = input.tasks.length;
+  if (total === 0) return [];
+  const branchNames = input.useWorktree ? buildBranchNameSeries(input.branchInput, total) : input.tasks.map(() => input.branchInput);
+  return input.tasks.map((task, index) => {
+    const relayBaseBranch = input.useWorktree && input.mode === "relay" && index > 0 ? branchNames[index - 1] ?? input.baseBranch : input.baseBranch;
+    return {
+      task,
+      index,
+      branchName: branchNames[index],
+      baseBranch: relayBaseBranch,
+      worktreePath: deriveIndexedPath(input.worktreePath, index, total, "task"),
+      logFile: deriveIndexedPath(input.logFile, index, total, "task")
+    };
+  });
+}
+
 // src/monitor.ts
-var import_fs_extra8 = __toESM(require("fs-extra"));
-var import_node_path9 = __toESM(require("path"));
+var import_fs_extra10 = __toESM(require("fs-extra"));
+var import_node_path11 = __toESM(require("path"));
 var REFRESH_INTERVAL = 1e3;
-function getTerminalSize2() {
+var TERMINATE_GRACE_MS = 800;
+function getTerminalSize3() {
   const rows = process.stdout.rows ?? 24;
   const columns = process.stdout.columns ?? 80;
   return { rows, columns };
 }
-function truncateLine2(line, width) {
+function truncateLine3(line, width) {
   if (width <= 0) return "";
   if (line.length <= width) return line;
   return line.slice(0, width);
 }
+function padLine(text, width) {
+  if (width <= 0) return "";
+  const truncated = text.length > width ? text.slice(0, width) : text;
+  const padding = width - truncated.length;
+  const left = Math.floor(padding / 2);
+  const right = padding - left;
+  return `${" ".repeat(left)}${truncated}${" ".repeat(right)}`;
+}
+function buildConfirmDialogLines(taskKey, columns) {
+  if (columns <= 0) return [];
+  const message = `\u786E\u8BA4\u7EC8\u6B62\u4EFB\u52A1 ${taskKey}?`;
+  const hint = "y \u786E\u8BA4 / n \u53D6\u6D88";
+  const minWidth = Math.max(message.length, hint.length, 4);
+  const innerWidth = Math.min(columns - 2, minWidth);
+  if (innerWidth <= 0) {
+    return [truncateLine3(message, columns), truncateLine3(hint, columns)];
+  }
+  const border = `+${"-".repeat(innerWidth)}+`;
+  const lines = [
+    border,
+    `|${padLine(message, innerWidth)}|`,
+    `|${padLine(hint, innerWidth)}|`,
+    border
+  ];
+  return lines.map((line) => truncateLine3(line, columns));
+}
+function applyDialogOverlay(lines, dialogLines) {
+  if (lines.length === 0 || dialogLines.length === 0) return;
+  const start = Math.max(0, Math.floor((lines.length - dialogLines.length) / 2));
+  for (let i = 0; i < dialogLines.length && start + i < lines.length; i += 1) {
+    lines[start + i] = dialogLines[i];
+  }
+}
+function resolveTerminationTarget(pid, platform = process.platform) {
+  return platform === "win32" ? pid : -pid;
+}
+function isProcessAlive(pid) {
+  if (!Number.isFinite(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const err = error;
+    if (err?.code === "ESRCH") return false;
+    return true;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function setStatus(state, message, isError = false) {
+  state.statusMessage = message;
+  state.statusIsError = message ? isError : false;
+}
+function findTaskByKey(state, key) {
+  return state.tasks.find((task) => task.key === key);
+}
+async function safeRemoveRegistry(logFile) {
+  try {
+    await removeCurrentRegistry(logFile);
+  } catch {
+  }
+}
 async function readLogLines2(logFile) {
   try {
-    const content = await import_fs_extra8.default.readFile(logFile, "utf8");
+    const content = await import_fs_extra10.default.readFile(logFile, "utf8");
     const normalized = content.replace(/\r\n?/g, "\n");
     const lines = normalized.split("\n");
     return lines.length > 0 ? lines : [""];
@@ -2345,8 +3394,18 @@ async function readLogLines2(logFile) {
 async function loadTasks(logsDir) {
   const registry = await readCurrentRegistry();
   const entries = Object.entries(registry).sort(([a], [b]) => a.localeCompare(b));
-  const tasks = await Promise.all(entries.map(async ([key, meta]) => {
-    const logFile = meta.logFile ?? import_node_path9.default.join(logsDir, key);
+  const aliveEntries = [];
+  for (const [key, meta] of entries) {
+    const pid = typeof meta.pid === "number" ? meta.pid : void 0;
+    if (pid && !isProcessAlive(pid)) {
+      const logFile = meta.logFile ?? import_node_path11.default.join(logsDir, key);
+      await safeRemoveRegistry(logFile);
+      continue;
+    }
+    aliveEntries.push([key, meta]);
+  }
+  const tasks = await Promise.all(aliveEntries.map(async ([key, meta]) => {
+    const logFile = meta.logFile ?? import_node_path11.default.join(logsDir, key);
     const lines = await readLogLines2(logFile);
     return {
       key,
@@ -2357,56 +3416,71 @@ async function loadTasks(logsDir) {
   }));
   return tasks;
 }
-function buildHeader(state, columns) {
+function buildHeader2(state, columns) {
   if (state.tasks.length === 0) {
-    return truncateLine2("\u6682\u65E0\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\uFF0C\u6309 q \u9000\u51FA", columns);
+    return truncateLine3("\u6682\u65E0\u8FD0\u884C\u4E2D\u7684\u4EFB\u52A1\uFF0C\u6309 q \u9000\u51FA", columns);
   }
   const current = state.tasks[state.selectedIndex];
   const total = state.tasks.length;
   const index = state.selectedIndex + 1;
-  const title = `\u4EFB\u52A1 ${index}/${total} \uFF5C ${current.key} \uFF5C \u2190/\u2192 \u5207\u6362\u4EFB\u52A1  \u2191/\u2193 \u7FFB\u9875  q \u9000\u51FA`;
-  return truncateLine2(title, columns);
+  const title = `\u4EFB\u52A1 ${index}/${total} \uFF5C ${current.key} \uFF5C \u2190/\u2192 \u5207\u6362\u4EFB\u52A1  \u2191/\u2193 \u4E0A\u4E0B 1 \u884C  PageUp/PageDown \u7FFB\u9875  t \u7EC8\u6B62  q \u9000\u51FA`;
+  return truncateLine3(title, columns);
 }
-function buildStatus(task, page, columns, errorMessage) {
+function buildStatus2(task, page, columns, errorMessage, statusMessage, statusIsError) {
   const meta = task.meta;
   const status = `\u8F6E\u6B21 ${meta.round} \uFF5C Token ${meta.tokenUsed} \uFF5C \u9875 ${page.current}/${page.total} \uFF5C \u9879\u76EE ${meta.path}`;
-  const suffix = errorMessage ? ` \uFF5C \u5237\u65B0\u5931\u8D25\uFF1A${errorMessage}` : "";
-  return truncateLine2(`${status}${suffix}`, columns);
+  const extras = [];
+  if (errorMessage) {
+    extras.push(`\u5237\u65B0\u5931\u8D25\uFF1A${errorMessage}`);
+  }
+  if (statusMessage) {
+    extras.push(statusIsError ? `\u64CD\u4F5C\u5931\u8D25\uFF1A${statusMessage}` : statusMessage);
+  }
+  const suffix = extras.length > 0 ? ` \uFF5C ${extras.join(" \uFF5C ")}` : "";
+  return truncateLine3(`${status}${suffix}`, columns);
 }
-function getPageSize2(rows) {
+function getPageSize3(rows) {
   return Math.max(1, rows - 2);
 }
-function render2(state) {
-  const { rows, columns } = getTerminalSize2();
-  const pageSize = getPageSize2(rows);
-  const header = buildHeader(state, columns);
+function render3(state) {
+  const { rows, columns } = getTerminalSize3();
+  const pageSize = getPageSize3(rows);
+  const header = buildHeader2(state, columns);
   if (state.tasks.length === 0) {
     const filler = Array.from({ length: pageSize }, () => "");
-    const statusText = state.lastError ? `\u5237\u65B0\u5931\u8D25\uFF1A${state.lastError}` : "\u7B49\u5F85\u540E\u53F0\u4EFB\u52A1\u542F\u52A8\u2026";
-    const status2 = truncateLine2(statusText, columns);
+    const statusText = state.lastError ? `\u5237\u65B0\u5931\u8D25\uFF1A${state.lastError}` : state.statusMessage ? state.statusIsError ? `\u64CD\u4F5C\u5931\u8D25\uFF1A${state.statusMessage}` : state.statusMessage : "\u7B49\u5F85\u540E\u53F0\u4EFB\u52A1\u542F\u52A8\u2026";
+    const status2 = truncateLine3(statusText, columns);
     const content2 = [header, ...filler, status2].join("\n");
     process.stdout.write(`\x1B[2J\x1B[H${content2}`);
     return;
   }
   const current = state.tasks[state.selectedIndex];
   const lines = current.lines;
-  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
-  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
   const stick = state.stickToBottom.get(current.key) ?? true;
   const nextOffset = Math.min(Math.max(stick ? maxOffset : offset, 0), maxOffset);
-  state.pageOffsets.set(current.key, nextOffset);
+  state.lineOffsets.set(current.key, nextOffset);
   state.stickToBottom.set(current.key, nextOffset === maxOffset);
-  const start = nextOffset * pageSize;
-  const pageLines = lines.slice(start, start + pageSize).map((line) => truncateLine2(line, columns));
+  const start = nextOffset;
+  const pageLines = lines.slice(start, start + pageSize).map((line) => truncateLine3(line, columns));
   while (pageLines.length < pageSize) {
     pageLines.push("");
   }
-  const status = buildStatus(
+  const totalPages = Math.max(1, Math.ceil(lines.length / pageSize));
+  const currentPage = Math.min(totalPages, Math.floor(nextOffset / pageSize) + 1);
+  const status = buildStatus2(
     current,
-    { current: nextOffset + 1, total: Math.max(1, maxOffset + 1) },
+    { current: currentPage, total: totalPages },
     columns,
-    state.lastError
+    state.lastError,
+    state.statusMessage,
+    state.statusIsError
   );
+  if (state.confirm) {
+    const dialogLines = buildConfirmDialogLines(state.confirm.key, columns);
+    applyDialogOverlay(pageLines, dialogLines);
+  }
   const content = [header, ...pageLines, status].join("\n");
   process.stdout.write(`\x1B[2J\x1B[H${content}`);
 }
@@ -2429,9 +3503,9 @@ function updateSelection(state, tasks) {
   }
   state.selectedKey = tasks[state.selectedIndex]?.key;
   const existing = new Set(tasks.map((task) => task.key));
-  for (const key of state.pageOffsets.keys()) {
+  for (const key of state.lineOffsets.keys()) {
     if (!existing.has(key)) {
-      state.pageOffsets.delete(key);
+      state.lineOffsets.delete(key);
     }
   }
   for (const key of state.stickToBottom.keys()) {
@@ -2439,6 +3513,9 @@ function updateSelection(state, tasks) {
       state.stickToBottom.delete(key);
     }
   }
+  if (state.confirm && !existing.has(state.confirm.key)) {
+    state.confirm = void 0;
+  }
 }
 function moveSelection(state, direction) {
   if (state.tasks.length === 0) return;
@@ -2446,24 +3523,92 @@ function moveSelection(state, direction) {
   state.selectedIndex = (state.selectedIndex + direction + total) % total;
   state.selectedKey = state.tasks[state.selectedIndex]?.key;
 }
-function movePage(state, direction) {
+function moveLine(state, direction) {
   if (state.tasks.length === 0) return;
-  const { rows } = getTerminalSize2();
-  const pageSize = getPageSize2(rows);
   const current = state.tasks[state.selectedIndex];
   const lines = current.lines;
-  const maxOffset = Math.max(0, Math.ceil(lines.length / pageSize) - 1);
-  const offset = state.pageOffsets.get(current.key) ?? maxOffset;
+  const { rows } = getTerminalSize3();
+  const pageSize = getPageSize3(rows);
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
   const nextOffset = Math.min(Math.max(offset + direction, 0), maxOffset);
-  state.pageOffsets.set(current.key, nextOffset);
+  state.lineOffsets.set(current.key, nextOffset);
   state.stickToBottom.set(current.key, nextOffset === maxOffset);
 }
-function shouldExit2(input) {
+function movePage(state, direction) {
+  if (state.tasks.length === 0) return;
+  const { rows } = getTerminalSize3();
+  const pageSize = getPageSize3(rows);
+  const current = state.tasks[state.selectedIndex];
+  const lines = current.lines;
+  const maxOffset = Math.max(0, lines.length - pageSize);
+  const offset = state.lineOffsets.get(current.key) ?? maxOffset;
+  const nextOffset = Math.min(Math.max(offset + direction * pageSize, 0), maxOffset);
+  state.lineOffsets.set(current.key, nextOffset);
+  state.stickToBottom.set(current.key, nextOffset === maxOffset);
+}
+async function terminateTask(task) {
+  const pid = typeof task.meta.pid === "number" ? task.meta.pid : void 0;
+  if (!pid || pid <= 0) {
+    return { message: "\u4EFB\u52A1\u672A\u8BB0\u5F55 PID\uFF0C\u65E0\u6CD5\u7EC8\u6B62", isError: true, removed: false };
+  }
+  const target = resolveTerminationTarget(pid);
+  try {
+    process.kill(target, "SIGTERM");
+  } catch (error) {
+    const err = error;
+    if (err?.code === "ESRCH") {
+      await safeRemoveRegistry(task.logFile);
+      return { message: `\u4EFB\u52A1 ${task.key} \u5DF2\u7ED3\u675F`, isError: false, removed: true };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { message: `\u53D1\u9001\u7EC8\u6B62\u4FE1\u53F7\u5931\u8D25\uFF1A${message}`, isError: true, removed: false };
+  }
+  await sleep(TERMINATE_GRACE_MS);
+  if (!isProcessAlive(pid)) {
+    await safeRemoveRegistry(task.logFile);
+    return { message: `\u4EFB\u52A1 ${task.key} \u5DF2\u7EC8\u6B62`, isError: false, removed: true };
+  }
+  return { message: `\u5DF2\u53D1\u9001\u7EC8\u6B62\u4FE1\u53F7\uFF0C\u4EFB\u52A1\u4ECD\u5728\u8FD0\u884C`, isError: false, removed: false };
+}
+async function terminateTaskByKey(state, key, refresh) {
+  const task = findTaskByKey(state, key);
+  if (!task) {
+    setStatus(state, `\u4EFB\u52A1 ${key} \u5DF2\u4E0D\u5B58\u5728`, true);
+    render3(state);
+    return;
+  }
+  const result = await terminateTask(task);
+  setStatus(state, result.message, result.isError);
+  if (result.removed) {
+    await refresh();
+    render3(state);
+    return;
+  }
+  render3(state);
+}
+function shouldExit3(input) {
   if (input === "") return true;
   if (input.toLowerCase() === "q") return true;
   return false;
 }
-function handleInput(state, input) {
+function handleInput(state, input, refresh) {
+  const lower = input.toLowerCase();
+  if (state.confirm) {
+    if (lower.includes("y")) {
+      const key = state.confirm.key;
+      state.confirm = void 0;
+      setStatus(state, `\u6B63\u5728\u7EC8\u6B62\u4EFB\u52A1 ${key}...`);
+      void terminateTaskByKey(state, key, refresh);
+      return;
+    }
+    if (lower.includes("n") || input === "\x1B") {
+      state.confirm = void 0;
+      setStatus(state, "\u5DF2\u53D6\u6D88\u7EC8\u6B62");
+      return;
+    }
+    return;
+  }
   if (input.includes("\x1B[D")) {
     moveSelection(state, -1);
     return;
@@ -2473,15 +3618,36 @@ function handleInput(state, input) {
     return;
   }
   if (input.includes("\x1B[A")) {
-    movePage(state, -1);
+    moveLine(state, -1);
     return;
   }
   if (input.includes("\x1B[B")) {
+    moveLine(state, 1);
+    return;
+  }
+  if (input.includes("\x1B[5~")) {
+    movePage(state, -1);
+    return;
+  }
+  if (input.includes("\x1B[6~")) {
     movePage(state, 1);
     return;
   }
+  if (lower.includes("t")) {
+    if (state.tasks.length === 0) {
+      setStatus(state, "\u6682\u65E0\u53EF\u7EC8\u6B62\u7684\u4EFB\u52A1", true);
+      return;
+    }
+    const current = state.tasks[state.selectedIndex];
+    if (typeof current.meta.pid !== "number" || current.meta.pid <= 0) {
+      setStatus(state, "\u4EFB\u52A1\u672A\u8BB0\u5F55 PID\uFF0C\u65E0\u6CD5\u7EC8\u6B62", true);
+      return;
+    }
+    state.confirm = { key: current.key };
+    setStatus(state, void 0);
+  }
 }
-function setupCleanup2(cleanup) {
+function setupCleanup3(cleanup) {
   const exitHandler = () => {
     cleanup();
   };
@@ -2502,7 +3668,7 @@ async function runMonitor() {
   const state = {
     tasks: [],
     selectedIndex: 0,
-    pageOffsets: /* @__PURE__ */ new Map(),
+    lineOffsets: /* @__PURE__ */ new Map(),
     stickToBottom: /* @__PURE__ */ new Map()
   };
   let cleaned = false;
@@ -2515,7 +3681,7 @@ async function runMonitor() {
     }
     process.stdout.write("\x1B[?25h");
   };
-  setupCleanup2(cleanup);
+  setupCleanup3(cleanup);
   process.stdout.write("\x1B[?25l");
   process.stdin.setRawMode(true);
   process.stdin.resume();
@@ -2527,11 +3693,11 @@ async function runMonitor() {
       const tasks = await loadTasks(logsDir);
       state.lastError = void 0;
       updateSelection(state, tasks);
-      render2(state);
+      render3(state);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       state.lastError = message;
-      render2(state);
+      render3(state);
     } finally {
       refreshing = false;
     }
@@ -2540,20 +3706,102 @@ async function runMonitor() {
   const timer = setInterval(refresh, REFRESH_INTERVAL);
   process.stdin.on("data", (data) => {
     const input = data.toString("utf8");
-    if (shouldExit2(input)) {
+    if (shouldExit3(input)) {
       clearInterval(timer);
       cleanup();
       process.exit(0);
     }
-    handleInput(state, input);
-    render2(state);
+    handleInput(state, input, refresh);
+    render3(state);
   });
   process.stdout.on("resize", () => {
-    render2(state);
+    render3(state);
   });
 }
 
+// src/log-tailer.ts
+var import_promises = require("fs/promises");
+var import_fs_extra11 = __toESM(require("fs-extra"));
+function normalizeChunk(chunk) {
+  return chunk.replace(/\r\n?/g, "\n");
+}
+async function tailLogFile(options) {
+  const intervalMs = options.pollIntervalMs ?? 200;
+  let offset = 0;
+  let buffer = "";
+  let reading = false;
+  let stopped = false;
+  if (options.startFromEnd) {
+    try {
+      const stat = await import_fs_extra11.default.stat(options.filePath);
+      offset = stat.size;
+    } catch {
+      offset = 0;
+    }
+  }
+  const flushBuffer = () => {
+    if (!buffer) return;
+    options.onLine(buffer);
+    buffer = "";
+  };
+  const emitChunk = (chunk) => {
+    buffer += normalizeChunk(chunk);
+    const parts = buffer.split("\n");
+    buffer = parts.pop() ?? "";
+    for (const line of parts) {
+      options.onLine(line);
+    }
+  };
+  const readNew = async () => {
+    if (reading || stopped) return;
+    reading = true;
+    try {
+      const stat = await import_fs_extra11.default.stat(options.filePath);
+      if (stat.size < offset) {
+        offset = stat.size;
+        buffer = "";
+      }
+      if (stat.size > offset) {
+        const length = stat.size - offset;
+        const handle = await (0, import_promises.open)(options.filePath, "r");
+        try {
+          const payload = Buffer.alloc(length);
+          const result = await handle.read(payload, 0, length, offset);
+          offset += result.bytesRead;
+          if (result.bytesRead > 0) {
+            const text = payload.subarray(0, result.bytesRead).toString("utf8");
+            emitChunk(text);
+          }
+        } finally {
+          await handle.close();
+        }
+      }
+    } catch (error) {
+      const err = error;
+      if (err?.code !== "ENOENT") {
+        const message = err instanceof Error ? err.message : String(err);
+        options.onError?.(message);
+      }
+    } finally {
+      reading = false;
+    }
+  };
+  const timer = setInterval(() => {
+    void readNew();
+  }, intervalMs);
+  await readNew();
+  return {
+    stop: async () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(timer);
+      flushBuffer();
+    }
+  };
+}
+
 // src/cli.ts
+var FOREGROUND_CHILD_ENV = "WHEEL_AI_FOREGROUND_CHILD";
 function parseInteger(value, defaultValue) {
   const parsed = Number.parseInt(value, 10);
   if (Number.isNaN(parsed)) return defaultValue;
@@ -2581,30 +3829,132 @@ function buildBackgroundArgs(argv, logFile, branchName, injectBranch = false) {
   }
   return filtered;
 }
+function extractAliasCommandArgs(argv, name) {
+  const args = argv.slice(2);
+  const start = args.findIndex((arg, index) => arg === "set" && args[index + 1] === "alias" && args[index + 2] === name);
+  if (start < 0) return [];
+  const rest = args.slice(start + 3);
+  if (rest[0] === "--") return rest.slice(1);
+  return rest;
+}
+async function runForegroundWithDetach(options) {
+  const args = buildBackgroundArgs(options.argv, options.logFile, options.branchName, options.injectBranch);
+  const child = (0, import_node_child_process.spawn)(process.execPath, [...process.execArgv, ...args], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      [FOREGROUND_CHILD_ENV]: "1"
+    }
+  });
+  child.unref();
+  const resolvedLogFile = resolvePath(process.cwd(), options.logFile);
+  const existed = await import_fs_extra12.default.pathExists(resolvedLogFile);
+  const tailer = await tailLogFile({
+    filePath: resolvedLogFile,
+    startFromEnd: existed,
+    onLine: (line) => {
+      process.stdout.write(`${line}
+`);
+    },
+    onError: (message) => {
+      defaultLogger.warn(`\u65E5\u5FD7\u8BFB\u53D6\u5931\u8D25\uFF1A${message}`);
+    }
+  });
+  const suffixNote = options.isMultiTask ? "\uFF08\u591A\u4EFB\u52A1\u5C06\u8FFD\u52A0\u5E8F\u53F7\uFF09" : "";
+  console.log(`\u5DF2\u8FDB\u5165\u524D\u53F0\u65E5\u5FD7\u67E5\u770B\uFF0C\u6309 Esc \u5207\u5230\u540E\u53F0\u8FD0\u884C\uFF0C\u65E5\u5FD7\u8F93\u51FA\u81F3 ${resolvedLogFile}${suffixNote}`);
+  let cleaned = false;
+  const cleanup = async () => {
+    if (cleaned) return;
+    cleaned = true;
+    await tailer.stop();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+  };
+  const detach = async () => {
+    await cleanup();
+    console.log(`\u5DF2\u5207\u5165\u540E\u53F0\u8FD0\u884C\uFF0C\u65E5\u5FD7\u8F93\u51FA\u81F3 ${resolvedLogFile}${suffixNote}`);
+    process.exit(0);
+  };
+  const terminate = async () => {
+    if (child.pid) {
+      try {
+        const target = resolveTerminationTarget(child.pid);
+        process.kill(target, "SIGTERM");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        defaultLogger.warn(`\u7EC8\u6B62\u5B50\u8FDB\u7A0B\u5931\u8D25\uFF1A${message}`);
+      }
+    }
+    await cleanup();
+    process.exit(0);
+  };
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      const input = data.toString("utf8");
+      if (input === "\x1B") {
+        void detach();
+        return;
+      }
+      if (input === "") {
+        void terminate();
+      }
+    });
+  }
+  process.on("SIGINT", () => {
+    void terminate();
+  });
+  process.on("SIGTERM", () => {
+    void terminate();
+  });
+  child.on("exit", async (code) => {
+    await cleanup();
+    process.exit(code ?? 0);
+  });
+}
 async function runCli(argv) {
   const globalConfig = await loadGlobalConfig(defaultLogger);
   const effectiveArgv = applyShortcutArgv(argv, globalConfig);
   const program = new import_commander.Command();
   program.name("wheel-ai").description("\u57FA\u4E8E AI CLI \u7684\u6301\u7EED\u8FED\u4EE3\u5F00\u53D1\u5DE5\u5177").version("1.0.0");
-  program.command("run").requiredOption("-t, --task <task>", "\u9700\u8981\u5B8C\u6210\u7684\u4EFB\u52A1\u63CF\u8FF0\uFF08\u4F1A\u8FDB\u5165 AI \u63D0\u793A\uFF09").option("-i, --iterations <number>", "\u6700\u5927\u8FED\u4EE3\u6B21\u6570", (value) => parseInteger(value, 5), 5).option("--ai-cli <command>", "AI CLI \u547D\u4EE4", "claude").option("--ai-args <args...>", "AI CLI \u53C2\u6570", []).option("--ai-prompt-arg <flag>", "\u7528\u4E8E\u4F20\u5165 prompt \u7684\u53C2\u6570\uFF08\u4E3A\u7A7A\u5219\u4F7F\u7528 stdin\uFF09").option("--notes-file <path>", "\u6301\u4E45\u5316\u8BB0\u5FC6\u6587\u4EF6", defaultNotesPath()).option("--plan-file <path>", "\u8BA1\u5212\u6587\u4EF6", defaultPlanPath()).option("--workflow-doc <path>", "AI \u5DE5\u4F5C\u6D41\u7A0B\u8BF4\u660E\u6587\u4EF6", defaultWorkflowDoc()).option("--worktree", "\u5728\u72EC\u7ACB worktree \u4E0A\u6267\u884C", false).option("--branch <name>", "worktree \u5206\u652F\u540D\uFF08\u9ED8\u8BA4\u81EA\u52A8\u751F\u6210\u6216\u5F53\u524D\u5206\u652F\uFF09").option("--worktree-path <path>", "worktree \u8DEF\u5F84\uFF0C\u9ED8\u8BA4 ../worktrees/<branch>").option("--base-branch <name>", "\u521B\u5EFA\u5206\u652F\u7684\u57FA\u7EBF\u5206\u652F", "main").option("--skip-install", "\u8DF3\u8FC7\u5F00\u59CB\u4EFB\u52A1\u524D\u7684\u4F9D\u8D56\u68C0\u67E5", false).option("--run-tests", "\u8FD0\u884C\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", false).option("--run-e2e", "\u8FD0\u884C e2e \u6D4B\u8BD5\u547D\u4EE4", false).option("--unit-command <cmd>", "\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", "yarn test").option("--e2e-command <cmd>", "e2e \u6D4B\u8BD5\u547D\u4EE4", "yarn e2e").option("--auto-commit", "\u81EA\u52A8 git commit", false).option("--auto-push", "\u81EA\u52A8 git push", false).option("--pr", "\u4F7F\u7528 gh \u521B\u5EFA PR", false).option("--pr-title <title>", "PR \u6807\u9898").option("--pr-body <path>", "PR \u63CF\u8FF0\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u7559\u7A7A\u81EA\u52A8\u751F\u6210\uFF09").option("--draft", "\u4EE5\u8349\u7A3F\u5F62\u5F0F\u521B\u5EFA PR", false).option("--reviewer <user...>", "PR reviewers", collect, []).option("--webhook <url>", "webhook \u901A\u77E5 URL\uFF08\u53EF\u91CD\u590D\uFF09", collect, []).option("--webhook-timeout <ms>", "webhook \u8BF7\u6C42\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09", (value) => parseInteger(value, 8e3)).option("--stop-signal <token>", "AI \u8F93\u51FA\u4E2D\u7684\u505C\u6B62\u6807\u8BB0", "<<DONE>>").option("--log-file <path>", "\u65E5\u5FD7\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").option("--background", "\u5207\u5165\u540E\u53F0\u8FD0\u884C", false).option("-v, --verbose", "\u8F93\u51FA\u8C03\u8BD5\u65E5\u5FD7", false).action(async (options) => {
+  program.command("run").option("-t, --task <task>", "\u9700\u8981\u5B8C\u6210\u7684\u4EFB\u52A1\u63CF\u8FF0\uFF08\u53EF\u91CD\u590D\u4F20\u5165\uFF0C\u72EC\u7ACB\u5904\u7406\uFF09", collect, []).option("-i, --iterations <number>", "\u6700\u5927\u8FED\u4EE3\u6B21\u6570", (value) => parseInteger(value, 5), 5).option("--ai-cli <command>", "AI CLI \u547D\u4EE4", "claude").option("--ai-args <args...>", "AI CLI \u53C2\u6570", []).option("--ai-prompt-arg <flag>", "\u7528\u4E8E\u4F20\u5165 prompt \u7684\u53C2\u6570\uFF08\u4E3A\u7A7A\u5219\u4F7F\u7528 stdin\uFF09").option("--notes-file <path>", "\u6301\u4E45\u5316\u8BB0\u5FC6\u6587\u4EF6", defaultNotesPath()).option("--plan-file <path>", "\u8BA1\u5212\u6587\u4EF6", defaultPlanPath()).option("--workflow-doc <path>", "AI \u5DE5\u4F5C\u6D41\u7A0B\u8BF4\u660E\u6587\u4EF6", defaultWorkflowDoc()).option("--worktree", "\u5728\u72EC\u7ACB worktree \u4E0A\u6267\u884C", false).option("--branch <name>", "worktree \u5206\u652F\u540D\uFF08\u9ED8\u8BA4\u81EA\u52A8\u751F\u6210\u6216\u5F53\u524D\u5206\u652F\uFF09").option("--worktree-path <path>", "worktree \u8DEF\u5F84\uFF0C\u9ED8\u8BA4 ../worktrees/<branch>").option("--base-branch <name>", "\u521B\u5EFA\u5206\u652F\u7684\u57FA\u7EBF\u5206\u652F", "main").option("--skip-install", "\u8DF3\u8FC7\u5F00\u59CB\u4EFB\u52A1\u524D\u7684\u4F9D\u8D56\u68C0\u67E5", false).option("--run-tests", "\u8FD0\u884C\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", false).option("--run-e2e", "\u8FD0\u884C e2e \u6D4B\u8BD5\u547D\u4EE4", false).option("--unit-command <cmd>", "\u5355\u5143\u6D4B\u8BD5\u547D\u4EE4", "yarn test").option("--e2e-command <cmd>", "e2e \u6D4B\u8BD5\u547D\u4EE4", "yarn e2e").option("--auto-commit", "\u81EA\u52A8 git commit", false).option("--auto-push", "\u81EA\u52A8 git push", false).option("--pr", "\u4F7F\u7528 gh \u521B\u5EFA PR", false).option("--pr-title <title>", "PR \u6807\u9898").option("--pr-body <path>", "PR \u63CF\u8FF0\u6587\u4EF6\u8DEF\u5F84\uFF08\u53EF\u7559\u7A7A\u81EA\u52A8\u751F\u6210\uFF09").option("--draft", "\u4EE5\u8349\u7A3F\u5F62\u5F0F\u521B\u5EFA PR", false).option("--reviewer <user...>", "PR reviewers", collect, []).option("--auto-merge", "PR \u68C0\u67E5\u901A\u8FC7\u540E\u81EA\u52A8\u5408\u5E76", false).option("--webhook <url>", "webhook \u901A\u77E5 URL\uFF08\u53EF\u91CD\u590D\uFF09", collect, []).option("--webhook-timeout <ms>", "webhook \u8BF7\u6C42\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09", (value) => parseInteger(value, 8e3)).option("--multi-task-mode <mode>", "\u591A\u4EFB\u52A1\u6267\u884C\u6A21\u5F0F\uFF08relay/serial/serial-continue/parallel\uFF0C\u6216\u4E2D\u6587\u63CF\u8FF0\uFF09", "relay").option("--stop-signal <token>", "AI \u8F93\u51FA\u4E2D\u7684\u505C\u6B62\u6807\u8BB0", "<<DONE>>").option("--log-file <path>", "\u65E5\u5FD7\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84").option("--background", "\u5207\u5165\u540E\u53F0\u8FD0\u884C", false).option("-v, --verbose", "\u8F93\u51FA\u8C03\u8BD5\u65E5\u5FD7", false).option("--skip-quality", "\u8DF3\u8FC7\u4EE3\u7801\u8D28\u91CF\u68C0\u67E5", false).action(async (options) => {
+    const tasks = normalizeTaskList(options.task);
+    if (tasks.length === 0) {
+      throw new Error("\u9700\u8981\u81F3\u5C11\u63D0\u4F9B\u4E00\u4E2A\u4EFB\u52A1\u63CF\u8FF0");
+    }
+    const multiTaskMode = parseMultiTaskMode(options.multiTaskMode);
     const useWorktree = Boolean(options.worktree);
+    if (multiTaskMode === "parallel" && !useWorktree) {
+      throw new Error("\u5E76\u884C\u6A21\u5F0F\u5FC5\u987B\u542F\u7528 --worktree");
+    }
     const branchInput = normalizeOptional(options.branch);
     const logFileInput = normalizeOptional(options.logFile);
+    const worktreePathInput = normalizeOptional(options.worktreePath);
     const background = Boolean(options.background);
-    let branchName = branchInput;
-    if (useWorktree && !branchName) {
-      branchName = generateBranchName();
-    }
+    const isMultiTask = tasks.length > 1;
+    const isForegroundChild = process.env[FOREGROUND_CHILD_ENV] === "1";
+    const canForegroundDetach = !background && !isForegroundChild && process.stdout.isTTY && process.stdin.isTTY;
+    const shouldInjectBranch = Boolean(useWorktree && branchInput && !isMultiTask);
+    const branchNameForBackground = branchInput;
     let logFile = logFileInput;
-    if (background && !logFile) {
-      let branchForLog = branchName;
-      if (!branchForLog) {
-        try {
-          const current = await getCurrentBranch(process.cwd(), defaultLogger);
-          branchForLog = current || "detached";
-        } catch {
-          branchForLog = "unknown";
+    if ((background || canForegroundDetach) && !logFile) {
+      let branchForLog = "multi-task";
+      if (!isMultiTask) {
+        branchForLog = branchNameForBackground ?? "";
+        if (!branchForLog) {
+          try {
+            const current = await getCurrentBranch(process.cwd(), defaultLogger);
+            branchForLog = current || "detached";
+          } catch {
+            branchForLog = "unknown";
+          }
         }
+      } else if (branchInput) {
+        branchForLog = `${branchInput}-multi`;
       }
       logFile = buildAutoLogFilePath(branchForLog);
     }
@@ -2612,18 +3962,40 @@ async function runCli(argv) {
       if (!logFile) {
         throw new Error("\u540E\u53F0\u8FD0\u884C\u9700\u8981\u6307\u5B9A\u65E5\u5FD7\u6587\u4EF6");
       }
-      const args = buildBackgroundArgs(effectiveArgv, logFile, branchName, useWorktree && !branchInput);
+      const args = buildBackgroundArgs(effectiveArgv, logFile, branchNameForBackground, shouldInjectBranch);
       const child = (0, import_node_child_process.spawn)(process.execPath, [...process.execArgv, ...args], {
         detached: true,
         stdio: "ignore"
       });
       child.unref();
       const displayLogFile = resolvePath(process.cwd(), logFile);
-      console.log(`\u5DF2\u5207\u5165\u540E\u53F0\u8FD0\u884C\uFF0C\u65E5\u5FD7\u8F93\u51FA\u81F3 ${displayLogFile}`);
+      const suffixNote = isMultiTask ? "\uFF08\u591A\u4EFB\u52A1\u5C06\u8FFD\u52A0\u5E8F\u53F7\uFF09" : "";
+      console.log(`\u5DF2\u5207\u5165\u540E\u53F0\u8FD0\u884C\uFF0C\u65E5\u5FD7\u8F93\u51FA\u81F3 ${displayLogFile}${suffixNote}`);
       return;
     }
-    const cliOptions = {
-      task: options.task,
+    if (canForegroundDetach) {
+      if (!logFile) {
+        throw new Error("\u5207\u5165\u540E\u53F0\u9700\u8981\u6307\u5B9A\u65E5\u5FD7\u6587\u4EF6");
+      }
+      await runForegroundWithDetach({
+        argv: effectiveArgv,
+        logFile,
+        branchName: branchNameForBackground,
+        injectBranch: shouldInjectBranch,
+        isMultiTask
+      });
+      return;
+    }
+    const taskPlans = buildTaskPlans({
+      tasks,
+      mode: multiTaskMode,
+      useWorktree,
+      baseBranch: options.baseBranch,
+      branchInput,
+      worktreePath: worktreePathInput,
+      logFile: logFileInput
+    });
+    const baseOptions = {
       iterations: options.iterations,
       aiCli: options.aiCli,
       aiArgs: options.aiArgs ?? [],
@@ -2632,9 +4004,6 @@ async function runCli(argv) {
       planFile: options.planFile,
       workflowDoc: options.workflowDoc,
       useWorktree,
-      branch: branchName,
-      worktreePath: options.worktreePath,
-      baseBranch: options.baseBranch,
       runTests: Boolean(options.runTests),
       runE2e: Boolean(options.runE2e),
       unitCommand: options.unitCommand,
@@ -2646,22 +4015,91 @@ async function runCli(argv) {
       prBody: options.prBody,
       draft: Boolean(options.draft),
       reviewers: options.reviewer ?? [],
+      autoMerge: Boolean(options.autoMerge),
       webhookUrls: options.webhook ?? [],
       webhookTimeout: options.webhookTimeout,
       stopSignal: options.stopSignal,
-      logFile,
       verbose: Boolean(options.verbose),
-      skipInstall: Boolean(options.skipInstall)
+      skipInstall: Boolean(options.skipInstall),
+      skipQuality: Boolean(options.skipQuality)
     };
-    const config = buildLoopConfig(cliOptions, process.cwd());
-    await runLoop(config);
+    const dynamicRelay = useWorktree && multiTaskMode === "relay" && !branchInput;
+    let relayBaseBranch = options.baseBranch;
+    const runPlan = async (plan, baseBranchOverride) => {
+      const cliOptions = {
+        task: plan.task,
+        ...baseOptions,
+        branch: plan.branchName,
+        worktreePath: plan.worktreePath,
+        baseBranch: baseBranchOverride ?? plan.baseBranch,
+        logFile: plan.logFile
+      };
+      const config = buildLoopConfig(cliOptions, process.cwd());
+      return runLoop(config);
+    };
+    if (multiTaskMode === "parallel") {
+      const results = await Promise.allSettled(taskPlans.map((plan) => runPlan(plan)));
+      const errors = results.flatMap((result, index) => {
+        if (result.status === "fulfilled") return [];
+        const reason = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        return [`\u4EFB\u52A1 ${index + 1} \u5931\u8D25: ${reason}`];
+      });
+      if (errors.length > 0) {
+        errors.forEach((message) => defaultLogger.warn(message));
+        throw new Error(errors.join("\n"));
+      }
+      return;
+    }
+    if (multiTaskMode === "serial-continue") {
+      const errors = [];
+      for (const plan of taskPlans) {
+        try {
+          const baseBranch = dynamicRelay ? relayBaseBranch : plan.baseBranch;
+          const result = await runPlan(plan, baseBranch);
+          if (dynamicRelay && result.branchName) {
+            relayBaseBranch = result.branchName;
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          errors.push(`\u4EFB\u52A1 ${plan.index + 1} \u5931\u8D25: ${message}`);
+          defaultLogger.warn(`\u4EFB\u52A1 ${plan.index + 1} \u6267\u884C\u5931\u8D25\uFF0C\u7EE7\u7EED\u4E0B\u4E00\u4EFB\u52A1\uFF1A${message}`);
+        }
+      }
+      if (errors.length > 0) {
+        throw new Error(errors.join("\n"));
+      }
+      return;
+    }
+    for (const plan of taskPlans) {
+      const baseBranch = dynamicRelay ? relayBaseBranch : plan.baseBranch;
+      const result = await runPlan(plan, baseBranch);
+      if (dynamicRelay && result.branchName) {
+        relayBaseBranch = result.branchName;
+      }
+    }
   });
-  program.command("monitor").description("\u67E5\u770B\u540E\u53F0\u8FD0\u884C\u65E5\u5FD7").action(async () => {
+  program.command("monitor").description("\u67E5\u770B\u540E\u53F0\u8FD0\u884C\u65E5\u5FD7\uFF08t \u7EC8\u6B62\u4EFB\u52A1\uFF09").action(async () => {
     await runMonitor();
   });
   program.command("logs").description("\u67E5\u770B\u5386\u53F2\u65E5\u5FD7").action(async () => {
     await runLogsViewer();
   });
+  program.command("set").description("\u5199\u5165\u5168\u5C40\u914D\u7F6E").command("alias <name> [options...]").description("\u8BBE\u7F6E alias").allowUnknownOption(true).action(async (name) => {
+    const normalized = normalizeAliasName(name);
+    if (!normalized) {
+      throw new Error("alias \u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A\u4E14\u4E0D\u80FD\u5305\u542B\u7A7A\u767D\u5B57\u7B26");
+    }
+    const commandArgs = extractAliasCommandArgs(effectiveArgv, name);
+    const commandLine = formatCommandLine(commandArgs);
+    if (!commandLine) {
+      throw new Error("alias \u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    await upsertAliasEntry(normalized, commandLine);
+    console.log(`\u5DF2\u5199\u5165 alias\uFF1A${normalized}`);
+  });
+  program.command("alias").alias("aliases").description("\u6D4F\u89C8\u5168\u5C40 alias \u914D\u7F6E").action(async () => {
+    await runAliasViewer();
+  });
   await program.parseAsync(effectiveArgv);
 }
 if (require.main === module) {