@xdevops/issue-auto-finish 1.0.0

package/dist/chunk-IDUKWCC2.js

@@ -0,0 +1,1995 @@
+import {
+  BrainstormService,
+  CLASSIC_PIPELINE,
+  GitOperations,
+  GongfengClient,
+  IssueTracker,
+  PLAN_MODE_PIPELINE,
+  PipelineOrchestrator,
+  PlanPersistence,
+  collectStateLabels,
+  createAIRunner,
+  eventBus,
+  getE2eEnabled,
+  getNoteSyncEnabled,
+  getPipelineDef,
+  isNoteSyncEnabledForIssue,
+  loadConfig,
+  logger,
+  setE2eOverride,
+  setNoteSyncOverride,
+  validatePhaseRegistry
+} from "./chunk-TBIEB3JY.js";
+import {
+  createSetupRouter
+} from "./chunk-I3T573SU.js";
+import {
+  setLocale,
+  t
+} from "./chunk-OWVT3Z34.js";
+
+// src/supplement/SupplementStore.ts
+import fs from "fs";
+import path from "path";
+var logger2 = logger.child("SupplementStore");
+var SupplementStore = class {
+  dir;
+  constructor(dataDir) {
+    this.dir = path.join(dataDir, "supplements");
+  }
+  filePath(issueIid) {
+    return path.join(this.dir, `${issueIid}.json`);
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.dir)) {
+      fs.mkdirSync(this.dir, { recursive: true });
+    }
+  }
+  get(issueIid) {
+    const fp = this.filePath(issueIid);
+    if (!fs.existsSync(fp)) return null;
+    try {
+      const raw = fs.readFileSync(fp, "utf-8");
+      return JSON.parse(raw);
+    } catch (err) {
+      logger2.error("Failed to read supplement", { issueIid, error: err.message });
+      return null;
+    }
+  }
+  save(issueIid, data) {
+    this.ensureDir();
+    const info = {
+      ...data,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    fs.writeFileSync(this.filePath(issueIid), JSON.stringify(info, null, 2), "utf-8");
+    logger2.info("Supplement saved", { issueIid });
+    return info;
+  }
+  delete(issueIid) {
+    const fp = this.filePath(issueIid);
+    if (!fs.existsSync(fp)) return false;
+    try {
+      fs.unlinkSync(fp);
+      logger2.info("Supplement deleted", { issueIid });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  toPromptText(issueIid) {
+    const info = this.get(issueIid);
+    if (!info) return "";
+    const sections = [];
+    if (info.requirements.trim()) {
+      sections.push(`### \u8865\u5145\u9700\u6C42\u8BF4\u660E
+${info.requirements.trim()}`);
+    }
+    if (info.acceptanceCriteria.trim()) {
+      sections.push(`### \u9A8C\u6536\u6807\u51C6
+${info.acceptanceCriteria.trim()}`);
+    }
+    if (info.scope.trim()) {
+      sections.push(`### \u53D8\u66F4\u8303\u56F4
+${info.scope.trim()}`);
+    }
+    if (info.constraints.trim()) {
+      sections.push(`### \u7EA6\u675F\u6761\u4EF6
+${info.constraints.trim()}`);
+    }
+    if (info.references.trim()) {
+      sections.push(`### \u53C2\u8003\u94FE\u63A5
+${info.references.trim()}`);
+    }
+    if (info.freeText.trim()) {
+      sections.push(`### \u5176\u4ED6\u8865\u5145
+${info.freeText.trim()}`);
+    }
+    if (sections.length === 0) return "";
+    return `## \u8865\u5145\u4FE1\u606F
+
+${sections.join("\n\n")}`;
+  }
+};
+
+// src/poller/IssuePoller.ts
+var logger3 = logger.child("IssuePoller");
+var AUTO_FINISH_LABEL = "auto-finish";
+var AUTO_APPROVE_CHECK_INTERVAL_MS = 3e4;
+var IssuePoller = class {
+  config;
+  gongfeng;
+  tracker;
+  orchestrator;
+  discoveryTimer = null;
+  driveTimer = null;
+  activeIssues = /* @__PURE__ */ new Set();
+  lastAutoApproveCheckMs = 0;
+  constructor(config, gongfeng, tracker, orchestrator) {
+    this.config = config;
+    this.gongfeng = gongfeng;
+    this.tracker = tracker;
+    this.orchestrator = orchestrator;
+  }
+  start() {
+    const { discoveryIntervalMs, driveIntervalMs } = this.config.poll;
+    logger3.info("Issue poller starting", { discoveryIntervalMs, driveIntervalMs });
+    this.discover();
+    this.drive();
+    this.discoveryTimer = setInterval(() => this.discover(), discoveryIntervalMs);
+    this.driveTimer = setInterval(() => this.drive(), driveIntervalMs);
+  }
+  stop() {
+    if (this.discoveryTimer) {
+      clearInterval(this.discoveryTimer);
+      this.discoveryTimer = null;
+    }
+    if (this.driveTimer) {
+      clearInterval(this.driveTimer);
+      this.driveTimer = null;
+    }
+    logger3.info("Issue poller stopped");
+  }
+  getActiveIssueIids() {
+    return [...this.activeIssues];
+  }
+  async discover() {
+    try {
+      logger3.debug("Discovering new issues...");
+      const issues = await this.gongfeng.listIssues("opened", AUTO_FINISH_LABEL);
+      const newIssues = this.filterNewIssues(issues);
+      if (newIssues.length === 0) {
+        logger3.debug("No new issues found");
+        return;
+      }
+      logger3.info("Discovered new issues", { count: newIssues.length });
+      for (const issue of newIssues) {
+        this.tracker.create({
+          issueId: issue.id,
+          issueIid: issue.iid,
+          issueTitle: issue.title,
+          state: "pending" /* Pending */,
+          branchName: `${this.config.project.branchPrefix}-${issue.iid}`
+        });
+      }
+    } catch (err) {
+      logger3.error("Discovery cycle failed", { error: err.message });
+    }
+  }
+  drive() {
+    this.maybeAutoApproveWaiting();
+    const maxConcurrent = this.config.poll.maxConcurrent;
+    const available = maxConcurrent - this.activeIssues.size;
+    if (available <= 0) {
+      logger3.debug("Skipping drive \u2014 at concurrency limit", {
+        active: this.activeIssues.size,
+        max: maxConcurrent
+      });
+      return;
+    }
+    const drivable = this.tracker.getDrivableIssues(this.config.poll.maxRetries).filter((r) => !this.activeIssues.has(r.issueIid));
+    if (drivable.length === 0) {
+      return;
+    }
+    const batch = drivable.slice(0, available);
+    logger3.info("Driving issues", {
+      batchSize: batch.length,
+      active: this.activeIssues.size,
+      max: maxConcurrent
+    });
+    for (const record of batch) {
+      this.activeIssues.add(record.issueIid);
+      this.processInBackground(record);
+    }
+  }
+  maybeAutoApproveWaiting() {
+    const autoLabels = this.config.review.autoApproveLabels;
+    if (!autoLabels.length) return;
+    const now = Date.now();
+    if (now - this.lastAutoApproveCheckMs < AUTO_APPROVE_CHECK_INTERVAL_MS) return;
+    this.lastAutoApproveCheckMs = now;
+    const waiting = this.tracker.getAll().filter((r) => r.state === "waiting_for_review" /* WaitingForReview */);
+    if (!waiting.length) return;
+    this.autoApproveByLabels(waiting, autoLabels).catch((err) => {
+      logger3.warn("Auto-approve check failed", { error: err.message });
+    });
+  }
+  async autoApproveByLabels(records, autoLabels) {
+    for (const record of records) {
+      try {
+        const issue = await this.gongfeng.getIssueDetail(record.issueId);
+        const matched = issue.labels.filter((l) => autoLabels.includes(l));
+        if (matched.length === 0) continue;
+        logger3.info("Auto-approving waiting issue (label matched)", {
+          iid: record.issueIid,
+          matchedLabels: matched
+        });
+        this.tracker.updateState(record.issueIid, "review_approved" /* ReviewApproved */);
+        eventBus.emitTyped("review:approved", { issueIid: record.issueIid });
+        try {
+          await this.gongfeng.createIssueNote(
+            record.issueId,
+            t("poller.autoApproveComment", { labels: matched.join(", ") })
+          );
+        } catch {
+        }
+      } catch (err) {
+        logger3.warn("Failed to check auto-approve labels", {
+          iid: record.issueIid,
+          error: err.message
+        });
+      }
+    }
+  }
+  async processInBackground(record) {
+    try {
+      const issue = await this.resolveIssue(record.issueId);
+      if (!issue) {
+        logger3.warn("Could not resolve issue from API, skipping", { iid: record.issueIid });
+        return;
+      }
+      await this.orchestrator.processIssue(issue);
+    } catch (err) {
+      logger3.error("Failed to process issue", {
+        iid: record.issueIid,
+        error: err.message
+      });
+    } finally {
+      this.activeIssues.delete(record.issueIid);
+    }
+  }
+  async resolveIssue(issueId) {
+    try {
+      return await this.gongfeng.getIssueDetail(issueId);
+    } catch {
+      return null;
+    }
+  }
+  filterNewIssues(issues) {
+    return issues.filter((issue) => {
+      if (!issue.labels.includes(AUTO_FINISH_LABEL)) return false;
+      if (issue.labels.some((l) => l === "auto-finish:done")) return false;
+      const record = this.tracker.get(issue.iid);
+      if (record) return false;
+      return true;
+    });
+  }
+};
+
+// src/web/WebServer.ts
+import express from "express";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
+// src/web/routes/api.ts
+import { Router } from "express";
+import fs2 from "fs";
+import path2 from "path";
+import { marked } from "marked";
+var logger4 = logger.child("ApiRoutes");
+var startTime = Date.now();
+function buildPreviewInfo(iid, orch) {
+  const ports = orch.getPortAllocator().getPortsForIssue(iid);
+  if (!ports) return null;
+  const dsm = orch.getDevServerManager();
+  const status = dsm.getStatus(iid);
+  return {
+    ...status,
+    ports,
+    previewUrl: orch.buildPreviewUrl(iid),
+    host: orch.getPreviewHost()
+  };
+}
+function createApiRouter(trackerOrDeps, config, agentLogStore, orchestrator, mainGit) {
+  let tracker;
+  let cfg;
+  let logStore;
+  let orch;
+  let git;
+  let gongfeng;
+  let supplementStore;
+  if (config !== void 0) {
+    tracker = trackerOrDeps;
+    cfg = config;
+    logStore = agentLogStore;
+    orch = orchestrator;
+    git = mainGit;
+  } else {
+    const deps = trackerOrDeps;
+    tracker = deps.tracker;
+    cfg = deps.config;
+    logStore = deps.agentLogStore;
+    orch = deps.orchestrator;
+    git = deps.mainGit;
+    gongfeng = deps.gongfeng;
+    supplementStore = deps.supplementStore;
+  }
+  const router = Router();
+  router.get("/api/issues", (_req, res) => {
+    const issues = tracker.getAll();
+    res.json(issues);
+  });
+  router.get("/api/issues/:iid", async (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const progress = await readProgress(iid, cfg, tracker, git);
+    const preview = buildPreviewInfo(iid, orch);
+    res.json({ ...record, progress, preview });
+  });
+  function getIssuePipelineDef(iid) {
+    const record = tracker.get(iid);
+    const mode = record?.pipelineMode ?? orch.getPipelineDef().mode;
+    return getPipelineDef(mode === "plan-mode" ? "plan-mode" : "classic");
+  }
+  router.get("/api/issues/:iid/plans/:filename", async (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const filename = req.params.filename;
+    const def = getIssuePipelineDef(iid);
+    const allowed = [
+      ...def.planFiles.map((f) => f.filename),
+      "progress.json",
+      "issue-meta.json"
+    ];
+    if (!allowed.includes(filename)) {
+      res.status(400).json({ error: "Invalid filename" });
+      return;
+    }
+    const content = await readPlanFile(iid, filename, cfg, tracker, git);
+    if (content === null) {
+      res.status(404).json({ error: "Plan file not found" });
+      return;
+    }
+    if (filename.endsWith(".json")) {
+      res.json(JSON.parse(content));
+      return;
+    }
+    if (req.query.format === "html") {
+      const html = await marked(content);
+      res.type("html").send(html);
+      return;
+    }
+    res.type("text/markdown").send(content);
+  });
+  router.post("/api/issues/:iid/retry", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const ok = tracker.resetForRetry(iid);
+    if (!ok) {
+      res.status(400).json({ error: "Issue is not in failed state or not found" });
+      return;
+    }
+    res.json({ success: true, message: `Issue #${iid} reset for retry` });
+  });
+  router.post("/api/issues/:iid/cancel", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const ok = tracker.delete(iid);
+    if (!ok) {
+      res.status(404).json({ error: "Issue not found in tracker" });
+      return;
+    }
+    res.json({ success: true, message: `Issue #${iid} removed from tracker` });
+  });
+  router.post("/api/issues/:iid/restart", async (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    try {
+      await orch.restartIssue(iid);
+      res.json({ success: true, message: `Issue #${iid} restarted` });
+    } catch (err) {
+      const msg = err.message;
+      logger4.error("Restart failed", { iid, error: msg });
+      res.status(400).json({ error: msg });
+    }
+  });
+  router.post("/api/issues/:iid/retry-from-phase", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const { phase } = req.body;
+    const def = getIssuePipelineDef(iid);
+    const validPhases = def.phases.filter((p) => p.kind === "ai").map((p) => p.name);
+    if (!phase || !validPhases.includes(phase)) {
+      res.status(400).json({ error: `Invalid phase. Must be one of: ${validPhases.join(", ")}` });
+      return;
+    }
+    try {
+      orch.retryFromPhase(iid, phase);
+      res.json({ success: true, message: `Issue #${iid} reset to phase: ${phase}` });
+    } catch (err) {
+      const msg = err.message;
+      logger4.error("Retry-from-phase failed", { iid, phase, error: msg });
+      res.status(400).json({ error: msg });
+    }
+  });
+  router.put("/api/issues/:iid/plans/:filename", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const filename = req.params.filename;
+    const def = getIssuePipelineDef(iid);
+    const editableFiles = def.planFiles.filter((f) => f.editable).map((f) => f.filename);
+    if (!editableFiles.includes(filename)) {
+      res.status(400).json({ error: `File not editable. Allowed: ${editableFiles.join(", ")}` });
+      return;
+    }
+    const { content } = req.body;
+    if (typeof content !== "string") {
+      res.status(400).json({ error: 'Request body must contain a "content" string field' });
+      return;
+    }
+    const planDir = getWorktreePlanDir(iid, cfg);
+    const filePath = path2.join(planDir, filename);
+    if (!fs2.existsSync(planDir)) {
+      res.status(404).json({ error: "Plan directory not found (worktree may have been cleaned)" });
+      return;
+    }
+    fs2.writeFileSync(filePath, content, "utf-8");
+    logger4.info("Plan file updated", { iid, filename });
+    res.json({ success: true, message: `Plan file ${filename} saved` });
+  });
+  router.get("/api/issues/:iid/logs", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const logs = logStore.getLogs(iid);
+    res.json(logs);
+  });
+  router.get("/api/issues/:iid/supplement", (req, res) => {
+    if (!supplementStore) {
+      res.status(501).json({ error: "Supplement store not available" });
+      return;
+    }
+    const iid = parseInt(req.params.iid, 10);
+    const info = supplementStore.get(iid);
+    res.json(info);
+  });
+  router.put("/api/issues/:iid/supplement", (req, res) => {
+    if (!supplementStore) {
+      res.status(501).json({ error: "Supplement store not available" });
+      return;
+    }
+    const iid = parseInt(req.params.iid, 10);
+    const body = req.body;
+    const data = {
+      requirements: String(body.requirements || ""),
+      acceptanceCriteria: String(body.acceptanceCriteria || ""),
+      scope: String(body.scope || ""),
+      constraints: String(body.constraints || ""),
+      references: String(body.references || ""),
+      freeText: String(body.freeText || ""),
+      tapdId: String(body.tapdId || "")
+    };
+    const saved = supplementStore.save(iid, data);
+    res.json({ success: true, data: saved });
+  });
+  router.get("/api/gongfeng/issues", async (req, res) => {
+    if (!gongfeng) {
+      res.status(501).json({ error: "Gongfeng client not available" });
+      return;
+    }
+    try {
+      const search = req.query.search || "";
+      const page = parseInt(req.query.page, 10) || 1;
+      const perPage = parseInt(req.query.per_page, 10) || 20;
+      const result = await gongfeng.listIssuesAdvanced({
+        state: "opened",
+        search: search || void 0,
+        page,
+        perPage
+      });
+      const trackedIids = new Set(tracker.getAll().map((r) => r.issueIid));
+      res.json({
+        issues: result.issues,
+        total: result.total,
+        trackedIids: Array.from(trackedIids)
+      });
+    } catch (err) {
+      const msg = err.message;
+      logger4.error("Failed to fetch gongfeng issues", { error: msg });
+      res.status(500).json({ error: msg });
+    }
+  });
+  router.post("/api/issues/start", async (req, res) => {
+    if (!gongfeng) {
+      res.status(501).json({ error: "Gongfeng client not available" });
+      return;
+    }
+    const body = req.body;
+    if (!body.issueId || !body.issueIid || !body.issueTitle) {
+      res.status(400).json({ error: "issueId, issueIid, and issueTitle are required" });
+      return;
+    }
+    const existing = tracker.get(body.issueIid);
+    if (existing) {
+      res.status(409).json({ error: `Issue #${body.issueIid} is already being tracked` });
+      return;
+    }
+    try {
+      await gongfeng.addLabel(body.issueId, "auto-finish");
+    } catch (err) {
+      logger4.warn("Failed to add auto-finish label", { error: err.message });
+    }
+    const branchName = `${cfg.project.branchPrefix}-${body.issueIid}`;
+    const record = tracker.create({
+      issueId: body.issueId,
+      issueIid: body.issueIid,
+      issueTitle: body.issueTitle,
+      state: "pending" /* Pending */,
+      branchName
+    });
+    if (supplementStore && body.supplement) {
+      supplementStore.save(body.issueIid, {
+        requirements: String(body.supplement.requirements || ""),
+        acceptanceCriteria: String(body.supplement.acceptanceCriteria || ""),
+        scope: String(body.supplement.scope || ""),
+        constraints: String(body.supplement.constraints || ""),
+        references: String(body.supplement.references || ""),
+        freeText: String(body.supplement.freeText || ""),
+        tapdId: String(body.supplement.tapdId || "")
+      });
+    }
+    res.json({ success: true, record });
+  });
+  router.post("/api/issues/:iid/approve-plan", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    if (record.state !== "waiting_for_review" /* WaitingForReview */) {
+      res.status(400).json({ error: `Issue is not waiting for review (current state: ${record.state})` });
+      return;
+    }
+    tracker.updateState(iid, "review_approved" /* ReviewApproved */);
+    const def = getIssuePipelineDef(iid);
+    const reviewSpec = def.phases.find((p) => p.kind === "gate");
+    if (reviewSpec) {
+      const workDir = getWorktreeWorkDir(iid, cfg);
+      const planPersistence = new PlanPersistence(workDir, iid);
+      planPersistence.updatePhaseProgress(reviewSpec.name, "completed");
+    }
+    eventBus.emitTyped("review:approved", { issueIid: iid });
+    logger4.info("Plan approved", { iid });
+    res.json({ success: true, message: `Issue #${iid} plan approved, will resume on next drive cycle` });
+  });
+  router.post("/api/issues/:iid/reject-plan", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    if (record.state !== "waiting_for_review" /* WaitingForReview */) {
+      res.status(400).json({ error: `Issue is not waiting for review (current state: ${record.state})` });
+      return;
+    }
+    const { feedback } = req.body;
+    if (!feedback || typeof feedback !== "string") {
+      res.status(400).json({ error: "Feedback is required" });
+      return;
+    }
+    const workDir = getWorktreeWorkDir(iid, cfg);
+    if (fs2.existsSync(workDir)) {
+      const planPersistence = new PlanPersistence(workDir, iid);
+      planPersistence.writeReviewFeedback(feedback);
+    }
+    tracker.updateState(iid, "branch_created" /* BranchCreated */);
+    eventBus.emitTyped("review:rejected", { issueIid: iid, feedback });
+    logger4.info("Plan rejected", { iid, feedback: feedback.slice(0, 100) });
+    if (gongfeng && isNoteSyncEnabledForIssue(iid, tracker, cfg)) {
+      const baseUrl = cfg.issueNoteSync.webBaseUrl.replace(/\/$/, "");
+      const planFile = record.pipelineMode === "plan-mode" ? "01-plan.md" : "02-design.md";
+      const history = fs2.existsSync(workDir) ? new PlanPersistence(workDir, iid).readReviewHistory() : [];
+      const round = history.length;
+      const note = [
+        t("api.reviewFeedback", { round }),
+        "",
+        feedback,
+        "",
+        "---",
+        t("api.viewPlan", { url: `${baseUrl}/doc/${iid}/${planFile}` }),
+        t("api.viewDetail", { url: `${baseUrl}/?issue=${iid}` })
+      ].join("\n");
+      gongfeng.createIssueNote(record.issueId, note).catch((err) => {
+        logger4.warn("Failed to sync review feedback to issue", { error: err.message });
+      });
+    }
+    res.json({ success: true, message: `Issue #${iid} plan rejected, will re-plan on next drive cycle` });
+  });
+  router.post("/api/issues/:iid/skip-review", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    if (record.state !== "waiting_for_review" /* WaitingForReview */) {
+      res.status(400).json({ error: `Issue is not waiting for review (current state: ${record.state})` });
+      return;
+    }
+    tracker.updateState(iid, "review_approved" /* ReviewApproved */);
+    const def = getIssuePipelineDef(iid);
+    const reviewSpec = def.phases.find((p) => p.kind === "gate");
+    if (reviewSpec) {
+      const workDir = getWorktreeWorkDir(iid, cfg);
+      const planPersistence = new PlanPersistence(workDir, iid);
+      planPersistence.updatePhaseProgress(reviewSpec.name, "completed");
+    }
+    eventBus.emitTyped("review:approved", { issueIid: iid });
+    logger4.info("Review skipped", { iid });
+    res.json({ success: true, message: `Issue #${iid} review skipped` });
+  });
+  router.get("/api/issues/:iid/review-history", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const workDir = getWorktreeWorkDir(iid, cfg);
+    if (!fs2.existsSync(workDir)) {
+      res.json([]);
+      return;
+    }
+    const planPersistence = new PlanPersistence(workDir, iid);
+    res.json(planPersistence.readReviewHistory());
+  });
+  router.put("/api/issues/:iid/note-sync", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const { enabled } = req.body;
+    const value = enabled === null ? void 0 : enabled;
+    tracker.updateState(iid, record.state, { issueNoteSyncEnabled: value });
+    logger4.info("Issue note-sync toggled", { iid, enabled: value });
+    res.json({ success: true, issueNoteSyncEnabled: value ?? null });
+  });
+  router.put("/api/system/note-sync", (req, res) => {
+    const { enabled } = req.body;
+    if (typeof enabled !== "boolean") {
+      res.status(400).json({ error: "enabled must be a boolean" });
+      return;
+    }
+    setNoteSyncOverride(enabled);
+    logger4.info("System note-sync toggled", { enabled });
+    res.json({ success: true, issueNoteSyncEnabled: enabled });
+  });
+  router.get("/api/issues/:iid/preview", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const preview = buildPreviewInfo(iid, orch);
+    res.json(preview ?? { running: false });
+  });
+  router.post("/api/issues/:iid/stop-preview", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    orch.stopPreviewServers(iid);
+    res.json({ success: true, message: `Preview servers stopped for issue #${iid}` });
+  });
+  router.put("/api/issues/:iid/e2e", (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const record = tracker.get(iid);
+    if (!record) {
+      res.status(404).json({ error: "Issue not found" });
+      return;
+    }
+    const { enabled } = req.body;
+    const value = enabled === null ? void 0 : enabled;
+    tracker.updateState(iid, record.state, { e2eEnabled: value });
+    logger4.info("Issue e2e toggled", { iid, enabled: value });
+    res.json({ success: true, e2eEnabled: value ?? null });
+  });
+  router.put("/api/system/e2e", (req, res) => {
+    const { enabled } = req.body;
+    if (typeof enabled !== "boolean") {
+      res.status(400).json({ error: "enabled must be a boolean" });
+      return;
+    }
+    setE2eOverride(enabled);
+    logger4.info("System e2e toggled", { enabled });
+    res.json({ success: true, e2eEnabled: enabled });
+  });
+  router.get("/api/system/status", (_req, res) => {
+    const runningPreviews = orch.getDevServerManager().getRunningIssues();
+    res.json({
+      uptime: Date.now() - startTime,
+      startedAt: new Date(startTime).toISOString(),
+      config: {
+        discoveryIntervalMs: cfg.poll.discoveryIntervalMs,
+        driveIntervalMs: cfg.poll.driveIntervalMs,
+        maxRetries: cfg.poll.maxRetries,
+        aiMode: cfg.ai.mode,
+        pipelineMode: orch.getPipelineDef().mode,
+        baseBranch: cfg.project.baseBranch,
+        projectPath: cfg.gongfeng.projectPath,
+        gongfengBaseUrl: cfg.gongfeng.apiUrl.replace(/\/$/, ""),
+        issueNoteSyncEnabled: getNoteSyncEnabled(cfg),
+        e2eEnabled: getE2eEnabled(cfg),
+        previewEnabled: cfg.preview.enabled,
+        locale: cfg.locale
+      },
+      issues: {
+        total: tracker.getAll().length,
+        active: tracker.getAllActive().length
+      },
+      preview: {
+        runningCount: runningPreviews.length,
+        runningIssues: runningPreviews
+      }
+    });
+  });
+  router.get("/api/events", (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 heartbeat = setInterval(() => {
+      res.write(`event: heartbeat
+data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
+
+`);
+    }, 15e3);
+    const handler = (_eventName, payload) => {
+      try {
+        res.write(`event: ${payload.type}
+data: ${JSON.stringify(payload)}
+
+`);
+      } catch {
+        logger4.warn("Failed to write SSE event");
+      }
+    };
+    eventBus.on("*", handler);
+    res.write(`event: connected
+data: ${JSON.stringify({ time: (/* @__PURE__ */ new Date()).toISOString() })}
+
+`);
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      eventBus.off("*", handler);
+    });
+  });
+  router.get("/doc/:iid/:filename", async (req, res) => {
+    const iid = parseInt(req.params.iid, 10);
+    const filename = req.params.filename;
+    const record = tracker.get(iid);
+    const title = record?.issueTitle ?? `Issue #${iid}`;
+    const def = getIssuePipelineDef(iid);
+    const allowed = def.planFiles.map((f) => f.filename);
+    if (!allowed.includes(filename)) {
+      res.status(400).type("html").send(renderDocPage(iid, title, t("api.invalidFilename"), filename));
+      return;
+    }
+    const content = await readPlanFile(iid, filename, cfg, tracker, git);
+    if (content === null) {
+      res.status(404).type("html").send(renderDocPage(iid, title, t("api.docNotGenerated"), filename));
+      return;
+    }
+    const htmlBody = await marked(content);
+    res.type("html").send(renderDocPage(iid, title, htmlBody, filename));
+  });
+  return router;
+}
+var DOC_LABELS_FUNC = (filename) => t(`docLabel.${filename}`) || filename;
+function renderDocPage(iid, issueTitle, htmlBody, filename) {
+  const docLabel = DOC_LABELS_FUNC(filename);
+  return `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Issue #${iid} \u2014 ${docLabel}</title>
+<style>
+  body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif; margin: 0; padding: 0; color: #24292f; background: #f6f8fa; }
+  .header { background: #fff; border-bottom: 1px solid #d0d7de; padding: 12px 24px; display: flex; align-items: center; gap: 12px; }
+  .header .crumb { font-size: 14px; color: #57606a; }
+  .header .crumb a { color: #0969da; text-decoration: none; }
+  .header .crumb a:hover { text-decoration: underline; }
+  .header .crumb .sep { margin: 0 4px; color: #8b949e; }
+  .container { max-width: 900px; margin: 24px auto; background: #fff; border: 1px solid #d0d7de; border-radius: 6px; padding: 32px 40px; }
+  .markdown-body h1 { font-size: 1.6em; border-bottom: 1px solid #d0d7de; padding-bottom: .3em; }
+  .markdown-body h2 { font-size: 1.3em; border-bottom: 1px solid #d0d7de; padding-bottom: .3em; }
+  .markdown-body h3 { font-size: 1.1em; }
+  .markdown-body pre { background: #f6f8fa; border: 1px solid #d0d7de; border-radius: 6px; padding: 16px; overflow-x: auto; }
+  .markdown-body code { background: #f6f8fa; border-radius: 3px; padding: 0.2em 0.4em; font-size: 85%; }
+  .markdown-body pre code { background: none; padding: 0; }
+  .markdown-body table { border-collapse: collapse; width: 100%; }
+  .markdown-body th, .markdown-body td { border: 1px solid #d0d7de; padding: 6px 13px; }
+  .markdown-body th { background: #f6f8fa; }
+  .markdown-body blockquote { margin: 0; padding: 0 1em; color: #57606a; border-left: 3px solid #d0d7de; }
+  .markdown-body ul, .markdown-body ol { padding-left: 2em; }
+  .markdown-body li { margin-top: 0.25em; }
+  .markdown-body p { margin: 8px 0; }
+  .markdown-body a { color: #0969da; }
+</style>
+</head>
+<body>
+  <div class="header">
+    <div class="crumb">
+      <a href="/?issue=${iid}">Issue #${iid}</a>
+      <span class="sep">/</span>
+      <strong>${docLabel}</strong>
+      <span class="sep">\xB7</span>
+      <span style="font-size:12px;color:#57606a">${escapeHtml(issueTitle)}</span>
+      <span class="sep">\xB7</span>
+      <a href="/?issue=${iid}" style="font-size:12px">${t("api.viewInDashboard")}</a>
+    </div>
+  </div>
+  <div class="container">
+    <div class="markdown-body">${htmlBody}</div>
+  </div>
+</body>
+</html>`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function getWorktreeWorkDir(issueIid, config) {
+  return path2.join(
+    config.project.worktreeBaseDir,
+    `issue-${issueIid}`,
+    config.project.projectSubDir
+  );
+}
+function getWorktreePlanDir(issueIid, config) {
+  return path2.join(getWorktreeWorkDir(issueIid, config), ".claude-plan", `issue-${issueIid}`);
+}
+function getPlanGitPath(issueIid, filename, config) {
+  return path2.posix.join(config.project.projectSubDir, ".claude-plan", `issue-${issueIid}`, filename);
+}
+async function readPlanFileFromGit(issueIid, filename, config, tracker, mainGit) {
+  if (!mainGit) return null;
+  const record = tracker.get(issueIid);
+  if (!record) return null;
+  const gitPath = getPlanGitPath(issueIid, filename, config);
+  return mainGit.showFile(record.branchName, gitPath);
+}
+var VERIFY_REPORT_FALLBACKS = {
+  "02-verify-report.md": "04-verify-report.md"
+};
+async function readPlanFile(issueIid, filename, config, tracker, mainGit) {
+  const planDir = getWorktreePlanDir(issueIid, config);
+  const filePath = path2.join(planDir, filename);
+  if (fs2.existsSync(filePath)) {
+    try {
+      return fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  const content = await readPlanFileFromGit(issueIid, filename, config, tracker, mainGit);
+  if (content !== null) return content;
+  const fallback = VERIFY_REPORT_FALLBACKS[filename];
+  if (fallback) {
+    return readPlanFile(issueIid, fallback, config, tracker, mainGit);
+  }
+  return null;
+}
+async function readProgress(issueIid, config, tracker, mainGit) {
+  const content = await readPlanFile(issueIid, "progress.json", config, tracker, mainGit);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// src/web/routes/brainstorm.ts
+import { Router as Router2 } from "express";
+var logger5 = logger.child("BrainstormRoutes");
+function sseWriter(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 {
+      logger5.warn("Failed to write SSE brainstorm event");
+    }
+  };
+}
+function createBrainstormRouter(deps) {
+  const router = Router2();
+  const { brainstormService, gongfeng } = deps;
+  router.post("/api/brainstorm/sessions", (req, res) => {
+    try {
+      const { transcript } = req.body;
+      if (!transcript?.trim()) {
+        res.status(400).json({ error: "transcript is required" });
+        return;
+      }
+      const session = brainstormService.createSession(transcript.trim());
+      res.json({ success: true, session });
+    } catch (err) {
+      logger5.error("Failed to create brainstorm session", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  router.get("/api/brainstorm/sessions/:id", (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    res.json({ success: true, session });
+  });
+  router.post("/api/brainstorm/sessions/:id/generate", async (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const write = sseWriter(res);
+    try {
+      await brainstormService.generate(req.params.id, write);
+      res.write(`event: done
+data: ${JSON.stringify({ type: "done" })}
+
+`);
+    } catch (err) {
+      write({ type: "error", data: { message: err.message } });
+    } finally {
+      res.end();
+    }
+  });
+  router.post("/api/brainstorm/sessions/:id/review", async (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const write = sseWriter(res);
+    try {
+      await brainstormService.review(req.params.id, write);
+      res.write(`event: done
+data: ${JSON.stringify({ type: "done" })}
+
+`);
+    } catch (err) {
+      write({ type: "error", data: { message: err.message } });
+    } finally {
+      res.end();
+    }
+  });
+  router.post("/api/brainstorm/sessions/:id/refine", async (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const write = sseWriter(res);
+    try {
+      await brainstormService.refine(req.params.id, write);
+      res.write(`event: done
+data: ${JSON.stringify({ type: "done" })}
+
+`);
+    } catch (err) {
+      write({ type: "error", data: { message: err.message } });
+    } finally {
+      res.end();
+    }
+  });
+  router.post("/api/brainstorm/sessions/:id/auto-refine", async (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    const { rounds } = req.body;
+    const write = sseWriter(res);
+    try {
+      await brainstormService.autoRefine(req.params.id, rounds, write);
+      res.write(`event: done
+data: ${JSON.stringify({ type: "done" })}
+
+`);
+    } catch (err) {
+      write({ type: "error", data: { message: err.message } });
+    } finally {
+      res.end();
+    }
+  });
+  router.post("/api/brainstorm/sessions/:id/create-issue", async (req, res) => {
+    const session = brainstormService.getSession(req.params.id);
+    if (!session) {
+      res.status(404).json({ error: "Session not found" });
+      return;
+    }
+    if (!session.currentSdd) {
+      res.status(400).json({ error: "No SDD generated yet" });
+      return;
+    }
+    try {
+      const { title, addAutoFinishLabel } = req.body;
+      const issueTitle = title?.trim() || extractTitle(session.currentSdd);
+      const labels = addAutoFinishLabel !== false ? ["auto-finish"] : [];
+      const issue = await gongfeng.createIssue(issueTitle, session.currentSdd, labels);
+      logger5.info("Issue created from brainstorm", { issueIid: issue.iid, sessionId: session.id });
+      res.json({ success: true, issue });
+    } catch (err) {
+      logger5.error("Failed to create issue from brainstorm", { error: err.message });
+      res.status(500).json({ error: err.message });
+    }
+  });
+  return router;
+}
+function extractTitle(sdd) {
+  const firstLine = sdd.split("\n").find((l) => l.trim());
+  if (firstLine) {
+    return firstLine.replace(/^#+\s*/, "").trim().slice(0, 200);
+  }
+  return "\u8111\u66B4\u751F\u6210\u7684\u9700\u6C42";
+}
+
+// src/web/WebServer.ts
+var __dirname = path3.dirname(fileURLToPath(import.meta.url));
+var logger6 = logger.child("WebServer");
+var WebServer = class {
+  app;
+  server = null;
+  port;
+  constructor(trackerOrDeps, config, agentLogStore, orchestrator, mainGit) {
+    let apiDeps;
+    if (trackerOrDeps instanceof IssueTracker) {
+      this.port = config.web.port;
+      apiDeps = {
+        tracker: trackerOrDeps,
+        config,
+        agentLogStore,
+        orchestrator,
+        mainGit,
+        gongfeng: void 0,
+        supplementStore: void 0
+      };
+    } else {
+      const deps = trackerOrDeps;
+      this.port = deps.config.web.port;
+      apiDeps = {
+        tracker: deps.tracker,
+        config: deps.config,
+        agentLogStore: deps.agentLogStore,
+        orchestrator: deps.orchestrator,
+        mainGit: deps.mainGit,
+        gongfeng: deps.gongfeng,
+        supplementStore: deps.supplementStore
+      };
+    }
+    this.app = express();
+    this.app.use(express.json());
+    const setupRouter = createSetupRouter({ serviceMode: true });
+    this.app.use(setupRouter);
+    const apiRouter = createApiRouter(apiDeps);
+    this.app.use(apiRouter);
+    if (apiDeps.config.brainstorm.enabled) {
+      const brainstormService = new BrainstormService(apiDeps.config);
+      const brainstormRouter = createBrainstormRouter({
+        brainstormService,
+        gongfeng: apiDeps.gongfeng
+      });
+      this.app.use(brainstormRouter);
+    }
+    const publicDir = apiDeps.config.web.frontendDistDir;
+    this.app.use(express.static(publicDir));
+    this.app.get("{*path}", (_req, res) => {
+      res.sendFile(path3.join(publicDir, "index.html"));
+    });
+  }
+  start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger6.info(`Web UI available at http://localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+  stop() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      logger6.info("Web server stopped");
+    }
+  }
+};
+
+// src/webhook/WebhookServer.ts
+import express2 from "express";
+
+// src/webhook/WebhookHandler.ts
+import { Router as Router3 } from "express";
+
+// src/webhook/CommandParser.ts
+var TRIGGER = "@issue-auto";
+var PHASE_ALIAS = {
+  "\u5206\u6790": "analysis",
+  "\u9700\u6C42\u5206\u6790": "analysis",
+  "\u8BBE\u8BA1": "design",
+  "\u7CFB\u7EDF\u8BBE\u8BA1": "design",
+  "\u5B9E\u73B0": "implement",
+  "\u5B9E\u65BD": "implement",
+  "\u7F16\u7801": "implement",
+  "\u9A8C\u8BC1": "verify",
+  "\u6D4B\u8BD5": "verify",
+  "\u89C4\u5212": "plan",
+  "\u6784\u5EFA": "build"
+};
+function resolvePhase(raw) {
+  const lower = raw.toLowerCase();
+  return PHASE_ALIAS[lower] ?? lower;
+}
+var EXACT_PATTERNS = [
+  {
+    regex: /retry-from\s+(\S+)/i,
+    build: (m) => ({ intent: "retry-from", phase: resolvePhase(m[1]) })
+  },
+  {
+    regex: /(?:从|回到)\s*(\S+?)\s*(?:阶段)?(?:重[试来做新]|开始)/,
+    build: (m) => ({ intent: "retry-from", phase: resolvePhase(m[1]) })
+  },
+  {
+    regex: /retry\b/i,
+    build: () => ({ intent: "retry" })
+  },
+  {
+    regex: /重试|再试/,
+    build: () => ({ intent: "retry" })
+  },
+  {
+    regex: /restart\b/i,
+    build: () => ({ intent: "restart" })
+  },
+  {
+    regex: /(?:重新开始|从头(?:开始|来|做)|重做)/,
+    build: () => ({ intent: "restart" })
+  },
+  {
+    regex: /approve\b/i,
+    build: () => ({ intent: "approve" })
+  },
+  {
+    regex: /(?:批准|通过|同意|LGTM)/i,
+    build: () => ({ intent: "approve" })
+  },
+  {
+    regex: /reject\s+([\s\S]+)/i,
+    build: (m) => ({ intent: "reject", feedback: m[1].trim() })
+  },
+  {
+    regex: /(?:驳回|拒绝|打回)[：:\s]*([\s\S]+)/,
+    build: (m) => ({ intent: "reject", feedback: m[1].trim() })
+  },
+  {
+    regex: /supplement\s+([\s\S]+)/i,
+    build: (m) => ({ intent: "supplement", context: m[1].trim() })
+  },
+  {
+    regex: /(?:补充)[：:\s]*([\s\S]+)/,
+    build: (m) => ({ intent: "supplement", context: m[1].trim() })
+  },
+  {
+    regex: /status\b/i,
+    build: () => ({ intent: "status" })
+  },
+  {
+    regex: /(?:状态|什么状态|进度|查询)/,
+    build: () => ({ intent: "status" })
+  },
+  {
+    regex: /stop-preview\b/i,
+    build: () => ({ intent: "stop-preview" })
+  },
+  {
+    regex: /(?:停止预览|关闭预览|停止体验)/,
+    build: () => ({ intent: "stop-preview" })
+  },
+  {
+    regex: /preview\b/i,
+    build: () => ({ intent: "preview" })
+  },
+  {
+    regex: /(?:预览|体验|preview环境)/,
+    build: () => ({ intent: "preview" })
+  },
+  {
+    regex: /clean-notes\b/i,
+    build: () => ({ intent: "clean-notes" })
+  },
+  {
+    regex: /(?:清理评论|清除评论|删除评论)/,
+    build: () => ({ intent: "clean-notes" })
+  }
+];
+function containsTrigger(text) {
+  return text.includes(TRIGGER);
+}
+function extractCommandText(text) {
+  const idx = text.indexOf(TRIGGER);
+  if (idx < 0) return null;
+  return text.slice(idx + TRIGGER.length).trim();
+}
+function parseExact(commandText) {
+  for (const { regex, build } of EXACT_PATTERNS) {
+    const match = commandText.match(regex);
+    if (match) return build(match);
+  }
+  return null;
+}
+
+// src/webhook/CommandExecutor.ts
+import path4 from "path";
+import fs3 from "fs";
+var logger7 = logger.child("CommandExecutor");
+var CommandExecutor = class {
+  tracker;
+  orchestrator;
+  supplementStore;
+  gongfeng;
+  config;
+  constructor(deps) {
+    this.tracker = deps.tracker;
+    this.orchestrator = deps.orchestrator;
+    this.supplementStore = deps.supplementStore;
+    this.gongfeng = deps.gongfeng;
+    this.config = deps.config;
+  }
+  async execute(issueIid, issueId, command) {
+    logger7.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 });
+      result = { success: false, message: msg };
+    }
+    await this.replyToIssue(issueId, result);
+    return result;
+  }
+  async dispatch(iid, cmd) {
+    switch (cmd.intent) {
+      case "retry":
+        return this.handleRetry(iid);
+      case "retry-from":
+        return this.handleRetryFrom(iid, cmd.phase, cmd.context);
+      case "supplement":
+        return this.handleSupplement(iid, cmd.context);
+      case "approve":
+        return this.handleApprove(iid);
+      case "reject":
+        return this.handleReject(iid, cmd.feedback);
+      case "status":
+        return this.handleStatus(iid);
+      case "restart":
+        return this.handleRestart(iid);
+      case "preview":
+        return this.handlePreview(iid);
+      case "stop-preview":
+        return this.handleStopPreview(iid);
+      case "clean-notes":
+        return this.handleCleanNotes(iid);
+      default:
+        return { success: false, message: "Unknown command" };
+    }
+  }
+  handleRetry(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    if (record.state !== "failed" /* Failed */) {
+      return this.fail(`Issue not in failed state (current: ${record.state})`);
+    }
+    const ok = this.tracker.resetForRetry(iid);
+    if (!ok) return this.fail("Reset for retry failed");
+    return this.ok(`Issue #${iid} has been reset and will retry on the next drive cycle.`);
+  }
+  handleRetryFrom(iid, phase, ctx) {
+    if (!phase) return this.fail("Phase is required for retry-from (e.g. design, implement)");
+    if (ctx) this.saveSupplement(iid, ctx);
+    try {
+      this.orchestrator.retryFromPhase(iid, phase);
+    } catch (err) {
+      return this.fail(err.message);
+    }
+    const extra = ctx ? "\nSupplement info recorded." : "";
+    return this.ok(`Issue #${iid} will restart from **${phase}** phase.${extra}`);
+  }
+  handleSupplement(iid, ctx) {
+    if (!ctx?.trim()) return this.fail("Supplement content cannot be empty");
+    this.saveSupplement(iid, ctx);
+    return this.ok("Supplement info recorded. AI will reference it on next execution.");
+  }
+  handleApprove(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    if (record.state !== "waiting_for_review" /* WaitingForReview */) {
+      return this.fail(`Issue not waiting for review (current: ${record.state})`);
+    }
+    this.tracker.updateState(iid, "review_approved" /* ReviewApproved */);
+    const def = this.getIssuePipelineDef(record);
+    const gate = def.phases.find((p) => p.kind === "gate");
+    if (gate) {
+      const workDir = this.getWorktreeWorkDir(iid);
+      if (fs3.existsSync(workDir)) {
+        new PlanPersistence(workDir, iid).updatePhaseProgress(gate.name, "completed");
+      }
+    }
+    eventBus.emitTyped("review:approved", { issueIid: iid });
+    return this.ok("Plan approved. Continuing to next phases.");
+  }
+  handleReject(iid, feedback) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    if (record.state !== "waiting_for_review" /* WaitingForReview */) {
+      return this.fail(`Issue not waiting for review (current: ${record.state})`);
+    }
+    if (!feedback?.trim()) return this.fail("Feedback is required when rejecting");
+    const workDir = this.getWorktreeWorkDir(iid);
+    if (fs3.existsSync(workDir)) {
+      new PlanPersistence(workDir, iid).writeReviewFeedback(feedback);
+    }
+    this.tracker.updateState(iid, "branch_created" /* BranchCreated */);
+    eventBus.emitTyped("review:rejected", { issueIid: iid, feedback });
+    return this.ok("Plan rejected. Will re-plan based on feedback.");
+  }
+  handleStatus(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    const def = this.getIssuePipelineDef(record);
+    const labels = collectStateLabels(def);
+    const stateLabel = labels.get(record.state) ?? record.state;
+    const lines = [
+      `**Issue #${iid} Status**`,
+      "",
+      `- State: **${stateLabel}**`,
+      `- Branch: \`${record.branchName}\``,
+      `- Attempts: ${record.attempts}`,
+      `- Pipeline: ${record.pipelineMode ?? "N/A"}`
+    ];
+    if (record.lastError) lines.push(`- Last error: ${record.lastError.slice(0, 200)}`);
+    if (record.mrUrl) lines.push(`- MR: ${record.mrUrl}`);
+    const previewUrl = this.orchestrator.buildPreviewUrl(iid);
+    if (previewUrl) {
+      const dsm = this.orchestrator.getDevServerManager();
+      const status = dsm.getStatus(iid);
+      lines.push(`- Preview: ${status.running ? `\u{1F310} ${previewUrl}` : t("cmd.previewStopped")}`);
+    }
+    const baseUrl = this.config.issueNoteSync.webBaseUrl.replace(/\/$/, "");
+    lines.push("", `[View in dashboard](${baseUrl}/?issue=${iid})`);
+    return this.ok(lines.join("\n"));
+  }
+  async handleRestart(iid) {
+    try {
+      await this.orchestrator.restartIssue(iid);
+    } catch (err) {
+      return this.fail(err.message);
+    }
+    return this.ok(`Issue #${iid} has been fully reset and will restart from scratch.`);
+  }
+  handlePreview(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    const previewUrl = this.orchestrator.buildPreviewUrl(iid);
+    if (!previewUrl) {
+      return this.ok(
+        t("cmd.previewNotStarted", { iid })
+      );
+    }
+    const dsm = this.orchestrator.getDevServerManager();
+    const status = dsm.getStatus(iid);
+    const ports = this.orchestrator.getPortAllocator().getPortsForIssue(iid);
+    const host = this.orchestrator.getPreviewHost();
+    const lines = [
+      "\u{1F310} **Preview Environment**",
+      "",
+      `| ${t("cmd.previewTable.component")} | ${t("cmd.previewTable.address")} |`,
+      `|------|------|`,
+      `| ${t("cmd.previewTable.frontend")} | ${previewUrl} |`,
+      `| ${t("cmd.previewTable.backendApi")} | http://${host}:${ports.backendPort}/api |`,
+      "",
+      `${t("cmd.previewTable.status")}: ${status.running ? t("cmd.previewRunning") : t("cmd.previewStopped")}`
+    ];
+    if (status.startedAt) lines.push(`${t("cmd.previewTable.startedAt")}: ${status.startedAt}`);
+    return this.ok(lines.join("\n"));
+  }
+  handleStopPreview(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    const dsm = this.orchestrator.getDevServerManager();
+    const status = dsm.getStatus(iid);
+    if (!status.running) {
+      return this.ok(t("cmd.noPreview", { iid }));
+    }
+    this.orchestrator.stopPreviewServers(iid);
+    return this.ok(t("cmd.previewStoppedMsg", { iid }));
+  }
+  async handleCleanNotes(iid) {
+    const record = this.tracker.get(iid);
+    if (!record) return this.notTracked(iid);
+    try {
+      const deleted = await this.gongfeng.cleanupAgentNotes(record.issueId);
+      return this.ok(t("cmd.cleanNotesSuccess", { count: deleted }));
+    } catch (err) {
+      return this.fail(err.message);
+    }
+  }
+  saveSupplement(iid, context) {
+    const existing = this.supplementStore.get(iid);
+    const prev = existing?.freeText?.trim() ?? "";
+    const merged = prev ? `${prev}
+
+---
+${context}` : context;
+    this.supplementStore.save(iid, {
+      requirements: existing?.requirements ?? "",
+      acceptanceCriteria: existing?.acceptanceCriteria ?? "",
+      scope: existing?.scope ?? "",
+      constraints: existing?.constraints ?? "",
+      references: existing?.references ?? "",
+      freeText: merged,
+      tapdId: existing?.tapdId ?? ""
+    });
+  }
+  async replyToIssue(issueId, result) {
+    try {
+      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 });
+    }
+  }
+  ok(message) {
+    return { success: true, message };
+  }
+  fail(message) {
+    return { success: false, message };
+  }
+  notTracked(iid) {
+    return this.fail(`Issue #${iid} is not tracked. Add the auto-finish label to start.`);
+  }
+  getIssuePipelineDef(record) {
+    const mode = record.pipelineMode === "plan-mode" ? "plan-mode" : "classic";
+    return getPipelineDef(mode);
+  }
+  getWorktreeWorkDir(iid) {
+    return path4.join(
+      this.config.project.worktreeBaseDir,
+      `issue-${iid}`,
+      this.config.project.projectSubDir
+    );
+  }
+};
+
+// src/webhook/NoteDeduplicator.ts
+var NoteDeduplicator = class {
+  seen;
+  maxSize;
+  constructor(maxSize = 1e3) {
+    this.seen = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  /**
+   * Returns true if this noteId has already been processed.
+   * If not, marks it as processed and returns false.
+   */
+  isDuplicate(noteId) {
+    if (this.seen.has(noteId)) return true;
+    this.seen.set(noteId, Date.now());
+    this.evictIfNeeded();
+    return false;
+  }
+  get size() {
+    return this.seen.size;
+  }
+  evictIfNeeded() {
+    if (this.seen.size <= this.maxSize) return;
+    const oldest = this.seen.keys().next().value;
+    if (oldest !== void 0) {
+      this.seen.delete(oldest);
+    }
+  }
+};
+
+// src/webhook/WebhookHandler.ts
+var logger8 = logger.child("WebhookHandler");
+function createWebhookRouter(deps) {
+  const router = Router3();
+  const executor = new CommandExecutor(deps);
+  const dedup = new NoteDeduplicator();
+  const { config, intentRecognizer } = deps;
+  const selfToken = config.gongfeng.privateToken;
+  router.post("/webhook/gongfeng", async (req, res) => {
+    if (!config.webhook.enabled) {
+      res.status(403).json({ error: "Webhook is disabled" });
+      return;
+    }
+    if (config.webhook.secret) {
+      const token = req.headers["x-gitlab-token"];
+      if (token !== config.webhook.secret) {
+        logger8.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" });
+      return;
+    }
+    if (isSelfNote(event, selfToken)) {
+      res.json({ ignored: true, reason: "self-posted note" });
+      return;
+    }
+    const noteId = event.object_attributes.id;
+    if (dedup.isDuplicate(noteId)) {
+      logger8.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;
+    }
+    res.json({ accepted: true, noteId, issueIid });
+    processCommandAsync(
+      noteBody,
+      issueIid,
+      issueId,
+      executor,
+      intentRecognizer,
+      config,
+      deps.tracker,
+      deps.gongfeng
+    );
+  });
+  return router;
+}
+var HELP_TEXT_FUNC = () => t("webhook.helpText");
+async function processCommandAsync(noteBody, issueIid, issueId, executor, intentRecognizer, config, tracker, gongfeng) {
+  try {
+    const cmdText = extractCommandText(noteBody);
+    if (!cmdText) return;
+    let command = parseExact(cmdText);
+    if (!command && intentRecognizer && config.webhook.llmFallback) {
+      const record = tracker.get(issueIid);
+      const state = record?.state;
+      logger8.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) });
+      await gongfeng.createIssueNote(issueId, HELP_TEXT_FUNC()).catch(
+        (e) => logger8.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", {
+      issueIid,
+      error: err.message
+    });
+  }
+}
+function isNoteOnIssue(event) {
+  return event.object_kind === "note" && event.object_attributes?.noteable_type?.toLowerCase() === "issue" && !!event.issue;
+}
+function isSelfNote(_event, _selfToken) {
+  return false;
+}
+
+// src/webhook/IntentRecognizer.ts
+import { spawn } from "child_process";
+var logger9 = logger.child("IntentRecognizer");
+var VALID_INTENTS = [
+  "retry",
+  "retry-from",
+  "supplement",
+  "approve",
+  "reject",
+  "status",
+  "restart"
+];
+var VALID_PHASES = [
+  "analysis",
+  "design",
+  "implement",
+  "verify",
+  "plan",
+  "build"
+];
+var SYSTEM_PROMPT_FUNC = () => t("intent.systemPrompt");
+var IntentRecognizer = class {
+  binary;
+  nvmNodeVersion;
+  model;
+  timeoutMs;
+  constructor(config) {
+    this.binary = config.binary;
+    this.nvmNodeVersion = config.nvmNodeVersion;
+    this.model = config.model;
+    this.timeoutMs = config.timeoutMs ?? 3e4;
+  }
+  async recognize(userComment, issueState) {
+    const stateHint = issueState ? `
+\u5F53\u524D Issue \u72B6\u6001: ${issueState}` : "";
+    const userPrompt = `${SYSTEM_PROMPT_FUNC()}
+
+\u7528\u6237\u8BC4\u8BBA:${stateHint}
+${userComment}`;
+    try {
+      const rawOutput = await this.runLLM(userPrompt);
+      return this.parseResponse(rawOutput);
+    } catch (err) {
+      logger9.error("Intent recognition failed", { error: err.message });
+      return null;
+    }
+  }
+  /** Visible for testing */
+  parseResponse(raw) {
+    const jsonMatch = raw.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      logger9.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) });
+      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 });
+      return null;
+    }
+    const result = { intent };
+    if (parsed.phase && parsed.phase !== "null") {
+      const phase = String(parsed.phase).toLowerCase();
+      if (VALID_PHASES.includes(phase)) {
+        result.phase = phase;
+      }
+    }
+    if (parsed.context && parsed.context !== "null") {
+      result.context = String(parsed.context).trim();
+    }
+    if (parsed.feedback && parsed.feedback !== "null") {
+      result.feedback = String(parsed.feedback).trim();
+    }
+    return result;
+  }
+  runLLM(prompt) {
+    return new Promise((resolve, reject) => {
+      const args = ["-p", "-", "--output-format", "text", "--verbose"];
+      if (this.model) args.push("--model", this.model);
+      const { CLAUDECODE, ...env } = process.env;
+      const child = spawn(this.binary, args, {
+        env: { ...env, NODE_VERSION: this.nvmNodeVersion },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        reject(new Error(`Intent recognition timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code !== 0) {
+          logger9.warn("LLM process exited with non-zero code", { code, stderr: stderr.slice(0, 300) });
+        }
+        resolve(stdout);
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
+  }
+};
+
+// src/webhook/WebhookServer.ts
+var logger10 = logger.child("WebhookServer");
+var WebhookServer = class {
+  app;
+  server = null;
+  port;
+  constructor(deps) {
+    this.port = deps.config.webhook.port;
+    const intentRecognizer = deps.config.webhook.llmFallback ? new IntentRecognizer({
+      binary: deps.config.webhook.llmBinary,
+      nvmNodeVersion: deps.config.ai.nvmNodeVersion,
+      model: deps.config.ai.model
+    }) : void 0;
+    const handlerDeps = {
+      tracker: deps.tracker,
+      orchestrator: deps.orchestrator,
+      supplementStore: deps.supplementStore,
+      gongfeng: deps.gongfeng,
+      config: deps.config,
+      intentRecognizer
+    };
+    this.app = express2();
+    this.app.use(express2.json());
+    this.app.use(createWebhookRouter(handlerDeps));
+    this.app.get("/health", (_req, res) => {
+      res.json({ status: "ok", service: "webhook" });
+    });
+  }
+  start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger10.info(`Webhook server listening on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+  stop() {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      logger10.info("Webhook server stopped");
+    }
+  }
+};
+
+// src/web/AgentLogStore.ts
+import fs4 from "fs";
+import path5 from "path";
+var logger11 = logger.child("AgentLogStore");
+var MAX_LOGS_PER_ISSUE = 2e4;
+var DEBUG_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "thinking",
+  "content_block_start",
+  "content_block_delta",
+  "content_block_stop",
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "ping"
+]);
+var AgentLogStore = class {
+  logDir;
+  constructor(dataDir) {
+    this.logDir = path5.join(dataDir, "agent-logs");
+    if (!fs4.existsSync(this.logDir)) {
+      fs4.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  startListening() {
+    eventBus.on("agent:output", (payload) => {
+      this.handleAgentOutput(payload);
+    });
+    eventBus.on("pipeline:progress", (payload) => {
+      this.handlePipelineProgress(payload);
+    });
+    logger11.info("AgentLogStore listening for events");
+  }
+  getLogs(issueIid) {
+    const filePath = this.logFilePath(issueIid);
+    if (!fs4.existsSync(filePath)) return [];
+    try {
+      const raw = fs4.readFileSync(filePath, "utf-8").trim();
+      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 });
+      return [];
+    }
+  }
+  clearLogs(issueIid) {
+    const filePath = this.logFilePath(issueIid);
+    if (fs4.existsSync(filePath)) {
+      fs4.unlinkSync(filePath);
+    }
+  }
+  logFilePath(issueIid) {
+    return path5.join(this.logDir, `${issueIid}.jsonl`);
+  }
+  appendLog(issueIid, entry) {
+    const filePath = this.logFilePath(issueIid);
+    try {
+      fs4.appendFileSync(filePath, `${JSON.stringify(entry)}
+`, "utf-8");
+      this.trimIfNeeded(issueIid, filePath);
+    } catch (err) {
+      logger11.warn("Failed to write agent log", { issueIid, error: err.message });
+    }
+  }
+  trimIfNeeded(issueIid, filePath) {
+    try {
+      const raw = fs4.readFileSync(filePath, "utf-8").trim();
+      if (!raw) return;
+      const lines = raw.split("\n");
+      if (lines.length > MAX_LOGS_PER_ISSUE) {
+        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 });
+      }
+    } catch {
+    }
+  }
+  handleAgentOutput(payload) {
+    const d = payload.data;
+    if (!d?.issueIid || !d.event) return;
+    const eventType = d.event.type || "raw";
+    if (DEBUG_EVENT_TYPES.has(eventType)) return;
+    const entry = {
+      type: eventType,
+      phase: d.phase,
+      timestamp: d.event.timestamp || payload.timestamp,
+      summary: this.summarizeContent(d.event)
+    };
+    this.appendLog(d.issueIid, entry);
+  }
+  handlePipelineProgress(payload) {
+    const d = payload.data;
+    if (!d?.issueIid) return;
+    const entry = {
+      type: "system",
+      phase: d.step,
+      timestamp: payload.timestamp,
+      summary: d.message || ""
+    };
+    this.appendLog(d.issueIid, entry);
+  }
+  summarizeContent(event) {
+    const { content } = event;
+    if (!content || typeof content === "string") return String(content || "");
+    if (event.type === "assistant") {
+      return this.extractAssistantText(content);
+    }
+    if (event.type === "tool_use") {
+      return this.extractToolUseText(content);
+    }
+    if (event.type === "tool_result") {
+      const text = typeof content.content === "string" ? content.content : JSON.stringify(content.content || "");
+      return text.slice(0, 150);
+    }
+    if (event.type === "result") {
+      const r = content;
+      return (r.result || JSON.stringify(content)).slice(0, 200);
+    }
+    return JSON.stringify(content).slice(0, 150);
+  }
+  extractAssistantText(content) {
+    const msg = content.message || content;
+    if (typeof msg === "string") return msg.slice(0, 200);
+    const m = msg;
+    if (m.text) return m.text.slice(0, 200);
+    if (m.content) {
+      const parts = Array.isArray(m.content) ? m.content : [m.content];
+      const texts = parts.filter((c) => c.type === "text").map((c) => c.text).join(" ");
+      return texts.slice(0, 200) || JSON.stringify(content).slice(0, 150);
+    }
+    return JSON.stringify(content).slice(0, 150);
+  }
+  extractToolUseText(content) {
+    const c = content;
+    const tool = c.tool;
+    const name = tool?.name || c.name || "?";
+    const input = tool?.input || c.input || {};
+    const detail = input.path || input.command || input.file_path || "";
+    return name + (detail ? `: ${detail}` : "");
+  }
+};
+
+// src/index.ts
+import path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = path6.dirname(fileURLToPath2(import.meta.url));
+async function main() {
+  logger.info("Issue Auto-Finish service starting...");
+  const config = loadConfig();
+  setLocale(config.locale);
+  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)
+  ];
+  validatePhaseRegistry([...new Set(allAiPhaseNames)]);
+  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 tracker = new IssueTracker(dataDir);
+  const supplementStore = new SupplementStore(dataDir);
+  const agentLogStore = new AgentLogStore(dataDir);
+  agentLogStore.startListening();
+  const orchestrator = new PipelineOrchestrator(config, gongfeng, git, aiRunner, tracker, supplementStore);
+  const poller = new IssuePoller(config, gongfeng, tracker, orchestrator);
+  let webServer = null;
+  if (config.web.enabled) {
+    webServer = new WebServer({ tracker, config, agentLogStore, orchestrator, gongfeng, supplementStore, mainGit: git });
+    await webServer.start();
+  }
+  let webhookServer = null;
+  if (config.webhook.enabled) {
+    webhookServer = new WebhookServer({ tracker, config, orchestrator, gongfeng, supplementStore });
+    await webhookServer.start();
+  }
+  const shutdown = () => {
+    logger.info("Shutting down...");
+    poller.stop();
+    webServer?.stop();
+    webhookServer?.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  poller.start();
+  logger.info("Issue Auto-Finish service started", {
+    projectPath: config.gongfeng.projectPath,
+    workDir: config.project.workDir,
+    discoveryIntervalMs: config.poll.discoveryIntervalMs,
+    driveIntervalMs: config.poll.driveIntervalMs,
+    webUI: config.web.enabled ? `http://localhost:${config.web.port}` : "disabled",
+    webhook: config.webhook.enabled ? `http://localhost:${config.webhook.port}/webhook/gongfeng` : "disabled"
+  });
+}
+
+export {
+  main
+};
+//# sourceMappingURL=chunk-IDUKWCC2.js.map