claude-plan-review 0.4.0 → 0.5.0

package/README.md

@@ -95,9 +95,12 @@ claude-plan-review init --global --published --runtime node   # pin --runtime to
 #   swap `--runtime node` for `--runtime bun` if the team standardises on Bun
 ```
 
-That single `init --global --published` does five things:
+That single `init --global --published` does these things:
 
 - writes the `ExitPlanMode` **hook** to `~/.claude/settings.json` (fires in **every** project);
+- writes the `EnterPlanMode` **context hook** to the same settings — it nudges Claude toward the
+  multi-document tree format as it starts planning, **without** touching plan-mode consent (it
+  makes no permission decision, so your approval to enter plan mode is untouched);
 - writes the **Stop-hook gate** to the same settings — it keeps Claude polling a tools-first
   review instead of ending its turn while your decision is still pending (see below);
 - installs the **`plan-review-multidoc` skill** to `~/.claude/skills/` (auto-triggers on large / sectioned plans);
@@ -126,7 +129,7 @@ Use `bun` or `node` interchangeably (or `bunx`/`npx claude-plan-review …` when
 
 | Command | What it does |
 | --- | --- |
-| `… cli.js init [dir] [--local] [--published] [--runtime bun\|node] [--no-skill] [--write-claude-md]` | Wire the `ExitPlanMode` hook + the Stop-hook gate, install the skill, register the MCP server |
+| `… cli.js init [dir] [--local] [--published] [--runtime bun\|node] [--no-skill] [--write-claude-md]` | Wire the `ExitPlanMode` hook + the `EnterPlanMode` context hook + the Stop-hook gate, install the skill, register the MCP server |
 | `… cli.js serve [port]` | Start the review server manually (default `4607`) |
 | `… cli.js stop` | Stop the running server |
 | `… cli.js channels` | Show storage-channel readiness (is `gh` installed / authed / `gist`-scoped?) |
@@ -246,13 +249,16 @@ the doc-tree format automatically whenever a plan is large or splits into sectio
 
 Plans no longer accumulate forever. From the UI you can:
 
-- **Delete a single version** — a per-version button with an in-app confirm.
+- **Delete a single version** — a per-version button. Deletes happen **immediately**
+  on click (no confirmation dialog).
 - **Bulk-delete / delete a whole project** — the manage modal (trash icon in the
-  header): tick versions and delete them, or remove the project entirely.
+  header): tick versions and delete them, or remove the project entirely — also immediate.
 
 Deleting the **last** version removes the project directory outright. A version with a
-**pending review** is protected: the delete returns `409` and the UI offers **Force**,
-which auto-rejects that review (telling Claude the plan was deleted) before removing it.
+**pending review** is protected: the delete is refused (`409` for a single version or
+project; a non-empty `blocked` list for a bulk delete) and the UI then pops a dialog
+offering **Force**, which auto-rejects the review (telling Claude the plan was deleted)
+before removing it. That blocked/Force dialog is the only confirmation step that remains.
 
 ## Storage layout
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-plan-review",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Review, comment on, and approve/reject Claude Code plans in a local GitHub-style web UI — with persistent comments, version history, and diffs.",
   "type": "module",
   "bin": {

package/skill/SKILL.md

@@ -41,6 +41,10 @@ Rules:
 - Marker lines inside fenced code blocks (```` ``` ````/`~~~`) are ignored — you can
   show marker examples in code fences safely.
 
+> An `EnterPlanMode` PreToolUse hook (installed by `init`) injects a short reminder of
+> this marker format as you start planning — it only adds context and never affects
+> your consent to enter plan mode. This skill is the full reference behind that nudge.
+
 ## Path A — in plan mode (preferred when you're already planning)
 
 Put the **whole tree in the single ExitPlanMode plan string**, using the markers

package/src/cli.js

@@ -16,9 +16,21 @@ import { DEFAULT_PORT, SERVER_FILE } from "./paths.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
 const HOOK_SCRIPT = join(HERE, "hook.js");
 const STOP_GATE_SCRIPT = join(HERE, "stop-gate.js");
+const PLAN_CONTEXT_SCRIPT = join(HERE, "plan-context.js");
 const CLI_SCRIPT = fileURLToPath(import.meta.url);
 const SKILL_SRC = join(HERE, "..", "skill", "SKILL.md");
 
+// A hook command "belongs to" plan-review when it invokes one of our entrypoints,
+// regardless of prefix (env vars) or runner (node/bun/npx/bunx). Robust dedup:
+// treat `PLAN_REVIEW_TIMEOUT=… npx claude-plan-review hook`, `bunx claude-plan-review hook`,
+// and `node /abs/path/hook.js` all as the same existing hook.
+//   kind: "hook" | "stop-gate" | "plan-context"
+function isPlanReviewHook(command, kind) {
+  if (!command) return false;
+  const scriptFile = { hook: "hook.js", "stop-gate": "stop-gate.js", "plan-context": "plan-context.js" }[kind];
+  return command.includes(`claude-plan-review ${kind}`) || (!!scriptFile && command.includes(scriptFile));
+}
+
 function canRun(bin) {
   try {
     return spawnSync(bin, ["--version"], { stdio: "ignore" }).status === 0;
@@ -75,6 +87,20 @@ function stopGateCommand(args) {
   return `${resolveBin(runtime)} ${STOP_GATE_SCRIPT}`;
 }
 
+// The EnterPlanMode context-injection hook command, mirroring hookCommand's
+// runtime routing: global/published installs go through the package runner
+// (npx/bunx) so they resolve in Claude Code's non-interactive env; a local
+// install points straight at plan-context.js (which runs on import).
+function planContextCommand(args) {
+  const runtime = chooseRuntime(args);
+  if (args.includes("--global") || args.includes("--published") || args.includes("--bunx")) {
+    return runtime === "node"
+      ? "npx claude-plan-review plan-context"
+      : "bunx claude-plan-review plan-context";
+  }
+  return `${resolveBin(runtime)} ${PLAN_CONTEXT_SCRIPT}`;
+}
+
 // The program + args that launch the MCP server, mirroring hookCommand's
 // runtime routing: global/published installs go through the package runner
 // (npx/bunx) so they resolve in Claude Code's non-interactive env; a local
@@ -165,6 +191,39 @@ function readJSON(path, fallback) {
   }
 }
 
+// Warn if a plan-review ExitPlanMode hook is ALSO configured in another settings
+// scope we know about (global + project settings.json + project settings.local.json).
+// Two entries in different scopes both fire for one plan-mode exit → the review
+// opens twice. `justWrote` is the scope init targeted this run (skip it).
+function warnOtherScopes(justWrote, global, dirArg) {
+  const projectRoot = resolve(dirArg || process.cwd());
+  const scopes = [
+    join(homedir(), ".claude", "settings.json"),
+    join(projectRoot, ".claude", "settings.json"),
+    join(projectRoot, ".claude", "settings.local.json"),
+  ];
+  const seen = new Set([resolve(justWrote)]);
+  for (const file of scopes) {
+    const abs = resolve(file);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    if (!existsSync(abs)) continue;
+    const s = readJSON(abs, null);
+    const entries = s?.hooks?.PreToolUse || [];
+    const hasHook = entries.some(
+      (entry) =>
+        entry?.matcher === "ExitPlanMode" &&
+        (entry.hooks || []).some((h) => isPlanReviewHook(h?.command, "hook")),
+    );
+    if (hasHook) {
+      console.log(
+        `\n⚠ WARNING: plan review hook also configured in ${abs} — multiple entries open the review multiple times.\n` +
+          `  Remove the ExitPlanMode plan-review hook from one of the scopes.`,
+      );
+    }
+  }
+}
+
 function cmdInit(args) {
   const global = args.includes("--global");
   const local = args.includes("--local");
@@ -183,7 +242,7 @@ function cmdInit(args) {
   const already = settings.hooks.PreToolUse.some(
     (entry) =>
       entry?.matcher === "ExitPlanMode" &&
-      (entry.hooks || []).some((h) => h?.command?.includes("hook.js") || h?.command === command),
+      (entry.hooks || []).some((h) => isPlanReviewHook(h?.command, "hook")),
   );
 
   if (already) {
@@ -197,13 +256,30 @@ function cmdInit(args) {
     console.log(`✓ Wrote ExitPlanMode plan-review hook to ${settingsFile}`);
   }
 
+  // EnterPlanMode context-injection hook: nudges Claude toward the multi-doc
+  // tree format as it starts planning. Never makes a permission decision.
+  const planContextCmd = planContextCommand(args);
+  const pcAlready = settings.hooks.PreToolUse.some(
+    (entry) =>
+      entry?.matcher === "EnterPlanMode" &&
+      (entry.hooks || []).some((h) => isPlanReviewHook(h?.command, "plan-context")),
+  );
+  if (pcAlready) {
+    console.log(`✓ EnterPlanMode plan-context hook already present in ${settingsFile}`);
+  } else {
+    settings.hooks.PreToolUse.push({
+      matcher: "EnterPlanMode",
+      hooks: [{ type: "command", command: planContextCmd, timeout: 10 }],
+    });
+    writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`✓ Wrote EnterPlanMode plan-context hook to ${settingsFile}`);
+  }
+
   // Stop-hook gate: blocks the turn from ending while a tools-first (mcp/api)
   // review is still pending. Matcher-less (Stop has no tool matcher).
   const stopCommand = stopGateCommand(args);
   const stopAlready = settings.hooks.Stop.some((entry) =>
-    (entry.hooks || []).some(
-      (h) => h?.command?.includes("stop-gate") || h?.command === stopCommand,
-    ),
+    (entry.hooks || []).some((h) => isPlanReviewHook(h?.command, "stop-gate")),
   );
   if (stopAlready) {
     console.log(`✓ Stop plan-review gate already present in ${settingsFile}`);
@@ -215,8 +291,13 @@ function cmdInit(args) {
     console.log(`✓ Wrote Stop plan-review gate to ${settingsFile}`);
   }
 
+  // Cross-scope warning: multiple ExitPlanMode plan-review hooks (across global /
+  // project / project-local settings) each fire for one plan-mode exit and open
+  // the review that many times. Scan the OTHER known scopes and warn.
+  warnOtherScopes(settingsFile, global, dirArg);
+
   console.log(
-    `\nRuntime: ${chooseRuntime(args)}\nHook:    ${command}\nStop:    ${stopCommand}`,
+    `\nRuntime: ${chooseRuntime(args)}\nHook:    ${command}\nPlanCtx: ${planContextCmd}\nStop:    ${stopCommand}`,
   );
 
   // Skill: auto-triggers the multi-document plan authoring in every project.
@@ -311,9 +392,9 @@ function usage() {
 Usage:
   claude-plan-review init [dir] [--global] [--local] [--published] [--runtime bun|node]
                                   [--no-skill] [--write-claude-md]
-                                  Wire the ExitPlanMode hook + the Stop-hook gate into a project
-                                  (or all projects), install the plan-review-multidoc skill, and
-                                  register the MCP server.
+                                  Wire the ExitPlanMode hook + the EnterPlanMode context hook +
+                                  the Stop-hook gate into a project (or all projects), install the
+                                  plan-review-multidoc skill, and register the MCP server.
                                   Runtime auto-detects (Bun if installed, else Node).
                                   --global         → ~/.claude/settings.json (applies to ALL projects)
                                   --local          → .claude/settings.local.json
@@ -326,7 +407,8 @@ Usage:
   claude-plan-review channels     Show storage-channel readiness (e.g. gh / gist)
   claude-plan-review skill        (Re)install the plan-review-multidoc skill into ~/.claude/skills
   claude-plan-review mcp          (internal) run the stdio MCP server (plan_review_* tools)
-  claude-plan-review hook         (internal) the PreToolUse hook entry
+  claude-plan-review hook         (internal) the PreToolUse hook entry (ExitPlanMode → review)
+  claude-plan-review plan-context (internal) the PreToolUse hook entry (EnterPlanMode → multi-doc guidance)
   claude-plan-review stop-gate    (internal) the Stop hook entry (blocks on a pending tools-first review)
 `);
 }
@@ -359,6 +441,9 @@ switch (sub) {
   case "stop-gate":
     await import("./stop-gate.js");
     break;
+  case "plan-context":
+    await import("./plan-context.js");
+    break;
   default:
     usage();
 }

package/src/hook.js

@@ -156,13 +156,18 @@ async function main() {
   } catch {
     process.exit(0); // store failure → don't interfere
   }
-  const { key, version, reviewId } = recorded;
+  const { key, version, reviewId, reused } = recorded;
 
   const port = await ensureServer();
   const reviewUrl = `http://localhost:${port}/?project=${encodeURIComponent(
     key,
   )}&version=${version}&review=${reviewId}&doc=root`;
-  openBrowser(reviewUrl);
+  // When a duplicate hook invocation (a second entry in another settings scope)
+  // fired for the SAME ExitPlanMode call, recordPlan reports `reused` — the first
+  // invocation already opened the browser, so we must NOT open it again. We still
+  // ensure the server is up and poll the shared review, so both processes return
+  // the same decision. (Fail-open invariant preserved.)
+  if (!reused) openBrowser(reviewUrl);
 
   // block until the UI resolves the review (or we time out)
   const deadline = Date.now() + TIMEOUT_MS;

package/src/plan-context.js

@@ -0,0 +1,63 @@
+/**
+ * Claude Code PreToolUse hook for the EnterPlanMode tool. Runs on Bun or Node ≥18.
+ *
+ * Injects the multi-document authoring guidance as `additionalContext` so Claude
+ * reaches for the doc-tree format when a plan is large — WITHOUT making a
+ * permission decision.
+ *
+ * CRITICAL: EnterPlanMode is permission-gated and the user's consent to enter
+ * plan mode MUST survive this hook. Per the Claude Code hooks doc
+ * (https://code.claude.com/docs/en/hooks), a PreToolUse hook may return
+ * `additionalContext` inside `hookSpecificOutput` on its own; the valid
+ * `permissionDecision` values are "allow" / "deny" / "ask", and OMITTING the
+ * field leaves the normal permission flow untouched. We therefore emit NO
+ * permissionDecision — only additionalContext — so nothing auto-approves or
+ * denies entering plan mode.
+ *
+ * Fail open (exit 0 silently) on any error, and on any non-EnterPlanMode tool.
+ *
+ *   stdin  = { tool_name:"EnterPlanMode", tool_input:{…}, cwd, session_id, ... }
+ *   stdout = { hookSpecificOutput:{ hookEventName:"PreToolUse", additionalContext } }
+ */
+import { readFileSync } from "node:fs";
+
+const CONTEXT = [
+  "Plan-review tip: when the plan you're about to write is large, multi-part, or",
+  "splits into several sections/areas, author it as a navigable TREE OF DOCUMENTS",
+  "instead of one long markdown blob. Put one marker per document, each alone on",
+  'its own line: <!--doc slug=<kebab-case> title="…" parent=<parent-slug>-->.',
+  "Exactly one root doc (omit `parent`); every child sets `parent` to its parent's",
+  "slug; cross-link docs with [[slug]]. A small, single-topic plan needs none of",
+  "this — write it as plain markdown with no markers. See the plan-review-multidoc",
+  "skill for the full syntax and rules.",
+].join(" ");
+
+function main() {
+  let input = {};
+  try {
+    input = JSON.parse(readFileSync(0, "utf8")); // fd 0 = stdin (node + bun)
+  } catch {
+    process.exit(0); // unparseable stdin → don't interfere
+  }
+
+  // Only act on EnterPlanMode; anything else passes through untouched.
+  if (input.tool_name !== "EnterPlanMode") process.exit(0);
+
+  try {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          // NO permissionDecision → the user's consent prompt for plan mode
+          // stays intact; we only add context.
+          additionalContext: CONTEXT,
+        },
+      }),
+    );
+  } catch {
+    /* non-fatal — fail open */
+  }
+  process.exit(0);
+}
+
+main();

package/src/store.js

@@ -1,9 +1,12 @@
 import { createHash, randomBytes } from "node:crypto";
 import {
+  closeSync,
   mkdirSync,
+  openSync,
   readdirSync,
   readFileSync,
   writeFileSync,
+  writeSync,
   existsSync,
   rmSync,
 } from "node:fs";
@@ -49,6 +52,28 @@ const versionMeta = (key, n) => join(projectDir(key), "versions", `${pad(n)}.jso
 const commentsPath = (key, n) => join(projectDir(key), "comments", `${pad(n)}.json`);
 const reviewPath = (id) => join(REVIEWS_DIR, `${id}.json`);
 
+// ---------- double-fire dedup (one ExitPlanMode call → one review) ----------
+// Two hook entries in different settings scopes can both fire for the SAME
+// ExitPlanMode tool call; they arrive with an identical tool_use_id. We serialize
+// them with an exclusive-create marker file keyed by tool_use_id: the first
+// process to create the marker "wins" and records the review, writing its id back
+// into the marker; concurrent losers read that id and reuse the review instead of
+// creating a duplicate. The marker uses a NON-.json extension so it's invisible to
+// listReviews() (which globs *.json). Fail-open: any error skips dedup.
+const toolUseMarkerPath = (id) =>
+  join(REVIEWS_DIR, `tooluse-${String(id).replace(/[^a-zA-Z0-9_-]/g, "_")}.lock`);
+
+/** Synchronous sleep (recordPlan is sync, called from the blocking hook). */
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    // SharedArrayBuffer unavailable → best-effort busy wait
+    const end = Date.now() + ms;
+    while (Date.now() < end) {}
+  }
+}
+
 // ---------- projects / versions ----------
 export function getProjectMeta(key) {
   return existsSync(metaPath(key)) ? readJSON(metaPath(key), null) : null;
@@ -104,6 +129,31 @@ function writeTree(key, version, tree) {
 export function recordPlan(opts) {
   const key = projectKey(opts.cwd);
   ensureDirs(key);
+
+  // Double-fire dedup: if another invocation with the same tool_use_id is already
+  // in flight (or done), reuse its review rather than creating a second one.
+  let markerFd = null;
+  const markerFile = opts.toolUseId ? toolUseMarkerPath(opts.toolUseId) : null;
+  if (markerFile) {
+    try {
+      markerFd = openSync(markerFile, "wx"); // atomic exclusive create — we won the race
+    } catch (e) {
+      if (e && e.code === "EEXIST") {
+        // Someone else is recording (or has recorded) this tool call. Wait for
+        // them to publish the reviewId, then reuse it.
+        for (let i = 0; i < 120; i++) {
+          const m = readJSON(markerFile, null);
+          if (m && m.reviewId && existsSync(reviewPath(m.reviewId))) {
+            return { key, version: m.version, reviewId: m.reviewId, reused: true };
+          }
+          sleepSync(50);
+        }
+        // Winner never published (crashed mid-write) → fall through and record our own.
+      }
+      // Any other error → skip dedup, record normally.
+    }
+  }
+
   const tree =
     opts.tree ?? { kind: "single", markdown: opts.plan != null ? opts.plan : "" };
   const hash = hashTree(tree);
@@ -166,7 +216,19 @@ export function recordPlan(opts) {
       createdAt: now(),
     }),
   );
-  return { key, version, reviewId };
+
+  // Publish the reviewId into the marker so any concurrent duplicate invocation
+  // reuses it instead of creating a second review.
+  if (markerFd !== null) {
+    try {
+      writeSync(markerFd, JSON.stringify({ toolUseId: opts.toolUseId, key, version, reviewId }));
+    } catch {}
+    try {
+      closeSync(markerFd);
+    } catch {}
+  }
+
+  return { key, version, reviewId, reused: false };
 }
 
 export function listProjects() {

package/src/ui/app.js

@@ -803,28 +803,32 @@ async function doSave() {
 }
 
 // ---------- deletion ----------
-function showDeleteModal(title, desc) {
-  $("deleteTitle").textContent = title;
-  $("deleteDesc").textContent = desc;
-  $("deletePending").hidden = true;
-  $("deletePending").textContent = "";
-  $("deleteForce").hidden = true;
-  $("deleteConfirm").hidden = false;
-  $("deleteConfirm").disabled = false;
+// Deletes happen IMMEDIATELY on click — no confirmation modal. The modal appears
+// ONLY when a delete is blocked by a pending review (409 for single/project, or a
+// non-empty `blocked` array for bulk): it shows the blocked info + a Force option.
+function deleteTitleFor(pd) {
+  if (pd.type === "version") return `Couldn't delete v${pd.n}`;
+  if (pd.type === "project") return `Couldn't delete “${projNameByKey(pd.key)}”`;
+  return "Couldn't delete every selected version";
+}
+
+// Open the blocked/Force modal (the only remaining modal interaction).
+function openBlockedModal(pd) {
+  $("deleteTitle").textContent = deleteTitleFor(pd);
+  $("deleteDesc").textContent = "";
+  $("deleteForce").hidden = false;
   $("deleteForce").disabled = false;
   $("deleteModal").hidden = false;
 }
 
-function openDeleteVersion() {
+function deleteVersionNow() {
   if (!state.version) return;
   state.pendingDelete = { type: "version", key: state.key, n: state.version };
-  showDeleteModal(
-    `Delete v${state.version}?`,
-    `This permanently removes v${state.version} of “${projectName()}” and its comments. This can't be undone.`,
-  );
+  performDelete(false);
 }
 
 function showDeleteBlocked(e) {
+  openBlockedModal(state.pendingDelete);
   const revs = e.pendingReviews || [];
   const info = $("deletePending");
   info.hidden = false;
@@ -832,14 +836,13 @@ function showDeleteBlocked(e) {
   info.textContent =
     `Blocked: ${revs.length || "a"} pending review${many ? "s" : ""} still awaiting a decision. ` +
     `Force will auto-reject ${many ? "them" : "it"} (Claude is told the plan was deleted and to re-present or ask how to proceed), then delete.`;
-  $("deleteForce").hidden = false;
-  $("deleteConfirm").hidden = true;
 }
 
 // bulk-delete is always 200 with partial-success {deleted,blocked,meta}; render
 // the blocked versions (+ their pending reviews) and offer a Force retry for
 // just those. Single-version / project DELETE stay 409-on-block (showDeleteBlocked).
 function showBulkBlocked(blocked, deleted) {
+  openBlockedModal(state.pendingDelete);
   const info = $("deletePending");
   info.hidden = false;
   const ns = blocked.map((b) => b.n);
@@ -850,9 +853,6 @@ function showBulkBlocked(blocked, deleted) {
     `${delMsg}Blocked: v${ns.join(", v")} — ${totalPending || "a"} pending review${many ? "s" : ""} ` +
     `still awaiting a decision. Force will auto-reject ${many ? "them" : "it"} (Claude is told the plan ` +
     `was deleted and to re-present or ask how to proceed) and delete the remaining ${ns.length} version${ns.length === 1 ? "" : "s"}.`;
-  $("deleteForce").hidden = false;
-  $("deleteForce").disabled = false;
-  $("deleteConfirm").hidden = true;
 }
 
 async function finishDelete(pd, msg) {
@@ -864,12 +864,10 @@ async function finishDelete(pd, msg) {
   if (wasManage && !$("manageModal").hidden) await renderManage();
 }
 
-async function confirmDelete(force) {
+async function performDelete(force) {
   const pd = state.pendingDelete;
   if (!pd) return;
-  const bconfirm = $("deleteConfirm");
   const bforce = $("deleteForce");
-  bconfirm.disabled = true;
   bforce.disabled = true;
   const f = force ? "true" : "";
   try {
@@ -903,7 +901,6 @@ async function confirmDelete(force) {
     if (e.status === 409) showDeleteBlocked(e); // version / project block
     else {
       toast("Delete failed: " + e.message);
-      bconfirm.disabled = false;
       bforce.disabled = false;
     }
   }
@@ -1109,8 +1106,8 @@ function wireUI() {
     await resolve("reject");
   };
 
-  // deletion + manage
-  $("deleteVerBtn").onclick = () => openDeleteVersion();
+  // deletion + manage — delete fires immediately; the modal is blocked-only
+  $("deleteVerBtn").onclick = () => deleteVersionNow();
   $("deleteCancel").onclick = async () => {
     const pd = state.pendingDelete;
     $("deleteModal").hidden = true;
@@ -1121,8 +1118,7 @@ function wireUI() {
       if (!$("manageModal").hidden) await renderManage();
     }
   };
-  $("deleteConfirm").onclick = () => confirmDelete(false);
-  $("deleteForce").onclick = () => confirmDelete(true);
+  $("deleteForce").onclick = () => performDelete(true);
 
   $("manageBtn").onclick = () => openManageModal();
   $("manageClose").onclick = () => ($("manageModal").hidden = true);
@@ -1132,10 +1128,7 @@ function wireUI() {
     const key = btn.dataset.key;
     if (btn.dataset.mg === "delproj") {
       state.pendingDelete = { type: "project", key, fromManage: true };
-      showDeleteModal(
-        `Delete project “${projNameByKey(key)}”?`,
-        `Permanently removes the project and all its versions, comments and reviews. This can't be undone.`,
-      );
+      performDelete(false);
     } else if (btn.dataset.mg === "delsel") {
       const ns = [...$("manageList").querySelectorAll('input[type="checkbox"]:checked')]
         .filter((x) => x.dataset.key === key)
@@ -1145,10 +1138,7 @@ function wireUI() {
         return;
       }
       state.pendingDelete = { type: "bulk", key, ns, fromManage: true };
-      showDeleteModal(
-        `Delete ${ns.length} version${ns.length === 1 ? "" : "s"} of “${projNameByKey(key)}”?`,
-        `Permanently removes v${ns.join(", v")} and their comments. This can't be undone.`,
-      );
+      performDelete(false);
     }
   });
 }

package/src/ui/index.html

@@ -127,7 +127,6 @@
       <div class="pendingInfo" id="deletePending" hidden></div>
       <div class="row">
         <button class="btn" id="deleteCancel">Cancel</button>
-        <button class="btn reject" id="deleteConfirm">Delete</button>
         <button class="btn reject" id="deleteForce" hidden>Force delete</button>
       </div>
     </div>