mulmoclaude 0.5.2 → 0.6.0

package/server/workspace/tool-trace/writeSearch.ts

@@ -11,6 +11,7 @@ import path from "node:path";
 import { createHash } from "node:crypto";
 import { slugify } from "../../utils/slug.js";
 import { toUtcIsoDate } from "../../utils/date.js";
+import { writeFileAtomic } from "../../utils/files/atomic.js";
 import { WORKSPACE_DIRS } from "../paths.js";
 
 export const SEARCHES_DIR = WORKSPACE_DIRS.searches;
@@ -87,7 +88,11 @@ const defaultDeps: WriteSearchDeps = {
   mkdir: async (dir) => {
     await fsp.mkdir(dir, { recursive: true });
   },
-  writeFile: (filePath, content) => fsp.writeFile(filePath, content, "utf-8"),
+  // Atomic write so a crash mid-flight can't leave a half-written
+  // search markdown that the jsonl `contentRef` then points at
+  // (#881 v2). Tests inject their own adapter so behaviour stays
+  // mockable.
+  writeFile: (filePath, content) => writeFileAtomic(filePath, content),
 };
 
 /**

package/server/workspace/wiki-backlinks/index.ts

@@ -21,6 +21,7 @@ import { workspacePath as defaultWorkspacePath } from "../workspace.js";
 import { WORKSPACE_DIRS } from "../paths.js";
 import { log } from "../../system/logger/index.js";
 import { updateSessionBacklinks } from "./sessionBacklinks.js";
+import { writeWikiPage } from "../wiki-pages/io.js";
 import { ONE_SECOND_MS } from "../../utils/time.js";
 
 // Small tolerance for filesystem mtime granularity (some filesystems
@@ -35,12 +36,23 @@ export interface WikiBacklinksDeps {
   writeFile: (filePath: string, content: string) => Promise<void>;
 }
 
-const defaultDeps: WikiBacklinksDeps = {
-  readdir: (dir) => fsp.readdir(dir),
-  stat: (filePath) => fsp.stat(filePath),
-  readFile: (filePath) => fsp.readFile(filePath, "utf-8"),
-  writeFile: (filePath, content) => fsp.writeFile(filePath, content, "utf-8"),
-};
+// Default writers funnel through `writeWikiPage` so the backlink
+// append participates in the same atomic-write + history pipeline
+// as user / LLM edits. Pre-#763 this was a non-atomic
+// `fsp.writeFile` and the call could leave a half-written page on
+// crash. Editor identity is `"system"` so PR 2's snapshot view can
+// distinguish automated edits from human / LLM ones.
+function buildDefaultDeps(workspaceRoot: string, sessionId: string): WikiBacklinksDeps {
+  return {
+    readdir: (dir) => fsp.readdir(dir),
+    stat: (filePath) => fsp.stat(filePath),
+    readFile: (filePath) => fsp.readFile(filePath, "utf-8"),
+    writeFile: async (filePath, content) => {
+      const slug = path.basename(filePath, ".md");
+      await writeWikiPage(slug, content, { editor: "system", sessionId }, { workspaceRoot });
+    },
+  };
+}
 
 export interface MaybeAppendWikiBacklinksOptions {
   chatSessionId: string;
@@ -52,7 +64,7 @@ export interface MaybeAppendWikiBacklinksOptions {
 export async function maybeAppendWikiBacklinks(opts: MaybeAppendWikiBacklinksOptions): Promise<void> {
   if (!opts.chatSessionId) return;
   const workspaceRoot = opts.workspaceRoot ?? defaultWorkspacePath;
-  const deps: WikiBacklinksDeps = { ...defaultDeps, ...(opts.deps ?? {}) };
+  const deps: WikiBacklinksDeps = { ...buildDefaultDeps(workspaceRoot, opts.chatSessionId), ...(opts.deps ?? {}) };
   const pagesDir = path.join(workspaceRoot, WORKSPACE_DIRS.wikiPages);
 
   const files = await listPageFiles(pagesDir, deps);

package/server/workspace/wiki-backlinks/sessionBacklinks.ts

@@ -113,6 +113,7 @@ function extractSessionIdFromHref(href: string): string | null {
 function stripFragmentAndQuery(href: string): string {
   let end = href.length;
   const hash = href.indexOf("#");
+  // eslint-disable-next-line security/detect-possible-timing-attacks -- numeric indexOf check, not a credential compare
   if (hash !== -1) end = hash;
   const query = href.indexOf("?");
   if (query !== -1 && query < end) end = query;

package/server/workspace/wiki-history/hook/snapshot.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+// server/workspace/wiki-history/hook/snapshot.ts
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path2 from "node:path";
+
+// src/lib/wiki-page/slug.ts
+import path from "node:path";
+function isSafeSlug(slug) {
+  if (slug.length === 0) return false;
+  if (slug === "." || slug === "..") return false;
+  if (slug.includes("/") || slug.includes("\\")) return false;
+  if (slug.includes("\0")) return false;
+  return true;
+}
+function wikiSlugFromAbsPath(absPath, pagesDir) {
+  const rel = path.relative(pagesDir, absPath);
+  if (rel.length === 0) return null;
+  if (path.isAbsolute(rel)) return null;
+  if (rel.includes(path.sep)) return null;
+  if (!rel.endsWith(".md")) return null;
+  const slug = rel.slice(0, -".md".length);
+  if (!isSafeSlug(slug)) return null;
+  return slug;
+}
+
+// server/workspace/wiki-history/hook/snapshot.ts
+var WORKSPACE_ROOT = path2.join(homedir(), "mulmoclaude");
+var WIKI_PAGES_DIR = path2.join(WORKSPACE_ROOT, "data", "wiki", "pages");
+var TOKEN_PATH = path2.join(WORKSPACE_ROOT, ".session-token");
+var PORT_PATH = path2.join(WORKSPACE_ROOT, ".server-port");
+var SERVER_HOST = process.env.MULMOCLAUDE_HOST ?? "127.0.0.1";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8");
+  if (!raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function extractFilePath(payload) {
+  const fromInput = payload.tool_input?.file_path;
+  if (typeof fromInput === "string") return fromInput;
+  const fromResponse = payload.tool_response?.filePath;
+  if (typeof fromResponse === "string") return fromResponse;
+  return null;
+}
+function readTokenSafe() {
+  try {
+    return readFileSync(TOKEN_PATH, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function readPortSafe() {
+  try {
+    const raw = readFileSync(PORT_PATH, "utf-8").trim();
+    const port = Number.parseInt(raw, 10);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+  } catch {
+    return null;
+  }
+}
+async function main() {
+  const payload = await readStdin();
+  if (!payload) return;
+  const filePath = extractFilePath(payload);
+  if (!filePath) return;
+  const slug = wikiSlugFromAbsPath(filePath, WIKI_PAGES_DIR);
+  if (slug === null) return;
+  const token = readTokenSafe();
+  const port = readPortSafe();
+  if (!token || port === null) return;
+  const envChatSessionId = process.env.MULMOCLAUDE_CHAT_SESSION_ID;
+  const payloadSessionId = typeof payload.session_id === "string" && payload.session_id.length > 0 ? payload.session_id : void 0;
+  const sessionId = envChatSessionId && envChatSessionId.length > 0 ? envChatSessionId : payloadSessionId;
+  const body = sessionId === void 0 ? { slug } : { slug, sessionId };
+  try {
+    await fetch(`http://${SERVER_HOST}:${port}/api/wiki/internal/snapshot`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    });
+  } catch {
+  }
+}
+main().catch(() => {
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["snapshot.ts", "../../../../src/lib/wiki-page/slug.ts"],
  "sourcesContent": ["// PostToolUse hook source \u2014 runs after every Claude CLI Write /\n// Edit tool call. Detects writes that target a wiki page file\n// and POSTs `{ slug, sessionId? }` to the parent server's\n// `/api/wiki/internal/snapshot` endpoint so the snapshot pipeline\n// (#763 PR 2) records the new state.\n//\n// THIS FILE IS THE SOURCE OF TRUTH. Edits here, then run\n// `yarn build:hooks` (or `yarn build`) to regenerate\n// `./snapshot.mjs`. The bundled `.mjs` is committed to git so\n// `provision.ts` can read it at server startup without invoking\n// esbuild on the runtime path. CI runs `yarn build:hooks &&\n// git diff --exit-code` to catch a stale bundle.\n//\n// The hook executes inside Claude CLI's process space \u2014 must be\n// self-contained ESM. esbuild bundles imports from the shared\n// `src/lib/wiki-page/slug.ts` module so the hook and the\n// server-side `classifyAsWikiPage` agree on what counts as a\n// wiki page (no copy-paste drift).\n\nimport { readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport path from \"node:path\";\nimport { wikiSlugFromAbsPath } from \"../../../../src/lib/wiki-page/slug.js\";\n\n// Workspace layout matches `WORKSPACE_DIRS.wikiPages`. We hard-\n// code \"data/wiki/pages\" rather than importing the constants\n// because the hook needs to stay independent of the server's\n// runtime config \u2014 the bundle must work even when the server\n// process isn't running yet (e.g. during a startup race).\nconst WORKSPACE_ROOT = path.join(homedir(), \"mulmoclaude\");\nconst WIKI_PAGES_DIR = path.join(WORKSPACE_ROOT, \"data\", \"wiki\", \"pages\");\nconst TOKEN_PATH = path.join(WORKSPACE_ROOT, \".session-token\");\nconst PORT_PATH = path.join(WORKSPACE_ROOT, \".server-port\");\n// In Docker mode the parent server runs on the host's 127.0.0.1\n// which the container can't reach via plain loopback. The Docker\n// spawn plumbing sets MULMOCLAUDE_HOST=host.docker.internal so\n// fetch() resolves to the host server. Outside Docker (or when\n// the var is unset) we fall back to the loopback address.\nconst SERVER_HOST = process.env.MULMOCLAUDE_HOST ?? \"127.0.0.1\";\n\ninterface HookPayload {\n  tool_input?: { file_path?: unknown };\n  tool_response?: { filePath?: unknown };\n  session_id?: unknown;\n}\n\nasync function readStdin(): Promise<HookPayload | null> {\n  const chunks: Buffer[] = [];\n  for await (const chunk of process.stdin) {\n    chunks.push(typeof chunk === \"string\" ? Buffer.from(chunk) : chunk);\n  }\n  const raw = Buffer.concat(chunks).toString(\"utf-8\");\n  if (!raw.trim()) return null;\n  try {\n    return JSON.parse(raw) as HookPayload;\n  } catch {\n    return null;\n  }\n}\n\nfunction extractFilePath(payload: HookPayload): string | null {\n  // Claude CLI hook payload: { tool_name, tool_input, tool_response, ... }\n  // Different tools surface the path under different keys \u2014\n  // check both shapes defensively.\n  const fromInput = payload.tool_input?.file_path;\n  if (typeof fromInput === \"string\") return fromInput;\n  const fromResponse = payload.tool_response?.filePath;\n  if (typeof fromResponse === \"string\") return fromResponse;\n  return null;\n}\n\nfunction readTokenSafe(): string {\n  try {\n    return readFileSync(TOKEN_PATH, \"utf-8\").trim();\n  } catch {\n    return \"\";\n  }\n}\n\nfunction readPortSafe(): number | null {\n  try {\n    const raw = readFileSync(PORT_PATH, \"utf-8\").trim();\n    const port = Number.parseInt(raw, 10);\n    return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;\n  } catch {\n    return null;\n  }\n}\n\nasync function main(): Promise<void> {\n  const payload = await readStdin();\n  if (!payload) return;\n\n  const filePath = extractFilePath(payload);\n  if (!filePath) return;\n  const slug = wikiSlugFromAbsPath(filePath, WIKI_PAGES_DIR);\n  if (slug === null) return;\n\n  const token = readTokenSafe();\n  const port = readPortSafe();\n  if (!token || port === null) return; // server isn't reachable; silent no-op\n\n  // Prefer our chat-session id from the spawn env (#963) \u2014 the\n  // server's session store keys by chatSessionId, not by Claude\n  // CLI's internal session_id, so the toolResult publish on the\n  // server side only matches when we forward our own id. Fall back\n  // to Claude CLI's `session_id` (still useful as a tracing token\n  // in the snapshot frontmatter) when the env var is absent \u2014 e.g.\n  // an older mulmoclaude server spawning a newer hook bundle.\n  const envChatSessionId = process.env.MULMOCLAUDE_CHAT_SESSION_ID;\n  const payloadSessionId = typeof payload.session_id === \"string\" && payload.session_id.length > 0 ? payload.session_id : undefined;\n  const sessionId = envChatSessionId && envChatSessionId.length > 0 ? envChatSessionId : payloadSessionId;\n  const body = sessionId === undefined ? { slug } : { slug, sessionId };\n\n  try {\n    await fetch(`http://${SERVER_HOST}:${port}/api/wiki/internal/snapshot`, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"application/json\",\n        Authorization: `Bearer ${token}`,\n      },\n      body: JSON.stringify(body),\n    });\n  } catch {\n    // Network / server down \u2014 drop silently. The wiki page write\n    // itself already succeeded; missing one snapshot is recoverable\n    // (the next save will record the next state).\n  }\n}\n\nmain().catch(() => {\n  // Hooks run synchronously to the LLM tool flow \u2014 never throw.\n  // A busted hook would make `Write` itself look like it failed\n  // to the LLM, which is much worse than a missing snapshot.\n});\n", "// Shared wiki-page slug logic \u2014 pure functions reused by:\n//\n//   - server/workspace/wiki-pages/io.ts (the write chokepoint)\n//   - server/workspace/wiki-history/hook/snapshot.ts (the\n//     PostToolUse hook script that detects LLM Write/Edit on a\n//     wiki page and triggers a snapshot)\n//\n// Both call sites need the same answer: \"given this absolute\n// path and the pages directory, is it a wiki page, and if so\n// what slug?\". Before the extraction the hook re-implemented\n// the rules as a JS-as-string template literal that drifted\n// from the server-side logic \u2014 see #951's discussion of how to\n// stop copying #lint logic between hook and server.\n//\n// Only `node:path` is allowed here so esbuild can bundle this\n// file into the hook script (no Node-specific server-side\n// imports leak into the bundle).\n\nimport path from \"node:path\";\n\n/** Reject slugs that would escape `data/wiki/pages/` once\n *  joined back into a path, or that are otherwise invalid as\n *  page filenames. The chokepoint must defend itself even when\n *  callers derive the slug from a trusted source \u2014 a typo or\n *  future caller mistake should fail loud, not silently write\n *  outside the wiki tree.\n *\n *  The rule is intentionally narrow \u2014 separators / `..` / NUL /\n *  empty \u2014 so it only rejects unambiguous violations. Aesthetic\n *  concerns (e.g. dot-prefixed filenames) are out of scope: a\n *  pre-existing `data/wiki/pages/.foo.md` should remain writable\n *  through the chokepoint (codex review iter-2 #883). */\nexport function isSafeSlug(slug: string): boolean {\n  if (slug.length === 0) return false;\n  if (slug === \".\" || slug === \"..\") return false;\n  if (slug.includes(\"/\") || slug.includes(\"\\\\\")) return false;\n  if (slug.includes(\"\\0\")) return false;\n  return true;\n}\n\n/** Given an absolute path and the absolute `pagesDir`, return the\n *  slug if `absPath` is a direct `.md` child of `pagesDir`, else\n *  null. Pure path-string math \u2014 no fs IO, no symlink resolution.\n *\n *  Caller responsibility: pass already-realpath'd values for both\n *  arguments. Mixing a realpath'd `absPath` with a symlinked\n *  `pagesDir` (or vice versa) silently mismatches because\n *  `path.relative` is plain string arithmetic. The trap caused\n *  #883 review-iter-1 \u2014 a symlinked workspace silently routed\n *  wiki writes through the generic writer. */\nexport function wikiSlugFromAbsPath(absPath: string, pagesDir: string): string | null {\n  const rel = path.relative(pagesDir, absPath);\n  if (rel.length === 0) return null;\n  if (path.isAbsolute(rel)) return null;\n  // Direct child only \u2014 no nested layout today. Any separator\n  // means the path either escapes (`../secret.md`) or descends\n  // (`subdir/foo.md`). A literal page name like `..foo.md` is a\n  // single segment without a separator and is allowed (codex\n  // iter-3 #883 \u2014 the prior `startsWith(\"..\")` rule wrongly\n  // rejected it).\n  if (rel.includes(path.sep)) return null;\n  if (!rel.endsWith(\".md\")) return null;\n  const slug = rel.slice(0, -\".md\".length);\n  if (!isSafeSlug(slug)) return null;\n  return slug;\n}\n"],
  "mappings": "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",
  "names": ["path", "path"]
}


package/server/workspace/wiki-history/hook/snapshot.ts

@@ -0,0 +1,135 @@
+// PostToolUse hook source — runs after every Claude CLI Write /
+// Edit tool call. Detects writes that target a wiki page file
+// and POSTs `{ slug, sessionId? }` to the parent server's
+// `/api/wiki/internal/snapshot` endpoint so the snapshot pipeline
+// (#763 PR 2) records the new state.
+//
+// THIS FILE IS THE SOURCE OF TRUTH. Edits here, then run
+// `yarn build:hooks` (or `yarn build`) to regenerate
+// `./snapshot.mjs`. The bundled `.mjs` is committed to git so
+// `provision.ts` can read it at server startup without invoking
+// esbuild on the runtime path. CI runs `yarn build:hooks &&
+// git diff --exit-code` to catch a stale bundle.
+//
+// The hook executes inside Claude CLI's process space — must be
+// self-contained ESM. esbuild bundles imports from the shared
+// `src/lib/wiki-page/slug.ts` module so the hook and the
+// server-side `classifyAsWikiPage` agree on what counts as a
+// wiki page (no copy-paste drift).
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { wikiSlugFromAbsPath } from "../../../../src/lib/wiki-page/slug.js";
+
+// Workspace layout matches `WORKSPACE_DIRS.wikiPages`. We hard-
+// code "data/wiki/pages" rather than importing the constants
+// because the hook needs to stay independent of the server's
+// runtime config — the bundle must work even when the server
+// process isn't running yet (e.g. during a startup race).
+const WORKSPACE_ROOT = path.join(homedir(), "mulmoclaude");
+const WIKI_PAGES_DIR = path.join(WORKSPACE_ROOT, "data", "wiki", "pages");
+const TOKEN_PATH = path.join(WORKSPACE_ROOT, ".session-token");
+const PORT_PATH = path.join(WORKSPACE_ROOT, ".server-port");
+// In Docker mode the parent server runs on the host's 127.0.0.1
+// which the container can't reach via plain loopback. The Docker
+// spawn plumbing sets MULMOCLAUDE_HOST=host.docker.internal so
+// fetch() resolves to the host server. Outside Docker (or when
+// the var is unset) we fall back to the loopback address.
+const SERVER_HOST = process.env.MULMOCLAUDE_HOST ?? "127.0.0.1";
+
+interface HookPayload {
+  tool_input?: { file_path?: unknown };
+  tool_response?: { filePath?: unknown };
+  session_id?: unknown;
+}
+
+async function readStdin(): Promise<HookPayload | null> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8");
+  if (!raw.trim()) return null;
+  try {
+    return JSON.parse(raw) as HookPayload;
+  } catch {
+    return null;
+  }
+}
+
+function extractFilePath(payload: HookPayload): string | null {
+  // Claude CLI hook payload: { tool_name, tool_input, tool_response, ... }
+  // Different tools surface the path under different keys —
+  // check both shapes defensively.
+  const fromInput = payload.tool_input?.file_path;
+  if (typeof fromInput === "string") return fromInput;
+  const fromResponse = payload.tool_response?.filePath;
+  if (typeof fromResponse === "string") return fromResponse;
+  return null;
+}
+
+function readTokenSafe(): string {
+  try {
+    return readFileSync(TOKEN_PATH, "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+
+function readPortSafe(): number | null {
+  try {
+    const raw = readFileSync(PORT_PATH, "utf-8").trim();
+    const port = Number.parseInt(raw, 10);
+    return Number.isInteger(port) && port > 0 && port < 65536 ? port : null;
+  } catch {
+    return null;
+  }
+}
+
+async function main(): Promise<void> {
+  const payload = await readStdin();
+  if (!payload) return;
+
+  const filePath = extractFilePath(payload);
+  if (!filePath) return;
+  const slug = wikiSlugFromAbsPath(filePath, WIKI_PAGES_DIR);
+  if (slug === null) return;
+
+  const token = readTokenSafe();
+  const port = readPortSafe();
+  if (!token || port === null) return; // server isn't reachable; silent no-op
+
+  // Prefer our chat-session id from the spawn env (#963) — the
+  // server's session store keys by chatSessionId, not by Claude
+  // CLI's internal session_id, so the toolResult publish on the
+  // server side only matches when we forward our own id. Fall back
+  // to Claude CLI's `session_id` (still useful as a tracing token
+  // in the snapshot frontmatter) when the env var is absent — e.g.
+  // an older mulmoclaude server spawning a newer hook bundle.
+  const envChatSessionId = process.env.MULMOCLAUDE_CHAT_SESSION_ID;
+  const payloadSessionId = typeof payload.session_id === "string" && payload.session_id.length > 0 ? payload.session_id : undefined;
+  const sessionId = envChatSessionId && envChatSessionId.length > 0 ? envChatSessionId : payloadSessionId;
+  const body = sessionId === undefined ? { slug } : { slug, sessionId };
+
+  try {
+    await fetch(`http://${SERVER_HOST}:${port}/api/wiki/internal/snapshot`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(body),
+    });
+  } catch {
+    // Network / server down — drop silently. The wiki page write
+    // itself already succeeded; missing one snapshot is recoverable
+    // (the next save will record the next state).
+  }
+}
+
+main().catch(() => {
+  // Hooks run synchronously to the LLM tool flow — never throw.
+  // A busted hook would make `Write` itself look like it failed
+  // to the LLM, which is much worse than a missing snapshot.
+});

package/server/workspace/wiki-history/provision.ts

@@ -0,0 +1,181 @@
+// Workspace provisioning for the LLM wiki-write hook (#763 PR 2 prereq).
+//
+// At server startup, ensure the workspace's `.claude/settings.json`
+// has a `PostToolUse` hook on Write|Edit that runs our snapshot
+// script. The script itself is rewritten from the source-of-truth
+// constant in `hookScript.ts` on every startup so updates ship via
+// the normal mulmoclaude code path — no per-workspace migration.
+//
+// Idempotent: running provisioning twice produces the same on-disk
+// state. Existing user-supplied keys in `settings.json` are
+// preserved; we only touch the one PostToolUse entry that we own
+// (identified by a `mulmoclaudeWikiHistory: true` marker on the
+// hook descriptor).
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readTextOrNull } from "../../utils/files/safe.js";
+import { writeFileAtomic } from "../../utils/files/atomic.js";
+import { workspacePath as defaultWorkspacePath } from "../workspace.js";
+import { log } from "../../system/logger/index.js";
+
+// The esbuild-built bundle is the source of truth for the hook
+// script written into `<workspace>/.claude/hooks/`. Source TS is
+// `hook/snapshot.ts`; `yarn build:hooks` (chained from
+// `yarn build`) regenerates `hook/snapshot.mjs`, and CI fails
+// when the committed bundle drifts from the source. The read
+// happens inside `provisionWikiHistoryHook` (not at module load)
+// so a missing / unreadable bundle degrades to a logged warning
+// without breaking server startup — provisioning is best-effort
+// and the rest of the server still functions (codex review
+// iter-1 #955).
+const HOOK_BUNDLE_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), "hook", "snapshot.mjs");
+
+function readHookBundle(): string | null {
+  try {
+    return readFileSync(HOOK_BUNDLE_PATH, "utf-8");
+  } catch (err) {
+    log.warn("wiki-history", "hook bundle unreadable, skipping provisioning", {
+      bundlePath: HOOK_BUNDLE_PATH,
+      error: err instanceof Error ? err.message : String(err),
+    });
+    return null;
+  }
+}
+
+const SETTINGS_REL = path.join(".claude", "settings.json");
+const HOOK_SCRIPT_REL = path.join(".claude", "hooks", "wiki-snapshot.mjs");
+// Forward-slash form for the shell command field — settings.json
+// is read by Claude CLI, and a hook command is interpreted by a
+// POSIX shell (Mac / Linux / inside the Docker container). We never
+// embed the workspace root directly: the same settings.json is
+// bind-mounted into the container, so a host-absolute path
+// (`/Users/.../mulmoclaude/...`) silently fails inside the container
+// where the workspace lives at `/home/node/mulmoclaude/...`. Claude
+// CLI exports `CLAUDE_PROJECT_DIR` to hooks, which resolves
+// correctly in both contexts.
+const HOOK_SCRIPT_REL_POSIX = ".claude/hooks/wiki-snapshot.mjs";
+const HOOK_COMMAND = `node "$CLAUDE_PROJECT_DIR/${HOOK_SCRIPT_REL_POSIX}"`;
+const OWNER_MARKER = "mulmoclaudeWikiHistory";
+
+interface HookCommandEntry {
+  type: "command";
+  command: string;
+  [key: string]: unknown;
+}
+
+interface HookMatcher {
+  matcher?: string;
+  hooks?: HookCommandEntry[];
+  [key: string]: unknown;
+}
+
+interface SettingsShape {
+  hooks?: {
+    PostToolUse?: HookMatcher[];
+    [key: string]: HookMatcher[] | undefined;
+  };
+  [key: string]: unknown;
+}
+
+export interface ProvisionOptions {
+  workspaceRoot?: string;
+}
+
+/** Ensure the hook script + `.claude/settings.json` are up to date.
+ *  Safe to call on every startup. Logs a one-line info on first
+ *  install, debug-only on subsequent no-op runs. Skips quietly
+ *  (with a warning) when the bundled hook script can't be read
+ *  — provisioning is best-effort and the rest of the server is
+ *  still functional. */
+export async function provisionWikiHistoryHook(opts: ProvisionOptions = {}): Promise<void> {
+  const bundle = readHookBundle();
+  if (bundle === null) return;
+
+  const root = opts.workspaceRoot ?? defaultWorkspacePath;
+  const scriptPath = path.join(root, HOOK_SCRIPT_REL);
+  const settingsPath = path.join(root, SETTINGS_REL);
+
+  await writeHookScript(scriptPath, bundle);
+  const changed = await mergeHookIntoSettings(settingsPath);
+  if (changed) {
+    log.info("wiki-history", "provisioned wiki-snapshot hook", { settingsPath, scriptPath });
+  }
+}
+
+async function writeHookScript(absPath: string, bundle: string): Promise<void> {
+  // Always overwrite — the esbuild bundle on disk is the source of
+  // truth, and rewriting on every startup means a mulmoclaude
+  // update propagates without per-workspace migration.
+  await writeFileAtomic(absPath, bundle, { mode: 0o700 });
+}
+
+async function mergeHookIntoSettings(settingsPath: string): Promise<boolean> {
+  const existingRaw = await readTextOrNull(settingsPath);
+  const existing: SettingsShape = existingRaw ? safeParse(existingRaw) : {};
+
+  const desiredHook: HookCommandEntry = {
+    type: "command",
+    command: HOOK_COMMAND,
+    [OWNER_MARKER]: true,
+  };
+
+  const next = upsertOurHook(existing, desiredHook);
+  const nextRaw = `${JSON.stringify(next, null, 2)}\n`;
+  if (existingRaw === nextRaw) return false;
+
+  // mode 0644 is fine — settings.json doesn't carry secrets, and
+  // matching the user's own conventions for `~/.claude/settings.json`
+  // (which is typically world-readable) avoids permission surprises.
+  await writeFileAtomic(settingsPath, nextRaw);
+  return true;
+}
+
+function safeParse(raw: string): SettingsShape {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed as SettingsShape;
+    }
+  } catch {
+    // Fall through — corrupted settings get rebuilt with our entry only.
+  }
+  return {};
+}
+
+function upsertOurHook(settings: SettingsShape, desiredHook: HookCommandEntry): SettingsShape {
+  const hooks = settings.hooks ?? {};
+  // Normalise to [] when an unexpected shape sits under `PostToolUse`
+  // (object, string, etc.). The `?? []` form only handles
+  // null/undefined; without this guard, `findIndex` throws and the
+  // hook silently fails to install for the session (codex iter-2 #917).
+  const rawPostToolUse = hooks.PostToolUse;
+  const postToolUse = Array.isArray(rawPostToolUse) ? rawPostToolUse : [];
+
+  const ownedIndex = postToolUse.findIndex((entry) => entryHasOwnedHook(entry));
+  const desiredEntry: HookMatcher = {
+    matcher: "Write|Edit",
+    hooks: [desiredHook],
+  };
+
+  const nextPostToolUse = [...postToolUse];
+  if (ownedIndex === -1) {
+    nextPostToolUse.push(desiredEntry);
+  } else {
+    nextPostToolUse[ownedIndex] = desiredEntry;
+  }
+
+  return {
+    ...settings,
+    hooks: {
+      ...hooks,
+      PostToolUse: nextPostToolUse,
+    },
+  };
+}
+
+function entryHasOwnedHook(entry: HookMatcher): boolean {
+  if (!Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some((hook) => hook[OWNER_MARKER] === true);
+}