@xdevops/issue-auto-finish 1.0.1 → 1.0.3

package/dist/{chunk-TBIEB3JY.js → chunk-N5YK6YVI.js}

@@ -1,220 +1,23 @@
+import {
+  getProjectKnowledge
+} from "./chunk-3JUHZGX5.js";
 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();
+} from "./chunk-JFYAXNNS.js";
+import {
+  KNOWLEDGE_DEFAULTS
+} from "./chunk-5VUB3UUK.js";
+import {
+  createAIRunner,
+  isShuttingDown
+} from "./chunk-SWG2Y7YX.js";
+import {
+  logger
+} from "./chunk-TZ6C7HL5.js";
 
 // src/clients/GongfengClient.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs from "fs";
+import path 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 -->";
@@ -231,8 +34,8 @@ var GongfengClient = class {
     const encoded = encodeURIComponent(this.projectPath);
     return `${this.apiUrl}/api/v3/projects/${encoded}`;
   }
-  async requestRaw(path11, options = {}) {
-    const url = `${this.projectApiBase}${path11}`;
+  async requestRaw(path10, options = {}) {
+    const url = `${this.projectApiBase}${path10}`;
     logger2.debug("API request", { method: options.method || "GET", url });
     const resp = await fetch(url, {
       ...options,
@@ -248,8 +51,8 @@ var GongfengClient = class {
     }
     return resp;
   }
-  async request(path11, options = {}) {
-    const resp = await this.requestRaw(path11, options);
+  async request(path10, options = {}) {
+    const resp = await this.requestRaw(path10, options);
     return resp.json();
   }
   async createIssue(title, description, labels) {
@@ -342,8 +145,8 @@ var GongfengClient = class {
     return `${this.apiUrl}/${this.projectPath}/merge_requests/${mrIid}`;
   }
   async uploadFile(filePath) {
-    const fileData = fs2.readFileSync(filePath);
-    const fileName = path2.basename(filePath);
+    const fileData = fs.readFileSync(filePath);
+    const fileName = path.basename(filePath);
     const mimeType = fileName.endsWith(".png") ? "image/png" : "application/octet-stream";
     const blob = new Blob([fileData], { type: mimeType });
     const formData = new FormData();
@@ -418,6 +221,13 @@ var GongfengClient = class {
     }
     return agentNotes.length;
   }
+  async getMergeRequestDetail(mrIid) {
+    const mr = await this.request(`/merge_requests/${mrIid}`);
+    if (!mr.web_url && mr.iid) {
+      mr.web_url = this.buildMergeRequestUrl(mr.iid);
+    }
+    return mr;
+  }
   async addLabel(issueId, label) {
     const issue = await this.getIssueDetail(issueId);
     if (issue.labels.includes(label)) {
@@ -556,319 +366,51 @@ var GitOperations = class {
       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();
-    });
+  async getConflictFiles() {
+    const output = await this.exec(["diff", "--name-only", "--diff-filter=U"]);
+    if (!output) return [];
+    return output.split("\n").filter(Boolean);
   }
-  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 };
-    }
+  async rebase(targetRef) {
     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;
+      await this.exec(["rebase", targetRef]);
+      return { success: true, conflictFiles: [] };
+    } catch (err) {
+      const msg = err.message || "";
+      if (msg.includes("CONFLICT") || msg.includes("could not apply")) {
+        const conflictFiles = await this.getConflictFiles();
+        return { success: false, conflictFiles };
       }
+      throw err;
     }
-    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
+  async rebaseContinue() {
+    try {
+      await this.exec(["-c", "core.editor=true", "rebase", "--continue"]);
+      return { done: true, conflictFiles: [] };
+    } catch (err) {
+      const msg = err.message || "";
+      if (msg.includes("CONFLICT") || msg.includes("could not apply")) {
+        const conflictFiles = await this.getConflictFiles();
+        return { done: false, conflictFiles };
       }
-    };
-  }
-};
-
-// 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);
+      throw err;
     }
-    return args;
   }
-  getSpawnOptions(options) {
-    return {
-      cwd: options.workDir,
-      env: {
-        ...process.env,
-        NODE_VERSION: this.nvmNodeVersion
-      }
-    };
+  async rebaseAbort() {
+    await this.exec(["rebase", "--abort"]);
+    logger3.info("Rebase aborted");
   }
-};
-
-// 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;
+  async isRebaseInProgress() {
+    const status = await this.exec(["status"]);
+    return status.includes("rebase in progress");
   }
-  getSpawnOptions(_options) {
-    return {
-      cwd: process.cwd(),
-      env: {
-        ...process.env,
-        NODE_VERSION: this.nvmNodeVersion
-      }
-    };
+  async forcePush(branch) {
+    await this.exec(["push", "--no-verify", "--force-with-lease", "-u", "origin", branch]);
+    logger3.info("Force pushed", { branch });
   }
 };
 
-// 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",
@@ -998,35 +540,35 @@ var EventBusImpl = class extends EventEmitter {
 var eventBus = new EventBusImpl();
 
 // src/tracker/IssueTracker.ts
-import fs3 from "fs";
-import path3 from "path";
-var logger5 = logger.child("IssueTracker");
+import fs2 from "fs";
+import path2 from "path";
+var logger4 = logger.child("IssueTracker");
 var IssueTracker = class _IssueTracker {
   filePath;
   data;
   constructor(dataDir) {
-    this.filePath = path3.join(dataDir, "tracker.json");
+    this.filePath = path2.join(dataDir, "tracker.json");
     this.data = this.load();
   }
   load() {
     try {
-      if (fs3.existsSync(this.filePath)) {
-        const raw = fs3.readFileSync(this.filePath, "utf-8");
+      if (fs2.existsSync(this.filePath)) {
+        const raw = fs2.readFileSync(this.filePath, "utf-8");
         return JSON.parse(raw);
       }
     } catch (err) {
-      logger5.error("Failed to load tracker data", { error: err.message });
+      logger4.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 dir = path2.dirname(this.filePath);
+    if (!fs2.existsSync(dir)) {
+      fs2.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);
+    const tmpPath = path2.join(dir, `.tracker-${process.pid}-${Date.now()}.tmp`);
+    fs2.writeFileSync(tmpPath, JSON.stringify(this.data, null, 2), "utf-8");
+    fs2.renameSync(tmpPath, this.filePath);
   }
   key(issueIid) {
     return String(issueIid);
@@ -1044,7 +586,7 @@ var IssueTracker = class _IssueTracker {
     };
     this.data.issues[this.key(record.issueIid)] = full;
     this.save();
-    logger5.info("Issue tracked", { issueIid: record.issueIid, state: record.state });
+    logger4.info("Issue tracked", { issueIid: record.issueIid, state: record.state });
     eventBus.emitTyped("issue:created", full);
     return full;
   }
@@ -1063,7 +605,7 @@ var IssueTracker = class _IssueTracker {
       Object.assign(record, extra);
     }
     this.save();
-    logger5.info("Issue state updated", { issueIid, state });
+    logger4.info("Issue state updated", { issueIid, state });
     eventBus.emitTyped("issue:stateChanged", { issueIid, state, record });
   }
   markFailed(issueIid, error, failedAtState) {
@@ -1075,7 +617,7 @@ var IssueTracker = class _IssueTracker {
     record.attempts += 1;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
-    logger5.warn("Issue marked as failed", { issueIid, error, failedAtState, attempts: record.attempts });
+    logger4.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 */]);
@@ -1142,7 +684,7 @@ var IssueTracker = class _IssueTracker {
     record.lastError = void 0;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
-    logger5.info("Issue fully reset", { issueIid });
+    logger4.info("Issue fully reset", { issueIid });
     eventBus.emitTyped("issue:restarted", { issueIid, record });
     return true;
   }
@@ -1157,7 +699,7 @@ var IssueTracker = class _IssueTracker {
     record.lastError = void 0;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
-    logger5.info("Issue reset to phase", { issueIid, phase, state: targetState });
+    logger4.info("Issue reset to phase", { issueIid, phase, state: targetState });
     eventBus.emitTyped("issue:retryFromPhase", { issueIid, phase, record });
     return true;
   }
@@ -1169,7 +711,7 @@ var IssueTracker = class _IssueTracker {
     record.lastError = void 0;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
-    logger5.info("Issue reset for retry", { issueIid, restoreState });
+    logger4.info("Issue reset for retry", { issueIid, restoreState });
     eventBus.emitTyped("issue:resetForRetry", { issueIid, restoreState, record });
     return true;
   }
@@ -1179,16 +721,53 @@ var IssueTracker = class _IssueTracker {
     const record = this.data.issues[key];
     delete this.data.issues[key];
     this.save();
-    logger5.info("Issue deleted from tracker", { issueIid });
+    logger4.info("Issue deleted from tracker", { issueIid });
     eventBus.emitTyped("issue:deleted", { issueIid, record });
     return true;
   }
+  static IN_PROGRESS_STATES = /* @__PURE__ */ new Set([
+    "analyzing" /* Analyzing */,
+    "designing" /* Designing */,
+    "implementing" /* Implementing */,
+    "verifying" /* Verifying */,
+    "planning" /* Planning */,
+    "building" /* Building */,
+    "resolving_conflict" /* ResolvingConflict */
+  ]);
+  recoverInterruptedIssues() {
+    let count = 0;
+    for (const record of Object.values(this.data.issues)) {
+      if (_IssueTracker.IN_PROGRESS_STATES.has(record.state)) {
+        logger4.warn("Recovering interrupted issue", {
+          issueIid: record.issueIid,
+          state: record.state
+        });
+        record.failedAtState = record.state;
+        record.state = "failed" /* Failed */;
+        record.lastError = "Interrupted by service restart";
+        record.attempts += 1;
+        record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        count++;
+        eventBus.emitTyped("issue:failed", {
+          issueIid: record.issueIid,
+          error: "Interrupted by service restart",
+          failedAtState: record.failedAtState,
+          record
+        });
+      }
+    }
+    if (count > 0) {
+      this.save();
+      logger4.info("Recovered interrupted issues", { count });
+    }
+    return count;
+  }
 };
 
 // src/persistence/PlanPersistence.ts
-import fs4 from "fs";
-import path4 from "path";
-var logger6 = logger.child("PlanPersistence");
+import fs3 from "fs";
+import path3 from "path";
+var logger5 = logger.child("PlanPersistence");
 var PLAN_DIR = ".claude-plan";
 var PlanPersistence = class _PlanPersistence {
   workDir;
@@ -1201,57 +780,57 @@ var PlanPersistence = class _PlanPersistence {
     return this.workDir;
   }
   get planDir() {
-    return path4.join(this.workDir, PLAN_DIR, `issue-${this.issueIid}`);
+    return path3.join(this.workDir, PLAN_DIR, `issue-${this.issueIid}`);
   }
   ensureDir() {
-    if (!fs4.existsSync(this.planDir)) {
-      fs4.mkdirSync(this.planDir, { recursive: true });
+    if (!fs3.existsSync(this.planDir)) {
+      fs3.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");
+    const filePath = path3.join(this.planDir, "issue-meta.json");
+    fs3.writeFileSync(filePath, JSON.stringify(meta, null, 2), "utf-8");
+    logger5.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 });
+    const filePath = path3.join(this.planDir, "progress.json");
+    fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    logger5.debug("Progress written", { currentPhase: data.currentPhase });
   }
   readProgress() {
-    const filePath = path4.join(this.planDir, "progress.json");
-    if (!fs4.existsSync(filePath)) return null;
+    const filePath = path3.join(this.planDir, "progress.json");
+    if (!fs3.existsSync(filePath)) return null;
     try {
-      return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs3.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");
+    fs3.writeFileSync(path3.join(this.planDir, "01-analysis.md"), content, "utf-8");
+    logger5.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");
+    fs3.writeFileSync(path3.join(this.planDir, "02-design.md"), content, "utf-8");
+    logger5.info("Design document written");
   }
   writeTodolist(content) {
     this.ensureDir();
-    fs4.writeFileSync(path4.join(this.planDir, "03-todolist.md"), content, "utf-8");
-    logger6.info("Todolist written");
+    fs3.writeFileSync(path3.join(this.planDir, "03-todolist.md"), content, "utf-8");
+    logger5.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 });
+    fs3.writeFileSync(path3.join(this.planDir, filename), content, "utf-8");
+    logger5.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));
+    if (!fs3.existsSync(this.planDir)) return [];
+    return fs3.readdirSync(this.planDir).map((f) => path3.join(PLAN_DIR, `issue-${this.issueIid}`, f));
   }
   createInitialProgress(issueId, issueTitle, branchName, def) {
     const pending = { status: "pending" };
@@ -1284,8 +863,8 @@ var PlanPersistence = class _PlanPersistence {
   }
   writePlan(content) {
     this.ensureDir();
-    fs4.writeFileSync(path4.join(this.planDir, "01-plan.md"), content, "utf-8");
-    logger6.info("Plan document written");
+    fs3.writeFileSync(path3.join(this.planDir, "01-plan.md"), content, "utf-8");
+    logger5.info("Plan document written");
   }
   writeReviewFeedback(content) {
     this.ensureDir();
@@ -1296,32 +875,32 @@ var PlanPersistence = class _PlanPersistence {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     history.push(round);
-    fs4.writeFileSync(
-      path4.join(this.planDir, "review-history.json"),
+    fs3.writeFileSync(
+      path3.join(this.planDir, "review-history.json"),
       JSON.stringify(history, null, 2),
       "utf-8"
     );
-    fs4.writeFileSync(
-      path4.join(this.planDir, "review-feedback.md"),
+    fs3.writeFileSync(
+      path3.join(this.planDir, "review-feedback.md"),
       _PlanPersistence.renderReviewHistoryMarkdown(history),
       "utf-8"
     );
-    logger6.info("Review feedback appended", { round: round.round });
+    logger5.info("Review feedback appended", { round: round.round });
   }
   readReviewFeedback() {
-    const filePath = path4.join(this.planDir, "review-feedback.md");
-    if (!fs4.existsSync(filePath)) return null;
+    const filePath = path3.join(this.planDir, "review-feedback.md");
+    if (!fs3.existsSync(filePath)) return null;
     try {
-      return fs4.readFileSync(filePath, "utf-8");
+      return fs3.readFileSync(filePath, "utf-8");
     } catch {
       return null;
     }
   }
   readReviewHistory() {
-    const filePath = path4.join(this.planDir, "review-history.json");
-    if (!fs4.existsSync(filePath)) return [];
+    const filePath = path3.join(this.planDir, "review-history.json");
+    if (!fs3.existsSync(filePath)) return [];
     try {
-      const data = JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+      const data = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
       return Array.isArray(data) ? data : [];
     } catch {
       return [];
@@ -1361,13 +940,43 @@ var PlanPersistence = class _PlanPersistence {
 };
 
 // src/phases/BasePhase.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs4 from "fs";
+import path5 from "path";
 
 // src/prompts/templates.ts
 function planDir(iid) {
   return `.claude-plan/issue-${iid}`;
 }
+function getKnowledgeForPrompt() {
+  const k = getProjectKnowledge() ?? KNOWLEDGE_DEFAULTS;
+  const codeStyleParts = [];
+  if (k.codeStyle.indentStyle === "spaces") {
+    codeStyleParts.push(`${k.codeStyle.indentSize}\u7A7A\u683C\u7F29\u8FDB`);
+  } else {
+    codeStyleParts.push("Tab\u7F29\u8FDB");
+  }
+  codeStyleParts.push(`${k.codeStyle.lineWidth}\u5B57\u7B26\u884C\u5BBD`);
+  codeStyleParts.push("\u547D\u540D\u89C4\u8303\u7B49");
+  if (k.codeStyle.additionalRules?.length) {
+    codeStyleParts.push(...k.codeStyle.additionalRules);
+  }
+  const knownIssueLines = k.knownIssues.map((issue) => `- ${issue.description}${issue.advice ? `\uFF0C${issue.advice}` : ""}`);
+  return {
+    dependencyCheckPath: k.toolchain.dependencyCheckPath ?? "node_modules/.bin/eslint",
+    installCommand: k.toolchain.installCommand,
+    installFallbackCommand: k.toolchain.installFallbackCommand ?? `${k.toolchain.installCommand} --ignore-scripts`,
+    lintCommand: k.toolchain.lintCommand ?? "npm run lint",
+    buildCommand: k.toolchain.buildCommand ?? "npm run build",
+    testCommand: k.toolchain.testCommand ?? "npm test",
+    testFilesCommand: k.toolchain.testFilesCommand ?? `${k.toolchain.testCommand ?? "npm test"} -- <\u6D89\u53CA\u53D8\u66F4\u7684\u6D4B\u8BD5\u6587\u4EF6>`,
+    knownIssuesSection: knownIssueLines.length > 0 ? knownIssueLines.join("\n") : "- \u65E0\u5DF2\u77E5\u9884\u5B58\u95EE\u9898",
+    codeStyleDescription: codeStyleParts.join("\u3001"),
+    // E2E related
+    e2eDir: k.structure.e2eDir ?? "e2e",
+    e2eTool: k.structure.e2eTool ?? "E2E",
+    frontendDir: k.structure.frontendDir ?? "frontend"
+  };
+}
 function analysisPrompt(ctx) {
   const supplementSection = ctx.supplementText ? `
 
@@ -1395,26 +1004,32 @@ ${ctx.supplementText}` : "";
 }
 function implementPrompt(ctx) {
   const pd = planDir(ctx.issueIid);
+  const kv = getKnowledgeForPrompt();
   return t("prompt.implement", {
     iid: ctx.issueIid,
     title: ctx.issueTitle,
-    planDir: pd
+    planDir: pd,
+    ...kv
   });
 }
 function verifyPrompt(ctx) {
   const pd = planDir(ctx.issueIid);
+  const kv = getKnowledgeForPrompt();
   return t("prompt.verify", {
     iid: ctx.issueIid,
     title: ctx.issueTitle,
-    planDir: pd
+    planDir: pd,
+    ...kv
   });
 }
 function planModeVerifyPrompt(ctx) {
   const pd = planDir(ctx.issueIid);
+  const kv = getKnowledgeForPrompt();
   return t("prompt.planModeVerify", {
     iid: ctx.issueIid,
     title: ctx.issueTitle,
-    planDir: pd
+    planDir: pd,
+    ...kv
   });
 }
 function planPrompt(ctx) {
@@ -1432,10 +1047,12 @@ ${ctx.supplementText}` : "";
 }
 function buildPrompt(ctx) {
   const pd = planDir(ctx.issueIid);
+  const kv = getKnowledgeForPrompt();
   return t("prompt.build", {
     iid: ctx.issueIid,
     title: ctx.issueTitle,
-    planDir: pd
+    planDir: pd,
+    ...kv
   });
 }
 function rePlanPrompt(ctx, history) {
@@ -1457,6 +1074,10 @@ ${ctx.supplementText}` : "";
   });
 }
 function e2eVerifyPromptSuffix(ctx, ports) {
+  const kv = getKnowledgeForPrompt();
+  const frontendDir = kv.frontendDir;
+  const e2eDir = kv.e2eDir;
+  const e2eTool = kv.e2eTool;
   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}
@@ -1465,13 +1086,13 @@ function e2eVerifyPromptSuffix(ctx, ports) {
 \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
+  cd ${frontendDir} && npx ${e2eTool.toLowerCase()} 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` : `
+**\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 ${e2eTool.toLowerCase()} test \u5373\u53EF\u590D\u7528\u5DF2\u542F\u52A8\u7684\u524D\u7AEF\u3002` : `
 \u6267\u884C E2E \u6D4B\u8BD5\uFF1A
 \`\`\`bash
-cd frontend && pnpm test:e2e
+cd ${frontendDir} && pnpm test:e2e
 \`\`\``;
   return `
 
@@ -1479,8 +1100,8 @@ cd frontend && pnpm test:e2e
 
 \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
+6. \u5982\u679C\u672C\u6B21\u53D8\u66F4\u6D89\u53CA\u524D\u7AEF\u9875\u9762\uFF08${frontendDir}/ \u76EE\u5F55\u6709\u6539\u52A8\uFF09\uFF0C\u8BF7\u6267\u884C UI E2E \u9A8C\u8BC1\uFF1A
+   a. \u5728 ${e2eDir}/ \u76EE\u5F55\u4E0B\u7F16\u5199\u9488\u5BF9\u672C\u6B21\u53D8\u66F4\u7684 ${e2eTool} \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
@@ -1488,6 +1109,15 @@ cd frontend && pnpm test:e2e
    - \u4E13\u9879\u6D4B\u8BD5\u7ED3\u679C\u5217\u8868
    - \u5931\u8D25\u622A\u56FE\u8DEF\u5F84\uFF08\u5982\u6709\uFF09`;
 }
+function conflictResolvePrompt(ctx) {
+  const conflictFilesList = ctx.conflictFiles.map((f) => `- \`${f}\``).join("\n");
+  return t("prompt.conflictResolve", {
+    iid: ctx.issueIid,
+    branch: ctx.branchName,
+    baseBranch: ctx.baseBranch,
+    conflictFilesList
+  });
+}
 function issueProgressComment(phase, status, detail) {
   const emoji = {
     analysis: "\u{1F50D}",
@@ -1512,42 +1142,12 @@ ${detail}`;
 
 // 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"]
-  }
-];
+import path4 from "path";
 function parseFrontmatter(raw) {
   const fmRegex = /^---\s*\n([\s\S]*?)\n---\s*\n/;
   const match = raw.match(fmRegex);
   if (!match) {
-    return { description: "", content: raw.trim() };
+    return { description: "", alwaysApply: false, content: raw.trim() };
   }
   const yamlBlock = match[1];
   const content = raw.slice(match[0].length).trim();
@@ -1556,10 +1156,19 @@ function parseFrontmatter(raw) {
   if (descMatch) {
     description = descMatch[1].trim();
   }
-  return { description, content };
+  let alwaysApply = false;
+  const applyMatch = yamlBlock.match(/alwaysApply:\s*(true|false)/i);
+  if (applyMatch) {
+    alwaysApply = applyMatch[1].toLowerCase() === "true";
+  }
+  return { description, alwaysApply, content };
 }
 var RuleResolver = class {
   rules = [];
+  triggers;
+  constructor(ruleTriggers) {
+    this.triggers = ruleTriggers;
+  }
   async loadRules(rulesDir) {
     this.rules = [];
     let files;
@@ -1571,10 +1180,10 @@ var RuleResolver = class {
     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);
+        const raw = await readFile(path4.join(rulesDir, filename), "utf-8");
+        const { description, alwaysApply, content } = parseFrontmatter(raw);
         if (content) {
-          this.rules.push({ filename, description, content });
+          this.rules.push({ filename, description, alwaysApply, content });
         }
       } catch {
       }
@@ -1586,16 +1195,34 @@ var RuleResolver = class {
   }
   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);
+    const matched = /* @__PURE__ */ new Map();
+    for (const rule of this.rules) {
+      if (rule.alwaysApply) {
+        matched.set(rule.filename, rule);
       }
     }
-    return matched;
+    if (this.triggers && this.triggers.length > 0) {
+      for (const trigger of this.triggers) {
+        if (matched.has(trigger.filename)) continue;
+        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.set(rule.filename, rule);
+        }
+      }
+    } else {
+      for (const rule of this.rules) {
+        if (matched.has(rule.filename)) continue;
+        if (!rule.description) continue;
+        const descWords = rule.description.split(/[\s,，;；、/|]+/).filter((w) => w.length >= 2);
+        const isMatched = descWords.some((word) => lowerText.includes(word.toLowerCase()));
+        if (isMatched) {
+          matched.set(rule.filename, rule);
+        }
+      }
+    }
+    return Array.from(matched.values());
   }
   formatForPrompt(rules) {
     if (rules.length === 0) return "";
@@ -1743,8 +1370,9 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
   }
   async resolveRules(ctx) {
     try {
-      const rulesDir = path6.join(this.plan.baseDir, ".cursor", "rules");
-      const resolver = new RuleResolver();
+      const rulesDir = path5.join(this.plan.baseDir, ".cursor", "rules");
+      const knowledge = getProjectKnowledge();
+      const resolver = new RuleResolver(knowledge?.ruleTriggers);
       await resolver.loadRules(rulesDir);
       const context = `${ctx.issueTitle} ${ctx.issueDescription} ${ctx.supplementText ?? ""}`;
       const matched = resolver.matchRules(context);
@@ -1803,11 +1431,11 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
     }
   }
   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;
+    const planDir2 = path5.join(this.plan.baseDir, ".claude-plan", `issue-${issueIid}`);
+    const filePath = path5.join(planDir2, filename);
+    if (!fs4.existsSync(filePath)) return null;
     try {
-      return fs5.readFileSync(filePath, "utf-8");
+      return fs4.readFileSync(filePath, "utf-8");
     } catch {
       return null;
     }
@@ -1872,7 +1500,7 @@ var ImplementPhase = class extends BasePhase {
 };
 
 // src/phases/VerifyPhase.ts
-import os2 from "os";
+import os from "os";
 
 // src/e2e/E2eSettings.ts
 var e2eOverride;
@@ -1890,7 +1518,7 @@ function isE2eEnabledForIssue(issueIid, tracker, cfg) {
 
 // src/phases/VerifyPhase.ts
 function getDefaultHost() {
-  const interfaces = os2.networkInterfaces();
+  const interfaces = os.networkInterfaces();
   for (const addrs of Object.values(interfaces)) {
     for (const addr of addrs ?? []) {
       if (addr.family === "IPv4" && !addr.internal) return addr.address;
@@ -2030,15 +1658,15 @@ var AsyncMutex = class {
 };
 
 // src/orchestrator/PipelineOrchestrator.ts
-import path10 from "path";
-import os3 from "os";
-import fs8 from "fs/promises";
+import path9 from "path";
+import os2 from "os";
+import fs7 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";
+import fs5 from "fs";
+import path6 from "path";
 var TAPD_PATTERNS = [
   /--story=(\d+)/i,
   /--bug=(\d+)/i,
@@ -2082,9 +1710,9 @@ function generateMRDescription(options) {
     ];
     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 filePath = path6.join(planDir2, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs5.existsSync(filePath)) {
+        const content = fs5.readFileSync(filePath, "utf-8");
         const summary = extractSummary(content);
         if (summary) {
           planSections.push(`### ${label}
@@ -2108,7 +1736,7 @@ function extractSummary(content, maxLines = 20) {
 
 // src/deploy/PortAllocator.ts
 import net from "net";
-var logger7 = logger.child("PortAllocator");
+var logger6 = logger.child("PortAllocator");
 var DEFAULT_OPTIONS = {
   backendPortBase: 4e3,
   frontendPortBase: 9e3,
@@ -2133,7 +1761,7 @@ var PortAllocator = class {
   async allocate(issueIid) {
     const existing = this.allocated.get(issueIid);
     if (existing) {
-      logger7.info("Returning already allocated ports", { issueIid, ports: existing });
+      logger6.info("Returning already allocated ports", { issueIid, ports: existing });
       return existing;
     }
     const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
@@ -2151,10 +1779,10 @@ var PortAllocator = class {
       if (beOk && feOk) {
         const pair = { backendPort, frontendPort };
         this.allocated.set(issueIid, pair);
-        logger7.info("Ports allocated", { issueIid, ...pair });
+        logger6.info("Ports allocated", { issueIid, ...pair });
         return pair;
       }
-      logger7.debug("Port pair unavailable, trying next", {
+      logger6.debug("Port pair unavailable, trying next", {
         backendPort,
         frontendPort,
         beOk,
@@ -2169,7 +1797,7 @@ var PortAllocator = class {
     const pair = this.allocated.get(issueIid);
     if (pair) {
       this.allocated.delete(issueIid);
-      logger7.info("Ports released", { issueIid, ...pair });
+      logger6.info("Ports released", { issueIid, ...pair });
     }
   }
   getPortsForIssue(issueIid) {
@@ -2180,16 +1808,16 @@ var PortAllocator = class {
   }
   restore(issueIid, ports) {
     this.allocated.set(issueIid, ports);
-    logger7.info("Ports restored from persistence", { issueIid, ...ports });
+    logger6.info("Ports restored from persistence", { issueIid, ...ports });
   }
 };
 
 // src/deploy/DevServerManager.ts
-import { spawn as spawn2 } from "child_process";
-import path8 from "path";
+import { spawn } from "child_process";
+import path7 from "path";
 import https from "https";
 import http from "http";
-var logger8 = logger.child("DevServerManager");
+var logger7 = logger.child("DevServerManager");
 var DEFAULT_OPTIONS2 = {
   healthCheckTimeoutMs: 12e4,
   healthCheckIntervalMs: 3e3
@@ -2234,51 +1862,51 @@ var DevServerManager = class {
   }
   async startServers(wtCtx, ports) {
     if (this.servers.has(wtCtx.issueIid)) {
-      logger8.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      logger7.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
       return;
     }
-    logger8.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    logger7.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"], {
+    const backend = spawn("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()}`);
+      logger7.debug(`[BE #${wtCtx.issueIid}] ${data.toString().trimEnd()}`);
     });
     backend.stderr?.on("data", (data) => {
-      logger8.debug(`[BE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
+      logger7.debug(`[BE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
     });
     backend.on("exit", (code) => {
-      logger8.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+      logger7.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
     });
-    const frontendDir = path8.join(wtCtx.workDir, "frontend");
+    const frontendDir = path7.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)], {
+    const frontend = spawn("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()}`);
+      logger7.debug(`[FE #${wtCtx.issueIid}] ${data.toString().trimEnd()}`);
     });
     frontend.stderr?.on("data", (data) => {
-      logger8.debug(`[FE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
+      logger7.debug(`[FE #${wtCtx.issueIid} ERR] ${data.toString().trimEnd()}`);
     });
     frontend.on("exit", (code) => {
-      logger8.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+      logger7.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
     });
     const serverSet = {
       backend,
@@ -2288,7 +1916,7 @@ var DevServerManager = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.servers.set(wtCtx.issueIid, serverSet);
-    logger8.info("Waiting for servers to become healthy", { issueIid: wtCtx.issueIid });
+    logger7.info("Waiting for servers to become healthy", { issueIid: wtCtx.issueIid });
     try {
       await Promise.all([
         waitForPort(
@@ -2304,9 +1932,9 @@ var DevServerManager = class {
           this.options.healthCheckIntervalMs
         )
       ]);
-      logger8.info("Dev servers healthy", { issueIid: wtCtx.issueIid, ...ports });
+      logger7.info("Dev servers healthy", { issueIid: wtCtx.issueIid, ...ports });
     } catch (err) {
-      logger8.error("Dev servers failed health check, cleaning up", {
+      logger7.error("Dev servers failed health check, cleaning up", {
         issueIid: wtCtx.issueIid,
         error: err.message
       });
@@ -2317,7 +1945,7 @@ var DevServerManager = class {
   stopServers(issueIid) {
     const set = this.servers.get(issueIid);
     if (!set) return;
-    logger8.info("Stopping dev servers", { issueIid, ports: set.ports });
+    logger7.info("Stopping dev servers", { issueIid, ports: set.ports });
     killProcess(set.backend, `backend #${issueIid}`);
     killProcess(set.frontend, `frontend #${issueIid}`);
     this.servers.delete(issueIid);
@@ -2346,23 +1974,23 @@ function killProcess(proc, label) {
     proc.kill("SIGTERM");
     setTimeout(() => {
       if (!proc.killed && proc.exitCode === null) {
-        logger8.warn(`Force killing ${label}`);
+        logger7.warn(`Force killing ${label}`);
         proc.kill("SIGKILL");
       }
     }, 5e3);
   } catch (err) {
-    logger8.warn(`Failed to kill ${label}`, { error: err.message });
+    logger7.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");
+import fs6 from "fs";
+import path8 from "path";
+var logger8 = 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);
+  for (const entry of fs6.readdirSync(dir, { withFileTypes: true })) {
+    const full = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkDir(full, files);
     } else if (entry.isFile() && entry.name.endsWith(".png")) {
@@ -2372,34 +2000,34 @@ function walkDir(dir, files = []) {
   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 });
+  const testResultsDir = path8.join(workDir, "frontend", "test-results");
+  if (!fs6.existsSync(testResultsDir)) {
+    logger8.debug("test-results directory not found", { dir: testResultsDir });
     return [];
   }
   const pngFiles = walkDir(testResultsDir);
   if (pngFiles.length === 0) {
-    logger9.debug("No screenshots found");
+    logger8.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");
+    const relative = path8.relative(testResultsDir, filePath);
+    const testName = relative.split(path8.sep)[0] || path8.basename(filePath, ".png");
     return { filePath, testName };
   });
   if (screenshots.length > MAX_SCREENSHOTS) {
-    logger9.warn("Too many screenshots, truncating", {
+    logger8.warn("Too many screenshots, truncating", {
       total: screenshots.length,
       max: MAX_SCREENSHOTS
     });
     return screenshots.slice(0, MAX_SCREENSHOTS);
   }
-  logger9.info("Screenshots collected", { count: screenshots.length });
+  logger8.info("Screenshots collected", { count: screenshots.length });
   return screenshots;
 }
 
 // src/e2e/ScreenshotPublisher.ts
-var logger10 = logger.child("ScreenshotPublisher");
+var logger9 = logger.child("ScreenshotPublisher");
 function buildComment(uploaded, truncated) {
   const lines = [t("screenshot.title"), ""];
   for (const item of uploaded) {
@@ -2418,12 +2046,12 @@ var ScreenshotPublisher = class {
     const { workDir, issueIid, issueId, mrIid } = options;
     const screenshots = collectScreenshots(workDir);
     if (screenshots.length === 0) {
-      logger10.info("No E2E screenshots to publish", { issueIid });
+      logger9.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 });
+      logger9.warn("All screenshot uploads failed", { issueIid });
       return;
     }
     const truncated = screenshots.length >= 20;
@@ -2432,7 +2060,7 @@ var ScreenshotPublisher = class {
     if (mrIid) {
       await this.postToMergeRequest(mrIid, comment);
     }
-    logger10.info("E2E screenshots published", {
+    logger9.info("E2E screenshots published", {
       issueIid,
       mrIid,
       count: uploaded.length
@@ -2448,7 +2076,7 @@ var ScreenshotPublisher = class {
           markdown: result.markdown
         });
       } catch (err) {
-        logger10.warn("Failed to upload screenshot", {
+        logger9.warn("Failed to upload screenshot", {
           filePath: screenshot.filePath,
           error: err.message
         });
@@ -2460,7 +2088,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createIssueNote(issueId, comment);
     } catch (err) {
-      logger10.warn("Failed to post screenshots to issue", {
+      logger9.warn("Failed to post screenshots to issue", {
         issueId,
         error: err.message
       });
@@ -2470,7 +2098,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, comment);
     } catch (err) {
-      logger10.warn("Failed to post screenshots to merge request", {
+      logger9.warn("Failed to post screenshots to merge request", {
         mrIid,
         error: err.message
       });
@@ -2480,7 +2108,7 @@ var ScreenshotPublisher = class {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger11 = logger.child("PipelineOrchestrator");
+var logger10 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -2502,7 +2130,7 @@ var PipelineOrchestrator = class {
     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 });
+    logger10.info("Pipeline mode resolved", { mode: this.pipelineDef.mode, aiMode: config.ai.mode });
     this.portAllocator = new PortAllocator({
       backendPortBase: config.e2e.backendPortBase,
       frontendPortBase: config.e2e.frontendPortBase
@@ -2517,6 +2145,44 @@ var PipelineOrchestrator = class {
   getDevServerManager() {
     return this.devServerManager;
   }
+  async cleanupStaleState() {
+    logger10.info("Cleaning up stale worktree state...");
+    let cleaned = 0;
+    try {
+      const worktrees = await this.mainGit.worktreeList();
+      for (const wtDir of worktrees) {
+        if (wtDir === this.config.project.gitRootDir) continue;
+        if (!wtDir.includes("/issue-")) continue;
+        try {
+          const wtGit = new GitOperations(wtDir);
+          if (await wtGit.isRebaseInProgress()) {
+            logger10.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            await wtGit.rebaseAbort();
+            cleaned++;
+          }
+          const indexLock = path9.join(wtDir, ".git", "index.lock");
+          try {
+            await fs7.unlink(indexLock);
+            logger10.warn("Removed stale index.lock", { path: indexLock });
+            cleaned++;
+          } catch {
+          }
+        } catch (err) {
+          logger10.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+        }
+      }
+    } catch (err) {
+      logger10.warn("Failed to list worktrees for cleanup", { error: err.message });
+    }
+    const mainIndexLock = path9.join(this.config.project.gitRootDir, ".git", "index.lock");
+    try {
+      await fs7.unlink(mainIndexLock);
+      logger10.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      cleaned++;
+    } catch {
+    }
+    logger10.info("Stale state cleanup complete", { cleaned });
+  }
   restorePortAllocations() {
     for (const record of this.tracker.getAll()) {
       if (record.ports) {
@@ -2531,14 +2197,14 @@ var PipelineOrchestrator = class {
     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);
+    const gitRootDir = path9.join(this.config.project.worktreeBaseDir, `issue-${issueIid}`);
+    const workDir = path9.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 });
+      logger10.info("Reusing existing worktree", { dir: wtCtx.gitRootDir });
       return;
     }
     const localExists = await this.mainGit.branchExists(wtCtx.branchName);
@@ -2560,69 +2226,84 @@ var PipelineOrchestrator = class {
   async cleanupWorktree(wtCtx) {
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger11.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger10.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger11.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger10.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;
+    logger10.info("Installing dependencies in worktree", { workDir });
+    const knowledge = getProjectKnowledge() ?? KNOWLEDGE_DEFAULTS;
+    const pkgMgr = knowledge.toolchain.packageManager.toLowerCase();
+    const isNodeProject = ["npm", "pnpm", "yarn", "bun"].some((m) => pkgMgr.includes(m));
+    if (isNodeProject) {
+      const ready = await this.ensureNodeModules(workDir);
+      if (ready) {
+        logger10.info("node_modules ready \u2014 skipping install");
+        return;
+      }
     }
+    const installCmd = knowledge.toolchain.installCommand;
+    const fallbackCmd = knowledge.toolchain.installFallbackCommand;
+    const [bin, ...args] = installCmd.split(/\s+/);
     try {
-      await execFileAsync2("pnpm", ["install", "--frozen-lockfile"], {
+      await execFileAsync2(bin, args, {
         cwd: workDir,
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger11.info("Dependencies installed");
+      logger10.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
+      if (fallbackCmd) {
+        logger10.warn(`${installCmd} failed, retrying with fallback command`, {
+          error: err.message
         });
-        logger11.info("Dependencies installed (scripts ignored)");
-      } catch (retryErr) {
-        logger11.warn("pnpm install also failed with --ignore-scripts", {
-          error: retryErr.message
+        const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
+        try {
+          await execFileAsync2(fallbackBin, fallbackArgs, {
+            cwd: workDir,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 3e5
+          });
+          logger10.info("Dependencies installed (fallback)");
+        } catch (retryErr) {
+          logger10.warn("Fallback install also failed", {
+            error: retryErr.message
+          });
+        }
+      } else {
+        logger10.warn("Install failed, no fallback configured", {
+          error: err.message
         });
       }
     }
   }
-  async seedNodeModulesFromMain(workDir) {
-    const targetBin = path10.join(workDir, "node_modules", ".bin");
+  async ensureNodeModules(workDir) {
+    const targetBin = path9.join(workDir, "node_modules", ".bin");
     try {
-      await fs8.access(targetBin);
-      logger11.info("Worktree node_modules already complete (has .bin/), skipping seed");
-      return false;
+      await fs7.access(targetBin);
+      logger10.info("node_modules already complete (has .bin/)");
+      return true;
     } catch {
     }
-    const sourceNM = path10.join(this.config.project.workDir, "node_modules");
-    const targetNM = path10.join(workDir, "node_modules");
+    const sourceNM = path9.join(this.config.project.workDir, "node_modules");
+    const targetNM = path9.join(workDir, "node_modules");
     try {
-      await fs8.access(sourceNM);
+      await fs7.access(sourceNM);
     } catch {
-      logger11.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger10.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 });
+    logger10.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");
+      logger10.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger11.warn("Failed to seed node_modules from main repo", {
+      logger10.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -2632,13 +2313,14 @@ var PipelineOrchestrator = class {
     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 });
+    logger10.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    this.aiRunner.killByWorkDir(wtCtx.workDir);
     this.stopPreviewServers(issueIid);
     try {
       const deleted = await this.gongfeng.cleanupAgentNotes(record.issueId);
-      logger11.info("Agent notes cleaned up", { issueIid, deleted });
+      logger10.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger11.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger10.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -2652,7 +2334,7 @@ var PipelineOrchestrator = class {
       }
     });
     this.tracker.resetFull(issueIid);
-    logger11.info("Issue restarted", { issueIid });
+    logger10.info("Issue restarted", { issueIid });
   }
   retryFromPhase(issueIid, phase) {
     const record = this.tracker.get(issueIid);
@@ -2662,7 +2344,7 @@ var PipelineOrchestrator = class {
     if (!spec || spec.kind !== "ai") {
       throw new Error(`Invalid phase for retry: ${phase}`);
     }
-    logger11.info("Retrying issue from phase", { issueIid, phase });
+    logger10.info("Retrying issue from phase", { issueIid, phase });
     this.tracker.resetToPhase(issueIid, phase, issueDef);
   }
   getIssueSpecificPipelineDef(record) {
@@ -2674,7 +2356,7 @@ var PipelineOrchestrator = class {
   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 });
+    logger10.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) {
@@ -2698,7 +2380,7 @@ var PipelineOrchestrator = class {
         "auto-finish:processing"
       ]);
     } catch (err) {
-      logger11.warn("Failed to update issue labels", { error: err.message });
+      logger10.warn("Failed to update issue labels", { error: err.message });
     }
     try {
       await this.gongfeng.createIssueNote(
@@ -2751,10 +2433,13 @@ var PipelineOrchestrator = class {
       const needsDeployment = this.shouldDeployServers(issue.iid);
       let serversStarted = false;
       for (let i = startIdx; i < issuePipelineDef.phases.length; i++) {
+        if (isShuttingDown()) {
+          throw new Error("Service shutting down");
+        }
         const spec = issuePipelineDef.phases[i];
         if (spec.kind === "gate") {
           if (this.shouldAutoApprove(issue.labels)) {
-            logger11.info("Auto-approving review gate (matched autoApproveLabels)", {
+            logger10.info("Auto-approving review gate (matched autoApproveLabels)", {
               iid: issue.iid,
               labels: issue.labels,
               autoApproveLabels: this.config.review.autoApproveLabels
@@ -2775,7 +2460,7 @@ var PipelineOrchestrator = class {
           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 });
+          logger10.info("Review gate reached, pausing", { iid: issue.iid });
           return;
         }
         const phase = createPhase(spec.name, this.aiRunner, wtGit, wtPlan, this.gongfeng, this.tracker, this.config);
@@ -2811,7 +2496,7 @@ var PipelineOrchestrator = class {
             mrIid: mrResult?.iid
           });
         } catch (err) {
-          logger11.warn("Failed to publish E2E screenshots", {
+          logger10.warn("Failed to publish E2E screenshots", {
             iid: issue.iid,
             error: err.message
           });
@@ -2828,20 +2513,25 @@ var PipelineOrchestrator = class {
       } catch {
       }
       if (serversStarted && this.config.preview.keepAfterComplete) {
-        logger11.info("Preview servers kept running after completion", { iid: issue.iid });
+        logger10.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 });
+      logger10.info("Issue processing completed", { iid: issue.iid });
     } catch (err) {
       const errorMsg = err.message;
-      logger11.error("Issue processing failed", { iid: issue.iid, error: errorMsg });
+      logger10.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 */) {
+      const wasReset = failedAtState === "pending" /* Pending */ && currentRecord?.attempts === 0;
+      if (failedAtState !== "failed" /* Failed */ && !wasReset) {
         this.tracker.markFailed(issue.iid, errorMsg.slice(0, 500), failedAtState);
       }
+      if (wasReset) {
+        logger10.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+        throw err;
+      }
       try {
         await this.gongfeng.updateIssueLabels(issue.id, [
           ...issue.labels.filter((l) => !l.startsWith("auto-finish:") && l !== "auto-finish"),
@@ -2857,7 +2547,7 @@ var PipelineOrchestrator = class {
         );
       } catch {
       }
-      logger11.info("Worktree preserved for debugging", { dir: wtCtx.gitRootDir });
+      logger10.info("Worktree preserved for debugging", { dir: wtCtx.gitRootDir });
       throw err;
     }
   }
@@ -2886,7 +2576,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger11.info("Merge request created successfully", {
+      logger10.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -2894,7 +2584,7 @@ var PipelineOrchestrator = class {
       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", {
+      logger10.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -2911,7 +2601,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger11.info("Found existing merge request", {
+        logger10.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -2919,7 +2609,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger11.warn("Failed to find existing merge request", {
+      logger10.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -2978,7 +2668,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger11.error("Failed to start preview servers", {
+      logger10.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -2998,7 +2688,7 @@ var PipelineOrchestrator = class {
   }
   getPreviewHost() {
     if (this.config.preview.host) return this.config.preview.host;
-    const interfaces = os3.networkInterfaces();
+    const interfaces = os2.networkInterfaces();
     for (const addrs of Object.values(interfaces)) {
       for (const addr of addrs ?? []) {
         if (addr.family === "IPv4" && !addr.internal) {
@@ -3029,6 +2719,149 @@ var PipelineOrchestrator = class {
       t("orchestrator.previewComment.expiry", { hours: ttlHours })
     ].join("\n");
   }
+  async resolveConflict(issueIid) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new Error(`Issue ${issueIid} not found in tracker`);
+    const baseBranch = this.config.project.baseBranch;
+    const branchName = record.branchName;
+    logger10.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
+    this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
+    eventBus.emitTyped("conflict:started", { issueIid });
+    try {
+      await this.gongfeng.createIssueNote(
+        record.issueId,
+        t("conflict.startComment", { branch: branchName, baseBranch })
+      );
+    } catch {
+    }
+    const wtCtx = this.computeWorktreeContext(issueIid, branchName);
+    try {
+      await this.mainGitMutex.runExclusive(async () => {
+        await this.mainGit.fetch();
+        await this.ensureWorktree(wtCtx);
+      });
+      const wtGit = new GitOperations(wtCtx.gitRootDir);
+      await wtGit.checkout(branchName);
+      if (await wtGit.isRebaseInProgress()) {
+        logger10.warn("Found residual rebase in progress, aborting", { issueIid });
+        await wtGit.rebaseAbort();
+      }
+      const rebaseResult = await wtGit.rebase(`origin/${baseBranch}`);
+      if (rebaseResult.success) {
+        await wtGit.forcePush(branchName);
+        this.tracker.updateState(issueIid, "completed" /* Completed */);
+        eventBus.emitTyped("conflict:resolved", { issueIid });
+        try {
+          await this.gongfeng.createIssueNote(
+            record.issueId,
+            t("conflict.noConflictComment", { branch: branchName, baseBranch })
+          );
+        } catch {
+        }
+        await this.commentOnMr(record.mrUrl, t("conflict.mrResolvedComment"));
+        logger10.info("Conflict resolution completed (no conflicts)", { issueIid });
+        return;
+      }
+      let conflictFiles = rebaseResult.conflictFiles;
+      const maxResolveAttempts = 20;
+      let attempt = 0;
+      while (conflictFiles.length > 0 && attempt < maxResolveAttempts) {
+        attempt++;
+        logger10.info("Resolving conflicts with AI", {
+          issueIid,
+          attempt,
+          conflictFiles
+        });
+        const prompt = conflictResolvePrompt({
+          issueIid,
+          branchName,
+          baseBranch,
+          conflictFiles
+        });
+        await this.aiRunner.run({
+          prompt,
+          workDir: wtCtx.workDir,
+          timeoutMs: this.config.ai.phaseTimeoutMs,
+          onStreamEvent: (event) => {
+            eventBus.emitTyped("agent:output", {
+              issueIid,
+              phase: "conflict-resolve",
+              event
+            });
+          }
+        });
+        await wtGit.add(conflictFiles);
+        const continueResult = await wtGit.rebaseContinue();
+        if (continueResult.done) {
+          conflictFiles = [];
+        } else {
+          conflictFiles = continueResult.conflictFiles;
+        }
+      }
+      if (conflictFiles.length > 0) {
+        await wtGit.rebaseAbort();
+        throw new Error(`Failed to resolve all conflicts after ${maxResolveAttempts} attempts. Remaining: ${conflictFiles.join(", ")}`);
+      }
+      logger10.info("Running verification after conflict resolution", { issueIid });
+      const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
+      wtPlan.ensureDir();
+      const verifyPhase = createPhase("verify", this.aiRunner, wtGit, wtPlan, this.gongfeng, this.tracker, this.config);
+      const verifyCtx = {
+        issueIid,
+        issueId: record.issueId,
+        issueTitle: record.issueTitle,
+        issueDescription: "",
+        branchName,
+        pipelineMode: record.pipelineMode
+      };
+      await verifyPhase.execute(verifyCtx);
+      await wtGit.forcePush(branchName);
+      this.tracker.updateState(issueIid, "completed" /* Completed */);
+      eventBus.emitTyped("conflict:resolved", { issueIid });
+      try {
+        await this.gongfeng.createIssueNote(
+          record.issueId,
+          t("conflict.resolvedComment", { branch: branchName, baseBranch })
+        );
+      } catch {
+      }
+      await this.commentOnMr(record.mrUrl, t("conflict.mrResolvedComment"));
+      logger10.info("Conflict resolution completed", { issueIid });
+    } catch (err) {
+      const errorMsg = err.message;
+      logger10.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      try {
+        const wtGit = new GitOperations(wtCtx.gitRootDir);
+        if (await wtGit.isRebaseInProgress()) {
+          await wtGit.rebaseAbort();
+        }
+      } catch {
+      }
+      this.tracker.markFailed(issueIid, errorMsg.slice(0, 500), "resolving_conflict" /* ResolvingConflict */);
+      eventBus.emitTyped("conflict:failed", { issueIid, error: errorMsg });
+      try {
+        await this.gongfeng.createIssueNote(
+          record.issueId,
+          t("conflict.failedComment", { error: errorMsg })
+        );
+      } catch {
+      }
+    }
+  }
+  extractMrIidFromUrl(mrUrl) {
+    const match = mrUrl.match(/merge_requests\/(\d+)/);
+    return match ? parseInt(match[1], 10) : null;
+  }
+  async commentOnMr(mrUrl, body) {
+    if (!mrUrl) return;
+    const mrIid = this.extractMrIidFromUrl(mrUrl);
+    if (!mrIid) return;
+    try {
+      await this.gongfeng.createMergeRequestNote(mrIid, body);
+    } catch (err) {
+      logger10.warn("Failed to comment on MR", { mrIid, error: err.message });
+    }
+  }
 };
 
 // src/services/BrainstormService.ts
@@ -3102,7 +2935,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger12 = logger.child("Brainstorm");
+var logger11 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -3138,7 +2971,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger12.info("Created brainstorm session", { sessionId: session.id });
+    logger11.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -3147,7 +2980,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger12.info("Generating SDD", { sessionId });
+    logger11.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -3173,7 +3006,7 @@ var BrainstormService = class {
     const session = this.requireSession(sessionId);
     const roundNum = session.rounds.length + 1;
     session.status = "reviewing";
-    logger12.info("Reviewing SDD", { sessionId, round: roundNum });
+    logger11.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({
@@ -3206,7 +3039,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger12.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger11.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -3262,17 +3095,9 @@ var BrainstormService = class {
 };
 
 export {
-  loadConfig,
-  Logger,
-  logger,
   AGENT_NOTE_MARKER,
   GongfengClient,
   GitOperations,
-  BaseAIRunner,
-  ClaudeInternalRunner,
-  CodebuddyRunner,
-  CursorAgentRunner,
-  createAIRunner,
   CLASSIC_PIPELINE,
   PLAN_MODE_PIPELINE,
   resolvePipelineMode,
@@ -3292,4 +3117,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-TBIEB3JY.js.map
+//# sourceMappingURL=chunk-N5YK6YVI.js.map