dsh-issue2pr 0.3.0 → 0.3.1

package/lib/assistant.js

@@ -2,9 +2,9 @@
 // focus 来自前端 viewStore：{ nav, slug, runId }（用户当前所在页面 / 选中项目 / 选中 Run）
 import { join } from "node:path";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { listProjects, readArtifact } from "./store.js";
-import { loadRun } from "./pipeline.js";
-import { STAGE_DEFS } from "./stageConfig.js";
+import { listProjects, readArtifact } from "./core/store.js";
+import { loadRun } from "./core/pipeline.js";
+import { STAGE_DEFS } from "./core/stageConfig.js";
 
 export const ASSISTANT_SYSTEM_HEAD = [
   "你是 Issue2PR 插件（运行在 DSH 宿主里）内置的智能助手，悬浮在工作台右上角，",

package/lib/{pipeline.js → core/pipeline.js}

@@ -2,7 +2,8 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { writeArtifact, appendArtifactLine, timestamp } from "./store.js";
-import { STAGE_DEFS, stageDelegated, delegateReady } from "./stageConfig.js";
+import { STAGE_DEFS, stageDelegated, delegateReady, purgeDelegateArtifacts } from "./stageConfig.js";
+import { verifyDelegateResult } from "../delegate/delegateVerify.js";
 
 export const STAGES = [
   { id: "P1",  name: "IssueAnalyzer",      artifact: "01-issue-analysis.json",     key: false },
@@ -84,6 +85,18 @@ export async function advance(rcx) {
     appendEvent(runDir, nextId, { kind: "stage", name: nextId + " 开始", detail: STAGES.find((s) => s.id === nextId)?.name || "" });
     const t0 = Date.now();
     try {
+      // A4 兜底 + 修正：P7 应用前对委托 P6 产物做完整验证（不只是存在性检查）。
+      // 存在 ≠ 可用：产物被外部删除 → 显式失败；产物存在但对 HEAD 基线不可应用（过期/坏补丁）
+      // → 同样显式拦截，而不是让 git apply 在半路炸出难定位的错。
+      if (nextId === "P7" && stageDelegated(rcx, "P6")) {
+        if (!delegateReady(runDir, "P6")) {
+          throw new Error("P6 委托产物缺失（无 coder-report.json / patches/*.diff），P7 无补丁可应用；请回退 P6 重跑");
+        }
+        const v7 = await verifyDelegateResult(rcx, "P6");
+        if (!v7.ok) {
+          throw new Error("P6 委外产物验证未通过，P7 拒绝应用: " + v7.errors.join("；"));
+        }
+      }
       const result = await executors[nextId](rcx);
       // 执行器运行期间可能被外部 stop/delete：落盘前复查，避免把 running 写回覆盖 stopped
       const diskAfter = loadRun(runDir);
@@ -95,12 +108,33 @@ export async function advance(rcx) {
       if (result && result.external) st.external = true; // session 模式：实施移交外部会话
       st.finishedAt = new Date().toISOString();
       appendSpan(runDir, { span: nextId, ms: Date.now() - t0, decision: (result && result.summary) || "" });
-      st.status = isGate(run, nextId) ? "awaiting_review" : "approved";
+      // A4 修复 + 修正：委托阶段必须「拿到委外结果且验证 ok」才允许流转，缺一不可：
+      // ① 产物未就绪 → 无论复核模式是否有门都停下等待（空手放行 = 下游必然失败）；
+      // ② 产物就绪 → 立即执行验证（结构完整 + 对 HEAD 基线的应用性演练），验证不过 = 显式失败。
+      //    全自动模式 claude 产出的坏补丁 / 会话期间被篡改的补丁，原先会直通 P7 才在 apply 炸，
+      //    现在在 P6 门上就地拦截并给出可定位的错误。
+      let delegateBlocked = false;
+      if (stageDelegated(rcx, nextId)) {
+        if (!delegateReady(runDir, nextId)) {
+          delegateBlocked = true;
+        } else {
+          const v = await verifyDelegateResult(rcx, nextId);
+          appendEvent(runDir, nextId, { kind: "stage", name: nextId + " 委外产物验证" + (v.ok ? "通过" : "未通过"),
+            detail: v.ok
+              ? "结构完整" + (v.rehearsal ? "，对 HEAD 基线应用性演练通过（" + v.patches + " 份补丁）" : "（无仓库环境，未演练）")
+              : v.errors.join("；"),
+            ok: v.ok });
+          if (!v.ok) throw new Error(nextId + " 委外产物验证未通过: " + v.errors.join("；") + "；请回退该阶段重跑，或修正外部产物");
+        }
+      }
+      st.status = (isGate(run, nextId) || delegateBlocked) ? "awaiting_review" : "approved";
       run.status = st.status === "approved" ? "running" : "awaiting_review";
       // external 阶段的实施不在本阶段完成，事件文案不能写"完成"（避免误导为已交付）
       const doneLabel = result && result.external
         ? nextId + " 任务包已生成 · 等待外部会话执行"
-        : nextId + (st.status === "awaiting_review" ? " 完成 · 待复核" : " 完成");
+        : delegateBlocked
+          ? nextId + " 任务包已生成 · 等待外部产出后放行"
+          : nextId + (st.status === "awaiting_review" ? " 完成 · 待复核" : " 完成");
       appendEvent(runDir, nextId, { kind: "stage", name: doneLabel,
         detail: (result && result.summary) || "", ms: Date.now() - t0 });
     } catch (e) {
@@ -116,7 +150,9 @@ export async function advance(rcx) {
   }
 }
 
-export function applyReview(rcx, { decision, comment }) {
+// 异步原因（A4 修正）：委托阶段的通过判定要做完整验证（含 git 应用性演练），
+// 文件存在性检查不再足够——人工放行与全自动放行同一验证口径。
+export async function applyReview(rcx, { decision, comment }) {
   const { run, runDir } = rcx;
   const id = run.current;
   const st = run.stages[id];
@@ -132,6 +168,14 @@ export function applyReview(rcx, { decision, comment }) {
     const mode = isP6 ? ((run.p6Mode || "session") + " 模式") : "委托模式";
     return [false, id + " " + mode + "：外部执行方尚未产出（未检测到 " + output + "）。请先在外部智能体执行任务包，产出落盘后再通过复核门"];
   }
+  // A4 修正：人工放行同样必须先过机器验证——「文件存在」只证明拿到结果，不证明结果可用。
+  // 坏补丁（结构残缺 / 对 HEAD 基线不可应用 / report 损坏）在这里拦截，不让它进 P7。
+  if (decision === "approve" && stageDelegated(rcx, id)) {
+    const v = await verifyDelegateResult(rcx, id);
+    if (!v.ok) {
+      return [false, id + " 委外产物验证未通过: " + v.errors.join("；") + "。请修正外部产物后重试，或打回重跑"];
+    }
+  }
   const record = { stage: id, decision, comment: comment || "", at: new Date().toISOString() };
   writeArtifact(runDir, `reviews/${timestamp()}-${decision}-${id}.json`, JSON.stringify(record, null, 2));
   appendEvent(runDir, id, { kind: "stage", name: id + (decision === "approve" ? " 复核通过" : " 复核打回"),
@@ -145,6 +189,13 @@ export function applyReview(rcx, { decision, comment }) {
     st.attempts += 1;
     run.status = "running";
     rcx.reviewComment = comment;
+    // A2 修复：打回委托阶段时清空旧外部产物 —— 旧 patches/report 会让 delegateReady 误判
+    // "外部已交付"（复核门形同虚设），并被 P7 当作本轮补丁应用（过期 patch 混入）。清场后按新任务包重新产出。
+    if (stageDelegated(rcx, id)) {
+      const removed = purgeDelegateArtifacts(runDir, id);
+      appendEvent(runDir, id, { kind: "stage", name: id + " 打回清场",
+        detail: removed.length ? "已清除旧外部产物: " + removed.join(", ") : "无旧外部产物可清" });
+    }
   }
   saveRun(runDir, run);
   return [true, decision === "approve" ? "已通过" : "已打回，将带意见重跑"];

package/lib/{stageConfig.js → core/stageConfig.js}

@@ -2,10 +2,10 @@
 // 配置存于 project.json 的 stageConfig 字段：{ P1: { prompts, provider, model,
 // reasoningEffort, timeoutMs, maxTokens, delegate }, … }；未配置项回落默认值。
 // STAGE_DEFS 的 prompts 与各阶段文件中的硬编码提示词保持 1:1（改默认值两处同步改）。
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { readArtifact } from "./store.js";
-import { readTriggerText } from "./stages/helpers.js";
+import { readTriggerText } from "../stages/helpers.js";
 
 const CODER_SYSTEM = [
   "你是 Coder Sub-Agent，纪律（superpowers）：",
@@ -311,3 +311,25 @@ function delegateReadyFromDir(runDir, rel, ext) {
   const dir = join(runDir, rel);
   return existsSync(dir) && readdirSync(dir).some((f) => f.endsWith(ext));
 }
+
+// 清空委托阶段的外部产出（打回 / 回退重跑时调用，返回被清除的产物相对路径清单）。
+// 不清理旧产物的后果：delegateReady 误判"外部已交付"（复核门形同虚设），
+// P7 把过期 patch 当作本轮补丁应用（打回意见等于没有生效）。任务包（session-task.md 等）保留，
+// 由阶段执行器重跑时重新生成。
+export function purgeDelegateArtifacts(runDir, stageId) {
+  const removed = [];
+  const kill = (rel) => {
+    try { rmSync(join(runDir, rel), { force: true, recursive: true }); removed.push(rel); } catch { /* 尽力 */ }
+  };
+  if (stageId === "P6") {
+    kill("06-implementation/coder-report.json");
+    const dir = join(runDir, "06-implementation", "patches");
+    if (existsSync(dir)) {
+      for (const f of readdirSync(dir)) if (f.endsWith(".diff")) kill("06-implementation/patches/" + f);
+    }
+    return removed;
+  }
+  const output = STAGE_DEFS[stageId]?.delegateSpec?.output;
+  if (output && !output.endsWith("/")) kill(output); // 目录型产物仅 P6；其余委托阶段产物为文件
+  return removed;
+}

package/lib/{agents.js → delegate/agents.js}

@@ -6,7 +6,7 @@
 // 全部探测函数可注入（index.js 传 __testHooks 版本），单测不依赖本机 claude。
 import { execFile, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { resolveClaudeBin, claudeCommonCandidates } from "./stages/p6-coder.js";
+import { resolveClaudeBin, claudeCommonCandidates } from "../stages/p6-coder.js";
 
 export const AGENT_SOURCE_LABELS = {
   configured: "项目配置",

package/lib/delegate/delegateVerify.js

@@ -0,0 +1,125 @@
+// lib/delegateVerify.js — 委外产物验证（审查报告 A4 修正：拿到结果 + 验证 ok 才往下流转）
+// 设计原则（第一性）：流水线放行一个委托阶段前，唯一可信的依据不是"文件存在"，
+// 而是"产物可用"——即下游阶段拿它当输入时不会必然失败。因此验证分两层：
+//   1) 结构完整（拿到结果）：补丁清单与 P7 完全同口径（collectPatches），逐份存在、
+//      非空、形如 unified diff；coder-report.json 若存在必须可解析。
+//   2) 可应用性演练（验证 ok）：用临时 GIT_INDEX_FILE 从 HEAD 构建一次性索引，
+//      按应用序逐份 `git apply --cached` 演练——不碰工作区、不依赖工作区是否干净，
+//      语义与 P7（reset 到 HEAD 后顺序 apply）完全一致。
+// 无 repoDir（纯单测裸 rcx）时退化为仅结构验证；repoDir 存在但非 git 仓库 → 显式验证失败。
+import { execFile } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readArtifact } from "../core/store.js";
+import { STAGE_DEFS } from "../core/stageConfig.js";
+import { collectPatches } from "../stages/p7-patch.js";
+
+const firstLine = (s) => String(s || "").split("\n").find((l) => l.trim()) || "";
+
+function execGit(args, { cwd, env, input }) {
+  return new Promise((resolve, reject) => {
+    const child = execFile("git", args, {
+      cwd, env,
+      timeout: 60000, windowsHide: true, maxBuffer: 16 * 1024 * 1024,
+    }, (err, stdout, stderr) => {
+      if (err) { err.stderr = String(stderr || err.message); reject(err); }
+      else resolve(String(stdout || ""));
+    });
+    child.stdin?.on?.("error", () => {}); // EPIPE 不掩盖主错误
+    child.stdin.end(input == null ? "" : input); // execFile 无 input 选项，须手写 stdin
+  });
+}
+
+// 形如 unified diff：git 风格（diff --git）或 patch 风格（--- / +++ 头）
+function looksLikeDiff(text) {
+  const t = String(text);
+  return /^diff --git /m.test(t) || (/^--- /m.test(t) && /^\+\+\+ /m.test(t));
+}
+
+// —— P6 深验证：结构 +（有仓库时）应用性演练 ——
+async function verifyP6(rcx) {
+  const { runDir } = rcx;
+  const errors = [];
+  // coder-report.json 存在时必须可解析（先于清单解析：坏 JSON 在此拦截并给出可定位错误，
+  // 而不是让 collectPatches/P7 在 JSON.parse 处崩出裸 SyntaxError）
+  const reportPath = join(runDir, "06-implementation", "coder-report.json");
+  if (existsSync(reportPath)) {
+    try { JSON.parse(readFileSync(reportPath, "utf8")); }
+    catch (e) { errors.push("coder-report.json 不是合法 JSON: " + String((e && e.message) || e)); }
+  }
+  const patches = errors.length ? [] : collectPatches(runDir); // 与 P7 应用口径 1:1：验证的就是 P7 将要应用的
+  if (!patches.length) errors.push("未检测到补丁（coder-report.json 未列出补丁且 patches/*.diff 为空）——未拿到委外结果");
+
+  const contents = [];
+  for (const p of patches) {
+    const text = readArtifact(runDir, p.patch);
+    if (text == null) { errors.push(p.patch + " 不存在（coder-report 清单与实际文件不一致）"); contents.push(null); continue; }
+    if (!String(text).trim()) { errors.push(p.patch + " 内容为空"); contents.push(null); continue; }
+    if (!looksLikeDiff(text)) { errors.push(p.patch + " 不是 unified diff（缺 ---/+++ 或 diff --git 头）"); contents.push(null); continue; }
+    contents.push(String(text));
+  }
+
+  // 应用性演练：仅在结构完好时执行（缺文件的演练只会产生噪音）
+  let rehearsal = false;
+  if (!errors.length && patches.length) {
+    if (!rcx.repoDir || !existsSync(rcx.repoDir)) {
+      // 无仓库环境（纯单测 / 测试钩子跳过仓库准备）：仅结构验证。
+      // 生产路径 drive 在 P2-P6 前必保仓库就位；仓库目录缺失时由 P7 的
+      // resetRepoClean 显式失败兜底，此处不重复拦截。
+    } else {
+      rehearsal = true;
+      const r = await rehearseApply(rcx.repoDir, patches.map((p, i) => ({ rel: p.patch, content: contents[i] })));
+      if (!r.ok) errors.push(...r.errors);
+    }
+  }
+  return { ok: !errors.length, errors, patches: patches.length, rehearsal };
+}
+
+// —— 临时索引演练：read-tree HEAD → 顺序 apply --cached（后续补丁在前序之上验证）——
+async function rehearseApply(repoDir, patches) {
+  let tmp = null;
+  try {
+    try { await execGit(["rev-parse", "--git-dir"], { cwd: repoDir }); }
+    catch (e) { return { ok: false, errors: ["无法执行应用性演练（repoDir 非 git 仓库）: " + firstLine(e.stderr || e.message)] }; }
+    tmp = mkdtempSync(join(tmpdir(), "i2p-verify-"));
+    const env = { ...process.env, GIT_INDEX_FILE: join(tmp, "index") };
+    await execGit(["read-tree", "HEAD"], { cwd: repoDir, env }); // 一次性索引 = HEAD 基线
+    const errors = [];
+    for (const p of patches) {
+      try {
+        // 临时索引可丢弃：直接 apply 即检查（成功即变更索引，后续补丁在前序之上演练，
+        // 与 P7 reset→顺序 apply 的真实语义一致）
+        await execGit(["apply", "--cached", "-"], { cwd: repoDir, env, input: p.content });
+      } catch (e) {
+        errors.push(p.rel + " 无法应用到 HEAD 基线: " + firstLine(e.stderr || e.message));
+      }
+    }
+    return { ok: !errors.length, errors };
+  } catch (e) {
+    return { ok: false, errors: ["补丁应用性演练失败: " + String((e && e.stderr) || (e && e.message) || e)] };
+  } finally {
+    if (tmp) { try { rmSync(tmp, { recursive: true, force: true }); } catch { /* 尽力 */ } }
+  }
+}
+
+// —— 其余委托阶段轻验证：产物存在、非空；.json 契约必须可解析 ——
+function verifyFileStage(rcx, stageId) {
+  const output = STAGE_DEFS[stageId]?.delegateSpec?.output;
+  if (!output || output.endsWith("/")) return { ok: true, errors: [], patches: 0, rehearsal: false };
+  const errors = [];
+  const text = readArtifact(rcx.runDir, output);
+  if (text == null) errors.push(output + " 尚未产出——未拿到委外结果");
+  else if (!String(text).trim()) errors.push(output + " 内容为空");
+  else if (output.endsWith(".json")) {
+    try { JSON.parse(String(text)); }
+    catch (e) { errors.push(output + " 不是合法 JSON: " + String((e && e.message) || e)); }
+  }
+  return { ok: !errors.length, errors, patches: text == null ? 0 : 1, rehearsal: false };
+}
+
+// 入口：委托阶段产物验证。返回 { ok, errors[], patches, rehearsal }
+// 调用方（applyReview / advance / 全自动 watcher / P7 兜底）必须 ok===true 才放行流转。
+export async function verifyDelegateResult(rcx, stageId) {
+  return stageId === "P6" ? await verifyP6(rcx) : verifyFileStage(rcx, stageId);
+}

package/lib/infra/repoState.js

@@ -0,0 +1,59 @@
+// lib/repoState.js — 仓库工作区基线与 per-Run worktree 管理（审查报告 A1/A3 修复）
+// 目录职责：
+//   projects/<slug>/repo            基线克隆（git clone --depth 1 一次，作为只读基准）
+//   projects/<slug>/worktrees/<id>  每 Run 独立 worktree（P7 应用补丁 / P8 测试 / 外部智能体都在这里工作）
+// per-Run worktree 让同项目并发 Run 的仓库状态互不污染；Run 删除时一并移除。
+// worktree 创建失败时兜底回退基线 repo（配合 drive 的项目级互斥，仍保证不交错写）。
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+function execGit(args, cwd, timeoutMs = 120000) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+      if (err) { err.stderr = String(stderr || err.message); reject(err); }
+      else resolve(String(stdout || ""));
+    });
+  });
+}
+
+export function baseRepoDir(root, slug) { return join(root, "projects", slug, "repo"); }
+export function runRepoDir(root, slug, runId) { return join(root, "projects", slug, "worktrees", runId); }
+
+// 工作区重置回 HEAD 基线：清掉已应用补丁（跟踪文件修改）与未跟踪文件。
+// 不加 -x：保留 .gitignore 忽略的目录（如 node_modules，避免测试依赖反复安装）。
+export async function resetRepoClean(repoDir) {
+  try {
+    await execGit(["reset", "--hard", "HEAD"], repoDir, 60000);
+    await execGit(["clean", "-fd"], repoDir, 60000);
+  } catch (e) {
+    throw new Error("仓库基线重置失败(git reset/clean): " + String((e && e.stderr) || (e && e.message) || e));
+  }
+}
+
+// 确保 per-Run worktree 存在（幂等）。返回实际使用的仓库目录：
+// 成功 → worktree 路径；基线仓库未就绪 / 创建失败 → 兜底返回基线 repo 路径（绝不抛错，由调用方日志呈现）。
+export async function ensureWorktree(root, slug, runId, log) {
+  const base = baseRepoDir(root, slug);
+  const wt = runRepoDir(root, slug, runId);
+  if (existsSync(join(wt, ".git"))) return wt; // worktree 的 .git 是文件，existsSync 同样命中
+  if (!existsSync(join(base, ".git"))) return base; // 基线尚未克隆（克隆失败路径由调用方处理）
+  try {
+    await execGit(["worktree", "add", "--detach", wt, "HEAD"], base);
+    log?.({ kind: "git", name: "git worktree add", detail: "Run 独立工作区: " + wt });
+    return wt;
+  } catch (e) {
+    log?.({ kind: "git", name: "git worktree add 失败（兜底共用基线仓库）", ok: false,
+      detail: String((e && e.stderr) || (e && e.message) || e).slice(0, 500) });
+    return base;
+  }
+}
+
+// Run 删除时尽力移除其 worktree（失败不抛：孤儿 worktree 可由 git worktree prune 收敛）
+export async function removeWorktree(root, slug, runId) {
+  const base = baseRepoDir(root, slug);
+  const wt = runRepoDir(root, slug, runId);
+  if (!existsSync(wt) || !existsSync(join(base, ".git"))) return;
+  try { await execGit(["worktree", "remove", "--force", wt], base); } catch { /* 尽力 */ }
+  try { await execGit(["worktree", "prune"], base); } catch { /* 尽力 */ }
+}

package/lib/stages/helpers.js

@@ -1,9 +1,9 @@
 // lib/stages/helpers.js — 各阶段通用辅助（读触发文档 / 列仓库文件 / 读文件 / 取上游产物 / 过程事件 / 委托外部）
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join, sep } from "node:path";
-import { appendArtifactLine, writeArtifact } from "../store.js";
-import { stageDelegated, buildDelegateTask } from "../stageConfig.js";
-import { matchConnection } from "../connections.js";
+import { appendArtifactLine, writeArtifact } from "../core/store.js";
+import { stageDelegated, buildDelegateTask } from "../core/stageConfig.js";
+import { matchConnection } from "../infra/connections.js";
 
 // 过程事件：追加到 runDir/trace/events.jsonl（UI 阶段详情按 stage 过滤展示）。
 // kind：stage | llm | git | test | tool | info；detail 截断 2000 字防膨胀。

package/lib/stages/p1-issue-analyzer.js

@@ -1,7 +1,7 @@
 // lib/stages/p1-issue-analyzer.js — 调研 §3：自然语言 → 结构化契约
-import { writeArtifact } from "../store.js";
+import { writeArtifact } from "../core/store.js";
 import { readTriggerText, maybeDelegate } from "./helpers.js";
-import { sysOf } from "../stageConfig.js";
+import { sysOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P1");

package/lib/stages/p10-failure.js

@@ -1,7 +1,7 @@
 // lib/stages/p10-failure.js — 调研 §10：先分类，再决定路径
-import { writeArtifact } from "../store.js";
+import { writeArtifact } from "../core/store.js";
 import { maybeDelegate } from "./helpers.js";
-import { sysOf } from "../stageConfig.js";
+import { sysOf } from "../core/stageConfig.js";
 
 const CATEGORIES = ["实现错误", "根因错误", "测试选择", "环境缺失", "权限被拒", "反复失败"];
 

package/lib/stages/p11-pr-builder.js

@@ -1,7 +1,7 @@
 // lib/stages/p11-pr-builder.js — 调研 §15：PR 说明忠实反映修改 + Gate 评测
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, maybeDelegate } from "./helpers.js";
-import { sysOf } from "../stageConfig.js";
+import { sysOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P11");

package/lib/stages/p2-search.js

@@ -1,7 +1,7 @@
 // lib/stages/p2-search.js — 调研 §4：结构化 Issue → 候选文件 + 证据
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { listRepoFiles, requireArtifact, maybeDelegate } from "./helpers.js";
-import { sysOf, paramsOf } from "../stageConfig.js";
+import { sysOf, paramsOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P2");

package/lib/stages/p3-code-understanding.js

@@ -1,7 +1,7 @@
 // lib/stages/p3-code-understanding.js — 调研 §4：调用链理解（基于真实文件内容）
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, readRepoFile, maybeDelegate } from "./helpers.js";
-import { sysOf, paramsOf } from "../stageConfig.js";
+import { sysOf, paramsOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P3");

package/lib/stages/p4-hypothesis.js

@@ -1,7 +1,7 @@
 // lib/stages/p4-hypothesis.js — 调研 §5：每个假设必须可验证
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, maybeDelegate } from "./helpers.js";
-import { sysOf } from "../stageConfig.js";
+import { sysOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P4");

package/lib/stages/p5-planner.js

@@ -1,7 +1,7 @@
 // lib/stages/p5-planner.js — 调研 §6：TaskGraph，每节点有契约
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, maybeDelegate } from "./helpers.js";
-import { sysOf } from "../stageConfig.js";
+import { sysOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P5");

package/lib/stages/p6-coder.js

@@ -6,11 +6,11 @@ import { spawn } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, readRepoFile, logEvent } from "./helpers.js";
-import { slugify, timestamp } from "../store.js";
-import { saveRun, sessionPatchesReady } from "../pipeline.js";
-import { sysOf, paramsOf } from "../stageConfig.js";
+import { slugify, timestamp } from "../core/store.js";
+import { saveRun, sessionPatchesReady } from "../core/pipeline.js";
+import { sysOf, paramsOf } from "../core/stageConfig.js";
 
 // —— claude CLI 进程管理（stop/删除 Run 时杀进程树，避免孤儿 claude 继续写仓库） ——
 const activeExternals = new Map(); // runDir → ChildProcess

package/lib/stages/p7-patch.js

@@ -3,8 +3,9 @@
 import { readFileSync, existsSync, readdirSync } from "node:fs";
 import { execFile } from "node:child_process";
 import { join } from "node:path";
-import { appendArtifactLine } from "../store.js";
+import { appendArtifactLine } from "../core/store.js";
 import { logEvent } from "./helpers.js";
+import { resetRepoClean } from "../infra/repoState.js";
 
 // 带stdin输入的异步执行（git apply - 用 stdin 收 diff）
 function execStdin(cmd, args, opts, input) {
@@ -27,12 +28,15 @@ async function hashRepo(repoDir) {
 // patch 清单：优先 coder-report.json（builtin 写 patches 字段；claude 委托写 tasks 字段且
 // patch 路径相对 06-implementation/，这里统一归一化为相对 runDir 全路径）；
 // report 缺失时退化为扫描目录（文件名序 = 应用序）。
-function collectPatches(runDir) {
+// 导出供 delegateVerify 复用：验证清单 = P7 应用清单，同一口径。
+export function collectPatches(runDir) {
   const normalize = (p) => !p ? null
     : { patch: p.startsWith("06-implementation/") ? p : "06-implementation/" + p.replace(/^\/+/, "") };
   const reportPath = join(runDir, "06-implementation", "coder-report.json");
   if (existsSync(reportPath)) {
-    const report = JSON.parse(readFileSync(reportPath, "utf8"));
+    let report;
+    try { report = JSON.parse(readFileSync(reportPath, "utf8")); }
+    catch { throw new Error("coder-report.json 损坏（非法 JSON），无法解析补丁清单；请回退 P6 重跑或修复报告文件"); }
     const list = Array.isArray(report.patches) ? report.patches
       : Array.isArray(report.tasks) ? report.tasks.map((t) => ({ patch: t.patch }))
       : [];
@@ -47,6 +51,11 @@ function collectPatches(runDir) {
 export default async function execute(rcx) {
   const patches = collectPatches(rcx.runDir);
   if (!patches.length) throw new Error("P7 无 patch 可应用（06-implementation/patches/ 为空且无 coder-report.json）");
+  // A1/A2 修复：应用补丁前先把工作区重置回 HEAD 基线。
+  // 打回重跑/回退重跑时上一轮已应用的补丁仍在工作区（直接 re-apply 必失败）；
+  // worktree 兜底共用基线 repo 的路径下同理清残留。reset 不碰 .gitignore 的目录（如 node_modules）。
+  await resetRepoClean(rcx.repoDir);
+  logEvent(rcx, { kind: "git", name: "工作区基线重置", detail: "P7 应用补丁前 git reset --hard + git clean -fd" });
   for (const p of patches) {
     const diff = readFileSync(join(rcx.runDir, p.patch), "utf8");
     const hashBefore = await hashRepo(rcx.repoDir);

package/lib/stages/p8-test-runner.js

@@ -3,9 +3,9 @@
 import { exec } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { writeArtifact } from "../store.js";
+import { writeArtifact } from "../core/store.js";
 import { logEvent } from "./helpers.js";
-import { DEFAULT_TEST_TIMEOUT_MS } from "../stageConfig.js";
+import { DEFAULT_TEST_TIMEOUT_MS } from "../core/stageConfig.js";
 
 function detectCommand(repoDir) {
   const pkg = join(repoDir, "package.json");

package/lib/stages/p9-reviewer.js

@@ -1,7 +1,7 @@
 // lib/stages/p9-reviewer.js — 调研 §9：Review 是 PRBuilder 的前置门控
-import { writeArtifact, readArtifact } from "../store.js";
+import { writeArtifact, readArtifact } from "../core/store.js";
 import { requireArtifact, maybeDelegate } from "./helpers.js";
-import { sysOf, paramsOf } from "../stageConfig.js";
+import { sysOf, paramsOf } from "../core/stageConfig.js";
 
 export default async function execute(rcx) {
   const delegated = await maybeDelegate(rcx, "P9");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-issue2pr",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Issue-to-PR 可验证交付链：项目配置 → 11 阶段流水线 → 人工复核 → PR 说明（DSH 全局插件）",
   "type": "module",
   "main": "./index.js",