@xdevops/issue-auto-finish 1.0.92 → 1.0.93

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

@@ -18,6 +18,9 @@ import {
   rePlanPrompt,
   verifyPrompt
 } from "./chunk-GPZX4DSY.js";
+import {
+  HookInjector
+} from "./chunk-HD6V7KPE.js";
 import {
   getProjectKnowledge
 } from "./chunk-ACVOOHAR.js";
@@ -233,8 +236,8 @@ var GongfengClient = class {
     const encoded = encodeURIComponent(this.projectPath);
     return `${this.apiUrl}/api/v3/projects/${encoded}`;
   }
-  async requestRaw(path13, options = {}) {
-    const url = `${this.projectApiBase}${path13}`;
+  async requestRaw(path12, options = {}) {
+    const url = `${this.projectApiBase}${path12}`;
     logger4.debug("API request", { method: options.method || "GET", url });
     return this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -251,11 +254,11 @@ var GongfengClient = class {
           throw new GongfengApiError(resp.status, `Gongfeng API error ${resp.status}: ${body}`, body);
         }
         return resp;
-      }, `requestRaw ${options.method || "GET"} ${path13}`)
+      }, `requestRaw ${options.method || "GET"} ${path12}`)
     );
   }
-  async request(path13, options = {}) {
-    const resp = await this.requestRaw(path13, options);
+  async request(path12, options = {}) {
+    const resp = await this.requestRaw(path12, options);
     return resp.json();
   }
   async createIssue(title, description, labels) {
@@ -434,8 +437,8 @@ var GongfengClient = class {
     }
     return mr;
   }
-  async requestGlobal(path13, options = {}) {
-    const url = `${this.apiUrl}${path13}`;
+  async requestGlobal(path12, options = {}) {
+    const url = `${this.apiUrl}${path12}`;
     logger4.debug("API request (global)", { method: options.method || "GET", url });
     const resp = await this.circuitBreaker.execute(
       () => this.retryPolicy.execute(async () => {
@@ -452,7 +455,7 @@ var GongfengClient = class {
           throw new GongfengApiError(r.status, `Gongfeng API error ${r.status}: ${body}`, body);
         }
         return r;
-      }, `requestGlobal ${options.method || "GET"} ${path13}`)
+      }, `requestGlobal ${options.method || "GET"} ${path12}`)
     );
     return resp.json();
   }
@@ -1646,7 +1649,7 @@ var PlanPersistence = class _PlanPersistence {
 };
 
 // src/phases/BasePhase.ts
-import path5 from "path";
+import path4 from "path";
 
 // src/rules/RuleResolver.ts
 import { readdir, readFile } from "fs/promises";
@@ -1743,454 +1746,6 @@ ${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;
@@ -2335,7 +1890,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) => path5.join(this.plan.planDir, fn)) : void 0;
+    const artifactPaths = snapshotFilenames.length > 0 ? snapshotFilenames.map((fn) => path4.join(this.plan.planDir, fn)) : void 0;
     let capturedSessionId;
     const result = await this.aiRunner.run({
       prompt,
@@ -2432,14 +1987,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 = path5.join(repo.gitRootDir, ".cursor", "rules");
+          const rulesDir = path4.join(repo.gitRootDir, ".cursor", "rules");
           try {
             await resolver.loadRules(rulesDir);
           } catch {
           }
         }
       } else {
-        const rulesDir = path5.join(this.plan.baseDir, ".cursor", "rules");
+        const rulesDir = path4.join(this.plan.baseDir, ".cursor", "rules");
         await resolver.loadRules(rulesDir);
       }
       const matched = resolver.matchRules(context);
@@ -2713,20 +2268,20 @@ var BuildPhase = class extends BasePhase {
 };
 
 // src/release/ReleaseDetectCache.ts
-import fs5 from "fs";
-import path6 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import { createHash } from "crypto";
-var logger9 = logger.child("ReleaseDetectCache");
+var logger7 = logger.child("ReleaseDetectCache");
 function hashProjectPath(projectPath) {
   return createHash("sha256").update(projectPath).digest("hex").slice(0, 16);
 }
 var ReleaseDetectCache = class {
   cacheDir;
   constructor(dataDir) {
-    this.cacheDir = path6.join(dataDir, "release-detect");
+    this.cacheDir = path5.join(dataDir, "release-detect");
   }
   filePath(projectPath) {
-    return path6.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
+    return path5.join(this.cacheDir, `${hashProjectPath(projectPath)}.json`);
   }
   /**
    * 读取缓存。返回 null 如果不存在、已过期或校验失败。
@@ -2734,21 +2289,21 @@ var ReleaseDetectCache = class {
   get(projectPath, ttlMs) {
     const fp = this.filePath(projectPath);
     try {
-      if (!fs5.existsSync(fp)) return null;
-      const raw = fs5.readFileSync(fp, "utf-8");
+      if (!fs3.existsSync(fp)) return null;
+      const raw = fs3.readFileSync(fp, "utf-8");
       const data = JSON.parse(raw);
       if (data.projectPath !== projectPath) {
-        logger9.warn("Cache projectPath mismatch, ignoring", { expected: projectPath, got: data.projectPath });
+        logger7.warn("Cache projectPath mismatch, ignoring", { expected: projectPath, got: data.projectPath });
         return null;
       }
       const age = Date.now() - new Date(data.detectedAt).getTime();
       if (age > ttlMs) {
-        logger9.debug("Cache expired", { projectPath, ageMs: age, ttlMs });
+        logger7.debug("Cache expired", { projectPath, ageMs: age, ttlMs });
         return null;
       }
       return data;
     } catch (err) {
-      logger9.warn("Failed to read release detect cache", { path: fp, error: err.message });
+      logger7.warn("Failed to read release detect cache", { path: fp, error: err.message });
       return null;
     }
   }
@@ -2758,13 +2313,13 @@ var ReleaseDetectCache = class {
   set(result) {
     const fp = this.filePath(result.projectPath);
     try {
-      if (!fs5.existsSync(this.cacheDir)) {
-        fs5.mkdirSync(this.cacheDir, { recursive: true });
+      if (!fs3.existsSync(this.cacheDir)) {
+        fs3.mkdirSync(this.cacheDir, { recursive: true });
       }
-      fs5.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
-      logger9.debug("Release detect cache written", { projectPath: result.projectPath, path: fp });
+      fs3.writeFileSync(fp, JSON.stringify(result, null, 2), "utf-8");
+      logger7.debug("Release detect cache written", { projectPath: result.projectPath, path: fp });
     } catch (err) {
-      logger9.warn("Failed to write release detect cache", { path: fp, error: err.message });
+      logger7.warn("Failed to write release detect cache", { path: fp, error: err.message });
     }
   }
   /**
@@ -2773,14 +2328,14 @@ var ReleaseDetectCache = class {
   invalidate(projectPath) {
     const fp = this.filePath(projectPath);
     try {
-      if (fs5.existsSync(fp)) {
-        fs5.unlinkSync(fp);
-        logger9.info("Release detect cache invalidated", { projectPath });
+      if (fs3.existsSync(fp)) {
+        fs3.unlinkSync(fp);
+        logger7.info("Release detect cache invalidated", { projectPath });
         return true;
       }
       return false;
     } catch (err) {
-      logger9.warn("Failed to invalidate release detect cache", { path: fp, error: err.message });
+      logger7.warn("Failed to invalidate release detect cache", { path: fp, error: err.message });
       return false;
     }
   }
@@ -3231,9 +2786,9 @@ function createLifecycleManager(def) {
 
 // src/workspace/WorkspaceConfig.ts
 import { z } from "zod";
-import fs6 from "fs";
-import path7 from "path";
-var logger10 = logger.child("WorkspaceConfig");
+import fs4 from "fs";
+import path6 from "path";
+var logger8 = logger.child("WorkspaceConfig");
 var repoConfigSchema = z.object({
   name: z.string().min(1, "Repo name is required"),
   projectPath: z.string().min(1, "Gongfeng project path is required"),
@@ -3249,29 +2804,29 @@ var workspaceConfigSchema = z.object({
 });
 function loadWorkspaceConfig(configPath) {
   if (!configPath) return null;
-  if (!fs6.existsSync(configPath)) {
-    logger10.warn("Workspace config file not found, falling back to single-repo mode", {
+  if (!fs4.existsSync(configPath)) {
+    logger8.warn("Workspace config file not found, falling back to single-repo mode", {
       path: configPath
     });
     return null;
   }
   try {
-    const raw = fs6.readFileSync(configPath, "utf-8");
+    const raw = fs4.readFileSync(configPath, "utf-8");
     const json = JSON.parse(raw);
     const result = workspaceConfigSchema.safeParse(json);
     if (!result.success) {
       const issues = result.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
-      logger10.error(`Workspace config validation failed:
+      logger8.error(`Workspace config validation failed:
 ${issues}`);
       return null;
     }
-    logger10.info("Workspace config loaded", {
+    logger8.info("Workspace config loaded", {
       primary: result.data.primary.name,
       associates: result.data.associates.map((a) => a.name)
     });
     return result.data;
   } catch (err) {
-    logger10.error("Failed to parse workspace config", {
+    logger8.error("Failed to parse workspace config", {
       path: configPath,
       error: err.message
     });
@@ -3297,14 +2852,14 @@ function isMultiRepo(ws) {
 }
 function persistWorkspaceConfig(ws, filePath) {
   try {
-    const dir = path7.dirname(filePath);
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    const dir = path6.dirname(filePath);
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
-    fs6.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
-    logger10.info("Workspace config auto-generated from .env", { path: filePath });
+    fs4.writeFileSync(filePath, JSON.stringify(ws, null, 2) + "\n", "utf-8");
+    logger8.info("Workspace config auto-generated from .env", { path: filePath });
   } catch (err) {
-    logger10.warn("Failed to persist workspace config", {
+    logger8.warn("Failed to persist workspace config", {
       path: filePath,
       error: err.message
     });
@@ -3312,12 +2867,12 @@ function persistWorkspaceConfig(ws, filePath) {
 }
 
 // src/workspace/WorkspaceManager.ts
-import path8 from "path";
-import fs7 from "fs/promises";
+import path7 from "path";
+import fs5 from "fs/promises";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
-var logger11 = logger.child("WorkspaceManager");
+var logger9 = logger.child("WorkspaceManager");
 var WorkspaceManager = class {
   wsConfig;
   worktreeBaseDir;
@@ -3346,7 +2901,7 @@ var WorkspaceManager = class {
    */
   async prepareWorkspace(issueIid, branchName, globalBaseBranch, globalBranchPrefix) {
     const wsRoot = this.getWorkspaceRoot(issueIid);
-    await fs7.mkdir(wsRoot, { recursive: true });
+    await fs5.mkdir(wsRoot, { recursive: true });
     const primaryCtx = await this.preparePrimaryRepo(
       issueIid,
       branchName,
@@ -3365,7 +2920,7 @@ var WorkspaceManager = class {
       );
       associateCtxs.push(ctx);
     }
-    logger11.info("Workspace prepared", {
+    logger9.info("Workspace prepared", {
       issueIid,
       wsRoot,
       repos: [primaryCtx.name, ...associateCtxs.map((a) => a.name)]
@@ -3390,7 +2945,7 @@ var WorkspaceManager = class {
         await git.commit(message);
         await git.push(wsCtx.branchName);
         committed.push(repo.name);
-        logger11.info("Committed and pushed changes", {
+        logger9.info("Committed and pushed changes", {
           repo: repo.name,
           branch: wsCtx.branchName
         });
@@ -3404,19 +2959,19 @@ var WorkspaceManager = class {
   async cleanupWorkspace(wsCtx) {
     try {
       await this.mainGit.worktreeRemove(wsCtx.primary.gitRootDir, true);
-      logger11.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
+      logger9.info("Primary worktree removed", { dir: wsCtx.primary.gitRootDir });
     } catch (err) {
-      logger11.warn("Failed to remove primary worktree", {
+      logger9.warn("Failed to remove primary worktree", {
         dir: wsCtx.primary.gitRootDir,
         error: err.message
       });
     }
     for (const assoc of wsCtx.associates) {
       try {
-        await fs7.rm(assoc.gitRootDir, { recursive: true, force: true });
-        logger11.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
+        await fs5.rm(assoc.gitRootDir, { recursive: true, force: true });
+        logger9.info("Associate repo dir removed", { name: assoc.name, dir: assoc.gitRootDir });
       } catch (err) {
-        logger11.warn("Failed to remove associate repo dir", {
+        logger9.warn("Failed to remove associate repo dir", {
           name: assoc.name,
           dir: assoc.gitRootDir,
           error: err.message
@@ -3424,9 +2979,9 @@ var WorkspaceManager = class {
       }
     }
     try {
-      const entries = await fs7.readdir(wsCtx.workspaceRoot);
+      const entries = await fs5.readdir(wsCtx.workspaceRoot);
       if (entries.length === 0) {
-        await fs7.rmdir(wsCtx.workspaceRoot);
+        await fs5.rmdir(wsCtx.workspaceRoot);
       }
     } catch {
     }
@@ -3438,13 +2993,13 @@ var WorkspaceManager = class {
     const wsRoot = this.getWorkspaceRoot(issueIid);
     const primary = this.wsConfig.primary;
     const defaultPrefix = globalBranchPrefix ?? primary.branchPrefix ?? "feat/issue";
-    const primaryDir = path8.join(wsRoot, primary.name);
+    const primaryDir = path7.join(wsRoot, primary.name);
     const repos = [{
       name: primary.name,
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: primaryDir,
-      workDir: path8.join(primaryDir, primary.projectSubDir ?? ""),
+      workDir: path7.join(primaryDir, primary.projectSubDir ?? ""),
       baseBranch: primary.baseBranch ?? globalBaseBranch,
       branchPrefix: primary.branchPrefix ?? defaultPrefix,
       isPrimary: true
@@ -3454,8 +3009,8 @@ var WorkspaceManager = class {
         name: assoc.name,
         projectPath: assoc.projectPath,
         role: assoc.role ?? "",
-        gitRootDir: path8.join(wsRoot, assoc.name),
-        workDir: path8.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
+        gitRootDir: path7.join(wsRoot, assoc.name),
+        workDir: path7.join(wsRoot, assoc.name, assoc.projectSubDir ?? ""),
         baseBranch: assoc.baseBranch ?? globalBaseBranch,
         branchPrefix: assoc.branchPrefix ?? defaultPrefix,
         isPrimary: false
@@ -3464,12 +3019,12 @@ var WorkspaceManager = class {
     return repos;
   }
   getWorkspaceRoot(issueIid) {
-    return path8.join(this.worktreeBaseDir, `issue-${issueIid}`);
+    return path7.join(this.worktreeBaseDir, `issue-${issueIid}`);
   }
   // ── Internal helpers ──
   async preparePrimaryRepo(issueIid, branchName, wsRoot, globalBaseBranch) {
     const primary = this.wsConfig.primary;
-    const repoDir = path8.join(wsRoot, primary.name);
+    const repoDir = path7.join(wsRoot, primary.name);
     const baseBranch = primary.baseBranch ?? globalBaseBranch;
     await this.ensurePrimaryWorktree(repoDir, branchName, baseBranch);
     return {
@@ -3477,18 +3032,18 @@ var WorkspaceManager = class {
       projectPath: primary.projectPath,
       role: primary.role ?? "",
       gitRootDir: repoDir,
-      workDir: path8.join(repoDir, primary.projectSubDir ?? ""),
+      workDir: path7.join(repoDir, primary.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: primary.branchPrefix ?? "feat/issue",
       isPrimary: true
     };
   }
   async ensurePrimaryWorktree(repoDir, branchName, baseBranch) {
-    const wsRoot = path8.dirname(repoDir);
+    const wsRoot = path7.dirname(repoDir);
     if (wsRoot !== repoDir) {
       try {
-        await fs7.access(path8.join(wsRoot, ".git"));
-        logger11.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
+        await fs5.access(path7.join(wsRoot, ".git"));
+        logger9.info("Migrating legacy worktree to primary subdir", { from: wsRoot, to: repoDir });
         await this.mainGit.worktreeRemove(wsRoot, true);
         await this.mainGit.worktreePrune();
         await this.cleanStaleDir(wsRoot);
@@ -3498,11 +3053,11 @@ var WorkspaceManager = class {
     const worktrees = await this.mainGit.worktreeList();
     if (worktrees.includes(repoDir)) {
       try {
-        await fs7.access(path8.join(repoDir, ".git"));
-        logger11.info("Reusing existing primary worktree", { dir: repoDir });
+        await fs5.access(path7.join(repoDir, ".git"));
+        logger9.info("Reusing existing primary worktree", { dir: repoDir });
         return;
       } catch {
-        logger11.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
+        logger9.warn("Primary worktree registered but .git missing, recreating", { dir: repoDir });
         await this.mainGit.worktreeRemove(repoDir, true);
         await this.mainGit.worktreePrune();
       }
@@ -3521,19 +3076,19 @@ var WorkspaceManager = class {
     await this.mainGit.worktreeAdd(repoDir, branchName, `origin/${baseBranch}`);
   }
   async prepareAssociateRepo(assoc, _issueIid, branchName, wsRoot, globalBaseBranch, globalBranchPrefix) {
-    const repoDir = path8.join(wsRoot, assoc.name);
+    const repoDir = path7.join(wsRoot, assoc.name);
     const baseBranch = assoc.baseBranch ?? globalBaseBranch;
     const cloneUrl = `${this.gongfengApiUrl}/${assoc.projectPath}.git`;
-    const gitDirExists = await this.dirExists(path8.join(repoDir, ".git"));
+    const gitDirExists = await this.dirExists(path7.join(repoDir, ".git"));
     if (!gitDirExists) {
       await this.cleanStaleDir(repoDir);
-      logger11.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
+      logger9.info("Cloning associate repo", { name: assoc.name, url: cloneUrl });
       await execFileAsync("git", ["clone", "--depth", "50", cloneUrl, repoDir], {
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024
       });
     } else {
-      logger11.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
+      logger9.info("Reusing existing associate clone", { name: assoc.name, dir: repoDir });
     }
     const assocGit = new GitOperations(repoDir);
     await assocGit.fetch();
@@ -3556,7 +3111,7 @@ var WorkspaceManager = class {
       projectPath: assoc.projectPath,
       role: assoc.role ?? "",
       gitRootDir: repoDir,
-      workDir: path8.join(repoDir, assoc.projectSubDir ?? ""),
+      workDir: path7.join(repoDir, assoc.projectSubDir ?? ""),
       baseBranch,
       branchPrefix: assoc.branchPrefix ?? globalBranchPrefix,
       isPrimary: false
@@ -3564,13 +3119,13 @@ var WorkspaceManager = class {
   }
   async cleanStaleDir(dir) {
     if (await this.dirExists(dir)) {
-      logger11.warn("Removing stale directory", { dir });
-      await fs7.rm(dir, { recursive: true, force: true });
+      logger9.warn("Removing stale directory", { dir });
+      await fs5.rm(dir, { recursive: true, force: true });
     }
   }
   async dirExists(dir) {
     try {
-      await fs7.access(dir);
+      await fs5.access(dir);
       return true;
     } catch {
       return false;
@@ -3579,8 +3134,8 @@ var WorkspaceManager = class {
 };
 
 // src/orchestrator/PipelineOrchestrator.ts
-import path12 from "path";
-import fs11 from "fs/promises";
+import path11 from "path";
+import fs9 from "fs/promises";
 import fsSync from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -3613,8 +3168,8 @@ function mapSupplement(s) {
 }
 
 // src/utils/MergeRequestHelper.ts
-import fs8 from "fs";
-import path9 from "path";
+import fs6 from "fs";
+import path8 from "path";
 var TAPD_PATTERNS = [
   /--story=(\d+)/i,
   /--bug=(\d+)/i,
@@ -3658,9 +3213,9 @@ function generateMRDescription(options) {
     ];
     const planSections = [];
     for (const { filename, label } of summaryFiles) {
-      const filePath = path9.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
-      if (fs8.existsSync(filePath)) {
-        const content = fs8.readFileSync(filePath, "utf-8");
+      const filePath = path8.join(planDir, ".claude-plan", `issue-${issueIid}`, filename);
+      if (fs6.existsSync(filePath)) {
+        const content = fs6.readFileSync(filePath, "utf-8");
         const summary = extractSummary(content);
         if (summary) {
           planSections.push(`### ${label}
@@ -3684,7 +3239,7 @@ function extractSummary(content, maxLines = 20) {
 
 // src/deploy/PortAllocator.ts
 import net from "net";
-var logger12 = logger.child("PortAllocator");
+var logger10 = logger.child("PortAllocator");
 var DEFAULT_OPTIONS = {
   backendPortBase: 4e3,
   frontendPortBase: 9e3,
@@ -3709,7 +3264,7 @@ var PortAllocator = class {
   async allocate(issueIid) {
     const existing = this.allocated.get(issueIid);
     if (existing) {
-      logger12.info("Returning already allocated ports", { issueIid, ports: existing });
+      logger10.info("Returning already allocated ports", { issueIid, ports: existing });
       return existing;
     }
     const usedBackend = new Set([...this.allocated.values()].map((p) => p.backendPort));
@@ -3727,10 +3282,10 @@ var PortAllocator = class {
       if (beOk && feOk) {
         const pair = { backendPort, frontendPort };
         this.allocated.set(issueIid, pair);
-        logger12.info("Ports allocated", { issueIid, ...pair });
+        logger10.info("Ports allocated", { issueIid, ...pair });
         return pair;
       }
-      logger12.debug("Port pair unavailable, trying next", {
+      logger10.debug("Port pair unavailable, trying next", {
         backendPort,
         frontendPort,
         beOk,
@@ -3745,7 +3300,7 @@ var PortAllocator = class {
     const pair = this.allocated.get(issueIid);
     if (pair) {
       this.allocated.delete(issueIid);
-      logger12.info("Ports released", { issueIid, ...pair });
+      logger10.info("Ports released", { issueIid, ...pair });
     }
   }
   getPortsForIssue(issueIid) {
@@ -3756,15 +3311,15 @@ var PortAllocator = class {
   }
   restore(issueIid, ports) {
     this.allocated.set(issueIid, ports);
-    logger12.info("Ports restored from persistence", { issueIid, ...ports });
+    logger10.info("Ports restored from persistence", { issueIid, ...ports });
   }
 };
 
 // src/deploy/DevServerManager.ts
 import { spawn } from "child_process";
-import fs9 from "fs";
-import path10 from "path";
-var logger13 = logger.child("DevServerManager");
+import fs7 from "fs";
+import path9 from "path";
+var logger11 = logger.child("DevServerManager");
 var DEFAULT_OPTIONS2 = {};
 var DevServerManager = class {
   servers = /* @__PURE__ */ new Map();
@@ -3772,25 +3327,25 @@ var DevServerManager = class {
   logDir;
   constructor(options) {
     this.options = { ...DEFAULT_OPTIONS2, ...options };
-    this.logDir = path10.join(resolveDataDir(), "preview-logs");
-    if (!fs9.existsSync(this.logDir)) {
-      fs9.mkdirSync(this.logDir, { recursive: true });
+    this.logDir = path9.join(resolveDataDir(), "preview-logs");
+    if (!fs7.existsSync(this.logDir)) {
+      fs7.mkdirSync(this.logDir, { recursive: true });
     }
   }
   getLogPath(issueIid, type) {
-    const filePath = path10.join(this.logDir, `${issueIid}-${type}.log`);
-    return fs9.existsSync(filePath) ? filePath : null;
+    const filePath = path9.join(this.logDir, `${issueIid}-${type}.log`);
+    return fs7.existsSync(filePath) ? filePath : null;
   }
   async startServers(wtCtx, ports) {
     if (this.servers.has(wtCtx.issueIid)) {
-      logger13.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
+      logger11.info("Servers already running for issue", { issueIid: wtCtx.issueIid });
       return;
     }
-    logger13.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
-    const backendLogPath = 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" });
+    logger11.info("Starting dev servers", { issueIid: wtCtx.issueIid, ...ports });
+    const backendLogPath = path9.join(this.logDir, `${wtCtx.issueIid}-backend.log`);
+    const frontendLogPath = path9.join(this.logDir, `${wtCtx.issueIid}-frontend.log`);
+    const backendLog = fs7.createWriteStream(backendLogPath, { flags: "a" });
+    const frontendLog = fs7.createWriteStream(frontendLogPath, { flags: "a" });
     const tsLine = (stream, data) => `[${(/* @__PURE__ */ new Date()).toISOString()}] [${stream}] ${data.toString().trimEnd()}
 `;
     const backendEnv = {
@@ -3814,9 +3369,9 @@ var DevServerManager = class {
       backendLog.write(tsLine("stderr", data));
     });
     backend.on("exit", (code) => {
-      logger13.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
+      logger11.info("Backend process exited", { issueIid: wtCtx.issueIid, code });
     });
-    const frontendDir = path10.join(wtCtx.workDir, "frontend");
+    const frontendDir = path9.join(wtCtx.workDir, "frontend");
     const frontendEnv = {
       ...process.env,
       BACKEND_PORT: String(ports.backendPort),
@@ -3838,7 +3393,7 @@ var DevServerManager = class {
       frontendLog.write(tsLine("stderr", data));
     });
     frontend.on("exit", (code) => {
-      logger13.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
+      logger11.info("Frontend process exited", { issueIid: wtCtx.issueIid, code });
     });
     const serverSet = {
       backend,
@@ -3850,14 +3405,14 @@ var DevServerManager = class {
       frontendLog
     };
     this.servers.set(wtCtx.issueIid, serverSet);
-    logger13.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
+    logger11.info("Dev servers spawned, waiting for startup", { issueIid: wtCtx.issueIid, ...ports });
     await new Promise((r) => setTimeout(r, 1e4));
-    logger13.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
+    logger11.info("Dev servers startup grace period done", { issueIid: wtCtx.issueIid });
   }
   stopServers(issueIid) {
     const set = this.servers.get(issueIid);
     if (!set) return;
-    logger13.info("Stopping dev servers", { issueIid, ports: set.ports });
+    logger11.info("Stopping dev servers", { issueIid, ports: set.ports });
     killProcess(set.backend, `backend #${issueIid}`);
     killProcess(set.frontend, `frontend #${issueIid}`);
     set.backendLog.end();
@@ -3894,7 +3449,7 @@ function killProcess(proc, label) {
     }
     setTimeout(() => {
       if (!proc.killed && proc.exitCode === null) {
-        logger13.warn(`Force killing ${label}`);
+        logger11.warn(`Force killing ${label}`);
         try {
           process.kill(-pid, "SIGKILL");
         } catch {
@@ -3903,7 +3458,7 @@ function killProcess(proc, label) {
       }
     }, 5e3);
   } catch (err) {
-    logger13.warn(`Failed to kill ${label}`, { error: err.message });
+    logger11.warn(`Failed to kill ${label}`, { error: err.message });
   }
 }
 
@@ -3922,13 +3477,13 @@ function isE2eEnabledForIssue(issueIid, tracker, cfg) {
 }
 
 // src/e2e/ScreenshotCollector.ts
-import fs10 from "fs";
-import path11 from "path";
-var logger14 = logger.child("ScreenshotCollector");
+import fs8 from "fs";
+import path10 from "path";
+var logger12 = logger.child("ScreenshotCollector");
 var MAX_SCREENSHOTS = 20;
 function walkDir(dir, files = []) {
-  for (const entry of fs10.readdirSync(dir, { withFileTypes: true })) {
-    const full = path11.join(dir, entry.name);
+  for (const entry of fs8.readdirSync(dir, { withFileTypes: true })) {
+    const full = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       walkDir(full, files);
     } else if (entry.isFile() && entry.name.endsWith(".png")) {
@@ -3938,34 +3493,34 @@ function walkDir(dir, files = []) {
   return files;
 }
 function collectScreenshots(workDir) {
-  const testResultsDir = path11.join(workDir, "frontend", "test-results");
-  if (!fs10.existsSync(testResultsDir)) {
-    logger14.debug("test-results directory not found", { dir: testResultsDir });
+  const testResultsDir = path10.join(workDir, "frontend", "test-results");
+  if (!fs8.existsSync(testResultsDir)) {
+    logger12.debug("test-results directory not found", { dir: testResultsDir });
     return [];
   }
   const pngFiles = walkDir(testResultsDir);
   if (pngFiles.length === 0) {
-    logger14.debug("No screenshots found");
+    logger12.debug("No screenshots found");
     return [];
   }
   const screenshots = pngFiles.map((filePath) => {
-    const relative = path11.relative(testResultsDir, filePath);
-    const testName = relative.split(path11.sep)[0] || path11.basename(filePath, ".png");
+    const relative = path10.relative(testResultsDir, filePath);
+    const testName = relative.split(path10.sep)[0] || path10.basename(filePath, ".png");
     return { filePath, testName };
   });
   if (screenshots.length > MAX_SCREENSHOTS) {
-    logger14.warn("Too many screenshots, truncating", {
+    logger12.warn("Too many screenshots, truncating", {
       total: screenshots.length,
       max: MAX_SCREENSHOTS
     });
     return screenshots.slice(0, MAX_SCREENSHOTS);
   }
-  logger14.info("Screenshots collected", { count: screenshots.length });
+  logger12.info("Screenshots collected", { count: screenshots.length });
   return screenshots;
 }
 
 // src/e2e/ScreenshotPublisher.ts
-var logger15 = logger.child("ScreenshotPublisher");
+var logger13 = logger.child("ScreenshotPublisher");
 function buildComment(uploaded, truncated) {
   const lines = [t("screenshot.title"), ""];
   for (const item of uploaded) {
@@ -3984,12 +3539,12 @@ var ScreenshotPublisher = class {
     const { workDir, issueIid, issueId, mrIid } = options;
     const screenshots = collectScreenshots(workDir);
     if (screenshots.length === 0) {
-      logger15.info("No E2E screenshots to publish", { issueIid });
+      logger13.info("No E2E screenshots to publish", { issueIid });
       return;
     }
     const uploaded = await this.uploadAll(screenshots);
     if (uploaded.length === 0) {
-      logger15.warn("All screenshot uploads failed", { issueIid });
+      logger13.warn("All screenshot uploads failed", { issueIid });
       return;
     }
     const truncated = screenshots.length >= 20;
@@ -3998,7 +3553,7 @@ var ScreenshotPublisher = class {
     if (mrIid) {
       await this.postToMergeRequest(mrIid, comment);
     }
-    logger15.info("E2E screenshots published", {
+    logger13.info("E2E screenshots published", {
       issueIid,
       mrIid,
       count: uploaded.length
@@ -4014,7 +3569,7 @@ var ScreenshotPublisher = class {
           markdown: result.markdown
         });
       } catch (err) {
-        logger15.warn("Failed to upload screenshot", {
+        logger13.warn("Failed to upload screenshot", {
           filePath: screenshot.filePath,
           error: err.message
         });
@@ -4026,7 +3581,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createIssueNote(issueId, comment);
     } catch (err) {
-      logger15.warn("Failed to post screenshots to issue", {
+      logger13.warn("Failed to post screenshots to issue", {
         issueId,
         error: err.message
       });
@@ -4036,7 +3591,7 @@ var ScreenshotPublisher = class {
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, comment);
     } catch (err) {
-      logger15.warn("Failed to post screenshots to merge request", {
+      logger13.warn("Failed to post screenshots to merge request", {
         mrIid,
         error: err.message
       });
@@ -4219,7 +3774,7 @@ metrics.registerCounter("iaf_braindump_batches_total", "Total braindump batches"
 metrics.registerCounter("iaf_braindump_tasks_total", "Total braindump tasks");
 
 // src/orchestrator/steps/SetupStep.ts
-var logger16 = logger.child("SetupStep");
+var logger14 = logger.child("SetupStep");
 async function executeSetup(ctx, deps) {
   const { issue, wtCtx, record, pipelineDef, branchName } = ctx;
   try {
@@ -4228,7 +3783,7 @@ async function executeSetup(ctx, deps) {
       "auto-finish:processing"
     ]);
   } catch (err) {
-    logger16.warn("Failed to update issue labels", { error: err.message });
+    logger14.warn("Failed to update issue labels", { error: err.message });
   }
   await deps.mainGitMutex.runExclusive(async () => {
     deps.emitProgress(issue.iid, "fetch", t("orchestrator.fetchProgress"));
@@ -4287,7 +3842,7 @@ async function executeSetup(ctx, deps) {
         issueDescription: issue.description
       });
     } catch (err) {
-      logger16.warn("Failed to inject Claude Code hooks (non-blocking)", {
+      logger14.warn("Failed to inject Claude Code hooks (non-blocking)", {
         error: err.message
       });
     }
@@ -4399,7 +3954,7 @@ function clearPendingDialog(issueIid) {
 }
 
 // src/orchestrator/steps/PhaseHelpers.ts
-var logger17 = logger.child("PhaseHelpers");
+var logger15 = logger.child("PhaseHelpers");
 async function safeComment(deps, issueId, message) {
   try {
     await deps.gongfeng.createIssueNote(issueId, message);
@@ -4421,7 +3976,7 @@ async function commitPlanFiles(ctx, wtGit, wtGitMap, phaseName, displayId) {
     for (const repo of ctx.workspace.repos) {
       const repoGit = wtGitMap?.get(repo.name);
       if (!repoGit) {
-        logger17.warn("Missing GitOperations for repo, skipping commit", { repo: repo.name });
+        logger15.warn("Missing GitOperations for repo, skipping commit", { repo: repo.name });
         continue;
       }
       const branch = repo.branchPrefix ? `${repo.branchPrefix}-${displayId}` : ctx.branchName;
@@ -4430,10 +3985,10 @@ async function commitPlanFiles(ctx, wtGit, wtGitMap, phaseName, displayId) {
           await repoGit.add(["."]);
           await repoGit.commit(commitMsg);
           await repoGit.push(branch);
-          logger17.info("Committed changes for repo", { repo: repo.name, branch });
+          logger15.info("Committed changes for repo", { repo: repo.name, branch });
         }
       } catch (err) {
-        logger17.warn("Failed to commit/push for repo", {
+        logger15.warn("Failed to commit/push for repo", {
           repo: repo.name,
           error: err.message
         });
@@ -4471,15 +4026,15 @@ async function syncResultToIssue(phase, ctx, displayId, phaseName, deps, issueId
         summary
       );
       await safeComment(deps, issueId, comment);
-      logger17.info("Result synced to issue", { issueIid: displayId, file: file.filename });
+      logger15.info("Result synced to issue", { issueIid: displayId, file: file.filename });
     }
   } catch (err) {
-    logger17.warn("Failed to sync result to issue", { error: err.message });
+    logger15.warn("Failed to sync result to issue", { error: err.message });
     await safeComment(deps, issueId, issueProgressComment(phaseName, "completed"));
   }
 }
 function handlePlanApproval(displayId, phaseName, deps) {
-  logger17.info("ACP plan-approval requested, delegating to review gate", {
+  logger15.info("ACP plan-approval requested, delegating to review gate", {
     issueIid: displayId,
     phase: phaseName
   });
@@ -4489,14 +4044,14 @@ function handlePlanApproval(displayId, phaseName, deps) {
       const data = payload.data;
       if (data.issueIid !== displayId) return;
       cleanup();
-      logger17.info("ACP plan-approval approved via review gate", { issueIid: displayId });
+      logger15.info("ACP plan-approval approved via review gate", { issueIid: displayId });
       resolve("allow");
     };
     const onRejected = (payload) => {
       const data = payload.data;
       if (data.issueIid !== displayId) return;
       cleanup();
-      logger17.info("ACP plan-approval rejected via review gate", { issueIid: displayId });
+      logger15.info("ACP plan-approval rejected via review gate", { issueIid: displayId });
       resolve("reject");
     };
     const cleanup = () => {
@@ -4508,7 +4063,7 @@ function handlePlanApproval(displayId, phaseName, deps) {
   });
 }
 function handleInteractiveDialog(displayId, phaseName, deps, request) {
-  logger17.info("Interactive dialog forwarded to frontend", {
+  logger15.info("Interactive dialog forwarded to frontend", {
     issueIid: displayId,
     phase: phaseName,
     question: request.content.slice(0, 80),
@@ -4538,7 +4093,7 @@ function handleInteractiveDialog(displayId, phaseName, deps, request) {
       if (data.issueIid !== displayId) return;
       cleanup();
       clearPendingDialog(displayId);
-      logger17.info("Interactive dialog response received from frontend", {
+      logger15.info("Interactive dialog response received from frontend", {
         issueIid: displayId,
         response: data.response
       });
@@ -4548,7 +4103,7 @@ function handleInteractiveDialog(displayId, phaseName, deps, request) {
       const data = payload.data;
       if (data.issueIid !== displayId) return;
       cleanup();
-      logger17.info("Interactive dialog dismissed by user (false positive)", { issueIid: displayId });
+      logger15.info("Interactive dialog dismissed by user (false positive)", { issueIid: displayId });
       resolve("");
     };
     deps.eventBus.on("agent:inputResponse", onResponse);
@@ -4572,7 +4127,7 @@ function updateHooksForPhase(spec, pipelineDef, ctx, wtPlan) {
       issueDescription: ctx.issue.description
     });
   } catch (err) {
-    logger17.warn("Failed to update hooks for phase (non-blocking)", {
+    logger15.warn("Failed to update hooks for phase (non-blocking)", {
       phase: spec.name,
       error: err.message
     });
@@ -4580,7 +4135,7 @@ function updateHooksForPhase(spec, pipelineDef, ctx, wtPlan) {
 }
 
 // src/lifecycle/DefaultLifecycleHook.ts
-var logger18 = logger.child("DefaultLifecycleHook");
+var logger16 = logger.child("DefaultLifecycleHook");
 var DefaultLifecycleHook = class {
   async beforePhase(ctx) {
     const { spec, issueCtx, deps, wtPlan } = ctx;
@@ -4680,7 +4235,7 @@ function createCallbacksFromHook(hook, ctx) {
 }
 
 // src/orchestrator/strategies/GateStrategy.ts
-var logger19 = logger.child("GateStrategy");
+var logger17 = logger.child("GateStrategy");
 var GateStrategy = class {
   name = "gate";
   shouldSkip() {
@@ -4690,7 +4245,7 @@ var GateStrategy = class {
     const { spec, issueCtx, deps, wtPlan } = ctx;
     const { issue } = issueCtx;
     if (deps.shouldAutoApprove(issue.labels)) {
-      logger19.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
@@ -4716,19 +4271,19 @@ var GateStrategy = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     deps.eventBus.emitTyped("review:requested", { issueIid: issue.iid });
-    logger19.info("Review gate reached, pausing", { iid: issue.iid });
+    logger17.info("Review gate reached, pausing", { iid: issue.iid });
     return { paused: true };
   }
 };
 
 // src/orchestrator/strategies/AiPhaseStrategy.ts
-var logger20 = logger.child("AiPhaseStrategy");
+var logger18 = logger.child("AiPhaseStrategy");
 var AiPhaseStrategy = class {
   name = "ai";
   shouldSkip(ctx) {
     const { spec, issueCtx, deps } = ctx;
     if (spec.name === "uat" && !isE2eEnabledForIssue(issueCtx.issue.iid, deps.tracker, deps.config)) {
-      logger20.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issueCtx.issue.iid });
+      logger18.info("UAT phase skipped (E2E not enabled for this issue)", { iid: issueCtx.issue.iid });
       return true;
     }
     return false;
@@ -4749,7 +4304,7 @@ var AiPhaseStrategy = class {
     const runner = this.resolveRunner(ctx);
     if (spec.name === "uat") {
       const runnerName = runner === deps.e2eAiRunner ? "e2eAiRunner (CodeBuddy)" : "mainRunner";
-      logger20.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
+      logger18.info("UAT phase starting", { iid: issue.iid, runner: runnerName });
     }
     const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
     if (wtGitMap) phase.setWtGitMap(wtGitMap);
@@ -4783,7 +4338,7 @@ var AiPhaseStrategy = class {
     const { spec, issueCtx, deps, wtGit, wtPlan, wtGitMap } = ctx;
     const { issue, phaseCtx } = issueCtx;
     if (outcome.awaitCompletion) {
-      logger20.info("Async phase running, awaiting completion", { iid: issue.iid, phase: spec.name });
+      logger18.info("Async phase running, awaiting completion", { iid: issue.iid, phase: spec.name });
       const finalOutcome = await outcome.awaitCompletion;
       if (finalOutcome.sessionId) {
         wtPlan.updatePhaseSessionId(spec.name, finalOutcome.sessionId);
@@ -4799,7 +4354,7 @@ var AiPhaseStrategy = class {
         const runner = this.resolveRunner(ctx);
         const phase = createPhase(spec.name, runner, wtGit, wtPlan, deps.config);
         await syncResultToIssue(phase, phaseCtx, issue.iid, spec.name, deps, issue.id, wtPlan);
-        logger20.info("Async phase completed successfully", { iid: issue.iid, phase: spec.name });
+        logger18.info("Async phase completed successfully", { iid: issue.iid, phase: spec.name });
         return { paused: false };
       }
       const errMsg = finalOutcome.error?.message ?? "Unknown error";
@@ -4825,7 +4380,7 @@ var AiPhaseStrategy = class {
     deps.tracker.updatePhaseProgress(issue.iid, spec.name, { status: "gate_waiting" });
     const gateEvent = spec.name === "uat" ? "uat:gateRequested" : "release:gateRequested";
     deps.eventBus.emitTyped(gateEvent, { issueIid: issue.iid });
-    logger20.info("Async phase running (no awaitCompletion), pausing pipeline", {
+    logger18.info("Async phase running (no awaitCompletion), pausing pipeline", {
       iid: issue.iid,
       phase: spec.name
     });
@@ -4838,13 +4393,13 @@ var AiPhaseStrategy = class {
     wtPlan.updatePhaseProgress(spec.name, "gate_waiting");
     deps.tracker.updatePhaseProgress(issue.iid, spec.name, { status: "gate_waiting" });
     deps.eventBus.emitTyped("release:gateRequested", { issueIid: issue.iid });
-    logger20.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
+    logger18.info("Phase requested gate, pausing", { iid: issue.iid, phase: spec.name });
     return { paused: true };
   }
 };
 
 // src/orchestrator/strategies/VerifyFixStrategy.ts
-var logger21 = logger.child("VerifyFixStrategy");
+var logger19 = logger.child("VerifyFixStrategy");
 var VerifyFixStrategy = class {
   name = "verify-fix";
   shouldSkip() {
@@ -4861,14 +4416,14 @@ var VerifyFixStrategy = class {
       issueIid: issue.iid,
       maxIterations
     });
-    logger21.info("Verify-fix loop started", {
+    logger19.info("Verify-fix loop started", {
       iid: issue.iid,
       maxIterations,
       buildPhaseIdx
     });
     for (let iteration = 1; iteration <= maxIterations; iteration++) {
       if (isShuttingDown()) throw new ServiceShutdownError();
-      logger21.info("Verify-fix loop iteration", { iteration, maxIterations, iid: issue.iid });
+      logger19.info("Verify-fix loop iteration", { iteration, maxIterations, iid: issue.iid });
       updateHooksForPhase(verifySpec, pipelineDef, issueCtx, wtPlan);
       const verifyRunner = resolveVerifyRunner(deps);
       const verifyPhase = createPhase("verify", verifyRunner, wtGit, wtPlan, deps.config);
@@ -4887,7 +4442,7 @@ var VerifyFixStrategy = class {
           hooks
         );
       } catch (err) {
-        logger21.warn("Verify phase execution failed", {
+        logger19.warn("Verify phase execution failed", {
           iteration,
           iid: issue.iid,
           error: err.message
@@ -4917,10 +4472,10 @@ var VerifyFixStrategy = class {
         failures: report?.failureReasons
       });
       if (passed) {
-        logger21.info("Verify-fix loop passed", { iteration, iid: issue.iid });
+        logger19.info("Verify-fix loop passed", { iteration, iid: issue.iid });
         return { paused: false };
       }
-      logger21.info("Verify failed, issues found", {
+      logger19.info("Verify failed, issues found", {
         iteration,
         iid: issue.iid,
         failures: report?.failureReasons,
@@ -4933,7 +4488,7 @@ var VerifyFixStrategy = class {
           failures: report?.failureReasons ?? []
         });
         const failMsg = `Verify-fix loop exhausted after ${maxIterations} iterations. Remaining issues: ${report?.failureReasons?.join("; ") ?? "unknown"}`;
-        logger21.warn(failMsg, { iid: issue.iid });
+        logger19.warn(failMsg, { iid: issue.iid });
         throw new AIExecutionError("verify", failMsg, {
           output: report?.rawReport ?? "",
           exitCode: 0
@@ -4952,7 +4507,7 @@ var VerifyFixStrategy = class {
   async executeBuildFix(ctx, deps, wtGit, wtPlan, buildPhaseIdx, fixContext, wtGitMap, hooks) {
     const { issue, phaseCtx, pipelineDef } = ctx;
     const buildSpec = pipelineDef.phases[buildPhaseIdx];
-    logger21.info("Looping back to build for fix", {
+    logger19.info("Looping back to build for fix", {
       iteration: fixContext.iteration,
       iid: issue.iid,
       failures: fixContext.verifyFailures
@@ -5000,7 +4555,7 @@ function resolveStrategy(spec, config) {
 }
 
 // src/orchestrator/steps/PhaseLoopStep.ts
-var logger22 = logger.child("PhaseLoopStep");
+var logger20 = logger.child("PhaseLoopStep");
 async function runPhaseWithLifecycle(phase, phaseCtx, spec, ctx, deps, wtGit, wtPlan, wtGitMap, hook) {
   const lifecycleHook = hook ?? new DefaultLifecycleHook();
   const execCtx = {
@@ -5065,15 +4620,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)) {
-        logger22.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
+        logger20.info("Restored preview ports from allocator", { iid: issue.iid, ...existingPorts });
         phaseCtx.ports = existingPorts;
         ctx.wtCtx.ports = existingPorts;
         serversStarted = true;
       } else {
         if (existingPorts) {
-          logger22.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
+          logger20.info("Ports allocated but servers not running, restarting", { iid: issue.iid });
         } else {
-          logger22.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
+          logger20.info("Restarting preview servers for resumed pipeline", { iid: issue.iid });
         }
         const ports = await deps.startPreviewServers(ctx.wtCtx, issue);
         if (ports) {
@@ -5139,7 +4694,7 @@ function healStaleProgress(ctx, deps, wtPlan, startIdx) {
       const prevSpec = pipelineDef.phases[i];
       const pp = currentProgress.phases[prevSpec.name];
       if (pp && pp.status !== "completed") {
-        logger22.warn("Fixing stale phase progress", {
+        logger20.warn("Fixing stale phase progress", {
           iid: issue.iid,
           phase: prevSpec.name,
           was: pp.status,
@@ -5171,7 +4726,7 @@ function healStaleProgress(ctx, deps, wtPlan, startIdx) {
 }
 
 // src/orchestrator/steps/CompletionStep.ts
-var logger23 = logger.child("CompletionStep");
+var logger21 = logger.child("CompletionStep");
 async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
   const { issue, branchName, wtCtx } = ctx;
   deps.emitProgress(issue.iid, "create_mr", t("orchestrator.createMrProgress"));
@@ -5203,7 +4758,7 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
         mrIid: void 0
       });
     } catch (err) {
-      logger23.warn("Failed to publish E2E screenshots", {
+      logger21.warn("Failed to publish E2E screenshots", {
         iid: issue.iid,
         error: err.message
       });
@@ -5223,19 +4778,19 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
     await deps.claimer.releaseClaim(issue.id, issue.iid, "completed");
   }
   if (phaseResult.serversStarted && deps.config.preview.keepAfterComplete) {
-    logger23.info("Preview servers kept running after completion", { iid: issue.iid });
+    logger21.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);
-        logger23.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
+        logger21.info("Workspace cleaned up", { dir: wtCtx.workspace.workspaceRoot });
       } else {
         try {
           await deps.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-          logger23.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+          logger21.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
         } catch (err) {
-          logger23.warn("Failed to cleanup worktree", {
+          logger21.warn("Failed to cleanup worktree", {
             dir: wtCtx.gitRootDir,
             error: err.message
           });
@@ -5243,16 +4798,16 @@ async function executeCompletion(ctx, deps, phaseResult, _wtGitMap) {
       }
     });
   }
-  logger23.info("Issue processing completed", { iid: issue.iid });
+  logger21.info("Issue processing completed", { iid: issue.iid });
 }
 
 // src/orchestrator/steps/FailureHandler.ts
-var logger24 = logger.child("FailureHandler");
+var logger22 = 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;
-  logger24.error("Issue processing failed", { iid: issue.iid, error: errorMsg, isRetryable, wasActiveAtTimeout });
+  logger22.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 */;
@@ -5265,11 +4820,11 @@ async function handleFailure(err, issue, wtCtx, deps) {
     }
   }
   if (wasReset) {
-    logger24.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
+    logger22.info("Issue was reset during processing, skipping failure marking", { iid: issue.iid });
     throw err;
   }
   if (failedAtState === "paused" /* Paused */) {
-    logger24.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
+    logger22.info("Issue was paused during processing, skipping failure handling", { iid: issue.iid });
     throw err;
   }
   try {
@@ -5291,7 +4846,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
     try {
       await deps.claimer.releaseClaim(issue.id, issue.iid, "failed");
     } catch (releaseErr) {
-      logger24.warn("Failed to release lock on failure", {
+      logger22.warn("Failed to release lock on failure", {
         iid: issue.iid,
         error: releaseErr.message
       });
@@ -5299,7 +4854,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];
-  logger24.info("Worktree(s) preserved for debugging", {
+  logger22.info("Worktree(s) preserved for debugging", {
     primary: wtCtx.gitRootDir,
     all: preservedDirs
   });
@@ -5308,7 +4863,7 @@ async function handleFailure(err, issue, wtCtx, deps) {
 
 // src/orchestrator/PipelineOrchestrator.ts
 var execFileAsync2 = promisify2(execFile2);
-var logger25 = logger.child("PipelineOrchestrator");
+var logger23 = logger.child("PipelineOrchestrator");
 var PipelineOrchestrator = class {
   config;
   gongfeng;
@@ -5338,7 +4893,7 @@ var PipelineOrchestrator = class {
   setAIRunner(runner) {
     this.aiRunner = runner;
     this.conflictResolver = new ConflictResolver(runner);
-    logger25.info("AIRunner replaced via hot-reload");
+    logger23.info("AIRunner replaced via hot-reload");
   }
   constructor(config, gongfeng, git, aiRunner, tracker, supplementStore, mainGitMutex, eventBusInstance, wsConfig, tenantId, e2eAiRunner) {
     this.config = config;
@@ -5356,14 +4911,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);
-    logger25.info("Pipeline mode resolved", { tenantId: this.tenantId, mode: this.pipelineDef.mode, aiMode: config.ai.mode });
+    logger23.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 : path12.join(config.project.worktreeBaseDir, this.tenantId);
+    this.effectiveWorktreeBaseDir = this.tenantId === "default" ? config.project.worktreeBaseDir : path11.join(config.project.worktreeBaseDir, this.tenantId);
     const effectiveWsConfig = wsConfig ?? buildSingleRepoWorkspace(config.project, config.gongfeng.projectPath);
     this.workspaceManager = new WorkspaceManager({
       wsConfig: effectiveWsConfig,
@@ -5372,7 +4927,7 @@ var PipelineOrchestrator = class {
       mainGitMutex: this.mainGitMutex,
       gongfengApiUrl: config.gongfeng.apiUrl
     });
-    logger25.info("WorkspaceManager initialized", {
+    logger23.info("WorkspaceManager initialized", {
       tenantId: this.tenantId,
       primary: effectiveWsConfig.primary.name,
       associates: effectiveWsConfig.associates.map((a) => a.name)
@@ -5393,7 +4948,7 @@ var PipelineOrchestrator = class {
     this.claimer = claimer;
   }
   async cleanupStaleState() {
-    logger25.info("Cleaning up stale worktree state...");
+    logger23.info("Cleaning up stale worktree state...");
     let cleaned = 0;
     const repoGitRoot = this.config.project.gitRootDir;
     try {
@@ -5402,11 +4957,11 @@ var PipelineOrchestrator = class {
         if (wtDir === repoGitRoot) continue;
         if (!wtDir.includes("/issue-")) continue;
         try {
-          const gitFile = path12.join(wtDir, ".git");
+          const gitFile = path11.join(wtDir, ".git");
           try {
-            await fs11.access(gitFile);
+            await fs9.access(gitFile);
           } catch {
-            logger25.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
+            logger23.warn("Worktree corrupted (.git missing), force removing", { dir: wtDir });
             await this.mainGit.worktreeRemove(wtDir, true).catch(() => {
             });
             await this.mainGit.worktreePrune();
@@ -5415,32 +4970,32 @@ var PipelineOrchestrator = class {
           }
           const wtGit = new GitOperations(wtDir);
           if (await wtGit.isRebaseInProgress()) {
-            logger25.warn("Aborting residual rebase in worktree", { dir: wtDir });
+            logger23.warn("Aborting residual rebase in worktree", { dir: wtDir });
             await wtGit.rebaseAbort();
             cleaned++;
           }
-          const indexLock = path12.join(wtDir, ".git", "index.lock");
+          const indexLock = path11.join(wtDir, ".git", "index.lock");
           try {
-            await fs11.unlink(indexLock);
-            logger25.warn("Removed stale index.lock", { path: indexLock });
+            await fs9.unlink(indexLock);
+            logger23.warn("Removed stale index.lock", { path: indexLock });
             cleaned++;
           } catch {
           }
         } catch (err) {
-          logger25.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
+          logger23.warn("Failed to clean worktree state", { dir: wtDir, error: err.message });
         }
       }
     } catch (err) {
-      logger25.warn("Failed to list worktrees for cleanup", { error: err.message });
+      logger23.warn("Failed to list worktrees for cleanup", { error: err.message });
     }
-    const mainIndexLock = path12.join(repoGitRoot, ".git", "index.lock");
+    const mainIndexLock = path11.join(repoGitRoot, ".git", "index.lock");
     try {
-      await fs11.unlink(mainIndexLock);
-      logger25.warn("Removed stale main repo index.lock", { path: mainIndexLock });
+      await fs9.unlink(mainIndexLock);
+      logger23.warn("Removed stale main repo index.lock", { path: mainIndexLock });
       cleaned++;
     } catch {
     }
-    logger25.info("Stale state cleanup complete", { cleaned });
+    logger23.info("Stale state cleanup complete", { cleaned });
   }
   /**
    * 重启后清理幽灵端口分配。
@@ -5453,7 +5008,7 @@ var PipelineOrchestrator = class {
     for (const record of this.tracker.getAll()) {
       if (record.ports) {
         const iid = getIid(record);
-        logger25.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
+        logger23.info("Clearing stale port allocation after restart", { iid, ports: record.ports });
         this.tracker.updateState(iid, record.state, {
           ports: void 0,
           previewStartedAt: void 0
@@ -5498,20 +5053,20 @@ var PipelineOrchestrator = class {
     }
     try {
       await this.mainGit.worktreeRemove(wtCtx.gitRootDir, true);
-      logger25.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
+      logger23.info("Worktree cleaned up", { dir: wtCtx.gitRootDir });
     } catch (err) {
-      logger25.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
+      logger23.warn("Failed to cleanup worktree", { dir: wtCtx.gitRootDir, error: err.message });
     }
   }
   async installDependencies(workDir) {
-    logger25.info("Installing dependencies in worktree", { workDir });
+    logger23.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) {
-        logger25.info("node_modules ready \u2014 skipping install");
+        logger23.info("node_modules ready \u2014 skipping install");
         return;
       }
     }
@@ -5524,10 +5079,10 @@ var PipelineOrchestrator = class {
         maxBuffer: 10 * 1024 * 1024,
         timeout: 3e5
       });
-      logger25.info("Dependencies installed");
+      logger23.info("Dependencies installed");
     } catch (err) {
       if (fallbackCmd) {
-        logger25.warn(`${installCmd} failed, retrying with fallback command`, {
+        logger23.warn(`${installCmd} failed, retrying with fallback command`, {
           error: err.message
         });
         const [fallbackBin, ...fallbackArgs] = fallbackCmd.split(/\s+/);
@@ -5537,45 +5092,45 @@ var PipelineOrchestrator = class {
             maxBuffer: 10 * 1024 * 1024,
             timeout: 3e5
           });
-          logger25.info("Dependencies installed (fallback)");
+          logger23.info("Dependencies installed (fallback)");
         } catch (retryErr) {
-          logger25.warn("Fallback install also failed", {
+          logger23.warn("Fallback install also failed", {
             error: retryErr.message
           });
         }
       } else {
-        logger25.warn("Install failed, no fallback configured", {
+        logger23.warn("Install failed, no fallback configured", {
           error: err.message
         });
       }
     }
   }
   async ensureNodeModules(workDir) {
-    const targetBin = path12.join(workDir, "node_modules", ".bin");
+    const targetBin = path11.join(workDir, "node_modules", ".bin");
     try {
-      await fs11.access(targetBin);
-      logger25.info("node_modules already complete (has .bin/)");
+      await fs9.access(targetBin);
+      logger23.info("node_modules already complete (has .bin/)");
       return true;
     } catch {
     }
-    const sourceNM = path12.join(this.config.project.workDir, "node_modules");
-    const targetNM = path12.join(workDir, "node_modules");
+    const sourceNM = path11.join(this.config.project.workDir, "node_modules");
+    const targetNM = path11.join(workDir, "node_modules");
     try {
-      await fs11.access(sourceNM);
+      await fs9.access(sourceNM);
     } catch {
-      logger25.warn("Main repo node_modules not found, skipping seed", { sourceNM });
+      logger23.warn("Main repo node_modules not found, skipping seed", { sourceNM });
       return false;
     }
-    logger25.info("Seeding node_modules from main repo via reflink copy", { sourceNM, targetNM });
+    logger23.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
       });
-      logger25.info("node_modules seeded from main repo");
+      logger23.info("node_modules seeded from main repo");
       return true;
     } catch (err) {
-      logger25.warn("Failed to seed node_modules from main repo", {
+      logger23.warn("Failed to seed node_modules from main repo", {
         error: err.message
       });
       return false;
@@ -5585,16 +5140,16 @@ var PipelineOrchestrator = class {
     const record = this.tracker.get(issueIid);
     if (!record) throw new IssueNotFoundError(issueIid);
     const wtCtx = this.computeWorktreeContext(issueIid, record.branchName);
-    logger25.info("Restarting issue \u2014 cleaning context", { issueIid, branchName: record.branchName });
+    logger23.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));
-      logger25.info("Agent notes cleaned up", { issueIid, deleted });
+      logger23.info("Agent notes cleaned up", { issueIid, deleted });
     } catch (err) {
-      logger25.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
+      logger23.warn("Failed to cleanup agent notes", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -5611,19 +5166,19 @@ var PipelineOrchestrator = class {
     await this.cleanupE2eOutputs(issueIid);
     this.tracker.resetFull(issueIid);
     this.pendingActions.delete(issueIid);
-    logger25.info("Issue restarted", { issueIid });
+    logger23.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);
-    logger25.info("Cancelling issue \u2014 cleaning all resources", { issueIid, branchName: record.branchName });
+    logger23.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) {
-      logger25.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
+      logger23.warn("Failed to remove labels on cancel", { issueIid, error: err.message });
     }
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
@@ -5640,7 +5195,7 @@ var PipelineOrchestrator = class {
     this.tracker.clearProcessingLock(issueIid);
     this.tracker.updateState(issueIid, "skipped" /* Skipped */);
     await this.cleanupE2eOutputs(issueIid);
-    logger25.info("Issue cancelled", { issueIid });
+    logger23.info("Issue cancelled", { issueIid });
   }
   /**
    * Remove the E2E output directory for an issue: {uatVendorDir}/outputs/issue-{iid}
@@ -5648,13 +5203,13 @@ var PipelineOrchestrator = class {
   async cleanupE2eOutputs(issueIid) {
     const vendorDir = this.config.e2e.uatVendorDir;
     if (!vendorDir) return;
-    const abs = path12.isAbsolute(vendorDir) ? vendorDir : path12.resolve(this.config.project.workDir, vendorDir);
-    const outputDir = path12.join(abs, "outputs", `issue-${issueIid}`);
+    const abs = path11.isAbsolute(vendorDir) ? vendorDir : path11.resolve(this.config.project.workDir, vendorDir);
+    const outputDir = path11.join(abs, "outputs", `issue-${issueIid}`);
     try {
-      await fs11.rm(outputDir, { recursive: true, force: true });
-      logger25.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
+      await fs9.rm(outputDir, { recursive: true, force: true });
+      logger23.info("E2E outputs cleaned up", { issueIid, dir: outputDir });
     } catch (err) {
-      logger25.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
+      logger23.warn("Failed to cleanup E2E outputs", { issueIid, dir: outputDir, error: err.message });
     }
   }
   /**
@@ -5666,10 +5221,10 @@ var PipelineOrchestrator = class {
     if (!this.workspaceManager) return;
     const wsRoot = this.workspaceManager.getWorkspaceRoot(issueIid);
     try {
-      await fs11.rm(wsRoot, { recursive: true, force: true });
-      logger25.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
+      await fs9.rm(wsRoot, { recursive: true, force: true });
+      logger23.info("Workspace root cleaned up", { issueIid, dir: wsRoot });
     } catch (err) {
-      logger25.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
+      logger23.warn("Failed to cleanup workspace root", { issueIid, dir: wsRoot, error: err.message });
     }
   }
   retryFromPhase(issueIid, phase) {
@@ -5685,7 +5240,7 @@ var PipelineOrchestrator = class {
       this.aiRunner.killByWorkDir(wtCtx.workDir);
     }
     this.e2eAiRunner?.killByWorkDir(wtCtx.workDir);
-    logger25.info("Retrying issue from phase", { issueIid, phase });
+    logger23.info("Retrying issue from phase", { issueIid, phase });
     const ok = this.tracker.resetToPhase(issueIid, phase, issueDef);
     if (!ok) {
       throw new InvalidPhaseError(phase);
@@ -5712,7 +5267,7 @@ var PipelineOrchestrator = class {
     } else {
       this.tracker.pauseIssue(issueIid, record.currentPhase ?? "");
     }
-    logger25.info("Issue abort requested", { issueIid, state: record.state });
+    logger23.info("Issue abort requested", { issueIid, state: record.state });
   }
   continueIssue(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5722,7 +5277,7 @@ var PipelineOrchestrator = class {
     }
     const issueDef = this.getIssueSpecificPipelineDef(record);
     this.tracker.resumeFromPause(issueIid, issueDef, false);
-    logger25.info("Issue continued from pause", { issueIid });
+    logger23.info("Issue continued from pause", { issueIid });
   }
   redoPhase(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -5766,7 +5321,7 @@ var PipelineOrchestrator = class {
       }
       this.eventBus.emitTyped("issue:redone", { issueIid });
     }
-    logger25.info("Issue redo requested", { issueIid, state: record.state });
+    logger23.info("Issue redo requested", { issueIid, state: record.state });
   }
   /**
    * 处理中止/重做的共享逻辑：
@@ -5839,7 +5394,7 @@ var PipelineOrchestrator = class {
   async _processIssueImpl(issue) {
     const branchName = `${this.config.project.branchPrefix}-${issue.iid}`;
     const wtCtx = this.computeWorktreeContext(issue.iid, branchName);
-    logger25.info("Processing issue", {
+    logger23.info("Processing issue", {
       iid: issue.iid,
       title: issue.title,
       branchName,
@@ -5946,7 +5501,7 @@ var PipelineOrchestrator = class {
         title,
         description
       });
-      logger25.info("Merge request created successfully", {
+      logger23.info("Merge request created successfully", {
         iid: issue.iid,
         mrIid: mr.iid,
         mrUrl: mr.web_url
@@ -5954,7 +5509,7 @@ var PipelineOrchestrator = class {
       return { url: mr.web_url, iid: mr.iid };
     } catch (err) {
       const errorMsg = err.message;
-      logger25.warn("Failed to create merge request, trying to find existing one", {
+      logger23.warn("Failed to create merge request, trying to find existing one", {
         iid: issue.iid,
         error: errorMsg
       });
@@ -5971,7 +5526,7 @@ var PipelineOrchestrator = class {
         this.config.project.baseBranch
       );
       if (existing) {
-        logger25.info("Found existing merge request", {
+        logger23.info("Found existing merge request", {
           iid: issueIid,
           mrIid: existing.iid,
           mrUrl: existing.web_url
@@ -5979,7 +5534,7 @@ var PipelineOrchestrator = class {
         return { url: existing.web_url, iid: existing.iid };
       }
     } catch (findErr) {
-      logger25.warn("Failed to find existing merge request", {
+      logger23.warn("Failed to find existing merge request", {
         iid: issueIid,
         error: findErr.message
       });
@@ -6024,7 +5579,7 @@ var PipelineOrchestrator = class {
       });
       return ports;
     } catch (err) {
-      logger25.error("Failed to start preview servers", {
+      logger23.error("Failed to start preview servers", {
         iid: issue.iid,
         error: err.message
       });
@@ -6059,7 +5614,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     await this.mainGitMutex.runExclusive(async () => {
       await this.cleanupWorktree(wtCtx);
     });
-    logger25.info("Preview stopped and worktree cleaned", { iid: issueIid });
+    logger23.info("Preview stopped and worktree cleaned", { iid: issueIid });
   }
   async markDeployed(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -6076,7 +5631,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.closeIssue(externalId);
     } catch (err) {
-      logger25.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
+      logger23.warn("Failed to close issue on Gongfeng", { iid: issueIid, error: err.message });
     }
     try {
       const issue = await this.gongfeng.getIssueDetail(externalId);
@@ -6084,10 +5639,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) {
-      logger25.warn("Failed to update labels", { iid: issueIid, error: err.message });
+      logger23.warn("Failed to update labels", { iid: issueIid, error: err.message });
     }
     this.tracker.updateState(issueIid, "deployed" /* Deployed */);
-    logger25.info("Issue marked as deployed", { iid: issueIid });
+    logger23.info("Issue marked as deployed", { iid: issueIid });
   }
   async restartPreview(issueIid) {
     const record = this.tracker.get(issueIid);
@@ -6114,7 +5669,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       throw err;
     }
     const url = this.buildPreviewUrl(issueIid);
-    logger25.info("Preview restarted", { iid: issueIid, url });
+    logger23.info("Preview restarted", { iid: issueIid, url });
     return url;
   }
   getPreviewHost() {
@@ -6147,7 +5702,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;
-    logger25.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
+    logger23.info("Starting conflict resolution", { issueIid, branchName, baseBranch });
     this.tracker.updateState(issueIid, "resolving_conflict" /* ResolvingConflict */);
     this.eventBus.emitTyped("conflict:started", { issueIid });
     try {
@@ -6180,7 +5735,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
           });
         }
       });
-      logger25.info("Running verification after conflict resolution", { issueIid });
+      logger23.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);
@@ -6218,10 +5773,10 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
       } catch {
       }
       await this.commentOnMr(record.mrUrl, t("conflict.mrResolvedComment"));
-      logger25.info("Conflict resolution completed", { issueIid });
+      logger23.info("Conflict resolution completed", { issueIid });
     } catch (err) {
       const errorMsg = err.message;
-      logger25.error("Conflict resolution failed", { issueIid, error: errorMsg });
+      logger23.error("Conflict resolution failed", { issueIid, error: errorMsg });
       try {
         const wtGit = new GitOperations(wtCtx.gitRootDir);
         if (await wtGit.isRebaseInProgress()) {
@@ -6251,7 +5806,7 @@ E2E \u6D4B\u8BD5\u5C06\u5C1D\u8BD5\u4F7F\u7528 config.json \u4E2D\u7684\u9ED8\u8
     try {
       await this.gongfeng.createMergeRequestNote(mrIid, body);
     } catch (err) {
-      logger25.warn("Failed to comment on MR", { mrIid, error: err.message });
+      logger23.warn("Failed to comment on MR", { mrIid, error: err.message });
     }
   }
 };
@@ -6327,7 +5882,7 @@ ${questions}
 }
 
 // src/services/BrainstormService.ts
-var logger26 = logger.child("Brainstorm");
+var logger24 = logger.child("Brainstorm");
 function agentConfigToAIConfig(agentCfg, timeoutMs) {
   return {
     mode: agentCfg.mode,
@@ -6363,7 +5918,7 @@ var BrainstormService = class {
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.sessions.set(session.id, session);
-    logger26.info("Created brainstorm session", { sessionId: session.id });
+    logger24.info("Created brainstorm session", { sessionId: session.id });
     return session;
   }
   getSession(id) {
@@ -6372,7 +5927,7 @@ var BrainstormService = class {
   async generate(sessionId, onEvent) {
     const session = this.requireSession(sessionId);
     session.status = "generating";
-    logger26.info("Generating SDD", { sessionId });
+    logger24.info("Generating SDD", { sessionId });
     const prompt = buildGeneratePrompt(session.transcript);
     const result = await this.generatorRunner.run({
       prompt,
@@ -6398,7 +5953,7 @@ var BrainstormService = class {
     const session = this.requireSession(sessionId);
     const roundNum = session.rounds.length + 1;
     session.status = "reviewing";
-    logger26.info("Reviewing SDD", { sessionId, round: roundNum });
+    logger24.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({
@@ -6431,7 +5986,7 @@ var BrainstormService = class {
       throw new Error("No review round to refine from");
     }
     session.status = "refining";
-    logger26.info("Refining SDD", { sessionId, round: currentRound.round });
+    logger24.info("Refining SDD", { sessionId, round: currentRound.round });
     const prompt = buildRefinePrompt(currentRound.questions);
     const result = await this.generatorRunner.run({
       prompt,
@@ -6518,4 +6073,4 @@ export {
   PipelineOrchestrator,
   BrainstormService
 };
-//# sourceMappingURL=chunk-WZGEYHCC.js.map
+//# sourceMappingURL=chunk-OPWP73PW.js.map