@difflab/pi 0.8.0 → 0.9.0

package/dist/tools/index.js

@@ -3,30 +3,13 @@ import { defineTool } from "@earendil-works/pi-coding-agent";
 import { z as z2 } from "zod";
 
 // src/environment.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { basename, join as join4 } from "node:path";
-
-// src/assets.ts
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
-  const moduleDir = dirname(fileURLToPath(moduleUrl));
-  const candidates = [join(moduleDir, name), join(moduleDir, "..", name), join(moduleDir, "..", "..", name)];
-  return candidates.find((path) => existsSync(path)) ?? candidates[1];
-}
-function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
-  return resolveBundledAssetDir("agents", moduleUrl);
-}
-function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
-  return resolveBundledAssetDir("templates", moduleUrl);
-}
+import { basename } from "node:path";
 
 // src/extensions/processx.ts
 import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access } from "node:fs/promises";
-import { delimiter, join as join2 } from "node:path";
+import { delimiter, join } from "node:path";
 async function findExecutable(name) {
   if (name.includes("/")) {
     try {
@@ -39,7 +22,7 @@ async function findExecutable(name) {
   for (const directory of (process.env.PATH ?? "").split(delimiter)) {
     if (!directory)
       continue;
-    const candidate = join2(directory, name);
+    const candidate = join(directory, name);
     try {
       await access(candidate, constants.X_OK);
       return candidate;
@@ -103,174 +86,6 @@ function appendBounded(current, next) {
   return combined.length <= MAX_CAPTURED_OUTPUT_LENGTH ? combined : combined.slice(-MAX_CAPTURED_OUTPUT_LENGTH);
 }
 
-// src/extensions/zedx.ts
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
-var ZED_LOCAL_REVIEW_TASK_NAME = "diffpi: tuicr local review";
-var ZED_PR_REVIEW_TASK_NAME = "diffpi: tuicr PR review";
-var ZED_PLAN_ANNOTATE_TASK_NAME = "diffpi: annotate plan";
-var LEGACY_ZED_REVIEW_TASK_NAME = "diffpi: tuicr review";
-var REVIEW_KEYBINDING = "cmd-alt-r";
-function zedTasksPath(homeDir = homedir()) {
-  return join3(homeDir, ".config", "zed", "tasks.json");
-}
-function zedKeymapPath(homeDir = homedir()) {
-  return join3(homeDir, ".config", "zed", "keymap.json");
-}
-async function ensureZedReviewTask(homeDir = homedir(), _command = ["tuicr", "-w", "-r", "main..HEAD"]) {
-  const path = zedTasksPath(homeDir);
-  const currentText = await readOptional(path);
-  const tasks = parseJsonArray(currentText, path);
-  const migrated = tasks.filter((task) => task.label !== LEGACY_ZED_REVIEW_TASK_NAME);
-  const next = [...migrated];
-  for (const task of [localReviewTask(), prReviewTask()]) {
-    const index = next.findIndex((existing) => existing.label === task.label);
-    if (index >= 0)
-      next[index] = { ...next[index], ...task };
-    else
-      next.push(task);
-  }
-  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
-  if (changed)
-    await writeJson(path, next);
-  return { path, changed, existed: currentText !== undefined };
-}
-async function ensureZedPlanTask(packageVersion, homeDir = homedir()) {
-  if (!/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(packageVersion)) {
-    throw new Error(`Invalid @difflab/pi package version: ${packageVersion}.`);
-  }
-  const path = zedTasksPath(homeDir);
-  const currentText = await readOptional(path);
-  const tasks = parseJsonArray(currentText, path);
-  const task = {
-    label: ZED_PLAN_ANNOTATE_TASK_NAME,
-    command: "npx",
-    args: ["--yes", `@difflab/pi@${packageVersion}`, "plan", "annotate", "$ZED_FILE", "--cwd", "$ZED_WORKTREE_ROOT"],
-    cwd: "$ZED_WORKTREE_ROOT",
-    use_new_terminal: true,
-    reveal: "always",
-    reveal_target: "center"
-  };
-  const next = [...tasks];
-  const index = next.findIndex((candidate) => candidate.label === task.label);
-  if (index >= 0)
-    next[index] = { ...next[index], ...task };
-  else
-    next.push(task);
-  const changed = JSON.stringify(tasks) !== JSON.stringify(next);
-  if (changed)
-    await writeJson(path, next);
-  return { path, changed, existed: currentText !== undefined };
-}
-async function ensureZedReviewKeybinding(homeDir = homedir()) {
-  const path = zedKeymapPath(homeDir);
-  const currentText = await readOptional(path);
-  const entries = parseJsonArray(currentText, path);
-  const migrated = entries.map(migrateReviewKeymapEntry);
-  const alreadyBound = migrated.some((entry) => Object.values(entry.bindings ?? {}).some((action) => Array.isArray(action) && action[0] === "task::Spawn" && bindsReviewTask(action[1])));
-  const next = alreadyBound ? migrated : [
-    ...migrated,
-    {
-      context: "Workspace",
-      bindings: { [REVIEW_KEYBINDING]: ["task::Spawn", { task_name: ZED_LOCAL_REVIEW_TASK_NAME }] }
-    }
-  ];
-  const changed = JSON.stringify(entries) !== JSON.stringify(next);
-  if (changed)
-    await writeJson(path, next);
-  return { path, changed, existed: currentText !== undefined };
-}
-function zedReviewTaskName(command) {
-  if (command.some((value, index) => value === "plan" && command[index + 1] === "annotate")) {
-    return ZED_PLAN_ANNOTATE_TASK_NAME;
-  }
-  return command[0] === "tuicr" && command[1] === "pr" ? ZED_PR_REVIEW_TASK_NAME : ZED_LOCAL_REVIEW_TASK_NAME;
-}
-var LOCAL_REVIEW_SCRIPT = `set -eu
-remote=$(git remote get-url origin 2>/dev/null || true)
-branch=$(git branch --show-current)
-base=
-case "$remote" in
-  *github.com*)
-    base=$(gh pr list --head "$branch" --state open --limit 100 --json baseRefName,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].baseRefName // empty' 2>/dev/null || true)
-    [ -n "$base" ] || base=$(gh repo view --json defaultBranchRef --jq .defaultBranchRef.name 2>/dev/null || true)
-    ;;
-  *gitlab*)
-    mr=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null || true)
-    base=$(printf '%s' "$mr" | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(a[0]?.target_branch||"")}catch{}})')
-    [ -n "$base" ] || base=$(glab repo view --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{process.stdout.write(JSON.parse(s).default_branch||"")}catch{}})' || true)
-    ;;
-esac
-[ -n "$base" ] || { echo 'diffpi: could not resolve a GitHub/GitLab review base' >&2; exit 1; }
-exec tuicr -w -r "$base..HEAD"`;
-var PR_REVIEW_SCRIPT = `set -eu
-remote=$(git remote get-url origin 2>/dev/null || true)
-branch=$(git branch --show-current)
-case "$remote" in
-  *github.com*) number=$(gh pr list --head "$branch" --state open --limit 100 --json number,createdAt --jq 'sort_by(.createdAt) | reverse | .[0].number // empty' 2>/dev/null || true) ;;
-  *gitlab*) number=$(glab mr list --source-branch "$branch" --order created_at --sort desc --per-page 100 --output json 2>/dev/null | node -e 'let s=""; process.stdin.on("data",d=>s+=d).on("end",()=>{try{let a=JSON.parse(s);process.stdout.write(String(a[0]?.iid||a[0]?.number||""))}catch{}})' || true) ;;
-  *) number= ;;
-esac
-[ -n "$number" ] || { echo 'diffpi: could not resolve the current GitHub PR or GitLab MR' >&2; exit 1; }
-exec tuicr pr "$number"`;
-function staticReviewTask(label, script) {
-  return {
-    label,
-    command: "sh",
-    args: ["-lc", script],
-    cwd: "$ZED_WORKTREE_ROOT",
-    use_new_terminal: true,
-    reveal: "always",
-    reveal_target: "center"
-  };
-}
-function localReviewTask() {
-  return staticReviewTask(ZED_LOCAL_REVIEW_TASK_NAME, LOCAL_REVIEW_SCRIPT);
-}
-function prReviewTask() {
-  return staticReviewTask(ZED_PR_REVIEW_TASK_NAME, PR_REVIEW_SCRIPT);
-}
-function bindsReviewTask(payload) {
-  return typeof payload === "object" && payload !== null && payload.task_name === ZED_LOCAL_REVIEW_TASK_NAME;
-}
-function migrateReviewKeymapEntry(entry) {
-  const bindings = Object.fromEntries(Object.entries(entry.bindings ?? {}).map(([key, action]) => {
-    if (Array.isArray(action) && action[0] === "task::Spawn" && typeof action[1] === "object" && action[1] !== null && action[1].task_name === LEGACY_ZED_REVIEW_TASK_NAME) {
-      return [key, ["task::Spawn", { ...action[1], task_name: ZED_LOCAL_REVIEW_TASK_NAME }]];
-    }
-    return [key, action];
-  }));
-  return entry.bindings ? { ...entry, bindings } : entry;
-}
-async function readOptional(path) {
-  try {
-    return await readFile(path, "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-function parseJsonArray(content, path) {
-  if (!content?.trim())
-    return [];
-  let value;
-  try {
-    value = JSON.parse(content);
-  } catch {
-    throw new Error(`Cannot safely edit ${path}: not strict JSON (it may contain JSONC comments).`);
-  }
-  if (!Array.isArray(value))
-    throw new Error(`Expected a JSON array in ${path}.`);
-  return value;
-}
-async function writeJson(path, value) {
-  await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-
 // src/environment.ts
 function detectIde(env = process.env) {
   const program = (env.TERM_PROGRAM ?? "").toLowerCase();
@@ -322,73 +137,6 @@ function parseRemote(remote) {
   const provider = /github/i.test(host) ? "github" : /gitlab/i.test(host) ? "gitlab" : "none";
   return { provider, host, owner, repo };
 }
-function diffpiLaunchName(cwd, workflow) {
-  return `diffpi: ${basename(cwd)} / ${workflow}`;
-}
-async function openInNewTab(command, opts) {
-  const env = opts.env ?? process.env;
-  const name = opts.name ?? "review";
-  const printable = command.join(" ");
-  const mux = detectMux(env);
-  if (mux !== "none") {
-    const opened = await openMuxTab(mux, command, opts.cwd, name, printable);
-    if (opened)
-      return opened;
-  }
-  if (detectIde(env) === "zed") {
-    try {
-      const taskName = zedReviewTaskName(command);
-      if (taskName === ZED_PLAN_ANNOTATE_TASK_NAME)
-        await ensureZedPlanTask(await packageVersion(), opts.homeDir);
-      else
-        await ensureZedReviewTask(opts.homeDir, command);
-      return {
-        launched: false,
-        configured: true,
-        via: "zed-task",
-        command: printable,
-        taskName,
-        instruction: `Run the Zed task "${taskName}".`
-      };
-    } catch {}
-  }
-  return { launched: false, via: "print", command: printable };
-}
-function screenWindowArgs(command, cwd, name) {
-  return ["-X", "screen", "-t", name, "sh", "-lc", 'cd -- "$1" && shift && exec "$@"', "sh", cwd, ...command];
-}
-async function packageVersion() {
-  let value;
-  try {
-    value = JSON.parse(await readFile2(join4(resolveBundledAgentsDir(), "..", "package.json"), "utf8"));
-  } catch (error) {
-    throw new Error("Cannot parse the installed @difflab/pi package metadata.", { cause: error });
-  }
-  if (typeof value.version !== "string")
-    throw new Error("Cannot resolve the installed @difflab/pi version.");
-  return value.version;
-}
-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)
-      return { launched: true, via: "zellij", command: printable };
-    const fallback = await run("zellij", ["run", "--cwd", cwd, "--name", name, "--", ...command]);
-    if (fallback.code === 0)
-      return { launched: true, via: "zellij-run", command: printable };
-  }
-  if (mux === "tmux" && await findExecutable("tmux")) {
-    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 };
-  }
-  if (mux === "screen" && await findExecutable("screen")) {
-    const result = await run("screen", screenWindowArgs(command, cwd, name));
-    if (result.code === 0)
-      return { launched: true, via: "screen", command: printable };
-  }
-  return;
-}
 
 // src/extensions/zodx.ts
 import { z } from "zod";
@@ -757,33 +505,21 @@ function result(text, status, detail = text) {
 
 // src/tools/log.ts
 import { defineTool as defineTool2 } from "@earendil-works/pi-coding-agent";
-import { join as join7 } from "node:path";
 import { z as z3 } from "zod";
 
 // src/log.ts
-import { randomUUID } from "node:crypto";
-import { appendFile, readFile as readFile3 } from "node:fs/promises";
-async function appendLogEntry(logPath, event) {
-  const entry = {
-    ...event,
-    version: 1,
-    eventId: event.eventId ?? randomUUID(),
-    timestamp: event.timestamp ?? new Date().toISOString()
-  };
-  await appendFile(logPath, `${JSON.stringify(entry)}
-`, { encoding: "utf8", mode: 384 });
-  return entry;
-}
+import { appendFile, lstat as lstat2, mkdir as mkdir2, readFile, realpath as realpath3 } from "node:fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join4, relative, resolve as resolve3, sep } from "node:path";
 
 // src/store.ts
 import { createHash } from "node:crypto";
-import { lstat, mkdir as mkdir2, readlink, realpath as realpath2, symlink, unlink } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
+import { lstat, mkdir, readlink, realpath as realpath2, symlink, unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute as isAbsolute2, join as join3, resolve as resolve2 } from "node:path";
 
 // src/extensions/gitx.ts
 import { realpath } from "node:fs/promises";
-import { basename as basename2, isAbsolute, join as join5, resolve } from "node:path";
+import { basename as basename2, isAbsolute, join as join2, resolve } from "node:path";
 async function gitToplevel(cwd) {
   const result = await run("git", ["-C", cwd, "rev-parse", "--show-toplevel"]);
   const top = result.stdout.trim();
@@ -795,7 +531,7 @@ async function inspectGitRepository(cwd) {
   const remote = remoteResult.code === 0 ? remoteResult.stdout.trim() : "";
   const commonResult = await run("git", ["-C", root, "rev-parse", "--git-common-dir"]);
   const common = commonResult.stdout.trim();
-  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join5(root, common)) : root;
+  const commonPath = commonResult.code === 0 && common ? resolve(isAbsolute(common) ? common : join2(root, common)) : root;
   const commonDir = await canonicalPath(commonPath);
   return {
     root,
@@ -822,17 +558,17 @@ async function canonicalPath(path) {
 
 // src/store.ts
 var STORE_LINK = ".diffpi";
-var LEGACY_STORE_LINK = join6(".pi", "diffpi");
-function storeGlobalRoot(homeDir = homedir2()) {
-  return join6(homeDir, ".difflab", "diffpi", "projects");
+var LEGACY_STORE_LINK = join3(".pi", "diffpi");
+function storeGlobalRoot(homeDir = homedir()) {
+  return join3(homeDir, ".difflab", "diffpi", "projects");
 }
-async function ensureStore(cwd, homeDir = homedir2()) {
+async function ensureStore(cwd, homeDir = homedir()) {
   const repository = await inspectGitRepository(cwd);
   const root = repository.root;
   const slug = projectSlug(repository);
-  const dest = join6(storeGlobalRoot(homeDir), slug);
-  const link = join6(root, STORE_LINK);
-  await mkdir2(dest, { recursive: true });
+  const dest = join3(storeGlobalRoot(homeDir), slug);
+  const link = join3(root, STORE_LINK);
+  await mkdir(dest, { recursive: true });
   try {
     await assertStoreLink(link, dest);
   } catch (error) {
@@ -840,32 +576,12 @@ async function ensureStore(cwd, homeDir = homedir2()) {
       throw error;
     await symlink(dest, link);
   }
-  await removeLegacyStoreLink(join6(root, LEGACY_STORE_LINK), dest);
+  await removeLegacyStoreLink(join3(root, LEGACY_STORE_LINK), dest);
   return { slug, root, dest, link, linked: true };
 }
-async function logsDir(cwd, homeDir = homedir2()) {
+async function storeDir(cwd, homeDir = homedir()) {
   const store = await ensureStore(cwd, homeDir);
-  const dir = join6(store.link, "logs");
-  await mkdir2(dir, { recursive: true });
-  return dir;
-}
-async function reviewsDir(cwd, homeDir = homedir2()) {
-  const store = await ensureStore(cwd, homeDir);
-  const dir = join6(store.link, "review");
-  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;
+  return store.dest;
 }
 async function assertStoreLink(path, dest) {
   const entry = await lstat(path);
@@ -890,7 +606,7 @@ async function removeLegacyStoreLink(path, dest) {
 }
 async function symlinkTarget(path) {
   const target = await readlink(path);
-  return canonicalPath2(isAbsolute2(target) ? target : resolve2(dirname3(path), target));
+  return canonicalPath2(isAbsolute2(target) ? target : resolve2(dirname(path), target));
 }
 async function canonicalPath2(path) {
   try {
@@ -905,41 +621,94 @@ function projectSlug(repository) {
   return `${readable}-${digest}`;
 }
 
+// src/log.ts
+async function appendLogEntry(logPath, entry) {
+  await appendFile(logPath, `${JSON.stringify(entry)}
+`, { encoding: "utf8", mode: 384 });
+  return entry;
+}
+async function appendLog(cwd, filename, message, label) {
+  const entry = label === undefined ? { message } : { message, label };
+  return appendLogEntry(await resolveLogPath(cwd, filename), entry);
+}
+async function resolveLogPath(cwd, filename) {
+  if (!filename || isAbsolute3(filename))
+    throw new Error("Log filename must be a non-empty relative path.");
+  const root = await realpath3(cwd);
+  const lexicalTarget = resolve3(root, filename);
+  assertContained(root, lexicalTarget);
+  let safeRoot = root;
+  let target = lexicalTarget;
+  if (filename.startsWith(`.diffpi${sep}`)) {
+    const insideStore = filename.slice(`.diffpi${sep}`.length);
+    if (insideStore.split(sep).includes(".."))
+      throw new Error("Log filename must stay within cwd.");
+    safeRoot = await realpath3(await storeDir(root));
+    target = resolve3(safeRoot, insideStore);
+    assertContained(safeRoot, target);
+    if (target === safeRoot)
+      throw new Error("Log filename must name a file within the store.");
+  }
+  await ensureSafeParent(safeRoot, dirname2(target));
+  try {
+    const entry = await lstat2(target);
+    if (entry.isSymbolicLink())
+      throw new Error("Log filename must not point through a symlink.");
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  return target;
+}
+async function ensureSafeParent(root, parent) {
+  assertContained(root, parent);
+  let current = root;
+  const suffix = relative(root, parent);
+  if (!suffix)
+    return;
+  for (const part of suffix.split(sep)) {
+    current = join4(current, part);
+    try {
+      await mkdir2(current);
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    const entry = await lstat2(current);
+    if (!entry.isDirectory() || entry.isSymbolicLink())
+      throw new Error("Log filename must not pass through a symlink or non-directory.");
+  }
+}
+function assertContained(root, target) {
+  const targetRelative = relative(root, target);
+  if (targetRelative === ".." || targetRelative.startsWith(`..${sep}`) || isAbsolute3(targetRelative))
+    throw new Error("Log filename must stay within cwd.");
+}
+
 // src/tools/log.ts
 var schema = z3.object({
   cwd: zx.cwd,
-  channel: zx.id,
-  kind: z3.enum(["progress", "issue", "deviation"]),
-  actor: zx.text,
-  message: zx.text,
-  correlation: z3.record(z3.string(), z3.string()).optional(),
-  evidence: z3.array(zx.text).optional(),
-  data: z3.record(z3.string(), z3.unknown()).optional()
+  filename: z3.string().trim().min(1),
+  label: z3.string().trim().min(1).optional(),
+  message: zx.text
 }).strict();
 var diffpiLogTool = defineTool2({
   name: "diffpi_log",
   label: "diffpi log",
-  description: "Append a reusable progress, issue, or deviation event to a project-scoped Diffpi JSONL channel.",
-  promptSnippet: "Use diffpi_log when a skill or workflow needs durable progress, issue, or deviation events.",
+  description: "Append a message to a caller-selected relative project JSONL file.",
+  promptSnippet: "Use diffpi_log to append durable progress messages to the supplied relative JSONL filename.",
   promptGuidelines: [
-    "Use stable channel names shared by one workflow, such as plan, flow, or session.",
-    "Keep plan status and task checkboxes in live PLAN.md files; diffpi_log is a general activity log, not another task system."
+    "For /plan go, use cwd at the canonical Git root and filename .diffpi/plan/<plan-id>/logs.jsonl, directly beside PLAN.md.",
+    "Use label only when a reusable category helps readers filter messages."
   ],
   parameters: z3.toJSONSchema(schema, { io: "input" }),
   executionMode: "sequential",
   async execute(_id, input) {
     const params = schema.parse(input);
-    const entry = await appendLogEntry(join7(await logsDir(params.cwd ?? process.cwd()), `${params.channel}.jsonl`), {
-      kind: params.kind,
-      actor: params.actor,
-      message: params.message,
-      correlation: params.correlation,
-      evidence: params.evidence,
-      data: params.data
-    });
+    const entry = await appendLog(params.cwd ?? process.cwd(), params.filename, params.message, params.label);
     return {
-      content: [{ type: "text", text: `Logged ${entry.eventId} to ${params.channel}.` }],
-      details: { entry, channel: params.channel }
+      content: [{ type: "text", text: `Logged message to ${params.filename}.` }],
+      details: { entry, filename: params.filename }
     };
   }
 });
@@ -950,19 +719,35 @@ import { z as z5 } from "zod";
 
 // src/doctor.ts
 import { createHash as createHash2 } from "node:crypto";
-import { lstat as lstat2, mkdir as mkdir6, readFile as readFile8, readdir as readdir3, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename5, join as join13 } from "node:path";
+import { lstat as lstat3, mkdir as mkdir6, readFile as readFile6, readdir as readdir3, writeFile as writeFile4 } from "node:fs/promises";
+import { basename as basename5, join as join11 } from "node:path";
+
+// src/assets.ts
+import { existsSync } from "node:fs";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+function resolveBundledAssetDir(name, moduleUrl = import.meta.url) {
+  const moduleDir = dirname3(fileURLToPath(moduleUrl));
+  const candidates = [join5(moduleDir, name), join5(moduleDir, "..", name), join5(moduleDir, "..", "..", name)];
+  return candidates.find((path) => existsSync(path)) ?? candidates[1];
+}
+function resolveBundledAgentsDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("agents", moduleUrl);
+}
+function resolveBundledTemplatesDir(moduleUrl = import.meta.url) {
+  return resolveBundledAssetDir("templates", moduleUrl);
+}
 
 // src/pi.ts
-import { mkdir as mkdir3, writeFile as writeFile2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { mkdir as mkdir3, writeFile } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname4, join as join6 } from "node:path";
 
 // src/fsx.ts
-import { readdir, readFile as readFile4 } from "node:fs/promises";
+import { readdir, readFile as readFile2 } from "node:fs/promises";
 async function readTextIfExists(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile2(path, "utf8");
   } catch (error) {
     if (isMissingPath(error))
       return;
@@ -986,19 +771,19 @@ var pi = {
   configEnsure: ensurePiConfig
 };
 async function ensurePiAgent(filename, content, agentDir = resolvePiAgentDir(), dryRun = false) {
-  const path = join8(agentDir, "agents", filename);
+  const path = join6(agentDir, "agents", filename);
   const currentText = await readTextIfExists(path);
   const changed = currentText !== content;
   if (changed && !dryRun) {
     await mkdir3(dirname4(path), { recursive: true });
-    await writeFile2(path, content, "utf8");
+    await writeFile(path, content, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
 }
-async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join8(homedir3(), ".agents", "skills")) {
-  const roots = [join8(agentDir, "skills"), sharedSkillsDir];
+async function checkGlobalPiSkill(name, agentDir = resolvePiAgentDir(), sharedSkillsDir = join6(homedir2(), ".agents", "skills")) {
+  const roots = [join6(agentDir, "skills"), sharedSkillsDir];
   for (const root of roots) {
-    if (await readTextIfExists(join8(root, name, "SKILL.md")) !== undefined)
+    if (await readTextIfExists(join6(root, name, "SKILL.md")) !== undefined)
       return true;
   }
   return false;
@@ -1028,7 +813,7 @@ async function ensurePiConfig(path, update, dryRun = false) {
   const changed = JSON.stringify(current) !== JSON.stringify(next);
   if (changed && !dryRun) {
     await mkdir3(dirname4(path), { recursive: true });
-    await writeFile2(path, `${JSON.stringify(next, null, 2)}
+    await writeFile(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   }
   return { path, changed, existed: currentText !== undefined, planned: changed && dryRun };
@@ -1047,8 +832,8 @@ function hasPiPackage(listOutput, source) {
 async function installPiPackage(executable, source) {
   await runChecked(executable, ["install", source]);
 }
-function resolvePiAgentDir(homeDir = homedir3()) {
-  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join8(process.env.XDG_CONFIG_HOME, "pi") : join8(homeDir, ".pi", "agent"));
+function resolvePiAgentDir(homeDir = homedir2()) {
+  return process.env.PI_CODING_AGENT_DIR ?? (process.env.XDG_CONFIG_HOME ? join6(process.env.XDG_CONFIG_HOME, "pi") : join6(homeDir, ".pi", "agent"));
 }
 function parseJsonObject(content, path) {
   if (!content?.trim())
@@ -1063,15 +848,15 @@ function parseJsonObject(content, path) {
 
 // src/setup.ts
 import { parseFrontmatter as parseFrontmatter2 } from "@earendil-works/pi-coding-agent";
-import { readdir as readdir2, readFile as readFile7 } from "node:fs/promises";
-import { homedir as homedir7 } from "node:os";
-import { basename as basename4, join as join12 } from "node:path";
+import { readdir as readdir2, readFile as readFile5 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { basename as basename4, join as join10 } from "node:path";
 
 // src/config.ts
 import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { z as z4 } from "zod";
-import { homedir as homedir4 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join7 } from "node:path";
 var modelReferenceSchema = zx.text;
 var agentConfigSchema = z4.object({
   models: z4.array(modelReferenceSchema).optional()
@@ -1079,11 +864,11 @@ var agentConfigSchema = z4.object({
 var diffpiConfigSchema = z4.object({
   agents: z4.record(z4.string(), agentConfigSchema).optional()
 }).strict();
-function diffpiConfigPaths(homeDir = homedir4()) {
-  const directory = join9(homeDir, ".difflab", "diffpi");
+function diffpiConfigPaths(homeDir = homedir3()) {
+  const directory = join7(homeDir, ".difflab", "diffpi");
   return {
-    yaml: join9(directory, "config.yaml"),
-    json: join9(directory, "config.json")
+    yaml: join7(directory, "config.yaml"),
+    json: join7(directory, "config.json")
   };
 }
 async function loadDiffpiConfig(options = {}) {
@@ -1139,12 +924,12 @@ function normalizeModelReference(value) {
 }
 
 // src/mcp.ts
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "node:fs/promises";
-import { homedir as homedir5 } from "node:os";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname5, join as join8 } from "node:path";
 var mcp = {
-  globalConfigPath(homeDir = homedir5()) {
-    return join10(homeDir, ".config", "mcp", "mcp.json");
+  globalConfigPath(homeDir = homedir4()) {
+    return join8(homeDir, ".config", "mcp", "mcp.json");
   },
   async serversEnsure(servers, options = {}) {
     const path = options.path ?? mcp.globalConfigPath();
@@ -1158,7 +943,7 @@ var mcp = {
     const changed = JSON.stringify(current) !== JSON.stringify(next);
     if (changed && !options.dryRun) {
       await mkdir4(dirname5(path), { recursive: true });
-      await writeFile3(path, `${JSON.stringify(next, null, 2)}
+      await writeFile2(path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
     }
     return { path, changed, existed: currentText !== undefined, planned: changed && options.dryRun === true };
@@ -1187,7 +972,7 @@ function getParsedConfig(content, path) {
 }
 async function getOptionalFile(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile3(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return;
@@ -1199,9 +984,9 @@ function isRecord(value) {
 }
 
 // src/extensions/misex.ts
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join11 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
+import { basename as basename3, dirname as dirname6, join as join9 } from "node:path";
 var MISE_HOOK_START = "# >>> @difflab/pi mise >>>";
 var MISE_HOOK_END = "# <<< @difflab/pi mise <<<";
 var mise = {
@@ -1212,11 +997,11 @@ var mise = {
     return run("mise", args, options);
   },
   async install(options = {}) {
-    const homeDir = options.homeDir ?? homedir6();
+    const homeDir = options.homeDir ?? homedir5();
     const platform = options.platform ?? process.platform;
     if (platform === "win32")
       throw new Error("Automatic mise installation supports macOS and Linux only.");
-    const installedPath = join11(homeDir, ".local", "bin", "mise");
+    const installedPath = join9(homeDir, ".local", "bin", "mise");
     if (options.dryRun)
       return installedPath;
     await runChecked("sh", ["-c", "curl -fsSL https://mise.run | sh"]);
@@ -1226,7 +1011,7 @@ var mise = {
     return executable;
   },
   async hookEnsure(executable, options = {}) {
-    const homeDir = options.homeDir ?? homedir6();
+    const homeDir = options.homeDir ?? homedir5();
     const hook = getShellHook(basename3(options.shell ?? process.env.SHELL ?? ""), executable, homeDir);
     const current = await getOptionalFile2(hook.path);
     if (current.includes(MISE_HOOK_START))
@@ -1237,7 +1022,7 @@ var mise = {
 `) ? "" : `
 `;
     await mkdir5(dirname6(hook.path), { recursive: true });
-    await writeFile4(hook.path, `${current}${separator}${hook.content}`, "utf8");
+    await writeFile3(hook.path, `${current}${separator}${hook.content}`, "utf8");
     return { path: hook.path, changed: true, planned: false };
   },
   async toolCheckGlobal(executable, tool, minimumVersion) {
@@ -1254,7 +1039,7 @@ var mise = {
   async toolInstallLocal(executable, specification, cwd = process.cwd()) {
     await runChecked(executable, ["use", "--path", cwd, specification], { cwd });
   },
-  async toolUpdateAllGlobal(executable, homeDir = homedir6()) {
+  async toolUpdateAllGlobal(executable, homeDir = homedir5()) {
     await runChecked(executable, ["upgrade"], { cwd: homeDir });
   }
 };
@@ -1263,7 +1048,7 @@ function getShellHook(shell, executable, homeDir) {
   switch (shell.toLowerCase()) {
     case "zsh":
       return {
-        path: join11(homeDir, ".zshrc"),
+        path: join9(homeDir, ".zshrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate zsh)"
 ${MISE_HOOK_END}
@@ -1271,7 +1056,7 @@ ${MISE_HOOK_END}
       };
     case "fish":
       return {
-        path: join11(homeDir, ".config", "fish", "config.fish"),
+        path: join9(homeDir, ".config", "fish", "config.fish"),
         content: `${MISE_HOOK_START}
 ${command} activate fish | source
 ${MISE_HOOK_END}
@@ -1280,7 +1065,7 @@ ${MISE_HOOK_END}
     case "nu":
     case "nushell":
       return {
-        path: join11(homeDir, ".config", "nushell", "config.nu"),
+        path: join9(homeDir, ".config", "nushell", "config.nu"),
         content: `${MISE_HOOK_START}
 let mise_bin = ${command}
 let mise_path = $nu.default-config-dir | path join mise.nu
@@ -1291,7 +1076,7 @@ ${MISE_HOOK_END}
       };
     case "xonsh":
       return {
-        path: join11(homeDir, ".xonshrc"),
+        path: join9(homeDir, ".xonshrc"),
         content: `${MISE_HOOK_START}
 execx($(${command} activate xonsh))
 ${MISE_HOOK_END}
@@ -1299,7 +1084,7 @@ ${MISE_HOOK_END}
       };
     case "elvish":
       return {
-        path: join11(homeDir, ".config", "elvish", "rc.elv"),
+        path: join9(homeDir, ".config", "elvish", "rc.elv"),
         content: `${MISE_HOOK_START}
 var mise: = (ns [&])
 eval (${command} activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
@@ -1310,7 +1095,7 @@ ${MISE_HOOK_END}
     case "pwsh":
     case "powershell":
       return {
-        path: join11(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
+        path: join9(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1"),
         content: `${MISE_HOOK_START}
 (& ${command} activate pwsh) | Out-String | Invoke-Expression
 ${MISE_HOOK_END}
@@ -1319,7 +1104,7 @@ ${MISE_HOOK_END}
     case "bash":
     default:
       return {
-        path: join11(homeDir, ".bashrc"),
+        path: join9(homeDir, ".bashrc"),
         content: `${MISE_HOOK_START}
 eval "$(${command} activate bash)"
 ${MISE_HOOK_END}
@@ -1358,7 +1143,7 @@ function isVersionAtLeast(version, minimumVersion) {
 }
 async function getOptionalFile2(path) {
   try {
-    return await readFile6(path, "utf8");
+    return await readFile4(path, "utf8");
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
       return "";
@@ -1374,12 +1159,6 @@ var MISE_DEPENDENCIES = [
   { name: "node", tool: "node", spec: "node@22", minimumVersion: "22.19.0" },
   { name: "zellij", tool: "zellij", spec: "zellij@latest", minimumVersion: undefined },
   { name: "helix", tool: "helix", spec: "helix@latest", minimumVersion: undefined },
-  {
-    name: "tuicr",
-    tool: "github:agavra/tuicr",
-    spec: "github:agavra/tuicr@latest",
-    minimumVersion: undefined
-  },
   {
     name: "context-mode",
     tool: "npm:context-mode",
@@ -1408,8 +1187,8 @@ var FORGE_DEPENDENCIES = {
   gitlab: { name: "glab", tool: "glab", spec: "glab@latest", minimumVersion: undefined }
 };
 async function ensureMise(options = {}) {
-  const homeDir = options.homeDir ?? homedir7();
-  const current = await mise.executableCheck() ?? await mise.executableCheck(join12(homeDir, ".local", "bin", "mise"));
+  const homeDir = options.homeDir ?? homedir6();
+  const current = await mise.executableCheck() ?? await mise.executableCheck(join10(homeDir, ".local", "bin", "mise"));
   if (current)
     return { executable: current, action: createSetupAction("mise", "ready", current) };
   reportProgress(options, "Installing mise");
@@ -1458,9 +1237,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(join12(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
+  const webSearch = await pi.configEnsure(join10(agentDir, "web-search.json"), (config) => ({ ...config, workflow: "auto-summary" }), options.dryRun);
   actions.push(getConfigSetupAction("web search settings", webSearch));
-  const lsp = await pi.configEnsure(join12(agentDir, "pi-lsp.json"), (config) => ({
+  const lsp = await pi.configEnsure(join10(agentDir, "pi-lsp.json"), (config) => ({
     ...config,
     progressive: { ...getRecord(config.progressive), enabled: true, inject: "none" }
   }), options.dryRun);
@@ -1475,7 +1254,7 @@ async function ensurePiAgents(options = {}) {
   const actions = [];
   for (const entry of entries) {
     const id = basename4(entry.name, ".md").replace(/^diffpi-/, "");
-    const source = await readFile7(join12(bundledAgentsDir, entry.name), "utf8");
+    const source = await readFile5(join10(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));
@@ -1484,7 +1263,7 @@ async function ensurePiAgents(options = {}) {
 }
 async function ensurePiSkills(miseExecutable, options = {}) {
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const sharedSkillsDir = join12(options.homeDir ?? homedir7(), ".agents", "skills");
+  const sharedSkillsDir = join10(options.homeDir ?? homedir6(), ".agents", "skills");
   const actions = [];
   for (const source of PI_SKILL_SOURCES) {
     const missing = [];
@@ -1552,8 +1331,6 @@ async function setupPi(options = {}) {
   actions.push(...await ensurePiAgents(options));
   actions.push(...await ensurePiSkills(miseResult.executable, options));
   actions.push(...await ensureMcpAdapters(miseResult.executable, options));
-  if (options.bindZedKey)
-    actions.push(...await ensureZedIntegration(options));
   return {
     actions,
     restartPi: setupRequiresRestart(actions)
@@ -1562,35 +1339,6 @@ async function setupPi(options = {}) {
 function setupRequiresRestart(actions) {
   return actions.some((item) => (item.status === "installed" || item.status === "updated") && (item.name.startsWith("pi package ") || item.name.startsWith("pi agent ") || item.name.startsWith("pi skill ") || item.name === "MCP configuration" || item.name === "web search settings" || item.name === "pi-lsp settings"));
 }
-async function ensureZedIntegration(options = {}) {
-  if (options.dryRun) {
-    const actions = [
-      createSetupAction("Zed review tasks", "planned", "global static runtime-resolver tasks in tasks.json"),
-      createSetupAction("Zed plan task", "planned", "pinned package CLI task in tasks.json")
-    ];
-    if (options.bindZedKey)
-      actions.push(createSetupAction("Zed review keybinding", "planned", "keymap.json"));
-    return actions;
-  }
-  const actions = [];
-  try {
-    const tasks = await ensureZedReviewTask(options.homeDir);
-    actions.push(createSetupAction("Zed review tasks", tasks.changed ? "installed" : "ready", tasks.path));
-    const planTask = await ensureZedPlanTask(await packageVersion2(), options.homeDir);
-    actions.push(createSetupAction("Zed plan task", planTask.changed ? "installed" : "ready", planTask.path));
-  } catch (error) {
-    actions.push(createSetupAction("Zed review tasks", "skipped", error instanceof Error ? error.message : String(error)));
-  }
-  if (options.bindZedKey) {
-    try {
-      const key = await ensureZedReviewKeybinding(options.homeDir);
-      actions.push(createSetupAction("Zed review keybinding", key.changed ? "installed" : "ready", key.path));
-    } catch (error) {
-      actions.push(createSetupAction("Zed review keybinding", "skipped", error instanceof Error ? error.message : String(error)));
-    }
-  }
-  return actions;
-}
 async function gitlabMcpHost(projectDir) {
   try {
     const vcs = await detectVcs(projectDir);
@@ -1679,18 +1427,6 @@ function createSetupAction(name, status, detail) {
 function reportProgress(options, message) {
   options.onProgress?.(message);
 }
-async function packageVersion2() {
-  const source = await readFile7(join12(resolveBundledAgentsDir(), "..", "package.json"), "utf8");
-  let value;
-  try {
-    value = JSON.parse(source);
-  } catch (error) {
-    throw new Error("Cannot parse the installed @difflab/pi package metadata.", { cause: error });
-  }
-  if (typeof value.version !== "string")
-    throw new Error("Cannot resolve the installed @difflab/pi version.");
-  return value.version;
-}
 function getRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -1706,13 +1442,13 @@ var REQUIRED_AGENTS = [
 async function doctorAgents(options = {}) {
   const bundledDir = options.bundledAgentsDir ?? resolveBundledAgentsDir();
   const agentDir = options.agentDir ?? pi.agentDir(options.homeDir);
-  const targetDir = join13(agentDir, "agents");
+  const targetDir = join11(agentDir, "agents");
   const bundled = (await readdir3(bundledDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.startsWith("diffpi-") && entry.name.endsWith(".md")).map((entry) => entry.name);
   for (const name of REQUIRED_AGENTS)
     if (!bundled.includes(name))
       throw new Error(`Installed @difflab/pi is missing bundled agent ${name}`);
   for (const name of bundled) {
-    const content = await readFile8(join13(bundledDir, name), "utf8");
+    const content = await readFile6(join11(bundledDir, name), "utf8");
     if (content.includes("diffpi_modes_"))
       throw new Error(`Installed agent ${name} still requires removed mode tools`);
   }
@@ -1726,10 +1462,10 @@ async function doctorAgents(options = {}) {
     if (!bundled.includes(basename5(path)))
       throw new Error(`Unexpected agent destination: ${path}`);
     try {
-      const stat = await lstat2(path);
+      const stat = await lstat3(path);
       if (!stat.isFile())
         throw new Error(`Refusing to overwrite non-file agent: ${path}`);
-      originals.push({ path, content: await readFile8(path) });
+      originals.push({ path, content: await readFile6(path) });
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
@@ -1737,17 +1473,17 @@ async function doctorAgents(options = {}) {
   }
   const backups = [];
   if (originals.length > 0) {
-    const backupDir = join13(targetDir, ".diffpi-doctor-backups");
+    const backupDir = join11(targetDir, ".diffpi-doctor-backups");
     await mkdir6(backupDir, { recursive: true, mode: 448 });
     for (const original of originals) {
       const digest = createHash2("sha256").update(original.content).digest("hex").slice(0, 16);
-      const backupPath = join13(backupDir, `${basename5(original.path)}.${digest}.bak`);
+      const backupPath = join11(backupDir, `${basename5(original.path)}.${digest}.bak`);
       try {
-        await writeFile5(backupPath, original.content, { flag: "wx", mode: 384 });
+        await writeFile4(backupPath, original.content, { flag: "wx", mode: 384 });
       } catch (error) {
         if (error.code !== "EEXIST")
           throw error;
-        const existing = await readFile8(backupPath);
+        const existing = await readFile6(backupPath);
         if (!existing.equals(original.content))
           throw new Error(`Backup hash collision: ${backupPath}`);
       }
@@ -1799,14 +1535,14 @@ import { defineTool as defineTool4 } from "@earendil-works/pi-coding-agent";
 import { z as z6 } from "zod";
 
 // src/plan/verify.ts
-import { readFile as readFile9, readdir as readdir4, stat } from "node:fs/promises";
-import { basename as basename6, dirname as dirname7, join as join14, resolve as resolve3 } from "node:path";
+import { lstat as lstat4, readFile as readFile7, readdir as readdir4, stat } from "node:fs/promises";
+import { basename as basename6, dirname as dirname7, join as join12, resolve as resolve4 } from "node:path";
 async function verifyLivePlan(requested, cwd = process.cwd()) {
-  const path = resolve3(cwd, requested);
+  const path = resolve4(cwd, requested);
   let planPath = path;
   try {
     if ((await stat(path)).isDirectory())
-      planPath = join14(path, "PLAN.md");
+      planPath = join12(path, "PLAN.md");
   } catch {}
   const issues = [];
   const briefPaths = [];
@@ -1819,7 +1555,7 @@ async function verifyLivePlan(requested, cwd = process.cwd()) {
     addIssue(issues, planPath, 0, "layout", "Place PLAN.md under .diffpi/plan/<YYMMDD[-ticket]-short-slug>/.");
   let source;
   try {
-    source = await readFile9(planPath, "utf8");
+    source = await readFile7(planPath, "utf8");
   } catch {
     addIssue(issues, planPath, 0, "missing-plan", "PLAN.md is not readable.");
     return { planPath, briefPaths, ok: false, issues };
@@ -1833,7 +1569,7 @@ async function verifyLivePlan(requested, cwd = process.cwd()) {
     if (!planLines[line]?.startsWith(`### Phase ${index + 1}: `))
       addIssue(issues, planPath, line + 1, "phase-order", "Number phase headings from 1 without gaps.");
   }
-  const implementation = join14(planDir, "implementation");
+  const implementation = join12(planDir, "implementation");
   let rootEntries = [];
   let briefEntries = [];
   try {
@@ -1841,19 +1577,28 @@ async function verifyLivePlan(requested, cwd = process.cwd()) {
     briefEntries = await readdir4(implementation);
   } catch {}
   for (const entry of rootEntries) {
-    if (entry !== "PLAN.md" && entry !== "implementation")
-      addIssue(issues, join14(planDir, entry), 0, "layout", "Only PLAN.md and implementation/ belong in the plan directory.");
+    const directory = ["implementation", "revisions", "logs"].includes(entry);
+    const logFile = entry === "logs.jsonl";
+    let valid = entry === "PLAN.md";
+    if (directory || logFile) {
+      try {
+        const details = await lstat4(join12(planDir, entry));
+        valid = !details.isSymbolicLink() && (directory ? details.isDirectory() : details.isFile());
+      } catch {}
+    }
+    if (!valid)
+      addIssue(issues, join12(planDir, entry), 0, "layout", "Only PLAN.md, implementation/, revisions/, logs.jsonl, and historical logs/ belong in the plan directory.");
   }
   for (const entry of briefEntries) {
     const ordinal = /^phase-(\d+)\.md$/.exec(entry)?.[1];
     if (!ordinal || !Number(ordinal) || Number(ordinal) > phases.length || entry !== `phase-${Number(ordinal)}.md`)
-      addIssue(issues, join14(implementation, entry), 0, "extra-brief", "Only matching numbered phase briefs belong in implementation/.");
+      addIssue(issues, join12(implementation, entry), 0, "extra-brief", "Only matching numbered phase briefs belong in implementation/.");
   }
   for (let index = 0;index < phases.length; index++) {
-    const brief = join14(implementation, `phase-${index + 1}.md`);
+    const brief = join12(implementation, `phase-${index + 1}.md`);
     briefPaths.push(brief);
     try {
-      const lines = visibleLines(await readFile9(brief, "utf8"));
+      const lines = visibleLines(await readFile7(brief, "utf8"));
       if (!/^# Phase \d+:\s*\S/.test(lines[0] ?? "") || !lines[0]?.startsWith(`# Phase ${index + 1}: `))
         addIssue(issues, brief, 1, "phase-title", `Start with # Phase ${index + 1}: <title>.`);
       checkHeadings(lines, brief, ["Objective", "Files Affected", "Tasks", "Implementation Constraints"], issues);
@@ -1934,11 +1679,8 @@ function createDiffpiReloadTool(pi) {
 }
 
 // src/tools/review.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { mkdir as mkdir7, readdir as readdir5, readFile as readFile14, rename as rename2, stat as stat2, unlink as unlink2, writeFile as writeFile8 } from "node:fs/promises";
-import { join as join17 } from "node:path";
 import { defineTool as defineTool6 } from "@earendil-works/pi-coding-agent";
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
 // src/gates.ts
 var CONVENTIONAL_COMMIT = /^(feat|fix|perf|refactor|docs|chore|test|build|ci|style|revert)(\([^)]+\))?!?: .+/;
@@ -2010,33 +1752,6 @@ var findingSchema = z8.object({
   reference: z8.string().optional().default("")
 });
 var findingsSchema = z8.array(findingSchema);
-function reviewSlug(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function yymmdd(date = new Date) {
-  const yy = String(date.getFullYear() % 100).padStart(2, "0");
-  const mm = String(date.getMonth() + 1).padStart(2, "0");
-  const dd = String(date.getDate()).padStart(2, "0");
-  return `${yy}${mm}${dd}`;
-}
-function reviewRecordName(target, date = new Date) {
-  return `${yymmdd(date)}-${reviewSlug(target) || "uncommitted"}`;
-}
-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;
@@ -2071,9 +1786,6 @@ function withRemoteProvenance(body, model) {
 
 Generated review by Diffpi using \`${model}\`.`;
 }
-function localReviewAuthor(model) {
-  return `Agent: ${model}`;
-}
 function renderCommentBody(finding) {
   const prefix = finding.severity === "BLOCKING" ? "**BLOCKING** " : "";
   const reference = finding.reference ? `
@@ -2081,142 +1793,6 @@ function renderCommentBody(finding) {
 > **Reference:** ${finding.reference}` : "";
   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"];
-  if (input.number !== undefined)
-    lines.push(`- **PR/MR**: #${input.number}${input.url ? ` — ${input.url}` : ""}`);
-  if (input.author)
-    lines.push(`- **Author**: ${input.author}`);
-  if (input.model)
-    lines.push(`- **Review agent**: ${input.model}`);
-  if (input.headRef && input.baseRef)
-    lines.push(`- **Branch**: ${input.headRef} → ${input.baseRef}`);
-  if (input.additions !== undefined)
-    lines.push(`- **Stats**: +${input.additions} -${input.deletions ?? 0} across ${input.changedFiles ?? 0} files`);
-  lines.push(`- **Reviewed**: ${input.timestamp ?? new Date().toISOString()}`, "");
-  if (input.overallIssues.length > 0) {
-    lines.push("## Overall issues", "");
-    for (const issue of input.overallIssues)
-      lines.push(`- ${issue}`);
-    lines.push("");
-  }
-  lines.push("## Verification", "");
-  for (const gate of input.gates)
-    lines.push(`- ${gate.name}: ${gate.status} — ${gate.detail}`);
-  lines.push("");
-  if (input.notVerified.length > 0) {
-    lines.push("## What was NOT verified", "");
-    for (const item of input.notVerified)
-      lines.push(`- ${item}`);
-    lines.push("");
-  }
-  lines.push("## Inline Comments", "");
-  for (const finding of anchored) {
-    lines.push(`### ${finding.file}:${finding.line} — ${finding.severity}`, "", finding.body, "");
-    if (finding.reference)
-      lines.push(`> **Reference:** ${finding.reference}`, "");
-    lines.push("---", "");
-  }
-  return `${lines.join(`
-`).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 () => {
@@ -2596,245 +2172,6 @@ function hasGitlabDraftNotes(input) {
   }
 }
 
-// src/review/local-review-backend.ts
-import { readFile as readFile11, writeFile as writeFile6 } from "node:fs/promises";
-
-// src/extensions/tuicrx.ts
-import { readFile as readFile10, realpath as realpath3 } from "node:fs/promises";
-import { resolve as resolve4 } from "node:path";
-async function tuicrAvailable() {
-  return Boolean(await findExecutable("tuicr"));
-}
-async function listSessions(repo = ".") {
-  await requireTuicr();
-  const result = await run("tuicr", ["review", "list", "--repo", repo]);
-  if (result.code !== 0 || !result.stdout.trim())
-    return [];
-  try {
-    const raw = JSON.parse(result.stdout);
-    return raw.map((entry) => ({
-      slug: entry.slug,
-      kind: entry.kind,
-      path: entry.path,
-      updatedAt: entry.updated_at,
-      commentCount: entry.comment_count,
-      anchor: entry.anchor,
-      active: entry.active
-    }));
-  } catch {
-    throw new Error("Cannot parse tuicr review list output.");
-  }
-}
-async function addComment(session, body, opts = {}) {
-  await requireTuicr();
-  const args = ["review", "add", "--session", session, body];
-  if (opts.targetFile)
-    args.push("--target-file", opts.targetFile);
-  if (opts.line !== undefined)
-    args.push("--line", String(opts.line));
-  if (opts.side)
-    args.push("--side", opts.side);
-  if (opts.username)
-    args.push("--username", opts.username);
-  await runChecked("tuicr", args);
-}
-async function launch(cwd, pr, localBase) {
-  let command;
-  if (pr !== undefined)
-    command = ["tuicr", "pr", String(pr)];
-  else if (localBase)
-    command = ["tuicr", "-w", "-r", `${localBase}..HEAD`];
-  else
-    throw new Error("Cannot launch a local tuicr review: no base branch could be determined.");
-  if (!await tuicrAvailable()) {
-    return {
-      launched: false,
-      via: "print",
-      command: command.join(" "),
-      reason: "tuicr is not installed or is not available on PATH.",
-      instruction: `Install tuicr, then run: ${command.join(" ")}`
-    };
-  }
-  const name = diffpiLaunchName(cwd, pr === undefined ? "local review" : `PR #${pr}`);
-  return openInNewTab(command, { cwd, name });
-}
-async function resolveSession(cwd, branch) {
-  const sessions = await listSessions(cwd);
-  return findMatchingSession(sessions, cwd, branch);
-}
-async function resolveReviewSession(cwd, target) {
-  if (!target.workingTree && target.owner && target.repo && target.number !== undefined) {
-    return resolvePrSession(cwd, target.owner, target.repo, target.number);
-  }
-  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);
-  return sessions.find((session) => {
-    const slug = session.slug.toLowerCase();
-    return session.kind === "pr" && slug.includes(coordinate) && (slug.endsWith(`/pr/${number}`) || slug.endsWith(`/mr/${number}`));
-  });
-}
-async function findMatchingSession(sessions, cwd, branch) {
-  const repository = await canonicalPath3(await gitToplevel(cwd));
-  for (const session of sessions) {
-    if (session.kind !== "local")
-      continue;
-    try {
-      const data = await readSession(session.path);
-      if (data.branch_name !== branch || !data.repo_path)
-        continue;
-      if (await canonicalPath3(data.repo_path) === repository)
-        return session;
-    } catch {}
-  }
-  return;
-}
-async function readSession(path) {
-  const content = await readFile10(path, "utf8");
-  try {
-    return JSON.parse(content);
-  } catch {
-    throw new Error(`Cannot parse tuicr session JSON: ${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}`,
-      ...location,
-      body: comment.content,
-      ...author ? { author } : {},
-      resolved: false,
-      question: /\?\s*$/.test(comment.content.trim())
-    });
-  };
-  for (const comment of session.review_comments ?? [])
-    add(comment);
-  for (const [file, entry] of Object.entries(session.files ?? {})) {
-    for (const comment of entry.file_comments ?? [])
-      add(comment, { file });
-    for (const [lineKey, lineComments] of Object.entries(entry.line_comments ?? {})) {
-      const line = Number.parseInt(lineKey, 10);
-      if (!Number.isFinite(line))
-        continue;
-      for (const comment of lineComments)
-        add(comment, { file, line });
-    }
-  }
-  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.");
-}
-function commentAuthor(comment) {
-  return comment.username ?? comment.author;
-}
-async function canonicalPath3(path) {
-  try {
-    return await realpath3(path);
-  } catch {
-    return resolve4(path);
-  }
-}
-
-// 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 readFile11(options.artifactPath, "utf8"));
-      } catch (error) {
-        if (error.code === "ENOENT")
-          return [];
-        throw error;
-      }
-    },
-    async reply(input) {
-      const content = await readFile11(options.artifactPath, "utf8");
-      await writeFile6(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.");
-    }
-  };
-}
-
 // src/review/review-backend.ts
 function createRemoteReviewBackend(vcs, number) {
   if (vcs.provider === "github")
@@ -2843,67 +2180,24 @@ function createRemoteReviewBackend(vcs, number) {
     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 createHash3 } from "node:crypto";
-import { readFile as readFile12, rename, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join15 } 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()
+import { z as z9 } from "zod";
+var reviewPublicationStateSchema = z9.object({
+  target: z9.string().optional(),
+  bodies: z9.array(z9.string()).default([]),
+  comments: z9.array(z9.string()).default([]),
+  stagedComments: z9.array(z9.string()).default([]),
+  replies: z9.array(z9.string()).default([]),
+  overlayPath: z9.string().optional()
 });
-function reviewBodyFingerprint(body) {
-  return digest(body);
-}
-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 = join15(await sessionsDir(cwd, homeDir), `review-publish-${digest(target).slice(0, 16)}.json`);
-  try {
-    const parsed = reviewPublicationStateSchema.parse(JSON.parse(await readFile12(path, "utf8")));
-    return { path, state: { ...parsed, target } };
-  } catch (error) {
-    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 writeFile7(temp, `${JSON.stringify(state, null, 2)}
-`, "utf8");
-  await rename(temp, path);
-}
-function digest(value) {
-  return createHash3("sha256").update(value).digest("hex");
-}
 // src/templates.ts
-import { readFile as readFile13 } from "node:fs/promises";
-import { homedir as homedir8 } from "node:os";
-import { join as join16, normalize } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { homedir as homedir7 } from "node:os";
+import { join as join13, normalize } from "node:path";
 async function loadTemplate(name, options = {}) {
   const relative = templateRelativePath(name);
-  const userPath = join16(options.homeDir ?? homedir8(), ".difflab", "diffpi", "templates", relative);
-  const bundledPath = join16(options.bundledDir ?? resolveBundledTemplatesDir(), relative);
+  const userPath = join13(options.homeDir ?? homedir7(), ".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 };
@@ -2924,7 +2218,7 @@ function templateRelativePath(name) {
 }
 async function readOptionalFile(path) {
   try {
-    return await readFile13(path, "utf8");
+    return await readFile8(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -2933,94 +2227,64 @@ async function readOptionalFile(path) {
 }
 
 // src/tools/review.ts
-var contextSchema = z11.object({
-  cwd: z11.string().optional(),
-  target: z11.string().optional(),
-  workingTree: z11.boolean().optional()
+var contextSchema = z10.object({
+  cwd: z10.string().optional(),
+  target: z10.string().optional(),
+  workingTree: z10.boolean().optional()
 });
-var localSchema = contextSchema.extend({ local: z11.boolean().optional() });
+var localSchema = contextSchema.extend({ local: z10.boolean().optional() });
 var openSchema = localSchema.extend({
-  title: z11.string().optional(),
-  intent: z11.string().optional(),
-  issueUrl: z11.string().url().optional(),
-  base: z11.string().optional()
+  title: z10.string().optional(),
+  intent: z10.string().optional(),
+  issueUrl: z10.string().url().optional(),
+  base: z10.string().optional(),
+  body: z10.string().optional()
 });
 var submitSchema = localSchema.extend({
   findings: findingsSchema,
-  overallIssues: z11.array(z11.string()).optional(),
-  notVerified: z11.array(z11.string()).optional(),
-  title: z11.string().optional()
+  overallIssues: z10.array(z10.string()).optional(),
+  notVerified: z10.array(z10.string()).optional(),
+  title: z10.string().optional()
 });
 var addCommentSchema = localSchema.extend({
-  body: z11.string().min(1),
-  file: z11.string().min(1),
-  line: z11.number().int().positive(),
-  side: z11.enum(["LEFT", "RIGHT"]).optional()
+  body: z10.string().min(1),
+  file: z10.string().min(1),
+  line: z10.number().int().positive(),
+  side: z10.enum(["LEFT", "RIGHT"]).optional()
 });
 var respondSchema = localSchema.extend({
-  threadId: z11.string().min(1),
-  body: z11.string().min(1),
-  question: z11.boolean().optional(),
-  resolve: z11.boolean().optional()
+  threadId: z10.string().min(1),
+  body: z10.string().min(1),
+  question: z10.boolean().optional(),
+  resolve: z10.boolean().optional()
 });
 var publishSchema = localSchema.extend({
-  status: z11.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
+  status: z10.enum(["COMMENT", "APPROVE", "REQUEST_CHANGES", "CLOSE"]).optional()
 });
 var completeSchema = localSchema.extend({
-  action: z11.enum(["approve", "reject", "abandon"]).optional()
+  action: z10.enum(["approve", "reject", "close"]).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;
+function assertRenderedReviewBody(body) {
+  if (/{{[^{}]+}}/.test(body))
+    throw new Error("Review body contains unresolved template placeholders.");
+  if (/<!--/.test(body))
+    throw new Error("Review body contains HTML comments.");
+  const headings = [...body.matchAll(/^## (.+)$/gm)];
+  for (const section of ["Intent", "Changes", "Validation", "References", "Further Work"]) {
+    const index = headings.findIndex((match) => match[1].trim() === section);
+    const current = headings[index];
+    if (!current || current.index === undefined)
+      throw new Error(`Review body requires a filled ${section} section.`);
+    const content = body.slice(current.index + current[0].length, headings[index + 1]?.index).trim();
+    if (!content)
+      throw new Error(`Review body requires a filled ${section} section.`);
   }
-  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" });
@@ -3044,7 +2308,7 @@ function createReviewTools() {
     defineTool6({
       name: "review_context",
       label: "review context",
-      description: "Orient to the target, backend, forge, environment, shared store, PR/MR, and tuicr session.",
+      description: "Orient to the target, forge, environment, shared store, and PR/MR.",
       promptSnippet: "Call review_context first",
       promptGuidelines: ["Call this before every review workflow."],
       parameters: parameters(localSchema),
@@ -3054,19 +2318,15 @@ 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)).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";
+        const backend = review.forge?.provider ?? "unsupported";
         return result2([
           `Backend: ${backend}`,
           `Forge: ${review.vcs.provider}${review.vcs.provider === "none" ? "" : ` (${review.vcs.owner}/${review.vcs.repo})`}`,
           `Branch: ${review.vcs.branch} → ${baseRef}`,
           `Env: ide=${env.ide} mux=${env.mux} shell=${env.shell}`,
           `Store: ${store.link} → ${store.dest}`,
-          review.pr ? `PR/MR: #${review.pr.number} ${review.pr.url}` : "PR/MR: none",
-          session ? `tuicr: ${session.slug} (${session.commentCount} comments)` : "tuicr: none"
+          review.pr ? `PR/MR: #${review.pr.number} ${review.pr.url}` : "PR/MR: none"
         ].join(`
 `), {
           cwd: review.cwd,
@@ -3074,7 +2334,6 @@ function createReviewTools() {
           pr: review.pr,
           env,
           store,
-          session,
           baseRef,
           backend
         });
@@ -3083,9 +2342,9 @@ function createReviewTools() {
     defineTool6({
       name: "review_status",
       label: "review status",
-      description: "Report local and remote review lifecycle status without requiring a forge or tuicr.",
+      description: "Report remote review lifecycle status without requiring a forge.",
       promptSnippet: "Call review_status for review lifecycle state",
-      promptGuidelines: ["Use this for status even when no forge or tuicr binary is available."],
+      promptGuidelines: ["Use this for status even when no forge is available."],
       parameters: parameters(localSchema),
       executionMode: "parallel",
       async execute(_id, input) {
@@ -3098,9 +2357,9 @@ function createReviewTools() {
     defineTool6({
       name: "review_new",
       label: "review new",
-      description: "Create a new local tuicr review or a remote draft PR/MR and open it in tuicr.",
+      description: "Create a filled remote draft PR/MR.",
       promptSnippet: "Call review_new to start",
-      promptGuidelines: ["Use local to select tuicr as the review backend."],
+      promptGuidelines: ["Use the skill workflow for direct-file local reviews."],
       parameters: parameters(openSchema),
       executionMode: "sequential",
       async execute(_id, input) {
@@ -3108,7 +2367,7 @@ function createReviewTools() {
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         await ensureStore(review.cwd);
         if (params.local || params.workingTree)
-          return launchLocalReview(review, true, params.base);
+          return result2("Local reviews are direct Markdown files; follow the review new workflow instead.");
         if (!review.forge)
           return result2(unsupportedForgeMessage());
         if (review.pr)
@@ -3116,57 +2375,25 @@ function createReviewTools() {
         await assertRemoteBranchReady(review.cwd);
         const base = params.base ?? await review.forge.defaultBranch();
         const template = await loadTemplate("review/draft-pr");
-        const body = renderTemplate(template.content, {
-          intent: params.intent ?? "<!-- Describe why this change is needed. -->",
-          issue_url: params.issueUrl ?? "<!-- Add issue tracker URL. -->",
-          head: review.vcs.branch,
-          base
-        });
+        if (!params.body)
+          throw new Error("A fully rendered draft PR body is required.");
+        assertRenderedReviewBody(params.body);
         const pr = await review.forge.createDraftPr({
           title: params.title ?? deriveTitle(review.vcs.branch),
-          body,
+          body: params.body,
           base,
           head: review.vcs.branch
         });
-        const launched = await launch(review.cwd, pr.number);
-        const openMessage = launched.launched ? `Opened PR/MR #${pr.number} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`;
-        return result2(`Draft PR/MR created from ${template.source} template: ${pr.url}
-${openMessage}`, {
+        return result2(`Draft PR/MR created from ${template.source} template: ${pr.url}`, {
           pr,
-          template,
-          launched
-        });
-      }
-    }),
-    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: parameters(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 result2(`${unsupportedForgeMessage()} Use review_new with local=true for an offline review.`);
-        if (!review.pr)
-          return result2("No remote PR/MR exists. Use review_new to create a draft review first.");
-        const opened = await openReviewUrl(review.pr.url);
-        return result2(`${opened ? "Opened" : "Open this URL"} PR/MR #${review.pr.number}: ${review.pr.url}`, {
-          pr: review.pr,
-          opened,
-          url: review.pr.url
+          template
         });
       }
     }),
     defineTool6({
       name: "review_edit",
       label: "review edit",
-      description: "Open an existing local tuicr session or remote PR/MR in tuicr without generating findings.",
+      description: "Print the selected local review path or remote PR/MR URL without generating findings.",
       promptSnippet: "Call review_edit to continue an existing review",
       promptGuidelines: ["This tool never creates review findings or a PR/MR."],
       parameters: parameters(localSchema),
@@ -3175,16 +2402,13 @@ ${openMessage}`, {
         const params = localSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         await ensureStore(review.cwd);
-        if (params.local || params.workingTree) {
-          if (!await resolveTuicrSession(review, true))
-            return result2("No local tuicr review exists. Use review_new with local=true to create one.");
-          return launchLocalReview(review, true);
-        }
+        if (params.local || params.workingTree)
+          return result2("Local reviews are direct Markdown files; print the selected REVIEW.md path from the workflow.");
         if (!review.forge)
           return result2(unsupportedForgeMessage());
         if (!review.pr)
           return result2("No remote PR/MR exists. Use review_new to create a draft review first.");
-        return launchLocalReview(review, false);
+        return result2(`PR/MR #${review.pr.number}: ${review.pr.url}`, { pr: review.pr, url: review.pr.url });
       }
     }),
     defineTool6({
@@ -3252,52 +2476,21 @@ ${openMessage}`, {
         const params = submitSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         const model = modelRoute(ctx);
-        const useLocalBackend = Boolean(params.local || params.workingTree);
-        if (!useLocalBackend && !review.forge)
+        if (params.local || params.workingTree)
+          return result2("Local reviews are direct Markdown files; follow the review address workflow instead.");
+        if (!review.forge)
           return result2(unsupportedForgeMessage());
         const findings = dedupeFindings(params.findings);
-        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 writeFile8(artifact, renderReviewDoc({
-          title: params.title ?? review.pr?.title ?? review.vcs.branch,
-          number: useLocalBackend ? undefined : review.pr?.number,
-          url: useLocalBackend ? undefined : review.pr?.url,
-          model,
-          headRef: review.vcs.branch,
-          baseRef,
-          findings,
-          overallIssues: params.overallIssues ?? [],
-          gates,
-          notVerified: params.notVerified ?? []
-        }), "utf8");
-        const comments = toReviewComments(findings, useLocalBackend ? undefined : model);
+        const comments = toReviewComments(findings, model);
         const body = (params.overallIssues ?? []).join(`
 `);
-        if (useLocalBackend) {
-          const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
-          if (!session) {
-            return result2(`Review written: ${artifact}. Open tuicr, then call review_submit again to seed comments.`, {
-              artifact,
-              count: findings.length
-            });
-          }
-          const backend = createLocalReviewBackend({
-            session: session.path,
-            artifactPath: artifact,
-            author: localReviewAuthor(model)
-          });
-          await backend.stage({ comments, body });
-          return result2(`Local review staged in tuicr: ${artifact}`, { artifact, count: findings.length, session });
-        }
         if (!review.pr)
-          return result2(`Review written: ${artifact}. No PR/MR matches this remote target.`, { artifact });
+          return result2("No PR/MR matches this remote target.");
         const hasDraft = hasReviewDraft(comments, body);
         if (hasDraft) {
           await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments, body });
         }
-        return result2(`${hasDraft ? "Pending review staged" : "Clean review recorded"} on #${review.pr.number}. Artifact: ${artifact}`, {
-          artifact,
+        return result2(`${hasDraft ? "Pending review staged" : "Clean review recorded"} on #${review.pr.number}.`, {
           pr: review.pr,
           count: findings.length
         });
@@ -3306,36 +2499,25 @@ ${openMessage}`, {
     defineTool6({
       name: "review_add_comment",
       label: "review add comment",
-      description: "Add one provenance-marked comment through tuicr or the remote pending-review backend.",
+      description: "Add one provenance-marked comment through the remote pending-review backend.",
       promptSnippet: "Call review_add_comment for incremental comments",
-      promptGuidelines: ["Pass local=true when tuicr owns the draft."],
+      promptGuidelines: ["Use the direct-file workflow for local reviews."],
       parameters: parameters(addCommentSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = addCommentSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         const model = modelRoute(ctx);
-        const useLocalBackend = Boolean(params.local || params.workingTree);
-        if (!useLocalBackend && !review.forge)
+        if (params.local || params.workingTree)
+          return result2("Local reviews are direct Markdown files; edit the selected REVIEW.md instead.");
+        if (!review.forge)
           return result2(unsupportedForgeMessage());
         const comment = {
           file: params.file,
           line: params.line,
           side: params.side ?? "RIGHT",
-          body: useLocalBackend ? params.body : withRemoteProvenance(params.body, model)
+          body: withRemoteProvenance(params.body, model)
         };
-        if (useLocalBackend) {
-          const session = await resolveTuicrSession(review, Boolean(params.local || params.workingTree));
-          if (!session)
-            return result2("No matching tuicr session. Open review_new or review_launch_ui first.");
-          const backend = createLocalReviewBackend({
-            session: session.path,
-            artifactPath: "",
-            author: localReviewAuthor(model)
-          });
-          await backend.stage({ comments: [comment], body: "" });
-          return result2(`Comment added to tuicr session ${session.slug}.`, { session, comment });
-        }
         if (!review.pr)
           return result2("No PR/MR matches this remote review target.");
         await createRemoteReviewBackend(review.vcs, review.pr.number).stage({ comments: [comment], body: "" });
@@ -3345,38 +2527,30 @@ ${openMessage}`, {
     defineTool6({
       name: "review_comments",
       label: "review comments",
-      description: "Pull review threads or local tuicr comments and write a target-named artifact.",
+      description: "Pull remote review threads and return them for the direct-file workflow.",
       promptSnippet: "Call review_comments before addressing findings",
-      promptGuidelines: ["Pass local=true to prepare the local reply overlay."],
+      promptGuidelines: ["Use the direct-file workflow for local review files."],
       parameters: parameters(localSchema),
       executionMode: "sequential",
       async execute(_id, input) {
         const params = localSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         let threads;
-        let artifact;
-        if (params.local || params.workingTree) {
-          const session = await resolveTuicrSession(review, true);
-          if (!session)
-            return result2("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) {
+        if (params.local || params.workingTree)
+          return result2("Local reviews are direct Markdown files; read the selected REVIEW.md instead.");
+        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 writeFile8(artifact, renderThreadArtifact(review.pr.title, target, threads, { number: review.pr.number, url: review.pr.url }), "utf8");
         } else {
           return result2(review.forge ? "No PR/MR matches this remote review target." : unsupportedForgeMessage());
         }
         return result2(threads.map((thread) => `${thread.id} ${thread.file ?? "review"}:${thread.line ?? "-"} — ${thread.body}`).join(`
-`) || "No comments.", { artifact, threads });
+`) || "No comments.", { threads });
       }
     }),
     defineTool6({
       name: "review_respond",
       label: "review respond",
-      description: "Post local question replies to tuicr and record their publish overlay, or reply to remote threads.",
+      description: "Reply to remote review threads.",
       promptSnippet: "Call review_respond after addressing a comment",
       promptGuidelines: ["Question replies remain unresolved."],
       parameters: parameters(respondSchema),
@@ -3385,36 +2559,8 @@ ${openMessage}`, {
         const params = respondSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         const model = modelRoute(ctx);
-        if (params.local) {
-          const tuicrSession = await resolveTuicrSession(review, true);
-          if (!tuicrSession)
-            return result2("No matching tuicr session. Open review_new or review_launch_ui first.");
-          const artifact = await localThreadArtifactPath(review.cwd, tuicrSession.slug);
-          if (!existsSync2(artifact))
-            return result2("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 result2(`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 (params.local || params.workingTree)
+          return result2("Local reviews are direct Markdown files; append the response to REVIEW.md instead.");
         if (!review.pr || !review.forge)
           return result2("No remote PR/MR for this reply.");
         const remote = createRemoteReviewBackend(review.vcs, review.pr.number);
@@ -3437,7 +2583,7 @@ ${params.body}`, {
     defineTool6({
       name: "review_publish",
       label: "review publish",
-      description: "Publish pending remote draft PR/MR review comments and status, or promote a local tuicr draft before publishing.",
+      description: "Publish pending remote draft PR/MR review comments and status.",
       promptSnippet: "Call review_publish to make remote review work public",
       promptGuidelines: ["Statuses are COMMENT, APPROVE, REQUEST_CHANGES, or CLOSE."],
       parameters: parameters(publishSchema),
@@ -3445,6 +2591,8 @@ ${params.body}`, {
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = publishSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
+        if (params.local || params.workingTree)
+          return result2("Local publish is unsupported; select a remote PR/MR.");
         if (!review.pr || !review.forge)
           return result2("No remote PR/MR to publish.");
         return publishResolvedReview(review, params, modelRoute(ctx));
@@ -3453,34 +2601,25 @@ ${params.body}`, {
     defineTool6({
       name: "review_complete",
       label: "review complete",
-      description: "Approve, reject, or abandon a remote review, or archive a local review artifact.",
+      description: "Approve, reject, or close a remote review.",
       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."],
+      promptGuidelines: ["Close closes the remote PR/MR without publishing a review first."],
       parameters: parameters(completeSchema),
       executionMode: "sequential",
       async execute(_id, input, _signal, _onUpdate, ctx) {
         const params = completeSchema.parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        if (params.local) {
-          const session = await resolveTuicrSession(review, true);
-          if (!session)
-            return result2("No matching local tuicr session to close.");
-          const artifact = await localThreadArtifactPath(review.cwd, session.slug);
-          if (!existsSync2(artifact))
-            return result2("No local review artifact. Run review_comments with local=true first.");
-          const archived = await uniqueRecordPath(await completedReviewsDir(review.cwd), reviewSlug(session.slug));
-          await rename2(artifact, archived);
-          await unlink2(session.path);
-          return result2(`Archived ${archived} and deleted the tuicr session ${session.slug}.`, {
-            artifact: archived,
-            session
-          });
-        }
+        if (params.local || params.workingTree)
+          return result2("Local complete is unsupported; select a remote PR/MR.");
         if (!review.pr || !review.forge)
           return result2("No remote PR/MR to complete.");
         if (!params.action)
-          return result2("Choose a complete action: approve, reject, or abandon.");
-        const status = { approve: "APPROVE", reject: "REQUEST_CHANGES", abandon: "CLOSE" }[params.action];
+          return result2("Choose a complete action: approve, reject, or close.");
+        if (params.action === "close") {
+          await review.forge.closePr(review.pr.number);
+          return result2(`Closed #${review.pr.number}.`, { pr: review.pr });
+        }
+        const status = params.action === "approve" ? "APPROVE" : "REQUEST_CHANGES";
         return publishResolvedReview(review, { ...params, status }, modelRoute(ctx));
       }
     }),
@@ -3493,10 +2632,10 @@ ${params.body}`, {
         "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: parameters(contextSchema.extend({ subject: z11.string().optional() })),
+      parameters: parameters(contextSchema.extend({ subject: z10.string().optional() })),
       executionMode: "sequential",
       async execute(_id, input) {
-        const params = contextSchema.extend({ subject: z11.string().optional() }).parse(input);
+        const params = contextSchema.extend({ subject: z10.string().optional() }).parse(input);
         const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
         if (review.vcs.provider !== "github" || !review.forge)
           return result2("review_merge currently supports GitHub only.");
@@ -3509,72 +2648,28 @@ ${params.body}`, {
         await review.forge.mergePr(review.pr.number, subject);
         return result2(`Merged #${review.pr.number} with subject: ${subject}.`, { pr: review.pr, guard });
       }
-    }),
-    defineTool6({
-      name: "review_launch_ui",
-      label: "review launch UI",
-      description: "Open a tuicr UI in a mux tab, configure Zed, or return the command to run.",
-      promptSnippet: "Call review_launch_ui for the interactive tuicr TUI",
-      promptGuidelines: ["Show the returned command when launch cannot open a tab."],
-      parameters: parameters(localSchema),
-      executionMode: "sequential",
-      async execute(_id, input) {
-        const params = localSchema.parse(input);
-        const review = await resolveReviewContext(resolveWorkingDirectory(params), params.target);
-        const workingTree = Boolean(params.local || params.workingTree);
-        if (!workingTree && !review.forge)
-          return result2(unsupportedForgeMessage());
-        return launchLocalReview(review, workingTree);
-      }
     })
   ];
 }
-async function syncLocalThreadArtifact(path, title, sessionSlug, threads) {
-  let previous = [];
-  try {
-    previous = parseThreadArtifact(await readFile14(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 writeFile8(path, renderThreadArtifact(title, sessionSlug, merged), "utf8");
-  return merged;
-}
 function parameters(schema) {
-  return z11.toJSONSchema(schema, { io: "input" });
+  return z10.toJSONSchema(schema, { io: "input" });
 }
 function resolveWorkingDirectory(params) {
   return params.cwd ?? process.cwd();
 }
+function deriveTitle(branch) {
+  return branch.replace(/^(feature|feat|fix|bug|chore)\//, "").replace(/^eng-\d+-/i, "").replace(/[-_]+/g, " ").replace(/^\w/, (char) => char.toUpperCase());
+}
 function result2(text, details = {}) {
   return { content: [{ type: "text", text }], details };
 }
 function unsupportedForgeMessage() {
-  return "No supported GitHub or GitLab remote was detected. Use local=true for an offline tuicr review.";
+  return "No supported GitHub or GitLab remote was detected.";
 }
 async function collectReviewStatus(review) {
-  const [porcelain, branch, localSession, remoteSession] = await Promise.all([
+  const [porcelain, branch] = 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;
-    })
+    runChecked("git", ["-C", review.cwd, "branch", "--show-current"])
   ]);
   const entries = porcelain.stdout.split("\\n").filter(Boolean);
   const staged = entries.filter((line) => !line.startsWith("??") && line[0] !== " ").length;
@@ -3585,10 +2680,8 @@ async function collectReviewStatus(review) {
   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"}`
+    `Remote URL: ${url}`
   ].join("\\n");
   return {
     text,
@@ -3597,8 +2690,6 @@ async function collectReviewStatus(review) {
       staged,
       unstaged,
       untracked,
-      localSession,
-      remoteSession,
       pr: review.pr,
       url
     }
@@ -3614,167 +2705,13 @@ async function publishResolvedReview(review, params, model) {
   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 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));
-  const promotedBodies = promotion?.promotedBodies ?? 0;
-  const promotedComments = promotion?.promotedComments ?? 0;
-  const promotedReplies = promotion?.promotedReplies ?? 0;
-  return result2(`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;
+  return result2(`Published #${review.pr.number} (${status}).`, { pr: finalPr ?? review.pr, status });
 }
 async function resolveReviewContext(cwd, target) {
   const vcs = await detectVcs(cwd);
@@ -3786,21 +2723,6 @@ async function resolveReviewContext(cwd, target) {
 function normalizeTarget(target) {
   return target.match(/\/(?:pull|merge_requests)\/(\d+)(?:\/|$)/)?.[1] ?? target;
 }
-function resolveTuicrSession(review, workingTree = false) {
-  return resolveReviewSession(review.cwd, {
-    branch: review.vcs.branch,
-    workingTree,
-    owner: review.vcs.provider === "none" ? undefined : review.vcs.owner,
-    repo: review.vcs.provider === "none" ? undefined : review.vcs.repo,
-    number: review.pr?.number
-  });
-}
-async function launchLocalReview(review, workingTree, requestedBase) {
-  const base = workingTree ? requestedBase ?? review.pr?.baseRef ?? (review.forge ? await review.forge.defaultBranch() : undefined) : undefined;
-  const launched = await launch(review.cwd, workingTree ? undefined : review.pr?.number, base);
-  const commandTarget = workingTree || !review.pr ? "full branch" : `PR/MR #${review.pr.number}`;
-  return result2(launched.launched ? `Opened ${commandTarget} in tuicr (${launched.via}).` : launched.instruction ?? `Run: ${launched.command}`, { launched, pr: review.pr, target: commandTarget });
-}
 async function assertRemoteBranchReady(cwd) {
   const dirty = await runChecked("git", ["-C", cwd, "status", "--porcelain"]);
   if (dirty.stdout.trim())
@@ -3815,112 +2737,16 @@ 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";
-  if (review.pr.headSha)
-    return review.pr.headSha.slice(0, 12);
-  if (review.pr.headRef === review.vcs.branch)
-    return headSha(review.cwd);
-  const remote = await run("git", ["-C", review.cwd, "ls-remote", "origin", `refs/heads/${review.pr.headRef}`]);
-  return remote.stdout.trim().split(/\s+/)[0]?.slice(0, 12) || headSha(review.cwd);
-}
-async function headSha(cwd) {
-  const result = await runChecked("git", ["-C", cwd, "rev-parse", "--short=12", "HEAD"]);
-  return result.stdout.trim();
-}
-async function newReviewArtifactPath(cwd, target) {
-  const dir = await reviewsDir(cwd);
-  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 readFile14(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 stat2(path);
-        return { path, name, content: await readFile14(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 readdir5(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 = join17(dir, `${base}.md`);
-  let count = 2;
-  while (existsSync2(path))
-    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 z12 } from "zod";
-var setupParametersSchema = z12.object({
-  issueTracker: z12.enum(["none", "linear", "jira"]).default("none").describe("Issue tracker MCP server to configure. Use none unless the user explicitly selects Linear or Jira."),
-  forges: z12.array(z12.enum(["github", "gitlab"])).default([]).describe("Hosted VCS MCP servers to configure. Installs matching CLIs and registers each MCP server."),
-  forge: z12.enum(["none", "github", "gitlab"]).optional().describe("Deprecated single-host alias. Prefer forges for one or more VCS MCP servers."),
-  bindZedKey: z12.boolean().default(false).describe("Opt in to a Zed keybinding for the tuicr review task.")
+import { z as z11 } from "zod";
+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.")
 });
-var setupParameters = z12.toJSONSchema(setupParametersSchema, { io: "input" });
+var setupParameters = z11.toJSONSchema(setupParametersSchema, { io: "input" });
 var diffpiSetupTool = defineTool7({
   name: "diffpi_setup",
   label: "diffpi setup",
@@ -3940,7 +2766,6 @@ var diffpiSetupTool = defineTool7({
       issueTracker: params.issueTracker,
       forges: params.forges,
       forge: params.forge,
-      bindZedKey: params.bindZedKey,
       installMiseHook: true,
       availableModels: ctx.modelRegistry.getAvailable(),
       onProgress(message) {
@@ -3968,7 +2793,6 @@ var diffpiValidateTool = defineTool7({
       issueTracker: params.issueTracker,
       forges: params.forges,
       forge: params.forge,
-      bindZedKey: params.bindZedKey,
       installMiseHook: true,
       dryRun: true,
       availableModels: ctx.modelRegistry.getAvailable()
@@ -3993,11 +2817,11 @@ ${lines.join(`
 
 // src/tools/templates.ts
 import { defineTool as defineTool8 } from "@earendil-works/pi-coding-agent";
-import { z as z13 } from "zod";
-var templateSchema = z13.object({
-  name: z13.string().min(1),
-  variables: z13.record(z13.string(), z13.string()).optional(),
-  homeDir: z13.string().optional()
+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()
 });
 var diffpiTemplateTool = defineTool8({
   name: "diffpi_template",
@@ -4005,7 +2829,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: z13.toJSONSchema(templateSchema, { io: "input" }),
+  parameters: z12.toJSONSchema(templateSchema, { io: "input" }),
   executionMode: "parallel",
   async execute(_id, input) {
     const params = templateSchema.parse(input);