@xdevops/issue-auto-finish 1.0.90 → 1.0.92

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

@@ -233,8 +233,8 @@ var GongfengClient = class {
     const encoded = encodeURIComponent(this.projectPath);
     return `${this.apiUrl}/api/v3/projects/${encoded}`;
   }
-  async requestRaw(path12, options = {}) {
-    const url = `${this.projectApiBase}${path12}`;
+  async requestRaw(path13, options = {}) {
+    const url = `${this.projectApiBase}${path13}`;
     logger4.debug("API request", { method: options.method || "GET", url });
     return this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -251,11 +251,11 @@ var GongfengClient = class {
           throw new GongfengApiError(resp.status, `Gongfeng API error ${resp.status}: ${body}`, body);
         }
         return resp;
-      }, `requestRaw ${options.method || "GET"} ${path12}`)
+      }, `requestRaw ${options.method || "GET"} ${path13}`)
     );
   }
-  async request(path12, options = {}) {
-    const resp = await this.requestRaw(path12, options);
+  async request(path13, options = {}) {
+    const resp = await this.requestRaw(path13, options);
     return resp.json();
   }
   async createIssue(title, description, labels) {
@@ -434,8 +434,8 @@ var GongfengClient = class {
     }
     return mr;
   }
-  async requestGlobal(path12, options = {}) {
-    const url = `${this.apiUrl}${path12}`;
+  async requestGlobal(path13, options = {}) {
+    const url = `${this.apiUrl}${path13}`;
     logger4.debug("API request (global)", { method: options.method || "GET", url });
     const resp = await this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -452,7 +452,7 @@ var GongfengClient = class {
           throw new GongfengApiError(r.status, `Gongfeng API error ${r.status}: ${body}`, body);
         }
         return r;
-      }, `requestGlobal ${options.method || "GET"} ${path12}`)
+      }, `requestGlobal ${options.method || "GET"} ${path13}`)
     );
     return resp.json();
   }
@@ -1646,7 +1646,7 @@ var PlanPersistence = class _PlanPersistence {
 };
 
 // src/phases/BasePhase.ts
-import path4 from "path";
+import path5 from "path";
 
 // src/rules/RuleResolver.ts
 import { readdir, readFile } from "fs/promises";
@@ -1743,6 +1743,454 @@ ${rule.content}`;
   }
 };
 
+// src/hooks/HookInjector.ts
+import fs3 from "fs";
+import path4 from "path";
+var logger7 = logger.child("HookInjector");
+var HOOKS_DIR = ".claude-plan/.hooks";
+var EVENTS_FILE_NAME = ".hook-events.jsonl";
+var MANIFEST_FILE_NAME = ".artifact-manifest.jsonl";
+var CONTEXT_FILE_NAME = ".hook-context.json";
+var HookInjector = class {
+  inject(ctx) {
+    this.writeHookScripts(ctx);
+    this.writeContextFile(ctx);
+    this.writeSettingsLocal(ctx);
+    this.initEventsFile(ctx);
+    logger7.info("Hooks injected", {
+      workDir: ctx.workDir,
+      issueIid: ctx.issueIid,
+      phase: ctx.phaseName,
+      artifacts: ctx.expectedArtifacts
+    });
+  }
+  /**
+   * 阶段切换时更新 hooks 配置（重写脚本 + settings.local.json）。
+   * 保留 events/manifest 文件（不截断），仅更新脚本和配置。
+   */
+  updateForPhase(ctx) {
+    this.writeHookScripts(ctx);
+    this.writeContextFile(ctx);
+    this.writeSettingsLocal(ctx);
+    logger7.info("Hooks updated for phase", {
+      workDir: ctx.workDir,
+      issueIid: ctx.issueIid,
+      phase: ctx.phaseName
+    });
+  }
+  readManifest(workDir) {
+    const manifestPath = path4.join(workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    return readJsonl(manifestPath);
+  }
+  readEvents(workDir) {
+    const eventsPath = path4.join(workDir, ".claude-plan", EVENTS_FILE_NAME);
+    return readJsonl(eventsPath);
+  }
+  getEventsFilePath(workDir) {
+    return path4.join(workDir, ".claude-plan", EVENTS_FILE_NAME);
+  }
+  getManifestFilePath(workDir) {
+    return path4.join(workDir, ".claude-plan", MANIFEST_FILE_NAME);
+  }
+  cleanup(workDir) {
+    const hooksDir = path4.join(workDir, HOOKS_DIR);
+    try {
+      if (fs3.existsSync(hooksDir)) {
+        fs3.rmSync(hooksDir, { recursive: true });
+      }
+    } catch (err) {
+      logger7.warn("Failed to cleanup hooks", { error: err.message });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  writeHookScripts(ctx) {
+    const hooksDir = path4.join(ctx.workDir, HOOKS_DIR);
+    fs3.mkdirSync(hooksDir, { recursive: true });
+    const eventsFile = path4.join(ctx.workDir, ".claude-plan", EVENTS_FILE_NAME);
+    const manifestFile = path4.join(ctx.workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    const contextFile = path4.join(ctx.workDir, ".claude-plan", CONTEXT_FILE_NAME);
+    const expected = ctx.expectedArtifacts.join(",");
+    const phaseExpected = (ctx.phaseExpectedArtifacts ?? ctx.expectedArtifacts).join(",");
+    const scripts = [
+      { name: "session-start.sh", content: buildSessionStartScript(eventsFile) },
+      { name: "compact-restore.sh", content: buildCompactRestoreScript(eventsFile, contextFile) },
+      { name: "post-tool-use.sh", content: buildPostToolUseScript(eventsFile, manifestFile, expected) },
+      { name: "post-artifact.sh", content: buildPostArtifactScript(manifestFile, expected) },
+      { name: "exit-plan-mode.sh", content: buildExitPlanModeScript(eventsFile) },
+      { name: "permission.sh", content: buildPermissionScript(eventsFile) },
+      { name: "protect-files.sh", content: buildProtectFilesScript(eventsFile, ctx.phaseName, ctx.planDir) },
+      { name: "stop.sh", content: buildStopScript(eventsFile, ctx.planDir, phaseExpected) }
+    ];
+    for (const { name, content } of scripts) {
+      const scriptPath = path4.join(hooksDir, name);
+      fs3.writeFileSync(scriptPath, content, { mode: 493 });
+    }
+  }
+  writeContextFile(ctx) {
+    const contextPath = path4.join(ctx.workDir, ".claude-plan", CONTEXT_FILE_NAME);
+    const context = {
+      issueIid: ctx.issueIid,
+      issueTitle: ctx.issueTitle ?? "",
+      issueDescription: ctx.issueDescription ?? "",
+      phaseName: ctx.phaseName ?? "",
+      expectedArtifacts: ctx.expectedArtifacts,
+      planDir: ctx.planDir
+    };
+    fs3.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
+  }
+  writeSettingsLocal(ctx) {
+    const claudeDir = path4.join(ctx.workDir, ".claude");
+    fs3.mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = path4.join(claudeDir, "settings.local.json");
+    let existing = {};
+    if (fs3.existsSync(settingsPath)) {
+      try {
+        existing = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
+      } catch {
+        logger7.warn("Failed to parse existing settings.local.json, overwriting");
+      }
+    }
+    const hooksDir = path4.join(ctx.workDir, HOOKS_DIR);
+    const hooks = buildHooksConfig(hooksDir, ctx);
+    const merged = { ...existing, hooks };
+    fs3.writeFileSync(settingsPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  initEventsFile(ctx) {
+    const eventsPath = path4.join(ctx.workDir, ".claude-plan", EVENTS_FILE_NAME);
+    const manifestPath = path4.join(ctx.workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    fs3.writeFileSync(eventsPath, "", "utf-8");
+    fs3.writeFileSync(manifestPath, "", "utf-8");
+  }
+};
+function buildHooksConfig(hooksDir, ctx) {
+  const isPlanPhase = ctx.phaseName === "plan";
+  const artifactIfPatterns = buildArtifactIfPatterns(ctx.expectedArtifacts);
+  const config = {
+    SessionStart: [
+      {
+        hooks: [{
+          type: "command",
+          command: path4.join(hooksDir, "session-start.sh"),
+          timeout: 5
+        }]
+      },
+      {
+        matcher: "compact",
+        hooks: [{
+          type: "command",
+          command: path4.join(hooksDir, "compact-restore.sh"),
+          timeout: 5
+        }]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "Edit|Write",
+        hooks: [{
+          type: "command",
+          command: path4.join(hooksDir, "protect-files.sh"),
+          timeout: 5,
+          ...buildProtectIfClause(ctx.phaseName)
+        }]
+      }
+    ],
+    PostToolUse: buildPostToolUseConfig(hooksDir, artifactIfPatterns),
+    PermissionRequest: buildPermissionRequestConfig(hooksDir, isPlanPhase),
+    Stop: [{
+      hooks: [{
+        type: "command",
+        command: path4.join(hooksDir, "stop.sh"),
+        timeout: 15
+      }]
+    }]
+  };
+  return config;
+}
+function buildPermissionRequestConfig(hooksDir, isPlanPhase) {
+  const groups = [];
+  if (isPlanPhase) {
+    groups.push({
+      matcher: "ExitPlanMode",
+      hooks: [{
+        type: "command",
+        command: path4.join(hooksDir, "exit-plan-mode.sh"),
+        timeout: 5
+      }]
+    });
+  }
+  groups.push({
+    matcher: "Bash|Edit|Write|Read|Glob|Grep|WebFetch|WebSearch|mcp__.*",
+    hooks: [{
+      type: "command",
+      command: path4.join(hooksDir, "permission.sh"),
+      timeout: 5
+    }]
+  });
+  return groups;
+}
+function buildPostToolUseConfig(hooksDir, artifactIfPatterns) {
+  const groups = [];
+  if (artifactIfPatterns) {
+    groups.push({
+      matcher: "Write|Edit",
+      hooks: [{
+        type: "command",
+        command: path4.join(hooksDir, "post-artifact.sh"),
+        timeout: 10,
+        if: artifactIfPatterns
+      }]
+    });
+  }
+  groups.push({
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: path4.join(hooksDir, "post-tool-use.sh"),
+      timeout: 10
+    }]
+  });
+  return groups;
+}
+function buildArtifactIfPatterns(artifacts) {
+  if (artifacts.length === 0) return void 0;
+  return artifacts.flatMap((f) => [`Write(*${f})`, `Edit(*${f})`]).join("|");
+}
+function buildProtectIfClause(phaseName) {
+  const alwaysProtected = [".env", ".env.*", "package-lock.json", "pnpm-lock.yaml"];
+  const patterns = [...alwaysProtected];
+  if (phaseName === "build") {
+    patterns.push("01-plan.md");
+  }
+  if (phaseName === "verify") {
+    patterns.push("01-plan.md");
+  }
+  const ifValue = patterns.flatMap((f) => [`Edit(*${f})`, `Write(*${f})`]).join("|");
+  return { if: ifValue };
+}
+function buildSessionStartScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+printf '{"ts":"%s","event":"session_start","session_id":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "$SESSION_ID" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildCompactRestoreScript(eventsFile, contextFile) {
+  return `#!/bin/bash
+set -euo pipefail
+
+CONTEXT_FILE=${quote(contextFile)}
+if [ ! -f "$CONTEXT_FILE" ]; then
+  exit 0
+fi
+
+ISSUE_IID=$(jq -r '.issueIid // empty' < "$CONTEXT_FILE")
+ISSUE_TITLE=$(jq -r '.issueTitle // empty' < "$CONTEXT_FILE")
+ISSUE_DESC=$(jq -r '.issueDescription // empty' < "$CONTEXT_FILE")
+PHASE=$(jq -r '.phaseName // empty' < "$CONTEXT_FILE")
+PLAN_DIR=$(jq -r '.planDir // empty' < "$CONTEXT_FILE")
+ARTIFACTS=$(jq -r '.expectedArtifacts | join(", ") // empty' < "$CONTEXT_FILE")
+
+READY=""
+MISSING=""
+for f in $(jq -r '.expectedArtifacts[]' < "$CONTEXT_FILE" 2>/dev/null); do
+  FPATH="$PLAN_DIR/$f"
+  if [ -f "$FPATH" ] && [ "$(wc -c < "$FPATH")" -ge 50 ]; then
+    READY="$READY $f"
+  else
+    MISSING="$MISSING $f"
+  fi
+done
+READY=$(echo "$READY" | xargs)
+MISSING=$(echo "$MISSING" | xargs)
+
+printf '{"ts":"%s","event":"compact_restore"}\\n' "$(date -u +%FT%TZ)" >> ${quote(eventsFile)}
+
+cat <<CONTEXT
+[\u4E0A\u4E0B\u6587\u6062\u590D \u2014 compaction \u540E\u81EA\u52A8\u6CE8\u5165]
+Issue #$ISSUE_IID: $ISSUE_TITLE
+\u5F53\u524D\u9636\u6BB5: $PHASE
+\u9884\u671F\u4EA7\u7269: $ARTIFACTS
+\u5DF2\u5C31\u7EEA: \${READY:-\u65E0}
+\u672A\u5B8C\u6210: \${MISSING:-\u65E0}
+
+\u9700\u6C42\u63CF\u8FF0:
+$ISSUE_DESC
+CONTEXT
+exit 0
+`;
+}
+function buildPostToolUseScript(eventsFile, manifestFile, expected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+EXPECTED=${quote(expected)}
+BASENAME=$(basename "$FILE_PATH")
+
+if echo "$EXPECTED" | tr ',' '\\n' | grep -qx "$BASENAME"; then
+  BYTES=$(wc -c < "$FILE_PATH" 2>/dev/null || echo 0)
+  printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":%s}\\n' \\
+    "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES" >> ${quote(manifestFile)}
+fi
+
+printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":0}\\n' \\
+  "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildPostArtifactScript(manifestFile, expected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+EXPECTED=${quote(expected)}
+BASENAME=$(basename "$FILE_PATH")
+
+if echo "$EXPECTED" | tr ',' '\\n' | grep -qx "$BASENAME"; then
+  BYTES=$(wc -c < "$FILE_PATH" 2>/dev/null || echo 0)
+  printf '{"ts":"%s","event":"write","file":"%s","path":"%s","bytes":%s}\\n' \\
+    "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES" >> ${quote(manifestFile)}
+fi
+exit 0
+`;
+}
+function buildExitPlanModeScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+
+printf '{"ts":"%s","event":"exit_plan_mode"}\\n' "$(date -u +%FT%TZ)" >> ${quote(eventsFile)}
+
+echo '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
+exit 0
+`;
+}
+function buildPermissionScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+printf '{"ts":"%s","event":"permission_request","tool":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "$TOOL" >> ${quote(eventsFile)}
+echo '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
+exit 0
+`;
+}
+function buildProtectFilesScript(eventsFile, phaseName, planDir) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+BASENAME=$(basename "$FILE_PATH")
+PHASE=${quote(phaseName ?? "")}
+
+blocked_reason() {
+  printf '{"ts":"%s","event":"protect_blocked","tool":"%s","file":"%s"}\\n' \\
+    "$(date -u +%FT%TZ)" "$TOOL" "$BASENAME" >> ${quote(eventsFile)}
+  echo "$1" >&2
+  exit 2
+}
+
+case "$BASENAME" in
+  .env|.env.*)
+    blocked_reason "\u7981\u6B62\u4FEE\u6539\u73AF\u5883\u914D\u7F6E\u6587\u4EF6 $BASENAME\uFF0C\u8BF7\u901A\u8FC7 .env.example \u6216\u6587\u6863\u8BF4\u660E\u914D\u7F6E\u53D8\u66F4\u3002"
+    ;;
+  package-lock.json|pnpm-lock.yaml)
+    blocked_reason "\u7981\u6B62\u76F4\u63A5\u4FEE\u6539\u9501\u6587\u4EF6 $BASENAME\uFF0C\u8BF7\u901A\u8FC7 npm install / pnpm install \u66F4\u65B0\u4F9D\u8D56\u3002"
+    ;;
+esac
+
+if [ "$PHASE" = "build" ] || [ "$PHASE" = "verify" ]; then
+  case "$BASENAME" in
+    01-plan.md)
+      blocked_reason "\u5728 $PHASE \u9636\u6BB5\u7981\u6B62\u4FEE\u6539\u89C4\u5212\u6587\u6863 01-plan.md\uFF0C\u8BE5\u6587\u4EF6\u5728 plan \u9636\u6BB5\u5DF2\u786E\u5B9A\u3002"
+      ;;
+  esac
+fi
+
+exit 0
+`;
+}
+function buildStopScript(eventsFile, planDir, phaseExpected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+STOP_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+
+PLAN_DIR=${quote(planDir)}
+MIN_BYTES=50
+PHASE_EXPECTED=${quote(phaseExpected)}
+
+MISSING=""
+READY=""
+for f in $(echo "$PHASE_EXPECTED" | tr ',' ' '); do
+  [ -z "$f" ] && continue
+  FPATH="$PLAN_DIR/$f"
+  if [ -f "$FPATH" ] && [ "$(wc -c < "$FPATH")" -ge "$MIN_BYTES" ]; then
+    BYTES=$(wc -c < "$FPATH")
+    READY="$READY $f(\${BYTES} bytes)"
+  else
+    MISSING="$MISSING $f"
+  fi
+done
+
+MISSING=$(echo "$MISSING" | xargs)
+READY=$(echo "$READY" | xargs)
+
+if [ -n "$MISSING" ] && [ "$STOP_ACTIVE" != "true" ]; then
+  printf '{"ts":"%s","event":"stop","blocked":true,"missing":"%s"}\\n' \\
+    "$(date -u +%FT%TZ)" "$MISSING" >> ${quote(eventsFile)}
+
+  REASON="\u4EA7\u7269\u672A\u5C31\u7EEA: $MISSING\u3002\u8BF7\u5199\u5165 $PLAN_DIR/ \u4E0B\u7684\u5BF9\u5E94\u6587\u4EF6\u3002\u5DF2\u5C31\u7EEA: \${READY:-\u65E0}"
+
+  printf '{"decision":"block","reason":"%s"}' "$REASON"
+  exit 0
+fi
+
+printf '{"ts":"%s","event":"stop","blocked":false,"missing":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "\${MISSING:-none}" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function quote(s) {
+  return `"${s.replace(/"/g, '\\"')}"`;
+}
+function readJsonl(filePath) {
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8").trim();
+    if (!content) return [];
+    return content.split("\n").reduce((acc, line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return acc;
+      try {
+        acc.push(JSON.parse(trimmed));
+      } catch {
+        logger7.debug("Skipping malformed JSONL line", { line: trimmed });
+      }
+      return acc;
+    }, []);
+  } catch {
+    return [];
+  }
+}
+
+// src/hooks/HookEventWatcher.ts
+import fs4 from "fs";
+var logger8 = logger.child("HookEventWatcher");
+
 // src/phases/BasePhase.ts
 var BasePhase = class _BasePhase {
   static MIN_ARTIFACT_BYTES = 50;
@@ -1887,7 +2335,7 @@ ${t("basePhase.rulesSection", { rules })}`;
     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;
+    const artifactPaths = snapshotFilenames.length > 0 ? snapshotFilenames.map((fn) => path5.join(this.plan.planDir, fn)) : void 0;
     let capturedSessionId;
     const result = await this.aiRunner.run({
       prompt,
@@ -1984,14 +2432,14 @@ ${t("basePhase.rulesSection", { rules })}`;
       const context = `${ctx.demand.title} ${ctx.demand.description} ${ctx.demand.supplement ? JSON.stringify(ctx.demand.supplement) : ""}`;
       if (ctx.workspace && ctx.workspace.repos.length > 1) {
         for (const repo of ctx.workspace.repos) {
-          const rulesDir = path4.join(repo.gitRootDir, ".cursor", "rules");
+          const rulesDir = path5.join(repo.gitRootDir, ".cursor", "rules");
           try {
             await resolver.loadRules(rulesDir);
           } catch {
           }
         }
       } else {
-        const rulesDir = path4.join(this.plan.baseDir, ".cursor", "rules");
+        const rulesDir = path5.join(this.plan.baseDir, ".cursor", "rules");
         await resolver.loadRules(rulesDir);
       }
       const matched = resolver.matchRules(context);
@@ -2024,6 +2472,24 @@ ${t("basePhase.rulesSection", { rules })}`;
       this.logger.error(msg, { phase: this.phaseName, displayId: _displayId });
       throw new AIExecutionError(this.phaseName, msg, { output: "", exitCode: 0 });
     }
+    this.logHookManifest();
+  }
+  /** 读取 hook manifest 并记录产物写入历史（P1 增强层，不影响主流程） */
+  logHookManifest() {
+    try {
+      const injector = new HookInjector();
+      const entries = injector.readManifest(this.plan.baseDir);
+      if (entries.length === 0) return;
+      const artifactWrites = entries.filter((e) => "file" in e && e.event === "write");
+      if (artifactWrites.length > 0) {
+        this.logger.info("Hook manifest: artifact writes recorded", {
+          phase: this.phaseName,
+          writes: artifactWrites.length,
+          files: artifactWrites.map((e) => "file" in e ? e.file : "unknown")
+        });
+      }
+    } catch {
+    }
   }
 };
 
@@ -2247,20 +2713,20 @@ var BuildPhase = class extends BasePhase {
 };
 
 // src/release/ReleaseDetectCache.ts
-import fs3 from "fs";
-import path5 from "path";
+import fs5 from "fs";
+import path6 from "path";
 import { createHash } from "crypto";
-var logger7 = logger.child("ReleaseDetectCache");
+var logger9 = logger.child("ReleaseDetectCache");
 function hashProjectPath(projectPath) {
   return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 var ReleaseDetectCache = class {
   cacheDir;
   constructor(dataDir) {
-    this.cacheDir = path5.join(dataDir, "release-detect");
+    this.cacheDir = path6.join(dataDir, "release-detect");
   }
   filePath(projectPath) {
-    return path5.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
+    return path6.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
   }
   /**
    * 读取缓存。返回 null 如果不存在、已过期或校验失败。
@@ -2268,21 +2734,21 @@ var ReleaseDetectCache = class {
   get(projectPath, ttlMs) {
     const fp = this.filePath(projectPath);
     try {
-      if (!fs3.existsSync(fp)) return null;
-      const raw = fs3.readFileSync(fp, "utf-8");
+      if (!fs5.existsSync(fp)) return null;
+      const raw = fs5.readFileSync(fp, "utf-8");
       const data = JSON.parse(raw);
       if (data.projectPath !== projectPath) {
-        logger7.warn("Cache projectPath mismatch, ignoring", { expected: projectPath, got: data.projectPath });
+        logger9.warn("Cache projectPath mismatch, ignoring", { expected: projectPath, got: data.projectPath });
         return null;
       }
       const age = Date.now() - new Date(data.detectedAt).getTime();
       if (age > ttlMs) {
-        logger7.debug("Cache expired", { projectPath, ageMs: age, ttlMs });
+        logger9.debug("Cache expired", { projectPath, ageMs: age, ttlMs });
         return null;
       }
       return data;
     } catch (err) {
-      logger7.warn("Failed to read release detect cache", { path: fp, error: err.message });
+      logger9.warn("Failed to read release detect cache", { path: fp, error: err.message });
       return null;
     }
   }
@@ -2292,13 +2758,13 @@ var ReleaseDetectCache = class {
   set(result) {
     const fp = this.filePath(result.projectPath);
     try {
-      if (!fs3.existsSync(this.cacheDir)) {
-        fs3.mkdirSync(this.cacheDir, { recursive: true });
+      if (!fs5.existsSync(this.cacheDir)) {
+        fs5.mkdirSync(this.cacheDir, { recursive: true });
       }
-      fs3.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
-      logger7.debug("Release detect cache written", { projectPath: result.projectPath, path: fp });
+      fs5.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
+      logger9.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 });
+      logger9.warn("Failed to write release detect cache", { path: fp, error: err.message });
     }
   }
   /**
@@ -2307,14 +2773,14 @@ var ReleaseDetectCache = class {
   invalidate(projectPath) {
     const fp = this.filePath(projectPath);
     try {
-      if (fs3.existsSync(fp)) {
-        fs3.unlinkSync(fp);
-        logger7.info("Release detect cache invalidated", { projectPath });
+      if (fs5.existsSync(fp)) {
+        fs5.unlinkSync(fp);
+        logger9.info("Release detect cache invalidated", { projectPath });
         return true;
       }
       return false;
     } catch (err) {
-      logger7.warn("Failed to invalidate release detect cache", { path: fp, error: err.message });
+      logger9.warn("Failed to invalidate release detect cache", { path: fp, error: err.message });
       return false;
     }
   }
@@ -2765,9 +3231,9 @@ function createLifecycleManager(def) {
 
 // src/workspace/WorkspaceConfig.ts
 import { z } from "zod";
-import fs4 from "fs";
-import path6 from "path";
-var logger8 = logger.child("WorkspaceConfig");
+import fs6 from "fs";
+import path7 from "path";
+var logger10 = logger.child("WorkspaceConfig");
 var repoConfigSchema = z.object({
   name: z.string().min(1, "Repo name is required"),
   projectPath: z.string().min(1, "Gongfeng project path is required"),
@@ -2783,29 +3249,29 @@ var workspaceConfigSchema = z.object({
 });
 function loadWorkspaceConfig(configPath) {
   if (!configPath) return null;
-  if (!fs4.existsSync(configPath)) {
-    logger8.warn("Workspace config file not found, falling back to single-repo mode", {
+  if (!fs6.existsSync(configPath)) {
+    logger10.warn("Workspace config file not found, falling back to single-repo mode", {
       path: configPath
     });
     return null;
   }
   try {
-    const raw = fs4.readFileSync(configPath, "utf-8");
+    const raw = fs6.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");
-      logger8.error(`Workspace config validation failed:
+      logger10.error(`Workspace config validation failed:
 ${issues}`);
       return null;
     }
-    logger8.info("Workspace config loaded", {
+    logger10.info("Workspace config loaded", {
       primary: result.data.primary.name,
       associates: result.data.associates.map((a) => a.name)
     });
     return result.data;
   } catch (err) {
-    logger8.error("Failed to parse workspace config", {
+    logger10.error("Failed to parse workspace config", {
       path: configPath,
       error: err.message
     });
@@ -2831,14 +3297,14 @@ function isMultiRepo(ws) {
 }
 function persistWorkspaceConfig(ws, filePath) {
   try {
-    const dir = path6.dirname(filePath);
-    if (!fs4.existsSync(dir)) {
-      fs4.mkdirSync(dir, { recursive: true });
+    const dir = path7.dirname(filePath);
+    if (!fs6.existsSync(dir)) {
+      fs6.mkdirSync(dir, { recursive: true });
     }
-    fs4.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
-    logger8.info("Workspace config auto-generated from .env", { path: filePath });
+    fs6.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
+    logger10.info("Workspace config auto-generated from .env", { path: filePath });
   } catch (err) {
-    logger8.warn("Failed to persist workspace config", {
+    logger10.warn("Failed to persist workspace config", {
       path: filePath,
       error: err.message
     });
@@ -2846,12 +3312,12 @@ function persistWorkspaceConfig(ws, filePath) {
 }
 
 // src/workspace/WorkspaceManager.ts
-import path7 from "path";
-import fs5 from "fs/promises";
+import path8 from "path";
+import fs7 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var logger9 = logger.child("WorkspaceManager");
+var logger11 = logger.child("WorkspaceManager");
 var WorkspaceManager = class {
   wsConfig;
   worktreeBaseDir;
@@ -2880,7 +3346,7 @@ var WorkspaceManager = class {
    */
   async prepareWorkspace(issueIid, branchName, globalBaseBranch, globalBranchPrefix) {
     const wsRoot = this.getWorkspaceRoot(issueIid);
-    await fs5.mkdir(wsRoot, { recursive: true });
+    await fs7.mkdir(wsRoot, { recursive: true });
     const primaryCtx = await this.preparePrimaryRepo(
       issueIid,
       branchName,
@@ -2899,7 +3365,7 @@ var WorkspaceManager = class {
       );
       associateCtxs.push(ctx);
     }
-    logger9.info("Workspace prepared", {
+    logger11.info("Workspace prepared", {
       issueIid,
       wsRoot,
       repos: [primaryCtx.name, ...associateCtxs.map((a) => a.name)]
@@ -2924,7 +3390,7 @@ var WorkspaceManager = class {
         await git.commit(message);
         await git.push(wsCtx.branchName);
         committed.push(repo.name);
-        logger9.info("Committed and pushed changes", {
+        logger11.info("Committed and pushed changes", {
           repo: repo.name,
           branch: wsCtx.branchName
         });
@@ -2938,19 +3404,19 @@ var WorkspaceManager = class {
   async cleanupWorkspace(wsCtx) {
     try {
       await this.mainGit.worktreeRemove(wsCtx.primary.gitRootDir, true);
-      logger9.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
+      logger11.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
     } catch (err) {
-      logger9.warn("Failed to remove primary worktree", {
+      logger11.warn("Failed to remove primary worktree", {
         dir: wsCtx.primary.gitRootDir,
         error: err.message
       });
     }
     for (const assoc of wsCtx.associates) {
       try {
-        await fs5.rm(assoc.gitRootDir, { recursive: true, force: true });
-        logger9.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
+        await fs7.rm(assoc.gitRootDir, { recursive: true, force: true });
+        logger11.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
       } catch (err) {
-        logger9.warn("Failed to remove associate repo dir", {
+        logger11.warn("Failed to remove associate repo dir", {
           name: assoc.name,
           dir: assoc.gitRootDir,
           error: err.message
@@ -2958,9 +3424,9 @@ var WorkspaceManager = class {
       }
     }
     try {
-      const entries = await fs5.readdir(wsCtx.workspaceRoot);
+      const entries = await fs7.readdir(wsCtx.workspaceRoot);
       if (entries.length === 0) {
-        await fs5.rmdir(wsCtx.workspaceRoot);
+        await fs7.rmdir(wsCtx.workspaceRoot);
       }
     } catch {
     }
@@ -2972,13 +3438,13 @@ var WorkspaceManager = class {
     const wsRoot = this.getWorkspaceRoot(issueIid);
     const primary = this.wsConfig.primary;
     const defaultPrefix = globalBranchPrefix ?? primary.branchPrefix ?? "feat/issue";
-    const primaryDir = path7.join(wsRoot, primary.name);
+    const primaryDir = path8.join(wsRoot, primary.name);
     const repos = [{
       name: primary.name,
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: primaryDir,
-      workDir: path7.join(primaryDir, primary.projectSubDir ?? ""),
+      workDir: path8.join(primaryDir, primary.projectSubDir ?? ""),
       baseBranch: primary.baseBranch ?? globalBaseBranch,
       branchPrefix: primary.branchPrefix ?? defaultPrefix,
       isPrimary: true
@@ -2988,8 +3454,8 @@ var WorkspaceManager = class {
         name: assoc.name,
         projectPath: assoc.projectPath,
         role: assoc.role ?? "",
-        gitRootDir: path7.join(wsRoot, assoc.name),
-        workDir: path7.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
+        gitRootDir: path8.join(wsRoot, assoc.name),
+        workDir: path8.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
         baseBranch: assoc.baseBranch ?? globalBaseBranch,
         branchPrefix: assoc.branchPrefix ?? defaultPrefix,
         isPrimary: false
@@ -2998,12 +3464,12 @@ var WorkspaceManager = class {
     return repos;
   }
   getWorkspaceRoot(issueIid) {
-    return path7.join(this.worktreeBaseDir, `issue-${issueIid}`);
+    return path8.join(this.worktreeBaseDir, `issue-${issueIid}`);
   }
   // ── Internal helpers ──
   async preparePrimaryRepo(issueIid, branchName, wsRoot, globalBaseBranch) {
     const primary = this.wsConfig.primary;
-    const repoDir = path7.join(wsRoot, primary.name);
+    const repoDir = path8.join(wsRoot, primary.name);
     const baseBranch = primary.baseBranch ?? globalBaseBranch;
     await this.ensurePrimaryWorktree(repoDir, branchName, baseBranch);
     return {
@@ -3011,18 +3477,18 @@ var WorkspaceManager = class {
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: repoDir,
-      workDir: path7.join(repoDir, primary.projectSubDir ?? ""),
+      workDir: path8.join(repoDir, primary.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: primary.branchPrefix ?? "feat/issue",
       isPrimary: true
     };
   }
   async ensurePrimaryWorktree(repoDir, branchName, baseBranch) {
-    const wsRoot = path7.dirname(repoDir);
+    const wsRoot = path8.dirname(repoDir);
     if (wsRoot !== repoDir) {
       try {
-        await fs5.access(path7.join(wsRoot, ".git"));
-        logger9.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
+        await fs7.access(path8.join(wsRoot, ".git"));
+        logger11.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
         await this.mainGit.worktreeRemove(wsRoot, true);
         await this.mainGit.worktreePrune();
         await this.cleanStaleDir(wsRoot);
@@ -3032,11 +3498,11 @@ var WorkspaceManager = class {
     const worktrees = await this.mainGit.worktreeList();
     if (worktrees.includes(repoDir)) {
       try {
-        await fs5.access(path7.join(repoDir, ".git"));
-        logger9.info("Reusing existing primary worktree", { dir: repoDir });
+        await fs7.access(path8.join(repoDir, ".git"));
+        logger11.info("Reusing existing primary worktree", { dir: repoDir });
         return;
       } catch {
-        logger9.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
+        logger11.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
         await this.mainGit.worktreeRemove(repoDir, true);
         await this.mainGit.worktreePrune();
       }
@@ -3055,19 +3521,19 @@ var WorkspaceManager = class {
     await this.mainGit.worktreeAdd(repoDir, branchName, `origin/${baseBranch}`);
   }
   async prepareAssociateRepo(assoc, _issueIid, branchName, wsRoot, globalBaseBranch, globalBranchPrefix) {
-    const repoDir = path7.join(wsRoot, assoc.name);
+    const repoDir = path8.join(wsRoot, assoc.name);
     const baseBranch = assoc.baseBranch ?? globalBaseBranch;
     const cloneUrl = `${this.gongfengApiUrl}/${assoc.projectPath}.git`;
-    const gitDirExists = await this.dirExists(path7.join(repoDir, ".git"));
+    const gitDirExists = await this.dirExists(path8.join(repoDir, ".git"));
     if (!gitDirExists) {
       await this.cleanStaleDir(repoDir);
-      logger9.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
+      logger11.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
       await execFileAsync("git", ["clone", "--depth", "50", cloneUrl, repoDir], {
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024
       });
     } else {
-      logger9.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
+      logger11.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
     }
     const assocGit = new GitOperations(repoDir);
     await assocGit.fetch();
@@ -3090,7 +3556,7 @@ var WorkspaceManager = class {
       projectPath: assoc.projectPath,
       role: assoc.role ?? "",
       gitRootDir: repoDir,
-      workDir: path7.join(repoDir, assoc.projectSubDir ?? ""),
+      workDir: path8.join(repoDir, assoc.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: assoc.branchPrefix ?? globalBranchPrefix,
       isPrimary: false
@@ -3098,13 +3564,13 @@ var WorkspaceManager = class {
   }
   async cleanStaleDir(dir) {
     if (await this.dirExists(dir)) {
-      logger9.warn("Removing stale directory", { dir });
-      await fs5.rm(dir, { recursive: true, force: true });
+      logger11.warn("Removing stale directory", { dir });
+      await fs7.rm(dir, { recursive: true, force: true });
     }
   }
   async dirExists(dir) {
     try {
-      await fs5.access(dir);
+      await fs7.access(dir);
       return true;
     } catch {
       return false;
@@ -3113,8 +3579,8 @@ var WorkspaceManager = class {
 };
 
 // src/orchestrator/PipelineOrchestrator.ts
-import path11 from "path";
-import fs9 from "fs/promises";
+import path12 from "path";
+import fs11 from "fs/promises";
 import fsSync from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3147,8 +3613,8 @@ function mapSupplement(s) {
 }
 
 // src/utils/MergeRequestHelper.ts
-import fs6 from "fs";
-import path8 from "path";
+import fs8 from "fs";
+import path9 from "path";
 var TAPD_PATTERNS = [
   /--story=(\d+)/i,
   /--bug=(\d+)/i,
@@ -3192,9 +3658,9 @@ function generateMRDescription(options) {
     ];
     const planSections = [];
     for (const { filename, label } of summaryFiles) {
-      const filePath = path8.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
-      if (fs6.existsSync(filePath)) {
-        const content = fs6.readFileSync(filePath, "utf-8");
+      const filePath = path9.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs8.existsSync(filePath)) {
+        const content = fs8.readFileSync(filePath, "utf-8");
         const summary = extractSummary(content);
         if (summary) {
           planSections.push(`### ${label}
@@ -3218,7 +3684,7 @@ function extractSummary(content, maxLines = 20) {
 
 // src/deploy/PortAllocator.ts
 import net from "net";
-var logger10 = logger.child("PortAllocator");
+var logger12 = logger.child("PortAllocator");
 var DEFAULT_OPTIONS = {
   backendPortBase: 4e3,
   frontendPortBase: 9e3,
@@ -3243,7 +3709,7 @@ var PortAllocator = class {
   async allocate(issueIid) {
     const existing = this.allocated.get(issueIid);
     if (existing) {
-      logger10.info("Returning already allocated ports", { issueIid, ports: existing });
+      logger12.info("Returning already allocated ports", { issueIid, ports: existing });
       return existing;
     }
     const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
@@ -3261,10 +3727,10 @@ var PortAllocator = class {
       if (beOk && feOk) {
         const pair = { backendPort, frontendPort };
         this.allocated.set(issueIid, pair);
-        logger10.info("Ports allocated", { issueIid, ...pair });
+        logger12.info("Ports allocated", { issueIid, ...pair });
         return pair;
       }
-      logger10.debug("Port pair unavailable, trying next", {
+      logger12.debug("Port pair unavailable, trying next", {
         backendPort,
         frontendPort,
         beOk,
@@ -3279,7 +3745,7 @@ var PortAllocator = class {
     const pair = this.allocated.get(issueIid);
     if (pair) {
       this.allocated.delete(issueIid);
-      logger10.info("Ports released", { issueIid, ...pair });
+      logger12.info("Ports released", { issueIid, ...pair });
     }
   }
   getPortsForIssue(issueIid) {
@@ -3290,15 +3756,15 @@ var PortAllocator = class {
   }
   restore(issueIid, ports) {
     this.allocated.set(issueIid, ports);
-    logger10.info("Ports restored from persistence", { issueIid, ...ports });
+    logger12.info("Ports restored from persistence", { issueIid, ...ports });
   }
 };
 
 // src/deploy/DevServerManager.ts
 import { spawn } from "child_process";
-import fs7 from "fs";
-import path9 from "path";
-var logger11 = logger.child("DevServerManager");
+import fs9 from "fs";
+import path10 from "path";
+var logger13 = logger.child("DevServerManager");
 var DEFAULT_OPTIONS2 = {};
 var DevServerManager = class {
   servers = /* @__PURE__ */ new Map();
@@ -3306,25 +3772,25 @@ var DevServerManager = class {
   logDir;
   constructor(options) {
     this.options = { ...DEFAULT_OPTIONS2, ...options };
-    this.logDir = path9.join(resolveDataDir(), "preview-logs");
-    if (!fs7.existsSync(this.logDir)) {
-      fs7.mkdirSync(this.logDir, { recursive: true });
+    this.logDir = path10.join(resolveDataDir(), "preview-logs");
+    if (!fs9.existsSync(this.logDir)) {
+      fs9.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogPath(issueIid, type) {
-    const filePath = path9.join(this.logDir, `${issueIid}-${type}.log`);
-    return fs7.existsSync(filePath) ? filePath : null;
+    const filePath = path10.join(this.logDir, `${issueIid}-${type}.log`);
+    return fs9.existsSync(filePath) ? filePath : null;
   }
   async startServers(wtCtx, ports) {
     if (this.servers.has(wtCtx.issueIid)) {
-      logger11.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      logger13.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
       return;
     }
-    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" });
+    logger13.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    const backendLogPath = path10.join(this.logDir, `${wtCtx.issueIid}-backend.log`);
+    const frontendLogPath = path10.join(this.logDir, `${wtCtx.issueIid}-frontend.log`);
+    const backendLog = fs9.createWriteStream(backendLogPath, { flags: "a" });
+    const frontendLog = fs9.createWriteStream(frontendLogPath, { flags: "a" });
     const tsLine = (stream, data) => `[${(/* @__PURE__ */ new Date()).toISOString()}] [${stream}] ${data.toString().trimEnd()}
 `;
     const backendEnv = {
@@ -3348,9 +3814,9 @@ var DevServerManager = class {
       backendLog.write(tsLine("stderr", data));
     });
     backend.on("exit", (code) => {
-      logger11.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+      logger13.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
     });
-    const frontendDir = path9.join(wtCtx.workDir, "frontend");
+    const frontendDir = path10.join(wtCtx.workDir, "frontend");
     const frontendEnv = {
       ...process.env,
       BACKEND_PORT: String(ports.backendPort),
@@ -3372,7 +3838,7 @@ var DevServerManager = class {
       frontendLog.write(tsLine("stderr", data));
     });
     frontend.on("exit", (code) => {
-      logger11.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+      logger13.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
     });
     const serverSet = {
       backend,
@@ -3384,14 +3850,14 @@ var DevServerManager = class {
       frontendLog
     };
     this.servers.set(wtCtx.issueIid, serverSet);
-    logger11.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
+    logger13.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
     await new Promise((r) => setTimeout(r, 1e4));
-    logger11.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
+    logger13.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
   }
   stopServers(issueIid) {
     const set = this.servers.get(issueIid);
     if (!set) return;
-    logger11.info("Stopping dev servers", { issueIid, ports: set.ports });
+    logger13.info("Stopping dev servers", { issueIid, ports: set.ports });
     killProcess(set.backend, `backend #${issueIid}`);
     killProcess(set.frontend, `frontend #${issueIid}`);
     set.backendLog.end();
@@ -3428,7 +3894,7 @@ function killProcess(proc, label) {
     }
     setTimeout(() => {
       if (!proc.killed && proc.exitCode === null) {
-        logger11.warn(`Force killing ${label}`);
+        logger13.warn(`Force killing ${label}`);
         try {
           process.kill(-pid, "SIGKILL");
         } catch {
@@ -3437,7 +3903,7 @@ function killProcess(proc, label) {
       }
     }, 5e3);
   } catch (err) {
-    logger11.warn(`Failed to kill ${label}`, { error: err.message });
+    logger13.warn(`Failed to kill ${label}`, { error: err.message });
   }
 }
 
@@ -3456,13 +3922,13 @@ function isE2eEnabledForIssue(issueIid, tracker, cfg) {
 }
 
 // src/e2e/ScreenshotCollector.ts
-import fs8 from "fs";
-import path10 from "path";
-var logger12 = logger.child("ScreenshotCollector");
+import fs10 from "fs";
+import path11 from "path";
+var logger14 = logger.child("ScreenshotCollector");
 var MAX_SCREENSHOTS = 20;
 function walkDir(dir, files = []) {
-  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
-    const full = path10.join(dir, entry.name);
+  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
+    const full = path11.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkDir(full, files);
     } else if (entry.isFile() && entry.name.endsWith(".png")) {
@@ -3472,34 +3938,34 @@ function walkDir(dir, files = []) {
   return files;
 }
 function collectScreenshots(workDir) {
-  const testResultsDir = path10.join(workDir, "frontend", "test-results");
-  if (!fs8.existsSync(testResultsDir)) {
-    logger12.debug("test-results directory not found", { dir: testResultsDir });
+  const testResultsDir = path11.join(workDir, "frontend", "test-results");
+  if (!fs10.existsSync(testResultsDir)) {
+    logger14.debug("test-results directory not found", { dir: testResultsDir });
     return [];
   }
   const pngFiles = walkDir(testResultsDir);
   if (pngFiles.length === 0) {
-    logger12.debug("No screenshots found");
+    logger14.debug("No screenshots found");
     return [];
   }
   const screenshots = pngFiles.map((filePath) => {
-    const relative = path10.relative(testResultsDir, filePath);
-    const testName = relative.split(path10.sep)[0] || path10.basename(filePath, ".png");
+    const relative = path11.relative(testResultsDir, filePath);
+    const testName = relative.split(path11.sep)[0] || path11.basename(filePath, ".png");
     return { filePath, testName };
   });
   if (screenshots.length > MAX_SCREENSHOTS) {
-    logger12.warn("Too many screenshots, truncating", {
+    logger14.warn("Too many screenshots, truncating", {
       total: screenshots.length,
       max: MAX_SCREENSHOTS
     });
     return screenshots.slice(0, MAX_SCREENSHOTS);
   }
-  logger12.info("Screenshots collected", { count: screenshots.length });
+  logger14.info("Screenshots collected", { count: screenshots.length });
   return screenshots;
 }
 
 // src/e2e/ScreenshotPublisher.ts
-var logger13 = logger.child("ScreenshotPublisher");
+var logger15 = logger.child("ScreenshotPublisher");
 function buildComment(uploaded, truncated) {
   const lines = [t("screenshot.title"), ""];
   for (const item of uploaded) {
@@ -3518,12 +3984,12 @@ var ScreenshotPublisher = class {
     const { workDir, issueIid, issueId, mrIid } = options;
     const screenshots = collectScreenshots(workDir);
     if (screenshots.length === 0) {
-      logger13.info("No E2E screenshots to publish", { issueIid });
+      logger15.info("No E2E screenshots to publish", { issueIid });
       return;
     }
     const uploaded = await this.uploadAll(screenshots);
     if (uploaded.length === 0) {
-      logger13.warn("All screenshot uploads failed", { issueIid });
+      logger15.warn("All screenshot uploads failed", { issueIid });
       return;
     }
     const truncated = screenshots.length >= 20;
@@ -3532,7 +3998,7 @@ var ScreenshotPublisher = class {
     if (mrIid) {
       await this.postToMergeRequest(mrIid, comment);
     }
-    logger13.info("E2E screenshots published", {
+    logger15.info("E2E screenshots published", {
       issueIid,
       mrIid,
       count: uploaded.length
@@ -3548,7 +4014,7 @@ var ScreenshotPublisher = class {
           markdown: result.markdown
         });
       } catch (err) {
-        logger13.warn("Failed to upload screenshot", {
+        logger15.warn("Failed to upload screenshot", {
           filePath: screenshot.filePath,
           error: err.message
         });
@@ -3560,7 +4026,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createIssueNote(issueId, comment);
     } catch (err) {
-      logger13.warn("Failed to post screenshots to issue", {
+      logger15.warn("Failed to post screenshots to issue", {
         issueId,
         error: err.message
       });
@@ -3570,7 +4036,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, comment);
     } catch (err) {
-      logger13.warn("Failed to post screenshots to merge request", {
+      logger15.warn("Failed to post screenshots to merge request", {
         mrIid,
         error: err.message
       });
@@ -3753,7 +4219,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 logger14 = logger.child("SetupStep");
+var logger16 = logger.child("SetupStep");
 async function executeSetup(ctx, deps) {
   const { issue, wtCtx, record, pipelineDef, branchName } = ctx;
   try {
@@ -3762,7 +4228,7 @@ async function executeSetup(ctx, deps) {
       "auto-finish:processing"
     ]);
   } catch (err) {
-    logger14.warn("Failed to update issue labels", { error: err.message });
+    logger16.warn("Failed to update issue labels", { error: err.message });
   }
   await deps.mainGitMutex.runExclusive(async () => {
     deps.emitProgress(issue.iid, "fetch", t("orchestrator.fetchProgress"));
@@ -3804,6 +4270,28 @@ async function executeSetup(ctx, deps) {
   if (!record.phaseProgress) {
     deps.tracker.initPhaseProgress(issue.iid, pipelineDef);
   }
+  const allArtifacts = pipelineDef.phases.flatMap((p) => p.artifacts ?? []).map((a) => a.filename);
+  if (allArtifacts.length > 0) {
+    try {
+      const firstPhase = pipelineDef.phases.find((p) => p.kind === "ai");
+      const firstPhaseArtifacts = (firstPhase?.artifacts ?? []).map((a) => a.filename);
+      const hookInjector = new HookInjector();
+      hookInjector.inject({
+        workDir: primaryWorkDir,
+        planDir: wtPlan.planDir,
+        expectedArtifacts: allArtifacts,
+        phaseExpectedArtifacts: firstPhaseArtifacts,
+        issueIid: issue.iid,
+        phaseName: firstPhase?.name,
+        issueTitle: issue.title,
+        issueDescription: issue.description
+      });
+    } catch (err) {
+      logger16.warn("Failed to inject Claude Code hooks (non-blocking)", {
+        error: err.message
+      });
+    }
+  }
   const wtGitMap = /* @__PURE__ */ new Map();
   if (wtCtx.workspace) {
     wtGitMap.set(wtCtx.workspace.primary.name, wtGit);
@@ -3816,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) {
@@ -3872,8 +4398,14 @@ function clearPendingDialog(issueIid) {
   store.delete(issueIid);
 }
 
-// src/orchestrator/steps/PhaseLoopStep.ts
-var logger15 = 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;
 }
@@ -3889,7 +4421,7 @@ async function commitPlanFiles(ctx, wtGit, wtGitMap, phaseName, displayId) {
     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 });
+        logger17.warn("Missing GitOperations for repo, skipping commit", { repo: repo.name });
         continue;
       }
       const branch = repo.branchPrefix ? `${repo.branchPrefix}-${displayId}` : ctx.branchName;
@@ -3898,10 +4430,10 @@ async function commitPlanFiles(ctx, wtGit, wtGitMap, phaseName, displayId) {
           await repoGit.add(["."]);
           await repoGit.commit(commitMsg);
           await repoGit.push(branch);
-          logger15.info("Committed changes for repo", { repo: repo.name, branch });
+          logger17.info("Committed changes for repo", { repo: repo.name, branch });
         }
       } catch (err) {
-        logger15.warn("Failed to commit/push for repo", {
+        logger17.warn("Failed to commit/push for repo", {
           repo: repo.name,
           error: err.message
         });
@@ -3939,27 +4471,15 @@ async function syncResultToIssue(phase, ctx, displayId, phaseName, deps, issueId
         summary
       );
       await safeComment(deps, issueId, comment);
-      logger15.info("Result synced to issue", { issueIid: displayId, file: file.filename });
+      logger17.info("Result synced to issue", { issueIid: displayId, file: file.filename });
     }
   } catch (err) {
-    logger15.warn("Failed to sync result to issue", { error: err.message });
+    logger17.warn("Failed to sync result to issue", { error: err.message });
     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) {
-  logger15.info("ACP plan-approval requested, delegating to review gate", {
+  logger17.info("ACP plan-approval requested, delegating to review gate", {
     issueIid: displayId,
     phase: phaseName
   });
@@ -3969,14 +4489,14 @@ function handlePlanApproval(displayId, phaseName, deps) {
       const data = payload.data;
       if (data.issueIid !== displayId) return;
       cleanup();
-      logger15.info("ACP plan-approval approved via review gate", { issueIid: displayId });
+      logger17.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 });
+      logger17.info("ACP plan-approval rejected via review gate", { issueIid: displayId });
       resolve("reject");
     };
     const cleanup = () => {
@@ -3988,7 +4508,7 @@ function handlePlanApproval(displayId, phaseName, deps) {
   });
 }
 function handleInteractiveDialog(displayId, phaseName, deps, request) {
-  logger15.info("Interactive dialog forwarded to frontend", {
+  logger17.info("Interactive dialog forwarded to frontend", {
     issueIid: displayId,
     phase: phaseName,
     question: request.content.slice(0, 80),
@@ -4018,7 +4538,7 @@ function handleInteractiveDialog(displayId, phaseName, deps, request) {
       if (data.issueIid !== displayId) return;
       cleanup();
       clearPendingDialog(displayId);
-      logger15.info("Interactive dialog response received from frontend", {
+      logger17.info("Interactive dialog response received from frontend", {
         issueIid: displayId,
         response: data.response
       });
@@ -4028,46 +4548,99 @@ function handleInteractiveDialog(displayId, phaseName, deps, request) {
       const data = payload.data;
       if (data.issueIid !== displayId) return;
       cleanup();
-      logger15.info("Interactive dialog dismissed by user (false positive)", { issueIid: displayId });
+      logger17.info("Interactive dialog dismissed by user (false positive)", { issueIid: displayId });
       resolve("");
     };
     deps.eventBus.on("agent:inputResponse", onResponse);
     deps.eventBus.on("agent:dialogDismissed", onDismiss);
   });
 }
-async function safeComment(deps, issueId, message) {
+function updateHooksForPhase(spec, pipelineDef, ctx, wtPlan) {
+  const phaseArtifacts = (spec.artifacts ?? []).map((a) => a.filename);
+  if (phaseArtifacts.length === 0 && spec.kind !== "ai") return;
   try {
-    await deps.gongfeng.createIssueNote(issueId, message);
-  } catch {
+    const allArtifacts = pipelineDef.phases.flatMap((p) => p.artifacts ?? []).map((a) => a.filename);
+    const hookInjector = new HookInjector();
+    hookInjector.updateForPhase({
+      workDir: wtPlan.baseDir,
+      planDir: wtPlan.planDir,
+      expectedArtifacts: allArtifacts.length > 0 ? allArtifacts : phaseArtifacts,
+      phaseExpectedArtifacts: phaseArtifacts,
+      issueIid: ctx.issue.iid,
+      phaseName: spec.name,
+      issueTitle: ctx.issue.title,
+      issueDescription: ctx.issue.description
+    });
+  } catch (err) {
+    logger17.warn("Failed to update hooks for phase (non-blocking)", {
+      phase: spec.name,
+      error: err.message
+    });
   }
 }
-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",
@@ -4075,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;
   }
-  await safeComment(deps, issue.id, issueProgressComment(spec.name, "failed", shortErr));
+  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;
+    }
+  }
+  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) {
@@ -4120,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)) {
-        logger15.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) {
-          logger15.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
+          logger22.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
         } else {
-          logger15.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) {
@@ -4140,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") {
-          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()
-          });
-        }
-      }
-    }
+    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)) {
-        logger15.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 });
-      logger15.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)) {
-      logger15.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, {
@@ -4235,48 +5112,12 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       });
       continue;
     }
-    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";
-      logger15.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) {
-        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 });
-      logger15.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 });
-      logger15.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);
@@ -4289,189 +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);
-    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);
-  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
-  });
-  logger15.info("Verify-fix loop started", {
-    iid: issue.iid,
-    maxIterations,
-    buildPhaseIdx
-  });
-  for (let iteration = 1; iteration <= maxIterations; iteration++) {
-    if (isShuttingDown()) {
-      throw new ServiceShutdownError();
-    }
-    logger15.info("Verify-fix loop iteration", {
-      iteration,
-      maxIterations,
-      iid: issue.iid
-    });
-    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) {
-      logger15.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) {
-      logger15.info("Verify-fix loop passed", {
-        iteration,
-        iid: issue.iid
-      });
-      return;
-    }
-    logger15.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"}`;
-      logger15.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];
-  logger15.info("Looping back to build for fix", {
-    iteration: fixContext.iteration,
-    iid: issue.iid,
-    failures: fixContext.verifyFailures
-  });
-  phaseCtx.fixContext = fixContext;
-  try {
-    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 logger16 = 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"));
@@ -4503,7 +5203,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger16.warn("Failed to publish E2E screenshots", {
+      logger23.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -4523,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) {
-    logger16.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);
-        logger16.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);
-          logger16.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+          logger23.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger16.warn("Failed to cleanup worktree", {
+          logger23.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -4543,16 +5243,16 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger16.info("Issue processing completed", { iid: issue.iid });
+  logger23.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger17 = 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;
-  logger17.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 */;
@@ -4565,11 +5265,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     }
   }
   if (wasReset) {
-    logger17.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 */) {
-    logger17.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 {
@@ -4591,7 +5291,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
     try {
       await deps.claimer.releaseClaim(issue.id, issue.iid, "failed");
     } catch (releaseErr) {
-      logger17.warn("Failed to release lock on failure", {
+      logger24.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -4599,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];
-  logger17.info("Worktree(s) preserved for debugging", {
+  logger24.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -4608,7 +5308,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger18 = logger.child("PipelineOrchestrator");
+var logger25 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -4638,7 +5338,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger18.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;
@@ -4656,14 +5356,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);
-    logger18.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
     });
     this.devServerManager = new DevServerManager();
     this.screenshotPublisher = new ScreenshotPublisher(gongfeng);
-    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path11.join(config.project.worktreeBaseDir, this.tenantId);
+    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path12.join(config.project.worktreeBaseDir, this.tenantId);
     const effectiveWsConfig = wsConfig ?? buildSingleRepoWorkspace(config.project, config.gongfeng.projectPath);
     this.workspaceManager = new WorkspaceManager({
       wsConfig: effectiveWsConfig,
@@ -4672,7 +5372,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger18.info("WorkspaceManager initialized", {
+    logger25.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -4693,7 +5393,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger18.info("Cleaning up stale worktree state...");
+    logger25.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -4702,11 +5402,11 @@ var PipelineOrchestrator = class {
         if (wtDir === repoGitRoot) continue;
         if (!wtDir.includes("/issue-")) continue;
         try {
-          const gitFile = path11.join(wtDir, ".git");
+          const gitFile = path12.join(wtDir, ".git");
           try {
-            await fs9.access(gitFile);
+            await fs11.access(gitFile);
           } catch {
-            logger18.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();
@@ -4715,32 +5415,32 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger18.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger25.warn("Aborting residual rebase in worktree", { dir: wtDir });
             await wtGit.rebaseAbort();
             cleaned++;
           }
-          const indexLock = path11.join(wtDir, ".git", "index.lock");
+          const indexLock = path12.join(wtDir, ".git", "index.lock");
           try {
-            await fs9.unlink(indexLock);
-            logger18.warn("Removed stale index.lock", { path: indexLock });
+            await fs11.unlink(indexLock);
+            logger25.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger18.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) {
-      logger18.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger25.warn("Failed to list worktrees for cleanup", { error: err.message });
     }
-    const mainIndexLock = path11.join(repoGitRoot, ".git", "index.lock");
+    const mainIndexLock = path12.join(repoGitRoot, ".git", "index.lock");
     try {
-      await fs9.unlink(mainIndexLock);
-      logger18.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      await fs11.unlink(mainIndexLock);
+      logger25.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger18.info("Stale state cleanup complete", { cleaned });
+    logger25.info("Stale state cleanup complete", { cleaned });
   }
   /**
    * 重启后清理幽灵端口分配。
@@ -4753,7 +5453,7 @@ var PipelineOrchestrator = class {
     for (const record of this.tracker.getAll()) {
       if (record.ports) {
         const iid = getIid(record);
-        logger18.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
@@ -4798,20 +5498,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger25.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger18.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) {
-    logger18.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) {
-        logger18.info("node_modules ready \u2014 skipping install");
+        logger25.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -4824,10 +5524,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger18.info("Dependencies installed");
+      logger25.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger18.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger25.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -4837,45 +5537,45 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger18.info("Dependencies installed (fallback)");
+          logger25.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger18.warn("Fallback install also failed", {
+          logger25.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger18.warn("Install failed, no fallback configured", {
+        logger25.warn("Install failed, no fallback configured", {
           error: err.message
         });
       }
     }
   }
   async ensureNodeModules(workDir) {
-    const targetBin = path11.join(workDir, "node_modules", ".bin");
+    const targetBin = path12.join(workDir, "node_modules", ".bin");
     try {
-      await fs9.access(targetBin);
-      logger18.info("node_modules already complete (has .bin/)");
+      await fs11.access(targetBin);
+      logger25.info("node_modules already complete (has .bin/)");
       return true;
     } catch {
     }
-    const sourceNM = path11.join(this.config.project.workDir, "node_modules");
-    const targetNM = path11.join(workDir, "node_modules");
+    const sourceNM = path12.join(this.config.project.workDir, "node_modules");
+    const targetNM = path12.join(workDir, "node_modules");
     try {
-      await fs9.access(sourceNM);
+      await fs11.access(sourceNM);
     } catch {
-      logger18.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger25.warn("Main repo node_modules not found, skipping seed", { sourceNM });
       return false;
     }
-    logger18.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
       });
-      logger18.info("node_modules seeded from main repo");
+      logger25.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger18.warn("Failed to seed node_modules from main repo", {
+      logger25.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -4885,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);
-    logger18.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));
-      logger18.info("Agent notes cleaned up", { issueIid, deleted });
+      logger25.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger18.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);
@@ -4911,19 +5611,19 @@ var PipelineOrchestrator = class {
     await this.cleanupE2eOutputs(issueIid);
     this.tracker.resetFull(issueIid);
     this.pendingActions.delete(issueIid);
-    logger18.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);
-    logger18.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) {
-      logger18.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);
@@ -4940,7 +5640,7 @@ var PipelineOrchestrator = class {
     this.tracker.clearProcessingLock(issueIid);
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
     await this.cleanupE2eOutputs(issueIid);
-    logger18.info("Issue cancelled", { issueIid });
+    logger25.info("Issue cancelled", { issueIid });
   }
   /**
    * Remove the E2E output directory for an issue: {uatVendorDir}/outputs/issue-{iid}
@@ -4948,13 +5648,13 @@ var PipelineOrchestrator = class {
   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}`);
+    const abs = path12.isAbsolute(vendorDir) ? vendorDir : path12.resolve(this.config.project.workDir, vendorDir);
+    const outputDir = path12.join(abs, "outputs", `issue-${issueIid}`);
     try {
-      await fs9.rm(outputDir, { recursive: true, force: true });
-      logger18.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
+      await fs11.rm(outputDir, { recursive: true, force: true });
+      logger25.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
     } catch (err) {
-      logger18.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 });
     }
   }
   /**
@@ -4966,10 +5666,10 @@ var PipelineOrchestrator = class {
     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 });
+      await fs11.rm(wsRoot, { recursive: true, force: true });
+      logger25.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
     } catch (err) {
-      logger18.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) {
@@ -4985,7 +5685,7 @@ var PipelineOrchestrator = class {
       this.aiRunner.killByWorkDir(wtCtx.workDir);
     }
     this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
-    logger18.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);
@@ -5012,7 +5712,7 @@ var PipelineOrchestrator = class {
     } else {
       this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
     }
-    logger18.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);
@@ -5022,7 +5722,7 @@ var PipelineOrchestrator = class {
     }
     const issueDef = this.getIssueSpecificPipelineDef(record);
     this.tracker.resumeFromPause(issueIid, issueDef, false);
-    logger18.info("Issue continued from pause", { issueIid });
+    logger25.info("Issue continued from pause", { issueIid });
   }
   redoPhase(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5066,7 +5766,7 @@ var PipelineOrchestrator = class {
       }
       this.eventBus.emitTyped("issue:redone", { issueIid });
     }
-    logger18.info("Issue redo requested", { issueIid, state: record.state });
+    logger25.info("Issue redo requested", { issueIid, state: record.state });
   }
   /**
    * 处理中止/重做的共享逻辑：
@@ -5139,7 +5839,7 @@ var PipelineOrchestrator = class {
   async _processIssueImpl(issue) {
     const branchName = `${this.config.project.branchPrefix}-${issue.iid}`;
     const wtCtx = this.computeWorktreeContext(issue.iid, branchName);
-    logger18.info("Processing issue", {
+    logger25.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -5246,7 +5946,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger18.info("Merge request created successfully", {
+      logger25.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -5254,7 +5954,7 @@ var PipelineOrchestrator = class {
       return { url: mr.web_url, iid: mr.iid };
     } catch (err) {
       const errorMsg = err.message;
-      logger18.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
       });
@@ -5271,7 +5971,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger18.info("Found existing merge request", {
+        logger25.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -5279,7 +5979,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger18.warn("Failed to find existing merge request", {
+      logger25.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -5324,7 +6024,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger18.error("Failed to start preview servers", {
+      logger25.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -5359,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);
     });
-    logger18.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);
@@ -5376,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) {
-      logger18.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);
@@ -5384,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) {
-      logger18.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 */);
-    logger18.info("Issue marked as deployed", { iid: issueIid });
+    logger25.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5414,7 +6114,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       throw err;
     }
     const url = this.buildPreviewUrl(issueIid);
-    logger18.info("Preview restarted", { iid: issueIid, url });
+    logger25.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -5447,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;
-    logger18.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 {
@@ -5480,7 +6180,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger18.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);
@@ -5518,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"));
-      logger18.info("Conflict resolution completed", { issueIid });
+      logger25.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger18.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()) {
@@ -5551,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) {
-      logger18.warn("Failed to comment on MR", { mrIid, error: err.message });
+      logger25.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -5627,7 +6327,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger19 = logger.child("Brainstorm");
+var logger26 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -5663,7 +6363,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger19.info("Created brainstorm session", { sessionId: session.id });
+    logger26.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -5672,7 +6372,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger19.info("Generating SDD", { sessionId });
+    logger26.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5698,7 +6398,7 @@ var BrainstormService = class {
     const session = this.requireSession(sessionId);
     const roundNum = session.rounds.length + 1;
     session.status = "reviewing";
-    logger19.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({
@@ -5731,7 +6431,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger19.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,
@@ -5818,4 +6518,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-IWSMQXBL.js.map
+//# sourceMappingURL=chunk-WZGEYHCC.js.map