@xdevops/issue-auto-finish 1.0.1 → 1.0.3

package/dist/{chunk-IDUKWCC2.js → chunk-C6ZJVIPZ.js}

@@ -1,3 +1,6 @@
+import {
+  createSetupRouter
+} from "./chunk-LEQYGOMJ.js";
 import {
   BrainstormService,
   CLASSIC_PIPELINE,
@@ -8,25 +11,38 @@ import {
   PipelineOrchestrator,
   PlanPersistence,
   collectStateLabels,
-  createAIRunner,
   eventBus,
   getE2eEnabled,
   getNoteSyncEnabled,
   getPipelineDef,
   isNoteSyncEnabledForIssue,
-  loadConfig,
-  logger,
   setE2eOverride,
   setNoteSyncOverride,
   validatePhaseRegistry
-} from "./chunk-TBIEB3JY.js";
+} from "./chunk-N5YK6YVI.js";
 import {
-  createSetupRouter
-} from "./chunk-I3T573SU.js";
+  IwikiImporter,
+  getProjectKnowledge,
+  loadKnowledge
+} from "./chunk-3JUHZGX5.js";
 import {
   setLocale,
   t
-} from "./chunk-OWVT3Z34.js";
+} from "./chunk-JFYAXNNS.js";
+import {
+  KnowledgeStore
+} from "./chunk-5JYCGAU3.js";
+import {
+  loadConfig
+} from "./chunk-KISVPNSV.js";
+import {
+  createAIRunner,
+  isShuttingDown,
+  setShuttingDown
+} from "./chunk-SWG2Y7YX.js";
+import {
+  logger
+} from "./chunk-TZ6C7HL5.js";
 
 // src/supplement/SupplementStore.ts
 import fs from "fs";
@@ -125,6 +141,7 @@ var IssuePoller = class {
   driveTimer = null;
   activeIssues = /* @__PURE__ */ new Set();
   lastAutoApproveCheckMs = 0;
+  discoveryPaused = false;
   constructor(config, gongfeng, tracker, orchestrator) {
     this.config = config;
     this.gongfeng = gongfeng;
@@ -153,7 +170,28 @@ var IssuePoller = class {
   getActiveIssueIids() {
     return [...this.activeIssues];
   }
+  getActiveCount() {
+    return this.activeIssues.size;
+  }
+  forceReleaseIssue(issueIid) {
+    const had = this.activeIssues.has(issueIid);
+    if (had) {
+      this.activeIssues.delete(issueIid);
+      logger3.info("Force-released issue from activeIssues", { issueIid });
+    }
+    return had;
+  }
+  pauseDiscovery() {
+    this.discoveryPaused = true;
+    logger3.info("Discovery paused (auto-update drain)");
+  }
+  resumeDiscovery() {
+    this.discoveryPaused = false;
+    logger3.info("Discovery resumed");
+  }
   async discover() {
+    if (isShuttingDown()) return;
+    if (this.discoveryPaused) return;
     try {
       logger3.debug("Discovering new issues...");
       const issues = await this.gongfeng.listIssues("opened", AUTO_FINISH_LABEL);
@@ -177,6 +215,7 @@ var IssuePoller = class {
     }
   }
   drive() {
+    if (isShuttingDown()) return;
     this.maybeAutoApproveWaiting();
     const maxConcurrent = this.config.poll.maxConcurrent;
     const available = maxConcurrent - this.activeIssues.size;
@@ -308,6 +347,8 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
   let git;
   let gongfeng;
   let supplementStore;
+  let autoUpdater;
+  let poller;
   if (config !== void 0) {
     tracker = trackerOrDeps;
     cfg = config;
@@ -323,6 +364,8 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
     git = deps.mainGit;
     gongfeng = deps.gongfeng;
     supplementStore = deps.supplementStore;
+    autoUpdater = deps.autoUpdater;
+    poller = deps.poller;
   }
   const router = Router();
   router.get("/api/issues", (_req, res) => {
@@ -395,6 +438,7 @@ function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mai
   router.post("/api/issues/:iid/restart", async (req, res) => {
     const iid = parseInt(req.params.iid, 10);
     try {
+      poller?.forceReleaseIssue(iid);
       await orch.restartIssue(iid);
       res.json({ success: true, message: `Issue #${iid} restarted` });
     } catch (err) {
@@ -802,6 +846,43 @@ data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
     const htmlBody = await marked(content);
     res.type("html").send(renderDocPage(iid, title, htmlBody, filename));
   });
+  router.get("/api/system/update-status", (_req, res) => {
+    if (!autoUpdater) {
+      res.status(501).json({ error: "Auto-updater not available" });
+      return;
+    }
+    res.json(autoUpdater.getStatus());
+  });
+  router.post("/api/system/update-check", async (_req, res) => {
+    if (!autoUpdater) {
+      res.status(501).json({ error: "Auto-updater not available" });
+      return;
+    }
+    try {
+      const result = await autoUpdater.checkForUpdate();
+      res.json(result);
+    } catch (err) {
+      const msg = err.message;
+      logger4.error("Manual update check failed", { error: msg });
+      res.status(500).json({ error: msg });
+    }
+  });
+  router.post("/api/system/update", async (_req, res) => {
+    if (!autoUpdater) {
+      res.status(501).json({ error: "Auto-updater not available" });
+      return;
+    }
+    try {
+      res.json({ success: true, message: "Update triggered" });
+      autoUpdater.triggerUpdate().catch((err) => {
+        logger4.error("Manual update failed", { error: err.message });
+      });
+    } catch (err) {
+      const msg = err.message;
+      logger4.error("Failed to trigger update", { error: msg });
+      res.status(500).json({ error: msg });
+    }
+  });
   return router;
 }
 var DOC_LABELS_FUNC = (filename) => t(`docLabel.${filename}`) || filename;
@@ -1063,9 +1144,553 @@ function extractTitle(sdd) {
   return "\u8111\u66B4\u751F\u6210\u7684\u9700\u6C42";
 }
 
+// src/web/routes/chat.ts
+import { Router as Router3 } from "express";
+var logger6 = logger.child("ChatRoutes");
+function sseWriter2(res) {
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  res.flushHeaders();
+  return (event) => {
+    try {
+      res.write(`event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`);
+    } catch {
+      logger6.warn("Failed to write SSE chat event");
+    }
+  };
+}
+function createChatRouter(deps) {
+  const router = Router3();
+  const { chatService } = deps;
+  router.post("/api/chat/sessions", (req, res) => {
+    try {
+      const { title } = req.body;
+      const session = chatService.createSession(title?.trim());
+      res.json({ success: true, session });
+    } catch (err) {
+      logger6.error("Failed to create chat session", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/chat/sessions", (_req, res) => {
+    try {
+      const sessions = chatService.listSessions();
+      res.json({ success: true, sessions });
+    } catch (err) {
+      logger6.error("Failed to list chat sessions", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/chat/sessions/:id", (req, res) => {
+    const session = chatService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    res.json({ success: true, session });
+  });
+  router.delete("/api/chat/sessions/:id", (req, res) => {
+    const deleted = chatService.deleteSession(req.params.id);
+    if (!deleted) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    res.json({ success: true });
+  });
+  router.post("/api/chat/sessions/:id/messages", async (req, res) => {
+    const session = chatService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const { content } = req.body;
+    if (!content?.trim()) {
+      res.status(400).json({ error: "content is required" });
+      return;
+    }
+    const write = sseWriter2(res);
+    try {
+      await chatService.sendMessage(req.params.id, content.trim(), write);
+      res.write(`event: done
+data: ${JSON.stringify({ type: "done" })}
+
+`);
+    } catch (err) {
+      write({ type: "error", data: { message: err.message } });
+    } finally {
+      res.end();
+    }
+  });
+  return router;
+}
+
+// src/web/routes/knowledge.ts
+import { Router as Router4 } from "express";
+var logger7 = logger.child("KnowledgeRoutes");
+function createKnowledgeRouter(deps) {
+  const router = Router4();
+  const { knowledgeStore, iwikiImporter, gongfengExtractor, config } = deps;
+  router.get("/api/knowledge/entries", (req, res) => {
+    try {
+      const type = req.query.type;
+      const q = req.query.q;
+      let entries;
+      if (q) {
+        entries = knowledgeStore.search(q);
+      } else {
+        entries = knowledgeStore.list(type || void 0);
+      }
+      res.json({ success: true, entries });
+    } catch (err) {
+      logger7.error("Failed to list knowledge entries", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/knowledge/entries/:id", (req, res) => {
+    try {
+      const entry = knowledgeStore.get(req.params.id);
+      if (!entry) {
+        res.status(404).json({ error: "Entry not found" });
+        return;
+      }
+      res.json({ success: true, entry });
+    } catch (err) {
+      logger7.error("Failed to get knowledge entry", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/api/knowledge/entries", (req, res) => {
+    try {
+      const { title, content, tags, type } = req.body;
+      if (!title?.trim() || !content?.trim()) {
+        res.status(400).json({ error: "title and content are required" });
+        return;
+      }
+      const entry = knowledgeStore.create({
+        type: type || "custom",
+        title: title.trim(),
+        content: content.trim(),
+        tags: tags || []
+      });
+      res.json({ success: true, entry });
+    } catch (err) {
+      logger7.error("Failed to create knowledge entry", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.put("/api/knowledge/entries/:id", (req, res) => {
+    try {
+      const { title, content, tags } = req.body;
+      const entry = knowledgeStore.update(req.params.id, { title, content, tags });
+      if (!entry) {
+        res.status(404).json({ error: "Entry not found" });
+        return;
+      }
+      res.json({ success: true, entry });
+    } catch (err) {
+      logger7.error("Failed to update knowledge entry", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.delete("/api/knowledge/entries/:id", (req, res) => {
+    try {
+      const deleted = knowledgeStore.delete(req.params.id);
+      if (!deleted) {
+        res.status(404).json({ error: "Entry not found" });
+        return;
+      }
+      res.json({ success: true });
+    } catch (err) {
+      logger7.error("Failed to delete knowledge entry", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/api/knowledge/analyze", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const workDir = config.project.workDir;
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const total = 4;
+    let heartbeat;
+    let closed = false;
+    function sendProgress(data) {
+      if (closed) return;
+      try {
+        res.write("data: " + JSON.stringify({ ...data, startedAt }) + "\n\n");
+      } catch {
+      }
+    }
+    (async () => {
+      try {
+        sendProgress({ step: "collecting", current: 1, total, message: "\u6536\u96C6\u9879\u76EE\u4FE1\u606F..." });
+        const { collectStaticInfo } = await import("./KnowledgeAnalyzer-EZSJT2MJ.js");
+        await collectStaticInfo(workDir);
+        sendProgress({ step: "analyzing", current: 2, total, message: "AI \u5206\u6790\u4E2D..." });
+        const aiStart = Date.now();
+        heartbeat = setInterval(() => {
+          sendProgress({ step: "analyzing", current: 2, total, message: "AI \u5206\u6790\u4E2D...", elapsed: Date.now() - aiStart });
+        }, 3e3);
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-RGAJPOOW.js");
+        const runner = createAIRunner2(config.ai);
+        const { analyze } = await import("./KnowledgeAnalyzer-EZSJT2MJ.js");
+        const knowledge = await analyze({ workDir, aiRunner: runner });
+        clearInterval(heartbeat);
+        heartbeat = void 0;
+        sendProgress({ step: "saving", current: 3, total, message: "\u4FDD\u5B58\u5206\u6790\u7ED3\u679C..." });
+        const { projectKnowledgeToMarkdown } = await import("./KnowledgeStore-4ROC6F56.js");
+        const markdown = projectKnowledgeToMarkdown(knowledge);
+        knowledgeStore.upsertProjectMeta(markdown, knowledge);
+        knowledgeStore.setLastAnalyzedAt(knowledge.generatedAt);
+        sendProgress({ step: "done", current: 4, total, message: "\u5206\u6790\u5B8C\u6210" });
+      } catch (err) {
+        if (heartbeat) clearInterval(heartbeat);
+        sendProgress({ step: "error", error: err.message });
+      } finally {
+        res.end();
+      }
+    })();
+    req.on("close", () => {
+      closed = true;
+      if (heartbeat) clearInterval(heartbeat);
+      res.end();
+    });
+  });
+  router.post("/api/knowledge/analyze-incremental", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const total = 3;
+    let heartbeat;
+    let closed = false;
+    function sendProgress(data) {
+      if (closed) return;
+      try {
+        res.write("data: " + JSON.stringify({ ...data, startedAt }) + "\n\n");
+      } catch {
+      }
+    }
+    (async () => {
+      try {
+        sendProgress({ step: "collecting", current: 1, total, message: "\u68C0\u6D4B\u53D8\u66F4\u5E76\u6536\u96C6\u4FE1\u606F..." });
+        const { createAIRunner: createAIRunner2 } = await import("./ai-runner-RGAJPOOW.js");
+        const { analyzeIncremental } = await import("./KnowledgeAnalyzer-EZSJT2MJ.js");
+        const runner = createAIRunner2(config.ai);
+        sendProgress({ step: "analyzing", current: 2, total, message: "\u589E\u91CF\u5206\u6790\u4E2D..." });
+        const aiStart = Date.now();
+        heartbeat = setInterval(() => {
+          sendProgress({ step: "analyzing", current: 2, total, message: "\u589E\u91CF\u5206\u6790\u4E2D...", elapsed: Date.now() - aiStart });
+        }, 3e3);
+        const result = await analyzeIncremental({
+          workDir: config.project.workDir,
+          aiRunner: runner,
+          store: knowledgeStore
+        });
+        clearInterval(heartbeat);
+        heartbeat = void 0;
+        if (!result) {
+          sendProgress({ step: "no_changes", current: total, total, message: "\u81EA\u4E0A\u6B21\u5206\u6790\u4EE5\u6765\u65E0\u53D8\u66F4" });
+        } else {
+          sendProgress({ step: "done", current: 3, total, message: "\u589E\u91CF\u5206\u6790\u5B8C\u6210", changedFiles: result.changedFiles });
+        }
+      } catch (err) {
+        if (heartbeat) clearInterval(heartbeat);
+        sendProgress({ step: "error", error: err.message });
+      } finally {
+        res.end();
+      }
+    })();
+    req.on("close", () => {
+      closed = true;
+      if (heartbeat) clearInterval(heartbeat);
+      res.end();
+    });
+  });
+  router.post("/api/knowledge/import/iwiki", async (req, res) => {
+    try {
+      const { url } = req.body;
+      if (!url?.trim()) {
+        res.status(400).json({ error: "url is required" });
+        return;
+      }
+      const entry = await iwikiImporter.importFromUrl(url.trim());
+      res.json({ success: true, entry });
+    } catch (err) {
+      logger7.error("Failed to import iwiki page", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/api/knowledge/import/gongfeng", async (req, res) => {
+    try {
+      if (!gongfengExtractor) {
+        res.status(400).json({ error: "Gongfeng extractor not available" });
+        return;
+      }
+      const { type, iid } = req.body;
+      if (!type || !iid) {
+        res.status(400).json({ error: "type and iid are required" });
+        return;
+      }
+      const workDir = config.project.workDir;
+      const entry = type === "issue" ? await gongfengExtractor.extractFromIssue(iid, workDir) : await gongfengExtractor.extractFromMR(iid, workDir);
+      res.json({ success: true, entry });
+    } catch (err) {
+      logger7.error("Failed to extract from gongfeng", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.post("/api/knowledge/entries/:id/sync", async (req, res) => {
+    try {
+      const entry = knowledgeStore.get(req.params.id);
+      if (!entry) {
+        res.status(404).json({ error: "Entry not found" });
+        return;
+      }
+      if (entry.type === "iwiki") {
+        const updated = await iwikiImporter.sync(req.params.id);
+        res.json({ success: true, entry: updated });
+      } else {
+        res.status(400).json({ error: "Only iwiki entries support sync" });
+      }
+    } catch (err) {
+      logger7.error("Failed to sync entry", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/knowledge/stats", (_req, res) => {
+    try {
+      const stats = knowledgeStore.getStats();
+      res.json({ success: true, stats });
+    } catch (err) {
+      logger7.error("Failed to get knowledge stats", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  return router;
+}
+
+// src/services/ChatService.ts
+import { randomUUID } from "crypto";
+
+// src/prompts/chat-templates.ts
+var SUMMARY_MAX_CHARS = 500;
+function buildChatSystemPrompt(knowledge, knowledgeEntries) {
+  let knowledgeSection = "";
+  if (knowledge) {
+    const parts = [];
+    if (knowledge.structure) {
+      parts.push(`- \u4E3B\u8981\u8BED\u8A00\uFF1A${knowledge.structure.primaryLanguage}`);
+      if (knowledge.structure.frameworks.length > 0) {
+        parts.push(`- \u6846\u67B6\uFF1A${knowledge.structure.frameworks.join(", ")}`);
+      }
+      if (knowledge.structure.description) {
+        parts.push(`- \u63CF\u8FF0\uFF1A${knowledge.structure.description}`);
+      }
+    }
+    if (knowledge.toolchain) {
+      parts.push(`- \u5305\u7BA1\u7406\u5668\uFF1A${knowledge.toolchain.packageManager}`);
+    }
+    if (parts.length > 0) {
+      knowledgeSection = `
+**\u9879\u76EE\u77E5\u8BC6\u5E93\uFF1A**
+${parts.join("\n")}
+`;
+    }
+  }
+  let entriesSection = "";
+  if (knowledgeEntries && knowledgeEntries.length > 0) {
+    const entryParts = knowledgeEntries.map((e) => {
+      const typeLabel = { "project-meta": "\u9879\u76EE\u5206\u6790", custom: "\u81EA\u5B9A\u4E49", iwiki: "iwiki\u6587\u6863", gongfeng: "\u5DE5\u8702\u63D0\u70BC" }[e.type] || e.type;
+      const summary = e.content.length > SUMMARY_MAX_CHARS ? e.content.slice(0, SUMMARY_MAX_CHARS) + "..." : e.content;
+      return `### [${typeLabel}] ${e.title}
+${summary}`;
+    });
+    entriesSection = `
+**\u77E5\u8BC6\u6761\u76EE\uFF08\u5171 ${knowledgeEntries.length} \u6761\uFF09\uFF1A**
+
+${entryParts.join("\n\n")}
+`;
+  }
+  return `\u4F60\u662F\u4E00\u4E2A\u667A\u80FD\u52A9\u624B\uFF0C\u4E13\u6CE8\u4E8E\u4E3A\u5F00\u53D1\u8005\u63D0\u4F9B\u6280\u672F\u54A8\u8BE2\u548C\u9879\u76EE\u5E2E\u52A9\u3002
+
+\u4F60\u7684\u804C\u8D23\uFF1A
+1. \u89E3\u7B54\u6280\u672F\u95EE\u9898\uFF08\u7F16\u7A0B\u8BED\u8A00\u3001\u6846\u67B6\u3001\u5DE5\u5177\u94FE\u7B49\uFF09
+2. \u63D0\u4F9B\u9879\u76EE\u76F8\u5173\u7684\u4F7F\u7528\u6307\u5357\u548C\u6700\u4F73\u5B9E\u8DF5
+3. \u5E2E\u52A9\u5206\u6790\u548C\u89E3\u51B3\u5F00\u53D1\u4E2D\u9047\u5230\u7684\u95EE\u9898
+4. \u7ED9\u51FA\u4EE3\u7801\u793A\u4F8B\u548C\u5B9E\u73B0\u5EFA\u8BAE
+
+\u56DE\u590D\u539F\u5219\uFF1A
+- \u4F7F\u7528\u6E05\u6670\u7B80\u6D01\u7684\u8BED\u8A00
+- \u7ED9\u51FA\u5177\u4F53\u53EF\u64CD\u4F5C\u7684\u5EFA\u8BAE
+- \u5FC5\u8981\u65F6\u63D0\u4F9B\u4EE3\u7801\u793A\u4F8B
+- \u5982\u679C\u4E0D\u786E\u5B9A\uFF0C\u660E\u786E\u8BF4\u660E\u5E76\u7ED9\u51FA\u53EF\u80FD\u7684\u65B9\u5411
+- \u4F7F\u7528 Markdown \u683C\u5F0F\u7EC4\u7EC7\u56DE\u590D
+${knowledgeSection}${entriesSection}
+\u8BF7\u76F4\u63A5\u56DE\u7B54\u7528\u6237\u7684\u95EE\u9898\uFF0C\u4E0D\u8981\u8F93\u51FA\u591A\u4F59\u7684\u5BD2\u6684\u3002`;
+}
+
+// src/services/ChatService.ts
+var logger8 = logger.child("Chat");
+function agentConfigToAIConfig(agentCfg, timeoutMs) {
+  return {
+    mode: agentCfg.mode,
+    binary: agentCfg.binary,
+    phaseTimeoutMs: timeoutMs,
+    nvmNodeVersion: agentCfg.nvmNodeVersion,
+    model: agentCfg.model
+  };
+}
+var ChatService = class {
+  sessions = /* @__PURE__ */ new Map();
+  runner;
+  config;
+  workDir;
+  knowledgeStore;
+  constructor(config, knowledgeStore) {
+    this.config = config.chat;
+    this.workDir = config.project.workDir;
+    this.knowledgeStore = knowledgeStore;
+    this.runner = createAIRunner(
+      agentConfigToAIConfig(this.config.agent, this.config.timeoutMs)
+    );
+  }
+  createSession(title) {
+    const session = {
+      id: randomUUID(),
+      title: title || "\u65B0\u5BF9\u8BDD",
+      messages: [],
+      status: "idle",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.sessions.set(session.id, session);
+    logger8.info("Created chat session", { sessionId: session.id });
+    return session;
+  }
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+  listSessions() {
+    return Array.from(this.sessions.values()).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+  deleteSession(id) {
+    return this.sessions.delete(id);
+  }
+  async sendMessage(sessionId, content, onEvent) {
+    const session = this.requireSession(sessionId);
+    if (session.messages.length >= this.config.maxSessionMessages) {
+      throw new Error(`Session message limit reached (${this.config.maxSessionMessages})`);
+    }
+    const userMessage = {
+      id: randomUUID(),
+      role: "user",
+      content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    session.messages.push(userMessage);
+    session.status = "thinking";
+    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const assistantMessageId = randomUUID();
+    let assistantContent = "";
+    try {
+      onEvent?.({
+        type: "message:thinking",
+        data: { status: "connecting" },
+        messageId: assistantMessageId
+      });
+      const isFirstMessage = session.messages.length === 1;
+      const knowledgeEntries = this.knowledgeStore?.getAllEntries();
+      const prompt = isFirstMessage ? `${buildChatSystemPrompt(getProjectKnowledge(), knowledgeEntries)}
+
+\u7528\u6237\u95EE\u9898\uFF1A${content}` : content;
+      const result = await this.runner.run({
+        prompt,
+        workDir: this.workDir,
+        timeoutMs: this.config.timeoutMs,
+        sessionId: session.aiSessionId,
+        continueSession: !!session.aiSessionId,
+        onStreamEvent: (evt) => {
+          if (evt.content && typeof evt.content === "object") {
+            const content2 = evt.content;
+            if (content2.type === "assistant") {
+              const message = content2.message;
+              if (message?.content && Array.isArray(message.content)) {
+                for (const block of message.content) {
+                  if (block.type === "text" && block.text) {
+                    assistantContent += block.text;
+                  }
+                }
+              }
+            }
+          } else if (evt.content && typeof evt.content === "string") {
+            if (evt.type === "partial" || evt.type === "raw") {
+              assistantContent += evt.content;
+            }
+          }
+          onEvent?.({
+            type: "message:chunk",
+            data: evt,
+            messageId: assistantMessageId
+          });
+        }
+      });
+      const finalContent = assistantContent.trim() ? assistantContent : result.success ? result.output : result.output || "AI \u672A\u8FD4\u56DE\u5185\u5BB9";
+      const assistantMessage = {
+        id: assistantMessageId,
+        role: "assistant",
+        content: finalContent,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      session.messages.push(assistantMessage);
+      session.aiSessionId = result.sessionId ?? session.aiSessionId;
+      session.status = result.success ? "idle" : "error";
+      if (!result.success) {
+        session.error = result.output;
+      }
+      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (session.title === "\u65B0\u5BF9\u8BDD" && session.messages.length >= 2) {
+        session.title = content.slice(0, 50) + (content.length > 50 ? "..." : "");
+      }
+      onEvent?.({
+        type: "message:complete",
+        data: { message: assistantMessage },
+        messageId: assistantMessageId
+      });
+      return assistantMessage;
+    } catch (err) {
+      session.status = "error";
+      session.error = err.message;
+      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      onEvent?.({
+        type: "error",
+        data: { message: err.message },
+        messageId: assistantMessageId
+      });
+      throw err;
+    }
+  }
+  requireSession(id) {
+    const session = this.sessions.get(id);
+    if (!session) {
+      throw new Error(`Chat session not found: ${id}`);
+    }
+    return session;
+  }
+};
+
 // src/web/WebServer.ts
 var __dirname = path3.dirname(fileURLToPath(import.meta.url));
-var logger6 = logger.child("WebServer");
+var logger9 = logger.child("WebServer");
 var WebServer = class {
   app;
   server = null;
@@ -1093,7 +1718,9 @@ var WebServer = class {
         orchestrator: deps.orchestrator,
         mainGit: deps.mainGit,
         gongfeng: deps.gongfeng,
-        supplementStore: deps.supplementStore
+        supplementStore: deps.supplementStore,
+        autoUpdater: deps.autoUpdater,
+        poller: deps.poller
       };
     }
     this.app = express();
@@ -1110,6 +1737,25 @@ var WebServer = class {
       });
       this.app.use(brainstormRouter);
     }
+    const knowledgeDataDir = path3.join(apiDeps.config.project.workDir, "data", "knowledge");
+    const knowledgeStore = new KnowledgeStore(knowledgeDataDir);
+    if (apiDeps.config.chat.enabled) {
+      const chatService = new ChatService(apiDeps.config, knowledgeStore);
+      const chatRouter = createChatRouter({ chatService });
+      this.app.use(chatRouter);
+    }
+    const iwikiImporter = new IwikiImporter(knowledgeStore, {
+      authCookie: apiDeps.config.iwiki?.authCookie,
+      authToken: apiDeps.config.iwiki?.authToken
+    });
+    const legacyKnowledgePath = path3.join(apiDeps.config.project.workDir, "knowledge.json");
+    knowledgeStore.migrateFromLegacy(legacyKnowledgePath);
+    const knowledgeRouter = createKnowledgeRouter({
+      knowledgeStore,
+      iwikiImporter,
+      config: apiDeps.config
+    });
+    this.app.use(knowledgeRouter);
     const publicDir = apiDeps.config.web.frontendDistDir;
     this.app.use(express.static(publicDir));
     this.app.get("{*path}", (_req, res) => {
@@ -1119,7 +1765,7 @@ var WebServer = class {
   start() {
     return new Promise((resolve) => {
       this.server = this.app.listen(this.port, () => {
-        logger6.info(`Web UI available at http://localhost:${this.port}`);
+        logger9.info(`Web UI available at http://localhost:${this.port}`);
         resolve();
       });
     });
@@ -1128,7 +1774,7 @@ var WebServer = class {
     if (this.server) {
       this.server.close();
       this.server = null;
-      logger6.info("Web server stopped");
+      logger9.info("Web server stopped");
     }
   }
 };
@@ -1137,10 +1783,10 @@ var WebServer = class {
 import express2 from "express";
 
 // src/webhook/WebhookHandler.ts
-import { Router as Router3 } from "express";
+import { Router as Router5 } from "express";
 
 // src/webhook/CommandParser.ts
-var TRIGGER = "@issue-auto";
+var TRIGGERS = ["@issue-auto", "@iaf"];
 var PHASE_ALIAS = {
   "\u5206\u6790": "analysis",
   "\u9700\u6C42\u5206\u6790": "analysis",
@@ -1238,15 +1884,27 @@ var EXACT_PATTERNS = [
   {
     regex: /(?:清理评论|清除评论|删除评论)/,
     build: () => ({ intent: "clean-notes" })
+  },
+  {
+    regex: /fix-conflict\b/i,
+    build: () => ({ intent: "fix-conflict" })
+  },
+  {
+    regex: /(?:修复冲突|解决冲突|处理冲突|冲突修复|fix\s*冲突)/,
+    build: () => ({ intent: "fix-conflict" })
   }
 ];
 function containsTrigger(text) {
-  return text.includes(TRIGGER);
+  const lower = text.toLowerCase();
+  return TRIGGERS.some((t2) => lower.includes(t2));
 }
 function extractCommandText(text) {
-  const idx = text.indexOf(TRIGGER);
-  if (idx < 0) return null;
-  return text.slice(idx + TRIGGER.length).trim();
+  const lower = text.toLowerCase();
+  for (const trigger of TRIGGERS) {
+    const idx = lower.indexOf(trigger);
+    if (idx >= 0) return text.slice(idx + trigger.length).trim();
+  }
+  return null;
 }
 function parseExact(commandText) {
   for (const { regex, build } of EXACT_PATTERNS) {
@@ -1259,28 +1917,30 @@ function parseExact(commandText) {
 // src/webhook/CommandExecutor.ts
 import path4 from "path";
 import fs3 from "fs";
-var logger7 = logger.child("CommandExecutor");
+var logger10 = logger.child("CommandExecutor");
 var CommandExecutor = class {
   tracker;
   orchestrator;
   supplementStore;
   gongfeng;
   config;
+  poller;
   constructor(deps) {
     this.tracker = deps.tracker;
     this.orchestrator = deps.orchestrator;
     this.supplementStore = deps.supplementStore;
     this.gongfeng = deps.gongfeng;
     this.config = deps.config;
+    this.poller = deps.poller;
   }
   async execute(issueIid, issueId, command) {
-    logger7.info("Executing webhook command", { issueIid, command });
+    logger10.info("Executing webhook command", { issueIid, command });
     let result;
     try {
       result = await this.dispatch(issueIid, command);
     } catch (err) {
       const msg = err.message;
-      logger7.error("Webhook command failed", { issueIid, error: msg });
+      logger10.error("Webhook command failed", { issueIid, error: msg });
       result = { success: false, message: msg };
     }
     await this.replyToIssue(issueId, result);
@@ -1308,6 +1968,8 @@ var CommandExecutor = class {
         return this.handleStopPreview(iid);
       case "clean-notes":
         return this.handleCleanNotes(iid);
+      case "fix-conflict":
+        return this.handleFixConflict(iid);
       default:
         return { success: false, message: "Unknown command" };
     }
@@ -1399,6 +2061,7 @@ var CommandExecutor = class {
   }
   async handleRestart(iid) {
     try {
+      this.poller?.forceReleaseIssue(iid);
       await this.orchestrator.restartIssue(iid);
     } catch (err) {
       return this.fail(err.message);
@@ -1452,6 +2115,22 @@ var CommandExecutor = class {
       return this.fail(err.message);
     }
   }
+  handleFixConflict(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    const isCompleted = record.state === "completed" /* Completed */;
+    const isConflictRetry = record.state === "failed" /* Failed */ && record.failedAtState === "resolving_conflict" /* ResolvingConflict */;
+    if (!isCompleted && !isConflictRetry) {
+      return this.fail(t("conflict.invalidState", { state: record.state }));
+    }
+    if (!record.mrUrl) {
+      return this.fail(t("conflict.noMr", { iid }));
+    }
+    this.orchestrator.resolveConflict(iid).catch((err) => {
+      logger10.error("Async conflict resolution failed", { iid, error: err.message });
+    });
+    return this.ok(t("conflict.startedMsg"));
+  }
   saveSupplement(iid, context) {
     const existing = this.supplementStore.get(iid);
     const prev = existing?.freeText?.trim() ?? "";
@@ -1474,7 +2153,7 @@ ${context}` : context;
       const prefix = result.success ? "" : "> **Failed**\n>\n> ";
       await this.gongfeng.createIssueNote(issueId, `${prefix}${result.message}`);
     } catch (err) {
-      logger7.warn("Failed to reply", { issueId, error: err.message });
+      logger10.warn("Failed to reply", { issueId, error: err.message });
     }
   }
   ok(message) {
@@ -1530,9 +2209,9 @@ var NoteDeduplicator = class {
 };
 
 // src/webhook/WebhookHandler.ts
-var logger8 = logger.child("WebhookHandler");
+var logger11 = logger.child("WebhookHandler");
 function createWebhookRouter(deps) {
-  const router = Router3();
+  const router = Router5();
   const executor = new CommandExecutor(deps);
   const dedup = new NoteDeduplicator();
   const { config, intentRecognizer } = deps;
@@ -1545,19 +2224,15 @@ function createWebhookRouter(deps) {
     if (config.webhook.secret) {
       const token = req.headers["x-gitlab-token"];
       if (token !== config.webhook.secret) {
-        logger8.warn("Webhook token mismatch");
+        logger11.warn("Webhook token mismatch");
         res.status(401).json({ error: "Invalid token" });
         return;
       }
     }
     const event = req.body;
-    if (!isNoteOnIssue(event)) {
-      res.json({ ignored: true, reason: "not a note on issue" });
-      return;
-    }
     const noteBody = event.object_attributes.note;
     if (!containsTrigger(noteBody)) {
-      res.json({ ignored: true, reason: "no @issue-auto trigger" });
+      res.json({ ignored: true, reason: "no trigger found" });
       return;
     }
     if (isSelfNote(event, selfToken)) {
@@ -1566,32 +2241,46 @@ function createWebhookRouter(deps) {
     }
     const noteId = event.object_attributes.id;
     if (dedup.isDuplicate(noteId)) {
-      logger8.debug("Duplicate note, skipping", { noteId });
+      logger11.debug("Duplicate note, skipping", { noteId });
       res.json({ ignored: true, reason: "duplicate" });
       return;
     }
-    const issueIid = event.issue?.iid;
-    const issueId = event.issue?.id;
-    if (!issueIid) {
-      res.status(400).json({ error: "Missing issue iid in webhook payload" });
-      return;
-    }
-    if (!issueId) {
-      logger8.info("Webhook received with null issue id (likely a test ping)", { issueIid });
-      res.json({ accepted: true, noteId, issueIid, test: true });
-      return;
+    if (isNoteOnIssue(event)) {
+      const issueIid = event.issue?.iid;
+      const issueId = event.issue?.id;
+      if (!issueIid) {
+        res.status(400).json({ error: "Missing issue iid in webhook payload" });
+        return;
+      }
+      if (!issueId) {
+        logger11.info("Webhook received with null issue id (likely a test ping)", { issueIid });
+        res.json({ accepted: true, noteId, issueIid, test: true });
+        return;
+      }
+      res.json({ accepted: true, noteId, issueIid });
+      processCommandAsync(
+        noteBody,
+        issueIid,
+        issueId,
+        executor,
+        intentRecognizer,
+        config,
+        deps.tracker,
+        deps.gongfeng
+      );
+    } else if (isNoteOnMergeRequest(event)) {
+      const mr = event.merge_request;
+      res.json({ accepted: true, noteId, mrIid: mr.iid });
+      processMRCommandAsync(
+        noteBody,
+        mr,
+        executor,
+        deps.tracker,
+        deps.gongfeng
+      );
+    } else {
+      res.json({ ignored: true, reason: "not a note on issue or MR" });
     }
-    res.json({ accepted: true, noteId, issueIid });
-    processCommandAsync(
-      noteBody,
-      issueIid,
-      issueId,
-      executor,
-      intentRecognizer,
-      config,
-      deps.tracker,
-      deps.gongfeng
-    );
   });
   return router;
 }
@@ -1604,19 +2293,19 @@ async function processCommandAsync(noteBody, issueIid, issueId, executor, intent
     if (!command && intentRecognizer && config.webhook.llmFallback) {
       const record = tracker.get(issueIid);
       const state = record?.state;
-      logger8.info("Falling back to LLM intent recognition", { issueIid });
+      logger11.info("Falling back to LLM intent recognition", { issueIid });
       command = await intentRecognizer.recognize(cmdText, state);
     }
     if (!command) {
-      logger8.info("Could not parse command from note", { issueIid, text: cmdText.slice(0, 100) });
+      logger11.info("Could not parse command from note", { issueIid, text: cmdText.slice(0, 100) });
       await gongfeng.createIssueNote(issueId, HELP_TEXT_FUNC()).catch(
-        (e) => logger8.warn("Failed to reply help text", { error: e.message })
+        (e) => logger11.warn("Failed to reply help text", { error: e.message })
       );
       return;
     }
     await executor.execute(issueIid, issueId, command);
   } catch (err) {
-    logger8.error("Failed to process webhook command", {
+    logger11.error("Failed to process webhook command", {
       issueIid,
       error: err.message
     });
@@ -1625,13 +2314,62 @@ async function processCommandAsync(noteBody, issueIid, issueId, executor, intent
 function isNoteOnIssue(event) {
   return event.object_kind === "note" && event.object_attributes?.noteable_type?.toLowerCase() === "issue" && !!event.issue;
 }
+function isNoteOnMergeRequest(event) {
+  return event.object_kind === "note" && (event.object_attributes?.noteable_type?.toLowerCase() === "review" || event.object_attributes?.noteable_type?.toLowerCase() === "mergerequest") && !!event.merge_request;
+}
+var MR_SUPPORTED_INTENTS = /* @__PURE__ */ new Set(["fix-conflict", "status"]);
+async function processMRCommandAsync(noteBody, mr, executor, tracker, gongfeng) {
+  try {
+    const cmdText = extractCommandText(noteBody);
+    if (!cmdText) return;
+    const command = parseExact(cmdText);
+    if (!command) {
+      await gongfeng.createMergeRequestNote(mr.iid, HELP_TEXT_FUNC()).catch(
+        (e) => logger11.warn("Failed to reply help text on MR", { error: e.message })
+      );
+      return;
+    }
+    if (!MR_SUPPORTED_INTENTS.has(command.intent)) {
+      await gongfeng.createMergeRequestNote(
+        mr.iid,
+        `\`${command.intent}\` command is not supported on MR comments. Please use Issue comments instead.`
+      ).catch(
+        (e) => logger11.warn("Failed to reply on MR", { error: e.message })
+      );
+      return;
+    }
+    const allRecords = tracker.getAll();
+    const record = allRecords.find((r) => r.branchName === mr.source_branch);
+    if (!record) {
+      await gongfeng.createMergeRequestNote(
+        mr.iid,
+        `Could not find a tracked issue for branch \`${mr.source_branch}\`.`
+      ).catch(
+        (e) => logger11.warn("Failed to reply on MR", { error: e.message })
+      );
+      return;
+    }
+    const result = await executor.execute(record.issueIid, record.issueId, command);
+    try {
+      const prefix = result.success ? "" : "> **Failed**\n>\n> ";
+      await gongfeng.createMergeRequestNote(mr.iid, `${prefix}${result.message}`);
+    } catch (err) {
+      logger11.warn("Failed to reply on MR", { mrIid: mr.iid, error: err.message });
+    }
+  } catch (err) {
+    logger11.error("Failed to process MR webhook command", {
+      mrIid: mr.iid,
+      error: err.message
+    });
+  }
+}
 function isSelfNote(_event, _selfToken) {
   return false;
 }
 
 // src/webhook/IntentRecognizer.ts
 import { spawn } from "child_process";
-var logger9 = logger.child("IntentRecognizer");
+var logger12 = logger.child("IntentRecognizer");
 var VALID_INTENTS = [
   "retry",
   "retry-from",
@@ -1639,7 +2377,8 @@ var VALID_INTENTS = [
   "approve",
   "reject",
   "status",
-  "restart"
+  "restart",
+  "fix-conflict"
 ];
 var VALID_PHASES = [
   "analysis",
@@ -1672,7 +2411,7 @@ ${userComment}`;
       const rawOutput = await this.runLLM(userPrompt);
       return this.parseResponse(rawOutput);
     } catch (err) {
-      logger9.error("Intent recognition failed", { error: err.message });
+      logger12.error("Intent recognition failed", { error: err.message });
       return null;
     }
   }
@@ -1680,20 +2419,20 @@ ${userComment}`;
   parseResponse(raw) {
     const jsonMatch = raw.match(/\{[\s\S]*\}/);
     if (!jsonMatch) {
-      logger9.warn("No JSON found in LLM response", { raw: raw.slice(0, 200) });
+      logger12.warn("No JSON found in LLM response", { raw: raw.slice(0, 200) });
       return null;
     }
     let parsed;
     try {
       parsed = JSON.parse(jsonMatch[0]);
     } catch {
-      logger9.warn("Failed to parse JSON from LLM", { raw: jsonMatch[0].slice(0, 200) });
+      logger12.warn("Failed to parse JSON from LLM", { raw: jsonMatch[0].slice(0, 200) });
       return null;
     }
     if (parsed.intent === null || parsed.intent === "null") return null;
     const intent = String(parsed.intent);
     if (!VALID_INTENTS.includes(intent)) {
-      logger9.warn("Invalid intent from LLM", { intent });
+      logger12.warn("Invalid intent from LLM", { intent });
       return null;
     }
     const result = { intent };
@@ -1735,7 +2474,7 @@ ${userComment}`;
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code !== 0) {
-          logger9.warn("LLM process exited with non-zero code", { code, stderr: stderr.slice(0, 300) });
+          logger12.warn("LLM process exited with non-zero code", { code, stderr: stderr.slice(0, 300) });
         }
         resolve(stdout);
       });
@@ -1750,7 +2489,7 @@ ${userComment}`;
 };
 
 // src/webhook/WebhookServer.ts
-var logger10 = logger.child("WebhookServer");
+var logger13 = logger.child("WebhookServer");
 var WebhookServer = class {
   app;
   server = null;
@@ -1768,7 +2507,8 @@ var WebhookServer = class {
       supplementStore: deps.supplementStore,
       gongfeng: deps.gongfeng,
       config: deps.config,
-      intentRecognizer
+      intentRecognizer,
+      poller: deps.poller
     };
     this.app = express2();
     this.app.use(express2.json());
@@ -1780,7 +2520,7 @@ var WebhookServer = class {
   start() {
     return new Promise((resolve) => {
       this.server = this.app.listen(this.port, () => {
-        logger10.info(`Webhook server listening on port ${this.port}`);
+        logger13.info(`Webhook server listening on port ${this.port}`);
         resolve();
       });
     });
@@ -1789,7 +2529,7 @@ var WebhookServer = class {
     if (this.server) {
       this.server.close();
       this.server = null;
-      logger10.info("Webhook server stopped");
+      logger13.info("Webhook server stopped");
     }
   }
 };
@@ -1797,7 +2537,7 @@ var WebhookServer = class {
 // src/web/AgentLogStore.ts
 import fs4 from "fs";
 import path5 from "path";
-var logger11 = logger.child("AgentLogStore");
+var logger14 = logger.child("AgentLogStore");
 var MAX_LOGS_PER_ISSUE = 2e4;
 var DEBUG_EVENT_TYPES = /* @__PURE__ */ new Set([
   "thinking",
@@ -1824,7 +2564,7 @@ var AgentLogStore = class {
     eventBus.on("pipeline:progress", (payload) => {
       this.handlePipelineProgress(payload);
     });
-    logger11.info("AgentLogStore listening for events");
+    logger14.info("AgentLogStore listening for events");
   }
   getLogs(issueIid) {
     const filePath = this.logFilePath(issueIid);
@@ -1834,7 +2574,7 @@ var AgentLogStore = class {
       if (!raw) return [];
       return raw.split("\n").map((line) => JSON.parse(line));
     } catch (err) {
-      logger11.warn("Failed to read agent logs", { issueIid, error: err.message });
+      logger14.warn("Failed to read agent logs", { issueIid, error: err.message });
       return [];
     }
   }
@@ -1854,7 +2594,7 @@ var AgentLogStore = class {
 `, "utf-8");
       this.trimIfNeeded(issueIid, filePath);
     } catch (err) {
-      logger11.warn("Failed to write agent log", { issueIid, error: err.message });
+      logger14.warn("Failed to write agent log", { issueIid, error: err.message });
     }
   }
   trimIfNeeded(issueIid, filePath) {
@@ -1866,7 +2606,7 @@ var AgentLogStore = class {
         const trimmed = lines.slice(-MAX_LOGS_PER_ISSUE);
         fs4.writeFileSync(filePath, `${trimmed.join("\n")}
 `, "utf-8");
-        logger11.info("Agent logs trimmed", { issueIid, from: lines.length, to: trimmed.length });
+        logger14.info("Agent logs trimmed", { issueIid, from: lines.length, to: trimmed.length });
       }
     } catch {
     }
@@ -1936,14 +2676,317 @@ var AgentLogStore = class {
   }
 };
 
-// src/index.ts
+// src/updater/VersionChecker.ts
+import { readFileSync, existsSync } from "fs";
 import path6 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
+var logger15 = logger.child("VersionChecker");
+function compareSemver(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+}
+var VersionChecker = class {
+  registry;
+  packageName;
+  currentVersion;
+  constructor(registry) {
+    this.registry = registry.replace(/\/$/, "");
+    const pkg = this.readPackageJson();
+    this.packageName = pkg.name;
+    this.currentVersion = pkg.version;
+  }
+  getCurrentVersion() {
+    return this.currentVersion;
+  }
+  getPackageName() {
+    return this.packageName;
+  }
+  async check() {
+    const latestVersion = await this.fetchLatestVersion();
+    const hasUpdate = compareSemver(latestVersion, this.currentVersion) > 0;
+    logger15.info("Version check completed", {
+      current: this.currentVersion,
+      latest: latestVersion,
+      hasUpdate
+    });
+    return {
+      currentVersion: this.currentVersion,
+      latestVersion,
+      hasUpdate
+    };
+  }
+  async fetchLatestVersion() {
+    const url = `${this.registry}/${encodeURIComponent(this.packageName)}`;
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(15e3),
+      headers: { Accept: "application/json" }
+    });
+    if (!response.ok) {
+      throw new Error(`Registry returned HTTP ${response.status} for ${this.packageName}`);
+    }
+    const data = await response.json();
+    const latest = data["dist-tags"]?.latest;
+    if (!latest) {
+      throw new Error(`No latest version found in dist-tags for ${this.packageName}`);
+    }
+    return latest;
+  }
+  readPackageJson() {
+    for (let dir = __dirname2; dir !== path6.dirname(dir); dir = path6.dirname(dir)) {
+      const candidate = path6.join(dir, "package.json");
+      if (existsSync(candidate)) {
+        try {
+          const content = JSON.parse(readFileSync(candidate, "utf-8"));
+          if (content.name && content.version) return content;
+        } catch {
+        }
+      }
+    }
+    throw new Error("Could not find package.json");
+  }
+};
+
+// src/updater/UpdateExecutor.ts
+import { execFile } from "child_process";
+import { cpSync, existsSync as existsSync2, rmSync } from "fs";
+import path7 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path7.dirname(fileURLToPath3(import.meta.url));
+var logger16 = logger.child("UpdateExecutor");
+function findProjectRoot() {
+  for (let dir = __dirname3; dir !== path7.dirname(dir); dir = path7.dirname(dir)) {
+    if (existsSync2(path7.join(dir, "package.json"))) {
+      return dir;
+    }
+  }
+  throw new Error("Could not find project root");
+}
+function run(cmd, args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { cwd, timeout: timeoutMs, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) {
+        reject(new Error(`${cmd} ${args.join(" ")} failed: ${stderr || err.message}`));
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+var UpdateExecutor = class {
+  packageName;
+  projectRoot;
+  constructor(packageName) {
+    this.packageName = packageName;
+    this.projectRoot = findProjectRoot();
+  }
+  async execute(targetVersion) {
+    const distDir = path7.join(this.projectRoot, "dist");
+    const backupDir = path7.join(this.projectRoot, "dist.backup");
+    logger16.info("Backing up dist directory...");
+    if (existsSync2(backupDir)) {
+      rmSync(backupDir, { recursive: true, force: true });
+    }
+    if (existsSync2(distDir)) {
+      cpSync(distDir, backupDir, { recursive: true });
+    }
+    try {
+      logger16.info("Running pnpm update...", { package: this.packageName, targetVersion });
+      await run("pnpm", ["update", this.packageName], this.projectRoot, 12e4);
+      logger16.info("Running pnpm build...");
+      await run("pnpm", ["build"], this.projectRoot, 12e4);
+    } catch (err) {
+      logger16.error("Update failed, rolling back dist...", { error: err.message });
+      if (existsSync2(backupDir)) {
+        if (existsSync2(distDir)) {
+          rmSync(distDir, { recursive: true, force: true });
+        }
+        cpSync(backupDir, distDir, { recursive: true });
+        rmSync(backupDir, { recursive: true, force: true });
+      }
+      throw err;
+    }
+    logger16.info("Reloading via PM2...");
+    try {
+      await run("pm2", ["reload", "issue-auto-finish"], this.projectRoot, 3e4);
+    } catch (err) {
+      logger16.warn("PM2 reload failed, the process may need manual restart", {
+        error: err.message
+      });
+      throw err;
+    }
+    if (existsSync2(backupDir)) {
+      rmSync(backupDir, { recursive: true, force: true });
+    }
+    logger16.info("Update completed successfully", { version: targetVersion });
+  }
+};
+
+// src/updater/AutoUpdater.ts
+var logger17 = logger.child("AutoUpdater");
+var INITIAL_DELAY_MS = 3e4;
+var AutoUpdater = class {
+  config;
+  poller;
+  versionChecker;
+  updateExecutor;
+  state = "idle";
+  latestVersion = null;
+  lastCheckAt = null;
+  lastError = null;
+  updateInProgress = false;
+  checkTimer = null;
+  initialTimer = null;
+  constructor(config, poller) {
+    this.config = config;
+    this.poller = poller;
+    this.versionChecker = new VersionChecker(config.autoUpdate.registry);
+    this.updateExecutor = new UpdateExecutor(this.versionChecker.getPackageName());
+  }
+  start() {
+    if (!this.config.autoUpdate.enabled) {
+      logger17.info("Auto-update is disabled");
+      return;
+    }
+    logger17.info("Auto-updater starting", {
+      intervalMs: this.config.autoUpdate.intervalMs,
+      registry: this.config.autoUpdate.registry
+    });
+    this.initialTimer = setTimeout(() => {
+      this.initialTimer = null;
+      this.performCheck();
+      this.checkTimer = setInterval(() => this.performCheck(), this.config.autoUpdate.intervalMs);
+    }, INITIAL_DELAY_MS);
+  }
+  stop() {
+    if (this.initialTimer) {
+      clearTimeout(this.initialTimer);
+      this.initialTimer = null;
+    }
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = null;
+    }
+    logger17.info("Auto-updater stopped");
+  }
+  getStatus() {
+    return {
+      state: this.state,
+      enabled: this.config.autoUpdate.enabled,
+      currentVersion: this.versionChecker.getCurrentVersion(),
+      latestVersion: this.latestVersion,
+      lastCheckAt: this.lastCheckAt,
+      lastError: this.lastError
+    };
+  }
+  async checkForUpdate() {
+    this.state = "checking";
+    eventBus.emitTyped("update:checking", {});
+    try {
+      const result = await this.versionChecker.check();
+      this.latestVersion = result.latestVersion;
+      this.lastCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.lastError = null;
+      if (result.hasUpdate) {
+        this.state = "update-available";
+        eventBus.emitTyped("update:available", {
+          currentVersion: result.currentVersion,
+          latestVersion: result.latestVersion
+        });
+      } else {
+        this.state = "idle";
+      }
+      return result;
+    } catch (err) {
+      const message = err.message;
+      this.lastError = message;
+      this.state = "failed";
+      eventBus.emitTyped("update:failed", { error: message });
+      throw err;
+    }
+  }
+  async triggerUpdate() {
+    if (this.updateInProgress) {
+      logger17.warn("Update already in progress, skipping");
+      return;
+    }
+    this.updateInProgress = true;
+    try {
+      if (!this.latestVersion) {
+        const result = await this.checkForUpdate();
+        if (!result.hasUpdate) {
+          logger17.info("No update available");
+          return;
+        }
+      }
+      const targetVersion = this.latestVersion;
+      this.state = "draining";
+      logger17.info("Draining active issues before update...");
+      this.poller.pauseDiscovery();
+      const drainStart = Date.now();
+      const drainTimeout = this.config.autoUpdate.drainTimeoutMs;
+      while (this.poller.getActiveCount() > 0 && Date.now() - drainStart < drainTimeout) {
+        logger17.info("Waiting for active issues to complete...", {
+          active: this.poller.getActiveCount()
+        });
+        await new Promise((resolve) => setTimeout(resolve, 5e3));
+      }
+      if (this.poller.getActiveCount() > 0) {
+        logger17.warn("Drain timeout reached, proceeding with update", {
+          active: this.poller.getActiveCount()
+        });
+      }
+      this.state = "updating";
+      eventBus.emitTyped("update:downloading", { version: targetVersion });
+      logger17.info("Executing update...", { targetVersion });
+      await this.updateExecutor.execute(targetVersion);
+      this.state = "completed";
+      eventBus.emitTyped("update:completed", { version: targetVersion });
+      logger17.info("Update completed", { version: targetVersion });
+    } catch (err) {
+      const message = err.message;
+      this.lastError = message;
+      this.state = "failed";
+      eventBus.emitTyped("update:failed", { error: message });
+      logger17.error("Update failed", { error: message });
+      this.poller.resumeDiscovery();
+    } finally {
+      this.updateInProgress = false;
+    }
+  }
+  async performCheck() {
+    if (this.updateInProgress) return;
+    try {
+      const result = await this.checkForUpdate();
+      if (result.hasUpdate) {
+        logger17.info("New version available, starting update", {
+          current: result.currentVersion,
+          latest: result.latestVersion
+        });
+        await this.triggerUpdate();
+      }
+    } catch (err) {
+      logger17.warn("Periodic version check failed", { error: err.message });
+    }
+  }
+};
+
+// src/index.ts
+import path8 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __dirname4 = path8.dirname(fileURLToPath4(import.meta.url));
 async function main() {
   logger.info("Issue Auto-Finish service starting...");
   const config = loadConfig();
   setLocale(config.locale);
+  loadKnowledge(config.knowledgePath);
   const allAiPhaseNames = [
     ...CLASSIC_PIPELINE.phases.filter((p) => p.kind === "ai").map((p) => p.name),
     ...PLAN_MODE_PIPELINE.phases.filter((p) => p.kind === "ai").map((p) => p.name)
@@ -1952,7 +2995,7 @@ async function main() {
   const gongfeng = new GongfengClient(config.gongfeng);
   const git = new GitOperations(config.project.gitRootDir);
   const aiRunner = createAIRunner(config.ai);
-  const dataDir = path6.resolve(__dirname2, "../data");
+  const dataDir = path8.resolve(__dirname4, "../data");
   const tracker = new IssueTracker(dataDir);
   const supplementStore = new SupplementStore(dataDir);
   const agentLogStore = new AgentLogStore(dataDir);
@@ -1960,25 +3003,53 @@ async function main() {
   const orchestrator = new PipelineOrchestrator(config, gongfeng, git, aiRunner, tracker, supplementStore);
   const poller = new IssuePoller(config, gongfeng, tracker, orchestrator);
   let webServer = null;
+  const autoUpdater = new AutoUpdater(config, poller);
   if (config.web.enabled) {
-    webServer = new WebServer({ tracker, config, agentLogStore, orchestrator, gongfeng, supplementStore, mainGit: git });
+    webServer = new WebServer({ tracker, config, agentLogStore, orchestrator, gongfeng, supplementStore, mainGit: git, autoUpdater, poller });
     await webServer.start();
   }
   let webhookServer = null;
   if (config.webhook.enabled) {
-    webhookServer = new WebhookServer({ tracker, config, orchestrator, gongfeng, supplementStore });
+    webhookServer = new WebhookServer({ tracker, config, orchestrator, gongfeng, supplementStore, poller });
     await webhookServer.start();
   }
-  const shutdown = () => {
-    logger.info("Shutting down...");
+  const recoveredCount = tracker.recoverInterruptedIssues();
+  if (recoveredCount > 0) {
+    logger.info("Recovered interrupted issues on startup", { count: recoveredCount });
+  }
+  await orchestrator.cleanupStaleState();
+  let shutdownInProgress = false;
+  const shutdown = async () => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
+    logger.info("Graceful shutdown initiated");
+    setShuttingDown();
+    autoUpdater.stop();
     poller.stop();
+    aiRunner.killAll();
+    orchestrator.getDevServerManager().stopAll();
+    const drainStart = Date.now();
+    const DRAIN_TIMEOUT_MS = 5e3;
+    while (poller.getActiveCount() > 0 && Date.now() - drainStart < DRAIN_TIMEOUT_MS) {
+      logger.info("Waiting for active issues to drain...", { active: poller.getActiveCount() });
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    if (poller.getActiveCount() > 0) {
+      logger.warn("Drain timeout reached, proceeding with shutdown", { active: poller.getActiveCount() });
+    }
     webServer?.stop();
     webhookServer?.stop();
+    logger.info("Graceful shutdown complete");
     process.exit(0);
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => {
+    shutdown();
+  });
+  process.on("SIGTERM", () => {
+    shutdown();
+  });
   poller.start();
+  autoUpdater.start();
   logger.info("Issue Auto-Finish service started", {
     projectPath: config.gongfeng.projectPath,
     workDir: config.project.workDir,
@@ -1992,4 +3063,4 @@ async function main() {
 export {
   main
 };
-//# sourceMappingURL=chunk-IDUKWCC2.js.map
+//# sourceMappingURL=chunk-C6ZJVIPZ.js.map