@xdevops/issue-auto-finish 1.0.89 → 1.0.91

package/dist/{chunk-IWSMQXBL.js → chunk-LDGK5NMS.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);
@@ -3873,7 +4361,7 @@ function clearPendingDialog(issueIid) {
 }
 
 // src/orchestrator/steps/PhaseLoopStep.ts
-var logger15 = logger.child("PhaseLoopStep");
+var logger17 = logger.child("PhaseLoopStep");
 function resolveVerifyRunner(deps) {
   return deps.aiRunner;
 }
@@ -3889,7 +4377,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 +4386,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,10 +4427,10 @@ 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"));
   }
 }
@@ -3959,7 +4447,7 @@ function buildInputHandler(displayId, phaseName, deps) {
   };
 }
 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 +4457,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 +4476,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 +4506,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,13 +4516,36 @@ 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);
   });
 }
+function updateHooksForPhase(spec, pipelineDef, ctx, wtPlan) {
+  const phaseArtifacts = (spec.artifacts ?? []).map((a) => a.filename);
+  if (phaseArtifacts.length === 0 && spec.kind !== "ai") return;
+  try {
+    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 safeComment(deps, issueId, message) {
   try {
     await deps.gongfeng.createIssueNote(issueId, message);
@@ -4120,15 +4631,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 });
+        logger17.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 });
+          logger17.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
         } else {
-          logger15.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+          logger17.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
         }
         const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
         if (ports) {
@@ -4147,7 +4658,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
         const prevSpec = pipelineDef.phases[i];
         const pp = currentProgress.phases[prevSpec.name];
         if (pp && pp.status !== "completed") {
-          logger15.warn("Fixing stale phase progress", {
+          logger17.warn("Fixing stale phase progress", {
             iid: issue.iid,
             phase: prevSpec.name,
             was: pp.status,
@@ -4188,7 +4699,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
     }
     if (spec.kind === "gate") {
       if (deps.shouldAutoApprove(issue.labels)) {
-        logger15.info("Auto-approving review gate (matched autoApproveLabels)", {
+        logger17.info("Auto-approving review gate (matched autoApproveLabels)", {
           iid: issue.iid,
           labels: issue.labels,
           autoApproveLabels: deps.config.review.autoApproveLabels
@@ -4217,7 +4728,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       });
       deps.eventBus.emitTyped("review:requested", { issueIid: issue.iid });
-      logger15.info("Review gate reached, pausing", { iid: issue.iid });
+      logger17.info("Review gate reached, pausing", { iid: issue.iid });
       return { serversStarted, paused: true };
     }
     if (spec.name === "verify" && deps.config.verifyFixLoop.enabled) {
@@ -4226,7 +4737,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, 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 });
+      logger17.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issue.iid });
       deps.tracker.updateState(issue.iid, spec.doneState, { currentPhase: spec.name });
       wtPlan.updatePhaseProgress(spec.name, "completed");
       deps.tracker.updatePhaseProgress(issue.iid, spec.name, {
@@ -4235,10 +4746,11 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       });
       continue;
     }
+    updateHooksForPhase(spec, pipelineDef, ctx, wtPlan);
     const runner = spec.name === "verify" ? resolveVerifyRunner(deps) : spec.name === "uat" ? resolveUatRunner(deps, issue.iid) : deps.aiRunner;
     if (spec.name === "uat") {
       const runnerName = runner === deps.e2eAiRunner ? "e2eAiRunner (CodeBuddy)" : "mainRunner";
-      logger15.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
+      logger17.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
     }
     const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
     if (wtGitMap) {
@@ -4256,7 +4768,7 @@ async function executePhaseLoop(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 });
+        logger17.info("Async phase running, awaiting completion", { iid: issue.iid, phase: spec.name });
         const finalOutcome = await awaitAsyncPhase(outcome, spec, ctx, deps, wtGit, wtPlan, wtGitMap);
         if (finalOutcome.status === "completed") {
           continue;
@@ -4267,7 +4779,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       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 });
+      logger17.info("Async phase running (no awaitCompletion), pausing pipeline", { iid: issue.iid, phase: spec.name });
       return { serversStarted, paused: true };
     }
     if (spec.approvedState && outcome.data?.hasReleaseCapability) {
@@ -4275,7 +4787,7 @@ async function executePhaseLoop(ctx, deps, wtGit, wtPlan, wtGitMap) {
       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 });
+      logger17.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
       return { serversStarted, paused: true };
     }
     if (needsDeployment && !serversStarted && lifecycleManager.shouldDeployPreview(spec.name)) {
@@ -4308,7 +4820,7 @@ async function awaitAsyncPhase(outcome, spec, ctx, deps, wtGit, wtPlan, wtGitMap
     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 });
+    logger17.info("Async phase completed successfully", { iid: displayId, phase: spec.name });
     return finalOutcome;
   }
   const errMsg = finalOutcome.error?.message ?? "Unknown error";
@@ -4343,7 +4855,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     issueIid: issue.iid,
     maxIterations
   });
-  logger15.info("Verify-fix loop started", {
+  logger17.info("Verify-fix loop started", {
     iid: issue.iid,
     maxIterations,
     buildPhaseIdx
@@ -4352,11 +4864,12 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
     if (isShuttingDown()) {
       throw new ServiceShutdownError();
     }
-    logger15.info("Verify-fix loop iteration", {
+    logger17.info("Verify-fix loop iteration", {
       iteration,
       maxIterations,
       iid: issue.iid
     });
+    updateHooksForPhase(verifySpec, ctx.pipelineDef, ctx, wtPlan);
     const verifyRunner = resolveVerifyRunner(deps);
     const verifyPhase = createPhase("verify", verifyRunner, wtGit, wtPlan, deps.config);
     if (wtGitMap) {
@@ -4375,7 +4888,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
         wtGitMap
       );
     } catch (err) {
-      logger15.warn("Verify phase execution failed", {
+      logger17.warn("Verify phase execution failed", {
         iteration,
         iid: issue.iid,
         error: err.message
@@ -4407,13 +4920,13 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
       failures: report?.failureReasons
     });
     if (passed) {
-      logger15.info("Verify-fix loop passed", {
+      logger17.info("Verify-fix loop passed", {
         iteration,
         iid: issue.iid
       });
       return;
     }
-    logger15.info("Verify failed, issues found", {
+    logger17.info("Verify failed, issues found", {
       iteration,
       iid: issue.iid,
       failures: report?.failureReasons,
@@ -4426,7 +4939,7 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
         failures: report?.failureReasons ?? []
       });
       const failMsg = `Verify-fix loop exhausted after ${maxIterations} iterations. Remaining issues: ${report?.failureReasons?.join("; ") ?? "unknown"}`;
-      logger15.warn(failMsg, { iid: issue.iid });
+      logger17.warn(failMsg, { iid: issue.iid });
       throw new AIExecutionError("verify", failMsg, {
         output: report?.rawReport ?? "",
         exitCode: 0
@@ -4444,13 +4957,14 @@ async function executeVerifyFixLoop(ctx, deps, wtGit, wtPlan, verifyPhaseIdx, bu
 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", {
+  logger17.info("Looping back to build for fix", {
     iteration: fixContext.iteration,
     iid: issue.iid,
     failures: fixContext.verifyFailures
   });
   phaseCtx.fixContext = fixContext;
   try {
+    updateHooksForPhase(buildSpec, ctx.pipelineDef, ctx, wtPlan);
     const buildPhase = createPhase("build", deps.aiRunner, wtGit, wtPlan, deps.config);
     if (wtGitMap) {
       buildPhase.setWtGitMap(wtGitMap);
@@ -4471,7 +4985,7 @@ async function executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixConte
 }
 
 // src/orchestrator/steps/CompletionStep.ts
-var logger16 = logger.child("CompletionStep");
+var logger18 = logger.child("CompletionStep");
 async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
   const { issue, branchName, wtCtx } = ctx;
   deps.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
@@ -4503,7 +5017,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger16.warn("Failed to publish E2E screenshots", {
+      logger18.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -4523,19 +5037,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 });
+    logger18.info("Preview servers kept running after completion", { iid: issue.iid });
   } else {
     deps.stopPreviewServers(issue.iid);
     await deps.mainGitMutex.runExclusive(async () => {
       if (wtCtx.workspace) {
         await deps.workspaceManager.cleanupWorkspace(wtCtx.workspace);
-        logger16.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
+        logger18.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
       } else {
         try {
           await deps.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-          logger16.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+          logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger16.warn("Failed to cleanup worktree", {
+          logger18.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -4543,16 +5057,16 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger16.info("Issue processing completed", { iid: issue.iid });
+  logger18.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger17 = logger.child("FailureHandler");
+var logger19 = logger.child("FailureHandler");
 async function handleFailure(err, issue, wtCtx, deps) {
   const errorMsg = err.message;
   const isRetryable = err instanceof AIExecutionError ? err.isRetryable : true;
   const wasActiveAtTimeout = err instanceof AIExecutionError && err.wasActiveAtTimeout;
-  logger17.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable, wasActiveAtTimeout });
+  logger19.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 +5079,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     }
   }
   if (wasReset) {
-    logger17.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    logger19.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
     throw err;
   }
   if (failedAtState === "paused" /* Paused */) {
-    logger17.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
+    logger19.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
     throw err;
   }
   try {
@@ -4591,7 +5105,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", {
+      logger19.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -4599,7 +5113,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", {
+  logger19.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -4608,7 +5122,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger18 = logger.child("PipelineOrchestrator");
+var logger20 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -4638,7 +5152,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger18.info("AIRunner replaced via hot-reload");
+    logger20.info("AIRunner replaced via hot-reload");
   }
   constructor(config, gongfeng, git, aiRunner, tracker, supplementStore, mainGitMutex, eventBusInstance, wsConfig, tenantId, e2eAiRunner) {
     this.config = config;
@@ -4656,14 +5170,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 });
+    logger20.info("Pipeline mode resolved", { tenantId: this.tenantId, mode: this.pipelineDef.mode, aiMode: config.ai.mode });
     this.portAllocator = new PortAllocator({
       backendPortBase: config.e2e.backendPortBase,
       frontendPortBase: config.e2e.frontendPortBase
     });
     this.devServerManager = new DevServerManager();
     this.screenshotPublisher = new ScreenshotPublisher(gongfeng);
-    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : 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 +5186,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger18.info("WorkspaceManager initialized", {
+    logger20.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -4693,7 +5207,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger18.info("Cleaning up stale worktree state...");
+    logger20.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -4702,11 +5216,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 });
+            logger20.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
             await this.mainGit.worktreeRemove(wtDir, true).catch(() => {
             });
             await this.mainGit.worktreePrune();
@@ -4715,32 +5229,32 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger18.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger20.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);
+            logger20.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger18.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+          logger20.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
         }
       }
     } catch (err) {
-      logger18.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger20.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);
+      logger20.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger18.info("Stale state cleanup complete", { cleaned });
+    logger20.info("Stale state cleanup complete", { cleaned });
   }
   /**
    * 重启后清理幽灵端口分配。
@@ -4753,7 +5267,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 });
+        logger20.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 +5312,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger18.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger20.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger18.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger20.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
     }
   }
   async installDependencies(workDir) {
-    logger18.info("Installing dependencies in worktree", { workDir });
+    logger20.info("Installing dependencies in worktree", { workDir });
     const knowledge = getProjectKnowledge() ?? KNOWLEDGE_DEFAULTS;
     const pkgMgr = knowledge.toolchain.packageManager.toLowerCase();
     const isNodeProject = ["npm", "pnpm", "yarn", "bun"].some((m) => pkgMgr.includes(m));
     if (isNodeProject) {
       const ready = await this.ensureNodeModules(workDir);
       if (ready) {
-        logger18.info("node_modules ready \u2014 skipping install");
+        logger20.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -4824,10 +5338,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger18.info("Dependencies installed");
+      logger20.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger18.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger20.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -4837,45 +5351,45 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger18.info("Dependencies installed (fallback)");
+          logger20.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger18.warn("Fallback install also failed", {
+          logger20.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger18.warn("Install failed, no fallback configured", {
+        logger20.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);
+      logger20.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 });
+      logger20.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 });
+    logger20.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
     try {
       await execFileAsync2("rm", ["-rf", targetNM], { timeout: 6e4 });
       await execFileAsync2("cp", ["-a", "--reflink=auto", sourceNM, targetNM], {
         timeout: 12e4
       });
-      logger18.info("node_modules seeded from main repo");
+      logger20.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger18.warn("Failed to seed node_modules from main repo", {
+      logger20.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -4885,16 +5399,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 });
+    logger20.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 });
+      logger20.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger18.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger20.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -4911,19 +5425,19 @@ var PipelineOrchestrator = class {
     await this.cleanupE2eOutputs(issueIid);
     this.tracker.resetFull(issueIid);
     this.pendingActions.delete(issueIid);
-    logger18.info("Issue restarted", { issueIid });
+    logger20.info("Issue restarted", { issueIid });
   }
   async cancelIssue(issueIid) {
     const record = this.tracker.get(issueIid);
     if (!record) throw new IssueNotFoundError(issueIid);
     const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
-    logger18.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
+    logger20.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
     this.aiRunner.killByWorkDir(wtCtx.workDir);
     this.stopPreviewServers(issueIid);
     try {
       await this.gongfeng.removeLabelsWithPrefix(getExternalId(record), "auto-finish");
     } catch (err) {
-      logger18.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
+      logger20.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -4940,7 +5454,7 @@ var PipelineOrchestrator = class {
     this.tracker.clearProcessingLock(issueIid);
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
     await this.cleanupE2eOutputs(issueIid);
-    logger18.info("Issue cancelled", { issueIid });
+    logger20.info("Issue cancelled", { issueIid });
   }
   /**
    * Remove the E2E output directory for an issue: {uatVendorDir}/outputs/issue-{iid}
@@ -4948,13 +5462,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 });
+      logger20.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
     } catch (err) {
-      logger18.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
+      logger20.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
     }
   }
   /**
@@ -4966,10 +5480,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 });
+      logger20.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
     } catch (err) {
-      logger18.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
+      logger20.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
     }
   }
   retryFromPhase(issueIid, phase) {
@@ -4985,7 +5499,7 @@ var PipelineOrchestrator = class {
       this.aiRunner.killByWorkDir(wtCtx.workDir);
     }
     this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
-    logger18.info("Retrying issue from phase", { issueIid, phase });
+    logger20.info("Retrying issue from phase", { issueIid, phase });
     const ok = this.tracker.resetToPhase(issueIid, phase, issueDef);
     if (!ok) {
       throw new InvalidPhaseError(phase);
@@ -5012,7 +5526,7 @@ var PipelineOrchestrator = class {
     } else {
       this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
     }
-    logger18.info("Issue abort requested", { issueIid, state: record.state });
+    logger20.info("Issue abort requested", { issueIid, state: record.state });
   }
   continueIssue(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5022,7 +5536,7 @@ var PipelineOrchestrator = class {
     }
     const issueDef = this.getIssueSpecificPipelineDef(record);
     this.tracker.resumeFromPause(issueIid, issueDef, false);
-    logger18.info("Issue continued from pause", { issueIid });
+    logger20.info("Issue continued from pause", { issueIid });
   }
   redoPhase(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5066,7 +5580,7 @@ var PipelineOrchestrator = class {
       }
       this.eventBus.emitTyped("issue:redone", { issueIid });
     }
-    logger18.info("Issue redo requested", { issueIid, state: record.state });
+    logger20.info("Issue redo requested", { issueIid, state: record.state });
   }
   /**
    * 处理中止/重做的共享逻辑：
@@ -5139,7 +5653,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", {
+    logger20.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -5246,7 +5760,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger18.info("Merge request created successfully", {
+      logger20.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -5254,7 +5768,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", {
+      logger20.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -5271,7 +5785,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger18.info("Found existing merge request", {
+        logger20.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -5279,7 +5793,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger18.warn("Failed to find existing merge request", {
+      logger20.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -5324,7 +5838,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger18.error("Failed to start preview servers", {
+      logger20.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -5359,7 +5873,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 });
+    logger20.info("Preview stopped and worktree cleaned", { iid: issueIid });
   }
   async markDeployed(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5376,7 +5890,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 });
+      logger20.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
     }
     try {
       const issue = await this.gongfeng.getIssueDetail(externalId);
@@ -5384,10 +5898,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 });
+      logger20.warn("Failed to update labels", { iid: issueIid, error: err.message });
     }
     this.tracker.updateState(issueIid, "deployed" /* Deployed */);
-    logger18.info("Issue marked as deployed", { iid: issueIid });
+    logger20.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5414,7 +5928,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 });
+    logger20.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -5447,7 +5961,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 });
+    logger20.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
     this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
     this.eventBus.emitTyped("conflict:started", { issueIid });
     try {
@@ -5480,7 +5994,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger18.info("Running verification after conflict resolution", { issueIid });
+      logger20.info("Running verification after conflict resolution", { issueIid });
       const wtPlan = new PlanPersistence(wtCtx.workDir, issueIid);
       wtPlan.ensureDir();
       const verifyPhase = createPhase("verify", this.aiRunner, wtGit, wtPlan, this.config);
@@ -5518,10 +6032,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 });
+      logger20.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger18.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      logger20.error("Conflict resolution failed", { issueIid, error: errorMsg });
       try {
         const wtGit = new GitOperations(wtCtx.gitRootDir);
         if (await wtGit.isRebaseInProgress()) {
@@ -5551,7 +6065,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 });
+      logger20.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -5627,7 +6141,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger19 = logger.child("Brainstorm");
+var logger21 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -5663,7 +6177,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger19.info("Created brainstorm session", { sessionId: session.id });
+    logger21.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -5672,7 +6186,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger19.info("Generating SDD", { sessionId });
+    logger21.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5698,7 +6212,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 });
+    logger21.info("Reviewing SDD", { sessionId, round: roundNum });
     onEvent?.({ type: "round:start", data: { round: roundNum, phase: "review" }, round: roundNum });
     const prompt = buildReviewPrompt(session.currentSdd, roundNum);
     const result = await this.reviewerRunner.run({
@@ -5731,7 +6245,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger19.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger21.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -5818,4 +6332,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-IWSMQXBL.js.map
+//# sourceMappingURL=chunk-LDGK5NMS.js.map