@xdevops/issue-auto-finish 1.0.84 → 1.0.85

package/dist/{chunk-7YCDMVIF.js → chunk-5UPYA6KH.js}

@@ -17,13 +17,13 @@ import {
   planPrompt,
   rePlanPrompt,
   verifyPrompt
-} from "./chunk-6S7ERGQ7.js";
+} from "./chunk-P4O4ZXEC.js";
 import {
   getProjectKnowledge
 } from "./chunk-ACVOOHAR.js";
 import {
   t
-} from "./chunk-KWODU7HB.js";
+} from "./chunk-YCYVNRLF.js";
 import {
   getLocalIP
 } from "./chunk-AKXDQH25.js";
@@ -40,6 +40,7 @@ import {
   InvalidPhaseError,
   InvalidStateError,
   IssueNotFoundError,
+  PhaseAbortedError,
   PhaseNotRegisteredError,
   PipelineNotFoundError,
   PortExhaustionError,
@@ -48,7 +49,7 @@ import {
   createAIRunner,
   getRunnerCapabilities,
   isShuttingDown
-} from "./chunk-7FLKETBC.js";
+} from "./chunk-4LFNFRCL.js";
 import {
   logger,
   runWithIssueContext
@@ -227,8 +228,8 @@ var GongfengClient = class {
     const encoded = encodeURIComponent(this.projectPath);
     return `${this.apiUrl}/api/v3/projects/${encoded}`;
   }
-  async requestRaw(path14, options = {}) {
-    const url = `${this.projectApiBase}${path14}`;
+  async requestRaw(path15, options = {}) {
+    const url = `${this.projectApiBase}${path15}`;
     logger4.debug("API request", { method: options.method || "GET", url });
     return this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -245,11 +246,11 @@ var GongfengClient = class {
           throw new GongfengApiError(resp.status, `Gongfeng API error ${resp.status}: ${body}`, body);
         }
         return resp;
-      }, `requestRaw ${options.method || "GET"} ${path14}`)
+      }, `requestRaw ${options.method || "GET"} ${path15}`)
     );
   }
-  async request(path14, options = {}) {
-    const resp = await this.requestRaw(path14, options);
+  async request(path15, options = {}) {
+    const resp = await this.requestRaw(path15, options);
     return resp.json();
   }
   async createIssue(title, description, labels) {
@@ -428,8 +429,8 @@ var GongfengClient = class {
     }
     return mr;
   }
-  async requestGlobal(path14, options = {}) {
-    const url = `${this.apiUrl}${path14}`;
+  async requestGlobal(path15, options = {}) {
+    const url = `${this.apiUrl}${path15}`;
     logger4.debug("API request (global)", { method: options.method || "GET", url });
     const resp = await this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -446,7 +447,7 @@ var GongfengClient = class {
           throw new GongfengApiError(r.status, `Gongfeng API error ${r.status}: ${body}`, body);
         }
         return r;
-      }, `requestGlobal ${options.method || "GET"} ${path14}`)
+      }, `requestGlobal ${options.method || "GET"} ${path15}`)
     );
     return resp.json();
   }
@@ -522,6 +523,7 @@ var IssueState = /* @__PURE__ */ ((IssueState2) => {
   IssueState2["PhaseWaiting"] = "phase_waiting";
   IssueState2["PhaseApproved"] = "phase_approved";
   IssueState2["ResolvingConflict"] = "resolving_conflict";
+  IssueState2["Paused"] = "paused";
   IssueState2["Completed"] = "completed";
   IssueState2["Failed"] = "failed";
   IssueState2["Deployed"] = "deployed";
@@ -550,6 +552,7 @@ var ActionLifecycleManager = class {
     this.addMapping("skipped" /* Skipped */, "init", "skipped");
     this.addMapping("branch_created" /* BranchCreated */, "init", "ready");
     this.addMapping("failed" /* Failed */, "init", "failed");
+    this.addMapping("paused" /* Paused */, "init", "paused");
     this.addMapping("deployed" /* Deployed */, "init", "done");
     this.addMapping("resolving_conflict" /* ResolvingConflict */, "conflict", "running");
     for (const spec of def.phases) {
@@ -593,6 +596,9 @@ var ActionLifecycleManager = class {
    * 对于通用状态 PhaseRunning/PhaseDone，需额外传入 currentPhase 来区分具体阶段。
    */
   resolve(state, currentPhase) {
+    if (state === "paused" /* Paused */ && currentPhase) {
+      return { action: currentPhase, status: "paused" };
+    }
     if (state === "phase_running" /* PhaseRunning */ && currentPhase) {
       return { action: currentPhase, status: "running" };
     }
@@ -648,6 +654,7 @@ var ActionLifecycleManager = class {
    * - done/skipped → 不可驱动
    */
   isDrivable(state, attempts, maxRetries, lastErrorRetryable) {
+    if (state === "paused" /* Paused */) return false;
     if (state === "phase_done" /* PhaseDone */) return true;
     if (state === "phase_approved" /* PhaseApproved */) return true;
     if (state === "phase_running" /* PhaseRunning */) return false;
@@ -664,6 +671,7 @@ var ActionLifecycleManager = class {
       case "running":
       case "done":
       case "skipped":
+      case "paused":
         return false;
     }
   }
@@ -772,6 +780,7 @@ var ActionLifecycleManager = class {
     }
     labels.set("completed" /* Completed */, t("state.completed"));
     labels.set("failed" /* Failed */, t("state.failed"));
+    labels.set("paused" /* Paused */, t("state.paused"));
     labels.set("resolving_conflict" /* ResolvingConflict */, t("state.resolvingConflict"));
     return labels;
   }
@@ -795,6 +804,19 @@ var ActionLifecycleManager = class {
       }
       return result;
     }
+    if (currentState === "paused" /* Paused */ && currentPhase) {
+      for (const phase of this.def.phases) {
+        if (passedCurrent) {
+          result[phase.name] = "pending";
+        } else if (phase.name === currentPhase) {
+          result[phase.name] = "in_progress";
+          passedCurrent = true;
+        } else {
+          result[phase.name] = "completed";
+        }
+      }
+      return result;
+    }
     if ((currentState === "phase_running" /* PhaseRunning */ || currentState === "phase_done" /* PhaseDone */) && currentPhase) {
       for (const phase of this.def.phases) {
         if (passedCurrent) {
@@ -1035,6 +1057,41 @@ var IssueTracker = class extends BaseTracker {
     logger5.warn("Issue marked as failed", { issueIid, error, failedAtState, attempts: record.attempts, isRetryable });
     eventBus.emitTyped("issue:failed", { issueIid, error, failedAtState, record });
   }
+  pauseIssue(issueIid, currentPhase) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record) return;
+    record.state = "paused" /* Paused */;
+    record.pausedAtPhase = currentPhase;
+    record.failedAtState = void 0;
+    record.lastError = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    logger5.info("Issue paused", { issueIid, pausedAtPhase: currentPhase });
+    eventBus.emitTyped("issue:paused", { issueIid, pausedAtPhase: currentPhase, record });
+  }
+  resumeFromPause(issueIid, def, clearSession) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record || record.state !== "paused" /* Paused */ || !record.pausedAtPhase) return false;
+    const lm = new ActionLifecycleManager(def);
+    const preState = lm.getPhasePreState(record.pausedAtPhase);
+    if (!preState) return false;
+    const phase = record.pausedAtPhase;
+    record.state = preState;
+    if (preState === "phase_done" /* PhaseDone */ || preState === "phase_approved" /* PhaseApproved */) {
+      const phases = def.phases;
+      const idx = phases.findIndex((p) => p.name === phase);
+      if (idx > 0) {
+        record.currentPhase = phases[idx - 1].name;
+      }
+    }
+    record.pausedAtPhase = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    const eventType = clearSession ? "issue:redone" : "issue:continued";
+    logger5.info("Issue resumed from pause", { issueIid, phase, clearSession, state: preState });
+    eventBus.emitTyped(eventType, { issueIid, phase, record });
+    return true;
+  }
   isProcessing(issueIid) {
     const record = this.get(issueIid);
     if (!record) return false;
@@ -1158,6 +1215,7 @@ var IssueTracker = class extends BaseTracker {
         record.failedAtState = record.state;
         record.state = "failed" /* Failed */;
         record.lastError = "Interrupted by service restart";
+        record.lastErrorRetryable = false;
         record.attempts += 1;
         record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         count++;
@@ -1167,6 +1225,16 @@ var IssueTracker = class extends BaseTracker {
           failedAtState: record.failedAtState,
           record
         });
+      } else if (record.state === "failed" /* Failed */ && record.lastErrorRetryable !== false) {
+        const iid = getIid(record);
+        logger5.info("Marking pre-existing failed issue as non-retryable after restart", {
+          issueIid: iid,
+          currentPhase: record.currentPhase,
+          attempts: record.attempts
+        });
+        record.lastErrorRetryable = false;
+        record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        count++;
       }
     }
     if (count > 0) {
@@ -2453,14 +2521,93 @@ var ReleasePhase = class extends BasePhase {
 };
 
 // src/phases/UatPhase.ts
+import fs7 from "fs";
+import path8 from "path";
+var logger9 = logger.child("UatPhase");
 function getDefaultHost() {
   return getLocalIP();
 }
 var UatPhase = class extends BasePhase {
   phaseName = "uat";
+  currentCtx;
   getResultFiles(_ctx) {
     return [{ filename: "03-uat-report.md", label: "UAT \u62A5\u544A" }];
   }
+  get planDir() {
+    const displayId = Number(this.currentCtx?.demand.sourceRef.displayId ?? 0);
+    return path8.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`);
+  }
+  /**
+   * 检查产物是否已存在且内容足够。
+   */
+  hasArtifact(displayId) {
+    const fp = path8.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`, "03-uat-report.md");
+    if (!fs7.existsSync(fp)) return false;
+    try {
+      return fs7.statSync(fp).size >= BasePhase.MIN_ARTIFACT_BYTES;
+    } catch {
+      return false;
+    }
+  }
+  async execute(ctx) {
+    this.currentCtx = ctx;
+    const displayId = Number(ctx.demand.sourceRef.displayId);
+    if (this.hasArtifact(displayId)) {
+      return this.completeWithExistingArtifact(ctx, displayId);
+    }
+    return this.launchAsyncUat(ctx, displayId);
+  }
+  /**
+   * Mode 2 — 产物已就绪，验证并完成阶段。
+   */
+  async completeWithExistingArtifact(ctx, displayId) {
+    logger9.info("UAT artifact found, completing phase", { iid: displayId });
+    await this.notifyPhaseStart();
+    await this.validatePhaseOutput(ctx, displayId);
+    await this.notifyPhaseDone();
+    this.plan.updatePhaseProgress(this.phaseName, "completed");
+    await this.commitPlanFiles(ctx, displayId);
+    await this.syncResultToIssue(ctx, displayId);
+    return { success: true, output: "UAT report validated", exitCode: 0, gateRequested: false };
+  }
+  /**
+   * Mode 1 — Fire-and-forget 启动 codebuddy，请求 gate 暂停。
+   * codebuddy 的日志通过 onStreamEvent → EventBus → SSE 实时推送到前端。
+   */
+  async launchAsyncUat(ctx, displayId) {
+    logger9.info("Launching async UAT", { iid: displayId });
+    await this.notifyPhaseStart();
+    this.plan.updatePhaseProgress(this.phaseName, "in_progress");
+    await this.notifyComment(issueProgressComment(this.phaseName, "in_progress"));
+    const prompt = this.buildPrompt(ctx);
+    const runPromise = this.aiRunner.run({
+      prompt,
+      workDir: this.resolveAIWorkDir(ctx),
+      timeoutMs: this.config.ai.phaseTimeoutMs,
+      idleTimeoutMs: this.config.ai.idleTimeoutMs,
+      onStreamEvent: (event) => {
+        eventBus.emitTyped("agent:output", {
+          issueIid: displayId,
+          phase: this.phaseName,
+          event
+        });
+      }
+    });
+    runPromise.then(async (result) => {
+      if (result.success && this.hasArtifact(displayId)) {
+        logger9.info("Async UAT completed successfully, approving gate", { iid: displayId });
+        await this.hooks.onAsyncGateApproval?.(this.phaseName);
+      } else {
+        const reason = result.errorMessage || "UAT failed or artifact 03-uat-report.md missing";
+        logger9.error("Async UAT failed", { iid: displayId, reason });
+        await this.hooks.onPhaseFailed(this.phaseName, reason);
+      }
+    }).catch(async (err) => {
+      logger9.error("Async UAT error", { iid: displayId, error: err.message });
+      await this.hooks.onPhaseFailed(this.phaseName, err.message);
+    });
+    return { success: true, output: "UAT launched asynchronously", exitCode: 0, gateRequested: true };
+  }
   buildPrompt(ctx) {
     const pc = demandToPromptContext(ctx.demand);
     const promptCtx = {
@@ -2594,6 +2741,7 @@ function buildPlanModePipeline(opts) {
       kind: "ai",
       startState: "phase_running" /* PhaseRunning */,
       doneState: "completed" /* Completed */,
+      approvedState: "phase_approved" /* PhaseApproved */,
       retryable: true,
       artifacts: [
         { filename: "03-uat-report.md", label: "UAT\u62A5\u544A", editable: false }
@@ -2638,9 +2786,9 @@ function createLifecycleManager(def) {
 
 // src/workspace/WorkspaceConfig.ts
 import { z } from "zod";
-import fs7 from "fs";
-import path8 from "path";
-var logger9 = logger.child("WorkspaceConfig");
+import fs8 from "fs";
+import path9 from "path";
+var logger10 = logger.child("WorkspaceConfig");
 var repoConfigSchema = z.object({
   name: z.string().min(1, "Repo name is required"),
   projectPath: z.string().min(1, "Gongfeng project path is required"),
@@ -2656,29 +2804,29 @@ var workspaceConfigSchema = z.object({
 });
 function loadWorkspaceConfig(configPath) {
   if (!configPath) return null;
-  if (!fs7.existsSync(configPath)) {
-    logger9.warn("Workspace config file not found, falling back to single-repo mode", {
+  if (!fs8.existsSync(configPath)) {
+    logger10.warn("Workspace config file not found, falling back to single-repo mode", {
       path: configPath
     });
     return null;
   }
   try {
-    const raw = fs7.readFileSync(configPath, "utf-8");
+    const raw = fs8.readFileSync(configPath, "utf-8");
     const json = JSON.parse(raw);
     const result = workspaceConfigSchema.safeParse(json);
     if (!result.success) {
       const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      logger9.error(`Workspace config validation failed:
+      logger10.error(`Workspace config validation failed:
 ${issues}`);
       return null;
     }
-    logger9.info("Workspace config loaded", {
+    logger10.info("Workspace config loaded", {
       primary: result.data.primary.name,
       associates: result.data.associates.map((a) => a.name)
     });
     return result.data;
   } catch (err) {
-    logger9.error("Failed to parse workspace config", {
+    logger10.error("Failed to parse workspace config", {
       path: configPath,
       error: err.message
     });
@@ -2704,14 +2852,14 @@ function isMultiRepo(ws) {
 }
 function persistWorkspaceConfig(ws, filePath) {
   try {
-    const dir = path8.dirname(filePath);
-    if (!fs7.existsSync(dir)) {
-      fs7.mkdirSync(dir, { recursive: true });
+    const dir = path9.dirname(filePath);
+    if (!fs8.existsSync(dir)) {
+      fs8.mkdirSync(dir, { recursive: true });
     }
-    fs7.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
-    logger9.info("Workspace config auto-generated from .env", { path: filePath });
+    fs8.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
+    logger10.info("Workspace config auto-generated from .env", { path: filePath });
   } catch (err) {
-    logger9.warn("Failed to persist workspace config", {
+    logger10.warn("Failed to persist workspace config", {
       path: filePath,
       error: err.message
     });
@@ -2719,12 +2867,12 @@ function persistWorkspaceConfig(ws, filePath) {
 }
 
 // src/workspace/WorkspaceManager.ts
-import path9 from "path";
-import fs8 from "fs/promises";
+import path10 from "path";
+import fs9 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var logger10 = logger.child("WorkspaceManager");
+var logger11 = logger.child("WorkspaceManager");
 var WorkspaceManager = class {
   wsConfig;
   worktreeBaseDir;
@@ -2753,7 +2901,7 @@ var WorkspaceManager = class {
    */
   async prepareWorkspace(issueIid, branchName, globalBaseBranch, globalBranchPrefix) {
     const wsRoot = this.getWorkspaceRoot(issueIid);
-    await fs8.mkdir(wsRoot, { recursive: true });
+    await fs9.mkdir(wsRoot, { recursive: true });
     const primaryCtx = await this.preparePrimaryRepo(
       issueIid,
       branchName,
@@ -2772,7 +2920,7 @@ var WorkspaceManager = class {
       );
       associateCtxs.push(ctx);
     }
-    logger10.info("Workspace prepared", {
+    logger11.info("Workspace prepared", {
       issueIid,
       wsRoot,
       repos: [primaryCtx.name, ...associateCtxs.map((a) => a.name)]
@@ -2797,7 +2945,7 @@ var WorkspaceManager = class {
         await git.commit(message);
         await git.push(wsCtx.branchName);
         committed.push(repo.name);
-        logger10.info("Committed and pushed changes", {
+        logger11.info("Committed and pushed changes", {
           repo: repo.name,
           branch: wsCtx.branchName
         });
@@ -2811,19 +2959,19 @@ var WorkspaceManager = class {
   async cleanupWorkspace(wsCtx) {
     try {
       await this.mainGit.worktreeRemove(wsCtx.primary.gitRootDir, true);
-      logger10.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
+      logger11.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
     } catch (err) {
-      logger10.warn("Failed to remove primary worktree", {
+      logger11.warn("Failed to remove primary worktree", {
         dir: wsCtx.primary.gitRootDir,
         error: err.message
       });
     }
     for (const assoc of wsCtx.associates) {
       try {
-        await fs8.rm(assoc.gitRootDir, { recursive: true, force: true });
-        logger10.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
+        await fs9.rm(assoc.gitRootDir, { recursive: true, force: true });
+        logger11.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
       } catch (err) {
-        logger10.warn("Failed to remove associate repo dir", {
+        logger11.warn("Failed to remove associate repo dir", {
           name: assoc.name,
           dir: assoc.gitRootDir,
           error: err.message
@@ -2831,9 +2979,9 @@ var WorkspaceManager = class {
       }
     }
     try {
-      const entries = await fs8.readdir(wsCtx.workspaceRoot);
+      const entries = await fs9.readdir(wsCtx.workspaceRoot);
       if (entries.length === 0) {
-        await fs8.rmdir(wsCtx.workspaceRoot);
+        await fs9.rmdir(wsCtx.workspaceRoot);
       }
     } catch {
     }
@@ -2845,13 +2993,13 @@ var WorkspaceManager = class {
     const wsRoot = this.getWorkspaceRoot(issueIid);
     const primary = this.wsConfig.primary;
     const defaultPrefix = globalBranchPrefix ?? primary.branchPrefix ?? "feat/issue";
-    const primaryDir = path9.join(wsRoot, primary.name);
+    const primaryDir = path10.join(wsRoot, primary.name);
     const repos = [{
       name: primary.name,
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: primaryDir,
-      workDir: path9.join(primaryDir, primary.projectSubDir ?? ""),
+      workDir: path10.join(primaryDir, primary.projectSubDir ?? ""),
       baseBranch: primary.baseBranch ?? globalBaseBranch,
       branchPrefix: primary.branchPrefix ?? defaultPrefix,
       isPrimary: true
@@ -2861,8 +3009,8 @@ var WorkspaceManager = class {
         name: assoc.name,
         projectPath: assoc.projectPath,
         role: assoc.role ?? "",
-        gitRootDir: path9.join(wsRoot, assoc.name),
-        workDir: path9.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
+        gitRootDir: path10.join(wsRoot, assoc.name),
+        workDir: path10.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
         baseBranch: assoc.baseBranch ?? globalBaseBranch,
         branchPrefix: assoc.branchPrefix ?? defaultPrefix,
         isPrimary: false
@@ -2871,12 +3019,12 @@ var WorkspaceManager = class {
     return repos;
   }
   getWorkspaceRoot(issueIid) {
-    return path9.join(this.worktreeBaseDir, `issue-${issueIid}`);
+    return path10.join(this.worktreeBaseDir, `issue-${issueIid}`);
   }
   // ── Internal helpers ──
   async preparePrimaryRepo(issueIid, branchName, wsRoot, globalBaseBranch) {
     const primary = this.wsConfig.primary;
-    const repoDir = path9.join(wsRoot, primary.name);
+    const repoDir = path10.join(wsRoot, primary.name);
     const baseBranch = primary.baseBranch ?? globalBaseBranch;
     await this.ensurePrimaryWorktree(repoDir, branchName, baseBranch);
     return {
@@ -2884,18 +3032,18 @@ var WorkspaceManager = class {
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: repoDir,
-      workDir: path9.join(repoDir, primary.projectSubDir ?? ""),
+      workDir: path10.join(repoDir, primary.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: primary.branchPrefix ?? "feat/issue",
       isPrimary: true
     };
   }
   async ensurePrimaryWorktree(repoDir, branchName, baseBranch) {
-    const wsRoot = path9.dirname(repoDir);
+    const wsRoot = path10.dirname(repoDir);
     if (wsRoot !== repoDir) {
       try {
-        await fs8.access(path9.join(wsRoot, ".git"));
-        logger10.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
+        await fs9.access(path10.join(wsRoot, ".git"));
+        logger11.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
         await this.mainGit.worktreeRemove(wsRoot, true);
         await this.mainGit.worktreePrune();
         await this.cleanStaleDir(wsRoot);
@@ -2905,11 +3053,11 @@ var WorkspaceManager = class {
     const worktrees = await this.mainGit.worktreeList();
     if (worktrees.includes(repoDir)) {
       try {
-        await fs8.access(path9.join(repoDir, ".git"));
-        logger10.info("Reusing existing primary worktree", { dir: repoDir });
+        await fs9.access(path10.join(repoDir, ".git"));
+        logger11.info("Reusing existing primary worktree", { dir: repoDir });
         return;
       } catch {
-        logger10.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
+        logger11.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
         await this.mainGit.worktreeRemove(repoDir, true);
         await this.mainGit.worktreePrune();
       }
@@ -2928,19 +3076,19 @@ var WorkspaceManager = class {
     await this.mainGit.worktreeAdd(repoDir, branchName, `origin/${baseBranch}`);
   }
   async prepareAssociateRepo(assoc, _issueIid, branchName, wsRoot, globalBaseBranch, globalBranchPrefix) {
-    const repoDir = path9.join(wsRoot, assoc.name);
+    const repoDir = path10.join(wsRoot, assoc.name);
     const baseBranch = assoc.baseBranch ?? globalBaseBranch;
     const cloneUrl = `${this.gongfengApiUrl}/${assoc.projectPath}.git`;
-    const gitDirExists = await this.dirExists(path9.join(repoDir, ".git"));
+    const gitDirExists = await this.dirExists(path10.join(repoDir, ".git"));
     if (!gitDirExists) {
       await this.cleanStaleDir(repoDir);
-      logger10.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
+      logger11.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
       await execFileAsync("git", ["clone", "--depth", "50", cloneUrl, repoDir], {
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024
       });
     } else {
-      logger10.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
+      logger11.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
     }
     const assocGit = new GitOperations(repoDir);
     await assocGit.fetch();
@@ -2963,7 +3111,7 @@ var WorkspaceManager = class {
       projectPath: assoc.projectPath,
       role: assoc.role ?? "",
       gitRootDir: repoDir,
-      workDir: path9.join(repoDir, assoc.projectSubDir ?? ""),
+      workDir: path10.join(repoDir, assoc.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: assoc.branchPrefix ?? globalBranchPrefix,
       isPrimary: false
@@ -2971,13 +3119,13 @@ var WorkspaceManager = class {
   }
   async cleanStaleDir(dir) {
     if (await this.dirExists(dir)) {
-      logger10.warn("Removing stale directory", { dir });
-      await fs8.rm(dir, { recursive: true, force: true });
+      logger11.warn("Removing stale directory", { dir });
+      await fs9.rm(dir, { recursive: true, force: true });
     }
   }
   async dirExists(dir) {
     try {
-      await fs8.access(dir);
+      await fs9.access(dir);
       return true;
     } catch {
       return false;
@@ -2986,8 +3134,8 @@ var WorkspaceManager = class {
 };
 
 // src/orchestrator/PipelineOrchestrator.ts
-import path13 from "path";
-import fs12 from "fs/promises";
+import path14 from "path";
+import fs13 from "fs/promises";
 import fsSync from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3020,8 +3168,8 @@ function mapSupplement(s) {
 }
 
 // src/utils/MergeRequestHelper.ts
-import fs9 from "fs";
-import path10 from "path";
+import fs10 from "fs";
+import path11 from "path";
 var TAPD_PATTERNS = [
   /--story=(\d+)/i,
   /--bug=(\d+)/i,
@@ -3065,9 +3213,9 @@ function generateMRDescription(options) {
     ];
     const planSections = [];
     for (const { filename, label } of summaryFiles) {
-      const filePath = path10.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
-      if (fs9.existsSync(filePath)) {
-        const content = fs9.readFileSync(filePath, "utf-8");
+      const filePath = path11.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs10.existsSync(filePath)) {
+        const content = fs10.readFileSync(filePath, "utf-8");
         const summary = extractSummary(content);
         if (summary) {
           planSections.push(`### ${label}
@@ -3091,7 +3239,7 @@ function extractSummary(content, maxLines = 20) {
 
 // src/deploy/PortAllocator.ts
 import net from "net";
-var logger11 = logger.child("PortAllocator");
+var logger12 = logger.child("PortAllocator");
 var DEFAULT_OPTIONS = {
   backendPortBase: 4e3,
   frontendPortBase: 9e3,
@@ -3116,7 +3264,7 @@ var PortAllocator = class {
   async allocate(issueIid) {
     const existing = this.allocated.get(issueIid);
     if (existing) {
-      logger11.info("Returning already allocated ports", { issueIid, ports: existing });
+      logger12.info("Returning already allocated ports", { issueIid, ports: existing });
       return existing;
     }
     const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
@@ -3134,10 +3282,10 @@ var PortAllocator = class {
       if (beOk && feOk) {
         const pair = { backendPort, frontendPort };
         this.allocated.set(issueIid, pair);
-        logger11.info("Ports allocated", { issueIid, ...pair });
+        logger12.info("Ports allocated", { issueIid, ...pair });
         return pair;
       }
-      logger11.debug("Port pair unavailable, trying next", {
+      logger12.debug("Port pair unavailable, trying next", {
         backendPort,
         frontendPort,
         beOk,
@@ -3152,7 +3300,7 @@ var PortAllocator = class {
     const pair = this.allocated.get(issueIid);
     if (pair) {
       this.allocated.delete(issueIid);
-      logger11.info("Ports released", { issueIid, ...pair });
+      logger12.info("Ports released", { issueIid, ...pair });
     }
   }
   getPortsForIssue(issueIid) {
@@ -3163,15 +3311,15 @@ var PortAllocator = class {
   }
   restore(issueIid, ports) {
     this.allocated.set(issueIid, ports);
-    logger11.info("Ports restored from persistence", { issueIid, ...ports });
+    logger12.info("Ports restored from persistence", { issueIid, ...ports });
   }
 };
 
 // src/deploy/DevServerManager.ts
 import { spawn } from "child_process";
-import fs10 from "fs";
-import path11 from "path";
-var logger12 = logger.child("DevServerManager");
+import fs11 from "fs";
+import path12 from "path";
+var logger13 = logger.child("DevServerManager");
 var DEFAULT_OPTIONS2 = {};
 var DevServerManager = class {
   servers = /* @__PURE__ */ new Map();
@@ -3179,25 +3327,25 @@ var DevServerManager = class {
   logDir;
   constructor(options) {
     this.options = { ...DEFAULT_OPTIONS2, ...options };
-    this.logDir = path11.join(resolveDataDir(), "preview-logs");
-    if (!fs10.existsSync(this.logDir)) {
-      fs10.mkdirSync(this.logDir, { recursive: true });
+    this.logDir = path12.join(resolveDataDir(), "preview-logs");
+    if (!fs11.existsSync(this.logDir)) {
+      fs11.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogPath(issueIid, type) {
-    const filePath = path11.join(this.logDir, `${issueIid}-${type}.log`);
-    return fs10.existsSync(filePath) ? filePath : null;
+    const filePath = path12.join(this.logDir, `${issueIid}-${type}.log`);
+    return fs11.existsSync(filePath) ? filePath : null;
   }
   async startServers(wtCtx, ports) {
     if (this.servers.has(wtCtx.issueIid)) {
-      logger12.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      logger13.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
       return;
     }
-    logger12.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
-    const backendLogPath = path11.join(this.logDir, `${wtCtx.issueIid}-backend.log`);
-    const frontendLogPath = path11.join(this.logDir, `${wtCtx.issueIid}-frontend.log`);
-    const backendLog = fs10.createWriteStream(backendLogPath, { flags: "a" });
-    const frontendLog = fs10.createWriteStream(frontendLogPath, { flags: "a" });
+    logger13.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    const backendLogPath = path12.join(this.logDir, `${wtCtx.issueIid}-backend.log`);
+    const frontendLogPath = path12.join(this.logDir, `${wtCtx.issueIid}-frontend.log`);
+    const backendLog = fs11.createWriteStream(backendLogPath, { flags: "a" });
+    const frontendLog = fs11.createWriteStream(frontendLogPath, { flags: "a" });
     const tsLine = (stream, data) => `[${(/* @__PURE__ */ new Date()).toISOString()}] [${stream}] ${data.toString().trimEnd()}
 `;
     const backendEnv = {
@@ -3221,9 +3369,9 @@ var DevServerManager = class {
       backendLog.write(tsLine("stderr", data));
     });
     backend.on("exit", (code) => {
-      logger12.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+      logger13.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
     });
-    const frontendDir = path11.join(wtCtx.workDir, "frontend");
+    const frontendDir = path12.join(wtCtx.workDir, "frontend");
     const frontendEnv = {
       ...process.env,
       BACKEND_PORT: String(ports.backendPort),
@@ -3245,7 +3393,7 @@ var DevServerManager = class {
       frontendLog.write(tsLine("stderr", data));
     });
     frontend.on("exit", (code) => {
-      logger12.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+      logger13.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
     });
     const serverSet = {
       backend,
@@ -3257,14 +3405,14 @@ var DevServerManager = class {
       frontendLog
     };
     this.servers.set(wtCtx.issueIid, serverSet);
-    logger12.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
+    logger13.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
     await new Promise((r) => setTimeout(r, 1e4));
-    logger12.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
+    logger13.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
   }
   stopServers(issueIid) {
     const set = this.servers.get(issueIid);
     if (!set) return;
-    logger12.info("Stopping dev servers", { issueIid, ports: set.ports });
+    logger13.info("Stopping dev servers", { issueIid, ports: set.ports });
     killProcess(set.backend, `backend #${issueIid}`);
     killProcess(set.frontend, `frontend #${issueIid}`);
     set.backendLog.end();
@@ -3301,7 +3449,7 @@ function killProcess(proc, label) {
     }
     setTimeout(() => {
       if (!proc.killed && proc.exitCode === null) {
-        logger12.warn(`Force killing ${label}`);
+        logger13.warn(`Force killing ${label}`);
         try {
           process.kill(-pid, "SIGKILL");
         } catch {
@@ -3310,7 +3458,7 @@ function killProcess(proc, label) {
       }
     }, 5e3);
   } catch (err) {
-    logger12.warn(`Failed to kill ${label}`, { error: err.message });
+    logger13.warn(`Failed to kill ${label}`, { error: err.message });
   }
 }
 
@@ -3329,13 +3477,13 @@ function isE2eEnabledForIssue(issueIid, tracker, cfg) {
 }
 
 // src/e2e/ScreenshotCollector.ts
-import fs11 from "fs";
-import path12 from "path";
-var logger13 = logger.child("ScreenshotCollector");
+import fs12 from "fs";
+import path13 from "path";
+var logger14 = logger.child("ScreenshotCollector");
 var MAX_SCREENSHOTS = 20;
 function walkDir(dir, files = []) {
-  for (const entry of fs11.readdirSync(dir, { withFileTypes: true })) {
-    const full = path12.join(dir, entry.name);
+  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
+    const full = path13.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkDir(full, files);
     } else if (entry.isFile() && entry.name.endsWith(".png")) {
@@ -3345,34 +3493,34 @@ function walkDir(dir, files = []) {
   return files;
 }
 function collectScreenshots(workDir) {
-  const testResultsDir = path12.join(workDir, "frontend", "test-results");
-  if (!fs11.existsSync(testResultsDir)) {
-    logger13.debug("test-results directory not found", { dir: testResultsDir });
+  const testResultsDir = path13.join(workDir, "frontend", "test-results");
+  if (!fs12.existsSync(testResultsDir)) {
+    logger14.debug("test-results directory not found", { dir: testResultsDir });
     return [];
   }
   const pngFiles = walkDir(testResultsDir);
   if (pngFiles.length === 0) {
-    logger13.debug("No screenshots found");
+    logger14.debug("No screenshots found");
     return [];
   }
   const screenshots = pngFiles.map((filePath) => {
-    const relative = path12.relative(testResultsDir, filePath);
-    const testName = relative.split(path12.sep)[0] || path12.basename(filePath, ".png");
+    const relative = path13.relative(testResultsDir, filePath);
+    const testName = relative.split(path13.sep)[0] || path13.basename(filePath, ".png");
     return { filePath, testName };
   });
   if (screenshots.length > MAX_SCREENSHOTS) {
-    logger13.warn("Too many screenshots, truncating", {
+    logger14.warn("Too many screenshots, truncating", {
       total: screenshots.length,
       max: MAX_SCREENSHOTS
     });
     return screenshots.slice(0, MAX_SCREENSHOTS);
   }
-  logger13.info("Screenshots collected", { count: screenshots.length });
+  logger14.info("Screenshots collected", { count: screenshots.length });
   return screenshots;
 }
 
 // src/e2e/ScreenshotPublisher.ts
-var logger14 = logger.child("ScreenshotPublisher");
+var logger15 = logger.child("ScreenshotPublisher");
 function buildComment(uploaded, truncated) {
   const lines = [t("screenshot.title"), ""];
   for (const item of uploaded) {
@@ -3391,12 +3539,12 @@ var ScreenshotPublisher = class {
     const { workDir, issueIid, issueId, mrIid } = options;
     const screenshots = collectScreenshots(workDir);
     if (screenshots.length === 0) {
-      logger14.info("No E2E screenshots to publish", { issueIid });
+      logger15.info("No E2E screenshots to publish", { issueIid });
       return;
     }
     const uploaded = await this.uploadAll(screenshots);
     if (uploaded.length === 0) {
-      logger14.warn("All screenshot uploads failed", { issueIid });
+      logger15.warn("All screenshot uploads failed", { issueIid });
       return;
     }
     const truncated = screenshots.length >= 20;
@@ -3405,7 +3553,7 @@ var ScreenshotPublisher = class {
     if (mrIid) {
       await this.postToMergeRequest(mrIid, comment);
     }
-    logger14.info("E2E screenshots published", {
+    logger15.info("E2E screenshots published", {
       issueIid,
       mrIid,
       count: uploaded.length
@@ -3421,7 +3569,7 @@ var ScreenshotPublisher = class {
           markdown: result.markdown
         });
       } catch (err) {
-        logger14.warn("Failed to upload screenshot", {
+        logger15.warn("Failed to upload screenshot", {
           filePath: screenshot.filePath,
           error: err.message
         });
@@ -3433,7 +3581,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createIssueNote(issueId, comment);
     } catch (err) {
-      logger14.warn("Failed to post screenshots to issue", {
+      logger15.warn("Failed to post screenshots to issue", {
         issueId,
         error: err.message
       });
@@ -3443,7 +3591,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, comment);
     } catch (err) {
-      logger14.warn("Failed to post screenshots to merge request", {
+      logger15.warn("Failed to post screenshots to merge request", {
         mrIid,
         error: err.message
       });
@@ -3626,7 +3774,7 @@ metrics.registerCounter("iaf_braindump_batches_total", "Total braindump batches"
 metrics.registerCounter("iaf_braindump_tasks_total", "Total braindump tasks");
 
 // src/orchestrator/steps/SetupStep.ts
-var logger15 = logger.child("SetupStep");
+var logger16 = logger.child("SetupStep");
 async function executeSetup(ctx, deps) {
   const { issue, wtCtx, record, pipelineDef, branchName } = ctx;
   try {
@@ -3635,7 +3783,7 @@ async function executeSetup(ctx, deps) {
       "auto-finish:processing"
     ]);
   } catch (err) {
-    logger15.warn("Failed to update issue labels", { error: err.message });
+    logger16.warn("Failed to update issue labels", { error: err.message });
   }
   await deps.mainGitMutex.runExclusive(async () => {
     deps.emitProgress(issue.iid, "fetch", t("orchestrator.fetchProgress"));
@@ -3687,7 +3835,7 @@ async function executeSetup(ctx, deps) {
 }
 
 // src/orchestrator/steps/PhaseLoopStep.ts
-var logger16 = logger.child("PhaseLoopStep");
+var logger17 = logger.child("PhaseLoopStep");
 function resolveVerifyRunner(deps) {
   return deps.aiRunner;
 }
@@ -3717,13 +3865,17 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     const skippedDeployPhase = pipelineDef.phases.slice(0, startIdx).some((p) => p.deploysPreview);
     if (skippedDeployPhase && !phaseCtx.ports) {
       const existingPorts = deps.getPortsForIssue(issue.iid);
-      if (existingPorts) {
-        logger16.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
+      if (existingPorts && deps.isPreviewRunning(issue.iid)) {
+        logger17.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
         phaseCtx.ports = existingPorts;
         ctx.wtCtx.ports = existingPorts;
         serversStarted = true;
       } else {
-        logger16.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+        if (existingPorts) {
+          logger17.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
+        } else {
+          logger17.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+        }
         const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
         if (ports) {
           phaseCtx.ports = ports;
@@ -3738,9 +3890,13 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       throw new ServiceShutdownError();
     }
     const spec = pipelineDef.phases[i];
+    const pendingAction = deps.consumePendingAction?.(issue.iid);
+    if (pendingAction) {
+      throw new PhaseAbortedError(spec.name, pendingAction);
+    }
     if (spec.kind === "gate") {
       if (deps.shouldAutoApprove(issue.labels)) {
-        logger16.info("Auto-approving review gate (matched autoApproveLabels)", {
+        logger17.info("Auto-approving review gate (matched autoApproveLabels)", {
           iid: issue.iid,
           labels: issue.labels,
           autoApproveLabels: deps.config.review.autoApproveLabels
@@ -3761,7 +3917,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       deps.tracker.updateState(issue.iid, spec.startState, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "in_progress");
       deps.eventBus.emitTyped("review:requested", { issueIid: issue.iid });
-      logger16.info("Review gate reached, pausing", { iid: issue.iid });
+      logger17.info("Review gate reached, pausing", { iid: issue.iid });
       return { serversStarted, paused: true };
     }
     if (spec.name === "verify" && deps.config.verifyFixLoop.enabled) {
@@ -3770,7 +3926,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       continue;
     }
     if (spec.name === "uat" && !isE2eEnabledForIssue(issue.iid, deps.tracker, deps.config)) {
-      logger16.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issue.iid });
+      logger17.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issue.iid });
       deps.tracker.updateState(issue.iid, spec.doneState, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "completed");
       continue;
@@ -3779,7 +3935,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     const runner = spec.name === "verify" ? resolveVerifyRunner(deps) : spec.name === "uat" ? resolveUatRunner(deps, issue.iid) : deps.aiRunner;
     if (spec.name === "uat") {
       const runnerName = runner === deps.e2eAiRunner ? "e2eAiRunner (CodeBuddy)" : "mainRunner";
-      logger16.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
+      logger17.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
     }
     const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config, lifecycleManager, hooks);
     if (wtGitMap && wtGitMap.size > 1) {
@@ -3789,8 +3945,9 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     if (spec.approvedState && result && "gateRequested" in result && result.gateRequested) {
       deps.tracker.updateState(issue.iid, "phase_waiting" /* PhaseWaiting */, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "gate_waiting");
-      deps.eventBus.emitTyped("release:gateRequested", { issueIid: issue.iid });
-      logger16.info("AI phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
+      const gateEvent = spec.name === "uat" ? "uat:gateRequested" : "release:gateRequested";
+      deps.eventBus.emitTyped(gateEvent, { issueIid: issue.iid });
+      logger17.info("AI phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
       return { serversStarted, paused: true };
     }
     if (needsDeployment && !serversStarted && lifecycleManager.shouldDeployPreview(spec.name)) {
@@ -3817,7 +3974,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     issueIid: issue.iid,
     maxIterations
   });
-  logger16.info("Verify-fix loop started", {
+  logger17.info("Verify-fix loop started", {
     iid: issue.iid,
     maxIterations,
     buildPhaseIdx
@@ -3826,7 +3983,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     if (isShuttingDown()) {
       throw new ServiceShutdownError();
     }
-    logger16.info("Verify-fix loop iteration", {
+    logger17.info("Verify-fix loop iteration", {
       iteration,
       maxIterations,
       iid: issue.iid
@@ -3849,7 +4006,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     try {
       verifyResult = await verifyPhase.execute(phaseCtx);
     } catch (err) {
-      logger16.warn("Verify phase execution failed", {
+      logger17.warn("Verify phase execution failed", {
         iteration,
         iid: issue.iid,
         error: err.message
@@ -3881,13 +4038,13 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
       failures: report?.failureReasons
     });
     if (passed) {
-      logger16.info("Verify-fix loop passed", {
+      logger17.info("Verify-fix loop passed", {
         iteration,
         iid: issue.iid
       });
       return;
     }
-    logger16.info("Verify failed, issues found", {
+    logger17.info("Verify failed, issues found", {
       iteration,
       iid: issue.iid,
       failures: report?.failureReasons,
@@ -3900,7 +4057,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
         failures: report?.failureReasons ?? []
       });
       const failMsg = `Verify-fix loop exhausted after ${maxIterations} iterations. Remaining issues: ${report?.failureReasons?.join("; ") ?? "unknown"}`;
-      logger16.warn(failMsg, { iid: issue.iid });
+      logger17.warn(failMsg, { iid: issue.iid });
       throw new AIExecutionError("verify", failMsg, {
         output: report?.rawReport ?? "",
         exitCode: 0
@@ -3917,7 +4074,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
 }
 async function executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixContext, wtGitMap) {
   const { issue, lifecycleManager, phaseCtx } = ctx;
-  logger16.info("Looping back to build for fix", {
+  logger17.info("Looping back to build for fix", {
     iteration: fixContext.iteration,
     iid: issue.iid,
     failures: fixContext.verifyFailures
@@ -3944,7 +4101,7 @@ async function executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixConte
 }
 
 // src/orchestrator/steps/CompletionStep.ts
-var logger17 = logger.child("CompletionStep");
+var logger18 = logger.child("CompletionStep");
 async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
   const { issue, branchName, wtCtx } = ctx;
   deps.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
@@ -3976,7 +4133,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger17.warn("Failed to publish E2E screenshots", {
+      logger18.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -3996,19 +4153,19 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
     await deps.claimer.releaseClaim(issue.id, issue.iid, "completed");
   }
   if (phaseResult.serversStarted && deps.config.preview.keepAfterComplete) {
-    logger17.info("Preview servers kept running after completion", { iid: issue.iid });
+    logger18.info("Preview servers kept running after completion", { iid: issue.iid });
   } else {
     deps.stopPreviewServers(issue.iid);
     await deps.mainGitMutex.runExclusive(async () => {
       if (wtCtx.workspace) {
         await deps.workspaceManager.cleanupWorkspace(wtCtx.workspace);
-        logger17.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
+        logger18.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
       } else {
         try {
           await deps.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-          logger17.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+          logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger17.warn("Failed to cleanup worktree", {
+          logger18.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -4016,15 +4173,15 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger17.info("Issue processing completed", { iid: issue.iid });
+  logger18.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger18 = logger.child("FailureHandler");
+var logger19 = logger.child("FailureHandler");
 async function handleFailure(err, issue, wtCtx, deps) {
   const errorMsg = err.message;
   const isRetryable = err instanceof AIExecutionError ? err.isRetryable : true;
-  logger18.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable });
+  logger19.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable });
   metrics.incCounter("iaf_issues_failed_total");
   const currentRecord = deps.tracker.get(issue.iid);
   const failedAtState = currentRecord?.state || "pending" /* Pending */;
@@ -4033,7 +4190,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     deps.tracker.markFailed(issue.iid, errorMsg.slice(0, 500), failedAtState, isRetryable);
   }
   if (wasReset) {
-    logger18.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    logger19.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    throw err;
+  }
+  if (failedAtState === "paused" /* Paused */) {
+    logger19.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
     throw err;
   }
   try {
@@ -4055,7 +4216,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
     try {
       await deps.claimer.releaseClaim(issue.id, issue.iid, "failed");
     } catch (releaseErr) {
-      logger18.warn("Failed to release lock on failure", {
+      logger19.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -4063,7 +4224,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
   }
   deps.stopPreviewServers(issue.iid);
   const preservedDirs = wtCtx.workspace ? [wtCtx.workspace.primary.gitRootDir, ...wtCtx.workspace.associates.map((a) => a.gitRootDir)] : [wtCtx.gitRootDir];
-  logger18.info("Worktree(s) preserved for debugging", {
+  logger19.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -4072,7 +4233,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger19 = logger.child("PipelineOrchestrator");
+var logger20 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -4093,6 +4254,7 @@ var PipelineOrchestrator = class {
   workspaceManager;
   tenantId;
   effectiveWorktreeBaseDir;
+  pendingActions = /* @__PURE__ */ new Map();
   /** 暴露 AIRunner 给外部（如 CommandExecutor 取消进程时使用） */
   getAIRunner() {
     return this.aiRunner;
@@ -4101,7 +4263,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger19.info("AIRunner replaced via hot-reload");
+    logger20.info("AIRunner replaced via hot-reload");
   }
   constructor(config, gongfeng, git, aiRunner, tracker, supplementStore, mainGitMutex, eventBusInstance, wsConfig, tenantId, e2eAiRunner) {
     this.config = config;
@@ -4119,14 +4281,14 @@ var PipelineOrchestrator = class {
     this.pipelineDef = mode === "plan-mode" ? buildPlanModePipeline({ releaseEnabled: config.release.enabled, e2eEnabled: config.e2e.enabled }) : getPipelineDef(mode);
     registerPipeline(this.pipelineDef);
     this.lifecycleManager = createLifecycleManager(this.pipelineDef);
-    logger19.info("Pipeline mode resolved", { tenantId: this.tenantId, mode: this.pipelineDef.mode, aiMode: config.ai.mode });
+    logger20.info("Pipeline mode resolved", { tenantId: this.tenantId, mode: this.pipelineDef.mode, aiMode: config.ai.mode });
     this.portAllocator = new PortAllocator({
       backendPortBase: config.e2e.backendPortBase,
       frontendPortBase: config.e2e.frontendPortBase
     });
     this.devServerManager = new DevServerManager();
     this.screenshotPublisher = new ScreenshotPublisher(gongfeng);
-    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path13.join(config.project.worktreeBaseDir, this.tenantId);
+    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path14.join(config.project.worktreeBaseDir, this.tenantId);
     const effectiveWsConfig = wsConfig ?? buildSingleRepoWorkspace(config.project, config.gongfeng.projectPath);
     this.workspaceManager = new WorkspaceManager({
       wsConfig: effectiveWsConfig,
@@ -4135,7 +4297,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger19.info("WorkspaceManager initialized", {
+    logger20.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -4156,7 +4318,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger19.info("Cleaning up stale worktree state...");
+    logger20.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -4165,11 +4327,11 @@ var PipelineOrchestrator = class {
         if (wtDir === repoGitRoot) continue;
         if (!wtDir.includes("/issue-")) continue;
         try {
-          const gitFile = path13.join(wtDir, ".git");
+          const gitFile = path14.join(wtDir, ".git");
           try {
-            await fs12.access(gitFile);
+            await fs13.access(gitFile);
           } catch {
-            logger19.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
+            logger20.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
             await this.mainGit.worktreeRemove(wtDir, true).catch(() => {
             });
             await this.mainGit.worktreePrune();
@@ -4178,37 +4340,49 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger19.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger20.warn("Aborting residual rebase in worktree", { dir: wtDir });
             await wtGit.rebaseAbort();
             cleaned++;
           }
-          const indexLock = path13.join(wtDir, ".git", "index.lock");
+          const indexLock = path14.join(wtDir, ".git", "index.lock");
           try {
-            await fs12.unlink(indexLock);
-            logger19.warn("Removed stale index.lock", { path: indexLock });
+            await fs13.unlink(indexLock);
+            logger20.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger19.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+          logger20.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
         }
       }
     } catch (err) {
-      logger19.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger20.warn("Failed to list worktrees for cleanup", { error: err.message });
     }
-    const mainIndexLock = path13.join(repoGitRoot, ".git", "index.lock");
+    const mainIndexLock = path14.join(repoGitRoot, ".git", "index.lock");
     try {
-      await fs12.unlink(mainIndexLock);
-      logger19.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      await fs13.unlink(mainIndexLock);
+      logger20.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger19.info("Stale state cleanup complete", { cleaned });
+    logger20.info("Stale state cleanup complete", { cleaned });
   }
+  /**
+   * 重启后清理幽灵端口分配。
+   *
+   * DevServerManager 的进程句柄仅存于内存，重启后全部丢失。
+   * 此时 tracker 中残留的 ports 字段指向不可控的孤儿进程，
+   * 必须清理以避免前端误显示 preview 状态。
+   */
   restorePortAllocations() {
     for (const record of this.tracker.getAll()) {
       if (record.ports) {
-        this.portAllocator.restore(getIid(record), record.ports);
+        const iid = getIid(record);
+        logger20.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
+        this.tracker.updateState(iid, record.state, {
+          ports: void 0,
+          previewStartedAt: void 0
+        });
       }
     }
   }
@@ -4249,20 +4423,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger19.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger20.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger19.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger20.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
     }
   }
   async installDependencies(workDir) {
-    logger19.info("Installing dependencies in worktree", { workDir });
+    logger20.info("Installing dependencies in worktree", { workDir });
     const knowledge = getProjectKnowledge() ?? KNOWLEDGE_DEFAULTS;
     const pkgMgr = knowledge.toolchain.packageManager.toLowerCase();
     const isNodeProject = ["npm", "pnpm", "yarn", "bun"].some((m) => pkgMgr.includes(m));
     if (isNodeProject) {
       const ready = await this.ensureNodeModules(workDir);
       if (ready) {
-        logger19.info("node_modules ready \u2014 skipping install");
+        logger20.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -4275,10 +4449,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger19.info("Dependencies installed");
+      logger20.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger19.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger20.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -4288,45 +4462,45 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger19.info("Dependencies installed (fallback)");
+          logger20.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger19.warn("Fallback install also failed", {
+          logger20.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger19.warn("Install failed, no fallback configured", {
+        logger20.warn("Install failed, no fallback configured", {
           error: err.message
         });
       }
     }
   }
   async ensureNodeModules(workDir) {
-    const targetBin = path13.join(workDir, "node_modules", ".bin");
+    const targetBin = path14.join(workDir, "node_modules", ".bin");
     try {
-      await fs12.access(targetBin);
-      logger19.info("node_modules already complete (has .bin/)");
+      await fs13.access(targetBin);
+      logger20.info("node_modules already complete (has .bin/)");
       return true;
     } catch {
     }
-    const sourceNM = path13.join(this.config.project.workDir, "node_modules");
-    const targetNM = path13.join(workDir, "node_modules");
+    const sourceNM = path14.join(this.config.project.workDir, "node_modules");
+    const targetNM = path14.join(workDir, "node_modules");
     try {
-      await fs12.access(sourceNM);
+      await fs13.access(sourceNM);
     } catch {
-      logger19.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger20.warn("Main repo node_modules not found, skipping seed", { sourceNM });
       return false;
     }
-    logger19.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
+    logger20.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
     try {
       await execFileAsync2("rm", ["-rf", targetNM], { timeout: 6e4 });
       await execFileAsync2("cp", ["-a", "--reflink=auto", sourceNM, targetNM], {
         timeout: 12e4
       });
-      logger19.info("node_modules seeded from main repo");
+      logger20.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger19.warn("Failed to seed node_modules from main repo", {
+      logger20.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -4336,14 +4510,14 @@ var PipelineOrchestrator = class {
     const record = this.tracker.get(issueIid);
     if (!record) throw new IssueNotFoundError(issueIid);
     const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
-    logger19.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    logger20.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
     this.aiRunner.killByWorkDir(wtCtx.workDir);
     this.stopPreviewServers(issueIid);
     try {
       const deleted = await this.gongfeng.cleanupAgentNotes(getExternalId(record));
-      logger19.info("Agent notes cleaned up", { issueIid, deleted });
+      logger20.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger19.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger20.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -4357,19 +4531,19 @@ var PipelineOrchestrator = class {
       }
     });
     this.tracker.resetFull(issueIid);
-    logger19.info("Issue restarted", { issueIid });
+    logger20.info("Issue restarted", { issueIid });
   }
   async cancelIssue(issueIid) {
     const record = this.tracker.get(issueIid);
     if (!record) throw new IssueNotFoundError(issueIid);
     const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
-    logger19.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
+    logger20.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
     this.aiRunner.killByWorkDir(wtCtx.workDir);
     this.stopPreviewServers(issueIid);
     try {
       await this.gongfeng.removeLabelsWithPrefix(getExternalId(record), "auto-finish");
     } catch (err) {
-      logger19.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
+      logger20.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -4383,7 +4557,7 @@ var PipelineOrchestrator = class {
       }
     });
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
-    logger19.info("Issue cancelled", { issueIid });
+    logger20.info("Issue cancelled", { issueIid });
   }
   retryFromPhase(issueIid, phase) {
     const record = this.tracker.get(issueIid);
@@ -4393,12 +4567,107 @@ var PipelineOrchestrator = class {
     if (!issueLM.isRetryable(phase)) {
       throw new InvalidPhaseError(phase);
     }
-    logger19.info("Retrying issue from phase", { issueIid, phase });
+    logger20.info("Retrying issue from phase", { issueIid, phase });
     const ok = this.tracker.resetToPhase(issueIid, phase, issueDef);
     if (!ok) {
       throw new InvalidPhaseError(phase);
     }
   }
+  // ── 阶段级中止/继续/重做 ──
+  abortIssue(issueIid) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new IssueNotFoundError(issueIid);
+    const ABORTABLE = /* @__PURE__ */ new Set([
+      "phase_running" /* PhaseRunning */,
+      "phase_done" /* PhaseDone */,
+      "phase_waiting" /* PhaseWaiting */,
+      "phase_approved" /* PhaseApproved */
+    ]);
+    if (!ABORTABLE.has(record.state)) {
+      throw new InvalidStateError(record.state, `Issue #${issueIid} not in abortable state`);
+    }
+    const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
+    if (record.state === "phase_running" /* PhaseRunning */) {
+      this.pendingActions.set(issueIid, "abort");
+      this.aiRunner.killByWorkDir(wtCtx.workDir);
+      this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
+    } else {
+      this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
+    }
+    logger20.info("Issue abort requested", { issueIid, state: record.state });
+  }
+  continueIssue(issueIid) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new IssueNotFoundError(issueIid);
+    if (record.state !== "paused" /* Paused */) {
+      throw new InvalidStateError(record.state, `Issue #${issueIid} not in paused state`);
+    }
+    const issueDef = this.getIssueSpecificPipelineDef(record);
+    this.tracker.resumeFromPause(issueIid, issueDef, false);
+    logger20.info("Issue continued from pause", { issueIid });
+  }
+  redoPhase(issueIid) {
+    const record = this.tracker.get(issueIid);
+    if (!record) throw new IssueNotFoundError(issueIid);
+    const REDOABLE = /* @__PURE__ */ new Set([
+      "paused" /* Paused */,
+      "phase_running" /* PhaseRunning */,
+      "phase_done" /* PhaseDone */,
+      "phase_waiting" /* PhaseWaiting */,
+      "phase_approved" /* PhaseApproved */
+    ]);
+    if (!REDOABLE.has(record.state)) {
+      throw new InvalidStateError(record.state, `Issue #${issueIid} not in redoable state`);
+    }
+    const issueDef = this.getIssueSpecificPipelineDef(record);
+    const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
+    if (record.state === "phase_running" /* PhaseRunning */) {
+      this.pendingActions.set(issueIid, "redo");
+      this.aiRunner.killByWorkDir(wtCtx.workDir);
+      this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
+    } else if (record.state === "paused" /* Paused */) {
+      const phase = record.pausedAtPhase;
+      if (phase) {
+        const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
+        wtPlan.updatePhaseProgress(phase, "pending");
+      }
+      this.tracker.resumeFromPause(issueIid, issueDef, true);
+      this.eventBus.emitTyped("issue:redone", { issueIid });
+    } else {
+      const phase = record.currentPhase;
+      if (phase) {
+        const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
+        wtPlan.updatePhaseProgress(phase, "pending");
+        this.tracker.resetToPhase(issueIid, phase, issueDef);
+      }
+      this.eventBus.emitTyped("issue:redone", { issueIid });
+    }
+    logger20.info("Issue redo requested", { issueIid, state: record.state });
+  }
+  /**
+   * 处理中止/重做的共享逻辑：
+   * - abort: 暂停 Issue（保留 session）
+   * - redo: 重置阶段（清除 session）
+   *
+   * 由 catch 块的两条路径（PhaseAbortedError / pendingActions）共用。
+   */
+  applyPendingAction(action, issueIid, wtCtx, pipelineDef) {
+    const rec = this.tracker.get(issueIid);
+    if (rec?.state === "failed" /* Failed */ && rec.attempts > 0) {
+      rec.attempts -= 1;
+    }
+    if (action === "abort") {
+      this.tracker.pauseIssue(issueIid, rec?.currentPhase ?? "");
+    } else {
+      const phase = rec?.currentPhase;
+      if (phase) {
+        const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
+        wtPlan.updatePhaseProgress(phase, "pending");
+        this.tracker.resetToPhase(issueIid, phase, pipelineDef);
+      }
+      this.eventBus.emitTyped("issue:redone", { issueIid });
+    }
+  }
   getIssueSpecificPipelineDef(record) {
     if (record.pipelineMode) {
       return getPipelineDef(record.pipelineMode);
@@ -4435,13 +4704,19 @@ var PipelineOrchestrator = class {
       stopPreviewServers: (iid) => this.stopPreviewServers(iid),
       tryCreateMergeRequest: (issue, branch, workDir, previewUrl) => this.tryCreateMergeRequest(issue, branch, workDir, previewUrl),
       buildPreviewUrl: (iid) => this.buildPreviewUrl(iid),
-      getPortsForIssue: (iid) => this.portAllocator.getPortsForIssue(iid)
+      getPortsForIssue: (iid) => this.portAllocator.getPortsForIssue(iid),
+      isPreviewRunning: (iid) => this.devServerManager.getStatus(iid).running,
+      consumePendingAction: (iid) => {
+        const action = this.pendingActions.get(iid);
+        if (action) this.pendingActions.delete(iid);
+        return action;
+      }
     };
   }
   async _processIssueImpl(issue) {
     const branchName = `${this.config.project.branchPrefix}-${issue.iid}`;
     const wtCtx = this.computeWorktreeContext(issue.iid, branchName);
-    logger19.info("Processing issue", {
+    logger20.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -4508,6 +4783,16 @@ var PipelineOrchestrator = class {
       if (phaseResult.paused) return;
       await executeCompletion(ctx, deps, phaseResult, wtGitMap);
     } catch (err) {
+      if (err instanceof PhaseAbortedError) {
+        this.applyPendingAction(err.action, issue.iid, wtCtx, issuePipelineDef);
+        return;
+      }
+      const pendingAction = this.pendingActions.get(issue.iid);
+      if (pendingAction) {
+        this.pendingActions.delete(issue.iid);
+        this.applyPendingAction(pendingAction, issue.iid, wtCtx, issuePipelineDef);
+        return;
+      }
       await handleFailure(err, issue, wtCtx, deps);
     }
   }
@@ -4536,7 +4821,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger19.info("Merge request created successfully", {
+      logger20.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -4544,7 +4829,7 @@ var PipelineOrchestrator = class {
       return { url: mr.web_url, iid: mr.iid };
     } catch (err) {
       const errorMsg = err.message;
-      logger19.warn("Failed to create merge request, trying to find existing one", {
+      logger20.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -4561,7 +4846,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger19.info("Found existing merge request", {
+        logger20.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -4569,7 +4854,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger19.warn("Failed to find existing merge request", {
+      logger20.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -4603,6 +4888,11 @@ var PipelineOrchestrator = class {
         } catch {
         }
       },
+      onAsyncGateApproval: async (phase) => {
+        this.tracker.updateState(iid, "phase_approved" /* PhaseApproved */, { currentPhase: phase });
+        this.eventBus.emitTyped("uat:completed", { issueIid: iid });
+        logger20.info("Async gate approved via process callback", { iid, phase });
+      },
       isNoteSyncEnabled: () => isNoteSyncEnabledForIssue(iid, this.tracker, this.config),
       isE2eEnabled: () => isE2eEnabledForIssue(iid, this.tracker, this.config)
     };
@@ -4635,7 +4925,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger19.error("Failed to start preview servers", {
+      logger20.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -4670,7 +4960,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
     });
-    logger19.info("Preview stopped and worktree cleaned", { iid: issueIid });
+    logger20.info("Preview stopped and worktree cleaned", { iid: issueIid });
   }
   async markDeployed(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -4687,7 +4977,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.closeIssue(externalId);
     } catch (err) {
-      logger19.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
+      logger20.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
     }
     try {
       const issue = await this.gongfeng.getIssueDetail(externalId);
@@ -4695,10 +4985,10 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       labels.push("auto-finish:deployed");
       await this.gongfeng.updateIssueLabels(externalId, labels);
     } catch (err) {
-      logger19.warn("Failed to update labels", { iid: issueIid, error: err.message });
+      logger20.warn("Failed to update labels", { iid: issueIid, error: err.message });
     }
     this.tracker.updateState(issueIid, "deployed" /* Deployed */);
-    logger19.info("Issue marked as deployed", { iid: issueIid });
+    logger20.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -4725,7 +5015,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       throw err;
     }
     const url = this.buildPreviewUrl(issueIid);
-    logger19.info("Preview restarted", { iid: issueIid, url });
+    logger20.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -4758,7 +5048,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     if (!record) throw new IssueNotFoundError(issueIid);
     const baseBranch = this.config.project.baseBranch;
     const branchName = record.branchName;
-    logger19.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
+    logger20.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
     this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
     this.eventBus.emitTyped("conflict:started", { issueIid });
     try {
@@ -4791,7 +5081,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger19.info("Running verification after conflict resolution", { issueIid });
+      logger20.info("Running verification after conflict resolution", { issueIid });
       const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
       wtPlan.ensureDir();
       const conflictLM = createLifecycleManager(this.getIssueSpecificPipelineDef(record));
@@ -4824,10 +5114,10 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       } catch {
       }
       await this.commentOnMr(record.mrUrl, t("conflict.mrResolvedComment"));
-      logger19.info("Conflict resolution completed", { issueIid });
+      logger20.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger19.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      logger20.error("Conflict resolution failed", { issueIid, error: errorMsg });
       try {
         const wtGit = new GitOperations(wtCtx.gitRootDir);
         if (await wtGit.isRebaseInProgress()) {
@@ -4857,7 +5147,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, body);
     } catch (err) {
-      logger19.warn("Failed to comment on MR", { mrIid, error: err.message });
+      logger20.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -4933,7 +5223,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger20 = logger.child("Brainstorm");
+var logger21 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -4969,7 +5259,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger20.info("Created brainstorm session", { sessionId: session.id });
+    logger21.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -4978,7 +5268,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger20.info("Generating SDD", { sessionId });
+    logger21.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5004,7 +5294,7 @@ var BrainstormService = class {
     const session = this.requireSession(sessionId);
     const roundNum = session.rounds.length + 1;
     session.status = "reviewing";
-    logger20.info("Reviewing SDD", { sessionId, round: roundNum });
+    logger21.info("Reviewing SDD", { sessionId, round: roundNum });
     onEvent?.({ type: "round:start", data: { round: roundNum, phase: "review" }, round: roundNum });
     const prompt = buildReviewPrompt(session.currentSdd, roundNum);
     const result = await this.reviewerRunner.run({
@@ -5037,7 +5327,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger20.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger21.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5122,4 +5412,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-7YCDMVIF.js.map
+//# sourceMappingURL=chunk-5UPYA6KH.js.map