@difflab/pi 0.6.0 → 0.7.0

package/dist/tools/index.js

@@ -503,6 +503,16 @@ function diffpiLaunchName(cwd, workflow) {
 }
 async function openFileAdjacent(path, opts) {
   const env = opts.env ?? process.env;
+  const mux = detectMux(env);
+  if (mux !== "none") {
+    const editor = await resolveEditor(env);
+    if (editor) {
+      const command = persistentEditorArgs(editor, path, opts.cwd, env.SHELL);
+      const opened = await openMuxTab(mux, command, opts.cwd, opts.name ?? "plan", [editor, path].join(" "), command);
+      if (opened)
+        return opened;
+    }
+  }
   const ide = detectIde(env);
   if (ide !== "unknown") {
     const ideCommand = { zed: "zed", vscode: "code", cursor: "cursor", windsurf: "windsurf", jetbrains: "idea" }[ide];
@@ -512,16 +522,6 @@ async function openFileAdjacent(path, opts) {
         return { launched: true, via: ide, command: `${ideCommand} ${path}` };
     }
   }
-  const mux = detectMux(env);
-  if (mux !== "none") {
-    const editor = await resolveEditor(env);
-    if (editor) {
-      const command = [editor, path];
-      const opened = await openMuxTab(mux, command, opts.cwd, opts.name ?? "plan", command.join(" "));
-      if (opened)
-        return opened;
-    }
-  }
   return { launched: false, via: "print", command: path, reason: "No supported IDE or multiplexer was available." };
 }
 async function openInNewTab(command, opts) {
@@ -556,10 +556,15 @@ async function openInNewTab(command, opts) {
 function screenWindowArgs(command, cwd, name) {
   return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
 }
+function persistentEditorArgs(editor, path, cwd, shell = "sh") {
+  return ["bash", "-lc", 'cd -- "$1" && shift && "$@"; exec "$0" -i', shell, cwd, editor, path];
+}
 async function resolveEditor(env) {
-  const configured = (env.VISUAL ?? env.EDITOR)?.trim().split(/\s+/)[0];
-  if (configured && await findExecutable(configured))
-    return configured;
+  for (const configured of [env.EDITOR, env.VISUAL]) {
+    const editor = configured?.trim();
+    if (editor && await findExecutable(editor))
+      return editor;
+  }
   for (const candidate of ["hx", "nvim", "vim"])
     if (await findExecutable(candidate))
       return candidate;
@@ -576,7 +581,7 @@ async function packageVersion() {
     throw new Error("Cannot resolve the installed @difflab/pi version.");
   return value.version;
 }
-async function openMuxTab(mux, command, cwd, name, printable) {
+async function openMuxTab(mux, command, cwd, name, printable, tmuxCommand) {
   if (mux === "zellij" && await findExecutable("zellij")) {
     const result = await run("zellij", ["action", "new-tab", "--cwd", cwd, "--name", name, "--", ...command]);
     if (result.code === 0)
@@ -586,7 +591,7 @@ async function openMuxTab(mux, command, cwd, name, printable) {
       return { launched: true, via: "zellij-run", command: printable };
   }
   if (mux === "tmux" && await findExecutable("tmux")) {
-    const result = await run("tmux", ["new-window", "-c", cwd, "-n", name, printable]);
+    const result = tmuxCommand ? await run("tmux", ["new-window", "-c", cwd, "-n", name, ...tmuxCommand]) : await run("tmux", ["new-window", "-c", cwd, "-n", name, printable]);
     if (result.code === 0)
       return { launched: true, via: "tmux", command: printable };
   }
@@ -1069,6 +1074,18 @@ async function reviewsDir(cwd, homeDir = homedir2()) {
   await mkdir2(dir, { recursive: true });
   return dir;
 }
+async function completedReviewsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "reviews");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
+async function sessionsDir(cwd, homeDir = homedir2()) {
+  const store = await ensureStore(cwd, homeDir);
+  const dir = join6(store.link, "sessions");
+  await mkdir2(dir, { recursive: true });
+  return dir;
+}
 async function assertStoreLink(path, dest) {
   const entry = await lstat(path);
   if (!entry.isSymbolicLink())
@@ -1273,7 +1290,7 @@ function sanitize(value) {
 }
 
 // src/tools/plan.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { pathToFileURL } from "node:url";
 import { defineTool as defineTool5 } from "@earendil-works/pi-coding-agent";
 import { z as z7 } from "zod";
@@ -1510,6 +1527,9 @@ async function discoverMiseTasks(cwd) {
 
 // src/plan/markdown.ts
 var import_mdast_builder = __toESM(require_src(), 1);
+import { createHash as createHash2 } from "node:crypto";
+import { readFile as readFile5, readdir } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // ../../node_modules/zwitch/index.js
 var own = {}.hasOwnProperty;
@@ -6149,6 +6169,8 @@ function isUint8Array2(value) {
 var PLAN_MARKER = /<!-- diffpi-plan: (\{[^\n]+\}) -->/;
 var PHASE_MARKER = /<!-- diffpi-phase: (\{[^\n]+\}) -->/g;
 var TASK_MARKER = /<!-- diffpi-task: (\{[^\n]+\}) -->/g;
+var BRIEF_MARKER = /<!-- diffpi-implementation: (\{[^\n]+\}) -->/;
+var BRIEF_TASK_MARKER = /<!-- diffpi-brief-task: (\{[^\n]+\}) -->/g;
 var SUPPORTED_SCHEMA = 1;
 function countDesignWords(plan) {
   return [plan.design.bigIdeas, plan.design.keyApiUpdates, plan.design.consequences].join(" ").trim().split(/\s+/).filter(Boolean).length;
@@ -6177,11 +6199,13 @@ function validatePlanDocument(plan, options = {}) {
         if (!taskIds.has(dependency))
           add("dangling-dependency", "error", `Task ${task.id} depends on missing ${dependency}.`);
       }
-      if (options.strict && task.acceptanceCriteria.length === 0)
-        add("acceptance", "error", `Task ${task.id} has no acceptance criteria.`, task.id);
+      if (options.strict && isPlaceholder(task.title))
+        add("placeholder", "error", `Task ${task.id} has placeholder content.`, task.id);
     }
     if (options.strict && phase.tasks.length === 0)
       add("empty-phase", "error", `Phase ${phase.id} has no tasks.`, phase.id);
+    if (options.strict && (isPlaceholder(phase.title) || isPlaceholder(phase.objective)))
+      add("placeholder", "error", `Phase ${phase.id} has placeholder content.`, phase.id);
   }
   for (const cycle of dependencyCycles(plan))
     add("dependency-cycle", "error", `Dependency cycle: ${cycle.join(" -> ")}.`);
@@ -6190,10 +6214,140 @@ function validatePlanDocument(plan, options = {}) {
     add("design-length", "warning", `Design is ${designWords} words; prefer 300 or fewer.`);
   if (options.strict && designWords > 800)
     add("design-too-long", "error", `Design is ${designWords} words; finalization allows at most 800.`);
-  if (options.strict && plan.phases.length === 0)
-    add("no-phases", "error", "Finalization requires at least one phase.");
+  if (options.strict) {
+    if (plan.phases.length === 0)
+      add("no-phases", "error", "Finalization requires at least one phase.");
+    if (isPlaceholder(plan.intent))
+      add("placeholder", "error", "Intent must contain concrete content.", "intent");
+    if (!plan.requirements.length || plan.requirements.some(isPlaceholder))
+      add("requirements", "error", "Requirements must contain concrete content.", "requirements");
+    for (const [key, value] of Object.entries(plan.design)) {
+      if (isPlaceholder(value))
+        add("design", "error", `Design/${key} must contain concrete content.`, `design.${key}`);
+    }
+  }
+  return issues;
+}
+function validatePlanBriefs(plan, briefs) {
+  const issues = [];
+  const phaseIds = plan.phases.map((phase) => phase.id);
+  const briefIds = briefs.map((brief) => brief.phaseId);
+  if (!sameIds(phaseIds, briefIds))
+    issues.push({
+      code: "brief-phase-ids",
+      severity: "error",
+      message: `Brief phase IDs must exactly match plan phases in order: ${phaseIds.join(", ")}.`
+    });
+  for (const [index, phase] of plan.phases.entries()) {
+    const brief = briefs[index];
+    if (!brief || brief.phaseId !== phase.id)
+      continue;
+    if (isPlaceholder(brief.summary))
+      issues.push({ code: "brief-placeholder", severity: "error", message: `Brief ${phase.id} needs a summary.` });
+    const taskIds = phase.tasks.map((task) => task.id);
+    const briefTaskIds = brief.tasks.map((task) => task.taskId);
+    if (!sameIds(taskIds, briefTaskIds))
+      issues.push({
+        code: "brief-task-ids",
+        severity: "error",
+        message: `Brief ${phase.id} task IDs must exactly match phase tasks in order: ${taskIds.join(", ")}.`
+      });
+    for (const task of brief.tasks) {
+      for (const [field, values] of [
+        ["ordered steps", task.steps],
+        ["file scopes", task.fileScopes],
+        ["acceptance criteria", task.acceptanceCriteria]
+      ]) {
+        if (!values.length || values.some(isPlaceholder))
+          issues.push({
+            code: "brief-incomplete",
+            severity: "error",
+            message: `Brief task ${task.taskId} needs concrete ${field}.`,
+            path: task.taskId
+          });
+      }
+    }
+    for (const [field, values] of [
+      ["API changes", brief.apiChanges],
+      ["libraries", brief.libraries],
+      ["constraints", brief.constraints]
+    ]) {
+      if (values.some(isPlaceholder))
+        issues.push({
+          code: "brief-placeholder",
+          severity: "error",
+          message: `Brief ${phase.id} has placeholder ${field}.`,
+          path: phase.id
+        });
+    }
+  }
+  return issues;
+}
+async function validatePlanRecord(record, options = {}) {
+  const issues = validatePlanDocument(record.document, options);
+  if (!options.strict)
+    return issues;
+  await validateImplementationDirectory(record.dir, record.document, issues, "latest");
+  if (options.checkSnapshots !== false)
+    await validateRevisionSnapshots(record, issues);
   return issues;
 }
+function renderImplementationBrief(planRevision, ordinal, phase, brief) {
+  const marker = { schemaVersion: 1, planRevision, ordinal, phaseId: phase.id };
+  const tasks = phase.tasks.map((task, index) => {
+    const details = brief.tasks[index];
+    if (!details || details.taskId !== task.id)
+      throw new Error(`Missing implementation details for ${task.id}.`);
+    return `<!-- diffpi-brief-task: ${json({ id: task.id })} -->
+### Task: ${task.title}
+
+#### Ordered Steps
+
+${bulletList(details.steps)}
+
+#### File Scopes
+
+${bulletList(details.fileScopes)}
+
+#### Acceptance Criteria
+
+${bulletList(details.acceptanceCriteria)}
+
+<!-- /diffpi-brief-task -->`;
+  }).join(`
+
+`);
+  return `<!-- diffpi-implementation: ${json(marker)} -->
+# Phase ${ordinal}: ${phase.title}
+
+- **Phase ID:** ${phase.id}
+- **Plan Revision:** ${planRevision}
+
+## Summary
+
+${brief.summary}
+
+## Objective
+
+${phase.objective}
+
+## Tasks
+
+${tasks}
+
+## API Changes
+
+${bulletList(brief.apiChanges, "None.")}
+
+## Libraries and Algorithms
+
+${bulletList(brief.libraries, "None.")}
+
+## Implementation Constraints
+
+${bulletList(brief.constraints, "None.")}
+`;
+}
 function renderPlanDocument(plan, previousSource) {
   if (previousSource && canPatch(previousSource, plan))
     return patchMarkers(previousSource, plan);
@@ -6202,6 +6356,8 @@ function renderPlanDocument(plan, previousSource) {
     id: plan.id,
     revision: plan.revision,
     branch: plan.branch,
+    issueId: plan.issueId,
+    issueUrl: plan.issueUrl,
     status: plan.status,
     execution: plan.execution,
     createdAt: plan.createdAt,
@@ -6210,6 +6366,8 @@ function renderPlanDocument(plan, previousSource) {
   const metadata = import_mdast_builder.list("unordered", [
     ["Plan ID", plan.id],
     ["Branch", plan.branch],
+    ...plan.issueId ? [["Issue", plan.issueId]] : [],
+    ...plan.issueUrl ? [["Issue URL", plan.issueUrl]] : [],
     ["Status", plan.status],
     ["Revision", String(plan.revision)]
   ].map(([label, value]) => import_mdast_builder.listItem(import_mdast_builder.paragraph([import_mdast_builder.strong(import_mdast_builder.text(`${label}:`)), import_mdast_builder.text(` ${value}`)]))));
@@ -6231,7 +6389,7 @@ function renderPlanDocument(plan, previousSource) {
     import_mdast_builder.heading(3, import_mdast_builder.text("Consequences")),
     import_mdast_builder.html(plan.design.consequences || "<!-- Describe trade-offs and limitations. -->"),
     import_mdast_builder.heading(2, import_mdast_builder.text("Implementation")),
-    ...plan.phases.length ? plan.phases.flatMap((phase) => [import_mdast_builder.html(renderPhase(phase))]) : [import_mdast_builder.html("<!-- Add phases with plan_add_phase. -->")],
+    ...plan.phases.length ? plan.phases.flatMap((phase) => [import_mdast_builder.html(renderPhase(phase))]) : [import_mdast_builder.html("<!-- Add phases with plan_apply_revision. -->")],
     import_mdast_builder.heading(2, import_mdast_builder.text("References")),
     references
   ]);
@@ -6305,10 +6463,7 @@ function renderTask(task) {
   const checked = task.status === "completed" || task.status === "skipped" ? "x" : " ";
   return `<!-- diffpi-task: ${json(marker)} -->
 - [${checked}] **${task.title}**
-${taskList("Steps", task.steps ?? [])}
   - Dependencies: ${list3(task.dependencies)}
-${taskList("File scopes", task.fileScopes)}
-${taskList("Acceptance criteria", task.acceptanceCriteria)}
 <!-- /diffpi-task -->`;
 }
 function parsePhases(input, ref) {
@@ -6358,10 +6513,7 @@ function parseTasks(input, ref) {
     return {
       ...marker,
       title,
-      steps: parseListValue(body, "Steps"),
-      dependencies: parseListValue(body, "Dependencies"),
-      fileScopes: parseListValue(body, "File scopes"),
-      acceptanceCriteria: parseListValue(body, "Acceptance criteria")
+      dependencies: parseListValue(body, "Dependencies")
     };
   });
   assertUniqueIds(tasks.map((task) => task.id), "task id");
@@ -6388,6 +6540,8 @@ function patchMarkers(source, plan) {
     id: plan.id,
     revision: plan.revision,
     branch: plan.branch,
+    issueId: plan.issueId,
+    issueUrl: plan.issueUrl,
     status: plan.status,
     execution: plan.execution,
     createdAt: plan.createdAt,
@@ -6437,19 +6591,12 @@ function contentShape(plan) {
     requirements: plan.requirements,
     design: plan.design,
     references: plan.references,
-    phases: plan.phases.map(({ id, title, objective, dependencies, tasks }) => ({
-      id,
-      title,
-      objective,
-      dependencies,
-      tasks: tasks.map(({ id: taskId, title: taskTitle, steps, dependencies: taskDependencies, fileScopes, acceptanceCriteria }) => ({
-        id: taskId,
-        title: taskTitle,
-        steps,
-        dependencies: taskDependencies,
-        fileScopes,
-        acceptanceCriteria
-      }))
+    phases: plan.phases.map((phase) => ({
+      id: phase.id,
+      title: phase.title,
+      objective: phase.objective,
+      dependencies: phase.dependencies,
+      tasks: phase.tasks.map(({ id, title, dependencies }) => ({ id, title, dependencies }))
     }))
   };
 }
@@ -6479,6 +6626,152 @@ function dependencyCycles(plan) {
     walk(id, []);
   return cycles;
 }
+async function validateRevisionSnapshots(record, issues) {
+  const revisionsDir = join10(record.dir, "revisions");
+  let entries;
+  try {
+    entries = await readdir(revisionsDir);
+  } catch {
+    issues.push({ code: "snapshot-missing", severity: "error", message: "Missing revisions directory." });
+    return;
+  }
+  const expected = Array.from({ length: record.document.revision + 1 }, (_, index) => String(index));
+  if (!sameIds(expected, entries.filter((entry) => /^\d+$/.test(entry)).sort((a, b) => Number(a) - Number(b))))
+    issues.push({
+      code: "snapshot-sequence",
+      severity: "error",
+      message: `Revision snapshots must be exactly ${expected.join(", ")}.`,
+      path: revisionsDir
+    });
+  for (const entry of entries) {
+    if (!/^\d+$/.test(entry))
+      issues.push({ code: "snapshot-entry", severity: "error", message: `Unexpected revisions entry: ${entry}.` });
+  }
+  for (const revision of expected) {
+    const dir = join10(revisionsDir, revision);
+    try {
+      const [request, metadataSource, planSource] = await Promise.all([
+        readFile5(join10(dir, "request.md"), "utf8"),
+        readFile5(join10(dir, "metadata.json"), "utf8"),
+        readFile5(join10(dir, "PLAN.md"), "utf8")
+      ]);
+      if (isPlaceholder(request))
+        issues.push({ code: "snapshot-request", severity: "error", message: `Revision ${revision} request is empty.` });
+      const metadata = JSON.parse(metadataSource);
+      const annotation = metadata.requestKind === "annotation" ? /^## Original annotation\n([\s\S]*?)\n\n## LLM response\n([\s\S]*)$/.exec(request) : undefined;
+      const requestText = annotation?.[1];
+      const responseText = annotation?.[2];
+      if (metadata.schemaVersion !== 1 || metadata.id !== record.id || metadata.revision !== Number(revision) || !["user", "annotation", "blocker"].includes(metadata.requestKind) || (metadata.requestKind === "annotation" ? !annotation || !requestText?.trim() || !responseText?.trim() || metadata.requestSha256 !== sha256(requestText) || metadata.originalAnnotationSha256 !== sha256(requestText) || metadata.responseSha256 !== sha256(responseText) : metadata.requestSha256 !== sha256(request)))
+        issues.push({
+          code: "snapshot-metadata",
+          severity: "error",
+          message: `Revision ${revision} metadata does not match its immutable request.`
+        });
+      const snapshotPlan = parsePlanDocument(planSource, join10(dir, "PLAN.md"));
+      if (snapshotPlan.id !== record.id || snapshotPlan.revision !== Number(revision))
+        issues.push({
+          code: "snapshot-plan",
+          severity: "error",
+          message: `Revision ${revision} PLAN.md has mismatched identity or revision.`
+        });
+      await validateImplementationDirectory(dir, snapshotPlan, issues, `revision ${revision}`);
+    } catch (error) {
+      issues.push({
+        code: "snapshot-missing",
+        severity: "error",
+        message: `Revision ${revision} is incomplete: ${error.message}`,
+        path: dir
+      });
+    }
+  }
+}
+async function validateImplementationDirectory(baseDir, plan, issues, label) {
+  const dir = join10(baseDir, "implementation");
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    issues.push({
+      code: "brief-directory",
+      severity: "error",
+      message: `${label} is missing implementation/.`,
+      path: dir
+    });
+    return;
+  }
+  const expected = plan.phases.map((_phase, index) => `phase-${index + 1}.md`);
+  const actual = entries.filter((entry) => entry.endsWith(".md")).sort((left, right) => left.localeCompare(right));
+  if (!sameIds([...expected].sort((left, right) => left.localeCompare(right)), actual))
+    issues.push({
+      code: "brief-filenames",
+      severity: "error",
+      message: `${label} briefs must use exactly: ${expected.join(", ") || "(none)"}.`,
+      path: dir
+    });
+  for (const [index, phase] of plan.phases.entries()) {
+    const path = join10(dir, `phase-${index + 1}.md`);
+    try {
+      validateBriefSource(await readFile5(path, "utf8"), plan.revision, index + 1, phase, path, issues);
+    } catch (error) {
+      issues.push({
+        code: "brief-missing",
+        severity: "error",
+        message: `${label} brief phase-${index + 1}.md is missing: ${error.message}`,
+        path
+      });
+    }
+  }
+}
+function validateBriefSource(source, planRevision, ordinal, phase, path, issues) {
+  const matches = source.match(new RegExp(BRIEF_MARKER.source, "g")) ?? [];
+  const markerMatch = source.match(BRIEF_MARKER);
+  if (matches.length !== 1 || !markerMatch) {
+    issues.push({ code: "brief-marker", severity: "error", message: `${path} needs one implementation marker.`, path });
+    return;
+  }
+  const marker = parseMarker(markerMatch[1], `${path} implementation`);
+  if (marker.schemaVersion !== 1 || marker.planRevision !== planRevision || marker.ordinal !== ordinal || marker.phaseId !== phase.id)
+    issues.push({
+      code: "brief-marker",
+      severity: "error",
+      message: `${path} marker must identify phase ${ordinal} (${phase.id}) at revision ${planRevision}.`,
+      path
+    });
+  const taskIds = [...source.matchAll(BRIEF_TASK_MARKER)].map((match) => parseMarker(match[1], `${path} task`).id);
+  if (!sameIds(phase.tasks.map((task) => task.id), taskIds))
+    issues.push({
+      code: "brief-task-ids",
+      severity: "error",
+      message: `${path} task markers must exactly match phase task IDs in order.`,
+      path
+    });
+  const prose = source.replace(BRIEF_MARKER, "").replace(BRIEF_TASK_MARKER, "").replace(/<!-- \/diffpi-brief-task -->/g, "");
+  if (/<!--[^]*?-->|\b(?:TODO|TBD)\b|define during implementation/i.test(prose))
+    issues.push({
+      code: "brief-placeholder",
+      severity: "error",
+      message: `${path} contains placeholder content.`,
+      path
+    });
+  try {
+    if (isPlaceholder(section(source, "Summary")))
+      throw new Error("Summary is empty.");
+    for (const task of phase.tasks) {
+      const taskStart = source.indexOf(`<!-- diffpi-brief-task: ${json({ id: task.id })} -->`);
+      const taskEnd = source.indexOf("<!-- /diffpi-brief-task -->", taskStart);
+      if (taskStart < 0 || taskEnd < 0)
+        throw new Error(`Task ${task.id} body is missing.`);
+      const body = source.slice(taskStart, taskEnd);
+      for (const heading of ["Ordered Steps", "File Scopes", "Acceptance Criteria"]) {
+        const content = briefSubsection(body, heading);
+        if (!parseBullets(content).length || parseBullets(content).some(isPlaceholder))
+          throw new Error(`Task ${task.id} ${heading} is incomplete.`);
+      }
+    }
+  } catch (error) {
+    issues.push({ code: "brief-incomplete", severity: "error", message: `${path}: ${error.message}`, path });
+  }
+}
 function section(source, heading) {
   const match = source.match(new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m"));
   if (!match?.index) {
@@ -6503,6 +6796,14 @@ function subsection(source, parent, heading) {
 function parseBullets(input) {
   return [...input.matchAll(/^- (?!<!--)(.+)$/gm)].map((match) => match[1].trim());
 }
+function briefSubsection(source, heading) {
+  const match = source.match(new RegExp(`^#### ${escapeRegExp(heading)}\\s*$`, "m"));
+  if (match?.index === undefined)
+    throw new Error(`Missing required brief heading: ${heading}.`);
+  const rest = source.slice(match.index + match[0].length);
+  const end = rest.search(/^#### |^<!-- \/diffpi-brief-task -->/m);
+  return (end < 0 ? rest : rest.slice(0, end)).trim();
+}
 function parseListValue(body, label) {
   const match = new RegExp(`^ {2}- ${escapeRegExp(label)}:[ \\t]*(.*)$`, "m").exec(body);
   if (!match)
@@ -6549,6 +6850,16 @@ function assertUniqueIds(ids, label) {
 function cleanPlaceholder(value) {
   return value.replace(/<!--[^]*?-->/g, "").trim();
 }
+function isPlaceholder(value) {
+  const normalized = cleanPlaceholder(value).trim();
+  return normalized.length === 0 || /^(?:todo|tbd|none|n\/a)$/i.test(normalized) || /define during implementation|describe the|add requirements|add implementation/i.test(normalized);
+}
+function sameIds(expected, actual) {
+  return expected.length === actual.length && expected.every((value, index) => actual[index] === value);
+}
+function sha256(value) {
+  return createHash2("sha256").update(value).digest("hex");
+}
 function parseMarker(value, label) {
   try {
     return JSON.parse(value);
@@ -6556,15 +6867,14 @@ function parseMarker(value, label) {
     throw new Error(`Malformed ${label} marker JSON.`);
   }
 }
-function taskList(label, values) {
+function bulletList(values, empty = "") {
   if (!values.length)
-    return `  - ${label}: none`;
-  const items = values.flatMap((value) => {
+    return empty;
+  return values.flatMap((value) => {
     const [first = "", ...continuations] = value.split(`
 `);
-    return [`    - ${first}`, ...continuations.map((line) => `      ${line}`)];
-  });
-  return [`  - ${label}:`, ...items].join(`
+    return [`- ${first}`, ...continuations.map((line) => `  ${line}`)];
+  }).join(`
 `);
 }
 function list3(values) {
@@ -6890,13 +7200,13 @@ function heartbeat(plan) {
 }
 
 // src/plan/reviews.ts
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname5, join as join11 } from "node:path";
 async function readPlanReview(record) {
   const path = reviewPath(record);
   let source;
   try {
-    source = await readFile5(path, "utf8");
+    source = await readFile6(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -6913,7 +7223,7 @@ async function readPlanReview(record) {
   return { path, dump };
 }
 function reviewPath(record) {
-  return join10(record.dir, "reviews", `${record.document.revision}.json`);
+  return join11(record.dir, "reviews", `${record.document.revision}.json`);
 }
 function isPlanReviewDump(value) {
   if (!value || typeof value !== "object")
@@ -6923,14 +7233,15 @@ function isPlanReviewDump(value) {
 }
 
 // src/plan/store.ts
-import { mkdir as mkdir6, readdir, readFile as readFile7, realpath as realpath3, rm as rm2 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname7, join as join13, resolve as resolve3, sep } from "node:path";
+import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir as mkdir6, readdir as readdir2, readFile as readFile8, realpath as realpath3, rename as rename2, rm as rm2 } from "node:fs/promises";
+import { basename as basename5, dirname as dirname7, join as join14, resolve as resolve3, sep } from "node:path";
 
 // src/extensions/fsx.ts
 import { mkdir as mkdir5, rename, rm, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename4, dirname as dirname6, join as join11 } from "node:path";
+import { basename as basename4, dirname as dirname6, join as join12 } from "node:path";
 async function atomicWrite(path, content) {
-  const temp = join11(dirname6(path), `.${basename4(path)}.${crypto.randomUUID()}.tmp`);
+  const temp = join12(dirname6(path), `.${basename4(path)}.${crypto.randomUUID()}.tmp`);
   await writeFile4(temp, content, { encoding: "utf8", mode: 384, flag: "wx" });
   await rename(temp, path);
 }
@@ -6961,13 +7272,13 @@ function sleep(ms) {
 }
 
 // src/templates.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { join as join12, normalize } from "node:path";
+import { join as join13, normalize } from "node:path";
 async function loadTemplate(name, options = {}) {
   const relative = templateRelativePath(name);
-  const userPath = join12(options.homeDir ?? homedir4(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join12(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const userPath = join13(options.homeDir ?? homedir4(), ".difflab", "diffpi", "templates", relative);
+  const bundledPath = join13(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
   const user = await readOptionalFile(userPath);
   if (user !== undefined)
     return { name, path: userPath, source: "user", content: user };
@@ -6988,7 +7299,7 @@ function templateRelativePath(name) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile7(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -7003,7 +7314,7 @@ function planRecordName(shortSlug, date = new Date) {
 }
 async function resolvePlan(cwd, query, filters = {}, options = {}) {
   const root = await plansDir(cwd, options.homeDir);
-  const entries = await readdir(root, { withFileTypes: true });
+  const entries = await readdir2(root, { withFileTypes: true });
   const normalizedQuery = query ? normalizeQuery(query) : undefined;
   const records = [];
   for (const entry of entries) {
@@ -7011,7 +7322,7 @@ async function resolvePlan(cwd, query, filters = {}, options = {}) {
       continue;
     if (normalizedQuery && entry.name !== normalizedQuery && stripDate(entry.name) !== normalizedQuery)
       continue;
-    const dir = join13(root, entry.name);
+    const dir = join14(root, entry.name);
     await assertContained(root, dir);
     try {
       const record = await readRecord(dir);
@@ -7030,6 +7341,15 @@ async function resolvePlan(cwd, query, filters = {}, options = {}) {
 }
 function createPlanStore(options = {}) {
   const now = options.now ?? (() => new Date);
+  const read = async (cwd, query, filters) => {
+    const result = await resolvePlan(cwd, query, filters, options);
+    if (!result.record) {
+      if (result.ambiguous)
+        throw new Error(`Plan query "${query}" is ambiguous: ${result.candidates.map((item) => item.id).join(", ")}.`);
+      throw new Error(`Plan "${query}" was not found.`);
+    }
+    return result.record;
+  };
   return {
     context(cwd, query, filters) {
       return resolvePlan(cwd, query, filters, options);
@@ -7037,120 +7357,318 @@ function createPlanStore(options = {}) {
     async init(input) {
       const root = await plansDir(input.cwd, options.homeDir);
       const id = planRecordName(input.shortSlug, now());
-      const dir = join13(root, id);
-      await assertContained(root, dirname7(dir));
-      try {
-        await mkdir6(dir);
-      } catch (error) {
-        if (error.code === "EEXIST")
-          throw new Error(`Plan ${id} already exists.`);
-        throw error;
-      }
+      const dir = join14(root, id);
+      await createPlanDirectory(root, dir, id);
       try {
         const timestamp = now().toISOString();
         const template = await loadTemplate("plan/PLAN", {
           homeDir: options.homeDir,
           bundledDir: options.bundledTemplatesDir
         });
+        const title = input.title?.trim() || titleFromSlug(input.shortSlug);
         const source = renderTemplate(template.content, {
           id,
           branch: input.branch,
-          title: input.title?.trim() || titleFromSlug(input.shortSlug),
+          title,
           intent: input.intent?.trim() || "<!-- Describe the intended outcome. -->",
-          issue_id: input.issueId?.trim() || "<!-- Add issue tracker ID. -->",
-          issue_url: input.issueUrl?.trim() || "<!-- Add issue tracker URL. -->",
+          issue_id: input.issueId?.trim() || "",
+          issue_url: input.issueUrl?.trim() || "",
           created_at: timestamp,
           updated_at: timestamp
         });
-        const document = parsePlanDocument(source, join13(dir, "PLAN.md"));
-        await atomicWrite(join13(dir, "PLAN.md"), source);
-        return {
-          id,
-          dir,
-          planPath: join13(dir, "PLAN.md"),
-          logPath: join13(dir, "logs.txt"),
-          implementationDir: join13(dir, "implementation"),
-          document,
-          source
-        };
+        const document = parsePlanDocument(source, join14(dir, "PLAN.md"));
+        const authoringRequest = input.request ?? { kind: "user", text: input.intent?.trim() || `Initialize phase-less plan ${title}.` };
+        await writeRevisionSnapshot(dir, document, source, authoringRequest, []);
+        await writeLatestView(dir, document, source, []);
+        return await readRecord(dir);
       } catch (error) {
         await rm2(dir, { recursive: true, force: true });
         throw error;
       }
     },
-    async read(cwd, query, filters) {
-      const result = await resolvePlan(cwd, query, filters, options);
-      if (!result.record) {
-        if (result.ambiguous)
-          throw new Error(`Plan query "${query}" is ambiguous: ${result.candidates.map((item) => item.id).join(", ")}.`);
-        throw new Error(`Plan "${query}" was not found.`);
+    read,
+    async applyRevision(cwd, request) {
+      if (request.mode === "create") {
+        const root = await plansDir(cwd, options.homeDir);
+        const id = planRecordName(request.shortSlug, now());
+        const dir = join14(root, id);
+        await createPlanDirectory(root, dir, id);
+        try {
+          const timestamp = now().toISOString();
+          const document = normalizeRevision(undefined, request, id, 0, timestamp);
+          assertCompleteRevision(document, request.briefs);
+          const source = renderPlanDocument(document);
+          parsePlanDocument(source, join14(dir, "PLAN.md"));
+          await writeRevisionSnapshot(dir, document, source, request.request, request.briefs);
+          await writeLatestView(dir, document, source, request.briefs);
+          return await readRecord(dir);
+        } catch (error) {
+          await rm2(dir, { recursive: true, force: true });
+          throw error;
+        }
       }
-      return result.record;
+      const initial = await read(cwd, request.plan);
+      return withDirectoryLock(join14(initial.dir, ".lock"), async () => {
+        const current = await readRecord(initial.dir);
+        if (current.document.revision !== request.expectedPlanRevision)
+          throw new Error(`Expected plan revision ${request.expectedPlanRevision}, found ${current.document.revision}.`);
+        const revision = current.document.revision + 1;
+        const document = normalizeRevision(current.document, request, current.id, revision, now().toISOString());
+        assertCompleteRevision(document, request.briefs);
+        const source = renderPlanDocument(document);
+        parsePlanDocument(source, current.planPath);
+        await writeRevisionSnapshot(current.dir, document, source, request.request, request.briefs);
+        try {
+          await writeLatestView(current.dir, document, source, request.briefs);
+        } catch (error) {
+          await rm2(join14(current.dir, "revisions", String(revision)), { recursive: true, force: true });
+          throw error;
+        }
+        return await readRecord(current.dir);
+      }, { operation: "apply revision" });
     },
     async mutate(cwd, query, operation, update) {
-      const initial = await this.read(cwd, query);
-      return withDirectoryLock(join13(initial.dir, ".lock"), async () => {
+      const initial = await read(cwd, query);
+      return withDirectoryLock(join14(initial.dir, ".lock"), async () => {
         const current = await readRecord(initial.dir);
         const next = await update(structuredClone(current.document));
         if (next.id !== current.id)
           throw new Error("A plan mutation cannot change the plan ID.");
         const document = {
           ...next,
-          revision: current.document.revision + 1,
+          revision: current.document.revision,
           updatedAt: now().toISOString()
         };
         const source = renderPlanDocument(document, current.source);
         parsePlanDocument(source, current.planPath);
         await atomicWrite(current.planPath, source);
-        await ensureImplementationFiles(current.dir, document, options);
-        return { ...current, document, source, implementationDir: join13(current.dir, "implementation") };
+        return { ...current, document, source };
       }, { operation });
     },
     async log(cwd, query, event) {
-      const record = await this.read(cwd, query);
+      const record = await read(cwd, query);
       return appendLogEntry(record.logPath, event);
     }
   };
 }
 async function readRecord(dir) {
-  const planPath = join13(dir, "PLAN.md");
-  const logPath = join13(dir, "logs.txt");
-  const source = await readFile7(planPath, "utf8");
+  const planPath = join14(dir, "PLAN.md");
+  const logPath = join14(dir, "logs.txt");
+  const source = await readFile8(planPath, "utf8");
   const document = parsePlanDocument(source, planPath);
   return {
     id: basename5(dir),
     dir,
     planPath,
     logPath,
-    implementationDir: join13(dir, "implementation"),
+    implementationDir: join14(dir, "implementation"),
     document,
     source
   };
 }
-async function ensureImplementationFiles(dir, document, options) {
-  const implementationDir = join13(dir, "implementation");
-  await mkdir6(implementationDir, { recursive: true });
-  const template = await loadTemplate("plan/implementation", {
-    homeDir: options.homeDir,
-    bundledDir: options.bundledTemplatesDir
-  });
-  for (const phase of document.phases) {
-    const path = join13(implementationDir, `phase-${phase.id}.md`);
+async function createPlanDirectory(root, dir, id) {
+  await assertContained(root, dirname7(dir));
+  try {
+    await mkdir6(dir);
+  } catch (error) {
+    if (error.code === "EEXIST")
+      throw new Error(`Plan ${id} already exists.`);
+    throw error;
+  }
+}
+async function writeRevisionSnapshot(planDir, document, source, request, briefs) {
+  if (!request.text.trim())
+    throw new Error("An exact non-empty authoring request is required.");
+  if (request.kind === "annotation" && !request.response?.trim())
+    throw new Error("Annotation requests require a non-empty response.");
+  const revisionsDir = join14(planDir, "revisions");
+  await mkdir6(revisionsDir, { recursive: true });
+  const target = join14(revisionsDir, String(document.revision));
+  try {
+    await readFile8(join14(target, "metadata.json"), "utf8");
+    throw new Error(`Revision ${document.revision} already exists and is immutable.`);
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const staging = join14(revisionsDir, `.tmp-${document.revision}-${randomUUID2()}`);
+  await mkdir6(staging);
+  try {
+    const requestSource = request.kind === "annotation" ? `## Original annotation
+${request.text}
+
+## LLM response
+${request.response}` : request.text;
+    await atomicWrite(join14(staging, "request.md"), requestSource);
+    await atomicWrite(join14(staging, "metadata.json"), `${JSON.stringify({
+      schemaVersion: 1,
+      id: document.id,
+      revision: document.revision,
+      requestKind: request.kind,
+      requestSha256: sha2562(request.text),
+      ...request.kind === "annotation" ? { originalAnnotationSha256: sha2562(request.text), responseSha256: sha2562(request.response) } : {},
+      createdAt: document.updatedAt
+    }, null, 2)}
+`);
+    await atomicWrite(join14(staging, "PLAN.md"), source);
+    await writeImplementationDirectory(staging, document, briefs);
+    await rename2(staging, target);
+  } catch (error) {
+    await rm2(staging, { recursive: true, force: true });
+    throw error;
+  }
+}
+async function writeLatestView(planDir, document, source, briefs) {
+  const current = join14(planDir, "implementation");
+  const stagingRoot = join14(planDir, `.latest-${randomUUID2()}`);
+  const stagedImplementation = join14(stagingRoot, "implementation");
+  const backup = join14(planDir, `.implementation-backup-${randomUUID2()}`);
+  await mkdir6(stagingRoot);
+  await writeImplementationDirectory(stagingRoot, document, briefs);
+  let backedUp = false;
+  try {
     try {
-      await readFile7(path, "utf8");
+      await rename2(current, backup);
+      backedUp = true;
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
-      const tasks = phase.tasks.map((task) => `- ${task.id}: ${task.title}`).join("\\n") || "- Add implementation tasks.";
-      await atomicWrite(path, renderTemplate(template.content, {
-        phase_id: phase.id,
-        phase_title: phase.title,
-        phase_objective: phase.objective,
-        phase_tasks: tasks
-      }));
     }
+    await rename2(stagedImplementation, current);
+    await atomicWrite(join14(planDir, "PLAN.md"), source);
+    if (backedUp)
+      await rm2(backup, { recursive: true, force: true });
+  } catch (error) {
+    await rm2(current, { recursive: true, force: true });
+    if (backedUp)
+      await rename2(backup, current);
+    throw error;
+  } finally {
+    await rm2(stagingRoot, { recursive: true, force: true });
   }
 }
+async function writeImplementationDirectory(baseDir, document, briefs) {
+  const implementationDir = join14(baseDir, "implementation");
+  await mkdir6(implementationDir, { recursive: true });
+  for (const [index, phase] of document.phases.entries()) {
+    const brief = briefs[index];
+    if (!brief)
+      throw new Error(`Missing implementation brief for phase ${phase.id}.`);
+    await atomicWrite(join14(implementationDir, `phase-${index + 1}.md`), renderImplementationBrief(document.revision, index + 1, phase, brief));
+  }
+}
+function normalizeRevision(current, request, id, revision, updatedAt) {
+  if (current?.status === "completed")
+    throw new Error("Completed plans cannot be amended.");
+  if (current?.execution?.active && request.request.kind !== "blocker")
+    throw new Error("An active execution accepts only a blocker amendment.");
+  const currentPhases = new Map(current?.phases.map((phase) => [phase.id, phase]) ?? []);
+  for (const phase of current?.phases ?? []) {
+    if (!request.phases.some((candidate) => candidate.id === phase.id) && (phase.status === "completed" || phase.status === "in_progress"))
+      throw new Error(`${phase.status === "completed" ? "Completed" : "Active"} phase ${phase.id} cannot be removed.`);
+  }
+  const phases = request.phases.map((draft) => reconcilePhase(currentPhases.get(draft.id), draft, current));
+  const createdAt = current?.createdAt ?? updatedAt;
+  return {
+    schemaVersion: 1,
+    id,
+    revision,
+    title: request.title,
+    branch: current?.branch ?? (request.mode === "create" ? request.branch : ""),
+    issueId: current?.issueId ?? (request.mode === "create" ? request.issueId : undefined),
+    issueUrl: current?.issueUrl ?? (request.mode === "create" ? request.issueUrl : undefined),
+    intent: request.intent,
+    requirements: request.requirements,
+    design: request.design,
+    references: request.references,
+    phases,
+    status: nextPlanStatus(current),
+    execution: current?.execution,
+    createdAt,
+    updatedAt
+  };
+}
+function reconcilePhase(current, draft, plan) {
+  if (!current)
+    return {
+      ...draft,
+      revision: 0,
+      status: "pending",
+      gate: { phaseRevision: 0, status: "pending", results: [] },
+      tasks: draft.tasks.map(newTask)
+    };
+  if (current.status === "completed") {
+    if (JSON.stringify(phaseContent(current)) !== JSON.stringify(draft))
+      throw new Error(`Completed phase ${current.id} cannot be changed.`);
+    return current;
+  }
+  const byId = new Map(current.tasks.map((task) => [task.id, task]));
+  for (const task of current.tasks) {
+    if (!draft.tasks.some((candidate) => candidate.id === task.id) && (task.status === "completed" || task.status === "in_progress"))
+      throw new Error(`${task.status === "completed" ? "Completed" : "Active"} task ${task.id} cannot be removed.`);
+  }
+  const tasks = draft.tasks.map((task) => reconcileTask(byId.get(task.id), task));
+  const changed = JSON.stringify(phaseContent(current)) !== JSON.stringify(draft);
+  const revision = changed ? current.revision + 1 : current.revision;
+  const wasBlocked = current.status === "blocked";
+  return {
+    ...current,
+    ...draft,
+    revision,
+    tasks,
+    status: wasBlocked ? plan?.execution?.active ? "in_progress" : "pending" : current.status,
+    gate: changed || wasBlocked ? { phaseRevision: revision, status: "stale", results: [] } : current.gate,
+    blocker: wasBlocked ? undefined : current.blocker
+  };
+}
+function reconcileTask(current, draft) {
+  if (!current)
+    return newTask(draft);
+  const changed = JSON.stringify(taskContent(current)) !== JSON.stringify(draft);
+  if ((current.status === "completed" || current.status === "in_progress") && changed)
+    throw new Error(`${current.status === "completed" ? "Completed" : "Active"} task ${current.id} cannot be changed.`);
+  if (current.status === "completed" || current.status === "in_progress")
+    return current;
+  return {
+    ...current,
+    ...draft,
+    revision: changed ? current.revision + 1 : current.revision,
+    status: current.status === "blocked" ? "pending" : current.status,
+    owner: current.status === "blocked" ? undefined : current.owner,
+    executionId: current.status === "blocked" ? undefined : current.executionId,
+    blocker: current.status === "blocked" ? undefined : current.blocker
+  };
+}
+function newTask(draft) {
+  return { ...draft, revision: 0, status: "pending" };
+}
+function phaseContent(phase) {
+  return {
+    id: phase.id,
+    title: phase.title,
+    objective: phase.objective,
+    dependencies: phase.dependencies,
+    tasks: phase.tasks.map(taskContent)
+  };
+}
+function taskContent(task) {
+  return { id: task.id, title: task.title, dependencies: task.dependencies };
+}
+function nextPlanStatus(current) {
+  if (!current)
+    return "draft";
+  if (current.execution?.active)
+    return current.status === "blocked" ? "in_progress" : current.status;
+  return current.status === "ready" || current.status === "blocked" ? "draft" : current.status;
+}
+function assertCompleteRevision(document, briefs) {
+  const errors = [...validatePlanDocument(document, { strict: true }), ...validatePlanBriefs(document, briefs)].filter((issue) => issue.severity === "error");
+  if (errors.length)
+    throw new Error(`Invalid plan revision: ${errors.map((issue) => issue.message).join(" ")}`);
+}
+function sha2562(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
 async function assertContained(root, candidate) {
   const canonicalRoot = await realpath3(root);
   let canonicalCandidate;
@@ -7182,34 +7700,54 @@ function stripDate(value) {
   return value.replace(/^\d{6}-/, "");
 }
 function titleFromSlug(value) {
-  return normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "").split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+  const slug = normalizeSlug(value).replace(/^(?:[a-z]+-\d+-)/, "");
+  return slug.replace(/(^|-)([a-z])/g, (_match, separator, letter) => {
+    return `${separator ? " " : ""}${letter.toUpperCase()}`;
+  });
 }
 
-// src/tools/plan-schema.ts
+// src/plan/schema.ts
 import { z as z6 } from "zod";
 var planStatusSchema = z6.enum(["draft", "ready", "in_progress", "blocked", "completed"]);
 var planUnitStatusSchema = z6.enum(["draft", "ready", "in_progress", "blocked", "completed", "pending", "skipped"]);
-var planTaskDraftSchema = z6.object({
-  id: zx.id,
-  title: zx.text,
-  steps: z6.array(zx.text).optional(),
-  dependencies: z6.array(zx.id).optional(),
-  fileScopes: z6.array(zx.text).optional(),
-  acceptanceCriteria: z6.array(zx.text).optional()
-}).strict();
+var planTaskDraftSchema = z6.object({ id: zx.id, title: zx.text, dependencies: z6.array(zx.id) }).strict();
 var planPhaseDraftSchema = z6.object({
   id: zx.id,
   title: zx.text,
   objective: zx.text,
-  dependencies: z6.array(zx.id).optional(),
-  tasks: z6.array(planTaskDraftSchema).optional()
+  dependencies: z6.array(zx.id),
+  tasks: z6.array(planTaskDraftSchema).min(1)
 }).strict();
-var planReferenceSchema = z6.object({ id: zx.id, value: zx.text }).strict();
-var planDesignSchema = z6.object({
-  bigIdeas: z6.string(),
-  keyApiUpdates: z6.string(),
-  consequences: z6.string()
+var planBriefSchema = z6.object({
+  phaseId: zx.id,
+  summary: zx.text,
+  apiChanges: z6.array(zx.text),
+  libraries: z6.array(zx.text),
+  constraints: z6.array(zx.text),
+  tasks: z6.array(z6.object({
+    taskId: zx.id,
+    steps: z6.array(zx.text).min(1),
+    fileScopes: z6.array(zx.text).min(1),
+    acceptanceCriteria: z6.array(zx.text).min(1)
+  }).strict()).min(1)
 }).strict();
+var planReferenceSchema = z6.object({ id: zx.id, value: zx.text }).strict();
+var planDesignSchema = z6.object({ bigIdeas: zx.text, keyApiUpdates: zx.text, consequences: zx.text }).strict();
+var planRequestSchema = z6.discriminatedUnion("kind", [
+  z6.object({ kind: z6.literal("annotation"), text: zx.text, response: zx.text }).strict(),
+  z6.object({ kind: z6.literal("user"), text: zx.text, response: zx.text.optional() }).strict(),
+  z6.object({ kind: z6.literal("blocker"), text: zx.text, response: zx.text.optional() }).strict()
+]);
+var revisionContentFields = {
+  request: planRequestSchema,
+  title: zx.text,
+  intent: zx.text,
+  requirements: z6.array(zx.text).min(1),
+  design: planDesignSchema,
+  references: z6.array(planReferenceSchema),
+  phases: z6.array(planPhaseDraftSchema).min(1),
+  briefs: z6.array(planBriefSchema).min(1)
+};
 var planContextParametersSchema = z6.object({
   cwd: zx.cwd,
   plan: z6.string().optional(),
@@ -7223,46 +7761,28 @@ var planInitParametersSchema = z6.object({
   title: zx.text.optional(),
   intent: zx.text.optional(),
   issueId: zx.text.optional(),
-  issueUrl: z6.string().url().optional(),
+  issueUrl: z6.url().optional(),
+  request: planRequestSchema.optional(),
   open: z6.boolean().optional()
 }).strict();
-var planUpdateOverviewParametersSchema = z6.object({
-  cwd: zx.cwd,
-  plan: zx.text,
-  expectedPlanRevision: zx.revision,
-  intent: zx.text.optional(),
-  requirements: z6.array(zx.text).optional(),
-  design: planDesignSchema.optional(),
-  references: z6.array(planReferenceSchema).optional()
-}).strict().refine((value) => value.intent || value.requirements || value.design || value.references, {
-  message: "At least one overview field is required."
-});
-var planAddPhaseParametersSchema = z6.object({
-  cwd: zx.cwd,
-  plan: zx.text,
-  expectedPlanRevision: zx.revision,
-  afterPhaseId: zx.id.optional(),
-  phase: planPhaseDraftSchema
-}).strict();
-var planRemovePhaseParametersSchema = z6.object({
-  cwd: zx.cwd,
-  plan: zx.text,
-  expectedPlanRevision: zx.revision,
-  phaseId: zx.id,
-  reason: zx.text
-}).strict();
-var planUpdatePhaseParametersSchema = z6.object({
-  cwd: zx.cwd,
-  plan: zx.text,
-  expectedPlanRevision: zx.revision,
-  phaseId: zx.id,
-  patch: z6.object({
-    title: zx.text.optional(),
-    objective: zx.text.optional(),
-    dependencies: z6.array(zx.id).optional(),
-    tasks: z6.array(planTaskDraftSchema).optional()
+var planApplyRevisionParametersSchema = z6.discriminatedUnion("mode", [
+  z6.object({
+    mode: z6.literal("create"),
+    cwd: zx.cwd,
+    shortSlug: zx.id,
+    branch: z6.string().min(1).optional(),
+    issueId: zx.text.optional(),
+    issueUrl: z6.url().optional(),
+    ...revisionContentFields
+  }).strict(),
+  z6.object({
+    mode: z6.literal("amend"),
+    cwd: zx.cwd,
+    plan: zx.text,
+    expectedPlanRevision: zx.revision,
+    ...revisionContentFields
   }).strict()
-}).strict();
+]);
 var planValidateParametersSchema = z6.object({ cwd: zx.cwd, plan: zx.text, strict: z6.boolean().optional() }).strict();
 var planLogProgressParametersSchema = z6.object({
   cwd: zx.cwd,
@@ -7362,116 +7882,17 @@ function createPlanTools(_pi, _modes, store = createPlanStore()) {
       }
     }),
     defineTool5({
-      name: "plan_update_overview",
-      label: "plan update overview",
-      description: "Replace selected plan overview fields using an expected plan revision.",
-      parameters: parameters(planUpdateOverviewParametersSchema),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = planUpdateOverviewParametersSchema.parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "update overview", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          return resetDraft({
-            ...plan,
-            intent: params.intent ?? plan.intent,
-            requirements: params.requirements ?? plan.requirements,
-            design: params.design ?? plan.design,
-            references: params.references ?? plan.references
-          });
-        });
-        return result2(`Updated ${record.id} to revision ${record.document.revision}.`, { record });
-      }
-    }),
-    defineTool5({
-      name: "plan_add_phase",
-      label: "plan add phase",
-      description: "Add an ordered phase with stable IDs.",
-      parameters: parameters(planAddPhaseParametersSchema),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = planAddPhaseParametersSchema.parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "add phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          if (allIds(plan).has(params.phase.id))
-            throw new Error(`Duplicate stable ID: ${params.phase.id}.`);
-          const phase = newPhase(params.phase);
-          const phases = [...plan.phases];
-          if (params.afterPhaseId) {
-            const index = phases.findIndex((item) => item.id === params.afterPhaseId);
-            if (index < 0)
-              throw new Error(`Unknown phase: ${params.afterPhaseId}.`);
-            phases.splice(index + 1, 0, phase);
-          } else
-            phases.push(phase);
-          assertNewIds(plan, phase);
-          return resetDraft({ ...plan, phases });
-        });
-        return result2(`Added phase ${params.phase.id} to ${record.id}.`, { record });
-      }
-    }),
-    defineTool5({
-      name: "plan_remove_phase",
-      label: "plan remove phase",
-      description: "Remove an unfinished phase that has no dependents.",
-      parameters: parameters(planRemovePhaseParametersSchema),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = planRemovePhaseParametersSchema.parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "remove phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan);
-          const phase = getPhase2(plan, params.phaseId);
-          if (phase.status === "completed" || phase.tasks.some((task) => task.status === "completed"))
-            throw new Error(`Completed phase ${phase.id} cannot be removed.`);
-          if (plan.phases.some((item) => item.dependencies.includes(phase.id)))
-            throw new Error(`Phase ${phase.id} has dependents and cannot be removed.`);
-          return resetDraft({ ...plan, phases: plan.phases.filter((item) => item.id !== phase.id) });
-        });
-        await store.log(params.cwd ?? process.cwd(), record.id, {
-          planRevision: record.document.revision,
-          kind: "updated",
-          actor: "planner",
-          message: `Removed phase ${params.phaseId}: ${params.reason}`,
-          phaseId: params.phaseId
-        });
-        return result2(`Removed phase ${params.phaseId}.`, { record });
-      }
-    }),
-    defineTool5({
-      name: "plan_update_phase",
-      label: "plan update phase",
-      description: "Update an unfinished phase and its ordered tasks.",
-      parameters: parameters(planUpdatePhaseParametersSchema),
+      name: "plan_apply_revision",
+      label: "plan apply revision",
+      description: "Create mode writes a complete revision 0 without plan_init; amend mode atomically writes the next complete authoring revision.",
+      parameters: parameters(planApplyRevisionParametersSchema),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = planUpdatePhaseParametersSchema.parse(input);
-        const record = await store.mutate(params.cwd ?? process.cwd(), params.plan, "update phase", (plan) => {
-          assertAuthoringRevision(plan, params.expectedPlanRevision);
-          assertAuthorable(plan, params.phaseId);
-          const existing = getPhase2(plan, params.phaseId);
-          if (existing.status === "completed")
-            throw new Error(`Completed phase ${existing.id} cannot be changed.`);
-          const tasks = params.patch.tasks ? reconcileTasks(existing.tasks, params.patch.tasks) : existing.tasks;
-          const updated = {
-            ...existing,
-            title: params.patch.title ?? existing.title,
-            objective: params.patch.objective ?? existing.objective,
-            dependencies: params.patch.dependencies ?? existing.dependencies,
-            tasks,
-            revision: existing.revision + 1,
-            status: existing.status === "blocked" ? "in_progress" : existing.status,
-            gate: { ...existing.gate, status: "stale" },
-            blocker: existing.status === "blocked" ? undefined : existing.blocker
-          };
-          assertNewIds({ ...plan, phases: plan.phases.filter((phase) => phase.id !== existing.id) }, updated);
-          return resetDraft({
-            ...plan,
-            phases: plan.phases.map((phase) => phase.id === existing.id ? updated : phase)
-          });
-        });
-        return result2(`Updated phase ${params.phaseId}.`, { record });
+        const params = planApplyRevisionParametersSchema.parse(input);
+        const workingDirectory = params.cwd ?? process.cwd();
+        const request = params.mode === "create" ? { ...params, branch: params.branch ?? await currentBranch(workingDirectory) } : params;
+        const record = await store.applyRevision(workingDirectory, request);
+        return result2(`Applied revision ${record.document.revision} to ${record.id}.`, { record });
       }
     }),
     defineTool5({
@@ -7483,7 +7904,7 @@ function createPlanTools(_pi, _modes, store = createPlanStore()) {
       async execute(_id, input) {
         const params = planValidateParametersSchema.parse(input);
         const record = await store.read(params.cwd ?? process.cwd(), params.plan);
-        const issues = validatePlanDocument(record.document, { strict: params.strict });
+        const issues = await validatePlanRecord(record, { strict: params.strict });
         const words = countDesignWords(record.document);
         return result2(issues.length ? issues.map((issue) => `- ${issue.severity}: ${issue.message}`).join(`
 `) : "Plan is valid.", { record, issues, designWordCount: words, ready: !issues.some((issue) => issue.severity === "error") });
@@ -7619,7 +8040,7 @@ function createPlanTools(_pi, _modes, store = createPlanStore()) {
         const resolution = await store.context(workingDirectory, params.plan);
         if (!resolution.record)
           throw new Error(resolution.ambiguous ? `Plan is ambiguous: ${resolution.candidates.map((item) => item.id).join(", ")}.` : "No matching plan.");
-        const cliPath = join14(resolveBundledAgentsDir(), "..", "dist", "cli.js");
+        const cliPath = join15(resolveBundledAgentsDir(), "..", "dist", "cli.js");
         const command = [
           process.execPath,
           cliPath,
@@ -7714,8 +8135,8 @@ function renderExecutionPrompt(packet) {
   return [
     `Execute the durable Diffpi plan using this packet: ${JSON.stringify(packet)}.`,
     "Call plan_context first and keep plan tools as the source of truth for eligibility, ownership, status, gates, and commits.",
-    "Use SubagentWorkflow for deterministic multi-task coordination: pipeline dependent work, parallelize only tasks with non-overlapping declared file scopes, and use structured schemas for worker outcomes.",
-    "The extension cannot launch workflow children over RPC, so the active orchestrator must invoke SubagentWorkflow itself.",
+    "Use bounded Agent delegation for eligible tasks. Run dependent tasks in order; parallelize only tasks with non-overlapping declared file scopes. Collect and verify worker results before changing plan state.",
+    "Use a multi-agent SubagentWorkflow only when the user explicitly opts into that orchestration.",
     "Persist every transition, progress event, issue, and deviation. Do not edit PLAN.md directly. Delegated implementation workers never commit or restructure the plan.",
     "In commit mode, create one local commit after each phase passes its gates and do not push. In push mode, commit and push each phase, record pending CI, and launch a bounded background Worker to call watch_ci for the exact SHA and then plan_record_ci for the phase while the next phase executes. Collect that monitor before the next push and collect all monitors before plan completion; failed or timed-out CI blocks execution."
   ].join(" ");
@@ -7779,81 +8200,6 @@ ${dirty.stdout.trim()}`);
     prompt: renderExecutionPrompt(packet)
   });
 }
-function newPhase(input) {
-  return {
-    id: input.id,
-    revision: 0,
-    title: input.title,
-    objective: input.objective,
-    dependencies: input.dependencies ?? [],
-    tasks: (input.tasks ?? []).map(newTask),
-    status: "pending",
-    gate: { phaseRevision: 0, status: "pending", results: [] }
-  };
-}
-function newTask(input) {
-  return {
-    id: input.id,
-    revision: 0,
-    title: input.title,
-    steps: input.steps,
-    dependencies: input.dependencies ?? [],
-    fileScopes: input.fileScopes ?? [],
-    acceptanceCriteria: input.acceptanceCriteria ?? [],
-    status: "pending"
-  };
-}
-function reconcileTasks(existing, drafts) {
-  const byId = new Map(existing.map((task) => [task.id, task]));
-  const requested = new Set(drafts.map((task) => task.id));
-  const protectedTask = existing.find((task) => (task.status === "completed" || task.status === "in_progress") && !requested.has(task.id));
-  if (protectedTask)
-    throw new Error(`${protectedTask.status === "completed" ? "Completed" : "Active"} task ${protectedTask.id} cannot be removed.`);
-  return drafts.map((draft) => {
-    const current = byId.get(draft.id);
-    if (current?.status === "completed" || current?.status === "in_progress")
-      return current;
-    return current ? {
-      ...newTask(draft),
-      revision: current.revision + 1,
-      status: current.status === "blocked" ? "pending" : current.status,
-      owner: current.status === "blocked" ? undefined : current.owner,
-      executionId: current.status === "blocked" ? undefined : current.executionId,
-      blocker: current.status === "blocked" ? undefined : current.blocker
-    } : newTask(draft);
-  });
-}
-function assertAuthoringRevision(plan, expected) {
-  if (plan.revision !== expected)
-    throw new Error(`Stale plan revision: expected ${expected}, found ${plan.revision}.`);
-}
-function assertAuthorable(plan, blockedPhaseId) {
-  if (plan.status === "completed")
-    throw new Error("Completed plans cannot be structurally changed.");
-  if (!plan.execution?.active)
-    return;
-  if (!blockedPhaseId)
-    throw new Error("An active execution owns this plan.");
-  const phase = getPhase2(plan, blockedPhaseId);
-  if (phase.status !== "blocked" && !phase.tasks.some((task) => task.status === "blocked"))
-    throw new Error("Planner may amend only blocked work during an active execution.");
-}
-function resetDraft(plan) {
-  if (plan.status === "blocked" && plan.execution?.active)
-    return { ...plan, status: "in_progress" };
-  return plan.status === "ready" || plan.status === "blocked" ? { ...plan, status: "draft" } : plan;
-}
-function allIds(plan) {
-  return new Set([plan.id, ...plan.phases.flatMap((phase) => [phase.id, ...phase.tasks.map((task) => task.id)])]);
-}
-function assertNewIds(plan, phase) {
-  const known = allIds(plan);
-  for (const candidate of [phase.id, ...phase.tasks.map((task) => task.id)]) {
-    if (known.has(candidate))
-      throw new Error(`Duplicate stable ID: ${candidate}.`);
-    known.add(candidate);
-  }
-}
 function getPhase2(plan, phaseId) {
   const phase = plan.phases.find((item) => item.id === phaseId);
   if (!phase)
@@ -7891,10 +8237,10 @@ function result2(text, details = {}) {
 
 // src/tools/review.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir8, writeFile as writeFile6 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { mkdir as mkdir7, readdir as readdir3, readFile as readFile12, rename as rename4, stat, unlink as unlink2, writeFile as writeFile7 } from "node:fs/promises";
+import { join as join17 } from "node:path";
 import { defineTool as defineTool6 } from "@earendil-works/pi-coding-agent";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 
 // src/review/types.ts
 import { z as z8 } from "zod";
@@ -7919,9 +8265,24 @@ function yymmdd(date = new Date) {
 function reviewRecordName(target, date = new Date) {
   return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
 }
-function dedupeFindings(findings) {
-  const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
-  const byKey = new Map;
+function localResponseMarker(threadId) {
+  return `<!-- diffpi -->`;
+}
+function isLocalResponse(body) {
+  return /^<!-- diffpi(?:-local-response:[A-Za-z0-9_-]+)? -->\n/m.test(body);
+}
+function parseReviewThreadAction(body) {
+  const match = body.match(/^\[(REOPEN|RESOLVE|DELETE)\]\s*/i);
+  if (!match)
+    return { body };
+  return {
+    action: match[1].toLowerCase(),
+    body: body.slice(match[0].length)
+  };
+}
+function dedupeFindings(findings) {
+  const rank = { BLOCKING: 3, CONSIDER: 2, NOTE: 1 };
+  const byKey = new Map;
   for (const finding of findings) {
     const key = `${finding.file}:${finding.line}`;
     const existing = byKey.get(key);
@@ -7964,6 +8325,18 @@ function renderCommentBody(finding) {
   return `${prefix}${finding.body}${reference}`;
 }
 // src/review/review-markdown.ts
+import { z as z9 } from "zod";
+var reviewThreadRecordSchema = z9.object({
+  id: z9.string().min(1),
+  file: z9.string().nullable().optional().transform((value) => value ?? undefined),
+  line: z9.number().int().positive().nullable().optional().transform((value) => value ?? undefined),
+  body: z9.string(),
+  author: z9.string().optional(),
+  resolved: z9.boolean(),
+  addressed: z9.boolean().optional(),
+  question: z9.boolean(),
+  replies: z9.array(z9.string()).optional()
+});
 function renderReviewDoc(input) {
   const anchored = dedupeFindings(input.findings).filter((finding) => finding.line > 0);
   const lines = [`# Review: ${input.title}`, "", "## Metadata"];
@@ -8005,6 +8378,88 @@ function renderReviewDoc(input) {
 `).trimEnd()}
 `;
 }
+function renderThreadArtifact(title, target, threads, options = {}) {
+  const records = threads.map((thread) => ({
+    id: thread.id,
+    file: thread.file,
+    line: thread.line,
+    body: thread.body,
+    author: thread.author,
+    resolved: thread.resolved,
+    addressed: thread.addressed,
+    question: thread.question,
+    replies: thread.replies
+  }));
+  const payload = Buffer.from(JSON.stringify(records), "utf8").toString("base64url");
+  const lines = [
+    `<!-- diffpi-threads:${payload} -->`,
+    `# Review threads: ${title}`,
+    "",
+    "## Metadata",
+    "",
+    `- Target: ${target}`,
+    `- Pulled: ${options.timestamp ?? new Date().toISOString()}`
+  ];
+  if (options.number !== undefined)
+    lines.push(`- PR/MR: #${options.number}${options.url ? ` — ${options.url}` : ""}`);
+  lines.push("", "## Replies", "");
+  for (const thread of threads) {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} (${thread.id})`, "", `<!-- diffpi-reply-start:${id} -->`, thread.reply ?? "", `<!-- diffpi-reply-end:${id} -->`, "");
+  }
+  lines.push("## Source comments", "");
+  for (const thread of threads) {
+    lines.push(`### ${thread.file ?? "review"}:${thread.line ?? "n/a"} — ${thread.author ?? "unknown"}`, "", `Thread: ${thread.id}`, `Status: ${thread.resolved ? "resolved" : thread.addressed ? "addressed" : "open"}`, "", "**Source comment**", "", thread.body, "", "**Recorded response**", "", thread.reply?.trim() || "_No response recorded._", "", "---", "");
+  }
+  return `${lines.join(`
+`).trimEnd()}
+`;
+}
+function parseThreadArtifact(content) {
+  const payload = content.match(/^<!-- diffpi-threads:([A-Za-z0-9_-]+) -->$/m)?.[1];
+  if (!payload)
+    throw new Error("This file is not a Diffpi thread artifact.");
+  let threads;
+  try {
+    const decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    threads = z9.array(reviewThreadRecordSchema).parse(decoded);
+  } catch {
+    throw new Error("Cannot parse the Diffpi thread artifact payload.");
+  }
+  const replies = content.split(/^## Source comments$/m, 1)[0] ?? "";
+  return threads.map((thread) => {
+    const id = Buffer.from(thread.id, "utf8").toString("base64url");
+    const startMarker = `<!-- diffpi-reply-start:${id} -->
+`;
+    const endMarker = `
+<!-- diffpi-reply-end:${id} -->`;
+    const start = replies.indexOf(startMarker);
+    const end = start < 0 ? -1 : replies.indexOf(endMarker, start + startMarker.length);
+    const reply = start >= 0 && end >= 0 ? replies.slice(start + startMarker.length, end).trim() : "";
+    return reply ? { ...thread, reply } : thread;
+  });
+}
+function upsertThreadReply(content, threadId, body, question, resolved) {
+  const threads = parseThreadArtifact(content);
+  const thread = threads.find((candidate) => candidate.id === threadId);
+  if (!thread)
+    throw new Error(`Review thread ${threadId} was not found in the local artifact.`);
+  thread.reply = body;
+  thread.addressed = true;
+  if (question !== undefined)
+    thread.question = question;
+  if (resolved !== undefined)
+    thread.resolved = resolved;
+  const title = content.match(/^# Review threads: (.+)$/m)?.[1] ?? "review";
+  const target = content.match(/^- Target: (.+)$/m)?.[1] ?? "local";
+  const timestamp = content.match(/^- Pulled: (.+)$/m)?.[1];
+  const pr = content.match(/^- PR\/MR: #(\d+)(?: — (.+))?$/m);
+  return renderThreadArtifact(title, target, threads, {
+    timestamp,
+    number: pr ? Number.parseInt(pr[1], 10) : undefined,
+    url: pr?.[2]
+  });
+}
 // src/review/github-review-backend.ts
 function GitHubReviewBackend(vcs, number) {
   const pendingReview = async () => {
@@ -8066,6 +8521,9 @@ function GitHubReviewBackend(vcs, number) {
         id: thread.id,
         file: thread.path ?? undefined,
         line: thread.line ?? undefined,
+        rootCommentId: comment?.id,
+        commentIds: nodes.flatMap((node) => [node.id, node.databaseId?.toString()].filter((id) => Boolean(id))),
+        commentNodeIds: nodes.flatMap((node) => node.id ? [node.id] : []),
         body,
         author: comment?.author?.login,
         resolved: thread.isResolved,
@@ -8075,6 +8533,7 @@ function GitHubReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const pending = await pendingReview();
       if (!pending) {
@@ -8132,6 +8591,33 @@ function GitHubReviewBackend(vcs, number) {
         await ghChecked(args);
       }
     },
+    async readDraft() {
+      const pending = await pendingReview();
+      if (!pending)
+        return { comments: [], body: "" };
+      const review = await ghChecked(["api", `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}`]);
+      const comments = await ghChecked([
+        "api",
+        `/repos/${vcs.owner}/${vcs.repo}/pulls/${number}/reviews/${pending.id}/comments`
+      ]);
+      let reviewData;
+      let commentData;
+      try {
+        reviewData = JSON.parse(review.stdout);
+        commentData = JSON.parse(comments.stdout);
+      } catch {
+        throw new Error("Cannot parse the pending GitHub review as JSON.");
+      }
+      return {
+        body: reviewData.body ?? "",
+        comments: commentData.map((comment) => ({
+          file: comment.path,
+          line: comment.line ?? comment.original_line ?? undefined,
+          side: comment.side ?? undefined,
+          body: comment.body
+        }))
+      };
+    },
     listThreads,
     async reply(input) {
       const threads = await listThreads();
@@ -8148,14 +8634,32 @@ function GitHubReviewBackend(vcs, number) {
           `body=${input.body}`
         ]);
       }
-      if (input.resolve) {
+      if (input.resolve)
+        await this.setResolved?.(input.threadId, true);
+    },
+    async setResolved(threadId, resolved) {
+      await ghChecked([
+        "api",
+        "graphql",
+        "-f",
+        `query=${resolved ? GITHUB_RESOLVE_MUTATION : GITHUB_UNRESOLVE_MUTATION}`,
+        "-f",
+        `threadId=${threadId}`
+      ]);
+    },
+    async deleteThread(threadId) {
+      const thread = (await listThreads()).find((candidate) => candidate.id === threadId);
+      const commentNodeIds = thread?.commentNodeIds ?? (thread?.rootCommentId ? [thread.rootCommentId] : []);
+      if (!commentNodeIds.length)
+        throw new Error(`Cannot delete GitHub thread ${threadId}: comment node IDs are missing.`);
+      for (const commentId of commentNodeIds) {
         await ghChecked([
           "api",
           "graphql",
           "-f",
-          `query=${GITHUB_RESOLVE_MUTATION}`,
+          `query=${GITHUB_DELETE_COMMENT_MUTATION}`,
           "-f",
-          `threadId=${input.threadId}`
+          `commentId=${commentId}`
         ]);
       }
     },
@@ -8174,11 +8678,13 @@ function GitHubReviewBackend(vcs, number) {
 function githubReviewSubmissionEndpoint(owner, repo, id, pendingReviewId) {
   return pendingReviewId ? `/repos/${owner}/${repo}/pulls/${id}/reviews/${pendingReviewId}/events` : `/repos/${owner}/${repo}/pulls/${id}/reviews`;
 }
-var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
+var GITHUB_THREADS_QUERY = `query($owner:String!,$repo:String!,$number:Int!,$after:String){repository(owner:$owner,name:$repo){pullRequest(number:$number){reviewThreads(first:100,after:$after){nodes{id,isResolved,path,line,comments(first:100){nodes{id,databaseId,body,author{login}}}}pageInfo{hasNextPage,endCursor}}}}}`;
 var GITHUB_ADD_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!,$line:Int!,$side:DiffSide!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,line:$line,side:$side}){thread{id}}}`;
 var GITHUB_ADD_FILE_THREAD_MUTATION = `mutation($reviewId:ID!,$body:String!,$path:String!){addPullRequestReviewThread(input:{pullRequestReviewId:$reviewId,body:$body,path:$path,subjectType:FILE}){thread{id}}}`;
 var GITHUB_REPLY_MUTATION = `mutation($threadId:ID!,$body:String!){addPullRequestReviewThreadReply(input:{pullRequestReviewThreadId:$threadId,body:$body}){comment{id}}}`;
 var GITHUB_RESOLVE_MUTATION = `mutation($threadId:ID!){resolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
+var GITHUB_UNRESOLVE_MUTATION = `mutation($threadId:ID!){unresolveReviewThread(input:{threadId:$threadId}){thread{isResolved}}}`;
+var GITHUB_DELETE_COMMENT_MUTATION = `mutation($commentId:ID!){deletePullRequestReviewComment(input:{id:$commentId}){clientMutationId}}`;
 
 // src/review/gitlab-review-backend.ts
 function GitLabReviewBackend(vcs, number) {
@@ -8215,6 +8721,7 @@ function GitLabReviewBackend(vcs, number) {
     });
   };
   return {
+    kind: "remote",
     async stage(draft) {
       const endpoint = `${mergeRequestEndpoint()}/draft_notes`;
       if (draft.body.trim()) {
@@ -8243,6 +8750,36 @@ function GitLabReviewBackend(vcs, number) {
         });
       }
     },
+    async readDraft() {
+      const result = await glabChecked(["api", `${mergeRequestEndpoint()}/draft_notes`]);
+      let notes;
+      try {
+        notes = JSON.parse(result.stdout);
+      } catch {
+        throw new Error("Cannot parse GitLab draft notes as JSON.");
+      }
+      const comments = [];
+      const body = [];
+      for (const note of notes) {
+        if (!note.note)
+          continue;
+        const file = note.position?.new_path ?? note.position?.old_path;
+        const line = note.position?.new_line ?? note.position?.old_line;
+        if (file && line) {
+          comments.push({
+            file,
+            line,
+            side: note.position?.new_line ? "RIGHT" : "LEFT",
+            body: note.note
+          });
+        } else {
+          body.push(note.note);
+        }
+      }
+      return { comments, body: body.join(`
+
+`) };
+    },
     listThreads,
     async reply(input) {
       const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(input.threadId)}`;
@@ -8254,7 +8791,15 @@ function GitLabReviewBackend(vcs, number) {
         });
       }
       if (input.resolve)
-        await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=true`]);
+        await this.setResolved?.(input.threadId, true);
+    },
+    async setResolved(threadId, resolved) {
+      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(threadId)}`;
+      await glabChecked(["api", "--method", "PUT", `${endpoint}?resolved=${resolved}`]);
+    },
+    async deleteThread(threadId) {
+      const endpoint = `${mergeRequestEndpoint()}/discussions/${encodeURIComponent(threadId)}`;
+      await glabChecked(["api", "--method", "DELETE", endpoint]);
     },
     async publish(event) {
       assertReviewEventSupported(vcs.provider, event);
@@ -8294,20 +8839,11 @@ function hasGitlabDraftNotes(input) {
   }
 }
 
-// src/review/review-backend.ts
-function createRemoteReviewBackend(vcs, number) {
-  if (vcs.provider === "github")
-    return GitHubReviewBackend(vcs, number);
-  if (vcs.provider === "gitlab")
-    return GitLabReviewBackend(vcs, number);
-  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
-}
-// src/review/local-reviews.ts
-import { mkdir as mkdir7, readdir as readdir2, readFile as readFile9, unlink as unlink2, writeFile as writeFile5 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+// src/review/local-review-backend.ts
+import { readFile as readFile10, writeFile as writeFile5 } from "node:fs/promises";
 
 // src/extensions/tuicrx.ts
-import { readFile as readFile8, realpath as realpath4 } from "node:fs/promises";
+import { readFile as readFile9, realpath as realpath4 } from "node:fs/promises";
 import { resolve as resolve4 } from "node:path";
 async function tuicrAvailable() {
   return Boolean(await findExecutable("tuicr"));
@@ -8375,6 +8911,11 @@ async function resolveReviewSession(cwd, target) {
   }
   return resolveSession(cwd, target.branch);
 }
+async function resolvePublishSession(cwd, target) {
+  if (target.owner && target.repo && target.number !== undefined)
+    return resolvePrSession(cwd, target.owner, target.repo, target.number);
+  return resolveSession(cwd, target.branch);
+}
 async function resolvePrSession(cwd, owner, repo, number) {
   const coordinate = `${owner}/${repo}`.toLowerCase();
   const sessions = await listSessions(cwd);
@@ -8399,7 +8940,7 @@ async function findMatchingSession(sessions, cwd, branch) {
   return;
 }
 async function readSession(path) {
-  const content = await readFile8(path, "utf8");
+  const content = await readFile9(path, "utf8");
   try {
     return JSON.parse(content);
   } catch {
@@ -8409,6 +8950,8 @@ async function readSession(path) {
 function toLocalReviewThreads(session) {
   const threads = [];
   const add = (comment, location = {}) => {
+    if (isLocalResponse(comment.content))
+      return;
     const author = commentAuthor(comment);
     threads.push({
       id: comment.id ?? `local-${threads.length + 1}`,
@@ -8434,6 +8977,54 @@ function toLocalReviewThreads(session) {
   }
   return threads;
 }
+function toFindings(session, options = {}) {
+  const comments = [];
+  const include = (comment) => (!options.agentOnly || commentAuthor(comment)?.startsWith("Agent: ")) && (!options.excludeLocalResponses || !isLocalResponse(comment.content));
+  const publishableBody = (comment) => {
+    const author = commentAuthor(comment);
+    const route = author?.match(/^Agent:\s*(.+)$/)?.[1];
+    return route ? withRemoteProvenance(comment.content, route) : comment.content;
+  };
+  const bodyParts = (session.review_comments ?? []).flatMap((comment) => include(comment) ? [publishableBody(comment)] : []);
+  for (const [file, entry] of Object.entries(session.files ?? {})) {
+    for (const fileComment of entry.file_comments ?? []) {
+      if (!include(fileComment))
+        continue;
+      const comment = {
+        file,
+        body: fileComment.content,
+        ...fileComment.id ? { sourceCommentId: String(fileComment.id) } : {}
+      };
+      const author = commentAuthor(fileComment);
+      if (author)
+        comment.author = author;
+      comments.push(comment);
+    }
+    for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
+      const line = Number.parseInt(lineKey, 10);
+      if (!Number.isFinite(line))
+        continue;
+      for (const lineComment of lineComments) {
+        if (!include(lineComment))
+          continue;
+        const comment = {
+          file,
+          line,
+          side: lineComment.side === "old" ? "LEFT" : "RIGHT",
+          body: lineComment.content,
+          ...lineComment.id ? { sourceCommentId: String(lineComment.id) } : {}
+        };
+        const author = commentAuthor(lineComment);
+        if (author)
+          comment.author = author;
+        comments.push(comment);
+      }
+    }
+  }
+  return { comments, body: bodyParts.join(`
+
+`) };
+}
 async function requireTuicr() {
   if (!await tuicrAvailable())
     throw new Error("tuicr is not installed or is not available on PATH.");
@@ -8449,83 +9040,195 @@ async function canonicalPath3(path) {
   }
 }
 
-// src/review/local-reviews.ts
-async function captureLocalReview(input) {
-  const id = reviewSlug(input.branch) || "local-review";
-  const dir = join15(await reviewsDir(input.cwd, input.homeDir), id);
-  await mkdir7(dir, { recursive: true });
-  const revision = await nextRevision(dir);
-  const output = await readFile9(input.session.path, "utf8");
-  const comments = toLocalReviewThreads(await readSession(input.session.path));
-  const dump = {
-    schemaVersion: 1,
-    id,
-    revision,
-    branch: input.branch,
-    base: input.base,
-    createdAt: (input.now ?? (() => new Date))().toISOString(),
-    diff: input.diff,
-    comments,
-    tuicr: { slug: input.session.slug, output }
+// src/review/local-review-backend.ts
+function LocalReviewBackend(options) {
+  return {
+    kind: "local",
+    async stage(draft) {
+      for (const comment of draft.comments) {
+        await addComment(options.session, comment.body, {
+          targetFile: comment.file,
+          line: comment.line,
+          side: comment.side === "LEFT" ? "old" : "new",
+          username: options.author
+        });
+      }
+      if (draft.body.trim())
+        await addComment(options.session, draft.body, { username: options.author });
+    },
+    async readDraft() {
+      return toFindings(await readSession(options.session), { excludeLocalResponses: true });
+    },
+    async listThreads() {
+      try {
+        return parseThreadArtifact(await readFile10(options.artifactPath, "utf8"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          return [];
+        throw error;
+      }
+    },
+    async reply(input) {
+      const content = await readFile10(options.artifactPath, "utf8");
+      await writeFile5(options.artifactPath, upsertThreadReply(content, input.threadId, input.body, input.question, input.resolve), "utf8");
+    },
+    async publish() {
+      throw new Error("Promote a local draft through a remote review backend before publishing it.");
+    }
   };
-  const path = join15(dir, `${revision}.json`);
-  await writeFile5(path, `${JSON.stringify(dump, null, 2)}
-`, { encoding: "utf8", flag: "wx" });
-  await unlink2(input.session.path);
-  return { path, dump };
 }
-async function nextRevision(dir) {
-  return await latestRevision(dir) + 1;
+
+// src/review/review-backend.ts
+function createRemoteReviewBackend(vcs, number) {
+  if (vcs.provider === "github")
+    return GitHubReviewBackend(vcs, number);
+  if (vcs.provider === "gitlab")
+    return GitLabReviewBackend(vcs, number);
+  throw new Error("A remote review backend requires a GitHub or GitLab repository.");
+}
+function createLocalReviewBackend(options) {
+  return LocalReviewBackend(options);
+}
+// src/review/review-state.ts
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile11, rename as rename3, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join16 } from "node:path";
+import { z as z10 } from "zod";
+var reviewPublicationStateSchema = z10.object({
+  target: z10.string().optional(),
+  bodies: z10.array(z10.string()).default([]),
+  comments: z10.array(z10.string()).default([]),
+  stagedComments: z10.array(z10.string()).default([]),
+  replies: z10.array(z10.string()).default([]),
+  overlayPath: z10.string().optional()
+});
+function reviewBodyFingerprint(body) {
+  return digest(body);
 }
-async function latestRevision(dir) {
+function reviewCommentFingerprint(comment) {
+  return digest([comment.file, String(comment.line), comment.side ?? "RIGHT", comment.body].join("\x00"));
+}
+function reviewReplyFingerprint(threadId, body) {
+  return digest(`${threadId}\x00${body}`);
+}
+function unpublishedReviewComments(comments, knownFingerprints) {
+  return comments.filter((comment) => !knownFingerprints.has(reviewCommentFingerprint(comment)));
+}
+async function loadReviewPublicationState(cwd, vcs, number, homeDir) {
+  const target = `${vcs.provider}:${vcs.owner}/${vcs.repo}#${number}`;
+  const path = join16(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
   try {
-    return (await readdir2(dir)).reduce((latest, name) => {
-      const match = name.match(/^(\d+)\.json$/);
-      return match ? Math.max(latest, Number(match[1])) : latest;
-    }, 0);
+    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile11(path, "utf8")));
+    return { path, state: { ...parsed, target } };
   } catch (error) {
-    if (error.code === "ENOENT")
-      return 0;
+    if (error.code === "ENOENT") {
+      return { path, state: { target, bodies: [], comments: [], stagedComments: [], replies: [] } };
+    }
+    if (error instanceof SyntaxError || error instanceof z10.ZodError) {
+      throw new Error(`Cannot parse review publication state: ${path}`);
+    }
     throw error;
   }
 }
+async function saveReviewPublicationState(path, state) {
+  const temp = `${path}.${process.pid}.tmp`;
+  await writeFile6(temp, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  await rename3(temp, path);
+}
+function digest(value) {
+  return createHash4("sha256").update(value).digest("hex");
+}
 // src/tools/review.ts
-var contextSchema = z9.object({
-  cwd: z9.string().optional(),
-  target: z9.string().optional(),
-  workingTree: z9.boolean().optional()
+var contextSchema = z11.object({
+  cwd: z11.string().optional(),
+  target: z11.string().optional(),
+  workingTree: z11.boolean().optional()
 });
-var localSchema = contextSchema.extend({ local: z9.boolean().optional() });
+var localSchema = contextSchema.extend({ local: z11.boolean().optional() });
 var openSchema = localSchema.extend({
-  title: z9.string().optional(),
-  intent: z9.string().optional(),
-  issueUrl: z9.string().url().optional(),
-  base: z9.string().optional()
+  title: z11.string().optional(),
+  intent: z11.string().optional(),
+  issueUrl: z11.string().url().optional(),
+  base: z11.string().optional()
 });
 var submitSchema = localSchema.extend({
   findings: findingsSchema,
-  overallIssues: z9.array(z9.string()).optional(),
-  notVerified: z9.array(z9.string()).optional(),
-  title: z9.string().optional()
+  overallIssues: z11.array(z11.string()).optional(),
+  notVerified: z11.array(z11.string()).optional(),
+  title: z11.string().optional()
 });
 var addCommentSchema = localSchema.extend({
-  body: z9.string().min(1),
-  file: z9.string().min(1),
-  line: z9.number().int().positive(),
-  side: z9.enum(["LEFT", "RIGHT"]).optional()
+  body: z11.string().min(1),
+  file: z11.string().min(1),
+  line: z11.number().int().positive(),
+  side: z11.enum(["LEFT", "RIGHT"]).optional()
 });
 var respondSchema = localSchema.extend({
-  threadId: z9.string().min(1),
-  body: z9.string().min(1),
-  question: z9.boolean().optional(),
-  resolve: z9.boolean().optional()
+  threadId: z11.string().min(1),
+  body: z11.string().min(1),
+  question: z11.boolean().optional(),
+  resolve: z11.boolean().optional()
 });
 var publishSchema = localSchema.extend({
-  status: z9.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+  status: z11.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
 });
 var completeSchema = localSchema.extend({
-  action: z9.enum(["approve", "reject", "abandon"]).optional()
+  action: z11.enum(["approve", "reject", "abandon"]).optional()
 });
+function hasReviewDraft(comments, body) {
+  return comments.length > 0 || body.trim().length > 0;
+}
+function reviewBrowserCommand(url, platform = process.platform) {
+  return platform === "darwin" ? { command: "open", args: [url] } : platform === "win32" ? { command: "cmd", args: ["/c", "start", "", url] } : { command: "xdg-open", args: [url] };
+}
+async function openReviewUrl(url, execute = run, platform = process.platform) {
+  const launch = reviewBrowserCommand(url, platform);
+  try {
+    return (await execute(launch.command, launch.args)).code === 0;
+  } catch {
+    return false;
+  }
+}
+function partitionReviewComments(comments, knownFingerprints, model) {
+  const normalized = comments.map((comment) => {
+    const published = { ...comment, body: withCommentProvenance(comment, model) };
+    return { source: comment, published, fingerprint: reviewCommentFingerprint(published) };
+  });
+  return {
+    checkpointed: normalized.filter((comment) => knownFingerprints.has(comment.fingerprint)),
+    candidates: normalized.filter((comment) => !knownFingerprints.has(comment.fingerprint))
+  };
+}
+function reviewResponseResolution(question, requested) {
+  return question ? false : requested ?? false;
+}
+function workingTreeReplyDraft(thread, body) {
+  if (!thread.file)
+    return { comments: [], body };
+  return {
+    comments: [
+      {
+        file: thread.file,
+        ...thread.line === undefined ? {} : { line: thread.line, side: "RIGHT" },
+        body
+      }
+    ],
+    body: ""
+  };
+}
+function resolveReviewThread(comment, threads) {
+  const sourceCommentId = comment.sourceCommentId;
+  if (sourceCommentId) {
+    const identified = threads.find((thread) => thread.id === sourceCommentId || thread.rootCommentId === sourceCommentId || thread.commentIds?.includes(sourceCommentId));
+    if (identified)
+      return identified;
+  }
+  const matches = threads.filter((thread) => thread.file === comment.file && (thread.line ?? undefined) === (comment.line ?? undefined));
+  if (matches.length > 1)
+    throw new Error(`Ambiguous remote review threads at ${comment.file}:${comment.line ?? "file"}: ${matches.map((thread) => thread.id).join(", ")}.`);
+  return matches[0];
+}
 async function workingTreeDiff(cwd) {
   const tracked = await run("git", ["-C", cwd, "diff", "HEAD"], { capture: "unbounded" });
   if (tracked.code !== 0)
@@ -8558,7 +9261,9 @@ function createReviewTools() {
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         const store = await ensureStore(review.cwd);
         const env = { ide: detectIde(), mux: detectMux(), shell: detectShell() };
-        const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
+        const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree)).catch(() => {
+          return;
+        });
         const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
         const backend = params.local || params.workingTree ? "tuicr" : review.forge?.provider ?? "unsupported";
         return result3([
@@ -8582,6 +9287,21 @@ function createReviewTools() {
         });
       }
     }),
+    defineTool6({
+      name: "review_status",
+      label: "review status",
+      description: "Report local and remote review lifecycle status without requiring a forge or tuicr.",
+      promptSnippet: "Call review_status for review lifecycle state",
+      promptGuidelines: ["Use this for status even when no forge or tuicr binary is available."],
+      parameters: parameters2(localSchema),
+      executionMode: "parallel",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const status = await collectReviewStatus(review);
+        return result3(status.text, status.details);
+      }
+    }),
     defineTool6({
       name: "review_new",
       label: "review new",
@@ -8625,6 +9345,31 @@ ${openMessage}`, {
         });
       }
     }),
+    defineTool6({
+      name: "review_open",
+      label: "review open",
+      description: "Open an existing remote PR/MR in the system browser; never creates one.",
+      promptSnippet: "Call review_open to open an existing PR/MR",
+      promptGuidelines: ["Direct users to review_new when no remote review exists."],
+      parameters: parameters2(localSchema),
+      executionMode: "sequential",
+      async execute(_id, input) {
+        const params = localSchema.parse(input);
+        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (params.local || params.workingTree)
+          return launchLocalReview(review, true);
+        if (!review.forge)
+          return result3(`${unsupportedForgeMessage()} Use review_new with local=true for an offline review.`);
+        if (!review.pr)
+          return result3("No remote PR/MR exists. Use review_new to create a draft review first.");
+        const opened = await openReviewUrl(review.pr.url);
+        return result3(`${opened ? "Opened" : "Open this URL"} PR/MR #${review.pr.number}: ${review.pr.url}`, {
+          pr: review.pr,
+          opened,
+          url: review.pr.url
+        });
+      }
+    }),
     defineTool6({
       name: "review_edit",
       label: "review edit",
@@ -8721,7 +9466,7 @@ ${openMessage}`, {
         const gates = await runMiseGates(review.cwd);
         const baseRef = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "local");
         const artifact = await newReviewArtifactPath(review.cwd, params.local || params.workingTree || !review.pr ? "uncommitted" : await reviewTargetId(review));
-        await writeFile6(artifact, renderReviewDoc({
+        await writeFile7(artifact, renderReviewDoc({
           title: params.title ?? review.pr?.title ?? review.vcs.branch,
           number: useLocalBackend ? undefined : review.pr?.number,
           url: useLocalBackend ? undefined : review.pr?.url,
@@ -8744,21 +9489,17 @@ ${openMessage}`, {
               count: findings.length
             });
           }
-          for (const comment of comments) {
-            await addComment(session.path, comment.body, {
-              targetFile: comment.file,
-              line: comment.line,
-              side: comment.side === "LEFT" ? "old" : "new",
-              username: localReviewAuthor(model)
-            });
-          }
-          if (body.trim())
-            await addComment(session.path, body, { username: localReviewAuthor(model) });
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: artifact,
+            author: localReviewAuthor(model)
+          });
+          await backend.stage({ comments, body });
           return result3(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
         }
         if (!review.pr)
           return result3(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
-        const hasDraft = comments.length > 0 || body.trim().length > 0;
+        const hasDraft = hasReviewDraft(comments, body);
         if (hasDraft) {
           await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
         }
@@ -8794,12 +9535,12 @@ ${openMessage}`, {
           const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
           if (!session)
             return result3("No matching tuicr session. Open review_new or review_launch_ui first.");
-          await addComment(session.path, comment.body, {
-            targetFile: comment.file,
-            line: comment.line,
-            side: comment.side === "LEFT" ? "old" : "new",
-            username: localReviewAuthor(model)
+          const backend = createLocalReviewBackend({
+            session: session.path,
+            artifactPath: "",
+            author: localReviewAuthor(model)
           });
+          await backend.stage({ comments: [comment], body: "" });
           return result3(`Comment added to tuicr session ${session.slug}.`, { session, comment });
         }
         if (!review.pr)
@@ -8811,70 +9552,88 @@ ${openMessage}`, {
     defineTool6({
       name: "review_comments",
       label: "review comments",
-      description: "Read remote GitHub or GitLab review threads.",
-      promptSnippet: "Call review_comments before addressing remote findings",
-      promptGuidelines: ["Use review_dump for a local tuicr review."],
+      description: "Pull review threads or local tuicr comments and write a target-named artifact.",
+      promptSnippet: "Call review_comments before addressing findings",
+      promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
       parameters: parameters2(localSchema),
-      executionMode: "parallel",
+      executionMode: "sequential",
       async execute(_id, input) {
         const params = localSchema.parse(input);
-        if (params.local || params.workingTree)
-          return result3("Use review_dump for a local tuicr review.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        if (!review.pr || !review.forge)
+        let threads;
+        let artifact;
+        if (params.local || params.workingTree) {
+          const session = await resolveTuicrSession(review, true);
+          if (!session)
+            return result3("No matching tuicr session found.");
+          artifact = await localThreadArtifactPath(review.cwd, session.slug);
+          threads = await syncLocalThreadArtifact(artifact, review.pr?.title ?? review.vcs.branch, session.slug, toLocalReviewThreads(await readSession(session.path)));
+        } else if (review.pr && review.forge) {
+          threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
+          const target = await reviewTargetId(review);
+          artifact = await newReviewArtifactPath(review.cwd, target);
+          await writeFile7(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
+        } else {
           return result3(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
-        const threads = await createRemoteReviewBackend(review.vcs, review.pr.number).listThreads();
+        }
         return result3(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
-`) || "No comments.", { pr: review.pr, threads });
-      }
-    }),
-    defineTool6({
-      name: "review_dump",
-      label: "review dump",
-      description: "Save one immutable local tuicr review revision and remove its completed session.",
-      promptSnippet: "Call review_dump before applying local review feedback",
-      promptGuidelines: ["Each dump advances the local review revision."],
-      parameters: parameters2(localSchema),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = localSchema.parse(input);
-        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        const session = await resolveTuicrSession(review, true);
-        if (!session)
-          return result3("No matching local tuicr session found.");
-        const base = review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : "HEAD");
-        const captured = await captureLocalReview({
-          cwd: review.cwd,
-          branch: review.vcs.branch,
-          base,
-          diff: await workingTreeDiff(review.cwd),
-          session
-        });
-        return result3(captured.dump.comments.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
-`) || "No comments.", { artifact: captured.path, review: captured.dump, threads: captured.dump.comments });
+`) || "No comments.", { artifact, threads });
       }
     }),
     defineTool6({
       name: "review_respond",
       label: "review respond",
-      description: "Reply directly to a remote GitHub or GitLab review thread.",
-      promptSnippet: "Call review_respond after addressing a remote comment",
-      promptGuidelines: ["Leave threads open unless the user explicitly requests resolution."],
+      description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
+      promptSnippet: "Call review_respond after addressing a comment",
+      promptGuidelines: ["Question replies remain unresolved."],
       parameters: parameters2(respondSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = respondSchema.parse(input);
-        if (params.local)
-          return result3("Local reviews use immutable revision dumps, not thread replies.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        const model = modelRoute(ctx);
+        if (params.local) {
+          const tuicrSession = await resolveTuicrSession(review, true);
+          if (!tuicrSession)
+            return result3("No matching tuicr session. Open review_new or review_launch_ui first.");
+          const artifact = await localThreadArtifactPath(review.cwd, tuicrSession.slug);
+          if (!existsSync2(artifact))
+            return result3("No local review artifact. Run review_comments with local=true first.");
+          const threads = await readThreadArtifact(artifact);
+          const known = threads.find((thread) => thread.id === params.threadId);
+          const question = known?.question === true || params.question === true || !known && params.question === undefined;
+          const awaitUserDeletion = !question && params.resolve === true;
+          await addComment(tuicrSession.path, `${localResponseMarker(params.threadId)}
+${params.body}`, {
+            targetFile: known?.file,
+            line: known?.line,
+            side: "new",
+            username: localReviewAuthor(model)
+          });
+          await createLocalReviewBackend({
+            session: tuicrSession.path,
+            artifactPath: artifact,
+            author: localReviewAuthor(model)
+          }).reply({
+            threadId: params.threadId,
+            body: params.body,
+            resolve: false,
+            question
+          });
+          return result3(`Local ${question ? "answer" : "response"} posted to tuicr and recorded in ${artifact}${awaitUserDeletion ? "; delete the source comment in tuicr to resolve it" : ""}.`, { artifact, question, awaitUserDeletion, session: tuicrSession });
+        }
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR for this reply.");
-        const resolve = params.question ? false : params.resolve ?? false;
-        await createRemoteReviewBackend(review.vcs, review.pr.number).reply({
+        const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
+        const remoteThreads = await remote.listThreads();
+        const known = remoteThreads.find((thread) => thread.id === params.threadId);
+        const question = known?.question === true || params.question === true || !known && params.question === undefined;
+        const resolve = reviewResponseResolution(question, params.resolve);
+        await remote.reply({
           threadId: params.threadId,
-          body: withRemoteProvenance(params.body, modelRoute(ctx)),
+          body: withRemoteProvenance(params.body, model),
           resolve,
-          question: params.question
+          question
         });
         return result3(`Replied to ${params.threadId}${resolve ? " and resolved it" : " and left it open"}.`, {
           pr: review.pr,
@@ -8885,52 +9644,66 @@ ${openMessage}`, {
     defineTool6({
       name: "review_publish",
       label: "review publish",
-      description: "Publish pending remote review comments and status.",
+      description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
       promptSnippet: "Call review_publish to make remote review work public",
-      promptGuidelines: ["Local reviews use revision dumps and are never published remotely."],
+      promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
       parameters: parameters2(publishSchema),
       executionMode: "sequential",
-      async execute(_id, input) {
+      async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = publishSchema.parse(input);
-        if (params.local)
-          return result3("Local reviews use immutable revision dumps and have no publish step.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR to publish.");
-        return publishResolvedReview(review, params);
+        return publishResolvedReview(review, params, modelRoute(ctx));
       }
     }),
     defineTool6({
       name: "review_complete",
       label: "review complete",
-      description: "Approve, reject, or abandon a remote review.",
-      promptSnippet: "Call review_complete to finish a remote review without merging it.",
-      promptGuidelines: ["Use review_dump to finish a local review revision."],
+      description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
+      promptSnippet: "Call review_complete to finish a review without merging it.",
+      promptGuidelines: ["A local completion archives the Diffpi artifact and deletes the matching tuicr session."],
       parameters: parameters2(completeSchema),
       executionMode: "sequential",
-      async execute(_id, input) {
+      async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = completeSchema.parse(input);
-        if (params.local)
-          return result3("Use review_dump to finish a local review revision.");
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (params.local) {
+          const session = await resolveTuicrSession(review, true);
+          if (!session)
+            return result3("No matching local tuicr session to close.");
+          const artifact = await localThreadArtifactPath(review.cwd, session.slug);
+          if (!existsSync2(artifact))
+            return result3("No local review artifact. Run review_comments with local=true first.");
+          const archived = await uniqueRecordPath(await completedReviewsDir(review.cwd), reviewSlug(session.slug));
+          await rename4(artifact, archived);
+          await unlink2(session.path);
+          return result3(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
+            artifact: archived,
+            session
+          });
+        }
         if (!review.pr || !review.forge)
           return result3("No remote PR/MR to complete.");
         if (!params.action)
           return result3("Choose a complete action: approve, reject, or abandon.");
         const status = { approve: "APPROVE", reject: "REQUEST_CHANGES", abandon: "CLOSE" }[params.action];
-        return publishResolvedReview(review, { ...params, status });
+        return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
       }
     }),
     defineTool6({
       name: "review_merge",
       label: "review merge",
-      description: "Squash-merge an open, ready GitHub PR after checking its conventional subject.",
-      promptSnippet: "Call review_merge after confirming the PR is open, ready, and CI is settled; approval is optional",
-      promptGuidelines: ["This is intentionally GitHub-only until GitLab merge support is added."],
-      parameters: parameters2(contextSchema.extend({ subject: z9.string().optional() })),
+      description: "Squash-merge an open, ready GitHub PR through gh after checking its conventional subject.",
+      promptSnippet: "Call review_merge directly; it uses gh to confirm the PR is open, ready, and CI is settled before merging",
+      promptGuidelines: [
+        "Do not query GitHub through MCP or duplicate readiness checks before calling review_merge.",
+        "This is intentionally GitHub-only until GitLab merge support is added."
+      ],
+      parameters: parameters2(contextSchema.extend({ subject: z11.string().optional() })),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = contextSchema.extend({ subject: z9.string().optional() }).parse(input);
+        const params = contextSchema.extend({ subject: z11.string().optional() }).parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (review.vcs.provider !== "github" || !review.forge)
           return result3("review_merge currently supports GitHub only.");
@@ -8963,8 +9736,32 @@ ${openMessage}`, {
     })
   ];
 }
+async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
+  let previous = [];
+  try {
+    previous = parseThreadArtifact(await readFile12(path, "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const previousById = new Map(previous.map((thread) => [thread.id, thread]));
+  const currentIds = new Set(threads.map((thread) => thread.id));
+  const current = threads.map((thread) => {
+    const existing = previousById.get(thread.id);
+    return {
+      ...thread,
+      resolved: false,
+      addressed: existing?.addressed ?? Boolean(existing?.reply),
+      reply: existing?.reply
+    };
+  });
+  const removed = previous.filter((thread) => !currentIds.has(thread.id)).map((thread) => ({ ...thread, resolved: true }));
+  const merged = [...current, ...removed];
+  await writeFile7(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
+  return merged;
+}
 function parameters2(schema) {
-  return z9.toJSONSchema(schema, { io: "input" });
+  return z11.toJSONSchema(schema, { io: "input" });
 }
 function resolveWorkingDirectory(params) {
   return params.cwd ?? process.cwd();
@@ -8975,22 +9772,216 @@ function result3(text, details = {}) {
 function unsupportedForgeMessage() {
   return "No supported GitHub or GitLab remote was detected. Use local=true for an offline tuicr review.";
 }
+async function collectReviewStatus(review) {
+  const [porcelain, branch, localSession, remoteSession] = await Promise.all([
+    runChecked("git", ["-C", review.cwd, "status", "--porcelain"]),
+    runChecked("git", ["-C", review.cwd, "branch", "--show-current"]),
+    resolveTuicrSession(review, true).catch(() => {
+      return;
+    }),
+    resolveTuicrSession(review, false).catch(() => {
+      return;
+    })
+  ]);
+  const entries = porcelain.stdout.split("\\n").filter(Boolean);
+  const staged = entries.filter((line) => !line.startsWith("??") && line[0] !== " ").length;
+  const unstaged = entries.filter((line) => !line.startsWith("??") && line[1] !== " ").length;
+  const untracked = entries.filter((line) => line.startsWith("??")).length;
+  const remote = review.pr ? `yes (#${review.pr.number})` : "no";
+  const url = review.pr?.url ?? "none";
+  const text = [
+    `Branch: ${branch.stdout.trim() || review.vcs.branch}`,
+    `Worktree: ${entries.length ? "dirty" : "clean"} (staged=${staged}, unstaged=${unstaged}, untracked=${untracked})`,
+    `Local working-tree tuicr review: ${localSession ? `yes (${localSession.slug}, ${localSession.commentCount} comments)` : "no"}`,
+    `Remote PR/MR: ${remote}`,
+    `Remote URL: ${url}`,
+    `Remote tuicr session: ${remoteSession ? `yes (${remoteSession.slug}, ${remoteSession.commentCount} comments)` : "no"}`
+  ].join("\\n");
+  return {
+    text,
+    details: {
+      branch: branch.stdout.trim(),
+      staged,
+      unstaged,
+      untracked,
+      localSession,
+      remoteSession,
+      pr: review.pr,
+      url
+    }
+  };
+}
 function modelRoute(ctx) {
   if (!ctx.model)
     throw new Error("Cannot record review provenance because Pi did not provide an active model route.");
   return `${ctx.model.provider}/${ctx.model.id}`;
 }
-async function publishResolvedReview(review, params) {
+async function publishResolvedReview(review, params, model) {
   const status = params.status ?? "COMMENT";
   const event = status === "CLOSE" ? "COMMENT" : status;
   assertReviewEventSupported(review.vcs.provider, event);
+  const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
+  const promotion = params.local ? await promoteLocalReview(review, remote, model) : undefined;
   if (status !== "CLOSE" && review.pr.isDraft)
     await review.forge.markReady(review.pr.number);
-  await createRemoteReviewBackend(review.vcs, review.pr.number).publish(event);
+  await remote.publish(event);
+  if (promotion) {
+    promotion.publication.state.bodies = [
+      ...new Set([...promotion.publication.state.bodies, ...promotion.bodyFingerprints])
+    ];
+    promotion.publication.state.comments = [
+      ...new Set([...promotion.publication.state.comments, ...promotion.commentFingerprints])
+    ];
+    const published = new Set(promotion.commentFingerprints);
+    promotion.publication.state.stagedComments = promotion.publication.state.stagedComments.filter((fingerprint) => !published.has(fingerprint));
+    await saveReviewPublicationState(promotion.publication.path, promotion.publication.state);
+  }
   if (status === "CLOSE")
     await review.forge.closePr(review.pr.number);
   const finalPr = await review.forge.viewPr(String(review.pr.number));
-  return result3(`Published #${review.pr.number} (${status}).`, { pr: finalPr ?? review.pr, status });
+  const promotedBodies = promotion?.promotedBodies ?? 0;
+  const promotedComments = promotion?.promotedComments ?? 0;
+  const promotedReplies = promotion?.promotedReplies ?? 0;
+  return result3(`Published #${review.pr.number} (${status}); promoted ${promotedBodies} review bodies, ${promotedComments} comments, and ${promotedReplies} replies.`, { pr: finalPr ?? review.pr, status, promotedBodies, promotedComments, promotedReplies });
+}
+async function promoteLocalReview(review, remote, model) {
+  const publication = await loadReviewPublicationState(review.cwd, review.vcs, review.pr.number);
+  const session = await resolvePublishSession(review.cwd, {
+    branch: review.vcs.branch,
+    owner: review.vcs.provider === "none" ? undefined : review.vcs.owner,
+    repo: review.vcs.provider === "none" ? undefined : review.vcs.repo,
+    number: review.pr?.number
+  });
+  if (!session)
+    throw new Error("No matching tuicr session to publish.");
+  const sessionIsWorkingTree = session.kind === "local";
+  const local = createLocalReviewBackend({
+    session: session.path,
+    artifactPath: "",
+    author: localReviewAuthor(model)
+  });
+  const draft = await local.readDraft();
+  const remoteDraft = await remote.readDraft();
+  const knownRootComments = new Set([
+    ...publication.state.comments,
+    ...publication.state.stagedComments,
+    ...remoteDraft.comments.map(reviewCommentFingerprint)
+  ]);
+  const { checkpointed, candidates } = partitionReviewComments(draft.comments, knownRootComments, model);
+  const remoteThreads = await remote.listThreads();
+  const threadReplies = sessionIsWorkingTree ? [] : candidates.flatMap(({ source: comment }) => {
+    const thread = resolveReviewThread(comment, remoteThreads);
+    return thread ? [{ comment, thread }] : [];
+  });
+  const unmatchedActions = sessionIsWorkingTree ? [] : candidates.map(({ source }) => source).filter((comment) => parseReviewThreadAction(comment.body).action && !threadReplies.some((reply) => reply.comment === comment));
+  if (unmatchedActions.length > 0) {
+    const locations = unmatchedActions.map(({ file, line }) => `${file}:${line ?? "?"}`).join(", ");
+    throw new Error(`Cannot apply review thread action: no matching remote thread at ${locations}.`);
+  }
+  const comments = candidates.filter(({ source }) => !threadReplies.some((reply) => reply.comment === source)).map(({ published }) => published);
+  const body = draft.body.trim();
+  const bodyFingerprints = body ? [reviewBodyFingerprint(body)] : [];
+  const commentFingerprints = [
+    ...checkpointed.map(({ fingerprint }) => fingerprint),
+    ...comments.map(reviewCommentFingerprint)
+  ];
+  const knownBodies = new Set(publication.state.bodies);
+  if (remoteDraft.body.trim())
+    knownBodies.add(reviewBodyFingerprint(remoteDraft.body));
+  const unpublishedBody = body && !knownBodies.has(reviewBodyFingerprint(body)) ? body : "";
+  const unpublished = unpublishedReviewComments(comments, knownRootComments);
+  if (unpublishedBody)
+    await remote.stage({ comments: [], body: unpublishedBody });
+  let promotedComments = 0;
+  for (const comment of unpublished) {
+    await remote.stage({ comments: [comment], body: "" });
+    publication.state.stagedComments.push(reviewCommentFingerprint(comment));
+    await saveReviewPublicationState(publication.path, publication.state);
+    promotedComments += 1;
+  }
+  const promotedReplies = await promoteLocalReplies(review, remote, publication, model, sessionIsWorkingTree) + await promoteLocationReplies(remote, publication, threadReplies, model);
+  return {
+    publication,
+    bodyFingerprints,
+    commentFingerprints,
+    promotedBodies: unpublishedBody ? 1 : 0,
+    promotedComments,
+    promotedReplies
+  };
+}
+async function promoteLocationReplies(remote, publication, replies, model) {
+  let count = 0;
+  for (const { comment, thread } of replies) {
+    const parsed = parseReviewThreadAction(comment.body);
+    const body = parsed.body.trim();
+    const action = parsed.action;
+    const fingerprint = reviewReplyFingerprint(thread.id, `${action ?? "reply"}\x00${body}`);
+    if (publication.state.replies.includes(fingerprint))
+      continue;
+    if (action === "delete") {
+      if (!remote.deleteThread)
+        throw new Error(`The review backend cannot delete thread ${thread.id}.`);
+      await remote.deleteThread(thread.id);
+      publication.state.replies.push(fingerprint);
+      await saveReviewPublicationState(publication.path, publication.state);
+      count += 1;
+      continue;
+    }
+    const remoteBody = withCommentProvenance({ ...comment, body }, model);
+    if (body && !thread.replies?.some((reply) => reply === body || reply === remoteBody)) {
+      await remote.reply({
+        threadId: thread.id,
+        body: remoteBody,
+        resolve: false
+      });
+    }
+    if (action && remote.setResolved)
+      await remote.setResolved(thread.id, action === "resolve");
+    publication.state.replies.push(fingerprint);
+    await saveReviewPublicationState(publication.path, publication.state);
+    count += 1;
+  }
+  return count;
+}
+async function promoteLocalReplies(review, remote, publication, model, workingTree) {
+  const target = workingTree ? "uncommitted" : await reviewTargetId(review);
+  const artifact = workingTree ? await latestThreadArtifact(review.cwd, review, target) : publication.state.overlayPath ?? await latestThreadArtifact(review.cwd, review, target);
+  if (!artifact)
+    return 0;
+  if (!workingTree)
+    publication.state.overlayPath = artifact;
+  let count = 0;
+  for (const thread of await readThreadArtifact(artifact)) {
+    if (!thread.reply)
+      continue;
+    const body = withRemoteProvenance(thread.reply, model);
+    const fingerprint = reviewReplyFingerprint(thread.id, body);
+    if (publication.state.replies.includes(fingerprint))
+      continue;
+    if (workingTree) {
+      const draft = workingTreeReplyDraft(thread, body);
+      const comment = draft.comments[0];
+      if (comment) {
+        const commentFingerprint = reviewCommentFingerprint(comment);
+        if (!publication.state.stagedComments.includes(commentFingerprint)) {
+          await remote.stage(draft);
+          publication.state.stagedComments.push(commentFingerprint);
+        }
+      } else {
+        const bodyFingerprint = reviewBodyFingerprint(draft.body);
+        if (!publication.state.bodies.includes(bodyFingerprint)) {
+          await remote.stage(draft);
+          publication.state.bodies.push(bodyFingerprint);
+        }
+      }
+    } else {
+      await remote.reply({ threadId: thread.id, body, resolve: false, question: thread.question });
+    }
+    publication.state.replies.push(fingerprint);
+    await saveReviewPublicationState(publication.path, publication.state);
+    count += 1;
+  }
+  return count;
 }
 async function resolveReviewContext(cwd, target) {
   const vcs = await detectVcs(cwd);
@@ -9031,6 +10022,10 @@ async function assertRemoteBranchReady(cwd) {
   if (head.stdout.trim() !== pushed.stdout.trim())
     throw new Error("Push the current branch before opening a remote review.");
 }
+function withCommentProvenance(comment, fallbackModel) {
+  const route = comment.author?.match(/^Agent:\s*(.+)$/)?.[1];
+  return route ? withRemoteProvenance(comment.body, route || fallbackModel) : comment.body;
+}
 async function reviewTargetId(review) {
   if (!review.pr)
     return "uncommitted";
@@ -9047,41 +10042,103 @@ async function headSha(cwd) {
 }
 async function newReviewArtifactPath(cwd, target) {
   const dir = await reviewsDir(cwd);
-  await mkdir8(dir, { recursive: true });
+  await mkdir7(dir, { recursive: true });
   return uniqueRecordPath(dir, reviewRecordName(target));
 }
+async function localThreadArtifactPath(cwd, sessionSlug) {
+  const dir = await reviewsDir(cwd);
+  return join17(dir, `${reviewSlug(sessionSlug) || "local-review"}.md`);
+}
+async function readThreadArtifact(path) {
+  try {
+    return parseThreadArtifact(await readFile12(path, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Expected local reply overlay is missing: ${path}`);
+    }
+    throw error;
+  }
+}
+async function latestThreadArtifact(cwd, review, target) {
+  try {
+    return await findLatestThreadArtifact(cwd, review, target);
+  } catch (error) {
+    throw new Error(`Cannot locate the latest review thread artifact for ${target}.`, { cause: error });
+  }
+}
+async function findLatestThreadArtifact(cwd, review, target) {
+  const dir = await reviewsDir(cwd);
+  const suffix = reviewSlug(target) || "uncommitted";
+  const names = await listReviewArtifactNames(dir);
+  const candidates = await Promise.all(names.flatMap((name) => {
+    if (!name.endsWith(".md"))
+      return [];
+    return [
+      (async () => {
+        const path = join17(dir, name);
+        const info = await stat(path);
+        return { path, name, content: await readFile12(path, "utf8"), modified: info.mtimeMs };
+      })()
+    ];
+  }));
+  return candidates.filter(({ name, content }) => {
+    if (!content.startsWith("<!-- diffpi-threads:"))
+      return false;
+    if (review.pr && target !== "local" && target !== "uncommitted")
+      return content.includes(`- PR/MR: #${review.pr.number}`);
+    return artifactNameMatches(name, suffix);
+  }).sort((a, b) => b.modified - a.modified)[0]?.path;
+}
+async function listReviewArtifactNames(dir) {
+  try {
+    return await readdir3(dir);
+  } catch (error) {
+    throw new Error(`Cannot read review artifacts in ${dir}.`, { cause: error });
+  }
+}
 function deriveTitle(branch) {
   return branch.replace(/^(feature|feat|fix|bug|chore)\//, "").replace(/^eng-\d+-/i, "").replace(/[-_]+/g, " ").replace(/^\w/, (char) => char.toUpperCase());
 }
 function uniqueRecordPath(dir, base) {
-  let path = join16(dir, `${base}.md`);
+  let path = join17(dir, `${base}.md`);
   let count = 2;
   while (existsSync2(path))
-    path = join16(dir, `${base}-${count++}.md`);
+    path = join17(dir, `${base}-${count++}.md`);
   return path;
 }
+function artifactNameMatches(name, suffix) {
+  if (!name.endsWith(".md"))
+    return false;
+  const stem = name.slice(0, -3);
+  const marker = `-${suffix}`;
+  const markerIndex = stem.lastIndexOf(marker);
+  if (markerIndex < 0)
+    return false;
+  const tail = stem.slice(markerIndex + marker.length);
+  return tail === "" || /^-\d+$/.test(tail);
+}
 
 // src/tools/setup.ts
 import { defineTool as defineTool7 } from "@earendil-works/pi-coding-agent";
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir4, readFile as readFile12 } from "node:fs/promises";
+import { readdir as readdir5, readFile as readFile15 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
-import { basename as basename6, join as join20 } from "node:path";
+import { basename as basename6, join as join21 } from "node:path";
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 import { homedir as homedir5 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 
 // src/fsx.ts
-import { readdir as readdir3, readFile as readFile10 } from "node:fs/promises";
+import { readdir as readdir4, readFile as readFile13 } from "node:fs/promises";
 async function readTextIfExists(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile13(path, "utf8");
   } catch (error) {
     if (isMissingPath(error))
       return;
@@ -9094,17 +10151,17 @@ function isMissingPath(error) {
 
 // src/config.ts
 var modelReferenceSchema = zx.text;
-var agentConfigSchema = z10.object({
-  models: z10.array(modelReferenceSchema).optional()
+var agentConfigSchema = z12.object({
+  models: z12.array(modelReferenceSchema).optional()
 }).strict();
-var diffpiConfigSchema = z10.object({
-  agents: z10.record(z10.string(), agentConfigSchema).optional()
+var diffpiConfigSchema = z12.object({
+  agents: z12.record(z12.string(), agentConfigSchema).optional()
 }).strict();
 function diffpiConfigPaths(homeDir = homedir5()) {
-  const directory = join17(homeDir, ".difflab", "diffpi");
+  const directory = join18(homeDir, ".difflab", "diffpi");
   return {
-    yaml: join17(directory, "config.yaml"),
-    json: join17(directory, "config.json")
+    yaml: join18(directory, "config.yaml"),
+    json: join18(directory, "config.json")
   };
 }
 async function loadDiffpiConfig(options = {}) {
@@ -9160,12 +10217,12 @@ function normalizeModelReference(value) {
 }
 
 // src/mcp.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile14, writeFile as writeFile8 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname8, join as join18 } from "node:path";
+import { dirname as dirname8, join as join19 } from "node:path";
 var mcp = {
   globalConfigPath(homeDir = homedir6()) {
-    return join18(homeDir, ".config", "mcp", "mcp.json");
+    return join19(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -9178,8 +10235,8 @@ var mcp = {
     const next = { ...current, mcpServers: nextServers };
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
-      await mkdir9(dirname8(path), { recursive: true });
-      await writeFile7(path, `${JSON.stringify(next, null, 2)}
+      await mkdir8(dirname8(path), { recursive: true });
+      await writeFile8(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -9208,7 +10265,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile14(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -9220,9 +10277,9 @@ function isRecord(value) {
 }
 
 // src/pi.ts
-import { mkdir as mkdir10, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir9, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { dirname as dirname9, join as join20 } from "node:path";
 var pi = {
   executableCheck: findPiExecutable,
   packageList: listPiPackages,
@@ -9235,19 +10292,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join19(agentDir, "agents", filename);
+  const path = join20(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
-    await mkdir10(dirname9(path), { recursive: true });
-    await writeFile8(path, content, "utf8");
+    await mkdir9(dirname9(path), { recursive: true });
+    await writeFile9(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join19(homedir7(), ".agents", "skills")) {
-  const roots = [join19(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join20(homedir7(), ".agents", "skills")) {
+  const roots = [join20(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join19(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join20(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -9276,8 +10333,8 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const next = update(current);
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
-    await mkdir10(dirname9(path), { recursive: true });
-    await writeFile8(path, `${JSON.stringify(next, null, 2)}
+    await mkdir9(dirname9(path), { recursive: true });
+    await writeFile9(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -9297,7 +10354,7 @@ async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
 function resolvePiAgentDir(homeDir = homedir7()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join19(process.env.XDG_CONFIG_HOME, "pi") : join19(homeDir, ".pi", "agent"));
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join20(process.env.XDG_CONFIG_HOME, "pi") : join20(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -9349,7 +10406,7 @@ var FORGE_DEPENDENCIES = {
 };
 async function ensureMise(options = {}) {
   const homeDir = options.homeDir ?? homedir8();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join20(homeDir, ".local", "bin", "mise"));
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join21(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -9398,9 +10455,9 @@ async function ensureMiseDeps(miseExecutable, options = {}) {
 async function ensurePiPlugins(options = {}) {
   const actions = await ensurePiPackages(PI_PACKAGES, options);
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const webSearch = await pi.configEnsure(join20(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join21(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join20(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join21(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -9411,11 +10468,11 @@ async function ensurePiAgents(options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
   const bundledAgentsDir = options.bundledAgentsDir ?? BUNDLED_AGENTS_DIR;
   const userConfig = await loadDiffpiConfig({ homeDir: options.homeDir });
-  const entries = (await readdir4(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
+  const entries = (await readdir5(bundledAgentsDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
   const actions = [];
   for (const entry of entries) {
     const id = basename6(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile12(join20(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile15(join21(bundledAgentsDir, entry.name), "utf8");
     const content = materializeAgentModels(source, id, userConfig.config, options.availableModels);
     const result = await pi.agentEnsure(entry.name, content, agentDir, options.dryRun);
     actions.push(getConfigSetupAction(`pi agent ${id}`, result));
@@ -9424,7 +10481,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join20(options.homeDir ?? homedir8(), ".agents", "skills");
+  const sharedSkillsDir = join21(options.homeDir ?? homedir8(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -9620,7 +10677,7 @@ function reportProgress(options, message) {
   options.onProgress?.(message);
 }
 async function packageVersion2() {
-  const source = await readFile12(join20(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
+  const source = await readFile15(join21(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
   let value;
   try {
     value = JSON.parse(source);
@@ -9636,13 +10693,13 @@ function getRecord(value) {
 }
 
 // src/tools/setup.ts
-var setupParametersSchema = z11.object({
-  issueTracker: z11.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
-  forges: z11.array(z11.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
-  forge: z11.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
-  bindZedKey: z11.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
+var setupParametersSchema = z13.object({
+  issueTracker: z13.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
+  forges: z13.array(z13.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
+  forge: z13.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
+  bindZedKey: z13.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
 });
-var setupParameters = z11.toJSONSchema(setupParametersSchema, { io: "input" });
+var setupParameters = z13.toJSONSchema(setupParametersSchema, { io: "input" });
 var diffpiSetupTool = defineTool7({
   name: "diffpi_setup",
   label: "diffpi setup",
@@ -9715,11 +10772,11 @@ ${lines.join(`
 
 // src/tools/templates.ts
 import { defineTool as defineTool8 } from "@earendil-works/pi-coding-agent";
-import { z as z12 } from "zod";
-var templateSchema = z12.object({
-  name: z12.string().min(1),
-  variables: z12.record(z12.string(), z12.string()).optional(),
-  homeDir: z12.string().optional()
+import { z as z14 } from "zod";
+var templateSchema = z14.object({
+  name: z14.string().min(1),
+  variables: z14.record(z14.string(), z14.string()).optional(),
+  homeDir: z14.string().optional()
 });
 var diffpiTemplateTool = defineTool8({
   name: "diffpi_template",
@@ -9727,7 +10784,7 @@ var diffpiTemplateTool = defineTool8({
   description: "Load a bundled Diffpi template or a user override and render named variables.",
   promptSnippet: "Use diffpi_template for package workflow templates",
   promptGuidelines: ["User overrides live under ~/.difflab/diffpi/templates."],
-  parameters: z12.toJSONSchema(templateSchema, { io: "input" }),
+  parameters: z14.toJSONSchema(templateSchema, { io: "input" }),
   executionMode: "parallel",
   async execute(_id, input) {
     const params = templateSchema.parse(input);