@xdevops/issue-auto-finish 1.0.91 → 1.0.92

package/dist/{chunk-LDGK5NMS.js → chunk-WZGEYHCC.js}

@@ -4304,6 +4304,44 @@ async function executeSetup(ctx, deps) {
   return { wtGit, wtPlan, wtGitMap };
 }
 
+// src/lifecycle/FeedbackTypes.ts
+function inputRequestToFeedback(request) {
+  switch (request.type) {
+    case "interactive-dialog":
+      return {
+        kind: "interactive-dialog",
+        question: request.content,
+        options: request.options ?? []
+      };
+    case "plan-approval":
+      return { kind: "approval-required", scope: "plan" };
+    case "generic":
+      return { kind: "generic", content: request.content };
+  }
+}
+function feedbackResponseToString(response) {
+  switch (response.action) {
+    case "approve":
+      return "allow";
+    case "reject":
+      return "reject";
+    case "select":
+      return response.value;
+    case "dismiss":
+      return "";
+    case "pause":
+      return "";
+  }
+}
+function stringToFeedbackResponse(str, originalFeedback) {
+  if (str === "allow") return { action: "approve" };
+  if (str === "reject") return { action: "reject" };
+  if (str === "") {
+    return originalFeedback.kind === "interactive-dialog" ? { action: "dismiss" } : { action: "approve" };
+  }
+  return { action: "select", value: str };
+}
+
 // src/notesync/NoteSyncSettings.ts
 var noteSyncOverride;
 function getNoteSyncEnabled(cfg) {
@@ -4360,8 +4398,14 @@ function clearPendingDialog(issueIid) {
   store.delete(issueIid);
 }
 
-// src/orchestrator/steps/PhaseLoopStep.ts
-var logger17 = logger.child("PhaseLoopStep");
+// src/orchestrator/steps/PhaseHelpers.ts
+var logger17 = logger.child("PhaseHelpers");
+async function safeComment(deps, issueId, message) {
+  try {
+    await deps.gongfeng.createIssueNote(issueId, message);
+  } catch {
+  }
+}
 function resolveVerifyRunner(deps) {
   return deps.aiRunner;
 }
@@ -4434,18 +4478,6 @@ async function syncResultToIssue(phase, ctx, displayId, phaseName, deps, issueId
     await safeComment(deps, issueId, issueProgressComment(phaseName, "completed"));
   }
 }
-function buildInputHandler(displayId, phaseName, deps) {
-  const useAcpGate = deps.config.ai.codebuddyAcpAutoApprove === false;
-  return (request) => {
-    if (request.type === "interactive-dialog") {
-      return handleInteractiveDialog(displayId, phaseName, deps, request);
-    }
-    if (request.type === "plan-approval" && useAcpGate) {
-      return handlePlanApproval(displayId, phaseName, deps);
-    }
-    return Promise.resolve("allow");
-  };
-}
 function handlePlanApproval(displayId, phaseName, deps) {
   logger17.info("ACP plan-approval requested, delegating to review gate", {
     issueIid: displayId,
@@ -4546,39 +4578,69 @@ function updateHooksForPhase(spec, pipelineDef, ctx, wtPlan) {
     });
   }
 }
-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", {
+
+// src/lifecycle/DefaultLifecycleHook.ts
+var logger18 = logger.child("DefaultLifecycleHook");
+var DefaultLifecycleHook = class {
+  async beforePhase(ctx) {
+    const { spec, issueCtx, deps, wtPlan } = ctx;
+    const { issue } = issueCtx;
+    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()
+      }
+    });
+  }
+  onStream(ctx, event) {
+    const { spec, issueCtx, deps } = ctx;
+    deps.eventBus.emitTyped("agent:output", {
+      issueIid: issueCtx.issue.iid,
+      phase: spec.name,
       event
-    }),
-    onInputRequired: buildInputHandler(displayId, spec.name, deps)
-  };
-  const outcome = await phase.run(phaseCtx, callbacks);
-  if (outcome.sessionId) wtPlan.updatePhaseSessionId(spec.name, outcome.sessionId);
-  if (outcome.status === "completed") {
+    });
+  }
+  beforeExecute;
+  afterExecute;
+  async onFeedback(ctx, feedback) {
+    const { deps, displayId, spec } = ctx;
+    if (feedback.kind === "interactive-dialog") {
+      const result = await handleInteractiveDialog(displayId, spec.name, deps, {
+        type: "interactive-dialog",
+        content: feedback.question,
+        options: feedback.options
+      });
+      return stringToFeedbackResponse(result, feedback);
+    }
+    if (feedback.kind === "approval-required" && feedback.scope === "plan") {
+      const useAcpGate = deps.config.ai.codebuddyAcpAutoApprove === false;
+      if (useAcpGate) {
+        const result = await handlePlanApproval(displayId, spec.name, deps);
+        return result === "allow" ? { action: "approve" } : { action: "reject" };
+      }
+      return { action: "approve" };
+    }
+    return { action: "approve" };
+  }
+  async afterPhase(ctx, outcome) {
+    const { spec, issueCtx, deps, wtGit, wtPlan, wtGitMap, phase } = ctx;
+    const { issue, phaseCtx } = issueCtx;
+    const displayId = issue.iid;
+    if (outcome.sessionId) {
+      wtPlan.updatePhaseSessionId(spec.name, outcome.sessionId);
+    }
     deps.tracker.updateState(displayId, spec.doneState, { currentPhase: spec.name });
     deps.tracker.updatePhaseProgress(displayId, spec.name, {
       status: "completed",
@@ -4586,28 +4648,400 @@ async function runPhaseWithLifecycle(phase, phaseCtx, spec, ctx, deps, wtGit, wt
     });
     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 (phase) {
+      await syncResultToIssue(phase, phaseCtx, displayId, spec.name, deps, issue.id, wtPlan);
+    }
+  }
+  async onError(ctx, error) {
+    const { spec, issueCtx, deps, wtPlan } = ctx;
+    const { issue } = issueCtx;
+    const displayId = issue.iid;
+    wtPlan.updatePhaseProgress(spec.name, "failed", error.message);
+    deps.tracker.updatePhaseProgress(displayId, spec.name, { status: "failed" });
+    if (error.wasActiveAtTimeout) {
+      deps.tracker.markFailedSoft(displayId, error.message, "phase_running" /* PhaseRunning */);
+    } else {
+      deps.tracker.markFailed(displayId, error.message, "phase_running" /* PhaseRunning */);
+    }
+    const shortErr = error.message.slice(0, 200);
+    await safeComment(deps, issue.id, issueProgressComment(spec.name, "failed", shortErr));
+    return { action: "fail", softFail: error.wasActiveAtTimeout };
   }
-  if (outcome.status === "running") {
-    return outcome;
+};
+function createCallbacksFromHook(hook, ctx) {
+  return {
+    onStreamEvent: hook.onStream ? (event) => hook.onStream(ctx, event) : void 0,
+    onInputRequired: hook.onFeedback ? async (request) => {
+      const feedback = inputRequestToFeedback(request);
+      const response = await hook.onFeedback(ctx, feedback);
+      return feedbackResponseToString(response);
+    } : void 0
+  };
+}
+
+// src/orchestrator/strategies/GateStrategy.ts
+var logger19 = logger.child("GateStrategy");
+var GateStrategy = class {
+  name = "gate";
+  shouldSkip() {
+    return false;
   }
-  const errMsg = outcome.error?.message ?? "Unknown error";
-  const shortErr = errMsg.slice(0, 200);
-  const wasActive = outcome.error?.wasActiveAtTimeout ?? false;
-  wtPlan.updatePhaseProgress(spec.name, "failed", errMsg);
-  deps.tracker.updatePhaseProgress(displayId, spec.name, { status: "failed" });
-  if (wasActive) {
-    deps.tracker.markFailedSoft(displayId, errMsg, "phase_running" /* PhaseRunning */);
-  } else {
-    deps.tracker.markFailed(displayId, errMsg, "phase_running" /* PhaseRunning */);
+  async execute(ctx, _hooks) {
+    const { spec, issueCtx, deps, wtPlan } = ctx;
+    const { issue } = issueCtx;
+    if (deps.shouldAutoApprove(issue.labels)) {
+      logger19.info("Auto-approving review gate (matched autoApproveLabels)", {
+        iid: issue.iid,
+        labels: issue.labels,
+        autoApproveLabels: deps.config.review.autoApproveLabels
+      });
+      if (spec.approvedState) {
+        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, t("orchestrator.autoApproveComment"));
+      } catch {
+      }
+      return { paused: false };
+    }
+    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 });
+    logger19.info("Review gate reached, pausing", { iid: issue.iid });
+    return { paused: true };
+  }
+};
+
+// src/orchestrator/strategies/AiPhaseStrategy.ts
+var logger20 = logger.child("AiPhaseStrategy");
+var AiPhaseStrategy = class {
+  name = "ai";
+  shouldSkip(ctx) {
+    const { spec, issueCtx, deps } = ctx;
+    if (spec.name === "uat" && !isE2eEnabledForIssue(issueCtx.issue.iid, deps.tracker, deps.config)) {
+      logger20.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issueCtx.issue.iid });
+      return true;
+    }
+    return false;
+  }
+  async execute(ctx, hooks) {
+    const { spec, issueCtx, deps, wtGit, wtPlan, wtGitMap } = ctx;
+    const { issue, phaseCtx } = issueCtx;
+    if (this.shouldSkip(ctx)) {
+      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()
+      });
+      return { paused: false };
+    }
+    updateHooksForPhase(spec, issueCtx.pipelineDef, issueCtx, wtPlan);
+    const runner = this.resolveRunner(ctx);
+    if (spec.name === "uat") {
+      const runnerName = runner === deps.e2eAiRunner ? "e2eAiRunner (CodeBuddy)" : "mainRunner";
+      logger20.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
+    }
+    const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
+    if (wtGitMap) phase.setWtGitMap(wtGitMap);
+    ctx.phase = phase;
+    const outcome = await runPhaseWithLifecycle(
+      phase,
+      phaseCtx,
+      spec,
+      issueCtx,
+      deps,
+      wtGit,
+      wtPlan,
+      wtGitMap,
+      hooks
+    );
+    if (outcome.status === "running") {
+      return this.handleAsyncOutcome(ctx, outcome);
+    }
+    if (spec.approvedState && outcome.data?.hasReleaseCapability) {
+      return this.handleGateRequest(ctx);
+    }
+    return { paused: false };
+  }
+  resolveRunner(ctx) {
+    const { spec, deps, displayId } = ctx;
+    if (spec.name === "verify") return resolveVerifyRunner(deps);
+    if (spec.name === "uat") return resolveUatRunner(deps, displayId);
+    return deps.aiRunner;
+  }
+  async handleAsyncOutcome(ctx, outcome) {
+    const { spec, issueCtx, deps, wtGit, wtPlan, wtGitMap } = ctx;
+    const { issue, phaseCtx } = issueCtx;
+    if (outcome.awaitCompletion) {
+      logger20.info("Async phase running, awaiting completion", { iid: issue.iid, phase: spec.name });
+      const finalOutcome = await outcome.awaitCompletion;
+      if (finalOutcome.sessionId) {
+        wtPlan.updatePhaseSessionId(spec.name, finalOutcome.sessionId);
+      }
+      if (finalOutcome.status === "completed") {
+        deps.tracker.updateState(issue.iid, spec.doneState, { currentPhase: spec.name });
+        deps.tracker.updatePhaseProgress(issue.iid, spec.name, {
+          status: "completed",
+          completedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        wtPlan.updatePhaseProgress(spec.name, "completed");
+        await commitPlanFiles(phaseCtx, wtGit, wtGitMap, spec.name, issue.iid);
+        const runner = this.resolveRunner(ctx);
+        const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
+        await syncResultToIssue(phase, phaseCtx, issue.iid, spec.name, deps, issue.id, wtPlan);
+        logger20.info("Async phase completed successfully", { iid: issue.iid, phase: spec.name });
+        return { paused: false };
+      }
+      const errMsg = finalOutcome.error?.message ?? "Unknown error";
+      const shortErr = errMsg.slice(0, 200);
+      const wasActive = finalOutcome.error?.wasActiveAtTimeout ?? false;
+      wtPlan.updatePhaseProgress(spec.name, "failed", errMsg);
+      deps.tracker.updatePhaseProgress(issue.iid, spec.name, { status: "failed" });
+      if (wasActive) {
+        deps.tracker.markFailedSoft(issue.iid, errMsg, "phase_running" /* PhaseRunning */);
+      } else {
+        deps.tracker.markFailed(issue.iid, 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,
+        wasActiveAtTimeout: wasActive
+      });
+    }
+    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 });
+    logger20.info("Async phase running (no awaitCompletion), pausing pipeline", {
+      iid: issue.iid,
+      phase: spec.name
+    });
+    return { paused: true };
+  }
+  handleGateRequest(ctx) {
+    const { spec, issueCtx, deps, wtPlan } = ctx;
+    const { issue } = issueCtx;
+    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 });
+    logger20.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
+    return { paused: true };
+  }
+};
+
+// src/orchestrator/strategies/VerifyFixStrategy.ts
+var logger21 = logger.child("VerifyFixStrategy");
+var VerifyFixStrategy = class {
+  name = "verify-fix";
+  shouldSkip() {
+    return false;
+  }
+  async execute(ctx, hooks) {
+    const { issueCtx, deps, wtGit, wtPlan, wtGitMap } = ctx;
+    const { issue, phaseCtx, pipelineDef } = issueCtx;
+    const maxIterations = deps.config.verifyFixLoop.maxIterations;
+    const verifySpec = ctx.spec;
+    const verifyPhaseIdx = pipelineDef.phases.findIndex((p) => p.name === verifySpec.name);
+    const buildPhaseIdx = this.findPreviousAiPhaseIndex(pipelineDef.phases, verifyPhaseIdx);
+    deps.eventBus.emitTyped("verify:loopStarted", {
+      issueIid: issue.iid,
+      maxIterations
+    });
+    logger21.info("Verify-fix loop started", {
+      iid: issue.iid,
+      maxIterations,
+      buildPhaseIdx
+    });
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+      if (isShuttingDown()) throw new ServiceShutdownError();
+      logger21.info("Verify-fix loop iteration", { iteration, maxIterations, iid: issue.iid });
+      updateHooksForPhase(verifySpec, pipelineDef, issueCtx, wtPlan);
+      const verifyRunner = resolveVerifyRunner(deps);
+      const verifyPhase = createPhase("verify", verifyRunner, wtGit, wtPlan, deps.config);
+      if (wtGitMap) verifyPhase.setWtGitMap(wtGitMap);
+      let verifyOutcome;
+      try {
+        verifyOutcome = await runPhaseWithLifecycle(
+          verifyPhase,
+          phaseCtx,
+          verifySpec,
+          issueCtx,
+          deps,
+          wtGit,
+          wtPlan,
+          wtGitMap,
+          hooks
+        );
+      } catch (err) {
+        logger21.warn("Verify phase execution failed", {
+          iteration,
+          iid: issue.iid,
+          error: err.message
+        });
+        deps.eventBus.emitTyped("verify:iterationComplete", {
+          issueIid: issue.iid,
+          iteration,
+          passed: false,
+          failures: ["AI runner execution failed"]
+        });
+        if (iteration === maxIterations) throw err;
+        if (buildPhaseIdx >= 0) {
+          await this.executeBuildFix(issueCtx, deps, wtGit, wtPlan, buildPhaseIdx, {
+            iteration,
+            verifyFailures: ["AI runner execution failed: " + err.message],
+            rawReport: ""
+          }, wtGitMap, hooks);
+        }
+        continue;
+      }
+      const report = verifyOutcome.data?.verifyReport;
+      const passed = report ? report.passed : true;
+      deps.eventBus.emitTyped("verify:iterationComplete", {
+        issueIid: issue.iid,
+        iteration,
+        passed,
+        failures: report?.failureReasons
+      });
+      if (passed) {
+        logger21.info("Verify-fix loop passed", { iteration, iid: issue.iid });
+        return { paused: false };
+      }
+      logger21.info("Verify failed, issues found", {
+        iteration,
+        iid: issue.iid,
+        failures: report?.failureReasons,
+        todolistStats: report?.todolistStats
+      });
+      if (iteration === maxIterations) {
+        deps.eventBus.emitTyped("verify:loopExhausted", {
+          issueIid: issue.iid,
+          totalIterations: iteration,
+          failures: report?.failureReasons ?? []
+        });
+        const failMsg = `Verify-fix loop exhausted after ${maxIterations} iterations. Remaining issues: ${report?.failureReasons?.join("; ") ?? "unknown"}`;
+        logger21.warn(failMsg, { iid: issue.iid });
+        throw new AIExecutionError("verify", failMsg, {
+          output: report?.rawReport ?? "",
+          exitCode: 0
+        });
+      }
+      if (buildPhaseIdx >= 0) {
+        await this.executeBuildFix(issueCtx, deps, wtGit, wtPlan, buildPhaseIdx, {
+          iteration,
+          verifyFailures: report?.failureReasons ?? [],
+          rawReport: report?.rawReport ?? ""
+        }, wtGitMap, hooks);
+      }
+    }
+    return { paused: false };
+  }
+  async executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixContext, wtGitMap, hooks) {
+    const { issue, phaseCtx, pipelineDef } = ctx;
+    const buildSpec = pipelineDef.phases[buildPhaseIdx];
+    logger21.info("Looping back to build for fix", {
+      iteration: fixContext.iteration,
+      iid: issue.iid,
+      failures: fixContext.verifyFailures
+    });
+    phaseCtx.fixContext = fixContext;
+    try {
+      updateHooksForPhase(buildSpec, pipelineDef, ctx, wtPlan);
+      const buildPhase = createPhase("build", deps.aiRunner, wtGit, wtPlan, deps.config);
+      if (wtGitMap) buildPhase.setWtGitMap(wtGitMap);
+      await runPhaseWithLifecycle(
+        buildPhase,
+        phaseCtx,
+        buildSpec,
+        ctx,
+        deps,
+        wtGit,
+        wtPlan,
+        wtGitMap,
+        hooks
+      );
+    } finally {
+      delete phaseCtx.fixContext;
+    }
   }
-  await safeComment(deps, issue.id, issueProgressComment(spec.name, "failed", shortErr));
+  findPreviousAiPhaseIndex(phases, currentIdx) {
+    for (let j = currentIdx - 1; j >= 0; j--) {
+      if (phases[j].kind === "ai") return j;
+    }
+    return -1;
+  }
+};
+
+// src/orchestrator/strategies/index.ts
+var gateStrategy = new GateStrategy();
+var aiStrategy = new AiPhaseStrategy();
+var verifyFixStrategy = new VerifyFixStrategy();
+function resolveStrategy(spec, config) {
+  if (spec.kind === "gate") {
+    return gateStrategy;
+  }
+  if (spec.name === "verify" && config.verifyFixLoop.enabled) {
+    return verifyFixStrategy;
+  }
+  return aiStrategy;
+}
+
+// src/orchestrator/steps/PhaseLoopStep.ts
+var logger22 = logger.child("PhaseLoopStep");
+async function runPhaseWithLifecycle(phase, phaseCtx, spec, ctx, deps, wtGit, wtPlan, wtGitMap, hook) {
+  const lifecycleHook = hook ?? new DefaultLifecycleHook();
+  const execCtx = {
+    spec,
+    issueCtx: ctx,
+    deps,
+    wtGit,
+    wtPlan,
+    wtGitMap,
+    phase,
+    displayId: ctx.issue.iid
+  };
+  await lifecycleHook.beforePhase(execCtx);
+  if (lifecycleHook.beforeExecute) {
+    await lifecycleHook.beforeExecute(execCtx);
+  }
+  const callbacks = createCallbacksFromHook(lifecycleHook, execCtx);
+  const outcome = await phase.run(phaseCtx, callbacks);
+  if (outcome.sessionId) wtPlan.updatePhaseSessionId(spec.name, outcome.sessionId);
+  const finalOutcome = lifecycleHook.afterExecute ? await lifecycleHook.afterExecute(execCtx, outcome) : outcome;
+  if (finalOutcome.status === "completed") {
+    await lifecycleHook.afterPhase(execCtx, finalOutcome);
+    return finalOutcome;
+  }
+  if (finalOutcome.status === "running") {
+    return finalOutcome;
+  }
+  const errMsg = finalOutcome.error?.message ?? "Unknown error";
+  const phaseError = {
+    message: errMsg,
+    isRetryable: finalOutcome.error?.isRetryable ?? true,
+    rawOutput: finalOutcome.error?.rawOutput ?? finalOutcome.output,
+    wasActiveAtTimeout: finalOutcome.error?.wasActiveAtTimeout ?? false
+  };
+  await lifecycleHook.onError(execCtx, phaseError);
+  const shortErr = errMsg.slice(0, 200);
   throw new AIExecutionError(spec.name, `Phase ${spec.name} failed: ${shortErr}`, {
-    output: outcome.error?.rawOutput ?? outcome.output,
-    exitCode: outcome.exitCode ?? 1,
-    isRetryable: outcome.error?.isRetryable,
-    wasActiveAtTimeout: wasActive
+    output: finalOutcome.error?.rawOutput ?? finalOutcome.output,
+    exitCode: finalOutcome.exitCode ?? 1,
+    isRetryable: finalOutcome.error?.isRetryable,
+    wasActiveAtTimeout: finalOutcome.error?.wasActiveAtTimeout ?? false
   });
 }
 async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
@@ -4631,15 +5065,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 });
+        logger22.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 });
+          logger22.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
         } else {
-          logger17.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+          logger22.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
         }
         const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
         if (ports) {
@@ -4651,93 +5085,25 @@ 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") {
-          logger17.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()
-          });
-        }
-      }
-    }
+    healStaleProgress(ctx, deps, wtPlan, startIdx);
   }
+  const hooks = new DefaultLifecycleHook();
   for (let i = startIdx; i < pipelineDef.phases.length; i++) {
-    if (isShuttingDown()) {
-      throw new ServiceShutdownError();
-    }
+    if (isShuttingDown()) throw new ServiceShutdownError();
     const spec = pipelineDef.phases[i];
     const pendingAction = deps.consumePendingAction?.(issue.iid);
-    if (pendingAction) {
-      throw new PhaseAbortedError(spec.name, pendingAction);
-    }
-    if (spec.kind === "gate") {
-      if (deps.shouldAutoApprove(issue.labels)) {
-        logger17.info("Auto-approving review gate (matched autoApproveLabels)", {
-          iid: issue.iid,
-          labels: issue.labels,
-          autoApproveLabels: deps.config.review.autoApproveLabels
-        });
-        if (spec.approvedState) {
-          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,
-            t("orchestrator.autoApproveComment")
-          );
-        } catch {
-        }
-        continue;
-      }
-      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 });
-      return { serversStarted, paused: true };
-    }
-    if (spec.name === "verify" && deps.config.verifyFixLoop.enabled) {
-      const buildIdx = findPreviousAiPhaseIndex(pipelineDef.phases, i);
-      await executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, i, buildIdx, 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 });
+    if (pendingAction) throw new PhaseAbortedError(spec.name, pendingAction);
+    const strategy = resolveStrategy(spec, deps.config);
+    const execCtx = {
+      spec,
+      issueCtx: ctx,
+      deps,
+      wtGit,
+      wtPlan,
+      wtGitMap,
+      displayId: issue.iid
+    };
+    if (strategy.shouldSkip(execCtx)) {
       deps.tracker.updateState(issue.iid, spec.doneState, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "completed");
       deps.tracker.updatePhaseProgress(issue.iid, spec.name, {
@@ -4746,49 +5112,12 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       });
       continue;
     }
-    updateHooksForPhase(spec, pipelineDef, ctx, wtPlan);
-    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 });
-    }
-    const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
-    if (wtGitMap) {
-      phase.setWtGitMap(wtGitMap);
-    }
-    const outcome = await runPhaseWithLifecycle(
-      phase,
-      phaseCtx,
-      spec,
-      ctx,
-      deps,
-      wtGit,
-      wtPlan,
-      wtGitMap
-    );
-    if (outcome.status === "running") {
-      if (outcome.awaitCompletion) {
-        logger17.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("Async phase running (no awaitCompletion), pausing pipeline", { iid: issue.iid, phase: spec.name });
-      return { serversStarted, paused: true };
+    const result = await strategy.execute(execCtx, hooks);
+    if (result.paused) {
+      return { serversStarted: serversStarted || !!result.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 });
-      logger17.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
-      return { serversStarted, paused: true };
+    if (result.serversStarted) {
+      serversStarted = true;
     }
     if (needsDeployment && !serversStarted && lifecycleManager.shouldDeployPreview(spec.name)) {
       const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
@@ -4801,191 +5130,48 @@ 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);
-    logger17.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);
-  const wasActive = finalOutcome.error?.wasActiveAtTimeout ?? false;
-  wtPlan.updatePhaseProgress(spec.name, "failed", errMsg);
-  deps.tracker.updatePhaseProgress(displayId, spec.name, { status: "failed" });
-  if (wasActive) {
-    deps.tracker.markFailedSoft(displayId, errMsg, "phase_running" /* PhaseRunning */);
-  } else {
-    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,
-    wasActiveAtTimeout: wasActive
-  });
-}
-function findPreviousAiPhaseIndex(phases, currentIdx) {
-  for (let j = currentIdx - 1; j >= 0; j--) {
-    if (phases[j].kind === "ai") return j;
-  }
-  return -1;
-}
-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", {
-    iid: issue.iid,
-    maxIterations,
-    buildPhaseIdx
-  });
-  for (let iteration = 1; iteration <= maxIterations; iteration++) {
-    if (isShuttingDown()) {
-      throw new ServiceShutdownError();
-    }
-    logger17.info("Verify-fix loop iteration", {
-      iteration,
-      maxIterations,
-      iid: issue.iid
-    });
-    updateHooksForPhase(verifySpec, ctx.pipelineDef, ctx, wtPlan);
-    const verifyRunner = resolveVerifyRunner(deps);
-    const verifyPhase = createPhase("verify", verifyRunner, wtGit, wtPlan, deps.config);
-    if (wtGitMap) {
-      verifyPhase.setWtGitMap(wtGitMap);
-    }
-    let verifyOutcome;
-    try {
-      verifyOutcome = await runPhaseWithLifecycle(
-        verifyPhase,
-        phaseCtx,
-        verifySpec,
-        ctx,
-        deps,
-        wtGit,
-        wtPlan,
-        wtGitMap
-      );
-    } catch (err) {
-      logger17.warn("Verify phase execution failed", {
-        iteration,
-        iid: issue.iid,
-        error: err.message
-      });
-      deps.eventBus.emitTyped("verify:iterationComplete", {
-        issueIid: issue.iid,
-        iteration,
-        passed: false,
-        failures: ["AI runner execution failed"]
-      });
-      if (iteration === maxIterations) {
-        throw err;
-      }
-      if (buildPhaseIdx >= 0) {
-        await executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, {
-          iteration,
-          verifyFailures: ["AI runner execution failed: " + err.message],
-          rawReport: ""
-        }, wtGitMap);
+function healStaleProgress(ctx, deps, wtPlan, startIdx) {
+  const { issue, pipelineDef, record } = ctx;
+  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") {
+        logger22.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;
       }
-      continue;
-    }
-    const report = verifyOutcome.data?.verifyReport;
-    const passed = report ? report.passed : true;
-    deps.eventBus.emitTyped("verify:iterationComplete", {
-      issueIid: issue.iid,
-      iteration,
-      passed,
-      failures: report?.failureReasons
-    });
-    if (passed) {
-      logger17.info("Verify-fix loop passed", {
-        iteration,
-        iid: issue.iid
-      });
-      return;
-    }
-    logger17.info("Verify failed, issues found", {
-      iteration,
-      iid: issue.iid,
-      failures: report?.failureReasons,
-      todolistStats: report?.todolistStats
-    });
-    if (iteration === maxIterations) {
-      deps.eventBus.emitTyped("verify:loopExhausted", {
-        issueIid: issue.iid,
-        totalIterations: iteration,
-        failures: report?.failureReasons ?? []
-      });
-      const failMsg = `Verify-fix loop exhausted after ${maxIterations} iterations. Remaining issues: ${report?.failureReasons?.join("; ") ?? "unknown"}`;
-      logger17.warn(failMsg, { iid: issue.iid });
-      throw new AIExecutionError("verify", failMsg, {
-        output: report?.rawReport ?? "",
-        exitCode: 0
-      });
     }
-    if (buildPhaseIdx >= 0) {
-      await executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, {
-        iteration,
-        verifyFailures: report?.failureReasons ?? [],
-        rawReport: report?.rawReport ?? ""
-      }, wtGitMap);
+    if (patched) {
+      wtPlan.writeProgress(currentProgress);
     }
   }
-}
-async function executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixContext, wtGitMap) {
-  const { issue, phaseCtx } = ctx;
-  const buildSpec = ctx.pipelineDef.phases[buildPhaseIdx];
-  logger17.info("Looping back to build for fix", {
-    iteration: fixContext.iteration,
-    iid: issue.iid,
-    failures: fixContext.verifyFailures
-  });
-  phaseCtx.fixContext = fixContext;
-  try {
-    updateHooksForPhase(buildSpec, ctx.pipelineDef, ctx, wtPlan);
-    const buildPhase = createPhase("build", deps.aiRunner, wtGit, wtPlan, deps.config);
-    if (wtGitMap) {
-      buildPhase.setWtGitMap(wtGitMap);
+  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()
+        });
+      }
     }
-    await runPhaseWithLifecycle(
-      buildPhase,
-      phaseCtx,
-      buildSpec,
-      ctx,
-      deps,
-      wtGit,
-      wtPlan,
-      wtGitMap
-    );
-  } finally {
-    delete phaseCtx.fixContext;
   }
 }
 
 // src/orchestrator/steps/CompletionStep.ts
-var logger18 = logger.child("CompletionStep");
+var logger23 = logger.child("CompletionStep");
 async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
   const { issue, branchName, wtCtx } = ctx;
   deps.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
@@ -5017,7 +5203,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger18.warn("Failed to publish E2E screenshots", {
+      logger23.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -5037,19 +5223,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 });
+    logger23.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 });
+        logger23.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 });
+          logger23.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger18.warn("Failed to cleanup worktree", {
+          logger23.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -5057,16 +5243,16 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger18.info("Issue processing completed", { iid: issue.iid });
+  logger23.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger19 = logger.child("FailureHandler");
+var logger24 = logger.child("FailureHandler");
 async function handleFailure(err, issue, wtCtx, deps) {
   const errorMsg = err.message;
   const isRetryable = err instanceof AIExecutionError ? err.isRetryable : true;
   const wasActiveAtTimeout = err instanceof AIExecutionError && err.wasActiveAtTimeout;
-  logger19.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable, wasActiveAtTimeout });
+  logger24.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable, wasActiveAtTimeout });
   metrics.incCounter("iaf_issues_failed_total");
   const currentRecord = deps.tracker.get(issue.iid);
   const failedAtState = currentRecord?.state || "pending" /* Pending */;
@@ -5079,11 +5265,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     }
   }
   if (wasReset) {
-    logger19.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    logger24.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 });
+    logger24.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
     throw err;
   }
   try {
@@ -5105,7 +5291,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", {
+      logger24.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -5113,7 +5299,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", {
+  logger24.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -5122,7 +5308,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger20 = logger.child("PipelineOrchestrator");
+var logger25 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -5152,7 +5338,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger20.info("AIRunner replaced via hot-reload");
+    logger25.info("AIRunner replaced via hot-reload");
   }
   constructor(config, gongfeng, git, aiRunner, tracker, supplementStore, mainGitMutex, eventBusInstance, wsConfig, tenantId, e2eAiRunner) {
     this.config = config;
@@ -5170,7 +5356,7 @@ 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 });
+    logger25.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
@@ -5186,7 +5372,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger20.info("WorkspaceManager initialized", {
+    logger25.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -5207,7 +5393,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger20.info("Cleaning up stale worktree state...");
+    logger25.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -5220,7 +5406,7 @@ var PipelineOrchestrator = class {
           try {
             await fs11.access(gitFile);
           } catch {
-            logger20.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
+            logger25.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
             await this.mainGit.worktreeRemove(wtDir, true).catch(() => {
             });
             await this.mainGit.worktreePrune();
@@ -5229,32 +5415,32 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger20.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger25.warn("Aborting residual rebase in worktree", { dir: wtDir });
             await wtGit.rebaseAbort();
             cleaned++;
           }
           const indexLock = path12.join(wtDir, ".git", "index.lock");
           try {
             await fs11.unlink(indexLock);
-            logger20.warn("Removed stale index.lock", { path: indexLock });
+            logger25.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger20.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+          logger25.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
         }
       }
     } catch (err) {
-      logger20.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger25.warn("Failed to list worktrees for cleanup", { error: err.message });
     }
     const mainIndexLock = path12.join(repoGitRoot, ".git", "index.lock");
     try {
       await fs11.unlink(mainIndexLock);
-      logger20.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      logger25.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger20.info("Stale state cleanup complete", { cleaned });
+    logger25.info("Stale state cleanup complete", { cleaned });
   }
   /**
    * 重启后清理幽灵端口分配。
@@ -5267,7 +5453,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 });
+        logger25.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
         this.tracker.updateState(iid, record.state, {
           ports: void 0,
           previewStartedAt: void 0
@@ -5312,20 +5498,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger20.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger25.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger20.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger25.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
     }
   }
   async installDependencies(workDir) {
-    logger20.info("Installing dependencies in worktree", { workDir });
+    logger25.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");
+        logger25.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -5338,10 +5524,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger20.info("Dependencies installed");
+      logger25.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger20.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger25.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -5351,14 +5537,14 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger20.info("Dependencies installed (fallback)");
+          logger25.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger20.warn("Fallback install also failed", {
+          logger25.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger20.warn("Install failed, no fallback configured", {
+        logger25.warn("Install failed, no fallback configured", {
           error: err.message
         });
       }
@@ -5368,7 +5554,7 @@ var PipelineOrchestrator = class {
     const targetBin = path12.join(workDir, "node_modules", ".bin");
     try {
       await fs11.access(targetBin);
-      logger20.info("node_modules already complete (has .bin/)");
+      logger25.info("node_modules already complete (has .bin/)");
       return true;
     } catch {
     }
@@ -5377,19 +5563,19 @@ var PipelineOrchestrator = class {
     try {
       await fs11.access(sourceNM);
     } catch {
-      logger20.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger25.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 });
+    logger25.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");
+      logger25.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger20.warn("Failed to seed node_modules from main repo", {
+      logger25.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -5399,16 +5585,16 @@ 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 });
+    logger25.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 });
+      logger25.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger20.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger25.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -5425,19 +5611,19 @@ var PipelineOrchestrator = class {
     await this.cleanupE2eOutputs(issueIid);
     this.tracker.resetFull(issueIid);
     this.pendingActions.delete(issueIid);
-    logger20.info("Issue restarted", { issueIid });
+    logger25.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 });
+    logger25.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 });
+      logger25.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -5454,7 +5640,7 @@ var PipelineOrchestrator = class {
     this.tracker.clearProcessingLock(issueIid);
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
     await this.cleanupE2eOutputs(issueIid);
-    logger20.info("Issue cancelled", { issueIid });
+    logger25.info("Issue cancelled", { issueIid });
   }
   /**
    * Remove the E2E output directory for an issue: {uatVendorDir}/outputs/issue-{iid}
@@ -5466,9 +5652,9 @@ var PipelineOrchestrator = class {
     const outputDir = path12.join(abs, "outputs", `issue-${issueIid}`);
     try {
       await fs11.rm(outputDir, { recursive: true, force: true });
-      logger20.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
+      logger25.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
     } catch (err) {
-      logger20.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
+      logger25.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
     }
   }
   /**
@@ -5481,9 +5667,9 @@ var PipelineOrchestrator = class {
     const wsRoot = this.workspaceManager.getWorkspaceRoot(issueIid);
     try {
       await fs11.rm(wsRoot, { recursive: true, force: true });
-      logger20.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
+      logger25.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
     } catch (err) {
-      logger20.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
+      logger25.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
     }
   }
   retryFromPhase(issueIid, phase) {
@@ -5499,7 +5685,7 @@ var PipelineOrchestrator = class {
       this.aiRunner.killByWorkDir(wtCtx.workDir);
     }
     this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
-    logger20.info("Retrying issue from phase", { issueIid, phase });
+    logger25.info("Retrying issue from phase", { issueIid, phase });
     const ok = this.tracker.resetToPhase(issueIid, phase, issueDef);
     if (!ok) {
       throw new InvalidPhaseError(phase);
@@ -5526,7 +5712,7 @@ var PipelineOrchestrator = class {
     } else {
       this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
     }
-    logger20.info("Issue abort requested", { issueIid, state: record.state });
+    logger25.info("Issue abort requested", { issueIid, state: record.state });
   }
   continueIssue(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5536,7 +5722,7 @@ var PipelineOrchestrator = class {
     }
     const issueDef = this.getIssueSpecificPipelineDef(record);
     this.tracker.resumeFromPause(issueIid, issueDef, false);
-    logger20.info("Issue continued from pause", { issueIid });
+    logger25.info("Issue continued from pause", { issueIid });
   }
   redoPhase(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5580,7 +5766,7 @@ var PipelineOrchestrator = class {
       }
       this.eventBus.emitTyped("issue:redone", { issueIid });
     }
-    logger20.info("Issue redo requested", { issueIid, state: record.state });
+    logger25.info("Issue redo requested", { issueIid, state: record.state });
   }
   /**
    * 处理中止/重做的共享逻辑：
@@ -5653,7 +5839,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", {
+    logger25.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -5760,7 +5946,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger20.info("Merge request created successfully", {
+      logger25.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -5768,7 +5954,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", {
+      logger25.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -5785,7 +5971,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger20.info("Found existing merge request", {
+        logger25.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -5793,7 +5979,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger20.warn("Failed to find existing merge request", {
+      logger25.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -5838,7 +6024,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger20.error("Failed to start preview servers", {
+      logger25.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -5873,7 +6059,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 });
+    logger25.info("Preview stopped and worktree cleaned", { iid: issueIid });
   }
   async markDeployed(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5890,7 +6076,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 });
+      logger25.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
     }
     try {
       const issue = await this.gongfeng.getIssueDetail(externalId);
@@ -5898,10 +6084,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 });
+      logger25.warn("Failed to update labels", { iid: issueIid, error: err.message });
     }
     this.tracker.updateState(issueIid, "deployed" /* Deployed */);
-    logger20.info("Issue marked as deployed", { iid: issueIid });
+    logger25.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5928,7 +6114,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 });
+    logger25.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -5961,7 +6147,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 });
+    logger25.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
     this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
     this.eventBus.emitTyped("conflict:started", { issueIid });
     try {
@@ -5994,7 +6180,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger20.info("Running verification after conflict resolution", { issueIid });
+      logger25.info("Running verification after conflict resolution", { issueIid });
       const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
       wtPlan.ensureDir();
       const verifyPhase = createPhase("verify", this.aiRunner, wtGit, wtPlan, this.config);
@@ -6032,10 +6218,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 });
+      logger25.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger20.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      logger25.error("Conflict resolution failed", { issueIid, error: errorMsg });
       try {
         const wtGit = new GitOperations(wtCtx.gitRootDir);
         if (await wtGit.isRebaseInProgress()) {
@@ -6065,7 +6251,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 });
+      logger25.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -6141,7 +6327,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger21 = logger.child("Brainstorm");
+var logger26 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -6177,7 +6363,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger21.info("Created brainstorm session", { sessionId: session.id });
+    logger26.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -6186,7 +6372,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger21.info("Generating SDD", { sessionId });
+    logger26.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -6212,7 +6398,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 });
+    logger26.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({
@@ -6245,7 +6431,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger21.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger26.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -6332,4 +6518,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-LDGK5NMS.js.map
+//# sourceMappingURL=chunk-WZGEYHCC.js.map