@xdevops/issue-auto-finish 1.0.0

package/dist/chunk-TBIEB3JY.js

@@ -0,0 +1,3295 @@
+import {
+  t
+} from "./chunk-OWVT3Z34.js";
+
+// src/config.ts
+import { config as loadDotenv } from "dotenv";
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function resolveEnvPath() {
+  if (process.env.IAF_CONFIG_PATH) return process.env.IAF_CONFIG_PATH;
+  const localEnv = path.resolve(__dirname, "../.env");
+  if (fs.existsSync(localEnv)) return localEnv;
+  const cwdEnv = path.resolve(process.cwd(), ".env");
+  if (fs.existsSync(cwdEnv)) return cwdEnv;
+  const globalEnv = path.join(os.homedir(), ".issue-auto-finish", ".env");
+  if (fs.existsSync(globalEnv)) return globalEnv;
+  return localEnv;
+}
+var _dotenvLoaded = false;
+function ensureDotenvLoaded() {
+  if (_dotenvLoaded) return;
+  _dotenvLoaded = true;
+  loadDotenv({ path: resolveEnvPath() });
+}
+var DEFAULT_AI_MODEL = "Claude-4.6-Opus";
+function requireEnv(key) {
+  const val = process.env[key];
+  if (!val) {
+    throw new Error(`Missing required environment variable: ${key}`);
+  }
+  return val;
+}
+function optionalEnv(key, defaultValue) {
+  return process.env[key] || defaultValue;
+}
+function loadConfig() {
+  ensureDotenvLoaded();
+  return {
+    gongfeng: {
+      apiUrl: requireEnv("GONGFENG_API_URL"),
+      privateToken: requireEnv("GONGFENG_PRIVATE_TOKEN"),
+      projectPath: requireEnv("GONGFENG_PROJECT_PATH")
+    },
+    project: {
+      workDir: requireEnv("PROJECT_WORK_DIR"),
+      gitRootDir: optionalEnv("GIT_ROOT_DIR", requireEnv("PROJECT_WORK_DIR")),
+      baseBranch: optionalEnv("BASE_BRANCH", "master"),
+      branchPrefix: optionalEnv("BRANCH_PREFIX", "feat/issue"),
+      worktreeBaseDir: optionalEnv("WORKTREE_BASE_DIR", ""),
+      projectSubDir: optionalEnv("PROJECT_SUBDIR", "")
+    },
+    claude: {
+      binary: optionalEnv("CLAUDE_BINARY", "claude-internal"),
+      phaseTimeoutMs: parseInt(optionalEnv("CLAUDE_PHASE_TIMEOUT_MS", "1800000"), 10),
+      nvmNodeVersion: optionalEnv("NVM_NODE_VERSION", "20")
+    },
+    ai: buildAIConfig(),
+    poll: {
+      intervalMs: parseInt(optionalEnv("POLL_INTERVAL_MS", "60000"), 10),
+      discoveryIntervalMs: parseInt(
+        optionalEnv("POLL_DISCOVERY_INTERVAL_MS", optionalEnv("POLL_INTERVAL_MS", "60000")),
+        10
+      ),
+      driveIntervalMs: parseInt(optionalEnv("POLL_DRIVE_INTERVAL_MS", "15000"), 10),
+      maxRetries: parseInt(optionalEnv("MAX_RETRIES", "3"), 10),
+      maxConcurrent: parseInt(optionalEnv("MAX_CONCURRENT_ISSUES", "3"), 10)
+    },
+    pipeline: {
+      mode: optionalEnv("PIPELINE_MODE", "auto")
+    },
+    review: {
+      enabled: optionalEnv("REVIEW_ENABLED", "true") === "true",
+      autoApproveLabels: optionalEnv("REVIEW_AUTO_APPROVE_LABELS", "").split(",").map((s) => s.trim()).filter(Boolean)
+    },
+    web: {
+      enabled: optionalEnv("WEB_ENABLED", "true") === "true",
+      port: parseInt(optionalEnv("WEB_PORT", "3000"), 10),
+      frontendDistDir: optionalEnv(
+        "FRONTEND_DIST_DIR",
+        path.resolve(process.cwd(), "src/web/frontend/dist")
+      )
+    },
+    issueNoteSync: {
+      enabled: optionalEnv("ISSUE_NOTE_SYNC_ENABLED", "true") === "true",
+      webBaseUrl: optionalEnv(
+        "WEB_BASE_URL",
+        `http://localhost:${optionalEnv("WEB_PORT", "3000")}`
+      )
+    },
+    webhook: {
+      enabled: optionalEnv("WEBHOOK_ENABLED", "false") === "true",
+      port: parseInt(optionalEnv("WEBHOOK_PORT", "8081"), 10),
+      secret: optionalEnv("WEBHOOK_SECRET", ""),
+      llmFallback: optionalEnv("WEBHOOK_LLM_FALLBACK", "true") === "true",
+      llmBinary: optionalEnv("WEBHOOK_LLM_BINARY", "claude-internal")
+    },
+    e2e: {
+      enabled: optionalEnv("E2E_UI_ENABLED", "false") === "true",
+      baseUrl: optionalEnv("E2E_BASE_URL", "https://localhost:8890"),
+      backendUrl: optionalEnv("E2E_BACKEND_URL", "http://127.0.0.1:3000"),
+      authCookies: optionalEnv("E2E_AUTH_COOKIES", "[]"),
+      backendPortBase: parseInt(optionalEnv("E2E_BACKEND_PORT_BASE", "4000"), 10),
+      frontendPortBase: parseInt(optionalEnv("E2E_FRONTEND_PORT_BASE", "9000"), 10)
+    },
+    preview: {
+      enabled: optionalEnv("PREVIEW_ENABLED", "false") === "true",
+      host: optionalEnv("PREVIEW_HOST", ""),
+      ttlMs: parseInt(optionalEnv("PREVIEW_TTL_MS", String(24 * 60 * 60 * 1e3)), 10),
+      keepAfterComplete: optionalEnv("PREVIEW_KEEP_AFTER_COMPLETE", "true") === "true"
+    },
+    brainstorm: {
+      enabled: optionalEnv("BRAINSTORM_ENABLED", "true") === "true",
+      maxRefinementRounds: parseInt(optionalEnv("BRAINSTORM_MAX_ROUNDS", "5"), 10),
+      timeoutMs: parseInt(optionalEnv("BRAINSTORM_TIMEOUT_MS", "600000"), 10),
+      generator: buildBrainstormAgentConfig("GENERATOR"),
+      reviewer: buildBrainstormAgentConfig("REVIEWER")
+    },
+    locale: optionalEnv("LOCALE", "zh-CN") === "en" ? "en" : "zh-CN"
+  };
+}
+function resolveAIRunnerMode(raw) {
+  if (raw === "cursor-agent") return "cursor-agent";
+  if (raw === "codebuddy") return "codebuddy";
+  return "claude-internal";
+}
+function resolveAIBinary(mode) {
+  switch (mode) {
+    case "cursor-agent":
+      return optionalEnv("CURSOR_BINARY", "cursor");
+    case "codebuddy":
+      return optionalEnv("CODEBUDDY_BINARY", "codebuddy");
+    default:
+      return optionalEnv("CLAUDE_BINARY", "claude-internal");
+  }
+}
+function buildAIConfig() {
+  const mode = resolveAIRunnerMode(optionalEnv("AI_RUNNER_MODE", "claude-internal"));
+  return {
+    mode,
+    binary: resolveAIBinary(mode),
+    phaseTimeoutMs: parseInt(optionalEnv("CLAUDE_PHASE_TIMEOUT_MS", "1800000"), 10),
+    nvmNodeVersion: optionalEnv("NVM_NODE_VERSION", "20"),
+    model: optionalEnv("AI_MODEL", DEFAULT_AI_MODEL)
+  };
+}
+function buildBrainstormAgentConfig(role) {
+  const globalMode = optionalEnv("AI_RUNNER_MODE", "claude-internal");
+  const roleMode = optionalEnv(`BRAINSTORM_${role}_MODE`, globalMode);
+  const mode = resolveAIRunnerMode(roleMode);
+  return {
+    mode,
+    binary: optionalEnv(`BRAINSTORM_${role}_BINARY`, resolveAIBinary(mode)),
+    nvmNodeVersion: optionalEnv("NVM_NODE_VERSION", "20"),
+    model: process.env[`BRAINSTORM_${role}_MODEL`] || optionalEnv("AI_MODEL", DEFAULT_AI_MODEL)
+  };
+}
+
+// src/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class _Logger {
+  level = "info";
+  context;
+  constructor(context) {
+    this.context = context;
+    const envLevel = process.env.LOG_LEVEL;
+    if (envLevel && envLevel in LOG_LEVELS) {
+      this.level = envLevel;
+    }
+  }
+  child(context) {
+    const child = new _Logger(this.context ? `${this.context}:${context}` : context);
+    child.level = this.level;
+    return child;
+  }
+  format(level, message, meta) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = this.context ? `[${this.context}]` : "";
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `${ts} ${level.toUpperCase().padEnd(5)} ${prefix} ${message}${metaStr}`;
+  }
+  log(level, message, meta) {
+    if (LOG_LEVELS[level] < LOG_LEVELS[this.level]) return;
+    const line = this.format(level, message, meta);
+    if (level === "error") {
+      console.error(line);
+    } else if (level === "warn") {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+};
+var logger = new Logger();
+
+// src/clients/GongfengClient.ts
+import fs2 from "fs";
+import path2 from "path";
+var logger2 = logger.child("GongfengClient");
+var AGENT_NOTE_MARKER = "\n\n<!-- issue-auto-finish-agent -->";
+var AGENT_NOTE_MARKER_PATTERN = "<!-- issue-auto-finish-agent -->";
+var GongfengClient = class {
+  apiUrl;
+  token;
+  projectPath;
+  constructor(config) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.token = config.privateToken;
+    this.projectPath = config.projectPath;
+  }
+  get projectApiBase() {
+    const encoded = encodeURIComponent(this.projectPath);
+    return `${this.apiUrl}/api/v3/projects/${encoded}`;
+  }
+  async requestRaw(path11, options = {}) {
+    const url = `${this.projectApiBase}${path11}`;
+    logger2.debug("API request", { method: options.method || "GET", url });
+    const resp = await fetch(url, {
+      ...options,
+      headers: {
+        "PRIVATE-TOKEN": this.token,
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+    if (!resp.ok) {
+      const body = await resp.text();
+      throw new Error(`Gongfeng API error ${resp.status}: ${body}`);
+    }
+    return resp;
+  }
+  async request(path11, options = {}) {
+    const resp = await this.requestRaw(path11, options);
+    return resp.json();
+  }
+  async createIssue(title, description, labels) {
+    const body = { title, description };
+    if (labels && labels.length > 0) {
+      body.labels = labels.join(",");
+    }
+    const issue = await this.request("/issues", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    logger2.info("Issue created", { id: issue.id, iid: issue.iid, title });
+    return issue;
+  }
+  async listIssues(state = "opened", labels) {
+    const params = new URLSearchParams({ state, per_page: "100" });
+    if (labels) {
+      params.set("labels", labels);
+    }
+    return this.request(`/issues?${params.toString()}`);
+  }
+  async listIssuesAdvanced(options = {}) {
+    const params = new URLSearchParams({
+      state: options.state || "opened",
+      page: String(options.page || 1),
+      per_page: String(options.perPage || 20)
+    });
+    if (options.labels) {
+      params.set("labels", options.labels);
+    }
+    if (options.search) {
+      params.set("search", options.search);
+    }
+    const resp = await this.requestRaw(`/issues?${params.toString()}`);
+    const total = parseInt(resp.headers.get("x-total") || "0", 10);
+    const issues = await resp.json();
+    return { issues, total: total || issues.length };
+  }
+  async getIssueDetail(issueId) {
+    return this.request(`/issues/${issueId}`);
+  }
+  async createIssueNote(issueId, body) {
+    const markedBody = body + AGENT_NOTE_MARKER;
+    await this.request(`/issues/${issueId}/notes`, {
+      method: "POST",
+      body: JSON.stringify({ body: markedBody })
+    });
+    logger2.info("Issue note created", { issueId });
+  }
+  async updateIssueLabels(issueId, labels) {
+    await this.request(`/issues/${issueId}`, {
+      method: "PUT",
+      body: JSON.stringify({ labels: labels.join(",") })
+    });
+    logger2.info("Issue labels updated", { issueId, labels });
+  }
+  async createMergeRequest(options) {
+    const mr = await this.request("/merge_requests", {
+      method: "POST",
+      body: JSON.stringify({
+        source_branch: options.sourceBranch,
+        target_branch: options.targetBranch,
+        title: options.title,
+        description: options.description ?? ""
+      })
+    });
+    if (!mr.web_url && mr.iid) {
+      mr.web_url = this.buildMergeRequestUrl(mr.iid);
+    }
+    logger2.info("Merge request created", { iid: mr.iid, webUrl: mr.web_url });
+    return mr;
+  }
+  async findMergeRequestByBranch(sourceBranch, targetBranch, state = "opened") {
+    const params = new URLSearchParams({
+      state,
+      source_branch: sourceBranch,
+      target_branch: targetBranch
+    });
+    const mrs = await this.request(
+      `/merge_requests?${params.toString()}`
+    );
+    if (mrs.length === 0) return null;
+    const mr = mrs[0];
+    if (!mr.web_url && mr.iid) {
+      mr.web_url = this.buildMergeRequestUrl(mr.iid);
+    }
+    return mr;
+  }
+  buildMergeRequestUrl(mrIid) {
+    return `${this.apiUrl}/${this.projectPath}/merge_requests/${mrIid}`;
+  }
+  async uploadFile(filePath) {
+    const fileData = fs2.readFileSync(filePath);
+    const fileName = path2.basename(filePath);
+    const mimeType = fileName.endsWith(".png") ? "image/png" : "application/octet-stream";
+    const blob = new Blob([fileData], { type: mimeType });
+    const formData = new FormData();
+    formData.append("file", blob, fileName);
+    const url = `${this.projectApiBase}/uploads`;
+    logger2.debug("Upload request", { url, fileName });
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: { "PRIVATE-TOKEN": this.token },
+      body: formData
+    });
+    if (!resp.ok) {
+      const body = await resp.text();
+      throw new Error(`Gongfeng upload error ${resp.status}: ${body}`);
+    }
+    const result = await resp.json();
+    logger2.info("File uploaded", { fileName, url: result.url });
+    return result;
+  }
+  async createMergeRequestNote(mrIid, body) {
+    const markedBody = body + AGENT_NOTE_MARKER;
+    await this.request(`/merge_requests/${mrIid}/notes`, {
+      method: "POST",
+      body: JSON.stringify({ body: markedBody })
+    });
+    logger2.info("Merge request note created", { mrIid });
+  }
+  async closeMergeRequest(mrIid) {
+    await this.request(`/merge_requests/${mrIid}`, {
+      method: "PUT",
+      body: JSON.stringify({ state_event: "close" })
+    });
+    logger2.info("Merge request closed", { mrIid });
+  }
+  async deleteIssue(issueId) {
+    await this.request(`/issues/${issueId}`, { method: "DELETE" });
+    logger2.info("Issue deleted", { issueId });
+  }
+  async closeIssue(issueId) {
+    await this.request(`/issues/${issueId}`, {
+      method: "PUT",
+      body: JSON.stringify({ state_event: "close", labels: "auto-finish:e2e-cleaned" })
+    });
+    logger2.info("Issue closed", { issueId });
+  }
+  async listIssueNotes(issueId) {
+    const allNotes = [];
+    let page = 1;
+    while (true) {
+      const params = new URLSearchParams({ per_page: "100", page: String(page) });
+      const batch = await this.request(
+        `/issues/${issueId}/notes?${params.toString()}`
+      );
+      allNotes.push(...batch);
+      if (batch.length < 100) break;
+      page++;
+    }
+    return allNotes;
+  }
+  async deleteIssueNote(issueId, noteId) {
+    await this.request(`/issues/${issueId}/notes/${noteId}`, { method: "DELETE" });
+    logger2.debug("Issue note deleted", { issueId, noteId });
+  }
+  async cleanupAgentNotes(issueId) {
+    const notes = await this.listIssueNotes(issueId);
+    const agentNotes = notes.filter((n) => n.body.includes(AGENT_NOTE_MARKER_PATTERN));
+    for (const note of agentNotes) {
+      await this.deleteIssueNote(issueId, note.id);
+    }
+    if (agentNotes.length > 0) {
+      logger2.info("Agent notes cleaned up", { issueId, deleted: agentNotes.length });
+    }
+    return agentNotes.length;
+  }
+  async addLabel(issueId, label) {
+    const issue = await this.getIssueDetail(issueId);
+    if (issue.labels.includes(label)) {
+      logger2.info("Label already exists, skipping", { issueId, label });
+      return;
+    }
+    const newLabels = [...issue.labels, label];
+    await this.updateIssueLabels(issueId, newLabels);
+  }
+};
+
+// src/git/GitOperations.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var logger3 = logger.child("GitOperations");
+var GitOperations = class {
+  workDir;
+  constructor(workDir) {
+    this.workDir = workDir;
+  }
+  async exec(args) {
+    logger3.debug("git exec", { args });
+    const { stdout } = await execFileAsync("git", args, {
+      cwd: this.workDir,
+      maxBuffer: 10 * 1024 * 1024,
+      env: { ...process.env, HUSKY: "0" }
+    });
+    return stdout.trim();
+  }
+  async fetchAndPull(branch) {
+    await this.exec(["fetch", "origin"]);
+    await this.exec(["checkout", "-f", branch]);
+    await this.exec(["pull", "origin", branch]);
+    logger3.info("Fetched and pulled", { branch });
+  }
+  async fetch() {
+    await this.exec(["fetch", "origin"]);
+    logger3.info("Fetched from origin");
+  }
+  async createBranch(name, from) {
+    await this.exec(["checkout", "-f", "-b", name, `origin/${from}`]);
+    logger3.info("Branch created", { name, from: `origin/${from}` });
+  }
+  async checkout(branch) {
+    await this.exec(["checkout", "-f", branch]);
+    logger3.info("Checked out", { branch });
+  }
+  async add(files) {
+    await this.exec(["add", ...files]);
+  }
+  async commit(message) {
+    await this.exec(["commit", "--no-verify", "-m", message]);
+    logger3.info("Committed", { message: message.slice(0, 80) });
+  }
+  async push(branch) {
+    await this.exec(["push", "--no-verify", "-u", "origin", branch]);
+    logger3.info("Pushed", { branch });
+  }
+  async branchExists(name) {
+    try {
+      await this.exec(["rev-parse", "--verify", name]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async remoteBranchExists(name) {
+    try {
+      await this.exec(["ls-remote", "--exit-code", "--heads", "origin", name]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getCurrentBranch() {
+    return this.exec(["rev-parse", "--abbrev-ref", "HEAD"]);
+  }
+  async stash() {
+    await this.exec(["stash"]);
+  }
+  async stashPop() {
+    await this.exec(["stash", "pop"]);
+  }
+  async hasChanges() {
+    const status = await this.exec(["status", "--porcelain"]);
+    return status.length > 0;
+  }
+  async addAndCommit(files, message) {
+    await this.add(files);
+    await this.commit(message);
+  }
+  async checkoutTrack(remoteBranch) {
+    await this.exec(["checkout", "-f", "--track", `origin/${remoteBranch}`]);
+    logger3.info("Checked out remote tracking branch", { remoteBranch });
+  }
+  async addCommitAndPush(files, message, branch) {
+    await this.add(files);
+    await this.commit(message);
+    await this.push(branch);
+  }
+  async deleteBranch(name) {
+    await this.exec(["branch", "-D", name]);
+    logger3.info("Branch deleted", { name });
+  }
+  async deleteRemoteBranch(name) {
+    await this.exec(["push", "origin", "--delete", name]);
+    logger3.info("Remote branch deleted", { name });
+  }
+  async worktreeAdd(dir, newBranch, startPoint) {
+    await this.exec(["worktree", "add", "-b", newBranch, dir, startPoint]);
+    logger3.info("Worktree added (new branch)", { dir, newBranch, startPoint });
+  }
+  async worktreeAddExisting(dir, branch) {
+    await this.exec(["worktree", "add", dir, branch]);
+    logger3.info("Worktree added (existing branch)", { dir, branch });
+  }
+  async worktreeAddTracking(dir, remoteBranch) {
+    await this.exec(["worktree", "add", "--track", "-b", remoteBranch, dir, `origin/${remoteBranch}`]);
+    logger3.info("Worktree added (tracking remote)", { dir, remoteBranch });
+  }
+  async worktreeRemove(dir, force = false) {
+    const args = ["worktree", "remove", dir];
+    if (force) args.push("--force");
+    await this.exec(args);
+    logger3.info("Worktree removed", { dir, force });
+  }
+  async worktreeList() {
+    const output = await this.exec(["worktree", "list", "--porcelain"]);
+    return output.split("\n").filter((line) => line.startsWith("worktree ")).map((line) => line.replace("worktree ", ""));
+  }
+  async showFile(ref, filePath) {
+    try {
+      return await this.exec(["show", `${ref}:${filePath}`]);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/ai-runner/BaseAIRunner.ts
+import { spawn } from "child_process";
+var logger4 = logger.child("AIRunner");
+var BaseAIRunner = class {
+  async run(options) {
+    const { prompt, workDir, timeoutMs, sessionId, continueSession, onStreamEvent } = options;
+    logger4.info("Running AI runner", {
+      workDir,
+      timeoutMs,
+      continueSession: !!continueSession,
+      sessionId
+    });
+    return new Promise((resolve) => {
+      const chunks = [];
+      const stderrChunks = [];
+      let timedOut = false;
+      let lineBuffer = "";
+      const binary = this.getBinary();
+      const args = this.buildArgs(options);
+      const spawnOpts = this.getSpawnOptions(options);
+      const child = spawn(binary, args, {
+        ...spawnOpts,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const timer = setTimeout(() => {
+        timedOut = true;
+        child.kill("SIGTERM");
+        logger4.warn("AI runner timed out", { timeoutMs });
+      }, timeoutMs);
+      const flushInterval = onStreamEvent ? setInterval(() => {
+        if (lineBuffer.trim()) {
+          onStreamEvent({ type: "partial", content: lineBuffer.trim(), timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        }
+      }, 3e3) : void 0;
+      child.stdout.on("data", (chunk) => {
+        chunks.push(chunk);
+        if (onStreamEvent) {
+          lineBuffer += chunk.toString();
+          let newlineIdx;
+          while ((newlineIdx = lineBuffer.indexOf("\n")) !== -1) {
+            const line = lineBuffer.slice(0, newlineIdx).trim();
+            lineBuffer = lineBuffer.slice(newlineIdx + 1);
+            if (!line) continue;
+            this.emitStreamLine(line, onStreamEvent);
+          }
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderrChunks.push(chunk);
+        const text = chunk.toString();
+        logger4.debug("AI runner stderr: " + text);
+        if (onStreamEvent) {
+          onStreamEvent({ type: "stderr", content: text, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        }
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (flushInterval) clearInterval(flushInterval);
+        if (onStreamEvent && lineBuffer.trim()) {
+          this.emitStreamLine(lineBuffer.trim(), onStreamEvent);
+        }
+        const rawOutput = Buffer.concat(chunks).toString("utf-8");
+        const { output, resolvedSessionId } = this.parseOutput(rawOutput, sessionId);
+        const success = code === 0 && !timedOut;
+        logger4.info("AI runner finished", { exitCode: code, success, timedOut });
+        const stderrText = stderrChunks.length > 0 ? Buffer.concat(stderrChunks).toString("utf-8").trim() : "";
+        const finalOutput = !success && !output.trim() && stderrText ? stderrText : output;
+        resolve({
+          success,
+          output: finalOutput,
+          sessionId: resolvedSessionId ?? sessionId,
+          exitCode: code
+        });
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        if (flushInterval) clearInterval(flushInterval);
+        logger4.error("AI runner spawn error", { error: err.message });
+        resolve({
+          success: false,
+          output: err.message,
+          exitCode: null
+        });
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
+  }
+  emitStreamLine(line, onStreamEvent) {
+    try {
+      const parsed = JSON.parse(line);
+      onStreamEvent({
+        type: typeof parsed.type === "string" ? parsed.type : "raw",
+        content: parsed,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } catch {
+      onStreamEvent({ type: "raw", content: line, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  }
+  /**
+   * Handles both stream-json (one JSON object per line) and legacy single-JSON formats.
+   */
+  parseOutput(rawOutput, _sessionId) {
+    let output = rawOutput;
+    let resolvedSessionId;
+    const events = this.tryParseStreamJson(rawOutput);
+    if (events) {
+      output = events.filter((item) => item.type === "result").map((item) => item.result ?? "").join("\n");
+      const sessionItem = events.find(
+        (item) => item.session_id != null
+      );
+      if (sessionItem) {
+        resolvedSessionId = sessionItem.session_id;
+      }
+      if (!output) {
+        output = this.summarizeStreamEvents(events);
+      }
+      return { output, resolvedSessionId };
+    }
+    try {
+      const parsed = JSON.parse(rawOutput);
+      if (Array.isArray(parsed)) {
+        output = parsed.filter((item) => item.type === "result").map((item) => item.result ?? "").join("\n");
+        const sessionItem = parsed.find(
+          (item) => item.session_id != null
+        );
+        if (sessionItem) {
+          resolvedSessionId = sessionItem.session_id;
+        }
+      } else if (parsed.result != null) {
+        output = parsed.result;
+        resolvedSessionId = parsed.session_id;
+      }
+    } catch {
+    }
+    return { output, resolvedSessionId };
+  }
+  summarizeStreamEvents(events) {
+    const errorEvents = events.filter(
+      (e) => e.type === "error" || e.subtype === "error"
+    );
+    if (errorEvents.length > 0) {
+      const messages = errorEvents.map(
+        (e) => String(e.message ?? e.error ?? JSON.stringify(e))
+      );
+      return `AI runner \u9519\u8BEF: ${messages.join("; ")}`;
+    }
+    const types = events.map((e) => String(e.type ?? "unknown"));
+    const typeCounts = {};
+    for (const t2 of types) {
+      typeCounts[t2] = (typeCounts[t2] ?? 0) + 1;
+    }
+    const summary = Object.entries(typeCounts).map(([t2, c]) => `${t2}(${c})`).join(", ");
+    return `AI runner \u672A\u8FD4\u56DE\u7ED3\u679C (\u6536\u5230 ${events.length} \u4E2A\u4E8B\u4EF6: ${summary})`;
+  }
+  tryParseStreamJson(raw) {
+    const lines = raw.split("\n").filter((l) => l.trim());
+    if (lines.length < 2) return null;
+    const objects = [];
+    for (const line of lines) {
+      try {
+        objects.push(JSON.parse(line));
+      } catch {
+        return null;
+      }
+    }
+    return objects;
+  }
+};
+
+// src/ai-runner/ClaudeInternalRunner.ts
+var ClaudeInternalRunner = class extends BaseAIRunner {
+  binary;
+  nvmNodeVersion;
+  model;
+  constructor(binary, nvmNodeVersion, model) {
+    super();
+    this.binary = binary;
+    this.nvmNodeVersion = nvmNodeVersion;
+    this.model = model;
+  }
+  getBinary() {
+    return this.binary;
+  }
+  buildArgs(options) {
+    const args = ["-p", "-", "--output-format", "stream-json", "--verbose"];
+    if (options.mode === "plan") {
+      args.push("--permission-mode", "plan", "--allowedTools", "Read,Grep,Glob,WebSearch");
+    } else {
+      args.push("--dangerously-skip-permissions");
+    }
+    if (this.model) {
+      args.push("--model", this.model);
+    }
+    if (options.continueSession && options.sessionId) {
+      args.push("--resume", options.sessionId);
+    }
+    return args;
+  }
+  getSpawnOptions(options) {
+    const { CLAUDECODE, ...env } = process.env;
+    return {
+      cwd: options.workDir,
+      env: {
+        ...env,
+        NODE_VERSION: this.nvmNodeVersion
+      }
+    };
+  }
+};
+
+// src/ai-runner/CodebuddyRunner.ts
+var CodebuddyRunner = class extends BaseAIRunner {
+  binary;
+  nvmNodeVersion;
+  model;
+  constructor(binary, nvmNodeVersion, model) {
+    super();
+    this.binary = binary;
+    this.nvmNodeVersion = nvmNodeVersion;
+    this.model = model;
+  }
+  getBinary() {
+    return this.binary;
+  }
+  buildArgs(options) {
+    const args = ["-p", "--output-format", "stream-json", "--verbose"];
+    if (options.mode === "plan") {
+      args.push("--permission-mode", "plan", "--allowedTools", "Read,Grep,Glob,WebSearch");
+    } else {
+      args.push("-y");
+    }
+    if (this.model) {
+      args.push("--model", this.model);
+    }
+    if (options.continueSession && options.sessionId) {
+      args.push("--resume", options.sessionId);
+    }
+    return args;
+  }
+  getSpawnOptions(options) {
+    return {
+      cwd: options.workDir,
+      env: {
+        ...process.env,
+        NODE_VERSION: this.nvmNodeVersion
+      }
+    };
+  }
+};
+
+// src/ai-runner/CursorAgentRunner.ts
+var CursorAgentRunner = class extends BaseAIRunner {
+  binary;
+  nvmNodeVersion;
+  model;
+  constructor(binary, nvmNodeVersion, model) {
+    super();
+    this.binary = binary;
+    this.nvmNodeVersion = nvmNodeVersion;
+    this.model = model;
+  }
+  getBinary() {
+    return this.binary;
+  }
+  buildArgs(options) {
+    const args = [
+      "agent",
+      "-p",
+      "--force",
+      "--trust",
+      "--output-format",
+      "stream-json",
+      "--workspace",
+      options.workDir
+    ];
+    if (options.mode === "plan") {
+      args.push("--mode", "plan");
+    }
+    if (this.model) {
+      args.push("--model", this.model);
+    }
+    if (options.continueSession && options.sessionId) {
+      args.push("--resume", options.sessionId);
+    }
+    return args;
+  }
+  getSpawnOptions(_options) {
+    return {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        NODE_VERSION: this.nvmNodeVersion
+      }
+    };
+  }
+};
+
+// src/ai-runner/index.ts
+function createAIRunner(ai) {
+  switch (ai.mode) {
+    case "cursor-agent":
+      return new CursorAgentRunner(ai.binary, ai.nvmNodeVersion, ai.model);
+    case "codebuddy":
+      return new CodebuddyRunner(ai.binary, ai.nvmNodeVersion, ai.model);
+    default:
+      return new ClaudeInternalRunner(ai.binary, ai.nvmNodeVersion, ai.model);
+  }
+}
+
+// src/pipeline/PipelineDefinition.ts
+var CLASSIC_PIPELINE = {
+  mode: "classic",
+  phases: [
+    {
+      name: "analysis",
+      label: "\u5206\u6790",
+      startState: "analyzing" /* Analyzing */,
+      doneState: "analysis_done" /* AnalysisDone */,
+      kind: "ai"
+    },
+    {
+      name: "design",
+      label: "\u8BBE\u8BA1",
+      startState: "designing" /* Designing */,
+      doneState: "design_done" /* DesignDone */,
+      kind: "ai"
+    },
+    {
+      name: "implement",
+      label: "\u5B9E\u65BD",
+      startState: "implementing" /* Implementing */,
+      doneState: "implement_done" /* ImplementDone */,
+      kind: "ai"
+    },
+    {
+      name: "verify",
+      label: "\u9A8C\u8BC1",
+      startState: "verifying" /* Verifying */,
+      doneState: "completed" /* Completed */,
+      kind: "ai"
+    }
+  ],
+  planFiles: [
+    { filename: "01-analysis.md", label: "\u9700\u6C42\u5206\u6790", editable: true },
+    { filename: "02-design.md", label: "\u7CFB\u7EDF\u8BBE\u8BA1", editable: true },
+    { filename: "03-todolist.md", label: "\u5B9E\u65BD\u6E05\u5355", editable: true },
+    { filename: "04-verify-report.md", label: "\u9A8C\u8BC1\u62A5\u544A", editable: false }
+  ]
+};
+var PLAN_MODE_PIPELINE = {
+  mode: "plan-mode",
+  phases: [
+    {
+      name: "plan",
+      label: "\u89C4\u5212",
+      startState: "planning" /* Planning */,
+      doneState: "plan_done" /* PlanDone */,
+      kind: "ai"
+    },
+    {
+      name: "review",
+      label: "\u5BA1\u6838",
+      startState: "waiting_for_review" /* WaitingForReview */,
+      doneState: "waiting_for_review" /* WaitingForReview */,
+      approvedState: "review_approved" /* ReviewApproved */,
+      kind: "gate"
+    },
+    {
+      name: "build",
+      label: "\u5B9E\u65BD",
+      startState: "building" /* Building */,
+      doneState: "build_done" /* BuildDone */,
+      kind: "ai"
+    },
+    {
+      name: "verify",
+      label: "\u9A8C\u8BC1",
+      startState: "verifying" /* Verifying */,
+      doneState: "completed" /* Completed */,
+      kind: "ai"
+    }
+  ],
+  planFiles: [
+    { filename: "01-plan.md", label: "\u5B9E\u65BD\u8BA1\u5212", editable: true },
+    { filename: "02-verify-report.md", label: "\u9A8C\u8BC1\u62A5\u544A", editable: false },
+    { filename: "review-feedback.md", label: "\u5BA1\u6838\u53CD\u9988", editable: false },
+    { filename: "review-history.json", label: "\u5BA1\u6838\u5386\u53F2", editable: false }
+  ]
+};
+function resolvePipelineMode(aiMode, explicit) {
+  if (explicit === "classic" || explicit === "plan-mode") return explicit;
+  return aiMode === "cursor-agent" ? "plan-mode" : "classic";
+}
+function getPipelineDef(mode) {
+  return mode === "plan-mode" ? PLAN_MODE_PIPELINE : CLASSIC_PIPELINE;
+}
+function getPhasePreState(def, phaseName) {
+  const idx = def.phases.findIndex((p) => p.name === phaseName);
+  if (idx < 0) return void 0;
+  if (idx === 0) return "branch_created" /* BranchCreated */;
+  const prev = def.phases[idx - 1];
+  return prev.approvedState ?? prev.doneState;
+}
+function collectStateLabels(def) {
+  const labels = /* @__PURE__ */ new Map();
+  labels.set("pending" /* Pending */, t("state.pending"));
+  labels.set("branch_created" /* BranchCreated */, t("state.branchCreated"));
+  for (const phase of def.phases) {
+    labels.set(phase.startState, t("state.phaseDoing", { label: t(`pipeline.phase.${phase.name}`) }));
+    if (phase.doneState !== "completed" /* Completed */) {
+      labels.set(phase.doneState, t("state.phaseDone", { label: t(`pipeline.phase.${phase.name}`) }));
+    }
+    if (phase.approvedState) labels.set(phase.approvedState, t("state.phaseApproved", { label: t(`pipeline.phase.${phase.name}`) }));
+  }
+  labels.set("completed" /* Completed */, t("state.completed"));
+  labels.set("failed" /* Failed */, t("state.failed"));
+  return labels;
+}
+
+// src/events/EventBus.ts
+import { EventEmitter } from "events";
+var EventBusImpl = class extends EventEmitter {
+  emit(event, ...args) {
+    super.emit("*", event, ...args);
+    return super.emit(event, ...args);
+  }
+  emitTyped(type, data) {
+    const payload = {
+      type,
+      data,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.emit(type, payload);
+  }
+};
+var eventBus = new EventBusImpl();
+
+// src/tracker/IssueTracker.ts
+import fs3 from "fs";
+import path3 from "path";
+var logger5 = logger.child("IssueTracker");
+var IssueTracker = class _IssueTracker {
+  filePath;
+  data;
+  constructor(dataDir) {
+    this.filePath = path3.join(dataDir, "tracker.json");
+    this.data = this.load();
+  }
+  load() {
+    try {
+      if (fs3.existsSync(this.filePath)) {
+        const raw = fs3.readFileSync(this.filePath, "utf-8");
+        return JSON.parse(raw);
+      }
+    } catch (err) {
+      logger5.error("Failed to load tracker data", { error: err.message });
+    }
+    return { issues: {} };
+  }
+  save() {
+    const dir = path3.dirname(this.filePath);
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
+    }
+    const tmpPath = path3.join(dir, `.tracker-${process.pid}-${Date.now()}.tmp`);
+    fs3.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), "utf-8");
+    fs3.renameSync(tmpPath, this.filePath);
+  }
+  key(issueIid) {
+    return String(issueIid);
+  }
+  get(issueIid) {
+    return this.data.issues[this.key(issueIid)];
+  }
+  create(record) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const full = {
+      ...record,
+      attempts: 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.data.issues[this.key(record.issueIid)] = full;
+    this.save();
+    logger5.info("Issue tracked", { issueIid: record.issueIid, state: record.state });
+    eventBus.emitTyped("issue:created", full);
+    return full;
+  }
+  updateState(issueIid, state, extra) {
+    const record = this.data.issues[this.key(issueIid)];
+    if (!record) {
+      throw new Error(`Issue ${issueIid} not found in tracker`);
+    }
+    record.state = state;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (state === "completed" /* Completed */) {
+      record.lastError = void 0;
+      record.failedAtState = void 0;
+    }
+    if (extra) {
+      Object.assign(record, extra);
+    }
+    this.save();
+    logger5.info("Issue state updated", { issueIid, state });
+    eventBus.emitTyped("issue:stateChanged", { issueIid, state, record });
+  }
+  markFailed(issueIid, error, failedAtState) {
+    const record = this.data.issues[this.key(issueIid)];
+    if (!record) return;
+    record.state = "failed" /* Failed */;
+    record.lastError = error;
+    record.failedAtState = failedAtState;
+    record.attempts += 1;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    logger5.warn("Issue marked as failed", { issueIid, error, failedAtState, attempts: record.attempts });
+    eventBus.emitTyped("issue:failed", { issueIid, error, failedAtState, record });
+  }
+  static TERMINAL_STATES = /* @__PURE__ */ new Set(["completed" /* Completed */, "failed" /* Failed */]);
+  static PHASE_DONE_STATES = /* @__PURE__ */ new Set([
+    "analysis_done" /* AnalysisDone */,
+    "design_done" /* DesignDone */,
+    "implement_done" /* ImplementDone */,
+    "plan_done" /* PlanDone */,
+    "build_done" /* BuildDone */
+  ]);
+  isProcessing(issueIid) {
+    const record = this.get(issueIid);
+    if (!record) return false;
+    return !_IssueTracker.TERMINAL_STATES.has(record.state);
+  }
+  isCompleted(issueIid) {
+    const record = this.get(issueIid);
+    return record?.state === "completed" /* Completed */;
+  }
+  canRetry(issueIid, maxRetries) {
+    const record = this.get(issueIid);
+    if (!record || record.state !== "failed" /* Failed */) return false;
+    return record.attempts < maxRetries;
+  }
+  getRetryState(issueIid) {
+    const record = this.get(issueIid);
+    return record?.failedAtState;
+  }
+  isStalled(issueIid, thresholdMs = 5 * 60 * 1e3) {
+    const record = this.get(issueIid);
+    if (!record) return false;
+    if (record.state === "waiting_for_review" /* WaitingForReview */) return false;
+    if (!this.isProcessing(issueIid)) return false;
+    const elapsed = Date.now() - new Date(record.updatedAt).getTime();
+    return elapsed > thresholdMs;
+  }
+  getDrivableIssues(maxRetries, stalledThresholdMs) {
+    return Object.values(this.data.issues).filter((record) => {
+      if (record.state === "waiting_for_review" /* WaitingForReview */) return false;
+      if (record.state === "pending" /* Pending */) return true;
+      if (record.state === "branch_created" /* BranchCreated */) return true;
+      if (record.state === "review_approved" /* ReviewApproved */) return true;
+      if (record.state === "failed" /* Failed */ && record.attempts < maxRetries) return true;
+      if (_IssueTracker.PHASE_DONE_STATES.has(record.state)) return true;
+      if (this.isStalled(record.issueIid, stalledThresholdMs)) return true;
+      return false;
+    });
+  }
+  getAllActive() {
+    return Object.values(this.data.issues).filter(
+      (r) => r.state !== "completed" /* Completed */ && r.state !== "failed" /* Failed */
+    );
+  }
+  getAll() {
+    return Object.values(this.data.issues);
+  }
+  resetFull(issueIid) {
+    const record = this.data.issues[this.key(issueIid)];
+    if (!record) return false;
+    record.state = "pending" /* Pending */;
+    record.attempts = 0;
+    record.sessionId = void 0;
+    record.failedAtState = void 0;
+    record.lastError = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    logger5.info("Issue fully reset", { issueIid });
+    eventBus.emitTyped("issue:restarted", { issueIid, record });
+    return true;
+  }
+  resetToPhase(issueIid, phase, def) {
+    const record = this.data.issues[this.key(issueIid)];
+    if (!record) return false;
+    const targetState = getPhasePreState(def, phase);
+    if (!targetState) return false;
+    record.state = targetState;
+    record.sessionId = void 0;
+    record.failedAtState = void 0;
+    record.lastError = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    logger5.info("Issue reset to phase", { issueIid, phase, state: targetState });
+    eventBus.emitTyped("issue:retryFromPhase", { issueIid, phase, record });
+    return true;
+  }
+  resetForRetry(issueIid) {
+    const record = this.data.issues[this.key(issueIid)];
+    if (!record || record.state !== "failed" /* Failed */) return false;
+    const restoreState = record.failedAtState ?? "pending" /* Pending */;
+    record.state = restoreState;
+    record.lastError = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    logger5.info("Issue reset for retry", { issueIid, restoreState });
+    eventBus.emitTyped("issue:resetForRetry", { issueIid, restoreState, record });
+    return true;
+  }
+  delete(issueIid) {
+    const key = this.key(issueIid);
+    if (!this.data.issues[key]) return false;
+    const record = this.data.issues[key];
+    delete this.data.issues[key];
+    this.save();
+    logger5.info("Issue deleted from tracker", { issueIid });
+    eventBus.emitTyped("issue:deleted", { issueIid, record });
+    return true;
+  }
+};
+
+// src/persistence/PlanPersistence.ts
+import fs4 from "fs";
+import path4 from "path";
+var logger6 = logger.child("PlanPersistence");
+var PLAN_DIR = ".claude-plan";
+var PlanPersistence = class _PlanPersistence {
+  workDir;
+  issueIid;
+  constructor(workDir, issueIid) {
+    this.workDir = workDir;
+    this.issueIid = issueIid;
+  }
+  get baseDir() {
+    return this.workDir;
+  }
+  get planDir() {
+    return path4.join(this.workDir, PLAN_DIR, `issue-${this.issueIid}`);
+  }
+  ensureDir() {
+    if (!fs4.existsSync(this.planDir)) {
+      fs4.mkdirSync(this.planDir, { recursive: true });
+    }
+  }
+  writeIssueMeta(meta) {
+    this.ensureDir();
+    const filePath = path4.join(this.planDir, "issue-meta.json");
+    fs4.writeFileSync(filePath, JSON.stringify(meta, null, 2), "utf-8");
+    logger6.info("Issue meta written");
+  }
+  writeProgress(data) {
+    this.ensureDir();
+    const filePath = path4.join(this.planDir, "progress.json");
+    fs4.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    logger6.debug("Progress written", { currentPhase: data.currentPhase });
+  }
+  readProgress() {
+    const filePath = path4.join(this.planDir, "progress.json");
+    if (!fs4.existsSync(filePath)) return null;
+    try {
+      return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  writeAnalysis(content) {
+    this.ensureDir();
+    fs4.writeFileSync(path4.join(this.planDir, "01-analysis.md"), content, "utf-8");
+    logger6.info("Analysis document written");
+  }
+  writeDesign(content) {
+    this.ensureDir();
+    fs4.writeFileSync(path4.join(this.planDir, "02-design.md"), content, "utf-8");
+    logger6.info("Design document written");
+  }
+  writeTodolist(content) {
+    this.ensureDir();
+    fs4.writeFileSync(path4.join(this.planDir, "03-todolist.md"), content, "utf-8");
+    logger6.info("Todolist written");
+  }
+  writeVerifyReport(content, filename = "04-verify-report.md") {
+    this.ensureDir();
+    fs4.writeFileSync(path4.join(this.planDir, filename), content, "utf-8");
+    logger6.info("Verify report written", { filename });
+  }
+  getAllPlanFiles() {
+    if (!fs4.existsSync(this.planDir)) return [];
+    return fs4.readdirSync(this.planDir).map((f) => path4.join(PLAN_DIR, `issue-${this.issueIid}`, f));
+  }
+  createInitialProgress(issueId, issueTitle, branchName, def) {
+    const pending = { status: "pending" };
+    if (def) {
+      const phases = {};
+      for (const spec of def.phases) {
+        phases[spec.name] = { ...pending };
+      }
+      return {
+        issueId,
+        issueTitle,
+        branchName,
+        pipelineMode: def.mode,
+        currentPhase: def.phases[0].name,
+        phases
+      };
+    }
+    return {
+      issueId,
+      issueTitle,
+      branchName,
+      currentPhase: "analysis",
+      phases: {
+        analysis: { ...pending },
+        design: { ...pending },
+        implement: { ...pending },
+        verify: { ...pending }
+      }
+    };
+  }
+  writePlan(content) {
+    this.ensureDir();
+    fs4.writeFileSync(path4.join(this.planDir, "01-plan.md"), content, "utf-8");
+    logger6.info("Plan document written");
+  }
+  writeReviewFeedback(content) {
+    this.ensureDir();
+    const history = this.readReviewHistory();
+    const round = {
+      round: history.length + 1,
+      feedback: content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    history.push(round);
+    fs4.writeFileSync(
+      path4.join(this.planDir, "review-history.json"),
+      JSON.stringify(history, null, 2),
+      "utf-8"
+    );
+    fs4.writeFileSync(
+      path4.join(this.planDir, "review-feedback.md"),
+      _PlanPersistence.renderReviewHistoryMarkdown(history),
+      "utf-8"
+    );
+    logger6.info("Review feedback appended", { round: round.round });
+  }
+  readReviewFeedback() {
+    const filePath = path4.join(this.planDir, "review-feedback.md");
+    if (!fs4.existsSync(filePath)) return null;
+    try {
+      return fs4.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  readReviewHistory() {
+    const filePath = path4.join(this.planDir, "review-history.json");
+    if (!fs4.existsSync(filePath)) return [];
+    try {
+      const data = JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+      return Array.isArray(data) ? data : [];
+    } catch {
+      return [];
+    }
+  }
+  static renderReviewHistoryMarkdown(history) {
+    if (history.length === 0) return "";
+    const lines = ["# \u5BA1\u6838\u53CD\u9988\u5386\u53F2", ""];
+    for (const r of history) {
+      lines.push(`## \u7B2C ${r.round} \u8F6E\u5BA1\u6838\u53CD\u9988`);
+      lines.push(`> \u65F6\u95F4: ${r.timestamp}`);
+      lines.push("");
+      lines.push(r.feedback);
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  updatePhaseProgress(phaseName, status, error) {
+    const progress = this.readProgress();
+    if (!progress) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (!progress.phases[phaseName]) {
+      progress.phases[phaseName] = { status: "pending" };
+    }
+    const phase = progress.phases[phaseName];
+    phase.status = status;
+    if (status === "in_progress") {
+      phase.startedAt = now;
+      progress.currentPhase = phaseName;
+    } else if (status === "completed") {
+      phase.completedAt = now;
+    } else if (status === "failed") {
+      phase.error = error;
+    }
+    this.writeProgress(progress);
+  }
+};
+
+// src/phases/BasePhase.ts
+import fs5 from "fs";
+import path6 from "path";
+
+// src/prompts/templates.ts
+function planDir(iid) {
+  return `.claude-plan/issue-${iid}`;
+}
+function analysisPrompt(ctx) {
+  const supplementSection = ctx.supplementText ? `
+
+${ctx.supplementText}` : "";
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.analysis", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    description: ctx.issueDescription,
+    supplement: supplementSection,
+    planDir: pd
+  });
+}
+function designPrompt(ctx) {
+  const supplementSection = ctx.supplementText ? `
+
+${ctx.supplementText}` : "";
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.design", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    supplement: supplementSection,
+    planDir: pd
+  });
+}
+function implementPrompt(ctx) {
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.implement", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    planDir: pd
+  });
+}
+function verifyPrompt(ctx) {
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.verify", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    planDir: pd
+  });
+}
+function planModeVerifyPrompt(ctx) {
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.planModeVerify", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    planDir: pd
+  });
+}
+function planPrompt(ctx) {
+  const supplementSection = ctx.supplementText ? `
+
+${ctx.supplementText}` : "";
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.plan", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    description: ctx.issueDescription,
+    supplement: supplementSection,
+    planDir: pd
+  });
+}
+function buildPrompt(ctx) {
+  const pd = planDir(ctx.issueIid);
+  return t("prompt.build", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    planDir: pd
+  });
+}
+function rePlanPrompt(ctx, history) {
+  const supplementSection = ctx.supplementText ? `
+
+${ctx.supplementText}` : "";
+  const pd = planDir(ctx.issueIid);
+  const feedbackLines = history.map(
+    (r) => t("prompt.rePlanRound", { round: r.round, timestamp: r.timestamp, feedback: r.feedback })
+  ).join("\n\n");
+  return t("prompt.rePlan", {
+    iid: ctx.issueIid,
+    title: ctx.issueTitle,
+    description: ctx.issueDescription,
+    supplement: supplementSection,
+    historyCount: history.length,
+    feedbackLines,
+    planDir: pd
+  });
+}
+function e2eVerifyPromptSuffix(ctx, ports) {
+  const serverSection = ports ? `
+**Preview \u73AF\u5883\u5DF2\u542F\u52A8\uFF08\u7531\u7CFB\u7EDF\u7BA1\u7406\uFF0C\u65E0\u9700\u624B\u52A8\u542F\u52A8\uFF09\uFF1A**
+- \u540E\u7AEF: http://${ports.host}:${ports.backendPort}
+- \u524D\u7AEF: https://${ports.host}:${ports.frontendPort}
+
+\u6267\u884C E2E \u6D4B\u8BD5\u65F6\u8BF7\u4F7F\u7528\u4EE5\u4E0B\u73AF\u5883\u53D8\u91CF\u6765\u8FDE\u63A5\u5DF2\u542F\u52A8\u7684\u670D\u52A1\uFF1A
+\`\`\`bash
+E2E_PORT=${ports.frontendPort} E2E_HOST=${ports.host} E2E_BASE_URL=https://${ports.host}:${ports.frontendPort} \\
+  cd frontend && npx playwright test
+\`\`\`
+
+**\u6CE8\u610F**: \u4E0D\u8981\u4F7F\u7528 pnpm test:e2e\uFF08\u5B83\u4F1A\u5C1D\u8BD5\u81EA\u884C\u542F\u52A8 webServer\uFF09\uFF0C\u76F4\u63A5\u7528 npx playwright test \u5373\u53EF\u590D\u7528\u5DF2\u542F\u52A8\u7684\u524D\u7AEF\u3002` : `
+\u6267\u884C E2E \u6D4B\u8BD5\uFF1A
+\`\`\`bash
+cd frontend && pnpm test:e2e
+\`\`\``;
+  return `
+
+## E2E UI \u9A8C\u8BC1\uFF08\u5DF2\u542F\u7528\uFF09
+
+\u672C\u6B21\u53D8\u66F4\u5DF2\u5F00\u542F E2E UI \u81EA\u52A8\u9A8C\u6536\uFF0C\u8BF7\u989D\u5916\u6267\u884C\u4EE5\u4E0B\u6B65\u9AA4\uFF1A
+
+6. \u5982\u679C\u672C\u6B21\u53D8\u66F4\u6D89\u53CA\u524D\u7AEF\u9875\u9762\uFF08frontend/ \u76EE\u5F55\u6709\u6539\u52A8\uFF09\uFF0C\u8BF7\u6267\u884C UI E2E \u9A8C\u8BC1\uFF1A
+   a. \u5728 frontend/e2e/dynamic/ \u76EE\u5F55\u4E0B\u7F16\u5199\u9488\u5BF9\u672C\u6B21\u53D8\u66F4\u7684 Playwright \u6D4B\u8BD5
+   b. ${serverSection.trim()}
+   c. \u5982\u679C\u6D4B\u8BD5\u5931\u8D25\uFF0C\u5206\u6790\u5931\u8D25\u539F\u56E0\u5E76\u5C1D\u8BD5\u4FEE\u590D
+7. \u5C06 E2E \u6D4B\u8BD5\u7ED3\u679C\u5199\u5165\u9A8C\u8BC1\u62A5\u544A\u7684 **E2E UI \u6D4B\u8BD5\u7ED3\u679C** \u7AE0\u8282\uFF0C\u5305\u62EC\uFF1A
+   - \u5192\u70DF\u6D4B\u8BD5\u901A\u8FC7\u6570 / \u603B\u6570
+   - \u4E13\u9879\u6D4B\u8BD5\u7ED3\u679C\u5217\u8868
+   - \u5931\u8D25\u622A\u56FE\u8DEF\u5F84\uFF08\u5982\u6709\uFF09`;
+}
+function issueProgressComment(phase, status, detail) {
+  const emoji = {
+    analysis: "\u{1F50D}",
+    design: "\u{1F4D0}",
+    implement: "\u{1F4BB}",
+    verify: "\u2705",
+    plan: "\u{1F4CB}",
+    review: "\u{1F440}",
+    build: "\u{1F528}"
+  };
+  const icon = emoji[phase] || "\u{1F4CB}";
+  const statusKey = status === "completed" ? "progress.completed" : status === "failed" ? "progress.failed" : "progress.inProgress";
+  const statusText = t(statusKey);
+  let msg = t("progress.comment", { icon, phase, status: statusText });
+  if (detail) {
+    msg += `
+
+${detail}`;
+  }
+  return msg;
+}
+
+// src/rules/RuleResolver.ts
+import { readdir, readFile } from "fs/promises";
+import path5 from "path";
+var RULE_TRIGGERS = [
+  {
+    filename: "session-rule.mdc",
+    keywords: ["Session", "PublishSession", "SessionData", "\u4F1A\u8BDD", "ActivitySession"]
+  },
+  {
+    filename: "backend-api-implementation.mdc",
+    keywords: ["\u65B0\u589E\u63A5\u53E3", "\u6DFB\u52A0\u63A5\u53E3", "\u4FEE\u6539\u63A5\u53E3", "Controller", "ServiceImpl", "\u8DEF\u7531"]
+  },
+  {
+    filename: "artifact-publish-rule.mdc",
+    keywords: ["\u5236\u54C1\u53D1\u5E03", "ArtifactPublish", "lockResource", "unlockResource", "\u53D1\u5E03\u7CFB\u7EDF"]
+  },
+  {
+    filename: "activity-realization-rule.mdc",
+    keywords: ["\u6D3B\u52A8\u5B9E\u73B0", "ActivityRealization", "BaseActivityRealization", "syncExecuteStatus", "queryExec"]
+  },
+  {
+    filename: "appset.mdc",
+    keywords: ["AppSet", "appset", "ComponentInstance", "StorageService", "IDC Set"]
+  },
+  {
+    filename: "add-artifact-workflow.mdc",
+    keywords: ["\u6DFB\u52A0\u5236\u54C1", "\u65B0\u589E\u5236\u54C1", "\u5236\u54C1\u7C7B\u578B", "ArtifactType", "ArtifactTypeId"]
+  },
+  {
+    filename: "add-appset-api-workflow.mdc",
+    keywords: ["AppSet\u63A5\u53E3", "AppSet API", "proto", "protobuf", "devops-contracts"]
+  }
+];
+function parseFrontmatter(raw) {
+  const fmRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
+  const match = raw.match(fmRegex);
+  if (!match) {
+    return { description: "", content: raw.trim() };
+  }
+  const yamlBlock = match[1];
+  const content = raw.slice(match[0].length).trim();
+  let description = "";
+  const descMatch = yamlBlock.match(/description:\s*(.+)/);
+  if (descMatch) {
+    description = descMatch[1].trim();
+  }
+  return { description, content };
+}
+var RuleResolver = class {
+  rules = [];
+  async loadRules(rulesDir) {
+    this.rules = [];
+    let files;
+    try {
+      files = await readdir(rulesDir);
+    } catch {
+      return;
+    }
+    const mdcFiles = files.filter((f) => f.endsWith(".mdc"));
+    const loadPromises = mdcFiles.map(async (filename) => {
+      try {
+        const raw = await readFile(path5.join(rulesDir, filename), "utf-8");
+        const { description, content } = parseFrontmatter(raw);
+        if (content) {
+          this.rules.push({ filename, description, content });
+        }
+      } catch {
+      }
+    });
+    await Promise.all(loadPromises);
+  }
+  getRules() {
+    return this.rules;
+  }
+  matchRules(text) {
+    const lowerText = text.toLowerCase();
+    const matched = [];
+    for (const trigger of RULE_TRIGGERS) {
+      const isTriggered = trigger.keywords.some((kw) => lowerText.includes(kw.toLowerCase()));
+      if (!isTriggered) continue;
+      const rule = this.rules.find((r) => r.filename === trigger.filename);
+      if (rule) {
+        matched.push(rule);
+      }
+    }
+    return matched;
+  }
+  formatForPrompt(rules) {
+    if (rules.length === 0) return "";
+    return rules.map((rule) => {
+      const header = rule.description ? `### ${rule.description} (${rule.filename})` : `### ${rule.filename}`;
+      return `${header}
+
+${rule.content}`;
+    }).join("\n\n---\n\n");
+  }
+};
+
+// src/notesync/NoteSyncSettings.ts
+var noteSyncOverride;
+function getNoteSyncEnabled(cfg) {
+  return noteSyncOverride ?? cfg.issueNoteSync.enabled;
+}
+function setNoteSyncOverride(value) {
+  noteSyncOverride = value;
+}
+function isNoteSyncEnabledForIssue(issueIid, tracker, cfg) {
+  const record = tracker.get(issueIid);
+  if (record?.issueNoteSyncEnabled !== void 0) return record.issueNoteSyncEnabled;
+  return getNoteSyncEnabled(cfg);
+}
+var SUMMARY_MAX_LENGTH = 500;
+function truncateToSummary(content) {
+  if (content.length <= SUMMARY_MAX_LENGTH) return content;
+  const cut = content.slice(0, SUMMARY_MAX_LENGTH);
+  const lastNewline = cut.lastIndexOf("\n\n");
+  const boundary = lastNewline > SUMMARY_MAX_LENGTH * 0.3 ? lastNewline : cut.lastIndexOf("\n");
+  const summary = boundary > SUMMARY_MAX_LENGTH * 0.3 ? cut.slice(0, boundary) : cut;
+  return summary + "\n\n...";
+}
+function buildNoteSyncComment(phaseName, phaseLabel, docUrl, dashboardUrl, summary) {
+  const emoji = {
+    analysis: "\u{1F50D}",
+    design: "\u{1F4D0}",
+    implement: "\u{1F4BB}",
+    verify: "\u2705",
+    plan: "\u{1F4CB}",
+    review: "\u{1F440}",
+    build: "\u{1F528}"
+  };
+  const icon = emoji[phaseName] || "\u{1F4CB}";
+  return [
+    t("notesync.phaseCompleted", { icon, label: phaseLabel }),
+    "",
+    summary,
+    "",
+    "---",
+    t("notesync.viewDoc", { label: phaseLabel, url: docUrl }),
+    t("notesync.viewDashboard", { url: dashboardUrl })
+  ].join("\n");
+}
+
+// src/phases/BasePhase.ts
+var BasePhase = class {
+  aiRunner;
+  git;
+  plan;
+  gongfeng;
+  tracker;
+  config;
+  logger;
+  constructor(aiRunner, git, plan, gongfeng, tracker, config) {
+    this.aiRunner = aiRunner;
+    this.git = git;
+    this.plan = plan;
+    this.gongfeng = gongfeng;
+    this.tracker = tracker;
+    this.config = config;
+    this.logger = logger.child(this.constructor.name);
+  }
+  getRunMode() {
+    return void 0;
+  }
+  getResultFiles(_ctx) {
+    return [];
+  }
+  async execute(ctx) {
+    this.logger.info(`Phase ${this.phaseName} starting`, { issueIid: ctx.issueIid });
+    this.tracker.updateState(ctx.issueIid, this.startState);
+    this.plan.updatePhaseProgress(this.phaseName, "in_progress");
+    try {
+      await this.gongfeng.createIssueNote(
+        ctx.issueId,
+        issueProgressComment(this.phaseName, "in_progress")
+      );
+    } catch (err) {
+      this.logger.warn("Failed to comment on issue", { error: err.message });
+    }
+    const phaseLabel = t(`phase.${this.phaseName}`) || this.phaseName;
+    eventBus.emitTyped("agent:output", {
+      issueIid: ctx.issueIid,
+      phase: this.phaseName,
+      event: {
+        type: "system",
+        content: t("basePhase.aiStarting", { label: phaseLabel }),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    const basePrompt = this.buildPrompt(ctx);
+    const matchedRulesText = await this.resolveRules(ctx);
+    const prompt = matchedRulesText ? `${basePrompt}
+
+${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
+    const record = this.tracker.get(ctx.issueIid);
+    const result = await this.aiRunner.run({
+      prompt,
+      workDir: this.plan.baseDir,
+      timeoutMs: this.config.ai.phaseTimeoutMs,
+      sessionId: record?.sessionId,
+      continueSession: !!record?.sessionId,
+      mode: this.getRunMode(),
+      onStreamEvent: (event) => {
+        eventBus.emitTyped("agent:output", {
+          issueIid: ctx.issueIid,
+          phase: this.phaseName,
+          event
+        });
+      }
+    });
+    if (!result.success) {
+      this.plan.updatePhaseProgress(this.phaseName, "failed", result.output.slice(0, 500));
+      this.tracker.markFailed(ctx.issueIid, result.output.slice(0, 500), this.startState);
+      try {
+        await this.gongfeng.createIssueNote(
+          ctx.issueId,
+          issueProgressComment(this.phaseName, "failed", t("basePhase.error", { message: result.output.slice(0, 200) }))
+        );
+      } catch {
+      }
+      throw new Error(`Phase ${this.phaseName} failed: ${result.output.slice(0, 200)}`);
+    }
+    if (result.sessionId) {
+      this.tracker.updateState(ctx.issueIid, this.startState, { sessionId: result.sessionId });
+    }
+    this.tracker.updateState(ctx.issueIid, this.doneState);
+    this.plan.updatePhaseProgress(this.phaseName, "completed");
+    await this.commitPlanFiles(ctx);
+    await this.syncResultToIssue(ctx);
+    this.logger.info(`Phase ${this.phaseName} completed`, { issueIid: ctx.issueIid });
+    return result;
+  }
+  async resolveRules(ctx) {
+    try {
+      const rulesDir = path6.join(this.plan.baseDir, ".cursor", "rules");
+      const resolver = new RuleResolver();
+      await resolver.loadRules(rulesDir);
+      const context = `${ctx.issueTitle} ${ctx.issueDescription} ${ctx.supplementText ?? ""}`;
+      const matched = resolver.matchRules(context);
+      if (matched.length > 0) {
+        this.logger.info(`Matched ${matched.length} MDC rules`, {
+          rules: matched.map((r) => r.filename)
+        });
+        return resolver.formatForPrompt(matched);
+      }
+    } catch (err) {
+      this.logger.warn("Failed to resolve MDC rules", { error: err.message });
+    }
+    return null;
+  }
+  async syncResultToIssue(ctx) {
+    try {
+      const enabled = isNoteSyncEnabledForIssue(ctx.issueIid, this.tracker, this.config);
+      const resultFiles = this.getResultFiles(ctx);
+      if (!enabled || resultFiles.length === 0) {
+        try {
+          await this.gongfeng.createIssueNote(
+            ctx.issueId,
+            issueProgressComment(this.phaseName, "completed")
+          );
+        } catch {
+        }
+        return;
+      }
+      const baseUrl = this.config.issueNoteSync.webBaseUrl.replace(/\/$/, "");
+      const phaseLabel = t(`phase.${this.phaseName}`) || this.phaseName;
+      const dashboardUrl = `${baseUrl}/?issue=${ctx.issueIid}`;
+      for (const file of resultFiles) {
+        const content = this.readResultFile(ctx.issueIid, file.filename);
+        if (!content) continue;
+        const summary = truncateToSummary(content);
+        const docUrl = `${baseUrl}/doc/${ctx.issueIid}/${file.filename}`;
+        const comment = buildNoteSyncComment(
+          this.phaseName,
+          file.label || phaseLabel,
+          docUrl,
+          dashboardUrl,
+          summary
+        );
+        await this.gongfeng.createIssueNote(ctx.issueId, comment);
+        this.logger.info("Result synced to issue", { issueIid: ctx.issueIid, file: file.filename });
+      }
+    } catch (err) {
+      this.logger.warn("Failed to sync result to issue", { error: err.message });
+      try {
+        await this.gongfeng.createIssueNote(
+          ctx.issueId,
+          issueProgressComment(this.phaseName, "completed")
+        );
+      } catch {
+      }
+    }
+  }
+  readResultFile(issueIid, filename) {
+    const planDir2 = path6.join(this.plan.baseDir, ".claude-plan", `issue-${issueIid}`);
+    const filePath = path6.join(planDir2, filename);
+    if (!fs5.existsSync(filePath)) return null;
+    try {
+      return fs5.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  async commitPlanFiles(ctx) {
+    if (await this.git.hasChanges()) {
+      await this.git.add(["."]);
+      await this.git.commit(`chore(auto): ${this.phaseName} phase completed for issue #${ctx.issueIid}`);
+      await this.git.push(ctx.branchName);
+    }
+  }
+};
+
+// src/phases/AnalysisPhase.ts
+var AnalysisPhase = class extends BasePhase {
+  phaseName = "analysis";
+  startState = "analyzing" /* Analyzing */;
+  doneState = "analysis_done" /* AnalysisDone */;
+  getResultFiles() {
+    return [{ filename: "01-analysis.md", label: "\u9700\u6C42\u5206\u6790" }];
+  }
+  buildPrompt(ctx) {
+    return analysisPrompt({
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid,
+      supplementText: ctx.supplementText
+    });
+  }
+};
+
+// src/phases/DesignPhase.ts
+var DesignPhase = class extends BasePhase {
+  phaseName = "design";
+  startState = "designing" /* Designing */;
+  doneState = "design_done" /* DesignDone */;
+  getResultFiles() {
+    return [{ filename: "02-design.md", label: "\u7CFB\u7EDF\u8BBE\u8BA1" }];
+  }
+  buildPrompt(ctx) {
+    return designPrompt({
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid,
+      supplementText: ctx.supplementText
+    });
+  }
+};
+
+// src/phases/ImplementPhase.ts
+var ImplementPhase = class extends BasePhase {
+  phaseName = "implement";
+  startState = "implementing" /* Implementing */;
+  doneState = "implement_done" /* ImplementDone */;
+  buildPrompt(ctx) {
+    return implementPrompt({
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid
+    });
+  }
+};
+
+// src/phases/VerifyPhase.ts
+import os2 from "os";
+
+// src/e2e/E2eSettings.ts
+var e2eOverride;
+function getE2eEnabled(cfg) {
+  return e2eOverride ?? cfg.e2e.enabled;
+}
+function setE2eOverride(value) {
+  e2eOverride = value;
+}
+function isE2eEnabledForIssue(issueIid, tracker, cfg) {
+  const record = tracker.get(issueIid);
+  if (record?.e2eEnabled !== void 0) return record.e2eEnabled;
+  return getE2eEnabled(cfg);
+}
+
+// src/phases/VerifyPhase.ts
+function getDefaultHost() {
+  const interfaces = os2.networkInterfaces();
+  for (const addrs of Object.values(interfaces)) {
+    for (const addr of addrs ?? []) {
+      if (addr.family === "IPv4" && !addr.internal) return addr.address;
+    }
+  }
+  return "localhost";
+}
+var VerifyPhase = class extends BasePhase {
+  phaseName = "verify";
+  startState = "verifying" /* Verifying */;
+  doneState = "completed" /* Completed */;
+  getResultFiles(ctx) {
+    const filename = ctx?.pipelineMode === "plan-mode" ? "02-verify-report.md" : "04-verify-report.md";
+    return [{ filename, label: "\u9A8C\u8BC1\u62A5\u544A" }];
+  }
+  buildPrompt(ctx) {
+    const promptCtx = {
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid
+    };
+    const base = ctx.pipelineMode === "plan-mode" ? planModeVerifyPrompt(promptCtx) : verifyPrompt(promptCtx);
+    if (!isE2eEnabledForIssue(ctx.issueIid, this.tracker, this.config)) {
+      return base;
+    }
+    const e2ePorts = ctx.ports ? {
+      backendPort: ctx.ports.backendPort,
+      frontendPort: ctx.ports.frontendPort,
+      host: this.config.preview.host || getDefaultHost()
+    } : void 0;
+    return base + e2eVerifyPromptSuffix(promptCtx, e2ePorts);
+  }
+};
+
+// src/phases/PlanPhase.ts
+var PlanPhase = class extends BasePhase {
+  phaseName = "plan";
+  startState = "planning" /* Planning */;
+  doneState = "plan_done" /* PlanDone */;
+  getResultFiles() {
+    return [{ filename: "01-plan.md", label: "\u5B9E\u65BD\u8BA1\u5212" }];
+  }
+  getRunMode() {
+    return "plan";
+  }
+  buildPrompt(ctx) {
+    const history = this.plan.readReviewHistory();
+    const promptCtx = {
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid,
+      supplementText: ctx.supplementText
+    };
+    if (history.length > 0) {
+      return rePlanPrompt(promptCtx, history);
+    }
+    return planPrompt(promptCtx);
+  }
+};
+
+// src/phases/BuildPhase.ts
+var BuildPhase = class extends BasePhase {
+  phaseName = "build";
+  startState = "building" /* Building */;
+  doneState = "build_done" /* BuildDone */;
+  buildPrompt(ctx) {
+    return buildPrompt({
+      issueTitle: ctx.issueTitle,
+      issueDescription: ctx.issueDescription,
+      issueIid: ctx.issueIid
+    });
+  }
+};
+
+// src/phases/PhaseFactory.ts
+var PHASE_REGISTRY = {
+  analysis: AnalysisPhase,
+  design: DesignPhase,
+  implement: ImplementPhase,
+  plan: PlanPhase,
+  build: BuildPhase,
+  verify: VerifyPhase
+};
+function createPhase(name, ...args) {
+  const Ctor = PHASE_REGISTRY[name];
+  if (!Ctor) {
+    throw new Error(
+      `Unknown phase: ${name}. Registered phases: ${Object.keys(PHASE_REGISTRY).join(", ")}`
+    );
+  }
+  return new Ctor(...args);
+}
+function validatePhaseRegistry(phaseNames) {
+  const missing = phaseNames.filter((name) => !(name in PHASE_REGISTRY));
+  if (missing.length > 0) {
+    throw new Error(
+      `Pipeline defines unregistered phases: ${missing.join(", ")}. Registered: ${Object.keys(PHASE_REGISTRY).join(", ")}`
+    );
+  }
+}
+
+// src/utils/AsyncMutex.ts
+var AsyncMutex = class {
+  queue = [];
+  locked = false;
+  async runExclusive(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+  get isLocked() {
+    return this.locked;
+  }
+  get queueLength() {
+    return this.queue.length;
+  }
+};
+
+// src/orchestrator/PipelineOrchestrator.ts
+import path10 from "path";
+import os3 from "os";
+import fs8 from "fs/promises";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+
+// src/utils/MergeRequestHelper.ts
+import fs6 from "fs";
+import path7 from "path";
+var TAPD_PATTERNS = [
+  /--story=(\d+)/i,
+  /--bug=(\d+)/i,
+  /tapd[:\s-]+(\d+)/i,
+  /tapd单号[:\s]*(\d+)/i
+];
+function extractTapdId(text) {
+  for (const pattern of TAPD_PATTERNS) {
+    const match = text.match(pattern);
+    if (match) return match[1];
+  }
+  return null;
+}
+function generateMRTitle(issueIid, issueTitle, tapdId) {
+  const base = `feat(#${issueIid}): ${issueTitle}`;
+  if (tapdId) {
+    return `${base} --story=${tapdId}`;
+  }
+  return base;
+}
+function generateMRDescription(options) {
+  const { issueIid, issueTitle, issueDescription, branchName, planDir: planDir2 } = options;
+  const sections = [
+    t("mr.relatedIssue"),
+    ``,
+    `- Issue: #${issueIid}`,
+    `- ${t("mr.title")}: ${issueTitle}`,
+    `- ${t("mr.branch")}: \`${branchName}\``,
+    ``,
+    t("mr.issueDescription"),
+    ``,
+    issueDescription || t("mr.noDescription")
+  ];
+  if (planDir2) {
+    const summaryFiles = [
+      { filename: "01-analysis.md", label: t("mr.summaryFiles.01-analysis.md") },
+      { filename: "01-plan.md", label: t("mr.summaryFiles.01-plan.md") },
+      { filename: "02-design.md", label: t("mr.summaryFiles.02-design.md") },
+      { filename: "04-verify-report.md", label: t("mr.summaryFiles.04-verify-report.md") },
+      { filename: "02-verify-report.md", label: t("mr.summaryFiles.02-verify-report.md") }
+    ];
+    const planSections = [];
+    for (const { filename, label } of summaryFiles) {
+      const filePath = path7.join(planDir2, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs6.existsSync(filePath)) {
+        const content = fs6.readFileSync(filePath, "utf-8");
+        const summary = extractSummary(content);
+        if (summary) {
+          planSections.push(`### ${label}
+
+${summary}`);
+        }
+      }
+    }
+    if (planSections.length > 0) {
+      sections.push("", t("mr.aiSummary"), "", ...planSections);
+    }
+  }
+  sections.push("", "---", t("mr.autoCreated"));
+  return sections.join("\n");
+}
+function extractSummary(content, maxLines = 20) {
+  const lines = content.split("\n");
+  if (lines.length <= maxLines) return content.trim();
+  return lines.slice(0, maxLines).join("\n").trim() + "\n\n" + t("mr.truncated");
+}
+
+// src/deploy/PortAllocator.ts
+import net from "net";
+var logger7 = logger.child("PortAllocator");
+var DEFAULT_OPTIONS = {
+  backendPortBase: 4e3,
+  frontendPortBase: 9e3,
+  maxPorts: 100
+};
+function checkPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(false));
+    server.once("listening", () => {
+      server.close(() => resolve(true));
+    });
+    server.listen(port, "0.0.0.0");
+  });
+}
+var PortAllocator = class {
+  allocated = /* @__PURE__ */ new Map();
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async allocate(issueIid) {
+    const existing = this.allocated.get(issueIid);
+    if (existing) {
+      logger7.info("Returning already allocated ports", { issueIid, ports: existing });
+      return existing;
+    }
+    const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
+    const usedFrontend = new Set([...this.allocated.values()].map((p) => p.frontendPort));
+    for (let offset = 1; offset <= this.options.maxPorts; offset++) {
+      const backendPort = this.options.backendPortBase + offset;
+      const frontendPort = this.options.frontendPortBase + offset;
+      if (usedBackend.has(backendPort) || usedFrontend.has(frontendPort)) {
+        continue;
+      }
+      const [beOk, feOk] = await Promise.all([
+        checkPortAvailable(backendPort),
+        checkPortAvailable(frontendPort)
+      ]);
+      if (beOk && feOk) {
+        const pair = { backendPort, frontendPort };
+        this.allocated.set(issueIid, pair);
+        logger7.info("Ports allocated", { issueIid, ...pair });
+        return pair;
+      }
+      logger7.debug("Port pair unavailable, trying next", {
+        backendPort,
+        frontendPort,
+        beOk,
+        feOk
+      });
+    }
+    throw new Error(
+      `No available port pair found for issue #${issueIid} (scanned ${this.options.maxPorts} offsets from backend=${this.options.backendPortBase} frontend=${this.options.frontendPortBase})`
+    );
+  }
+  release(issueIid) {
+    const pair = this.allocated.get(issueIid);
+    if (pair) {
+      this.allocated.delete(issueIid);
+      logger7.info("Ports released", { issueIid, ...pair });
+    }
+  }
+  getPortsForIssue(issueIid) {
+    return this.allocated.get(issueIid);
+  }
+  getAllAllocated() {
+    return new Map(this.allocated);
+  }
+  restore(issueIid, ports) {
+    this.allocated.set(issueIid, ports);
+    logger7.info("Ports restored from persistence", { issueIid, ...ports });
+  }
+};
+
+// src/deploy/DevServerManager.ts
+import { spawn as spawn2 } from "child_process";
+import path8 from "path";
+import https from "https";
+import http from "http";
+var logger8 = logger.child("DevServerManager");
+var DEFAULT_OPTIONS2 = {
+  healthCheckTimeoutMs: 12e4,
+  healthCheckIntervalMs: 3e3
+};
+function waitForPort(port, useTls, timeoutMs, intervalMs) {
+  return new Promise((resolve, reject) => {
+    const deadline = Date.now() + timeoutMs;
+    const check = () => {
+      if (Date.now() > deadline) {
+        reject(new Error(`Port ${port} not ready after ${timeoutMs}ms`));
+        return;
+      }
+      const req = useTls ? https.get(
+        { hostname: "127.0.0.1", port, path: "/", rejectUnauthorized: false, timeout: 5e3 },
+        (res) => {
+          res.resume();
+          resolve();
+        }
+      ) : http.get(
+        { hostname: "127.0.0.1", port, path: "/", timeout: 5e3 },
+        (res) => {
+          res.resume();
+          resolve();
+        }
+      );
+      req.on("error", () => {
+        setTimeout(check, intervalMs);
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        setTimeout(check, intervalMs);
+      });
+    };
+    check();
+  });
+}
+var DevServerManager = class {
+  servers = /* @__PURE__ */ new Map();
+  options;
+  constructor(options) {
+    this.options = { ...DEFAULT_OPTIONS2, ...options };
+  }
+  async startServers(wtCtx, ports) {
+    if (this.servers.has(wtCtx.issueIid)) {
+      logger8.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      return;
+    }
+    logger8.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    const backendEnv = {
+      ...process.env,
+      PORT: String(ports.backendPort),
+      E2E_PORT_OVERRIDE: "1",
+      ENV_PATH: ".env.development.local"
+    };
+    const backend = spawn2("node", ["ace", "serve", "--watch"], {
+      cwd: wtCtx.workDir,
+      env: backendEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    backend.stdout?.on("data", (data) => {
+      logger8.debug(`[BE #${wtCtx.issueIid}] ${data.toString().trimEnd()}`);
+    });
+    backend.stderr?.on("data", (data) => {
+      logger8.debug(`[BE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
+    });
+    backend.on("exit", (code) => {
+      logger8.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+    });
+    const frontendDir = path8.join(wtCtx.workDir, "frontend");
+    const frontendEnv = {
+      ...process.env,
+      BACKEND_PORT: String(ports.backendPort),
+      FRONTEND_PORT: String(ports.frontendPort)
+    };
+    const frontend = spawn2("pnpm", ["dev", "--", "--port", String(ports.frontendPort)], {
+      cwd: frontendDir,
+      env: frontendEnv,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    frontend.stdout?.on("data", (data) => {
+      logger8.debug(`[FE #${wtCtx.issueIid}] ${data.toString().trimEnd()}`);
+    });
+    frontend.stderr?.on("data", (data) => {
+      logger8.debug(`[FE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
+    });
+    frontend.on("exit", (code) => {
+      logger8.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+    });
+    const serverSet = {
+      backend,
+      frontend,
+      ports,
+      workDir: wtCtx.workDir,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.servers.set(wtCtx.issueIid, serverSet);
+    logger8.info("Waiting for servers to become healthy", { issueIid: wtCtx.issueIid });
+    try {
+      await Promise.all([
+        waitForPort(
+          ports.backendPort,
+          false,
+          this.options.healthCheckTimeoutMs,
+          this.options.healthCheckIntervalMs
+        ),
+        waitForPort(
+          ports.frontendPort,
+          true,
+          this.options.healthCheckTimeoutMs,
+          this.options.healthCheckIntervalMs
+        )
+      ]);
+      logger8.info("Dev servers healthy", { issueIid: wtCtx.issueIid, ...ports });
+    } catch (err) {
+      logger8.error("Dev servers failed health check, cleaning up", {
+        issueIid: wtCtx.issueIid,
+        error: err.message
+      });
+      this.stopServers(wtCtx.issueIid);
+      throw err;
+    }
+  }
+  stopServers(issueIid) {
+    const set = this.servers.get(issueIid);
+    if (!set) return;
+    logger8.info("Stopping dev servers", { issueIid, ports: set.ports });
+    killProcess(set.backend, `backend #${issueIid}`);
+    killProcess(set.frontend, `frontend #${issueIid}`);
+    this.servers.delete(issueIid);
+  }
+  stopAll() {
+    for (const [iid] of this.servers) {
+      this.stopServers(iid);
+    }
+  }
+  getStatus(issueIid) {
+    const set = this.servers.get(issueIid);
+    if (!set) return { running: false };
+    return {
+      running: true,
+      ports: set.ports,
+      startedAt: set.startedAt
+    };
+  }
+  getRunningIssues() {
+    return [...this.servers.keys()];
+  }
+};
+function killProcess(proc, label) {
+  try {
+    if (proc.killed || proc.exitCode !== null) return;
+    proc.kill("SIGTERM");
+    setTimeout(() => {
+      if (!proc.killed && proc.exitCode === null) {
+        logger8.warn(`Force killing ${label}`);
+        proc.kill("SIGKILL");
+      }
+    }, 5e3);
+  } catch (err) {
+    logger8.warn(`Failed to kill ${label}`, { error: err.message });
+  }
+}
+
+// src/e2e/ScreenshotCollector.ts
+import fs7 from "fs";
+import path9 from "path";
+var logger9 = logger.child("ScreenshotCollector");
+var MAX_SCREENSHOTS = 20;
+function walkDir(dir, files = []) {
+  for (const entry of fs7.readdirSync(dir, { withFileTypes: true })) {
+    const full = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(full, files);
+    } else if (entry.isFile() && entry.name.endsWith(".png")) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+function collectScreenshots(workDir) {
+  const testResultsDir = path9.join(workDir, "frontend", "test-results");
+  if (!fs7.existsSync(testResultsDir)) {
+    logger9.debug("test-results directory not found", { dir: testResultsDir });
+    return [];
+  }
+  const pngFiles = walkDir(testResultsDir);
+  if (pngFiles.length === 0) {
+    logger9.debug("No screenshots found");
+    return [];
+  }
+  const screenshots = pngFiles.map((filePath) => {
+    const relative = path9.relative(testResultsDir, filePath);
+    const testName = relative.split(path9.sep)[0] || path9.basename(filePath, ".png");
+    return { filePath, testName };
+  });
+  if (screenshots.length > MAX_SCREENSHOTS) {
+    logger9.warn("Too many screenshots, truncating", {
+      total: screenshots.length,
+      max: MAX_SCREENSHOTS
+    });
+    return screenshots.slice(0, MAX_SCREENSHOTS);
+  }
+  logger9.info("Screenshots collected", { count: screenshots.length });
+  return screenshots;
+}
+
+// src/e2e/ScreenshotPublisher.ts
+var logger10 = logger.child("ScreenshotPublisher");
+function buildComment(uploaded, truncated) {
+  const lines = [t("screenshot.title"), ""];
+  for (const item of uploaded) {
+    lines.push(`### ${item.testName}`, "", item.markdown, "");
+  }
+  if (truncated) {
+    lines.push(t("screenshot.truncated"), "");
+  }
+  return lines.join("\n");
+}
+var ScreenshotPublisher = class {
+  constructor(gongfeng) {
+    this.gongfeng = gongfeng;
+  }
+  async publish(options) {
+    const { workDir, issueIid, issueId, mrIid } = options;
+    const screenshots = collectScreenshots(workDir);
+    if (screenshots.length === 0) {
+      logger10.info("No E2E screenshots to publish", { issueIid });
+      return;
+    }
+    const uploaded = await this.uploadAll(screenshots);
+    if (uploaded.length === 0) {
+      logger10.warn("All screenshot uploads failed", { issueIid });
+      return;
+    }
+    const truncated = screenshots.length >= 20;
+    const comment = buildComment(uploaded, truncated);
+    await this.postToIssue(issueId, comment);
+    if (mrIid) {
+      await this.postToMergeRequest(mrIid, comment);
+    }
+    logger10.info("E2E screenshots published", {
+      issueIid,
+      mrIid,
+      count: uploaded.length
+    });
+  }
+  async uploadAll(screenshots) {
+    const results = [];
+    for (const screenshot of screenshots) {
+      try {
+        const result = await this.gongfeng.uploadFile(screenshot.filePath);
+        results.push({
+          testName: screenshot.testName,
+          markdown: result.markdown
+        });
+      } catch (err) {
+        logger10.warn("Failed to upload screenshot", {
+          filePath: screenshot.filePath,
+          error: err.message
+        });
+      }
+    }
+    return results;
+  }
+  async postToIssue(issueId, comment) {
+    try {
+      await this.gongfeng.createIssueNote(issueId, comment);
+    } catch (err) {
+      logger10.warn("Failed to post screenshots to issue", {
+        issueId,
+        error: err.message
+      });
+    }
+  }
+  async postToMergeRequest(mrIid, comment) {
+    try {
+      await this.gongfeng.createMergeRequestNote(mrIid, comment);
+    } catch (err) {
+      logger10.warn("Failed to post screenshots to merge request", {
+        mrIid,
+        error: err.message
+      });
+    }
+  }
+};
+
+// src/orchestrator/PipelineOrchestrator.ts
+var execFileAsync2 = promisify2(execFile2);
+var logger11 = logger.child("PipelineOrchestrator");
+var PipelineOrchestrator = class {
+  config;
+  gongfeng;
+  mainGit;
+  aiRunner;
+  tracker;
+  supplementStore;
+  mainGitMutex = new AsyncMutex();
+  pipelineDef;
+  portAllocator;
+  devServerManager;
+  screenshotPublisher;
+  constructor(config, gongfeng, git, aiRunner, tracker, supplementStore) {
+    this.config = config;
+    this.gongfeng = gongfeng;
+    this.mainGit = git;
+    this.aiRunner = aiRunner;
+    this.tracker = tracker;
+    this.supplementStore = supplementStore;
+    const mode = resolvePipelineMode(config.ai.mode, config.pipeline?.mode === "auto" ? void 0 : config.pipeline?.mode);
+    this.pipelineDef = getPipelineDef(mode);
+    logger11.info("Pipeline mode resolved", { mode: this.pipelineDef.mode, aiMode: config.ai.mode });
+    this.portAllocator = new PortAllocator({
+      backendPortBase: config.e2e.backendPortBase,
+      frontendPortBase: config.e2e.frontendPortBase
+    });
+    this.devServerManager = new DevServerManager();
+    this.screenshotPublisher = new ScreenshotPublisher(gongfeng);
+    this.restorePortAllocations();
+  }
+  getPortAllocator() {
+    return this.portAllocator;
+  }
+  getDevServerManager() {
+    return this.devServerManager;
+  }
+  restorePortAllocations() {
+    for (const record of this.tracker.getAll()) {
+      if (record.ports) {
+        this.portAllocator.restore(record.issueIid, record.ports);
+      }
+    }
+  }
+  getPipelineDef() {
+    return this.pipelineDef;
+  }
+  emitProgress(issueIid, step, message) {
+    eventBus.emitTyped("pipeline:progress", { issueIid, step, message });
+  }
+  computeWorktreeContext(issueIid, branchName) {
+    const gitRootDir = path10.join(this.config.project.worktreeBaseDir, `issue-${issueIid}`);
+    const workDir = path10.join(gitRootDir, this.config.project.projectSubDir);
+    return { gitRootDir, workDir, branchName, issueIid };
+  }
+  async ensureWorktree(wtCtx) {
+    const worktrees = await this.mainGit.worktreeList();
+    if (worktrees.includes(wtCtx.gitRootDir)) {
+      logger11.info("Reusing existing worktree", { dir: wtCtx.gitRootDir });
+      return;
+    }
+    const localExists = await this.mainGit.branchExists(wtCtx.branchName);
+    if (localExists) {
+      await this.mainGit.worktreeAddExisting(wtCtx.gitRootDir, wtCtx.branchName);
+      return;
+    }
+    const remoteExists = await this.mainGit.remoteBranchExists(wtCtx.branchName);
+    if (remoteExists) {
+      await this.mainGit.worktreeAddTracking(wtCtx.gitRootDir, wtCtx.branchName);
+      return;
+    }
+    await this.mainGit.worktreeAdd(
+      wtCtx.gitRootDir,
+      wtCtx.branchName,
+      `origin/${this.config.project.baseBranch}`
+    );
+  }
+  async cleanupWorktree(wtCtx) {
+    try {
+      await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
+      logger11.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+    } catch (err) {
+      logger11.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+    }
+  }
+  async installDependencies(workDir) {
+    logger11.info("Installing dependencies in worktree", { workDir });
+    const seeded = await this.seedNodeModulesFromMain(workDir);
+    if (seeded) {
+      logger11.info("node_modules seeded from main repo \u2014 skipping pnpm install");
+      return;
+    }
+    try {
+      await execFileAsync2("pnpm", ["install", "--frozen-lockfile"], {
+        cwd: workDir,
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 3e5
+      });
+      logger11.info("Dependencies installed");
+    } catch (err) {
+      logger11.warn("pnpm install --frozen-lockfile failed, retrying with --ignore-scripts", {
+        error: err.message
+      });
+      try {
+        await execFileAsync2("pnpm", ["install", "--frozen-lockfile", "--ignore-scripts"], {
+          cwd: workDir,
+          maxBuffer: 10 * 1024 * 1024,
+          timeout: 3e5
+        });
+        logger11.info("Dependencies installed (scripts ignored)");
+      } catch (retryErr) {
+        logger11.warn("pnpm install also failed with --ignore-scripts", {
+          error: retryErr.message
+        });
+      }
+    }
+  }
+  async seedNodeModulesFromMain(workDir) {
+    const targetBin = path10.join(workDir, "node_modules", ".bin");
+    try {
+      await fs8.access(targetBin);
+      logger11.info("Worktree node_modules already complete (has .bin/), skipping seed");
+      return false;
+    } catch {
+    }
+    const sourceNM = path10.join(this.config.project.workDir, "node_modules");
+    const targetNM = path10.join(workDir, "node_modules");
+    try {
+      await fs8.access(sourceNM);
+    } catch {
+      logger11.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      return false;
+    }
+    logger11.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
+    try {
+      await execFileAsync2("rm", ["-rf", targetNM], { timeout: 6e4 });
+      await execFileAsync2("cp", ["-a", "--reflink=auto", sourceNM, targetNM], {
+        timeout: 12e4
+      });
+      logger11.info("node_modules seeded from main repo");
+      return true;
+    } catch (err) {
+      logger11.warn("Failed to seed node_modules from main repo", {
+        error: err.message
+      });
+      return false;
+    }
+  }
+  async restartIssue(issueIid) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new Error(`Issue ${issueIid} not found in tracker`);
+    const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
+    logger11.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    this.stopPreviewServers(issueIid);
+    try {
+      const deleted = await this.gongfeng.cleanupAgentNotes(record.issueId);
+      logger11.info("Agent notes cleaned up", { issueIid, deleted });
+    } catch (err) {
+      logger11.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+    }
+    await this.mainGitMutex.runExclusive(async () => {
+      await this.cleanupWorktree(wtCtx);
+      try {
+        await this.mainGit.deleteBranch(record.branchName);
+      } catch {
+      }
+      try {
+        await this.mainGit.deleteRemoteBranch(record.branchName);
+      } catch {
+      }
+    });
+    this.tracker.resetFull(issueIid);
+    logger11.info("Issue restarted", { issueIid });
+  }
+  retryFromPhase(issueIid, phase) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new Error(`Issue ${issueIid} not found in tracker`);
+    const issueDef = this.getIssueSpecificPipelineDef(record);
+    const spec = issueDef.phases.find((p) => p.name === phase);
+    if (!spec || spec.kind !== "ai") {
+      throw new Error(`Invalid phase for retry: ${phase}`);
+    }
+    logger11.info("Retrying issue from phase", { issueIid, phase });
+    this.tracker.resetToPhase(issueIid, phase, issueDef);
+  }
+  getIssueSpecificPipelineDef(record) {
+    if (record.pipelineMode === "plan-mode" || record.pipelineMode === "classic") {
+      return getPipelineDef(record.pipelineMode);
+    }
+    return this.pipelineDef;
+  }
+  async processIssue(issue) {
+    const branchName = `${this.config.project.branchPrefix}-${issue.iid}`;
+    const wtCtx = this.computeWorktreeContext(issue.iid, branchName);
+    logger11.info("Processing issue", { iid: issue.iid, title: issue.title, branchName, worktree: wtCtx.gitRootDir });
+    let record = this.tracker.get(issue.iid);
+    const isRetry = record?.state === "failed" /* Failed */;
+    if (!record) {
+      record = this.tracker.create({
+        issueId: issue.id,
+        issueIid: issue.iid,
+        issueTitle: issue.title,
+        state: "pending" /* Pending */,
+        branchName,
+        pipelineMode: this.pipelineDef.mode
+      });
+    }
+    if (!record.pipelineMode) {
+      this.tracker.updateState(issue.iid, record.state, { pipelineMode: this.pipelineDef.mode });
+      record.pipelineMode = this.pipelineDef.mode;
+    }
+    const issuePipelineDef = this.getIssueSpecificPipelineDef(record);
+    try {
+      await this.gongfeng.updateIssueLabels(issue.id, [
+        ...issue.labels.filter((l) => !l.startsWith("auto-finish:")),
+        "auto-finish:processing"
+      ]);
+    } catch (err) {
+      logger11.warn("Failed to update issue labels", { error: err.message });
+    }
+    try {
+      await this.gongfeng.createIssueNote(
+        issue.id,
+        isRetry ? t("orchestrator.retryComment") : t("orchestrator.startComment")
+      );
+    } catch {
+    }
+    const supplementText = this.supplementStore?.toPromptText(issue.iid) ?? "";
+    const ctx = {
+      issueIid: issue.iid,
+      issueId: issue.id,
+      issueTitle: issue.title,
+      issueDescription: issue.description || "",
+      branchName,
+      supplementText: supplementText || void 0,
+      pipelineMode: issuePipelineDef.mode
+    };
+    try {
+      await this.mainGitMutex.runExclusive(async () => {
+        this.emitProgress(issue.iid, "fetch", t("orchestrator.fetchProgress"));
+        await this.mainGit.fetch();
+        this.emitProgress(issue.iid, "worktree", t("orchestrator.worktreeProgress"));
+        await this.ensureWorktree(wtCtx);
+      });
+      if (record.state === "pending" /* Pending */) {
+        this.tracker.updateState(issue.iid, "branch_created" /* BranchCreated */);
+      }
+      this.emitProgress(issue.iid, "install", t("orchestrator.installProgress"));
+      await this.installDependencies(wtCtx.workDir);
+      this.emitProgress(issue.iid, "init_plan", t("orchestrator.initPlanProgress"));
+      const wtGit = new GitOperations(wtCtx.gitRootDir);
+      const wtPlan = new PlanPersistence(wtCtx.workDir, issue.iid);
+      wtPlan.ensureDir();
+      wtPlan.writeIssueMeta({
+        id: issue.id,
+        iid: issue.iid,
+        title: issue.title,
+        labels: issue.labels,
+        state: issue.state
+      });
+      const existingProgress = wtPlan.readProgress();
+      if (!existingProgress) {
+        wtPlan.writeProgress(
+          wtPlan.createInitialProgress(issue.id, issue.title, branchName, issuePipelineDef)
+        );
+      }
+      const startIdx = this.determineStartIndex(record.state, isRetry ? record.failedAtState : void 0, issuePipelineDef);
+      this.emitProgress(issue.iid, "phase_start", t("orchestrator.phaseStartProgress", { phase: issuePipelineDef.phases[startIdx]?.name ?? "start" }));
+      const needsDeployment = this.shouldDeployServers(issue.iid);
+      let serversStarted = false;
+      for (let i = startIdx; i < issuePipelineDef.phases.length; i++) {
+        const spec = issuePipelineDef.phases[i];
+        if (spec.kind === "gate") {
+          if (this.shouldAutoApprove(issue.labels)) {
+            logger11.info("Auto-approving review gate (matched autoApproveLabels)", {
+              iid: issue.iid,
+              labels: issue.labels,
+              autoApproveLabels: this.config.review.autoApproveLabels
+            });
+            if (spec.approvedState) {
+              this.tracker.updateState(issue.iid, spec.approvedState);
+            }
+            wtPlan.updatePhaseProgress(spec.name, "completed");
+            try {
+              await this.gongfeng.createIssueNote(
+                issue.id,
+                t("orchestrator.autoApproveComment")
+              );
+            } catch {
+            }
+            continue;
+          }
+          this.tracker.updateState(issue.iid, spec.startState);
+          wtPlan.updatePhaseProgress(spec.name, "in_progress");
+          eventBus.emitTyped("review:requested", { issueIid: issue.iid });
+          logger11.info("Review gate reached, pausing", { iid: issue.iid });
+          return;
+        }
+        const phase = createPhase(spec.name, this.aiRunner, wtGit, wtPlan, this.gongfeng, this.tracker, this.config);
+        await phase.execute(ctx);
+        if (needsDeployment && !serversStarted && this.isImplementDonePhase(spec.name, spec.doneState)) {
+          const ports = await this.startPreviewServers(wtCtx, issue);
+          if (ports) {
+            ctx.ports = ports;
+            wtCtx.ports = ports;
+            serversStarted = true;
+          }
+        }
+      }
+      this.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
+      const previewUrl = this.buildPreviewUrl(issue.iid);
+      const mrResult = await this.tryCreateMergeRequest(issue, branchName, wtCtx.workDir, previewUrl);
+      const mrUrl = mrResult?.url ?? null;
+      this.tracker.updateState(issue.iid, "completed" /* Completed */, mrUrl ? { mrUrl } : void 0);
+      try {
+        await this.gongfeng.updateIssueLabels(issue.id, [
+          ...issue.labels.filter((l) => !l.startsWith("auto-finish:") && l !== "auto-finish"),
+          "auto-finish:done"
+        ]);
+      } catch {
+      }
+      if (isE2eEnabledForIssue(issue.iid, this.tracker, this.config)) {
+        this.emitProgress(issue.iid, "screenshots", t("orchestrator.uploadScreenshotsProgress"));
+        try {
+          await this.screenshotPublisher.publish({
+            workDir: wtCtx.workDir,
+            issueIid: issue.iid,
+            issueId: issue.id,
+            mrIid: mrResult?.iid
+          });
+        } catch (err) {
+          logger11.warn("Failed to publish E2E screenshots", {
+            iid: issue.iid,
+            error: err.message
+          });
+        }
+      }
+      const mrSection = mrUrl ? t("orchestrator.mrSection", { mrUrl }) : t("orchestrator.mrFailSection");
+      const previewSection = previewUrl ? `
+\u{1F310} Preview: ${previewUrl}` : "";
+      try {
+        await this.gongfeng.createIssueNote(
+          issue.id,
+          t("orchestrator.completedComment", { branch: branchName, mrSection, previewSection })
+        );
+      } catch {
+      }
+      if (serversStarted && this.config.preview.keepAfterComplete) {
+        logger11.info("Preview servers kept running after completion", { iid: issue.iid });
+      } else {
+        this.stopPreviewServers(issue.iid);
+        await this.mainGitMutex.runExclusive(() => this.cleanupWorktree(wtCtx));
+      }
+      logger11.info("Issue processing completed", { iid: issue.iid });
+    } catch (err) {
+      const errorMsg = err.message;
+      logger11.error("Issue processing failed", { iid: issue.iid, error: errorMsg });
+      const currentRecord = this.tracker.get(issue.iid);
+      const failedAtState = currentRecord?.state || "pending" /* Pending */;
+      if (failedAtState !== "failed" /* Failed */) {
+        this.tracker.markFailed(issue.iid, errorMsg.slice(0, 500), failedAtState);
+      }
+      try {
+        await this.gongfeng.updateIssueLabels(issue.id, [
+          ...issue.labels.filter((l) => !l.startsWith("auto-finish:") && l !== "auto-finish"),
+          "auto-finish",
+          "auto-finish:failed"
+        ]);
+      } catch {
+      }
+      try {
+        await this.gongfeng.createIssueNote(
+          issue.id,
+          t("orchestrator.failedComment", { error: errorMsg })
+        );
+      } catch {
+      }
+      logger11.info("Worktree preserved for debugging", { dir: wtCtx.gitRootDir });
+      throw err;
+    }
+  }
+  async tryCreateMergeRequest(issue, branchName, workDir, previewUrl) {
+    try {
+      const supplement = this.supplementStore?.get(issue.iid);
+      const tapdId = supplement?.tapdId?.trim() || extractTapdId(issue.description || "");
+      const title = generateMRTitle(issue.iid, issue.title, tapdId);
+      let description = generateMRDescription({
+        issueIid: issue.iid,
+        issueTitle: issue.title,
+        issueDescription: issue.description || "",
+        branchName,
+        planDir: workDir
+      });
+      if (previewUrl) {
+        description += `
+
+## Preview Environment
+
+\u{1F310} ${previewUrl}`;
+      }
+      const mr = await this.gongfeng.createMergeRequest({
+        sourceBranch: branchName,
+        targetBranch: this.config.project.baseBranch,
+        title,
+        description
+      });
+      logger11.info("Merge request created successfully", {
+        iid: issue.iid,
+        mrIid: mr.iid,
+        mrUrl: mr.web_url
+      });
+      return { url: mr.web_url, iid: mr.iid };
+    } catch (err) {
+      const errorMsg = err.message;
+      logger11.warn("Failed to create merge request, trying to find existing one", {
+        iid: issue.iid,
+        error: errorMsg
+      });
+      if (errorMsg.includes("already exists")) {
+        return this.tryFindExistingMergeRequest(issue.iid, branchName);
+      }
+      return null;
+    }
+  }
+  async tryFindExistingMergeRequest(issueIid, branchName) {
+    try {
+      const existing = await this.gongfeng.findMergeRequestByBranch(
+        branchName,
+        this.config.project.baseBranch
+      );
+      if (existing) {
+        logger11.info("Found existing merge request", {
+          iid: issueIid,
+          mrIid: existing.iid,
+          mrUrl: existing.web_url
+        });
+        return { url: existing.web_url, iid: existing.iid };
+      }
+    } catch (findErr) {
+      logger11.warn("Failed to find existing merge request", {
+        iid: issueIid,
+        error: findErr.message
+      });
+    }
+    return null;
+  }
+  determineStartIndex(state, failedAtState, def) {
+    const target = failedAtState || state;
+    for (let i = def.phases.length - 1; i >= 0; i--) {
+      const spec = def.phases[i];
+      if (spec.kind === "gate" && spec.approvedState === target) {
+        return i + 1;
+      }
+      if (spec.startState === target || spec.doneState === target) {
+        return spec.doneState === target ? i + 1 : i;
+      }
+    }
+    return 0;
+  }
+  shouldDeployServers(issueIid) {
+    return isE2eEnabledForIssue(issueIid, this.tracker, this.config) || this.config.preview.enabled;
+  }
+  shouldAutoApprove(issueLabels) {
+    const autoLabels = this.config.review.autoApproveLabels;
+    if (!autoLabels.length) return false;
+    return issueLabels.some((l) => autoLabels.includes(l));
+  }
+  isImplementDonePhase(phaseName, doneState) {
+    return doneState === "implement_done" /* ImplementDone */ || doneState === "build_done" /* BuildDone */;
+  }
+  async startPreviewServers(wtCtx, issue) {
+    try {
+      this.emitProgress(issue.iid, "deploy", t("orchestrator.deployProgress"));
+      const ports = await this.portAllocator.allocate(issue.iid);
+      wtCtx.ports = ports;
+      this.tracker.updateState(issue.iid, this.tracker.get(issue.iid).state, {
+        ports,
+        previewStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await this.devServerManager.startServers(wtCtx, ports);
+      const previewUrl = this.buildPreviewUrl(issue.iid);
+      if (previewUrl) {
+        try {
+          await this.gongfeng.createIssueNote(
+            issue.id,
+            this.buildPreviewComment(ports, previewUrl)
+          );
+        } catch {
+        }
+      }
+      this.emitProgress(issue.iid, "deploy_done", t("orchestrator.deployDoneProgress", { url: previewUrl ?? "N/A" }));
+      eventBus.emitTyped("pipeline:progress", {
+        issueIid: issue.iid,
+        step: "preview_ready",
+        message: previewUrl ?? ""
+      });
+      return ports;
+    } catch (err) {
+      logger11.error("Failed to start preview servers", {
+        iid: issue.iid,
+        error: err.message
+      });
+      return null;
+    }
+  }
+  stopPreviewServers(issueIid) {
+    this.devServerManager.stopServers(issueIid);
+    this.portAllocator.release(issueIid);
+    const record = this.tracker.get(issueIid);
+    if (record?.ports) {
+      this.tracker.updateState(issueIid, record.state, {
+        ports: void 0,
+        previewStartedAt: void 0
+      });
+    }
+  }
+  getPreviewHost() {
+    if (this.config.preview.host) return this.config.preview.host;
+    const interfaces = os3.networkInterfaces();
+    for (const addrs of Object.values(interfaces)) {
+      for (const addr of addrs ?? []) {
+        if (addr.family === "IPv4" && !addr.internal) {
+          return addr.address;
+        }
+      }
+    }
+    return "localhost";
+  }
+  buildPreviewUrl(issueIid) {
+    const ports = this.portAllocator.getPortsForIssue(issueIid);
+    if (!ports) return null;
+    const host = this.getPreviewHost();
+    return `https://${host}:${ports.frontendPort}`;
+  }
+  buildPreviewComment(ports, previewUrl) {
+    const host = this.getPreviewHost();
+    const ttlHours = Math.round(this.config.preview.ttlMs / (60 * 60 * 1e3));
+    return [
+      t("orchestrator.previewComment.title"),
+      "",
+      t("orchestrator.previewComment.tableHeader"),
+      t("orchestrator.previewComment.tableSep"),
+      `| ${t("orchestrator.previewComment.frontend")} | ${previewUrl} |`,
+      `| ${t("orchestrator.previewComment.backendApi")} | http://${host}:${ports.backendPort}/api |`,
+      "",
+      t("orchestrator.previewComment.hint"),
+      t("orchestrator.previewComment.expiry", { hours: ttlHours })
+    ].join("\n");
+  }
+};
+
+// src/services/BrainstormService.ts
+import { randomUUID } from "crypto";
+
+// src/prompts/brainstorm-templates.ts
+function buildGeneratePrompt(transcript) {
+  return `\u4F60\u662F\u4E00\u4E2A\u8D44\u6DF1\u8F6F\u4EF6\u67B6\u6784\u5E08\u3002\u4E0B\u9762\u662F\u7528\u6237\u901A\u8FC7\u8BED\u97F3\u503E\u5012\u7684\u4E00\u6BB5\u5173\u4E8E\u8F6F\u4EF6\u9700\u6C42\u7684\u60F3\u6CD5\uFF0C\u5185\u5BB9\u53EF\u80FD\u4E0D\u8FDE\u8D2F\u3001\u6709\u91CD\u590D\u3001\u5939\u6742\u8BED\u6C14\u8BCD\u2014\u2014\u8FD9\u662F\u6B63\u5E38\u7684\u3002
+
+**\u6838\u5FC3\u539F\u5219\u2014\u2014\u7B2C\u4E00\u6027\u539F\u7406\u601D\u8003\uFF1A**
+- \u4E0D\u8981\u5047\u8BBE\u7528\u6237\u975E\u5E38\u6E05\u695A\u81EA\u5DF1\u60F3\u8981\u4EC0\u4E48\u4EE5\u53CA\u8BE5\u600E\u4E48\u5F97\u5230\u3002\u7528\u6237\u5F80\u5F80\u53EA\u6709\u6A21\u7CCA\u7684\u610F\u56FE\uFF0C\u4F60\u7684\u5DE5\u4F5C\u662F\u4ECE\u539F\u59CB\u9700\u6C42\u548C\u5E95\u5C42\u95EE\u9898\u51FA\u53D1\uFF0C\u5E2E\u4ED6\u5398\u6E05\u771F\u6B63\u7684\u76EE\u6807\u3002
+- \u5982\u679C\u7528\u6237\u7684\u52A8\u673A\u548C\u76EE\u6807\u4E0D\u6E05\u6670\uFF0C\u5728 SDD \u4E2D\u660E\u786E\u6807\u6CE8 [\u5F85\u6F84\u6E05]\uFF0C\u8BF4\u660E\u4E3A\u4EC0\u4E48\u8FD9\u91CC\u9700\u8981\u8FDB\u4E00\u6B65\u8BA8\u8BBA\uFF0C\u5E76\u7ED9\u51FA\u4F60\u7684\u7406\u89E3\u548C\u5EFA\u8BAE\u3002
+- \u5982\u679C\u76EE\u6807\u6E05\u6670\u4F46\u7528\u6237\u63CF\u8FF0\u7684\u8DEF\u5F84\u4E0D\u662F\u6700\u4F18\u89E3\uFF0C\u6307\u51FA\u6765\uFF0C\u5E76\u5EFA\u8BAE\u66F4\u597D\u7684\u65B9\u6848\u3002\u7528 [\u66F4\u4F18\u8DEF\u5F84] \u6807\u6CE8\u8FD9\u7C7B\u5EFA\u8BAE\u3002
+- \u56DE\u5230\u95EE\u9898\u7684\u672C\u8D28\uFF1A\u5148\u95EE"\u7528\u6237\u771F\u6B63\u8981\u89E3\u51B3\u7684\u95EE\u9898\u662F\u4EC0\u4E48"\uFF0C\u518D\u60F3"\u6700\u7B80\u5355\u6709\u6548\u7684\u65B9\u6848\u662F\u4EC0\u4E48"\uFF0C\u907F\u514D\u8FC7\u5EA6\u8BBE\u8BA1\u3002
+
+\u8BF7\u4F60\uFF1A
+1. \u9996\u5148\u4F7F\u7528 Read\u3001Grep\u3001Glob \u7B49\u5DE5\u5177\u6D4F\u89C8\u9879\u76EE\u4EE3\u7801\u5E93\uFF0C\u4E86\u89E3\u73B0\u6709\u67B6\u6784\u3001\u6280\u672F\u6808\u548C\u4EE3\u7801\u98CE\u683C
+2. \u5206\u6790\u7528\u6237\u60F3\u6CD5\u7684\u5E95\u5C42\u52A8\u673A\u2014\u2014\u4ED6\u8981\u89E3\u51B3\u4EC0\u4E48\u95EE\u9898\uFF1F\u4E3A\u4EC0\u4E48\u8981\u89E3\u51B3\uFF1F\u73B0\u6709\u65B9\u6848\u4E3A\u4EC0\u4E48\u4E0D\u591F\uFF1F
+3. \u57FA\u4E8E\u5BF9\u4EE3\u7801\u5E93\u7684\u7406\u89E3\u548C\u7528\u6237\u7684\u771F\u5B9E\u9700\u6C42\uFF0C\u751F\u6210\u4E00\u4EFD\u7ED3\u6784\u5316\u7684\u8F6F\u4EF6\u8BBE\u8BA1\u6587\u6863 (SDD)
+
+SDD \u8F93\u51FA\u8981\u6C42\uFF1A
+- \u4F7F\u7528 Markdown \u683C\u5F0F
+- \u5305\u542B\u4EE5\u4E0B\u7AE0\u8282\uFF1A\u6982\u8FF0\u3001\u76EE\u6807\u4E0E\u8303\u56F4\u3001\u6280\u672F\u65B9\u6848\uFF08\u542B\u67B6\u6784\u8BBE\u8BA1\u3001\u6570\u636E\u6A21\u578B\u3001\u63A5\u53E3\u8BBE\u8BA1\uFF09\u3001\u5B9E\u65BD\u8BA1\u5212\u3001\u98CE\u9669\u4E0E\u7EA6\u675F
+- \u5728"\u6982\u8FF0"\u7AE0\u8282\u4E2D\uFF0C\u5148\u7528 2-3 \u53E5\u8BDD\u9610\u660E\u4F60\u7406\u89E3\u7684\u7528\u6237\u6838\u5FC3\u8BC9\u6C42\u548C\u5E95\u5C42\u52A8\u673A\uFF0C\u518D\u5C55\u5F00\u65B9\u6848
+- \u7ED3\u5408\u9879\u76EE\u73B0\u6709\u4EE3\u7801\u7ED3\u6784\u7ED9\u51FA\u5177\u4F53\u7684\u6587\u4EF6\u8DEF\u5F84\u548C\u6A21\u5757\u5EFA\u8BAE
+- \u5982\u679C\u7528\u6237\u7684\u60F3\u6CD5\u4E2D\u6709\u6A21\u7CCA\u6216\u77DB\u76FE\u7684\u5730\u65B9\uFF0C\u5148\u505A\u5408\u7406\u63A8\u65AD\u5E76\u6807\u6CE8 [\u63A8\u65AD]
+- \u5982\u679C\u53D1\u73B0\u66F4\u77ED\u7684\u5B9E\u73B0\u8DEF\u5F84\u6216\u66F4\u7B80\u6D01\u7684\u65B9\u6848\uFF0C\u7528 [\u66F4\u4F18\u8DEF\u5F84] \u6807\u6CE8\u5E76\u8BF4\u660E\u7406\u7531
+
+\u7528\u6237\u7684\u60F3\u6CD5\u539F\u6587\uFF1A
+---
+${transcript}
+---
+
+\u8BF7\u76F4\u63A5\u8F93\u51FA\u5B8C\u6574\u7684 SDD \u6587\u6863\u5185\u5BB9\uFF08\u7EAF Markdown \u6587\u672C\uFF09\uFF0C\u4E0D\u8981\u8F93\u51FA\u4EFB\u4F55\u591A\u4F59\u89E3\u91CA\u3002`;
+}
+function buildReviewPrompt(sdd, round) {
+  return `\u4F60\u662F\u4E00\u4E2A\u4E25\u8C28\u7684\u6280\u672F\u8BC4\u5BA1\u4E13\u5BB6\u3002\u8BF7\u4F60\u4ED4\u7EC6\u5BA1\u67E5\u4EE5\u4E0B\u8F6F\u4EF6\u8BBE\u8BA1\u6587\u6863 (SDD)\u3002
+
+\u8BF7\u4F60\uFF1A
+1. \u4F7F\u7528 Read\u3001Grep\u3001Glob \u7B49\u5DE5\u5177\u6D4F\u89C8\u9879\u76EE\u4EE3\u7801\u5E93\uFF0C\u9A8C\u8BC1 SDD \u4E2D\u63D0\u5230\u7684\u6A21\u5757\u3001\u8DEF\u5F84\u3001\u63A5\u53E3\u662F\u5426\u4E0E\u73B0\u6709\u4EE3\u7801\u4E00\u81F4
+2. \u7528\u7B2C\u4E00\u6027\u539F\u7406\u5BA1\u89C6\uFF1A\u9700\u6C42\u672C\u8EAB\u662F\u5426\u5408\u7406\uFF1F\u76EE\u6807\u662F\u5426\u6E05\u6670\uFF1F\u662F\u5426\u5B58\u5728\u66F4\u7B80\u5355\u76F4\u63A5\u7684\u5B9E\u73B0\u8DEF\u5F84\u88AB\u5FFD\u7565\u4E86\uFF1F
+3. \u7AD9\u5728\u5B9E\u9645\u5B9E\u65BD\u8005\u7684\u89D2\u5EA6\uFF0C\u627E\u51FA\u6587\u6863\u4E2D**\u672A\u8BF4\u6E05\u695A\u3001\u542B\u7CCA\u4E0D\u6E05\u3001\u7F3A\u5931\u3001\u6216\u53EF\u80FD\u5BFC\u81F4\u5B9E\u65BD\u56F0\u96BE**\u7684\u5730\u65B9
+4. \u5217\u51FA\u6070\u597D 20 \u4E2A\u95EE\u9898\uFF0C\u6309\u4E25\u91CD\u7A0B\u5EA6\u6392\u5E8F\uFF08\u6700\u91CD\u8981\u7684\u5728\u524D\uFF09
+
+\u8FD9\u662F\u7B2C ${round} \u8F6E\u5BA1\u67E5${round > 1 ? "\uFF0C\u8BF7\u5173\u6CE8\u6BD4\u4E4B\u524D\u66F4\u7EC6\u7C92\u5EA6\u7684\u95EE\u9898\uFF0C\u7279\u522B\u662F\u8FB9\u754C\u6761\u4EF6\u3001\u9519\u8BEF\u5904\u7406\u3001\u6027\u80FD\u3001\u5B89\u5168\u7B49\u65B9\u9762" : ""}\u3002
+
+SDD \u6587\u6863\uFF1A
+---
+${sdd}
+---
+
+\u8F93\u51FA\u683C\u5F0F\u8981\u6C42\uFF1A
+\u6BCF\u4E2A\u95EE\u9898\u7528\u7F16\u53F7\u5217\u51FA\uFF0C\u683C\u5F0F\u4E3A\uFF1A
+1. [\u7C7B\u522B] \u95EE\u9898\u63CF\u8FF0
+
+\u7C7B\u522B\u5305\u62EC\uFF1A[\u7F3A\u5931]\u3001[\u6A21\u7CCA]\u3001[\u77DB\u76FE]\u3001[\u98CE\u9669]\u3001[\u5EFA\u8BAE]\u3001[\u52A8\u673A]\uFF08\u9700\u6C42\u52A8\u673A\u6216\u76EE\u6807\u672C\u8EAB\u9700\u8981\u8D28\u7591\u65F6\uFF09\u3001[\u8FC7\u5EA6\u8BBE\u8BA1]\uFF08\u5B58\u5728\u66F4\u7B80\u5355\u8DEF\u5F84\u65F6\uFF09
+
+\u8BF7\u76F4\u63A5\u8F93\u51FA 20 \u4E2A\u95EE\u9898\uFF0C\u4E0D\u8981\u8F93\u51FA\u591A\u4F59\u89E3\u91CA\u3002`;
+}
+function buildRefinePrompt(questions) {
+  return `\u4E00\u4F4D\u6280\u672F\u8BC4\u5BA1\u4E13\u5BB6\u5BA1\u67E5\u4E86\u4F60\u4E4B\u524D\u751F\u6210\u7684 SDD\uFF0C\u53D1\u73B0\u4E86\u4EE5\u4E0B\u95EE\u9898\uFF1A
+
+${questions}
+
+\u8BF7\u4F60\uFF1A
+1. \u9010\u4E00\u56DE\u5E94\u6BCF\u4E2A\u95EE\u9898\uFF0C\u5728 SDD \u4E2D\u4FEE\u590D\u6216\u8865\u5145\u5BF9\u5E94\u5185\u5BB9
+2. \u5982\u679C\u67D0\u4E2A\u95EE\u9898\u9700\u8981\u67E5\u770B\u4EE3\u7801\u6765\u56DE\u7B54\uFF0C\u8BF7\u4F7F\u7528 Read\u3001Grep\u3001Glob \u7B49\u5DE5\u5177\u67E5\u770B\u9879\u76EE\u4EE3\u7801\u540E\u518D\u4F5C\u7B54
+3. \u5BF9\u65E0\u6CD5\u786E\u5B9A\u7684\u95EE\u9898\uFF0C\u7ED9\u51FA\u591A\u79CD\u65B9\u6848\u5E76\u6807\u6CE8\u63A8\u8350\u65B9\u6848
+
+\u8BF7\u8F93\u51FA\u4FEE\u590D\u540E\u7684\u5B8C\u6574 SDD \u6587\u6863\uFF08\u7EAF Markdown \u6587\u672C\uFF09\uFF0C\u4E0D\u8981\u8F93\u51FA\u5BF9\u6BD4\u8BF4\u660E\uFF0C\u76F4\u63A5\u7ED9\u51FA\u6700\u65B0\u7248\u672C\u3002`;
+}
+
+// src/services/BrainstormService.ts
+var logger12 = logger.child("Brainstorm");
+function agentConfigToAIConfig(agentCfg, timeoutMs) {
+  return {
+    mode: agentCfg.mode,
+    binary: agentCfg.binary,
+    phaseTimeoutMs: timeoutMs,
+    nvmNodeVersion: agentCfg.nvmNodeVersion,
+    model: agentCfg.model
+  };
+}
+var BrainstormService = class {
+  sessions = /* @__PURE__ */ new Map();
+  generatorRunner;
+  reviewerRunner;
+  config;
+  workDir;
+  constructor(config) {
+    this.config = config.brainstorm;
+    this.workDir = config.project.workDir;
+    this.generatorRunner = createAIRunner(
+      agentConfigToAIConfig(this.config.generator, this.config.timeoutMs)
+    );
+    this.reviewerRunner = createAIRunner(
+      agentConfigToAIConfig(this.config.reviewer, this.config.timeoutMs)
+    );
+  }
+  createSession(transcript) {
+    const session = {
+      id: randomUUID(),
+      transcript,
+      currentSdd: "",
+      rounds: [],
+      status: "idle",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.sessions.set(session.id, session);
+    logger12.info("Created brainstorm session", { sessionId: session.id });
+    return session;
+  }
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+  async generate(sessionId, onEvent) {
+    const session = this.requireSession(sessionId);
+    session.status = "generating";
+    logger12.info("Generating SDD", { sessionId });
+    const prompt = buildGeneratePrompt(session.transcript);
+    const result = await this.generatorRunner.run({
+      prompt,
+      workDir: this.workDir,
+      timeoutMs: this.config.timeoutMs,
+      onStreamEvent: (evt) => {
+        onEvent?.({ type: "sdd:chunk", data: evt });
+      }
+    });
+    if (result.success) {
+      session.currentSdd = result.output;
+      session.generatorSessionId = result.sessionId;
+      session.status = "idle";
+      onEvent?.({ type: "sdd:complete", data: { sdd: result.output } });
+    } else {
+      session.status = "error";
+      session.error = result.output;
+      onEvent?.({ type: "error", data: { message: result.output } });
+    }
+    return result;
+  }
+  async review(sessionId, onEvent) {
+    const session = this.requireSession(sessionId);
+    const roundNum = session.rounds.length + 1;
+    session.status = "reviewing";
+    logger12.info("Reviewing SDD", { sessionId, round: roundNum });
+    onEvent?.({ type: "round:start", data: { round: roundNum, phase: "review" }, round: roundNum });
+    const prompt = buildReviewPrompt(session.currentSdd, roundNum);
+    const result = await this.reviewerRunner.run({
+      prompt,
+      workDir: this.workDir,
+      timeoutMs: this.config.timeoutMs,
+      onStreamEvent: (evt) => {
+        onEvent?.({ type: "review:chunk", data: evt, round: roundNum });
+      }
+    });
+    if (result.success) {
+      session.rounds.push({
+        round: roundNum,
+        questions: result.output,
+        refinedSdd: ""
+      });
+      session.status = "idle";
+      onEvent?.({ type: "review:complete", data: { round: roundNum, questions: result.output }, round: roundNum });
+    } else {
+      session.status = "error";
+      session.error = result.output;
+      onEvent?.({ type: "error", data: { message: result.output, round: roundNum }, round: roundNum });
+    }
+    return result;
+  }
+  async refine(sessionId, onEvent) {
+    const session = this.requireSession(sessionId);
+    const currentRound = session.rounds[session.rounds.length - 1];
+    if (!currentRound) {
+      throw new Error("No review round to refine from");
+    }
+    session.status = "refining";
+    logger12.info("Refining SDD", { sessionId, round: currentRound.round });
+    const prompt = buildRefinePrompt(currentRound.questions);
+    const result = await this.generatorRunner.run({
+      prompt,
+      workDir: this.workDir,
+      timeoutMs: this.config.timeoutMs,
+      sessionId: session.generatorSessionId,
+      continueSession: !!session.generatorSessionId,
+      onStreamEvent: (evt) => {
+        onEvent?.({ type: "sdd:chunk", data: evt, round: currentRound.round });
+      }
+    });
+    if (result.success) {
+      currentRound.refinedSdd = result.output;
+      session.currentSdd = result.output;
+      session.generatorSessionId = result.sessionId ?? session.generatorSessionId;
+      session.status = "idle";
+      onEvent?.({
+        type: "round:complete",
+        data: { round: currentRound.round, sdd: result.output },
+        round: currentRound.round
+      });
+    } else {
+      session.status = "error";
+      session.error = result.output;
+      onEvent?.({ type: "error", data: { message: result.output, round: currentRound.round }, round: currentRound.round });
+    }
+    return result;
+  }
+  async autoRefine(sessionId, rounds, onEvent) {
+    const maxRounds = Math.min(rounds ?? this.config.maxRefinementRounds, this.config.maxRefinementRounds);
+    const session = this.requireSession(sessionId);
+    if (!session.currentSdd) {
+      await this.generate(sessionId, onEvent);
+      if (session.status === "error") return;
+    }
+    for (let i = 0; i < maxRounds; i++) {
+      const reviewResult = await this.review(sessionId, onEvent);
+      if (!reviewResult.success) break;
+      const refineResult = await this.refine(sessionId, onEvent);
+      if (!refineResult.success) break;
+    }
+    if (session.status !== "error") {
+      session.status = "done";
+    }
+  }
+  requireSession(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new Error(`Brainstorm session not found: ${id}`);
+    }
+    return session;
+  }
+};
+
+export {
+  loadConfig,
+  Logger,
+  logger,
+  AGENT_NOTE_MARKER,
+  GongfengClient,
+  GitOperations,
+  BaseAIRunner,
+  ClaudeInternalRunner,
+  CodebuddyRunner,
+  CursorAgentRunner,
+  createAIRunner,
+  CLASSIC_PIPELINE,
+  PLAN_MODE_PIPELINE,
+  resolvePipelineMode,
+  getPipelineDef,
+  collectStateLabels,
+  eventBus,
+  IssueTracker,
+  PlanPersistence,
+  getNoteSyncEnabled,
+  setNoteSyncOverride,
+  isNoteSyncEnabledForIssue,
+  BasePhase,
+  getE2eEnabled,
+  setE2eOverride,
+  validatePhaseRegistry,
+  AsyncMutex,
+  PipelineOrchestrator,
+  BrainstormService
+};
+//# sourceMappingURL=chunk-TBIEB3JY.js.map