@xdevops/issue-auto-finish 1.0.85 → 1.0.87

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

@@ -17,22 +17,27 @@ import {
   planPrompt,
   rePlanPrompt,
   verifyPrompt
-} from "./chunk-P4O4ZXEC.js";
+} from "./chunk-2YQHKXLL.js";
 import {
   getProjectKnowledge
 } from "./chunk-ACVOOHAR.js";
+import {
+  KNOWLEDGE_DEFAULTS
+} from "./chunk-B7TVVODN.js";
 import {
   t
 } from "./chunk-YCYVNRLF.js";
 import {
   getLocalIP
 } from "./chunk-AKXDQH25.js";
-import {
-  KNOWLEDGE_DEFAULTS
-} from "./chunk-B7TVVODN.js";
 import {
   resolveDataDir
 } from "./chunk-TN2SYADO.js";
+import {
+  createAIRunner,
+  getRunnerCapabilities,
+  isShuttingDown
+} from "./chunk-SAMTXC4A.js";
 import {
   AIExecutionError,
   GongfengApiError,
@@ -45,11 +50,8 @@ import {
   PipelineNotFoundError,
   PortExhaustionError,
   ServiceShutdownError,
-  UnregisteredPhasesError,
-  createAIRunner,
-  getRunnerCapabilities,
-  isShuttingDown
-} from "./chunk-4LFNFRCL.js";
+  UnregisteredPhasesError
+} from "./chunk-AVGZH64A.js";
 import {
   logger,
   runWithIssueContext
@@ -228,8 +230,8 @@ var GongfengClient = class {
     const encoded = encodeURIComponent(this.projectPath);
     return `${this.apiUrl}/api/v3/projects/${encoded}`;
   }
-  async requestRaw(path15, options = {}) {
-    const url = `${this.projectApiBase}${path15}`;
+  async requestRaw(path12, options = {}) {
+    const url = `${this.projectApiBase}${path12}`;
     logger4.debug("API request", { method: options.method || "GET", url });
     return this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -246,11 +248,11 @@ var GongfengClient = class {
           throw new GongfengApiError(resp.status, `Gongfeng API error ${resp.status}: ${body}`, body);
         }
         return resp;
-      }, `requestRaw ${options.method || "GET"} ${path15}`)
+      }, `requestRaw ${options.method || "GET"} ${path12}`)
     );
   }
-  async request(path15, options = {}) {
-    const resp = await this.requestRaw(path15, options);
+  async request(path12, options = {}) {
+    const resp = await this.requestRaw(path12, options);
     return resp.json();
   }
   async createIssue(title, description, labels) {
@@ -429,8 +431,8 @@ var GongfengClient = class {
     }
     return mr;
   }
-  async requestGlobal(path15, options = {}) {
-    const url = `${this.apiUrl}${path15}`;
+  async requestGlobal(path12, options = {}) {
+    const url = `${this.apiUrl}${path12}`;
     logger4.debug("API request (global)", { method: options.method || "GET", url });
     const resp = await this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -447,7 +449,7 @@ var GongfengClient = class {
           throw new GongfengApiError(r.status, `Gongfeng API error ${r.status}: ${body}`, body);
         }
         return r;
-      }, `requestGlobal ${options.method || "GET"} ${path15}`)
+      }, `requestGlobal ${options.method || "GET"} ${path12}`)
     );
     return resp.json();
   }
@@ -934,7 +936,7 @@ var STATE_MIGRATION_MAP = {
   waiting_for_review: { state: "phase_waiting", currentPhase: "review" },
   review_approved: { state: "phase_approved", currentPhase: "review" }
 };
-var IssueTracker = class extends BaseTracker {
+var IssueTracker = class _IssueTracker extends BaseTracker {
   lifecycleManagers;
   tenantId;
   constructor(dataDir, lifecycleManagers, tenantId) {
@@ -1044,6 +1046,29 @@ var IssueTracker = class extends BaseTracker {
     logger5.info("Issue state updated", { issueIid, state });
     eventBus.emitTyped("issue:stateChanged", { issueIid, state, record });
   }
+  /** 初始化阶段进度（流水线启动时调用） */
+  initPhaseProgress(issueIid, def) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record) return;
+    const phases = {};
+    for (const spec of def.phases) {
+      phases[spec.name] = { status: "pending" };
+    }
+    record.phaseProgress = phases;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+  }
+  /** 更新单个阶段的进度（原子保存 + SSE 推送） */
+  updatePhaseProgress(issueIid, phase, update) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record?.phaseProgress) return;
+    const pp = record.phaseProgress[phase];
+    if (!pp) return;
+    Object.assign(pp, update);
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    eventBus.emitTyped("issue:stateChanged", { issueIid, state: record.state, record });
+  }
   markFailed(issueIid, error, failedAtState, isRetryable) {
     const record = this.collection[this.key(issueIid)];
     if (!record) return;
@@ -1064,6 +1089,7 @@ var IssueTracker = class extends BaseTracker {
     record.pausedAtPhase = currentPhase;
     record.failedAtState = void 0;
     record.lastError = void 0;
+    record.processingLock = void 0;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
     logger5.info("Issue paused", { issueIid, pausedAtPhase: currentPhase });
@@ -1092,6 +1118,65 @@ var IssueTracker = class extends BaseTracker {
     eventBus.emitTyped(eventType, { issueIid, phase, record });
     return true;
   }
+  // ── processingLock 管理 ──
+  /** 持久化锁超时阈值（默认 30 分钟，与 PHASE_TIMEOUT 一致） */
+  static LOCK_TIMEOUT_MS = 30 * 60 * 1e3;
+  /**
+   * 获取持久化处理锁。
+   * - 无锁或超时锁 → 写入并返回 true
+   * - 有未超时锁（其他 correlationId）→ 返回 false
+   */
+  acquireProcessingLock(issueIid, correlationId) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record) return false;
+    const existing = record.processingLock;
+    if (existing) {
+      const age = Date.now() - new Date(existing.ts).getTime();
+      if (age < _IssueTracker.LOCK_TIMEOUT_MS) {
+        logger5.warn("Processing lock held, rejecting acquire", {
+          issueIid,
+          existingCorrelationId: existing.correlationId,
+          ageMs: age
+        });
+        return false;
+      }
+      logger5.warn("Processing lock timed out, forcibly acquiring", {
+        issueIid,
+        staleCorrelationId: existing.correlationId,
+        ageMs: age
+      });
+    }
+    record.processingLock = { correlationId, ts: (/* @__PURE__ */ new Date()).toISOString() };
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    return true;
+  }
+  /**
+   * 释放持久化处理锁。仅当 correlationId 匹配时才清除，防止旧协程误释放新锁。
+   */
+  releaseProcessingLock(issueIid, correlationId) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record?.processingLock) return;
+    if (record.processingLock.correlationId !== correlationId) {
+      logger5.warn("Processing lock correlationId mismatch, skipping release", {
+        issueIid,
+        ownCorrelationId: correlationId,
+        actualCorrelationId: record.processingLock.correlationId
+      });
+      return;
+    }
+    record.processingLock = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+  }
+  /** 强制清除持久化处理锁（管理员操作：restart/cancel/retryFromPhase） */
+  clearProcessingLock(issueIid) {
+    const record = this.collection[this.key(issueIid)];
+    if (!record?.processingLock) return;
+    record.processingLock = void 0;
+    record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+  }
   isProcessing(issueIid) {
     const record = this.get(issueIid);
     if (!record) return false;
@@ -1121,9 +1206,15 @@ var IssueTracker = class extends BaseTracker {
   getDrivableIssues(maxRetries, stalledThresholdMs) {
     return this.getAllRecords().filter((record) => {
       const lm = this.lifecycleFor(record);
-      if (lm.isDrivable(record.state, record.attempts, maxRetries, record.lastErrorRetryable)) return true;
-      if (this.isStalled(getIid(record), stalledThresholdMs)) return true;
-      return false;
+      const drivable = lm.isDrivable(record.state, record.attempts, maxRetries, record.lastErrorRetryable) || this.isStalled(getIid(record), stalledThresholdMs);
+      if (!drivable) return false;
+      if (record.processingLock) {
+        const age = Date.now() - new Date(record.processingLock.ts).getTime();
+        if (age < _IssueTracker.LOCK_TIMEOUT_MS) {
+          return false;
+        }
+      }
+      return true;
     });
   }
   getAllActive() {
@@ -1152,6 +1243,8 @@ var IssueTracker = class extends BaseTracker {
     record.attempts = 0;
     record.failedAtState = void 0;
     record.lastError = void 0;
+    record.phaseProgress = void 0;
+    record.processingLock = void 0;
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
     logger5.info("Issue fully reset", { issueIid });
@@ -1174,6 +1267,21 @@ var IssueTracker = class extends BaseTracker {
     }
     record.failedAtState = void 0;
     record.lastError = void 0;
+    record.processingLock = void 0;
+    if (record.phaseProgress) {
+      const phaseIdx = def.phases.findIndex((p) => p.name === phase);
+      if (phaseIdx >= 0) {
+        for (let i = phaseIdx; i < def.phases.length; i++) {
+          const pp = record.phaseProgress[def.phases[i].name];
+          if (pp) {
+            pp.status = "pending";
+            pp.startedAt = void 0;
+            pp.completedAt = void 0;
+            pp.error = void 0;
+          }
+        }
+      }
+    }
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
     logger5.info("Issue reset to phase", { issueIid, phase, state: targetState });
@@ -1186,6 +1294,16 @@ var IssueTracker = class extends BaseTracker {
     const restoreState = record.failedAtState ?? "pending" /* Pending */;
     record.state = restoreState;
     record.lastError = void 0;
+    record.processingLock = void 0;
+    if (record.phaseProgress && record.currentPhase) {
+      const pp = record.phaseProgress[record.currentPhase];
+      if (pp && pp.status === "failed") {
+        pp.status = "pending";
+        pp.startedAt = void 0;
+        pp.completedAt = void 0;
+        pp.error = void 0;
+      }
+    }
     record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.save();
     logger5.info("Issue reset for retry", { issueIid, restoreState });
@@ -1217,6 +1335,7 @@ var IssueTracker = class extends BaseTracker {
         record.lastError = "Interrupted by service restart";
         record.lastErrorRetryable = false;
         record.attempts += 1;
+        record.processingLock = void 0;
         record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         count++;
         eventBus.emitTyped("issue:failed", {
@@ -1233,6 +1352,7 @@ var IssueTracker = class extends BaseTracker {
           attempts: record.attempts
         });
         record.lastErrorRetryable = false;
+        record.processingLock = void 0;
         record.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         count++;
       }
@@ -1408,7 +1528,14 @@ var PlanPersistence = class _PlanPersistence {
   }
   updatePhaseProgress(phaseName, status, error, options) {
     const progress = this.readProgress();
-    if (!progress) return;
+    if (!progress) {
+      logger6.warn("Cannot update phase progress: progress.json not found", {
+        issueIid: this.issueIid,
+        phase: phaseName,
+        targetStatus: status
+      });
+      return;
+    }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (!progress.phases[phaseName]) {
       progress.phases[phaseName] = { status: "pending" };
@@ -1438,10 +1565,37 @@ var PlanPersistence = class _PlanPersistence {
     const progress = this.readProgress();
     return progress?.phases[phaseName]?.sessionId;
   }
+  // ---------------------------------------------------------------------------
+  // 通用文件操作 — 替代阶段中散落的 fs 直接调用
+  // ---------------------------------------------------------------------------
+  /** 读取 planDir 下指定文件，不存在返回 null */
+  readFile(filename) {
+    const filePath = path2.join(this.planDir, filename);
+    if (!fs2.existsSync(filePath)) return null;
+    try {
+      return fs2.readFileSync(filePath, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  /** 检查 planDir 下指定文件是否就绪（存在 + 大于 minBytes） */
+  isArtifactReady(filename, minBytes = 50) {
+    const filePath = path2.join(this.planDir, filename);
+    if (!fs2.existsSync(filePath)) return false;
+    try {
+      return fs2.statSync(filePath).size >= minBytes;
+    } catch {
+      return false;
+    }
+  }
+  /** 写入 planDir 下指定文件（自动 ensureDir） */
+  writeFile(filename, content) {
+    this.ensureDir();
+    fs2.writeFileSync(path2.join(this.planDir, filename), content, "utf-8");
+  }
 };
 
 // src/phases/BasePhase.ts
-import fs3 from "fs";
 import path4 from "path";
 
 // src/rules/RuleResolver.ts
@@ -1539,50 +1693,6 @@ ${rule.content}`;
   }
 };
 
-// src/notesync/NoteSyncSettings.ts
-var noteSyncOverride;
-function getNoteSyncEnabled(cfg) {
-  return noteSyncOverride ?? cfg.issueNoteSync.enabled;
-}
-function setNoteSyncOverride(value) {
-  noteSyncOverride = value;
-}
-function isNoteSyncEnabledForIssue(issueIid, tracker, cfg) {
-  const record = tracker.get(issueIid);
-  if (record?.issueNoteSyncEnabled !== void 0) return record.issueNoteSyncEnabled;
-  return getNoteSyncEnabled(cfg);
-}
-var SUMMARY_MAX_LENGTH = 500;
-function truncateToSummary(content) {
-  if (content.length <= SUMMARY_MAX_LENGTH) return content;
-  const cut = content.slice(0, SUMMARY_MAX_LENGTH);
-  const lastNewline = cut.lastIndexOf("\n\n");
-  const boundary = lastNewline > SUMMARY_MAX_LENGTH * 0.3 ? lastNewline : cut.lastIndexOf("\n");
-  const summary = boundary > SUMMARY_MAX_LENGTH * 0.3 ? cut.slice(0, boundary) : cut;
-  return summary + "\n\n...";
-}
-function buildNoteSyncComment(phaseName, phaseLabel, docUrl, dashboardUrl, summary) {
-  const emoji = {
-    analysis: "\u{1F50D}",
-    design: "\u{1F4D0}",
-    implement: "\u{1F4BB}",
-    verify: "\u2705",
-    plan: "\u{1F4CB}",
-    review: "\u{1F440}",
-    build: "\u{1F528}"
-  };
-  const icon = emoji[phaseName] || "\u{1F4CB}";
-  return [
-    t("notesync.phaseCompleted", { icon, label: phaseLabel }),
-    "",
-    summary,
-    "",
-    "---",
-    t("notesync.viewDoc", { label: phaseLabel, url: docUrl }),
-    t("notesync.viewDashboard", { url: dashboardUrl })
-  ].join("\n");
-}
-
 // src/phases/BasePhase.ts
 var BasePhase = class _BasePhase {
   static MIN_ARTIFACT_BYTES = 50;
@@ -1591,27 +1701,13 @@ var BasePhase = class _BasePhase {
   plan;
   config;
   logger;
-  lifecycle;
-  hooks;
   /** 多仓模式下所有 repo 的 GitOperations（repo name → GitOperations） */
   wtGitMap;
-  get startState() {
-    const states = this.lifecycle.getPhaseStates(this.phaseName);
-    if (!states) throw new Error(`Phase "${this.phaseName}" not found in lifecycle manager`);
-    return states.startState;
-  }
-  get doneState() {
-    const states = this.lifecycle.getPhaseStates(this.phaseName);
-    if (!states) throw new Error(`Phase "${this.phaseName}" not found in lifecycle manager`);
-    return states.doneState;
-  }
-  constructor(aiRunner, git, plan, config, lifecycle, hooks) {
+  constructor(aiRunner, git, plan, config) {
     this.aiRunner = aiRunner;
     this.git = git;
     this.plan = plan;
     this.config = config;
-    this.lifecycle = lifecycle;
-    this.hooks = hooks;
     this.logger = logger.child(this.constructor.name);
   }
   /** 注入多仓库 GitOperations map（由编排器在创建 phase 后调用） */
@@ -1621,40 +1717,29 @@ var BasePhase = class _BasePhase {
   getRunMode() {
     return void 0;
   }
+  /** 获取阶段预期的产物文件列表。编排器需通过此方法同步产物到 Issue。 */
   getResultFiles(_ctx) {
     return [];
   }
-  async execute(ctx) {
+  /**
+   * 纯逻辑执行 — 零副作用，返回 PhaseOutcome。
+   *
+   * 阶段内部仅做：构建 prompt → AI 执行 → 验证产物 → 返回结果。
+   * 所有副作用（状态转换、Git commit、Issue 评论、事件推送）由编排器统一处理。
+   */
+  async run(ctx, callbacks) {
     const displayId = Number(ctx.demand.sourceRef.displayId);
-    this.logger.info(`Phase ${this.phaseName} starting`, { issueIid: displayId });
-    const resumeInfo = this.resolveResumeInfo();
-    await this.notifyPhaseStart();
-    this.plan.updatePhaseProgress(this.phaseName, "in_progress", void 0, {
-      preserveSessionId: resumeInfo.resumable
-    });
-    await this.notifyComment(
-      issueProgressComment(this.phaseName, "in_progress")
-    );
-    const phaseLabel = t(`phase.${this.phaseName}`) || this.phaseName;
-    const systemMessage = resumeInfo.resumable ? t("basePhase.aiResuming", { label: phaseLabel }) : t("basePhase.aiStarting", { label: phaseLabel });
-    eventBus.emitTyped("agent:output", {
-      issueIid: displayId,
-      phase: this.phaseName,
-      event: { type: "system", content: systemMessage, timestamp: (/* @__PURE__ */ new Date()).toISOString() }
-    });
-    let basePrompt = this.buildPrompt(ctx);
+    const expectedResultFiles = this.getResultFiles(ctx);
+    let prompt = this.buildPrompt(ctx);
     const wsSection = buildWorkspaceSection(ctx.workspace);
-    if (wsSection) {
-      basePrompt = `${basePrompt}
+    if (wsSection) prompt += `
 
 ${wsSection}`;
-    }
-    const matchedRulesText = await this.resolveRules(ctx);
-    const fullPrompt = matchedRulesText ? `${basePrompt}
+    const rules = await this.resolveRules(ctx);
+    if (rules) prompt += `
 
-${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
-    const resumePrompt = t("basePhase.resumePrompt");
-    const onInputRequired = this.buildInputRequiredHandler(displayId);
+${t("basePhase.rulesSection", { rules })}`;
+    const resumeInfo = this.resolveResumeInfo();
     let result;
     if (resumeInfo.resumable) {
       this.logger.info("Attempting session resume", {
@@ -1665,37 +1750,53 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
       result = await this.runWithResumeFallback(
         displayId,
         resumeInfo.sessionId,
-        resumePrompt,
-        fullPrompt,
-        onInputRequired,
-        ctx
+        t("basePhase.resumePrompt"),
+        prompt,
+        callbacks?.onInputRequired,
+        ctx,
+        callbacks?.onStreamEvent
       );
     } else {
-      result = await this.runAI(displayId, fullPrompt, onInputRequired, void 0, ctx);
+      result = await this.runAI(
+        displayId,
+        prompt,
+        callbacks?.onInputRequired,
+        void 0,
+        ctx,
+        callbacks?.onStreamEvent
+      );
     }
     if (!result.success) {
       this.persistSessionId(result.sessionId);
-      const failReason = (result.errorMessage || result.output).slice(0, 500);
-      const shortReason = (result.errorMessage || result.output).slice(0, 200);
-      this.plan.updatePhaseProgress(this.phaseName, "failed", failReason);
-      await this.notifyPhaseFailed(failReason);
-      await this.notifyComment(
-        issueProgressComment(this.phaseName, "failed", t("basePhase.error", { message: shortReason }))
-      );
-      throw new AIExecutionError(this.phaseName, `Phase ${this.phaseName} failed: ${shortReason}`, {
+      return {
+        status: "failed",
         output: result.output,
+        sessionId: result.sessionId,
         exitCode: result.exitCode,
-        isRetryable: this.classifyRetryable(result)
-      });
+        error: {
+          message: (result.errorMessage || result.output).slice(0, 500),
+          isRetryable: this.classifyRetryable(result),
+          rawOutput: result.output
+        }
+      };
     }
     this.persistSessionId(result.sessionId);
-    await this.validatePhaseOutput(ctx, displayId);
-    await this.notifyPhaseDone();
-    this.plan.updatePhaseProgress(this.phaseName, "completed");
-    await this.commitPlanFiles(ctx, displayId);
-    await this.syncResultToIssue(ctx, displayId);
-    this.logger.info(`Phase ${this.phaseName} completed`, { issueIid: displayId });
-    return result;
+    try {
+      await this.validatePhaseOutput(ctx, displayId, expectedResultFiles);
+    } catch (err) {
+      return {
+        status: "failed",
+        output: result.output,
+        sessionId: result.sessionId,
+        error: { message: err.message, isRetryable: false, rawOutput: result.output }
+      };
+    }
+    return {
+      status: "completed",
+      output: result.output,
+      sessionId: result.sessionId,
+      exitCode: result.exitCode
+    };
   }
   // ── Session resume helpers ──
   resolveResumeInfo() {
@@ -1722,7 +1823,20 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
     }
     return this.plan.baseDir;
   }
-  async runAI(displayId, prompt, onInputRequired, options, ctx) {
+  /** 检查预期产物文件是否已就绪（存在且满足最小字节数），不抛异常 */
+  checkArtifactsReady(ctx, _displayId) {
+    const resultFiles = this.getResultFiles(ctx);
+    if (resultFiles.length === 0) return true;
+    for (const file of resultFiles) {
+      if (!this.plan.isArtifactReady(file.filename, _BasePhase.MIN_ARTIFACT_BYTES)) return false;
+    }
+    return true;
+  }
+  async runAI(displayId, prompt, onInputRequired, options, ctx, onStreamEvent) {
+    const resultFiles = this.getResultFiles(ctx);
+    const snapshotFilenames = resultFiles.map((f) => f.filename);
+    const artifactCheck = snapshotFilenames.length > 0 ? () => snapshotFilenames.every((fn) => this.plan.isArtifactReady(fn, _BasePhase.MIN_ARTIFACT_BYTES)) : void 0;
+    const artifactPaths = snapshotFilenames.length > 0 ? snapshotFilenames.map((fn) => path4.join(this.plan.planDir, fn)) : void 0;
     let capturedSessionId;
     const result = await this.aiRunner.run({
       prompt,
@@ -1730,6 +1844,9 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
       timeoutMs: this.config.ai.phaseTimeoutMs,
       idleTimeoutMs: this.config.ai.idleTimeoutMs,
       mode: this.getRunMode(),
+      phaseName: this.phaseName,
+      artifactCheck,
+      artifactPaths,
       sessionId: options?.sessionId,
       continueSession: options?.continueSession,
       onStreamEvent: (event) => {
@@ -1740,11 +1857,7 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
             this.persistSessionId(capturedSessionId);
           }
         }
-        eventBus.emitTyped("agent:output", {
-          issueIid: displayId,
-          phase: this.phaseName,
-          event
-        });
+        onStreamEvent?.(event);
       },
       onInputRequired
     });
@@ -1753,27 +1866,23 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
     }
     return result;
   }
-  async runWithResumeFallback(displayId, sessionId, resumePrompt, fullPrompt, onInputRequired, ctx) {
+  async runWithResumeFallback(displayId, sessionId, resumePrompt, fullPrompt, onInputRequired, ctx, onStreamEvent) {
     const result = await this.runAI(displayId, resumePrompt, onInputRequired, {
       sessionId,
       continueSession: true
-    }, ctx);
+    }, ctx, onStreamEvent);
     if (!result.success && this.isResumeFailure(result)) {
       this.logger.warn(t("basePhase.resumeFallback"), {
         issueIid: displayId,
         phase: this.phaseName,
         exitCode: result.exitCode
       });
-      eventBus.emitTyped("agent:output", {
-        issueIid: displayId,
-        phase: this.phaseName,
-        event: {
-          type: "system",
-          content: t("basePhase.resumeFallback"),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }
+      onStreamEvent?.({
+        type: "system",
+        content: t("basePhase.resumeFallback"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      return this.runAI(displayId, fullPrompt, onInputRequired, void 0, ctx);
+      return this.runAI(displayId, fullPrompt, onInputRequired, void 0, ctx, onStreamEvent);
     }
     return result;
   }
@@ -1814,63 +1923,6 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
       this.plan.updatePhaseSessionId(this.phaseName, sessionId);
     }
   }
-  // ── Hook dispatch methods ──
-  async notifyPhaseStart() {
-    await this.hooks.onPhaseStart(this.phaseName);
-  }
-  async notifyPhaseDone() {
-    await this.hooks.onPhaseDone(this.phaseName);
-  }
-  async notifyPhaseFailed(error) {
-    await this.hooks.onPhaseFailed(this.phaseName, error);
-  }
-  async notifyComment(message) {
-    try {
-      await this.hooks.onComment(message);
-    } catch (err) {
-      this.logger.warn("Hook onComment failed", { error: err.message });
-    }
-  }
-  /**
-   * Build an onInputRequired handler for ACP permission delegation.
-   * Only returns a handler when codebuddyAcpAutoApprove is false,
-   * enabling review gate delegation for permission requests.
-   */
-  buildInputRequiredHandler(displayId) {
-    if (this.config.ai.codebuddyAcpAutoApprove !== false) return void 0;
-    return (request) => {
-      if (request.type !== "plan-approval") {
-        return Promise.resolve("allow");
-      }
-      this.logger.info("ACP plan-approval requested, delegating to review gate", {
-        issueIid: displayId,
-        phase: this.phaseName
-      });
-      eventBus.emitTyped("review:requested", { issueIid: displayId });
-      return new Promise((resolve) => {
-        const onApproved = (payload) => {
-          const data = payload.data;
-          if (data.issueIid !== displayId) return;
-          cleanup();
-          this.logger.info("ACP plan-approval approved via review gate", { issueIid: displayId });
-          resolve("allow");
-        };
-        const onRejected = (payload) => {
-          const data = payload.data;
-          if (data.issueIid !== displayId) return;
-          cleanup();
-          this.logger.info("ACP plan-approval rejected via review gate", { issueIid: displayId });
-          resolve("reject");
-        };
-        const cleanup = () => {
-          eventBus.removeListener("review:approved", onApproved);
-          eventBus.removeListener("review:rejected", onRejected);
-        };
-        eventBus.on("review:approved", onApproved);
-        eventBus.on("review:rejected", onRejected);
-      });
-    };
-  }
   async resolveRules(ctx) {
     try {
       const knowledge = getProjectKnowledge();
@@ -1900,107 +1952,27 @@ ${t("basePhase.rulesSection", { rules: matchedRulesText })}` : basePrompt;
     }
     return null;
   }
-  async syncResultToIssue(ctx, displayId) {
-    try {
-      const enabled = this.hooks.isNoteSyncEnabled();
-      const resultFiles = this.getResultFiles(ctx);
-      if (!enabled || resultFiles.length === 0) {
-        await this.notifyComment(
-          issueProgressComment(this.phaseName, "completed")
-        );
-        return;
-      }
-      const baseUrl = this.config.issueNoteSync.webBaseUrl.replace(/\/$/, "");
-      const phaseLabel = t(`phase.${this.phaseName}`) || this.phaseName;
-      const dashboardUrl = `${baseUrl}/?issue=${displayId}`;
-      for (const file of resultFiles) {
-        const content = this.readResultFile(displayId, file.filename);
-        if (!content) continue;
-        const summary = truncateToSummary(content);
-        const docUrl = `${baseUrl}/doc/${displayId}/${file.filename}`;
-        const comment = buildNoteSyncComment(
-          this.phaseName,
-          file.label || phaseLabel,
-          docUrl,
-          dashboardUrl,
-          summary
-        );
-        await this.notifyComment(comment);
-        this.logger.info("Result synced to issue", { issueIid: displayId, file: file.filename });
-      }
-    } catch (err) {
-      this.logger.warn("Failed to sync result to issue", { error: err.message });
-      await this.notifyComment(
-        issueProgressComment(this.phaseName, "completed")
-      );
-    }
-  }
-  readResultFile(issueIid, filename) {
-    const planDir = path4.join(this.plan.baseDir, ".claude-plan", `issue-${issueIid}`);
-    const filePath = path4.join(planDir, filename);
-    if (!fs3.existsSync(filePath)) return null;
-    try {
-      return fs3.readFileSync(filePath, "utf-8");
-    } catch {
-      return null;
-    }
-  }
-  async validatePhaseOutput(ctx, displayId) {
-    const resultFiles = this.getResultFiles(ctx);
+  async validatePhaseOutput(ctx, _displayId, resultFiles = this.getResultFiles(ctx)) {
     if (resultFiles.length === 0) return;
-    const planDir = path4.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`);
     const missing = [];
     for (const file of resultFiles) {
-      const filePath = path4.join(planDir, file.filename);
-      if (!fs3.existsSync(filePath)) {
-        missing.push(file.filename);
-        continue;
-      }
-      const stat = fs3.statSync(filePath);
-      if (stat.size < _BasePhase.MIN_ARTIFACT_BYTES) {
-        missing.push(`${file.filename} (${stat.size} bytes, \u5185\u5BB9\u4E0D\u8DB3)`);
+      if (!this.plan.isArtifactReady(file.filename, _BasePhase.MIN_ARTIFACT_BYTES)) {
+        const content = this.plan.readFile(file.filename);
+        if (content === null) {
+          missing.push(file.filename);
+        } else {
+          missing.push(`${file.filename} (${Buffer.byteLength(content, "utf-8")} bytes, \u5185\u5BB9\u4E0D\u8DB3)`);
+        }
       }
     }
     if (missing.length > 0) {
       const msg = `AI \u8FDB\u7A0B\u6210\u529F\u9000\u51FA\u4F46\u672A\u751F\u6210\u9884\u671F\u4EA7\u7269: ${missing.join(", ")}`;
-      this.logger.error(msg, { phase: this.phaseName, displayId });
+      this.logger.error(msg, { phase: this.phaseName, displayId: _displayId });
       throw new AIExecutionError(this.phaseName, msg, { output: "", exitCode: 0 });
     }
   }
-  async commitPlanFiles(ctx, displayId) {
-    const commitMsg = `chore(auto): ${this.phaseName} phase completed for issue #${displayId}`;
-    if (ctx.workspace && ctx.workspace.repos.length > 1) {
-      for (const repo of ctx.workspace.repos) {
-        const repoGit = this.wtGitMap?.get(repo.name) ?? new GitOperations(repo.gitRootDir);
-        const branch = repo.branchPrefix ? `${repo.branchPrefix}-${displayId}` : ctx.branchName;
-        try {
-          if (await repoGit.hasChanges()) {
-            await repoGit.add(["."]);
-            await repoGit.commit(commitMsg);
-            await repoGit.push(branch);
-            this.logger.info("Committed changes for repo", { repo: repo.name, branch });
-          }
-        } catch (err) {
-          this.logger.warn("Failed to commit/push for repo", {
-            repo: repo.name,
-            error: err.message
-          });
-        }
-      }
-    } else {
-      if (await this.git.hasChanges()) {
-        await this.git.add(["."]);
-        await this.git.commit(commitMsg);
-        await this.git.push(ctx.branchName);
-      }
-    }
-  }
 };
 
-// src/phases/VerifyPhase.ts
-import fs4 from "fs";
-import path5 from "path";
-
 // src/verify/VerifyReportParser.ts
 var LINT_FAIL_RE = /\*{0,2}Lint\s*(?:结果|Result)\*{0,2}\s*[:：]\s*(?:失败|failed|fail|未通过)/i;
 var BUILD_FAIL_RE = /\*{0,2}Build\s*(?:结果|Result)\*{0,2}\s*[:：]\s*(?:失败|failed|fail|未通过)/i;
@@ -2083,41 +2055,40 @@ var VerifyPhase = class extends BasePhase {
     const filename = ctx?.pipelineMode === "plan-mode" ? "02-verify-report.md" : "04-verify-report.md";
     return [{ filename, label: "\u9A8C\u8BC1\u62A5\u544A" }];
   }
-  async execute(ctx) {
-    const result = await super.execute(ctx);
-    if (result.success) {
-      const report = this.readVerifyReport(ctx);
-      if (report) {
-        const parsed = this.reportParser.parse(report);
-        if (this.config.verifyFixLoop.todolistCheckEnabled && !parsed.todolistStats) {
-          const planContent = this.readPlanFile(ctx);
-          if (planContent) {
-            const todoStats = this.reportParser.parseTodolistFromPlan(planContent);
-            if (todoStats.total > 0) {
-              parsed.todolistStats = todoStats;
-              parsed.todolistComplete = todoStats.completed === todoStats.total;
-              if (!parsed.todolistComplete) {
-                parsed.failureReasons.push(
-                  `Todolist \u672A\u5168\u90E8\u5B8C\u6210(${todoStats.completed}/${todoStats.total})`
-                );
-                parsed.passed = false;
-              }
+  async run(ctx, callbacks) {
+    const outcome = await super.run(ctx, callbacks);
+    if (outcome.status !== "completed") return outcome;
+    const report = this.readVerifyReport(ctx);
+    if (report) {
+      const parsed = this.reportParser.parse(report);
+      if (this.config.verifyFixLoop.todolistCheckEnabled && !parsed.todolistStats) {
+        const planContent = this.readPlanFile();
+        if (planContent) {
+          const todoStats = this.reportParser.parseTodolistFromPlan(planContent);
+          if (todoStats.total > 0) {
+            parsed.todolistStats = todoStats;
+            parsed.todolistComplete = todoStats.completed === todoStats.total;
+            if (!parsed.todolistComplete) {
+              parsed.failureReasons.push(
+                `Todolist \u672A\u5168\u90E8\u5B8C\u6210(${todoStats.completed}/${todoStats.total})`
+              );
+              parsed.passed = false;
             }
           }
         }
-        this.logger.info("Verify report parsed", {
-          passed: parsed.passed,
-          lintPassed: parsed.lintPassed,
-          buildPassed: parsed.buildPassed,
-          testPassed: parsed.testPassed,
-          todolistComplete: parsed.todolistComplete,
-          todolistStats: parsed.todolistStats,
-          failureCount: parsed.failureReasons.length
-        });
-        return { ...result, verifyReport: parsed };
       }
+      this.logger.info("Verify report parsed", {
+        passed: parsed.passed,
+        lintPassed: parsed.lintPassed,
+        buildPassed: parsed.buildPassed,
+        testPassed: parsed.testPassed,
+        todolistComplete: parsed.todolistComplete,
+        todolistStats: parsed.todolistStats,
+        failureCount: parsed.failureReasons.length
+      });
+      return { ...outcome, data: { ...outcome.data, verifyReport: parsed } };
     }
-    return result;
+    return outcome;
   }
   buildPrompt(ctx) {
     const pc = demandToPromptContext(ctx.demand);
@@ -2132,26 +2103,10 @@ var VerifyPhase = class extends BasePhase {
   readVerifyReport(ctx) {
     const files = this.getResultFiles(ctx);
     if (files.length === 0) return null;
-    const displayId = Number(ctx.demand.sourceRef.displayId);
-    const planDir = path5.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`);
-    const filePath = path5.join(planDir, files[0].filename);
-    if (!fs4.existsSync(filePath)) return null;
-    try {
-      return fs4.readFileSync(filePath, "utf-8");
-    } catch {
-      return null;
-    }
+    return this.plan.readFile(files[0].filename);
   }
-  readPlanFile(ctx) {
-    const displayId = Number(ctx.demand.sourceRef.displayId);
-    const planDir = path5.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`);
-    const filePath = path5.join(planDir, "01-plan.md");
-    if (!fs4.existsSync(filePath)) return null;
-    try {
-      return fs4.readFileSync(filePath, "utf-8");
-    } catch {
-      return null;
-    }
+  readPlanFile() {
+    return this.plan.readFile("01-plan.md");
   }
 };
 
@@ -2197,7 +2152,11 @@ var BuildPhase = class extends BasePhase {
     let hasAnyChanges = false;
     if (ctx.workspace && ctx.workspace.repos.length > 1) {
       for (const repo of ctx.workspace.repos) {
-        const repoGit = new GitOperations(repo.gitRootDir);
+        const repoGit = this.wtGitMap?.get(repo.name);
+        if (!repoGit) {
+          this.logger.warn("Missing GitOperations for repo in validation", { repo: repo.name });
+          continue;
+        }
         if (await repoGit.hasChanges()) {
           hasAnyChanges = true;
           break;
@@ -2231,13 +2190,9 @@ var BuildPhase = class extends BasePhase {
   }
 };
 
-// src/phases/ReleasePhase.ts
-import fs6 from "fs";
-import path7 from "path";
-
 // src/release/ReleaseDetectCache.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import { createHash } from "crypto";
 var logger7 = logger.child("ReleaseDetectCache");
 function hashProjectPath(projectPath) {
@@ -2246,10 +2201,10 @@ function hashProjectPath(projectPath) {
 var ReleaseDetectCache = class {
   cacheDir;
   constructor(dataDir) {
-    this.cacheDir = path6.join(dataDir, "release-detect");
+    this.cacheDir = path5.join(dataDir, "release-detect");
   }
   filePath(projectPath) {
-    return path6.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
+    return path5.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
   }
   /**
    * 读取缓存。返回 null 如果不存在、已过期或校验失败。
@@ -2257,8 +2212,8 @@ var ReleaseDetectCache = class {
   get(projectPath, ttlMs) {
     const fp = this.filePath(projectPath);
     try {
-      if (!fs5.existsSync(fp)) return null;
-      const raw = fs5.readFileSync(fp, "utf-8");
+      if (!fs3.existsSync(fp)) return null;
+      const raw = fs3.readFileSync(fp, "utf-8");
       const data = JSON.parse(raw);
       if (data.projectPath !== projectPath) {
         logger7.warn("Cache projectPath mismatch, ignoring", { expected: projectPath, got: data.projectPath });
@@ -2281,10 +2236,10 @@ var ReleaseDetectCache = class {
   set(result) {
     const fp = this.filePath(result.projectPath);
     try {
-      if (!fs5.existsSync(this.cacheDir)) {
-        fs5.mkdirSync(this.cacheDir, { recursive: true });
+      if (!fs3.existsSync(this.cacheDir)) {
+        fs3.mkdirSync(this.cacheDir, { recursive: true });
       }
-      fs5.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
+      fs3.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
       logger7.debug("Release detect cache written", { projectPath: result.projectPath, path: fp });
     } catch (err) {
       logger7.warn("Failed to write release detect cache", { path: fp, error: err.message });
@@ -2296,8 +2251,8 @@ var ReleaseDetectCache = class {
   invalidate(projectPath) {
     const fp = this.filePath(projectPath);
     try {
-      if (fs5.existsSync(fp)) {
-        fs5.unlinkSync(fp);
+      if (fs3.existsSync(fp)) {
+        fs3.unlinkSync(fp);
         logger7.info("Release detect cache invalidated", { projectPath });
         return true;
       }
@@ -2312,54 +2267,66 @@ var ReleaseDetectCache = class {
 // src/prompts/release-templates.ts
 function releaseDetectPrompt(ctx) {
   const pd = `.claude-plan/issue-${ctx.issueIid}`;
-  return `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684 DevOps \u5206\u6790\u5E08\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u63A2\u7D22\u5F53\u524D\u9879\u76EE\uFF0C\u67E5\u627E\u6240\u6709\u4E0E**\u53D1\u5E03/\u90E8\u7F72**\u76F8\u5173\u7684\u673A\u5236\u3002
+  return `\u4F60\u662F\u4E00\u4E2A\u4E13\u4E1A\u7684 DevOps \u5206\u6790\u5E08\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u63A2\u7D22\u5F53\u524D\u9879\u76EE\uFF0C\u5224\u65AD\u662F\u5426\u5B58\u5728 **AI \u53EF\u4EE5\u5728\u672C\u5730\u76F4\u63A5\u6267\u884C\u7684\u53D1\u5E03\u6D41\u7A0B**\u3002
 
-## \u63A2\u7D22\u8303\u56F4
+## \u5173\u952E\u5224\u5B9A\u539F\u5219
 
-\u8BF7\u6309\u4F18\u5148\u7EA7\u4F9D\u6B21\u68C0\u67E5\u4EE5\u4E0B\u4F4D\u7F6E\uFF1A
+\`hasReleaseCapability\` \u4EC5\u5728\u4EE5\u4E0B\u60C5\u51B5\u4E3A \`true\`\uFF1A
+- \u5B58\u5728 **AI \u53EF\u4EE5\u5728\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u76F4\u63A5\u8FD0\u884C** \u7684\u53D1\u5E03\u547D\u4EE4\u6216\u811A\u672C
+- \u4F8B\u5982\uFF1A\`npm publish\`\u3001\`make release\`\u3001\`scripts/release.sh\`\u3001\u5E26\u660E\u786E\u6B65\u9AA4\u7684 Skill \u6587\u4EF6
 
-1. **Skill \u6587\u4EF6**
-   - \`.cursor/skills/\` \u76EE\u5F55\u4E0B\u4E0E release/deploy/publish \u76F8\u5173\u7684 skill
-   - \u9879\u76EE\u6839\u76EE\u5F55\u7684 \`SKILL.md\` \u6216 \`release.md\`
+\u4EE5\u4E0B\u60C5\u51B5\u5FC5\u987B\u8BBE\u4E3A \`false\`\uFF1A
+- **\u4EC5\u6709 Dockerfile** \u2014 Docker \u955C\u50CF\u7531\u5916\u90E8 CI/CD \u7CFB\u7EDF\uFF08\u84DD\u76FE/Landun/Jenkins/GitHub Actions\uFF09\u6784\u5EFA\u548C\u63A8\u9001\uFF0CAI \u65E0\u6CD5\u66FF\u4EE3
+- **\u4EC5\u6709\u5916\u90E8 CI/CD \u914D\u7F6E** \u2014 \`.gitlab-ci.yml\` \u7B49\u5B9A\u4E49\u4E86\u6D41\u6C34\u7EBF\uFF0C\u4F46\u9700\u8981 CI \u73AF\u5883\u6267\u884C\uFF0CAI \u65E0\u6CD5\u89E6\u53D1
+- **\u9879\u76EE\u662F private \u5305\u4E14\u4E0D\u53D1\u5E03\u5230 registry** \u2014 \`package.json\` \u4E2D \`"private": true\` \u4E14\u65E0 publish \u811A\u672C
+- **\u53D1\u5E03\u76F8\u5173\u4EE3\u7801\u5C5E\u4E8E\u4E1A\u52A1\u57DF** \u2014 \u9879\u76EE\u672C\u8EAB\u662F\u90E8\u7F72\u5E73\u53F0/\u7F16\u6392\u7CFB\u7EDF\uFF0C\u5176\u4EE3\u7801\u662F\u4E3A\u5176\u4ED6\u670D\u52A1\u7F16\u6392\u53D1\u5E03\uFF0C\u4E0D\u662F\u672C\u9879\u76EE\u7684\u53D1\u5E03\u6D41\u7A0B
+- **\u4EC5\u6709\u6784\u5EFA\u811A\u672C\u65E0\u53D1\u5E03\u6B65\u9AA4** \u2014 \`build.sh\` \u7B49\u53EA\u6784\u5EFA\u4EA7\u7269\u4F46\u4E0D\u5B9E\u9645\u53D1\u5E03
 
-2. **Rule \u6587\u4EF6**
-   - \`.cursor/rules/\` \u76EE\u5F55\u4E0B\u4E0E release/deploy \u76F8\u5173\u7684 \`.mdc\` \u89C4\u5219
+## \u63A2\u7D22\u8303\u56F4
 
-3. **CI/CD \u914D\u7F6E**
-   - \`.gitlab-ci.yml\` / \`Jenkinsfile\` / \`.github/workflows/\`
-   - \u67E5\u627E release/deploy/publish \u76F8\u5173\u7684 stage/job/workflow
+\u8BF7\u6309\u4F18\u5148\u7EA7\u4F9D\u6B21\u68C0\u67E5\uFF1A
 
-4. **Package Manager**
-   - \`package.json\` \u4E2D\u7684 \`scripts\` \u5B57\u6BB5\uFF1Apublish\u3001release\u3001deploy \u7B49
-   - \`Makefile\` \u4E2D\u7684 release/deploy target
+1. **Skill / Rule \u6587\u4EF6**\uFF08\u6700\u9AD8\u4F18\u5148\u7EA7\uFF09
+   - \`.cursor/skills/\` \u4E0B\u4E0E release/deploy/publish \u76F8\u5173\u7684 skill
+   - \`.cursor/rules/\` \u4E0B\u4E0E release/deploy \u76F8\u5173\u7684 \`.mdc\` \u89C4\u5219
+   - \u26A0\uFE0F \u6CE8\u610F\u533A\u5206\uFF1A\u4E3A\u9879\u76EE\u81EA\u8EAB\u53D1\u5E03\u7684 skill vs \u4E3A\u4E1A\u52A1\u57DF\uFF08\u5982"\u6DFB\u52A0\u5236\u54C1\u7C7B\u578B"\uFF09\u7684 skill
+
+2. **Package Manager \u53D1\u5E03**
+   - \`package.json\` \u7684 \`scripts\` \u4E2D\u662F\u5426\u6709 \`publish\`\u3001\`release\` \u547D\u4EE4
+   - \`package.json\` \u662F\u5426\u4E3A \`"private": true\`\uFF08\u79C1\u6709\u5305\u901A\u5E38\u4E0D\u53D1\u5E03\uFF09
 
-5. **\u811A\u672C\u4E0E\u6587\u6863**
+3. **\u53D1\u5E03\u811A\u672C**
    - \`scripts/release.*\`\u3001\`scripts/deploy.*\`\u3001\`scripts/publish.*\`
-   - \`RELEASE.md\`\u3001\`CHANGELOG.md\`\u3001\`CONTRIBUTING.md\` \u4E2D\u7684\u53D1\u5E03\u8BF4\u660E
+   - \`Makefile\` \u4E2D\u7684 release/deploy target
+
+4. **CI/CD \u914D\u7F6E**\uFF08\u4EC5\u8BB0\u5F55\uFF0C\u901A\u5E38\u4E0D\u7B97 AI \u53EF\u6267\u884C\uFF09
+   - \`.gitlab-ci.yml\` / \`Jenkinsfile\` / \`.github/workflows/\`
+
+5. **\u5BB9\u5668\u5316**\uFF08\u4EC5\u8BB0\u5F55\uFF0C\u901A\u5E38\u4E0D\u7B97 AI \u53EF\u6267\u884C\uFF09
    - \`Dockerfile\`\u3001\`docker-compose*.yml\`
 
 ## \u8F93\u51FA\u8981\u6C42
 
-\u5C06\u68C0\u6D4B\u7ED3\u679C\u4EE5 **\u4E25\u683C JSON** \u683C\u5F0F\u5199\u5165 \`${pd}/03-release-detect.json\`\uFF1A
+\u5C06\u68C0\u6D4B\u7ED3\u679C\u4EE5 **\u4E25\u683C JSON** \u683C\u5F0F\u5199\u5165 \`${pd}/05-release-detect.json\`\uFF1A
 
 \`\`\`json
 {
-  "hasReleaseCapability": true,
-  "releaseMethod": "npm-publish",
-  "artifacts": ["package.json", ".gitlab-ci.yml"],
-  "instructions": "\u8FD0\u884C npm publish \u53D1\u5E03\u5230 npm registry..."
+  "hasReleaseCapability": false,
+  "releaseMethod": "ci-pipeline",
+  "artifacts": ["Dockerfile", ".gitlab-ci.yml"],
+  "instructions": "\u9879\u76EE\u901A\u8FC7\u5916\u90E8 CI/CD \u6D41\u6C34\u7EBF\u6784\u5EFA Docker \u955C\u50CF\u5E76\u90E8\u7F72\uFF0CAI \u65E0\u6CD5\u76F4\u63A5\u6267\u884C\u53D1\u5E03\u3002"
 }
 \`\`\`
 
 \u5B57\u6BB5\u8BF4\u660E\uFF1A
-- \`hasReleaseCapability\`: \u662F\u5426\u627E\u5230\u53D1\u5E03\u673A\u5236\uFF08boolean\uFF09
-- \`releaseMethod\`: \u53D1\u5E03\u65B9\u5F0F\uFF0C\u53EF\u9009\u503C\uFF1A"npm-publish" | "ci-pipeline" | "makefile" | "custom-script" | "skill" | "docker" | \u5176\u4ED6\u63CF\u8FF0
-- \`artifacts\`: \u53D1\u73B0\u7684\u53D1\u5E03\u76F8\u5173\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4
-- \`instructions\`: \u4ECE\u6587\u4EF6\u4E2D\u63D0\u53D6\u7684\u53D1\u5E03\u6B65\u9AA4\u8BF4\u660E\u3002\u5982\u679C\u662F skill/rule \u6587\u4EF6\uFF0C\u8BF7\u5B8C\u6574\u590D\u5236\u5176\u5185\u5BB9
+- \`hasReleaseCapability\`: **AI \u662F\u5426\u80FD\u76F4\u63A5\u6267\u884C\u53D1\u5E03**\uFF08boolean\uFF09\u2014 \u4EC5\u5F53\u6709\u53EF\u5728\u672C\u5730\u8FD0\u884C\u7684\u53D1\u5E03\u547D\u4EE4\u65F6\u4E3A true
+- \`releaseMethod\`: \u53D1\u5E03\u65B9\u5F0F\u63CF\u8FF0\uFF1A"npm-publish" | "ci-pipeline" | "makefile" | "custom-script" | "skill" | "docker" | \u5176\u4ED6
+- \`artifacts\`: \u53D1\u73B0\u7684\u53D1\u5E03\u76F8\u5173\u6587\u4EF6\u8DEF\u5F84\u6570\u7EC4\uFF08\u65E0\u8BBA capability \u662F\u5426\u4E3A true \u90FD\u5217\u51FA\uFF09
+- \`instructions\`: \u53D1\u5E03\u6B65\u9AA4\u8BF4\u660E\u3002capability \u4E3A false \u65F6\u8BF4\u660E\u539F\u56E0
 
 **\u91CD\u8981**\uFF1A
-- \u5982\u679C\u6CA1\u6709\u627E\u5230\u4EFB\u4F55\u53D1\u5E03\u673A\u5236\uFF0C\u5C06 \`hasReleaseCapability\` \u8BBE\u4E3A \`false\`\uFF0C\u5176\u4ED6\u5B57\u6BB5\u53EF\u7701\u7565
-- \u5982\u679C\u627E\u5230\u4E86 skill \u6216 rule \u6587\u4EF6\uFF0C\u8BF7\u5728 \`instructions\` \u4E2D\u5B8C\u6574\u4FDD\u7559\u539F\u6587\u5185\u5BB9\uFF0C\u540E\u7EED\u53D1\u5E03\u6267\u884C\u5C06\u4F9D\u8D56\u5B83
+- \u5927\u591A\u6570\u9879\u76EE\u4F9D\u8D56\u5916\u90E8 CI/CD\uFF0C\`hasReleaseCapability\` \u5E94\u4E3A \`false\`
+- \u5982\u679C\u627E\u5230\u4E86 skill \u6216 rule \u6587\u4EF6\uFF0C\u8BF7\u5728 \`instructions\` \u4E2D\u5B8C\u6574\u4FDD\u7559\u539F\u6587\u5185\u5BB9
 - \u53EA\u8F93\u51FA JSON \u6587\u4EF6\uFF0C\u4E0D\u8981\u6267\u884C\u4EFB\u4F55\u53D1\u5E03\u64CD\u4F5C`;
 }
 function releaseExecPrompt(ctx, detectResult) {
@@ -2382,7 +2349,7 @@ ${instructionSection}
 
 1. \u9605\u8BFB\u4E0A\u8FF0\u53D1\u5E03\u6307\u5F15\u548C\u76F8\u5173\u6587\u4EF6
 2. \u6309\u7167\u9879\u76EE\u5B9A\u4E49\u7684\u53D1\u5E03\u6D41\u7A0B\u6267\u884C\u53D1\u5E03\u64CD\u4F5C
-3. \u5C06\u53D1\u5E03\u7ED3\u679C\u5199\u5165 \`${pd}/04-release-report.md\`
+3. \u5C06\u53D1\u5E03\u7ED3\u679C\u5199\u5165 \`${pd}/06-release-report.md\`
 
 ## \u53D1\u5E03\u62A5\u544A\u683C\u5F0F
 
@@ -2406,38 +2373,27 @@ ${instructionSection}
 }
 
 // src/phases/ReleasePhase.ts
-var logger8 = logger.child("ReleasePhase");
 var DETECT_FILENAME = "05-release-detect.json";
 var REPORT_FILENAME = "06-release-report.md";
 var ReleasePhase = class extends BasePhase {
   phaseName = "release";
-  get planDir() {
-    const displayId = Number(this.currentCtx?.demand.sourceRef.displayId ?? 0);
-    return path7.join(this.plan.baseDir, ".claude-plan", `issue-${displayId}`);
-  }
-  /** 暂存当前 ctx 供 planDir getter 使用 */
-  currentCtx;
   /**
    * 检测结果是否已存在（即是否处于执行模式）。
    */
   hasDetectionResult() {
-    return fs6.existsSync(path7.join(this.planDir, DETECT_FILENAME));
+    return this.plan.readFile(DETECT_FILENAME) !== null;
   }
   readDetectionFile() {
-    const fp = path7.join(this.planDir, DETECT_FILENAME);
-    if (!fs6.existsSync(fp)) return null;
+    const raw = this.plan.readFile(DETECT_FILENAME);
+    if (raw === null) return null;
     try {
-      return JSON.parse(fs6.readFileSync(fp, "utf-8"));
+      return JSON.parse(raw);
     } catch {
       return null;
     }
   }
   writeDetectionFile(result) {
-    const dir = this.planDir;
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
-    }
-    fs6.writeFileSync(path7.join(dir, DETECT_FILENAME), JSON.stringify(result, null, 2), "utf-8");
+    this.plan.writeFile(DETECT_FILENAME, JSON.stringify(result, null, 2));
   }
   getResultFiles(_ctx) {
     if (this.hasDetectionResult()) {
@@ -2460,40 +2416,30 @@ var ReleasePhase = class extends BasePhase {
     }
     return releaseDetectPrompt(pc);
   }
-  async execute(ctx) {
-    this.currentCtx = ctx;
-    const isDetect = !this.hasDetectionResult();
-    if (isDetect) {
+  async run(ctx, callbacks) {
+    const needsDetection = !this.hasDetectionResult();
+    if (needsDetection) {
       const cache = new ReleaseDetectCache(resolveDataDir());
       const projectPath = this.config.gongfeng.projectPath;
       const ttlMs = this.config.release.detectCacheTtlMs;
       const cached = cache.get(projectPath, ttlMs);
       if (cached) {
-        logger8.info("Using cached release detection result", {
+        this.logger.info("Using cached release detection result", {
           projectPath,
           hasCapability: cached.hasReleaseCapability,
           method: cached.releaseMethod
         });
-        await this.hooks.onPhaseStart(this.phaseName);
         this.writeDetectionFile(cached);
-        this.plan.updatePhaseProgress(this.phaseName, "completed");
-        try {
-          await this.git.add(["."]);
-          await this.git.commit(`chore: release detection (cached) for issue-${ctx.demand.sourceRef.displayId}`);
-        } catch {
-        }
-        await this.hooks.onPhaseDone(this.phaseName);
         return {
-          success: true,
+          status: "completed",
           output: `Release detection cached: ${cached.hasReleaseCapability ? cached.releaseMethod ?? "found" : "no capability"}`,
-          exitCode: 0,
-          gateRequested: cached.hasReleaseCapability,
-          hasReleaseCapability: cached.hasReleaseCapability
+          data: { hasReleaseCapability: cached.hasReleaseCapability }
         };
       }
     }
-    const result = await super.execute(ctx);
-    if (isDetect && result.success) {
+    const outcome = await super.run(ctx, callbacks);
+    if (outcome.status !== "completed") return outcome;
+    if (needsDetection) {
       const detected = this.readDetectionFile();
       if (detected) {
         const cache = new ReleaseDetectCache(resolveDataDir());
@@ -2503,110 +2449,88 @@ var ReleasePhase = class extends BasePhase {
           projectPath,
           detectedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
-        logger8.info("Release detection completed", {
+        this.logger.info("Release detection completed", {
           hasCapability: detected.hasReleaseCapability,
           method: detected.releaseMethod,
           artifacts: detected.artifacts
         });
         return {
-          ...result,
-          gateRequested: detected.hasReleaseCapability,
-          hasReleaseCapability: detected.hasReleaseCapability
+          ...outcome,
+          data: { ...outcome.data, hasReleaseCapability: detected.hasReleaseCapability }
         };
       }
-      return { ...result, gateRequested: false, hasReleaseCapability: false };
+      return { ...outcome, data: { ...outcome.data, hasReleaseCapability: false } };
     }
-    return { ...result, gateRequested: false };
+    return outcome;
   }
 };
 
 // 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;
-    }
+  hasArtifact(_displayId) {
+    return this.plan.isArtifactReady("03-uat-report.md", BasePhase.MIN_ARTIFACT_BYTES);
   }
-  async execute(ctx) {
-    this.currentCtx = ctx;
+  async run(ctx, callbacks) {
     const displayId = Number(ctx.demand.sourceRef.displayId);
     if (this.hasArtifact(displayId)) {
-      return this.completeWithExistingArtifact(ctx, displayId);
+      this.logger.info("UAT artifact found, completing phase", { iid: displayId });
+      try {
+        await this.validatePhaseOutput(ctx, displayId);
+      } catch (err) {
+        return {
+          status: "failed",
+          output: "",
+          error: { message: err.message, isRetryable: false }
+        };
+      }
+      return { status: "completed", output: "UAT report validated" };
     }
-    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 };
+    return this.launchAsync(ctx, displayId, callbacks);
   }
-  /**
-   * 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"));
+  async launchAsync(ctx, displayId, callbacks) {
+    this.logger.info("Launching async UAT", { iid: displayId });
     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
-        });
-      }
+      onStreamEvent: callbacks?.onStreamEvent
     });
-    runPromise.then(async (result) => {
+    const awaitCompletion = 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);
+        return {
+          status: "completed",
+          output: result.output,
+          sessionId: result.sessionId
+        };
       }
-    }).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 };
+      const reason = result.errorMessage || "UAT failed or artifact 03-uat-report.md missing";
+      return {
+        status: "failed",
+        output: result.output,
+        error: { message: reason, isRetryable: false }
+      };
+    }).catch(async (err) => ({
+      status: "failed",
+      output: "",
+      error: { message: err.message, isRetryable: false }
+    }));
+    return {
+      status: "running",
+      output: "UAT launched asynchronously",
+      awaitCompletion
+    };
   }
   buildPrompt(ctx) {
     const pc = demandToPromptContext(ctx.demand);
@@ -2617,8 +2541,7 @@ var UatPhase = class extends BasePhase {
       workspace: ctx.workspace
     };
     const hasUatTool = !!this.config.e2e.uatVendorDir;
-    const systemE2e = this.hooks.isE2eEnabled();
-    const e2ePorts = systemE2e && ctx.ports ? {
+    const e2ePorts = ctx.ports ? {
       backendPort: ctx.ports.backendPort,
       frontendPort: ctx.ports.frontendPort,
       host: this.config.preview.host || getDefaultHost()
@@ -2786,9 +2709,9 @@ function createLifecycleManager(def) {
 
 // src/workspace/WorkspaceConfig.ts
 import { z } from "zod";
-import fs8 from "fs";
-import path9 from "path";
-var logger10 = logger.child("WorkspaceConfig");
+import fs4 from "fs";
+import path6 from "path";
+var logger8 = 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"),
@@ -2804,29 +2727,29 @@ var workspaceConfigSchema = z.object({
 });
 function loadWorkspaceConfig(configPath) {
   if (!configPath) return null;
-  if (!fs8.existsSync(configPath)) {
-    logger10.warn("Workspace config file not found, falling back to single-repo mode", {
+  if (!fs4.existsSync(configPath)) {
+    logger8.warn("Workspace config file not found, falling back to single-repo mode", {
       path: configPath
     });
     return null;
   }
   try {
-    const raw = fs8.readFileSync(configPath, "utf-8");
+    const raw = fs4.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");
-      logger10.error(`Workspace config validation failed:
+      logger8.error(`Workspace config validation failed:
 ${issues}`);
       return null;
     }
-    logger10.info("Workspace config loaded", {
+    logger8.info("Workspace config loaded", {
       primary: result.data.primary.name,
       associates: result.data.associates.map((a) => a.name)
     });
     return result.data;
   } catch (err) {
-    logger10.error("Failed to parse workspace config", {
+    logger8.error("Failed to parse workspace config", {
       path: configPath,
       error: err.message
     });
@@ -2852,14 +2775,14 @@ function isMultiRepo(ws) {
 }
 function persistWorkspaceConfig(ws, filePath) {
   try {
-    const dir = path9.dirname(filePath);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(filePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
-    fs8.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
-    logger10.info("Workspace config auto-generated from .env", { path: filePath });
+    fs4.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
+    logger8.info("Workspace config auto-generated from .env", { path: filePath });
   } catch (err) {
-    logger10.warn("Failed to persist workspace config", {
+    logger8.warn("Failed to persist workspace config", {
       path: filePath,
       error: err.message
     });
@@ -2867,12 +2790,12 @@ function persistWorkspaceConfig(ws, filePath) {
 }
 
 // src/workspace/WorkspaceManager.ts
-import path10 from "path";
-import fs9 from "fs/promises";
+import path7 from "path";
+import fs5 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var logger11 = logger.child("WorkspaceManager");
+var logger9 = logger.child("WorkspaceManager");
 var WorkspaceManager = class {
   wsConfig;
   worktreeBaseDir;
@@ -2901,7 +2824,7 @@ var WorkspaceManager = class {
    */
   async prepareWorkspace(issueIid, branchName, globalBaseBranch, globalBranchPrefix) {
     const wsRoot = this.getWorkspaceRoot(issueIid);
-    await fs9.mkdir(wsRoot, { recursive: true });
+    await fs5.mkdir(wsRoot, { recursive: true });
     const primaryCtx = await this.preparePrimaryRepo(
       issueIid,
       branchName,
@@ -2920,7 +2843,7 @@ var WorkspaceManager = class {
       );
       associateCtxs.push(ctx);
     }
-    logger11.info("Workspace prepared", {
+    logger9.info("Workspace prepared", {
       issueIid,
       wsRoot,
       repos: [primaryCtx.name, ...associateCtxs.map((a) => a.name)]
@@ -2945,7 +2868,7 @@ var WorkspaceManager = class {
         await git.commit(message);
         await git.push(wsCtx.branchName);
         committed.push(repo.name);
-        logger11.info("Committed and pushed changes", {
+        logger9.info("Committed and pushed changes", {
           repo: repo.name,
           branch: wsCtx.branchName
         });
@@ -2959,19 +2882,19 @@ var WorkspaceManager = class {
   async cleanupWorkspace(wsCtx) {
     try {
       await this.mainGit.worktreeRemove(wsCtx.primary.gitRootDir, true);
-      logger11.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
+      logger9.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
     } catch (err) {
-      logger11.warn("Failed to remove primary worktree", {
+      logger9.warn("Failed to remove primary worktree", {
         dir: wsCtx.primary.gitRootDir,
         error: err.message
       });
     }
     for (const assoc of wsCtx.associates) {
       try {
-        await fs9.rm(assoc.gitRootDir, { recursive: true, force: true });
-        logger11.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
+        await fs5.rm(assoc.gitRootDir, { recursive: true, force: true });
+        logger9.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
       } catch (err) {
-        logger11.warn("Failed to remove associate repo dir", {
+        logger9.warn("Failed to remove associate repo dir", {
           name: assoc.name,
           dir: assoc.gitRootDir,
           error: err.message
@@ -2979,9 +2902,9 @@ var WorkspaceManager = class {
       }
     }
     try {
-      const entries = await fs9.readdir(wsCtx.workspaceRoot);
+      const entries = await fs5.readdir(wsCtx.workspaceRoot);
       if (entries.length === 0) {
-        await fs9.rmdir(wsCtx.workspaceRoot);
+        await fs5.rmdir(wsCtx.workspaceRoot);
       }
     } catch {
     }
@@ -2993,13 +2916,13 @@ var WorkspaceManager = class {
     const wsRoot = this.getWorkspaceRoot(issueIid);
     const primary = this.wsConfig.primary;
     const defaultPrefix = globalBranchPrefix ?? primary.branchPrefix ?? "feat/issue";
-    const primaryDir = path10.join(wsRoot, primary.name);
+    const primaryDir = path7.join(wsRoot, primary.name);
     const repos = [{
       name: primary.name,
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: primaryDir,
-      workDir: path10.join(primaryDir, primary.projectSubDir ?? ""),
+      workDir: path7.join(primaryDir, primary.projectSubDir ?? ""),
       baseBranch: primary.baseBranch ?? globalBaseBranch,
       branchPrefix: primary.branchPrefix ?? defaultPrefix,
       isPrimary: true
@@ -3009,8 +2932,8 @@ var WorkspaceManager = class {
         name: assoc.name,
         projectPath: assoc.projectPath,
         role: assoc.role ?? "",
-        gitRootDir: path10.join(wsRoot, assoc.name),
-        workDir: path10.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
+        gitRootDir: path7.join(wsRoot, assoc.name),
+        workDir: path7.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
         baseBranch: assoc.baseBranch ?? globalBaseBranch,
         branchPrefix: assoc.branchPrefix ?? defaultPrefix,
         isPrimary: false
@@ -3019,12 +2942,12 @@ var WorkspaceManager = class {
     return repos;
   }
   getWorkspaceRoot(issueIid) {
-    return path10.join(this.worktreeBaseDir, `issue-${issueIid}`);
+    return path7.join(this.worktreeBaseDir, `issue-${issueIid}`);
   }
   // ── Internal helpers ──
   async preparePrimaryRepo(issueIid, branchName, wsRoot, globalBaseBranch) {
     const primary = this.wsConfig.primary;
-    const repoDir = path10.join(wsRoot, primary.name);
+    const repoDir = path7.join(wsRoot, primary.name);
     const baseBranch = primary.baseBranch ?? globalBaseBranch;
     await this.ensurePrimaryWorktree(repoDir, branchName, baseBranch);
     return {
@@ -3032,18 +2955,18 @@ var WorkspaceManager = class {
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: repoDir,
-      workDir: path10.join(repoDir, primary.projectSubDir ?? ""),
+      workDir: path7.join(repoDir, primary.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: primary.branchPrefix ?? "feat/issue",
       isPrimary: true
     };
   }
   async ensurePrimaryWorktree(repoDir, branchName, baseBranch) {
-    const wsRoot = path10.dirname(repoDir);
+    const wsRoot = path7.dirname(repoDir);
     if (wsRoot !== repoDir) {
       try {
-        await fs9.access(path10.join(wsRoot, ".git"));
-        logger11.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
+        await fs5.access(path7.join(wsRoot, ".git"));
+        logger9.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);
@@ -3053,11 +2976,11 @@ var WorkspaceManager = class {
     const worktrees = await this.mainGit.worktreeList();
     if (worktrees.includes(repoDir)) {
       try {
-        await fs9.access(path10.join(repoDir, ".git"));
-        logger11.info("Reusing existing primary worktree", { dir: repoDir });
+        await fs5.access(path7.join(repoDir, ".git"));
+        logger9.info("Reusing existing primary worktree", { dir: repoDir });
         return;
       } catch {
-        logger11.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
+        logger9.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
         await this.mainGit.worktreeRemove(repoDir, true);
         await this.mainGit.worktreePrune();
       }
@@ -3076,19 +2999,19 @@ var WorkspaceManager = class {
     await this.mainGit.worktreeAdd(repoDir, branchName, `origin/${baseBranch}`);
   }
   async prepareAssociateRepo(assoc, _issueIid, branchName, wsRoot, globalBaseBranch, globalBranchPrefix) {
-    const repoDir = path10.join(wsRoot, assoc.name);
+    const repoDir = path7.join(wsRoot, assoc.name);
     const baseBranch = assoc.baseBranch ?? globalBaseBranch;
     const cloneUrl = `${this.gongfengApiUrl}/${assoc.projectPath}.git`;
-    const gitDirExists = await this.dirExists(path10.join(repoDir, ".git"));
+    const gitDirExists = await this.dirExists(path7.join(repoDir, ".git"));
     if (!gitDirExists) {
       await this.cleanStaleDir(repoDir);
-      logger11.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
+      logger9.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
       await execFileAsync("git", ["clone", "--depth", "50", cloneUrl, repoDir], {
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024
       });
     } else {
-      logger11.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
+      logger9.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
     }
     const assocGit = new GitOperations(repoDir);
     await assocGit.fetch();
@@ -3111,7 +3034,7 @@ var WorkspaceManager = class {
       projectPath: assoc.projectPath,
       role: assoc.role ?? "",
       gitRootDir: repoDir,
-      workDir: path10.join(repoDir, assoc.projectSubDir ?? ""),
+      workDir: path7.join(repoDir, assoc.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: assoc.branchPrefix ?? globalBranchPrefix,
       isPrimary: false
@@ -3119,13 +3042,13 @@ var WorkspaceManager = class {
   }
   async cleanStaleDir(dir) {
     if (await this.dirExists(dir)) {
-      logger11.warn("Removing stale directory", { dir });
-      await fs9.rm(dir, { recursive: true, force: true });
+      logger9.warn("Removing stale directory", { dir });
+      await fs5.rm(dir, { recursive: true, force: true });
     }
   }
   async dirExists(dir) {
     try {
-      await fs9.access(dir);
+      await fs5.access(dir);
       return true;
     } catch {
       return false;
@@ -3134,8 +3057,8 @@ var WorkspaceManager = class {
 };
 
 // src/orchestrator/PipelineOrchestrator.ts
-import path14 from "path";
-import fs13 from "fs/promises";
+import path11 from "path";
+import fs9 from "fs/promises";
 import fsSync from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3168,8 +3091,8 @@ function mapSupplement(s) {
 }
 
 // src/utils/MergeRequestHelper.ts
-import fs10 from "fs";
-import path11 from "path";
+import fs6 from "fs";
+import path8 from "path";
 var TAPD_PATTERNS = [
   /--story=(\d+)/i,
   /--bug=(\d+)/i,
@@ -3213,9 +3136,9 @@ function generateMRDescription(options) {
     ];
     const planSections = [];
     for (const { filename, label } of summaryFiles) {
-      const filePath = path11.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
-      if (fs10.existsSync(filePath)) {
-        const content = fs10.readFileSync(filePath, "utf-8");
+      const filePath = path8.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs6.existsSync(filePath)) {
+        const content = fs6.readFileSync(filePath, "utf-8");
         const summary = extractSummary(content);
         if (summary) {
           planSections.push(`### ${label}
@@ -3239,7 +3162,7 @@ function extractSummary(content, maxLines = 20) {
 
 // src/deploy/PortAllocator.ts
 import net from "net";
-var logger12 = logger.child("PortAllocator");
+var logger10 = logger.child("PortAllocator");
 var DEFAULT_OPTIONS = {
   backendPortBase: 4e3,
   frontendPortBase: 9e3,
@@ -3264,7 +3187,7 @@ var PortAllocator = class {
   async allocate(issueIid) {
     const existing = this.allocated.get(issueIid);
     if (existing) {
-      logger12.info("Returning already allocated ports", { issueIid, ports: existing });
+      logger10.info("Returning already allocated ports", { issueIid, ports: existing });
       return existing;
     }
     const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
@@ -3282,10 +3205,10 @@ var PortAllocator = class {
       if (beOk && feOk) {
         const pair = { backendPort, frontendPort };
         this.allocated.set(issueIid, pair);
-        logger12.info("Ports allocated", { issueIid, ...pair });
+        logger10.info("Ports allocated", { issueIid, ...pair });
         return pair;
       }
-      logger12.debug("Port pair unavailable, trying next", {
+      logger10.debug("Port pair unavailable, trying next", {
         backendPort,
         frontendPort,
         beOk,
@@ -3300,7 +3223,7 @@ var PortAllocator = class {
     const pair = this.allocated.get(issueIid);
     if (pair) {
       this.allocated.delete(issueIid);
-      logger12.info("Ports released", { issueIid, ...pair });
+      logger10.info("Ports released", { issueIid, ...pair });
     }
   }
   getPortsForIssue(issueIid) {
@@ -3311,15 +3234,15 @@ var PortAllocator = class {
   }
   restore(issueIid, ports) {
     this.allocated.set(issueIid, ports);
-    logger12.info("Ports restored from persistence", { issueIid, ...ports });
+    logger10.info("Ports restored from persistence", { issueIid, ...ports });
   }
 };
 
 // src/deploy/DevServerManager.ts
 import { spawn } from "child_process";
-import fs11 from "fs";
-import path12 from "path";
-var logger13 = logger.child("DevServerManager");
+import fs7 from "fs";
+import path9 from "path";
+var logger11 = logger.child("DevServerManager");
 var DEFAULT_OPTIONS2 = {};
 var DevServerManager = class {
   servers = /* @__PURE__ */ new Map();
@@ -3327,25 +3250,25 @@ var DevServerManager = class {
   logDir;
   constructor(options) {
     this.options = { ...DEFAULT_OPTIONS2, ...options };
-    this.logDir = path12.join(resolveDataDir(), "preview-logs");
-    if (!fs11.existsSync(this.logDir)) {
-      fs11.mkdirSync(this.logDir, { recursive: true });
+    this.logDir = path9.join(resolveDataDir(), "preview-logs");
+    if (!fs7.existsSync(this.logDir)) {
+      fs7.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogPath(issueIid, type) {
-    const filePath = path12.join(this.logDir, `${issueIid}-${type}.log`);
-    return fs11.existsSync(filePath) ? filePath : null;
+    const filePath = path9.join(this.logDir, `${issueIid}-${type}.log`);
+    return fs7.existsSync(filePath) ? filePath : null;
   }
   async startServers(wtCtx, ports) {
     if (this.servers.has(wtCtx.issueIid)) {
-      logger13.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      logger11.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
       return;
     }
-    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" });
+    logger11.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    const backendLogPath = path9.join(this.logDir, `${wtCtx.issueIid}-backend.log`);
+    const frontendLogPath = path9.join(this.logDir, `${wtCtx.issueIid}-frontend.log`);
+    const backendLog = fs7.createWriteStream(backendLogPath, { flags: "a" });
+    const frontendLog = fs7.createWriteStream(frontendLogPath, { flags: "a" });
     const tsLine = (stream, data) => `[${(/* @__PURE__ */ new Date()).toISOString()}] [${stream}] ${data.toString().trimEnd()}
 `;
     const backendEnv = {
@@ -3369,9 +3292,9 @@ var DevServerManager = class {
       backendLog.write(tsLine("stderr", data));
     });
     backend.on("exit", (code) => {
-      logger13.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+      logger11.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
     });
-    const frontendDir = path12.join(wtCtx.workDir, "frontend");
+    const frontendDir = path9.join(wtCtx.workDir, "frontend");
     const frontendEnv = {
       ...process.env,
       BACKEND_PORT: String(ports.backendPort),
@@ -3393,7 +3316,7 @@ var DevServerManager = class {
       frontendLog.write(tsLine("stderr", data));
     });
     frontend.on("exit", (code) => {
-      logger13.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+      logger11.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
     });
     const serverSet = {
       backend,
@@ -3405,14 +3328,14 @@ var DevServerManager = class {
       frontendLog
     };
     this.servers.set(wtCtx.issueIid, serverSet);
-    logger13.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
+    logger11.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
     await new Promise((r) => setTimeout(r, 1e4));
-    logger13.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
+    logger11.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
   }
   stopServers(issueIid) {
     const set = this.servers.get(issueIid);
     if (!set) return;
-    logger13.info("Stopping dev servers", { issueIid, ports: set.ports });
+    logger11.info("Stopping dev servers", { issueIid, ports: set.ports });
     killProcess(set.backend, `backend #${issueIid}`);
     killProcess(set.frontend, `frontend #${issueIid}`);
     set.backendLog.end();
@@ -3449,7 +3372,7 @@ function killProcess(proc, label) {
     }
     setTimeout(() => {
       if (!proc.killed && proc.exitCode === null) {
-        logger13.warn(`Force killing ${label}`);
+        logger11.warn(`Force killing ${label}`);
         try {
           process.kill(-pid, "SIGKILL");
         } catch {
@@ -3458,7 +3381,7 @@ function killProcess(proc, label) {
       }
     }, 5e3);
   } catch (err) {
-    logger13.warn(`Failed to kill ${label}`, { error: err.message });
+    logger11.warn(`Failed to kill ${label}`, { error: err.message });
   }
 }
 
@@ -3477,13 +3400,13 @@ function isE2eEnabledForIssue(issueIid, tracker, cfg) {
 }
 
 // src/e2e/ScreenshotCollector.ts
-import fs12 from "fs";
-import path13 from "path";
-var logger14 = logger.child("ScreenshotCollector");
+import fs8 from "fs";
+import path10 from "path";
+var logger12 = logger.child("ScreenshotCollector");
 var MAX_SCREENSHOTS = 20;
 function walkDir(dir, files = []) {
-  for (const entry of fs12.readdirSync(dir, { withFileTypes: true })) {
-    const full = path13.join(dir, entry.name);
+  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+    const full = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkDir(full, files);
     } else if (entry.isFile() && entry.name.endsWith(".png")) {
@@ -3493,34 +3416,34 @@ function walkDir(dir, files = []) {
   return files;
 }
 function collectScreenshots(workDir) {
-  const testResultsDir = path13.join(workDir, "frontend", "test-results");
-  if (!fs12.existsSync(testResultsDir)) {
-    logger14.debug("test-results directory not found", { dir: testResultsDir });
+  const testResultsDir = path10.join(workDir, "frontend", "test-results");
+  if (!fs8.existsSync(testResultsDir)) {
+    logger12.debug("test-results directory not found", { dir: testResultsDir });
     return [];
   }
   const pngFiles = walkDir(testResultsDir);
   if (pngFiles.length === 0) {
-    logger14.debug("No screenshots found");
+    logger12.debug("No screenshots found");
     return [];
   }
   const screenshots = pngFiles.map((filePath) => {
-    const relative = path13.relative(testResultsDir, filePath);
-    const testName = relative.split(path13.sep)[0] || path13.basename(filePath, ".png");
+    const relative = path10.relative(testResultsDir, filePath);
+    const testName = relative.split(path10.sep)[0] || path10.basename(filePath, ".png");
     return { filePath, testName };
   });
   if (screenshots.length > MAX_SCREENSHOTS) {
-    logger14.warn("Too many screenshots, truncating", {
+    logger12.warn("Too many screenshots, truncating", {
       total: screenshots.length,
       max: MAX_SCREENSHOTS
     });
     return screenshots.slice(0, MAX_SCREENSHOTS);
   }
-  logger14.info("Screenshots collected", { count: screenshots.length });
+  logger12.info("Screenshots collected", { count: screenshots.length });
   return screenshots;
 }
 
 // src/e2e/ScreenshotPublisher.ts
-var logger15 = logger.child("ScreenshotPublisher");
+var logger13 = logger.child("ScreenshotPublisher");
 function buildComment(uploaded, truncated) {
   const lines = [t("screenshot.title"), ""];
   for (const item of uploaded) {
@@ -3539,12 +3462,12 @@ var ScreenshotPublisher = class {
     const { workDir, issueIid, issueId, mrIid } = options;
     const screenshots = collectScreenshots(workDir);
     if (screenshots.length === 0) {
-      logger15.info("No E2E screenshots to publish", { issueIid });
+      logger13.info("No E2E screenshots to publish", { issueIid });
       return;
     }
     const uploaded = await this.uploadAll(screenshots);
     if (uploaded.length === 0) {
-      logger15.warn("All screenshot uploads failed", { issueIid });
+      logger13.warn("All screenshot uploads failed", { issueIid });
       return;
     }
     const truncated = screenshots.length >= 20;
@@ -3553,7 +3476,7 @@ var ScreenshotPublisher = class {
     if (mrIid) {
       await this.postToMergeRequest(mrIid, comment);
     }
-    logger15.info("E2E screenshots published", {
+    logger13.info("E2E screenshots published", {
       issueIid,
       mrIid,
       count: uploaded.length
@@ -3569,7 +3492,7 @@ var ScreenshotPublisher = class {
           markdown: result.markdown
         });
       } catch (err) {
-        logger15.warn("Failed to upload screenshot", {
+        logger13.warn("Failed to upload screenshot", {
           filePath: screenshot.filePath,
           error: err.message
         });
@@ -3581,7 +3504,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createIssueNote(issueId, comment);
     } catch (err) {
-      logger15.warn("Failed to post screenshots to issue", {
+      logger13.warn("Failed to post screenshots to issue", {
         issueId,
         error: err.message
       });
@@ -3591,7 +3514,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, comment);
     } catch (err) {
-      logger15.warn("Failed to post screenshots to merge request", {
+      logger13.warn("Failed to post screenshots to merge request", {
         mrIid,
         error: err.message
       });
@@ -3774,7 +3697,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 logger16 = logger.child("SetupStep");
+var logger14 = logger.child("SetupStep");
 async function executeSetup(ctx, deps) {
   const { issue, wtCtx, record, pipelineDef, branchName } = ctx;
   try {
@@ -3783,7 +3706,7 @@ async function executeSetup(ctx, deps) {
       "auto-finish:processing"
     ]);
   } catch (err) {
-    logger16.warn("Failed to update issue labels", { error: err.message });
+    logger14.warn("Failed to update issue labels", { error: err.message });
   }
   await deps.mainGitMutex.runExclusive(async () => {
     deps.emitProgress(issue.iid, "fetch", t("orchestrator.fetchProgress"));
@@ -3817,11 +3740,14 @@ async function executeSetup(ctx, deps) {
     state: issue.state
   });
   const existingProgress = wtPlan.readProgress();
-  if (!existingProgress) {
+  if (!existingProgress || !ctx.isRetry) {
     wtPlan.writeProgress(
       wtPlan.createInitialProgress(issue.iid, issue.title, branchName, pipelineDef)
     );
   }
+  if (!record.phaseProgress) {
+    deps.tracker.initPhaseProgress(issue.iid, pipelineDef);
+  }
   const wtGitMap = /* @__PURE__ */ new Map();
   if (wtCtx.workspace) {
     wtGitMap.set(wtCtx.workspace.primary.name, wtGit);
@@ -3834,8 +3760,52 @@ async function executeSetup(ctx, deps) {
   return { wtGit, wtPlan, wtGitMap };
 }
 
+// src/notesync/NoteSyncSettings.ts
+var noteSyncOverride;
+function getNoteSyncEnabled(cfg) {
+  return noteSyncOverride ?? cfg.issueNoteSync.enabled;
+}
+function setNoteSyncOverride(value) {
+  noteSyncOverride = value;
+}
+function isNoteSyncEnabledForIssue(issueIid, tracker, cfg) {
+  const record = tracker.get(issueIid);
+  if (record?.issueNoteSyncEnabled !== void 0) return record.issueNoteSyncEnabled;
+  return getNoteSyncEnabled(cfg);
+}
+var SUMMARY_MAX_LENGTH = 500;
+function truncateToSummary(content) {
+  if (content.length <= SUMMARY_MAX_LENGTH) return content;
+  const cut = content.slice(0, SUMMARY_MAX_LENGTH);
+  const lastNewline = cut.lastIndexOf("\n\n");
+  const boundary = lastNewline > SUMMARY_MAX_LENGTH * 0.3 ? lastNewline : cut.lastIndexOf("\n");
+  const summary = boundary > SUMMARY_MAX_LENGTH * 0.3 ? cut.slice(0, boundary) : cut;
+  return summary + "\n\n...";
+}
+function buildNoteSyncComment(phaseName, phaseLabel, docUrl, dashboardUrl, summary) {
+  const emoji = {
+    analysis: "\u{1F50D}",
+    design: "\u{1F4D0}",
+    implement: "\u{1F4BB}",
+    verify: "\u2705",
+    plan: "\u{1F4CB}",
+    review: "\u{1F440}",
+    build: "\u{1F528}"
+  };
+  const icon = emoji[phaseName] || "\u{1F4CB}";
+  return [
+    t("notesync.phaseCompleted", { icon, label: phaseLabel }),
+    "",
+    summary,
+    "",
+    "---",
+    t("notesync.viewDoc", { label: phaseLabel, url: docUrl }),
+    t("notesync.viewDashboard", { url: dashboardUrl })
+  ].join("\n");
+}
+
 // src/orchestrator/steps/PhaseLoopStep.ts
-var logger17 = logger.child("PhaseLoopStep");
+var logger15 = logger.child("PhaseLoopStep");
 function resolveVerifyRunner(deps) {
   return deps.aiRunner;
 }
@@ -3845,6 +3815,162 @@ function resolveUatRunner(deps, issueIid) {
   }
   return deps.aiRunner;
 }
+async function commitPlanFiles(ctx, wtGit, wtGitMap, phaseName, displayId) {
+  const commitMsg = `chore(auto): ${phaseName} phase completed for issue #${displayId}`;
+  if (ctx.workspace && ctx.workspace.repos.length > 1) {
+    for (const repo of ctx.workspace.repos) {
+      const repoGit = wtGitMap?.get(repo.name);
+      if (!repoGit) {
+        logger15.warn("Missing GitOperations for repo, skipping commit", { repo: repo.name });
+        continue;
+      }
+      const branch = repo.branchPrefix ? `${repo.branchPrefix}-${displayId}` : ctx.branchName;
+      try {
+        if (await repoGit.hasChanges()) {
+          await repoGit.add(["."]);
+          await repoGit.commit(commitMsg);
+          await repoGit.push(branch);
+          logger15.info("Committed changes for repo", { repo: repo.name, branch });
+        }
+      } catch (err) {
+        logger15.warn("Failed to commit/push for repo", {
+          repo: repo.name,
+          error: err.message
+        });
+      }
+    }
+  } else {
+    if (await wtGit.hasChanges()) {
+      await wtGit.add(["."]);
+      await wtGit.commit(commitMsg);
+      await wtGit.push(ctx.branchName);
+    }
+  }
+}
+async function syncResultToIssue(phase, ctx, displayId, phaseName, deps, issueId, wtPlan) {
+  try {
+    const enabled = isNoteSyncEnabledForIssue(displayId, deps.tracker, deps.config);
+    const resultFiles = phase.getResultFiles(ctx);
+    if (!enabled || resultFiles.length === 0) {
+      await safeComment(deps, issueId, issueProgressComment(phaseName, "completed"));
+      return;
+    }
+    const baseUrl = deps.config.issueNoteSync.webBaseUrl.replace(/\/$/, "");
+    const phaseLabel = t(`phase.${phaseName}`) || phaseName;
+    const dashboardUrl = `${baseUrl}/?issue=${displayId}`;
+    for (const file of resultFiles) {
+      const content = wtPlan.readFile(file.filename);
+      if (!content) continue;
+      const summary = truncateToSummary(content);
+      const docUrl = `${baseUrl}/doc/${displayId}/${file.filename}`;
+      const comment = buildNoteSyncComment(
+        phaseName,
+        file.label || phaseLabel,
+        docUrl,
+        dashboardUrl,
+        summary
+      );
+      await safeComment(deps, issueId, comment);
+      logger15.info("Result synced to issue", { issueIid: displayId, file: file.filename });
+    }
+  } catch (err) {
+    logger15.warn("Failed to sync result to issue", { error: err.message });
+    await safeComment(deps, issueId, issueProgressComment(phaseName, "completed"));
+  }
+}
+function buildAcpHandler(displayId, phaseName, deps) {
+  if (deps.config.ai.codebuddyAcpAutoApprove !== false) return void 0;
+  return (request) => {
+    if (request.type !== "plan-approval") {
+      return Promise.resolve("allow");
+    }
+    logger15.info("ACP plan-approval requested, delegating to review gate", {
+      issueIid: displayId,
+      phase: phaseName
+    });
+    deps.eventBus.emitTyped("review:requested", { issueIid: displayId });
+    return new Promise((resolve) => {
+      const onApproved = (payload) => {
+        const data = payload.data;
+        if (data.issueIid !== displayId) return;
+        cleanup();
+        logger15.info("ACP plan-approval approved via review gate", { issueIid: displayId });
+        resolve("allow");
+      };
+      const onRejected = (payload) => {
+        const data = payload.data;
+        if (data.issueIid !== displayId) return;
+        cleanup();
+        logger15.info("ACP plan-approval rejected via review gate", { issueIid: displayId });
+        resolve("reject");
+      };
+      const cleanup = () => {
+        deps.eventBus.removeListener("review:approved", onApproved);
+        deps.eventBus.removeListener("review:rejected", onRejected);
+      };
+      deps.eventBus.on("review:approved", onApproved);
+      deps.eventBus.on("review:rejected", onRejected);
+    });
+  };
+}
+async function safeComment(deps, issueId, message) {
+  try {
+    await deps.gongfeng.createIssueNote(issueId, message);
+  } catch {
+  }
+}
+async function runPhaseWithLifecycle(phase, phaseCtx, spec, ctx, deps, wtGit, wtPlan, wtGitMap) {
+  const { issue } = ctx;
+  const displayId = issue.iid;
+  deps.tracker.updateState(displayId, spec.startState, { currentPhase: spec.name });
+  deps.tracker.updatePhaseProgress(displayId, spec.name, {
+    status: "in_progress",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  wtPlan.updatePhaseProgress(spec.name, "in_progress");
+  await safeComment(deps, issue.id, issueProgressComment(spec.name, "in_progress"));
+  const phaseLabel = t(`phase.${spec.name}`) || spec.name;
+  deps.eventBus.emitTyped("agent:output", {
+    issueIid: displayId,
+    phase: spec.name,
+    event: { type: "system", content: t("basePhase.aiStarting", { label: phaseLabel }), timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+  });
+  const callbacks = {
+    onStreamEvent: (event) => deps.eventBus.emitTyped("agent:output", {
+      issueIid: displayId,
+      phase: spec.name,
+      event
+    }),
+    onInputRequired: buildAcpHandler(displayId, spec.name, deps)
+  };
+  const outcome = await phase.run(phaseCtx, callbacks);
+  if (outcome.sessionId) wtPlan.updatePhaseSessionId(spec.name, outcome.sessionId);
+  if (outcome.status === "completed") {
+    deps.tracker.updateState(displayId, spec.doneState, { currentPhase: spec.name });
+    deps.tracker.updatePhaseProgress(displayId, spec.name, {
+      status: "completed",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    wtPlan.updatePhaseProgress(spec.name, "completed");
+    await commitPlanFiles(phaseCtx, wtGit, wtGitMap, spec.name, displayId);
+    await syncResultToIssue(phase, phaseCtx, displayId, spec.name, deps, issue.id, wtPlan);
+    return outcome;
+  }
+  if (outcome.status === "running") {
+    return outcome;
+  }
+  const errMsg = outcome.error?.message ?? "Unknown error";
+  const shortErr = errMsg.slice(0, 200);
+  wtPlan.updatePhaseProgress(spec.name, "failed", errMsg);
+  deps.tracker.updatePhaseProgress(displayId, spec.name, { status: "failed" });
+  deps.tracker.markFailed(displayId, errMsg, "phase_running" /* PhaseRunning */);
+  await safeComment(deps, issue.id, issueProgressComment(spec.name, "failed", shortErr));
+  throw new AIExecutionError(spec.name, `Phase ${spec.name} failed: ${shortErr}`, {
+    output: outcome.error?.rawOutput ?? outcome.output,
+    exitCode: outcome.exitCode ?? 1,
+    isRetryable: outcome.error?.isRetryable
+  });
+}
 async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
   const { issue, pipelineDef, lifecycleManager, record, isRetry, phaseCtx } = ctx;
   const startIdx = lifecycleManager.determineResumePhaseIndex(
@@ -3866,15 +3992,15 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     if (skippedDeployPhase && !phaseCtx.ports) {
       const existingPorts = deps.getPortsForIssue(issue.iid);
       if (existingPorts && deps.isPreviewRunning(issue.iid)) {
-        logger17.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
+        logger15.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
         phaseCtx.ports = existingPorts;
         ctx.wtCtx.ports = existingPorts;
         serversStarted = true;
       } else {
         if (existingPorts) {
-          logger17.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
+          logger15.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
         } else {
-          logger17.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+          logger15.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
         }
         const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
         if (ports) {
@@ -3885,6 +4011,44 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       }
     }
   }
+  if (startIdx > 0) {
+    const currentProgress = wtPlan.readProgress();
+    if (currentProgress) {
+      let patched = false;
+      for (let i = 0; i < startIdx; i++) {
+        const prevSpec = pipelineDef.phases[i];
+        const pp = currentProgress.phases[prevSpec.name];
+        if (pp && pp.status !== "completed") {
+          logger15.warn("Fixing stale phase progress", {
+            iid: issue.iid,
+            phase: prevSpec.name,
+            was: pp.status,
+            now: "completed"
+          });
+          pp.status = "completed";
+          if (!pp.completedAt) {
+            pp.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          }
+          patched = true;
+        }
+      }
+      if (patched) {
+        wtPlan.writeProgress(currentProgress);
+      }
+    }
+    if (record.phaseProgress) {
+      for (let i = 0; i < startIdx; i++) {
+        const prevSpec = pipelineDef.phases[i];
+        const tp = record.phaseProgress[prevSpec.name];
+        if (tp && tp.status !== "completed") {
+          deps.tracker.updatePhaseProgress(issue.iid, prevSpec.name, {
+            status: "completed",
+            completedAt: tp.completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+    }
+  }
   for (let i = startIdx; i < pipelineDef.phases.length; i++) {
     if (isShuttingDown()) {
       throw new ServiceShutdownError();
@@ -3896,7 +4060,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     }
     if (spec.kind === "gate") {
       if (deps.shouldAutoApprove(issue.labels)) {
-        logger17.info("Auto-approving review gate (matched autoApproveLabels)", {
+        logger15.info("Auto-approving review gate (matched autoApproveLabels)", {
           iid: issue.iid,
           labels: issue.labels,
           autoApproveLabels: deps.config.review.autoApproveLabels
@@ -3905,6 +4069,10 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
           deps.tracker.updateState(issue.iid, spec.approvedState, { currentPhase: spec.name });
         }
         wtPlan.updatePhaseProgress(spec.name, "completed");
+        deps.tracker.updatePhaseProgress(issue.iid, spec.name, {
+          status: "completed",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
         try {
           await deps.gongfeng.createIssueNote(
             issue.id,
@@ -3916,8 +4084,12 @@ 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.tracker.updatePhaseProgress(issue.iid, spec.name, {
+        status: "in_progress",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
       deps.eventBus.emitTyped("review:requested", { issueIid: issue.iid });
-      logger17.info("Review gate reached, pausing", { iid: issue.iid });
+      logger15.info("Review gate reached, pausing", { iid: issue.iid });
       return { serversStarted, paused: true };
     }
     if (spec.name === "verify" && deps.config.verifyFixLoop.enabled) {
@@ -3926,28 +4098,56 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       continue;
     }
     if (spec.name === "uat" && !isE2eEnabledForIssue(issue.iid, deps.tracker, deps.config)) {
-      logger17.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issue.iid });
+      logger15.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");
+      deps.tracker.updatePhaseProgress(issue.iid, spec.name, {
+        status: "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
       continue;
     }
-    const hooks = deps.buildPhaseHooks(issue.iid, issue.id);
     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";
-      logger17.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
+      logger15.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) {
+    const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
+    if (wtGitMap) {
       phase.setWtGitMap(wtGitMap);
     }
-    const result = await phase.execute(phaseCtx);
-    if (spec.approvedState && result && "gateRequested" in result && result.gateRequested) {
+    const outcome = await runPhaseWithLifecycle(
+      phase,
+      phaseCtx,
+      spec,
+      ctx,
+      deps,
+      wtGit,
+      wtPlan,
+      wtGitMap
+    );
+    if (outcome.status === "running") {
+      if (outcome.awaitCompletion) {
+        logger15.info("Async phase running, awaiting completion", { iid: issue.iid, phase: spec.name });
+        const finalOutcome = await awaitAsyncPhase(outcome, spec, ctx, deps, wtGit, wtPlan, wtGitMap);
+        if (finalOutcome.status === "completed") {
+          continue;
+        }
+      }
       deps.tracker.updateState(issue.iid, "phase_waiting" /* PhaseWaiting */, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "gate_waiting");
+      deps.tracker.updatePhaseProgress(issue.iid, spec.name, { status: "gate_waiting" });
       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 });
+      logger15.info("Async phase running (no awaitCompletion), pausing pipeline", { iid: issue.iid, phase: spec.name });
+      return { serversStarted, paused: true };
+    }
+    if (spec.approvedState && outcome.data?.hasReleaseCapability) {
+      deps.tracker.updateState(issue.iid, "phase_waiting" /* PhaseWaiting */, { currentPhase: spec.name });
+      wtPlan.updatePhaseProgress(spec.name, "gate_waiting");
+      deps.tracker.updatePhaseProgress(issue.iid, spec.name, { status: "gate_waiting" });
+      deps.eventBus.emitTyped("release:gateRequested", { issueIid: issue.iid });
+      logger15.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
       return { serversStarted, paused: true };
     }
     if (needsDeployment && !serversStarted && lifecycleManager.shouldDeployPreview(spec.name)) {
@@ -3961,6 +4161,40 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
   }
   return { serversStarted, paused: false };
 }
+async function awaitAsyncPhase(outcome, spec, ctx, deps, wtGit, wtPlan, wtGitMap) {
+  const { issue } = ctx;
+  const displayId = issue.iid;
+  const phaseCtx = ctx.phaseCtx;
+  const finalOutcome = await outcome.awaitCompletion;
+  if (finalOutcome.sessionId) {
+    wtPlan.updatePhaseSessionId(spec.name, finalOutcome.sessionId);
+  }
+  if (finalOutcome.status === "completed") {
+    deps.tracker.updateState(displayId, spec.doneState, { currentPhase: spec.name });
+    deps.tracker.updatePhaseProgress(displayId, spec.name, {
+      status: "completed",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    wtPlan.updatePhaseProgress(spec.name, "completed");
+    await commitPlanFiles(phaseCtx, wtGit, wtGitMap, spec.name, displayId);
+    const runner = spec.name === "uat" ? resolveUatRunner(deps, displayId) : deps.aiRunner;
+    const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
+    await syncResultToIssue(phase, phaseCtx, displayId, spec.name, deps, issue.id, wtPlan);
+    logger15.info("Async phase completed successfully", { iid: displayId, phase: spec.name });
+    return finalOutcome;
+  }
+  const errMsg = finalOutcome.error?.message ?? "Unknown error";
+  const shortErr = errMsg.slice(0, 200);
+  wtPlan.updatePhaseProgress(spec.name, "failed", errMsg);
+  deps.tracker.updatePhaseProgress(displayId, spec.name, { status: "failed" });
+  deps.tracker.markFailed(displayId, errMsg, "phase_running" /* PhaseRunning */);
+  await safeComment(deps, issue.id, issueProgressComment(spec.name, "failed", shortErr));
+  throw new AIExecutionError(spec.name, `Phase ${spec.name} failed: ${shortErr}`, {
+    output: finalOutcome.error?.rawOutput ?? finalOutcome.output,
+    exitCode: finalOutcome.exitCode ?? 1,
+    isRetryable: finalOutcome.error?.isRetryable
+  });
+}
 function findPreviousAiPhaseIndex(phases, currentIdx) {
   for (let j = currentIdx - 1; j >= 0; j--) {
     if (phases[j].kind === "ai") return j;
@@ -3970,11 +4204,12 @@ function findPreviousAiPhaseIndex(phases, currentIdx) {
 async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, buildPhaseIdx, wtGitMap) {
   const { issue, lifecycleManager, phaseCtx } = ctx;
   const maxIterations = deps.config.verifyFixLoop.maxIterations;
+  const verifySpec = ctx.pipelineDef.phases[verifyPhaseIdx];
   deps.eventBus.emitTyped("verify:loopStarted", {
     issueIid: issue.iid,
     maxIterations
   });
-  logger17.info("Verify-fix loop started", {
+  logger15.info("Verify-fix loop started", {
     iid: issue.iid,
     maxIterations,
     buildPhaseIdx
@@ -3983,30 +4218,30 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     if (isShuttingDown()) {
       throw new ServiceShutdownError();
     }
-    logger17.info("Verify-fix loop iteration", {
+    logger15.info("Verify-fix loop iteration", {
       iteration,
       maxIterations,
       iid: issue.iid
     });
-    const verifyHooks = deps.buildPhaseHooks(issue.iid, issue.id);
     const verifyRunner = resolveVerifyRunner(deps);
-    const verifyPhase = createPhase(
-      "verify",
-      verifyRunner,
-      wtGit,
-      wtPlan,
-      deps.config,
-      lifecycleManager,
-      verifyHooks
-    );
-    if (wtGitMap && wtGitMap.size > 1) {
+    const verifyPhase = createPhase("verify", verifyRunner, wtGit, wtPlan, deps.config);
+    if (wtGitMap) {
       verifyPhase.setWtGitMap(wtGitMap);
     }
-    let verifyResult;
+    let verifyOutcome;
     try {
-      verifyResult = await verifyPhase.execute(phaseCtx);
+      verifyOutcome = await runPhaseWithLifecycle(
+        verifyPhase,
+        phaseCtx,
+        verifySpec,
+        ctx,
+        deps,
+        wtGit,
+        wtPlan,
+        wtGitMap
+      );
     } catch (err) {
-      logger17.warn("Verify phase execution failed", {
+      logger15.warn("Verify phase execution failed", {
         iteration,
         iid: issue.iid,
         error: err.message
@@ -4029,7 +4264,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
       }
       continue;
     }
-    const report = verifyResult.verifyReport;
+    const report = verifyOutcome.data?.verifyReport;
     const passed = report ? report.passed : true;
     deps.eventBus.emitTyped("verify:iterationComplete", {
       issueIid: issue.iid,
@@ -4038,13 +4273,13 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
       failures: report?.failureReasons
     });
     if (passed) {
-      logger17.info("Verify-fix loop passed", {
+      logger15.info("Verify-fix loop passed", {
         iteration,
         iid: issue.iid
       });
       return;
     }
-    logger17.info("Verify failed, issues found", {
+    logger15.info("Verify failed, issues found", {
       iteration,
       iid: issue.iid,
       failures: report?.failureReasons,
@@ -4057,7 +4292,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"}`;
-      logger17.warn(failMsg, { iid: issue.iid });
+      logger15.warn(failMsg, { iid: issue.iid });
       throw new AIExecutionError("verify", failMsg, {
         output: report?.rawReport ?? "",
         exitCode: 0
@@ -4073,35 +4308,36 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
   }
 }
 async function executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixContext, wtGitMap) {
-  const { issue, lifecycleManager, phaseCtx } = ctx;
-  logger17.info("Looping back to build for fix", {
+  const { issue, phaseCtx } = ctx;
+  const buildSpec = ctx.pipelineDef.phases[buildPhaseIdx];
+  logger15.info("Looping back to build for fix", {
     iteration: fixContext.iteration,
     iid: issue.iid,
     failures: fixContext.verifyFailures
   });
   phaseCtx.fixContext = fixContext;
   try {
-    const buildHooks = deps.buildPhaseHooks(issue.iid, issue.id);
-    const buildPhase = createPhase(
-      "build",
-      deps.aiRunner,
+    const buildPhase = createPhase("build", deps.aiRunner, wtGit, wtPlan, deps.config);
+    if (wtGitMap) {
+      buildPhase.setWtGitMap(wtGitMap);
+    }
+    await runPhaseWithLifecycle(
+      buildPhase,
+      phaseCtx,
+      buildSpec,
+      ctx,
+      deps,
       wtGit,
       wtPlan,
-      deps.config,
-      lifecycleManager,
-      buildHooks
+      wtGitMap
     );
-    if (wtGitMap && wtGitMap.size > 1) {
-      buildPhase.setWtGitMap(wtGitMap);
-    }
-    await buildPhase.execute(phaseCtx);
   } finally {
     delete phaseCtx.fixContext;
   }
 }
 
 // src/orchestrator/steps/CompletionStep.ts
-var logger18 = logger.child("CompletionStep");
+var logger16 = logger.child("CompletionStep");
 async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
   const { issue, branchName, wtCtx } = ctx;
   deps.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
@@ -4133,7 +4369,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger18.warn("Failed to publish E2E screenshots", {
+      logger16.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -4153,19 +4389,19 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
     await deps.claimer.releaseClaim(issue.id, issue.iid, "completed");
   }
   if (phaseResult.serversStarted && deps.config.preview.keepAfterComplete) {
-    logger18.info("Preview servers kept running after completion", { iid: issue.iid });
+    logger16.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);
-        logger18.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
+        logger16.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
       } else {
         try {
           await deps.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-          logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+          logger16.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger18.warn("Failed to cleanup worktree", {
+          logger16.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -4173,15 +4409,15 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger18.info("Issue processing completed", { iid: issue.iid });
+  logger16.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger19 = logger.child("FailureHandler");
+var logger17 = logger.child("FailureHandler");
 async function handleFailure(err, issue, wtCtx, deps) {
   const errorMsg = err.message;
   const isRetryable = err instanceof AIExecutionError ? err.isRetryable : true;
-  logger19.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable });
+  logger17.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 */;
@@ -4190,11 +4426,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     deps.tracker.markFailed(issue.iid, errorMsg.slice(0, 500), failedAtState, isRetryable);
   }
   if (wasReset) {
-    logger19.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    logger17.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 });
+    logger17.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
     throw err;
   }
   try {
@@ -4216,7 +4452,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
     try {
       await deps.claimer.releaseClaim(issue.id, issue.iid, "failed");
     } catch (releaseErr) {
-      logger19.warn("Failed to release lock on failure", {
+      logger17.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -4224,7 +4460,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];
-  logger19.info("Worktree(s) preserved for debugging", {
+  logger17.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -4233,7 +4469,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger20 = logger.child("PipelineOrchestrator");
+var logger18 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -4263,7 +4499,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger20.info("AIRunner replaced via hot-reload");
+    logger18.info("AIRunner replaced via hot-reload");
   }
   constructor(config, gongfeng, git, aiRunner, tracker, supplementStore, mainGitMutex, eventBusInstance, wsConfig, tenantId, e2eAiRunner) {
     this.config = config;
@@ -4281,14 +4517,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);
-    logger20.info("Pipeline mode resolved", { tenantId: this.tenantId, mode: this.pipelineDef.mode, aiMode: config.ai.mode });
+    logger18.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 : path14.join(config.project.worktreeBaseDir, this.tenantId);
+    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path11.join(config.project.worktreeBaseDir, this.tenantId);
     const effectiveWsConfig = wsConfig ?? buildSingleRepoWorkspace(config.project, config.gongfeng.projectPath);
     this.workspaceManager = new WorkspaceManager({
       wsConfig: effectiveWsConfig,
@@ -4297,7 +4533,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger20.info("WorkspaceManager initialized", {
+    logger18.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -4318,7 +4554,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger20.info("Cleaning up stale worktree state...");
+    logger18.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -4327,11 +4563,11 @@ var PipelineOrchestrator = class {
         if (wtDir === repoGitRoot) continue;
         if (!wtDir.includes("/issue-")) continue;
         try {
-          const gitFile = path14.join(wtDir, ".git");
+          const gitFile = path11.join(wtDir, ".git");
           try {
-            await fs13.access(gitFile);
+            await fs9.access(gitFile);
           } catch {
-            logger20.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
+            logger18.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
             await this.mainGit.worktreeRemove(wtDir, true).catch(() => {
             });
             await this.mainGit.worktreePrune();
@@ -4340,32 +4576,32 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger20.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger18.warn("Aborting residual rebase in worktree", { dir: wtDir });
             await wtGit.rebaseAbort();
             cleaned++;
           }
-          const indexLock = path14.join(wtDir, ".git", "index.lock");
+          const indexLock = path11.join(wtDir, ".git", "index.lock");
           try {
-            await fs13.unlink(indexLock);
-            logger20.warn("Removed stale index.lock", { path: indexLock });
+            await fs9.unlink(indexLock);
+            logger18.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger20.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+          logger18.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
         }
       }
     } catch (err) {
-      logger20.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger18.warn("Failed to list worktrees for cleanup", { error: err.message });
     }
-    const mainIndexLock = path14.join(repoGitRoot, ".git", "index.lock");
+    const mainIndexLock = path11.join(repoGitRoot, ".git", "index.lock");
     try {
-      await fs13.unlink(mainIndexLock);
-      logger20.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      await fs9.unlink(mainIndexLock);
+      logger18.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger20.info("Stale state cleanup complete", { cleaned });
+    logger18.info("Stale state cleanup complete", { cleaned });
   }
   /**
    * 重启后清理幽灵端口分配。
@@ -4378,7 +4614,7 @@ var PipelineOrchestrator = class {
     for (const record of this.tracker.getAll()) {
       if (record.ports) {
         const iid = getIid(record);
-        logger20.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
+        logger18.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
         this.tracker.updateState(iid, record.state, {
           ports: void 0,
           previewStartedAt: void 0
@@ -4423,20 +4659,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger20.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger20.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger18.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
     }
   }
   async installDependencies(workDir) {
-    logger20.info("Installing dependencies in worktree", { workDir });
+    logger18.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) {
-        logger20.info("node_modules ready \u2014 skipping install");
+        logger18.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -4449,10 +4685,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger20.info("Dependencies installed");
+      logger18.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger20.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger18.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -4462,45 +4698,45 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger20.info("Dependencies installed (fallback)");
+          logger18.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger20.warn("Fallback install also failed", {
+          logger18.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger20.warn("Install failed, no fallback configured", {
+        logger18.warn("Install failed, no fallback configured", {
           error: err.message
         });
       }
     }
   }
   async ensureNodeModules(workDir) {
-    const targetBin = path14.join(workDir, "node_modules", ".bin");
+    const targetBin = path11.join(workDir, "node_modules", ".bin");
     try {
-      await fs13.access(targetBin);
-      logger20.info("node_modules already complete (has .bin/)");
+      await fs9.access(targetBin);
+      logger18.info("node_modules already complete (has .bin/)");
       return true;
     } catch {
     }
-    const sourceNM = path14.join(this.config.project.workDir, "node_modules");
-    const targetNM = path14.join(workDir, "node_modules");
+    const sourceNM = path11.join(this.config.project.workDir, "node_modules");
+    const targetNM = path11.join(workDir, "node_modules");
     try {
-      await fs13.access(sourceNM);
+      await fs9.access(sourceNM);
     } catch {
-      logger20.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger18.warn("Main repo node_modules not found, skipping seed", { sourceNM });
       return false;
     }
-    logger20.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
+    logger18.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
       });
-      logger20.info("node_modules seeded from main repo");
+      logger18.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger20.warn("Failed to seed node_modules from main repo", {
+      logger18.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -4510,17 +4746,20 @@ var PipelineOrchestrator = class {
     const record = this.tracker.get(issueIid);
     if (!record) throw new IssueNotFoundError(issueIid);
     const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
-    logger20.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    logger18.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    this.pendingActions.set(issueIid, "restart");
     this.aiRunner.killByWorkDir(wtCtx.workDir);
+    this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
     this.stopPreviewServers(issueIid);
     try {
       const deleted = await this.gongfeng.cleanupAgentNotes(getExternalId(record));
-      logger20.info("Agent notes cleaned up", { issueIid, deleted });
+      logger18.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger20.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger18.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
+      await this.cleanupWorkspaceRoot(issueIid);
       try {
         await this.mainGit.deleteBranch(record.branchName);
       } catch {
@@ -4530,23 +4769,26 @@ var PipelineOrchestrator = class {
       } catch {
       }
     });
+    await this.cleanupE2eOutputs(issueIid);
     this.tracker.resetFull(issueIid);
-    logger20.info("Issue restarted", { issueIid });
+    this.pendingActions.delete(issueIid);
+    logger18.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);
-    logger20.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
+    logger18.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) {
-      logger20.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
+      logger18.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
+      await this.cleanupWorkspaceRoot(issueIid);
       try {
         await this.mainGit.deleteBranch(record.branchName);
       } catch {
@@ -4556,8 +4798,40 @@ var PipelineOrchestrator = class {
       } catch {
       }
     });
+    this.tracker.clearProcessingLock(issueIid);
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
-    logger20.info("Issue cancelled", { issueIid });
+    await this.cleanupE2eOutputs(issueIid);
+    logger18.info("Issue cancelled", { issueIid });
+  }
+  /**
+   * Remove the E2E output directory for an issue: {uatVendorDir}/outputs/issue-{iid}
+   */
+  async cleanupE2eOutputs(issueIid) {
+    const vendorDir = this.config.e2e.uatVendorDir;
+    if (!vendorDir) return;
+    const abs = path11.isAbsolute(vendorDir) ? vendorDir : path11.resolve(this.config.project.workDir, vendorDir);
+    const outputDir = path11.join(abs, "outputs", `issue-${issueIid}`);
+    try {
+      await fs9.rm(outputDir, { recursive: true, force: true });
+      logger18.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
+    } catch (err) {
+      logger18.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
+    }
+  }
+  /**
+   * When WorkspaceManager is active, the workspace root (which contains
+   * associate repo clone dirs) may survive after cleanupWorktree removes
+   * only the primary worktree.  Force-remove the whole workspace root.
+   */
+  async cleanupWorkspaceRoot(issueIid) {
+    if (!this.workspaceManager) return;
+    const wsRoot = this.workspaceManager.getWorkspaceRoot(issueIid);
+    try {
+      await fs9.rm(wsRoot, { recursive: true, force: true });
+      logger18.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
+    } catch (err) {
+      logger18.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
+    }
   }
   retryFromPhase(issueIid, phase) {
     const record = this.tracker.get(issueIid);
@@ -4567,7 +4841,12 @@ var PipelineOrchestrator = class {
     if (!issueLM.isRetryable(phase)) {
       throw new InvalidPhaseError(phase);
     }
-    logger20.info("Retrying issue from phase", { issueIid, phase });
+    const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
+    if (!this.aiRunner.interruptByWorkDir?.(wtCtx.workDir)) {
+      this.aiRunner.killByWorkDir(wtCtx.workDir);
+    }
+    this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
+    logger18.info("Retrying issue from phase", { issueIid, phase });
     const ok = this.tracker.resetToPhase(issueIid, phase, issueDef);
     if (!ok) {
       throw new InvalidPhaseError(phase);
@@ -4594,7 +4873,7 @@ var PipelineOrchestrator = class {
     } else {
       this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
     }
-    logger20.info("Issue abort requested", { issueIid, state: record.state });
+    logger18.info("Issue abort requested", { issueIid, state: record.state });
   }
   continueIssue(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -4604,7 +4883,7 @@ var PipelineOrchestrator = class {
     }
     const issueDef = this.getIssueSpecificPipelineDef(record);
     this.tracker.resumeFromPause(issueIid, issueDef, false);
-    logger20.info("Issue continued from pause", { issueIid });
+    logger18.info("Issue continued from pause", { issueIid });
   }
   redoPhase(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -4630,6 +4909,12 @@ var PipelineOrchestrator = class {
       if (phase) {
         const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
         wtPlan.updatePhaseProgress(phase, "pending");
+        this.tracker.updatePhaseProgress(issueIid, phase, {
+          status: "pending",
+          startedAt: void 0,
+          completedAt: void 0,
+          error: void 0
+        });
       }
       this.tracker.resumeFromPause(issueIid, issueDef, true);
       this.eventBus.emitTyped("issue:redone", { issueIid });
@@ -4642,7 +4927,7 @@ var PipelineOrchestrator = class {
       }
       this.eventBus.emitTyped("issue:redone", { issueIid });
     }
-    logger20.info("Issue redo requested", { issueIid, state: record.state });
+    logger18.info("Issue redo requested", { issueIid, state: record.state });
   }
   /**
    * 处理中止/重做的共享逻辑：
@@ -4697,7 +4982,6 @@ var PipelineOrchestrator = class {
       emitProgress: (iid, step, msg) => this.emitProgress(iid, step, msg),
       ensureWorktree: (wtCtx) => this.ensureWorktree(wtCtx),
       installDependencies: (workDir) => this.installDependencies(workDir),
-      buildPhaseHooks: (iid, issueId) => this.buildPhaseHooks(iid, issueId),
       shouldAutoApprove: (labels) => this.shouldAutoApprove(labels),
       shouldDeployServers: (iid) => this.shouldDeployServers(iid),
       startPreviewServers: (wtCtx, issue) => this.startPreviewServers(wtCtx, issue),
@@ -4716,7 +5000,7 @@ var PipelineOrchestrator = class {
   async _processIssueImpl(issue) {
     const branchName = `${this.config.project.branchPrefix}-${issue.iid}`;
     const wtCtx = this.computeWorktreeContext(issue.iid, branchName);
-    logger20.info("Processing issue", {
+    logger18.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -4784,12 +5068,14 @@ var PipelineOrchestrator = class {
       await executeCompletion(ctx, deps, phaseResult, wtGitMap);
     } catch (err) {
       if (err instanceof PhaseAbortedError) {
+        if (err.action === "restart") return;
         this.applyPendingAction(err.action, issue.iid, wtCtx, issuePipelineDef);
         return;
       }
       const pendingAction = this.pendingActions.get(issue.iid);
       if (pendingAction) {
         this.pendingActions.delete(issue.iid);
+        if (pendingAction === "restart") return;
         this.applyPendingAction(pendingAction, issue.iid, wtCtx, issuePipelineDef);
         return;
       }
@@ -4821,7 +5107,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger20.info("Merge request created successfully", {
+      logger18.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -4829,7 +5115,7 @@ var PipelineOrchestrator = class {
       return { url: mr.web_url, iid: mr.iid };
     } catch (err) {
       const errorMsg = err.message;
-      logger20.warn("Failed to create merge request, trying to find existing one", {
+      logger18.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -4846,7 +5132,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger20.info("Found existing merge request", {
+        logger18.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -4854,7 +5140,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger20.warn("Failed to find existing merge request", {
+      logger18.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -4871,32 +5157,6 @@ var PipelineOrchestrator = class {
     if (!autoLabels.length) return false;
     return issueLabels.some((l) => autoLabels.includes(l));
   }
-  buildPhaseHooks(iid, issueId) {
-    return {
-      onPhaseStart: async (phase) => {
-        this.tracker.updateState(iid, "phase_running" /* PhaseRunning */, { currentPhase: phase });
-      },
-      onPhaseDone: async (phase) => {
-        this.tracker.updateState(iid, "phase_done" /* PhaseDone */, { currentPhase: phase });
-      },
-      onPhaseFailed: async (_phase, error) => {
-        this.tracker.markFailed(iid, error, "phase_running" /* PhaseRunning */);
-      },
-      onComment: async (msg) => {
-        try {
-          await this.gongfeng.createIssueNote(issueId, msg);
-        } 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)
-    };
-  }
   async startPreviewServers(wtCtx, issue) {
     try {
       this.emitProgress(issue.iid, "deploy", t("orchestrator.deployProgress"));
@@ -4925,7 +5185,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger20.error("Failed to start preview servers", {
+      logger18.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -4960,7 +5220,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
     });
-    logger20.info("Preview stopped and worktree cleaned", { iid: issueIid });
+    logger18.info("Preview stopped and worktree cleaned", { iid: issueIid });
   }
   async markDeployed(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -4977,7 +5237,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.closeIssue(externalId);
     } catch (err) {
-      logger20.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
+      logger18.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
     }
     try {
       const issue = await this.gongfeng.getIssueDetail(externalId);
@@ -4985,10 +5245,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) {
-      logger20.warn("Failed to update labels", { iid: issueIid, error: err.message });
+      logger18.warn("Failed to update labels", { iid: issueIid, error: err.message });
     }
     this.tracker.updateState(issueIid, "deployed" /* Deployed */);
-    logger20.info("Issue marked as deployed", { iid: issueIid });
+    logger18.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5015,7 +5275,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       throw err;
     }
     const url = this.buildPreviewUrl(issueIid);
-    logger20.info("Preview restarted", { iid: issueIid, url });
+    logger18.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -5048,7 +5308,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;
-    logger20.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
+    logger18.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
     this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
     this.eventBus.emitTyped("conflict:started", { issueIid });
     try {
@@ -5081,12 +5341,10 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger20.info("Running verification after conflict resolution", { issueIid });
+      logger18.info("Running verification after conflict resolution", { issueIid });
       const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
       wtPlan.ensureDir();
-      const conflictLM = createLifecycleManager(this.getIssueSpecificPipelineDef(record));
-      const conflictHooks = this.buildPhaseHooks(issueIid, getExternalId(record));
-      const verifyPhase = createPhase("verify", this.aiRunner, wtGit, wtPlan, this.config, conflictLM, conflictHooks);
+      const verifyPhase = createPhase("verify", this.aiRunner, wtGit, wtPlan, this.config);
       const verifyCtx = {
         demand: {
           demandId: `gf-${issueIid}`,
@@ -5102,7 +5360,14 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
         branchName,
         pipelineMode: record.pipelineMode
       };
-      await verifyPhase.execute(verifyCtx);
+      const verifyOutcome = await verifyPhase.run(verifyCtx);
+      if (verifyOutcome.status === "failed") {
+        const errMsg = verifyOutcome.error?.message ?? "Verification failed after conflict resolution";
+        throw new (await import("./errors-S3BWYA4I.js")).AIExecutionError("verify", errMsg, {
+          output: verifyOutcome.error?.rawOutput ?? verifyOutcome.output,
+          exitCode: verifyOutcome.exitCode ?? 1
+        });
+      }
       await wtGit.forcePush(branchName);
       this.tracker.updateState(issueIid, "completed" /* Completed */);
       this.eventBus.emitTyped("conflict:resolved", { issueIid });
@@ -5114,10 +5379,10 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       } catch {
       }
       await this.commentOnMr(record.mrUrl, t("conflict.mrResolvedComment"));
-      logger20.info("Conflict resolution completed", { issueIid });
+      logger18.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger20.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      logger18.error("Conflict resolution failed", { issueIid, error: errorMsg });
       try {
         const wtGit = new GitOperations(wtCtx.gitRootDir);
         if (await wtGit.isRebaseInProgress()) {
@@ -5147,7 +5412,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, body);
     } catch (err) {
-      logger20.warn("Failed to comment on MR", { mrIid, error: err.message });
+      logger18.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -5223,7 +5488,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger21 = logger.child("Brainstorm");
+var logger19 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -5259,7 +5524,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger21.info("Created brainstorm session", { sessionId: session.id });
+    logger19.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -5268,7 +5533,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger21.info("Generating SDD", { sessionId });
+    logger19.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5294,7 +5559,7 @@ var BrainstormService = class {
     const session = this.requireSession(sessionId);
     const roundNum = session.rounds.length + 1;
     session.status = "reviewing";
-    logger21.info("Reviewing SDD", { sessionId, round: roundNum });
+    logger19.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({
@@ -5327,7 +5592,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger21.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger19.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5388,9 +5653,6 @@ export {
   IssueState,
   IssueTracker,
   PlanPersistence,
-  getNoteSyncEnabled,
-  setNoteSyncOverride,
-  isNoteSyncEnabledForIssue,
   BasePhase,
   registerPhase,
   validatePhaseRegistry,
@@ -5409,7 +5671,10 @@ export {
   buildSingleRepoWorkspace,
   isMultiRepo,
   persistWorkspaceConfig,
+  getNoteSyncEnabled,
+  setNoteSyncOverride,
+  isNoteSyncEnabledForIssue,
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-5UPYA6KH.js.map
+//# sourceMappingURL=chunk-IP3QTP5A.js.map