seekstone 0.16.0 → 0.17.1

package/dist/index.js

@@ -14,79 +14,147 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/semantic/model-manifest.ts
+function hfFiles(repo, hashes) {
+  const base = `https://huggingface.co/minishlab/${repo}/resolve/main`;
+  return [
+    {
+      name: "model.safetensors",
+      url: `${base}/model.safetensors`,
+      sha256: hashes.safetensors[0],
+      bytes: hashes.safetensors[1]
+    },
+    {
+      name: "tokenizer.json",
+      url: `${base}/tokenizer.json`,
+      sha256: hashes.tokenizer[0],
+      bytes: hashes.tokenizer[1]
+    },
+    {
+      name: "config.json",
+      url: `${base}/config.json`,
+      sha256: hashes.config[0],
+      bytes: hashes.config[1]
+    }
+  ];
+}
+function findModel(id) {
+  return MODELS.find((m) => m.id === id);
+}
+var DEFAULT_MODEL, RETRIEVAL_32M_MODEL, MODELS, MODEL_IDS;
+var init_model_manifest = __esm({
+  "src/semantic/model-manifest.ts"() {
+    "use strict";
+    DEFAULT_MODEL = {
+      id: "potion-base-8M",
+      license: "MIT (https://huggingface.co/minishlab/potion-base-8M)",
+      dim: 256,
+      files: hfFiles("potion-base-8M", {
+        safetensors: ["f65d0f325faadc1e121c319e2faa41170d3fa07d8c89abd48ca5358d9a223de2", 30236760],
+        tokenizer: ["e67e803f624fb4d67dea1c730d06e1067e1b14d830e2c2202569e3ef0f70bb50", 683666],
+        config: ["2a6ac0e9aaa356a68a5688070db78fc3a464fefe85d2f06a1905ce3718687553", 202]
+      })
+    };
+    RETRIEVAL_32M_MODEL = {
+      id: "potion-retrieval-32M",
+      license: "MIT (https://huggingface.co/minishlab/potion-retrieval-32M)",
+      dim: 512,
+      files: hfFiles("potion-retrieval-32M", {
+        safetensors: ["07609e5bd33aad37900b3fd62f4ec96f6daec88ca4d46b9d8b928bfababf6ea0", 129210456],
+        tokenizer: ["7d75cbc54318138807c401b0f0c9721117c628b39de8e8e0edb6cb17e0ee7d18", 1493150],
+        config: ["63c00d90824c832c04ec1d02b6a983fb90489bf049f29fbff15ba481b8a432ee", 202]
+      })
+    };
+    MODELS = [DEFAULT_MODEL, RETRIEVAL_32M_MODEL];
+    MODEL_IDS = MODELS.map((m) => m.id);
+  }
+});
+
 // src/semantic/config.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function defaultCacheDir(env, homedir2) {
-  return env.SEEKSTONE_CACHE_DIR || join7(homedir2, ".cache", "seekstone");
+  return env.SEEKSTONE_CACHE_DIR || join8(homedir2, ".cache", "seekstone");
+}
+function resolveModel(raw) {
+  const id = raw?.trim();
+  if (!id) return DEFAULT_MODEL;
+  const manifest = findModel(id);
+  if (!manifest) {
+    throw new Error(
+      `SEEKSTONE_SEMANTIC_MODEL: unknown model "${id}" \u2014 expected one of ${MODEL_IDS.join(", ")}`
+    );
+  }
+  return manifest;
+}
+function resolveModelId(raw) {
+  return resolveModel(raw).id;
+}
+function fetchCommandFor(modelId) {
+  return modelId === DEFAULT_MODEL_ID ? "npx -y seekstone fetch-model" : `npx -y seekstone fetch-model --model ${modelId}`;
 }
 function resolveSemanticConfig(env, homedir2) {
   if (env.SEEKSTONE_SEMANTIC !== "1") return void 0;
+  const modelId = resolveModelId(env.SEEKSTONE_SEMANTIC_MODEL);
   const cacheDir = defaultCacheDir(env, homedir2);
-  const modelDir = env.SEEKSTONE_MODEL_PATH || join7(cacheDir, "models", DEFAULT_MODEL_ID);
-  return { modelDir, cacheDir };
+  const modelDir = env.SEEKSTONE_MODEL_PATH || join8(cacheDir, "models", modelId);
+  return { modelId, modelDir, cacheDir };
 }
 var DEFAULT_MODEL_ID;
 var init_config = __esm({
   "src/semantic/config.ts"() {
     "use strict";
-    DEFAULT_MODEL_ID = "potion-base-8M";
-  }
-});
-
-// src/semantic/model-manifest.ts
-var DEFAULT_MODEL;
-var init_model_manifest = __esm({
-  "src/semantic/model-manifest.ts"() {
-    "use strict";
-    DEFAULT_MODEL = {
-      id: "potion-base-8M",
-      license: "MIT (https://huggingface.co/minishlab/potion-base-8M)",
-      files: [
-        {
-          name: "model.safetensors",
-          url: "https://huggingface.co/minishlab/potion-base-8M/resolve/main/model.safetensors",
-          sha256: "f65d0f325faadc1e121c319e2faa41170d3fa07d8c89abd48ca5358d9a223de2",
-          bytes: 30236760
-        },
-        {
-          name: "tokenizer.json",
-          url: "https://huggingface.co/minishlab/potion-base-8M/resolve/main/tokenizer.json",
-          sha256: "e67e803f624fb4d67dea1c730d06e1067e1b14d830e2c2202569e3ef0f70bb50",
-          bytes: 683666
-        },
-        {
-          name: "config.json",
-          url: "https://huggingface.co/minishlab/potion-base-8M/resolve/main/config.json",
-          sha256: "2a6ac0e9aaa356a68a5688070db78fc3a464fefe85d2f06a1905ce3718687553",
-          bytes: 202
-        }
-      ]
-    };
+    init_model_manifest();
+    DEFAULT_MODEL_ID = DEFAULT_MODEL.id;
   }
 });
 
 // src/semantic/fetch-model.ts
 var fetch_model_exports = {};
 __export(fetch_model_exports, {
-  runFetchModel: () => runFetchModel
+  runFetchModel: () => runFetchModel,
+  selectManifest: () => selectManifest
 });
 import { createHash as createHash3 } from "crypto";
 import { existsSync } from "fs";
-import { mkdir as mkdir7, readFile as readFile17, writeFile as writeFile4 } from "fs/promises";
-import { join as join11 } from "path";
+import { mkdir as mkdir9, readFile as readFile19, writeFile as writeFile4 } from "fs/promises";
+import { join as join12 } from "path";
+function selectManifest(argv, env) {
+  let requested;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--model") {
+      requested = argv[i + 1];
+      if (!requested || requested.startsWith("--")) {
+        throw new Error(`--model needs a value: one of ${MODEL_IDS.join(", ")}`);
+      }
+      i++;
+    } else if (arg?.startsWith("--model=")) {
+      requested = arg.slice("--model=".length);
+    } else {
+      throw new Error(`fetch-model: unknown argument "${arg}" (usage: fetch-model [--model <id>])`);
+    }
+  }
+  return resolveModel(requested ?? env.SEEKSTONE_SEMANTIC_MODEL);
+}
 async function runFetchModel(deps) {
-  const manifest = deps.manifest ?? DEFAULT_MODEL;
-  const fetchFn = deps.fetchFn ?? fetch;
-  const destDir = deps.env.SEEKSTONE_MODEL_PATH || join11(defaultCacheDir(deps.env, deps.homedir), "models", manifest.id);
   const output = [];
+  let manifest;
+  try {
+    manifest = deps.manifest ?? selectManifest(deps.argv ?? [], deps.env);
+  } catch (err) {
+    output.push(`\u2717 ${err instanceof Error ? err.message : String(err)}`);
+    return { output, exitCode: 1 };
+  }
+  const fetchFn = deps.fetchFn ?? fetch;
+  const destDir = deps.env.SEEKSTONE_MODEL_PATH || join12(defaultCacheDir(deps.env, deps.homedir), "models", manifest.id);
   output.push(`fetch-model: ${manifest.id} \u2192 ${destDir}`);
   try {
-    await mkdir7(destDir, { recursive: true });
+    await mkdir9(destDir, { recursive: true });
     let fetched = 0;
     let skipped = 0;
     for (const file of manifest.files) {
-      const dest = join11(destDir, file.name);
-      if (existsSync(dest) && sha256(await readFile17(dest)) === file.sha256) {
+      const dest = join12(destDir, file.name);
+      if (existsSync(dest) && sha256(await readFile19(dest)) === file.sha256) {
         skipped++;
         continue;
       }
@@ -103,7 +171,7 @@ async function runFetchModel(deps) {
     }
     output.push(`\u2713 ${manifest.id}: ${fetched} fetched, ${skipped} already present (verified).`);
     output.push(
-      "Enable semantic search with SEEKSTONE_SEMANTIC=1 in your MCP server config, then restart the session."
+      manifest.id === DEFAULT_MODEL_ID ? "Enable semantic search with SEEKSTONE_SEMANTIC=1 in your MCP server config, then restart the session." : `Enable it with SEEKSTONE_SEMANTIC=1 and SEEKSTONE_SEMANTIC_MODEL=${manifest.id} in your MCP server config, then restart the session.`
     );
     return { output, exitCode: 0 };
   } catch (err) {
@@ -132,6 +200,198 @@ import {
   ListToolsRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
+// src/audit.ts
+import {
+  appendFileSync as appendFileSync2,
+  closeSync,
+  fsyncSync,
+  openSync,
+  renameSync as renameSync2,
+  statSync as statSync2,
+  writeSync
+} from "fs";
+
+// src/log.ts
+import { appendFileSync, renameSync, statSync } from "fs";
+var ORDER = ["error", "warn", "info", "debug"];
+var DEFAULT_MAX_SIZE = 5 * 1024 * 1024;
+function parseLevel(raw, onBad) {
+  if (raw === void 0 || raw === "") return "info";
+  const v = raw.trim().toLowerCase();
+  for (const lvl of ORDER) {
+    if (lvl === v) return lvl;
+  }
+  onBad(`invalid SEEKSTONE_LOG_LEVEL=${JSON.stringify(raw)}; using "info"`);
+  return "info";
+}
+function parseSize(raw, fallback = DEFAULT_MAX_SIZE) {
+  if (raw === void 0) return fallback;
+  const m = /^(\d+(?:\.\d+)?)(b|kb|mb|gb)?$/i.exec(raw.trim());
+  if (m === null) return fallback;
+  const num = Number(m[1]);
+  const unit = (m[2] ?? "b").toLowerCase();
+  const mult = unit === "gb" ? 1e9 : unit === "mb" ? 1e6 : unit === "kb" ? 1e3 : 1;
+  return Math.max(1, Math.floor(num * mult));
+}
+function fmtFields(fields) {
+  const parts = [];
+  for (const [k, v] of Object.entries(fields)) {
+    if (v === void 0) continue;
+    parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+  }
+  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+function createLogger(opts = {}) {
+  const env = opts.env ?? process.env;
+  const stderr = opts.stderr ?? ((line) => void process.stderr.write(line));
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const level = parseLevel(env.SEEKSTONE_LOG_LEVEL, (m) => {
+    stderr(`WARN  ${now().toISOString()} ${m}
+`);
+  });
+  const threshold = ORDER.indexOf(level);
+  const filePath = env.SEEKSTONE_LOG_FILE;
+  const maxSize = parseSize(env.SEEKSTONE_LOG_MAX_SIZE);
+  let fileOk = false;
+  let bytes = 0;
+  if (filePath !== void 0 && filePath !== "") {
+    try {
+      try {
+        bytes = statSync(filePath).size;
+      } catch {
+        bytes = 0;
+      }
+      appendFileSync(filePath, "");
+      fileOk = true;
+    } catch (err) {
+      const m = err instanceof Error ? err.message : String(err);
+      stderr(
+        `WARN  ${now().toISOString()} cannot write log file ${filePath}: ${m}; file logging disabled
+`
+      );
+    }
+  }
+  function writeFile5(record) {
+    if (!fileOk || filePath === void 0) return;
+    const line = `${JSON.stringify(record)}
+`;
+    const len = Buffer.byteLength(line);
+    try {
+      if (bytes > 0 && bytes + len > maxSize) {
+        renameSync(filePath, `${filePath}.1`);
+        bytes = 0;
+      }
+      appendFileSync(filePath, line);
+      bytes += len;
+    } catch {
+      fileOk = false;
+    }
+  }
+  function emit(lvl, msg, fields) {
+    if (ORDER.indexOf(lvl) > threshold) return;
+    const ts = now().toISOString();
+    const f = fields ?? {};
+    stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
+`);
+    writeFile5({ t: ts, level: lvl, msg, ...f });
+  }
+  return {
+    level,
+    error: (m, f) => {
+      emit("error", m, f);
+    },
+    warn: (m, f) => {
+      emit("warn", m, f);
+    },
+    info: (m, f) => {
+      emit("info", m, f);
+    },
+    debug: (m, f) => {
+      emit("debug", m, f);
+    }
+  };
+}
+
+// src/audit.ts
+var DEFAULT_MAX_SIZE2 = 10 * 1e6;
+function resolveAuditConfig(env) {
+  const path2 = (env.SEEKSTONE_AUDIT_FILE ?? "").trim();
+  if (path2 === "") return void 0;
+  return { path: path2, maxBytes: parseSize(env.SEEKSTONE_AUDIT_MAX_SIZE, DEFAULT_MAX_SIZE2) };
+}
+var AuditLog = class _AuditLog {
+  path;
+  maxBytes;
+  bytes;
+  constructor(path2, maxBytes, bytes) {
+    this.path = path2;
+    this.maxBytes = maxBytes;
+    this.bytes = bytes;
+  }
+  /**
+   * Open (create if missing) the audit file, verifying it is writable now so
+   * an unwritable path fails at boot rather than on the first write.
+   */
+  static open(config) {
+    let bytes = 0;
+    try {
+      bytes = statSync2(config.path).size;
+    } catch {
+      bytes = 0;
+    }
+    appendFileSync2(config.path, "");
+    return new _AuditLog(config.path, config.maxBytes, bytes);
+  }
+  /** Append one record durably. Throws if the append or fsync fails. */
+  record(rec) {
+    const line = `${JSON.stringify(rec)}
+`;
+    const len = Buffer.byteLength(line);
+    if (this.bytes > 0 && this.bytes + len > this.maxBytes) {
+      renameSync2(this.path, `${this.path}.1`);
+      this.bytes = 0;
+    }
+    const fd = openSync(this.path, "a");
+    try {
+      writeSync(fd, line);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    this.bytes += len;
+  }
+};
+function classifyError(message) {
+  if (message.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(message);
+      if (typeof parsed.error === "string") {
+        if (parsed.error === "hash_conflict")
+          return { outcome: "hash_conflict", error: parsed.error };
+        if (parsed.error === "undo_conflict")
+          return { outcome: "undo_conflict", error: parsed.error };
+        return { outcome: "error", error: parsed.error };
+      }
+    } catch {
+    }
+  }
+  if (message.startsWith("Server is read-only")) {
+    return { outcome: "policy_denied", policy: "read_only", error: "read_only" };
+  }
+  if (message.startsWith("Write not permitted")) {
+    return { outcome: "policy_denied", policy: "write_paths", error: "write_paths" };
+  }
+  if (/ENOENT|not found/i.test(message)) return { outcome: "error", error: "not_found" };
+  if (/already exists/i.test(message)) return { outcome: "error", error: "exists" };
+  if (/^Invalid regex/.test(message)) return { outcome: "error", error: "invalid_regex" };
+  if (/^Write-safety violation/.test(message))
+    return { outcome: "error", error: "write_safety_violation" };
+  if (/^\[\s*\{/.test(message) || /invalid_type|Required|Expected|expected/.test(message)) {
+    return { outcome: "error", error: "invalid_input" };
+  }
+  return { outcome: "error", error: "error" };
+}
+
 // src/cli-args.ts
 function parseCliIntent(argv) {
   if (argv[0] === "init") {
@@ -160,6 +420,7 @@ Usage:
   seekstone              Start the MCP server (reads from stdin/stdout)
   seekstone init         Validate a vault and print/patch the client MCP config
   seekstone fetch-model  Download the local embedding model for semantic search
+                         (--model potion-base-8M | potion-retrieval-32M)
   seekstone --version    Print the version and exit
   seekstone --help       Print this help and exit
 
@@ -175,6 +436,7 @@ Optional environment:
   SEEKSTONE_WATCH_POLL Set to 1 to poll for changes (network drives, WSL)
   SEEKSTONE_WATCH_POLL_INTERVAL  Poll interval in ms (default 10000)
   SEEKSTONE_SEMANTIC   Set to 1 to enable semantic search (needs fetch-model first)
+  SEEKSTONE_SEMANTIC_MODEL  potion-base-8M (default) | potion-retrieval-32M (bigger, more accurate)
   SEEKSTONE_MODEL_PATH Override the embedding-model directory
   SEEKSTONE_CACHE_DIR  Override the cache root (default ~/.cache/seekstone)
 
@@ -204,7 +466,7 @@ Docs: https://github.com/shaqmughal/seekstone`;
 }
 
 // src/tools/append_note.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 
 // ../core/src/frontmatter.ts
 import { parse as parseYaml } from "yaml";
@@ -300,6 +562,271 @@ function assertHashMatch(raw, prevHash, path2) {
   }
 }
 
+// src/journal.ts
+import { timingSafeEqual } from "crypto";
+import { mkdir, open, readdir, readFile, rename as rename2, rm, stat } from "fs/promises";
+import { join } from "path";
+var DEFAULT_MAX_BYTES = 50 * 1e6;
+var DEFAULT_MAX_ENTRIES = 1e3;
+var HISTORY_DIR = ".seekstone/history";
+function resolveJournalConfig(env) {
+  const flag = (env.SEEKSTONE_HISTORY ?? "").trim().toLowerCase();
+  if (flag === "0" || flag === "false" || flag === "off") return void 0;
+  const maxEntriesRaw = Number.parseInt(env.SEEKSTONE_HISTORY_MAX_ENTRIES ?? "", 10);
+  return {
+    maxBytes: parseSize(env.SEEKSTONE_HISTORY_MAX_SIZE, DEFAULT_MAX_BYTES),
+    maxEntries: Number.isFinite(maxEntriesRaw) && maxEntriesRaw > 0 ? maxEntriesRaw : DEFAULT_MAX_ENTRIES
+  };
+}
+async function writeDurable(dest, content) {
+  const tmp = `${dest}.seekstone-tmp`;
+  const fh = await open(tmp, "w");
+  try {
+    await fh.writeFile(content, "utf8");
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+  await rename2(tmp, dest);
+}
+async function appendDurable(dest, line) {
+  const fh = await open(dest, "a");
+  try {
+    await fh.writeFile(line, "utf8");
+    await fh.sync();
+  } finally {
+    await fh.close();
+  }
+}
+var Journal = class _Journal {
+  config;
+  dir;
+  blobDir;
+  manifestPath;
+  log;
+  entries;
+  nextSeq;
+  /** Blob hash → byte size, for every blob currently on disk. */
+  blobSizes;
+  totalBytes;
+  /** Serialises commits so seq assignment and eviction never interleave. */
+  chain = Promise.resolve();
+  constructor(vaultRoot2, config, entries, blobSizes, log2) {
+    this.config = config;
+    this.dir = join(vaultRoot2, HISTORY_DIR);
+    this.blobDir = join(this.dir, "blobs");
+    this.manifestPath = join(this.dir, "manifest.jsonl");
+    this.entries = entries;
+    this.nextSeq = (entries.at(-1)?.seq ?? 0) + 1;
+    this.blobSizes = blobSizes;
+    this.totalBytes = 0;
+    for (const n of blobSizes.values()) this.totalBytes += n;
+    this.log = log2;
+  }
+  /** Open (or create) the journal under `vaultRoot`, loading the manifest into memory. */
+  static async open(vaultRoot2, config, opts = {}) {
+    const dir = join(vaultRoot2, HISTORY_DIR);
+    const blobDir = join(dir, "blobs");
+    await mkdir(blobDir, { recursive: true });
+    const entries = [];
+    let manifest = "";
+    try {
+      manifest = await readFile(join(dir, "manifest.jsonl"), "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    let lastSeq = 0;
+    for (const line of manifest.split("\n")) {
+      if (line.trim() === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        opts.log?.warn("journal: skipping malformed manifest line");
+        continue;
+      }
+      if (!isEntry(parsed) || parsed.seq <= lastSeq) {
+        opts.log?.warn("journal: skipping invalid manifest entry");
+        continue;
+      }
+      entries.push(parsed);
+      lastSeq = parsed.seq;
+    }
+    const blobSizes = /* @__PURE__ */ new Map();
+    for (const name of await readdir(blobDir)) {
+      if (!/^[0-9a-f]{64}$/.test(name)) continue;
+      try {
+        blobSizes.set(name, (await stat(join(blobDir, name))).size);
+      } catch {
+      }
+    }
+    return new _Journal(vaultRoot2, config, entries, blobSizes, opts.log);
+  }
+  begin(tool, undoOf) {
+    const files = [];
+    let committed = false;
+    return {
+      add: async (path2, pre, post) => {
+        if (committed) throw new Error("journal: add after commit");
+        const preHash = pre === null ? null : await this.storeBlob(pre);
+        files.push({ path: path2, preHash, postHash: post === null ? null : contentHash(post) });
+      },
+      commit: async () => {
+        if (committed) throw new Error("journal: double commit");
+        committed = true;
+        return this.enqueue(() => this.commit(tool, files, undoOf));
+      }
+    };
+  }
+  /** Newest-first rows for `list_writes`. */
+  list(opts = {}) {
+    const limit = opts.limit ?? 20;
+    const filtered = opts.path === void 0 ? this.entries : this.entries.filter((e) => e.files.some((f) => f.path === opts.path));
+    const writes = [];
+    for (let i = filtered.length - 1; i >= 0 && writes.length < limit; i--) {
+      const e = filtered[i];
+      const row = {
+        seq: e.seq,
+        ts: e.ts,
+        tool: e.tool,
+        paths: e.files.map((f) => f.path),
+        undoable: this.isUndoable(e)
+      };
+      if (e.undoOf !== void 0) row.undoOf = e.undoOf;
+      writes.push(row);
+    }
+    return { writes, total: filtered.length };
+  }
+  /** Seq of the newest entry (0 when empty). */
+  get lastSeq() {
+    return this.nextSeq - 1;
+  }
+  /** Entries committed after `seq`, oldest first. */
+  since(seq) {
+    return this.entries.filter((e) => e.seq > seq);
+  }
+  get(seq) {
+    return this.entries.find((e) => e.seq === seq);
+  }
+  /**
+   * The most recent write that is still in effect and restorable — the
+   * default target of `undo_write`. Undo entries and writes they reverted are
+   * skipped (so repeated default undos walk backwards instead of ping-ponging
+   * undo/redo); an undo that was itself undone re-exposes its target. Redo is
+   * always explicit: `undo_write({ seq: <the undo's seq> })`.
+   */
+  latestUndoable() {
+    const cancelled = /* @__PURE__ */ new Set();
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const e = this.entries[i];
+      if (cancelled.has(e.seq)) continue;
+      if (e.undoOf !== void 0) {
+        cancelled.add(e.undoOf);
+        continue;
+      }
+      if (this.isUndoable(e)) return e;
+    }
+    return void 0;
+  }
+  isUndoable(entry) {
+    return entry.files.every((f) => f.preHash === null || this.blobSizes.has(f.preHash));
+  }
+  /** Read a stored pre-image by hash. Throws if evicted. */
+  async preimage(hash) {
+    const raw = await readFile(join(this.blobDir, hash), "utf8");
+    const actual = Buffer.from(contentHash(raw), "hex");
+    const expected = Buffer.from(hash, "hex");
+    if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+      throw new Error(`journal: blob ${hash} is corrupt (hash mismatch)`);
+    }
+    return raw;
+  }
+  /** Bytes of pre-images currently stored (for diagnostics/tests). */
+  get storedBytes() {
+    return this.totalBytes;
+  }
+  enqueue(fn) {
+    const next = this.chain.then(fn, fn);
+    this.chain = next.catch(() => void 0);
+    return next;
+  }
+  async storeBlob(content) {
+    const hash = contentHash(content);
+    if (this.blobSizes.has(hash)) return hash;
+    await writeDurable(join(this.blobDir, hash), content);
+    const size = Buffer.byteLength(content, "utf8");
+    this.blobSizes.set(hash, size);
+    this.totalBytes += size;
+    return hash;
+  }
+  async commit(tool, files, undoOf) {
+    const entry = { seq: this.nextSeq, ts: (/* @__PURE__ */ new Date()).toISOString(), tool, files };
+    if (undoOf !== void 0) entry.undoOf = undoOf;
+    await appendDurable(this.manifestPath, `${JSON.stringify(entry)}
+`);
+    this.nextSeq++;
+    this.entries.push(entry);
+    await this.evict();
+    return entry;
+  }
+  /**
+   * Enforce the caps. Blobs are reference-counted across entries, so a
+   * pre-image shared by an old and a new entry survives the old one's
+   * eviction. Over the entry cap, the oldest rows are dropped and the
+   * manifest rewritten atomically; over the byte cap, the oldest entries'
+   * blobs are removed but the rows stay (listed as undoable: false).
+   */
+  async evict() {
+    const refs = /* @__PURE__ */ new Map();
+    for (const e of this.entries) {
+      for (const f of e.files) {
+        if (f.preHash !== null) refs.set(f.preHash, (refs.get(f.preHash) ?? 0) + 1);
+      }
+    }
+    const dropBlobs = async (e) => {
+      for (const f of e.files) {
+        if (f.preHash === null) continue;
+        const n = (refs.get(f.preHash) ?? 1) - 1;
+        refs.set(f.preHash, n);
+        if (n > 0 || !this.blobSizes.has(f.preHash)) continue;
+        await rm(join(this.blobDir, f.preHash), { force: true });
+        this.totalBytes -= this.blobSizes.get(f.preHash) ?? 0;
+        this.blobSizes.delete(f.preHash);
+      }
+    };
+    let rewrite = false;
+    while (this.entries.length > this.config.maxEntries) {
+      const oldest = this.entries.shift();
+      await dropBlobs(oldest);
+      rewrite = true;
+    }
+    for (let i = 0; this.totalBytes > this.config.maxBytes && i < this.entries.length - 1; i++) {
+      await dropBlobs(this.entries[i]);
+    }
+    if (rewrite) {
+      await writeDurable(
+        this.manifestPath,
+        this.entries.map((e) => `${JSON.stringify(e)}
+`).join("")
+      );
+      this.log?.debug("journal: manifest compacted", { entries: this.entries.length });
+    }
+  }
+};
+function isEntry(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const e = v;
+  return typeof e.seq === "number" && typeof e.ts === "string" && typeof e.tool === "string" && Array.isArray(e.files) && e.files.every(
+    (f) => typeof f === "object" && f !== null && typeof f.path === "string" && (f.preHash === null || typeof f.preHash === "string") && (f.postHash === null || typeof f.postHash === "string")
+  );
+}
+async function journalWrite(ctx2, tool, path2, pre, post) {
+  if (!ctx2.journal) return;
+  const txn = ctx2.journal.begin(tool);
+  await txn.add(path2, pre, post);
+  await txn.commit();
+}
+
 // src/policy.ts
 import picomatch from "picomatch";
 function parseWritePolicy(env) {
@@ -352,7 +879,7 @@ var AppendNoteInput = z.object({
 async function appendNote(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
   assertWritable(ctx2.policy, input.path);
-  const original = await readFile(absPath, "utf8");
+  const original = await readFile2(absPath, "utf8");
   if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, input.path);
   const fm = parseFrontmatter(original);
   const body = fm.body.endsWith("\n") ? fm.body : `${fm.body}
@@ -361,6 +888,7 @@ async function appendNote(ctx2, input) {
   const newBody = `${body}${separator}${input.content}`;
   const header = original.slice(0, fm.bodyStart);
   const newContent = `${header}${newBody}`;
+  await journalWrite(ctx2, "append_note", input.path, original, newContent);
   await atomicWrite(absPath, newContent);
   const cached = ctx2.notes.get(input.path);
   if (cached) {
@@ -611,7 +1139,10 @@ function lexicalSearch(ctx2, input) {
 }
 function semanticSearch(ctx2, semantic, input) {
   const queryVec = semantic.embedQuery(input.query);
-  const candidates = semantic.store.topNotes(queryVec, SEMANTIC_CANDIDATES);
+  const candidates = semantic.rerank(
+    input.query,
+    semantic.store.topNotes(queryVec, SEMANTIC_CANDIDATES)
+  );
   const terms = searchTerms(input.query);
   const hits = [];
   for (const c of candidates) {
@@ -839,7 +1370,7 @@ function contextPack(ctx2, input) {
 }
 
 // src/tools/create_note.ts
-import { access, mkdir, readFile as readFile2 } from "fs/promises";
+import { access, mkdir as mkdir2, readFile as readFile3 } from "fs/promises";
 import { dirname } from "path";
 import { stringify as stringifyYaml } from "yaml";
 import { z as z4 } from "zod";
@@ -888,6 +1419,7 @@ async function createNote(ctx2, rawInput) {
   const input = CreateNoteInput.parse(rawInput);
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
   assertWritable(ctx2.policy, input.path);
+  let existing = null;
   if (!input.overwrite) {
     try {
       await access(absPath);
@@ -895,22 +1427,26 @@ async function createNote(ctx2, rawInput) {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-  } else if (input.prevHash !== void 0) {
-    let existing;
+  } else {
     try {
-      existing = await readFile2(absPath, "utf8");
-    } catch {
-      throw new Error(
-        JSON.stringify({
-          error: "hash_conflict",
-          path: input.path,
-          expected: input.prevHash,
-          actual: null,
-          hint: "The note no longer exists on disk. Re-check before overwriting."
-        })
-      );
+      existing = await readFile3(absPath, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+      if (input.prevHash !== void 0) {
+        throw new Error(
+          JSON.stringify({
+            error: "hash_conflict",
+            path: input.path,
+            expected: input.prevHash,
+            actual: null,
+            hint: "The note no longer exists on disk. Re-check before overwriting."
+          })
+        );
+      }
+    }
+    if (existing !== null && input.prevHash !== void 0) {
+      assertHashMatch(existing, input.prevHash, input.path);
     }
-    assertHashMatch(existing, input.prevHash, input.path);
   }
   let raw = "";
   if (input.frontmatter && Object.keys(input.frontmatter).length > 0) {
@@ -919,7 +1455,8 @@ ${stringifyYaml(input.frontmatter, { lineWidth: 0 })}---
 `;
   }
   raw += input.content ?? "";
-  await mkdir(dirname(absPath), { recursive: true });
+  await mkdir2(dirname(absPath), { recursive: true });
+  await journalWrite(ctx2, "create_note", input.path, existing, raw);
   await atomicWrite(absPath, raw);
   upsertDoc(ctx2, buildDoc(input.path, raw));
   return {
@@ -930,8 +1467,8 @@ ${stringifyYaml(input.frontmatter, { lineWidth: 0 })}---
 }
 
 // src/tools/delete_note.ts
-import { access as access2, mkdir as mkdir2, readFile as readFile3, rename as rename2, rm } from "fs/promises";
-import { basename as basename2, extname as extname2, join } from "path";
+import { access as access2, mkdir as mkdir3, readFile as readFile4, rename as rename3, rm as rm2 } from "fs/promises";
+import { basename as basename2, extname as extname2, join as join2 } from "path";
 import { z as z5 } from "zod";
 
 // src/index/backlinks.ts
@@ -982,7 +1519,7 @@ async function freeTrashPath(vaultRoot2, noteBase) {
   let candidate = `.trash/${noteBase}`;
   for (; ; ) {
     try {
-      await access2(join(vaultRoot2, candidate));
+      await access2(join2(vaultRoot2, candidate));
     } catch {
       return candidate;
     }
@@ -993,15 +1530,16 @@ async function deleteNote(ctx2, rawInput) {
   const input = DeleteNoteInput.parse(rawInput);
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
   assertWritable(ctx2.policy, input.path);
-  const raw = await readFile3(absPath, "utf8");
+  const raw = await readFile4(absPath, "utf8");
   if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.path);
+  await journalWrite(ctx2, "delete_note", input.path, raw, null);
   let trashedTo;
   if (input.permanent) {
-    await rm(absPath);
+    await rm2(absPath);
   } else {
-    await mkdir2(join(ctx2.vaultRoot, ".trash"), { recursive: true });
+    await mkdir3(join2(ctx2.vaultRoot, ".trash"), { recursive: true });
     trashedTo = await freeTrashPath(ctx2.vaultRoot, basename2(input.path));
-    await rename2(absPath, join(ctx2.vaultRoot, trashedTo));
+    await rename3(absPath, join2(ctx2.vaultRoot, trashedTo));
   }
   removeNoteBacklinks(ctx2, input.path);
   if (ctx2.notes.has(input.path)) {
@@ -1139,10 +1677,24 @@ function listTags(ctx2, input) {
   return { tags, total: tags.length };
 }
 
-// src/tools/move_note.ts
-import { access as access3, mkdir as mkdir3, readFile as readFile4, rename as rename3 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+// src/tools/list_writes.ts
 import { z as z10 } from "zod";
+var ListWritesInput = z10.object({
+  limit: z10.number().int().min(1).max(200).default(20).describe("Max entries to return, newest first (1\u2013200, default 20)."),
+  path: z10.string().optional().describe("Only entries that touched this vault-relative path.")
+});
+function listWrites(ctx2, rawInput) {
+  const input = ListWritesInput.parse(rawInput);
+  if (!ctx2.journal) return { writes: [], total: 0, disabled: true };
+  const opts = { limit: input.limit };
+  if (input.path !== void 0) opts.path = input.path;
+  return ctx2.journal.list(opts);
+}
+
+// src/tools/move_note.ts
+import { mkdir as mkdir4, readFile as readFile5, rename as rename4 } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+import { z as z11 } from "zod";
 
 // src/tools/rewrite_links.ts
 import { posix } from "path";
@@ -1237,14 +1789,14 @@ function hasMarkdownLinkTo(raw, sourcePath, targetPath) {
 }
 
 // src/tools/move_note.ts
-var MoveNoteInput = z10.object({
-  from: z10.string().describe("Vault-relative path of the note to move."),
-  to: z10.string().describe("Vault-relative destination path."),
-  overwrite: z10.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false."),
-  rewriteLinks: z10.boolean().default(true).describe(
+var MoveNoteInput = z11.object({
+  from: z11.string().describe("Vault-relative path of the note to move."),
+  to: z11.string().describe("Vault-relative destination path."),
+  overwrite: z11.boolean().default(false).describe("Overwrite the destination if it exists. Defaults to false."),
+  rewriteLinks: z11.boolean().default(true).describe(
     "Rewrite wikilinks and markdown links in other notes that point at the moved note, so nothing breaks. Defaults to true; pass false to move the file only."
   ),
-  prevHash: z10.string().optional().describe(
+  prevHash: z11.string().optional().describe(
     "Optional compare-and-swap guard on the source note: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -1256,20 +1808,19 @@ async function moveNote(ctx2, rawInput) {
   assertWritable(ctx2.policy, input.to);
   let raw;
   try {
-    raw = await readFile4(absFrom, "utf8");
+    raw = await readFile5(absFrom, "utf8");
   } catch {
     throw new Error(`Note not found: ${input.from}`);
   }
   if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.from);
-  if (!input.overwrite) {
-    try {
-      await access3(absTo);
-      throw new Error(
-        `Destination already exists: ${input.to}. Pass overwrite: true to replace it.`
-      );
-    } catch (err) {
-      if (err.code !== "ENOENT") throw err;
-    }
+  let existingAtTo = null;
+  try {
+    existingAtTo = await readFile5(absTo, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  if (existingAtTo !== null && !input.overwrite) {
+    throw new Error(`Destination already exists: ${input.to}. Pass overwrite: true to replace it.`);
   }
   const preNotes = new Map(ctx2.notes);
   const candidates = /* @__PURE__ */ new Set();
@@ -1281,20 +1832,13 @@ async function moveNote(ctx2, rawInput) {
     }
     candidates.delete(input.from);
   }
-  await mkdir3(dirname2(absTo), { recursive: true });
-  await rename3(absFrom, absTo);
-  removeNoteBacklinks(ctx2, input.from);
-  if (ctx2.notes.has(input.from)) {
-    ctx2.index.discard(input.from);
-    ctx2.notes.delete(input.from);
-  }
-  upsertDoc(ctx2, buildDoc(input.to, raw));
-  addNoteBacklinks(ctx2, input.to, raw);
-  let notesRewritten = 0;
-  let linksRewritten = 0;
+  const postNotes = new Map(preNotes);
+  postNotes.delete(input.from);
+  postNotes.set(input.to, buildDoc(input.to, raw));
+  const rewrites = [];
   const skipped = [];
   for (const path2 of [...candidates].sort()) {
-    const doc = ctx2.notes.get(path2);
+    const doc = preNotes.get(path2);
     if (doc === void 0) continue;
     if (!isWritable(ctx2.policy, path2)) {
       skipped.push(path2);
@@ -1306,11 +1850,34 @@ async function moveNote(ctx2, rawInput) {
       input.from,
       input.to,
       preNotes,
-      ctx2.notes
+      postNotes
     );
+    rewrites.push({ path: path2, pre: doc.raw, content, count });
+  }
+  if (ctx2.journal) {
+    const txn = ctx2.journal.begin("move_note");
+    await txn.add(input.from, raw, null);
+    await txn.add(input.to, existingAtTo, raw);
+    for (const r of rewrites) if (r.count > 0) await txn.add(r.path, r.pre, r.content);
+    await txn.commit();
+  }
+  await mkdir4(dirname2(absTo), { recursive: true });
+  await rename4(absFrom, absTo);
+  removeNoteBacklinks(ctx2, input.from);
+  if (ctx2.notes.has(input.from)) {
+    ctx2.index.discard(input.from);
+    ctx2.notes.delete(input.from);
+  }
+  upsertDoc(ctx2, buildDoc(input.to, raw));
+  addNoteBacklinks(ctx2, input.to, raw);
+  let notesRewritten = 0;
+  let linksRewritten = 0;
+  for (const { path: path2, content, count } of rewrites) {
+    const doc = ctx2.notes.get(path2);
+    if (doc === void 0) continue;
     removeNoteBacklinks(ctx2, path2);
     if (count > 0) {
-      await atomicWrite(join2(ctx2.vaultRoot, path2), content);
+      await atomicWrite(join3(ctx2.vaultRoot, path2), content);
       upsertDoc(ctx2, buildDoc(path2, content));
       notesRewritten++;
       linksRewritten += count;
@@ -1332,7 +1899,7 @@ async function moveNote(ctx2, rawInput) {
 }
 
 // src/tools/outline_note.ts
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 
 // ../core/src/outline.ts
 var HEADING_RE = /^(#{1,6})\s+(.+)/;
@@ -1382,15 +1949,15 @@ function buildOutline(raw, options = {}) {
 }
 
 // src/tools/outline_note.ts
-import { z as z11 } from "zod";
-var OutlineNoteInput = z11.object({
-  path: z11.string().describe("Vault-relative path to the note."),
-  includeBlocks: z11.boolean().default(true).describe("Include block-reference anchors (^id). Default true."),
-  includeSizes: z11.boolean().default(false).describe("Include per-section character length in each heading entry. Default false.")
+import { z as z12 } from "zod";
+var OutlineNoteInput = z12.object({
+  path: z12.string().describe("Vault-relative path to the note."),
+  includeBlocks: z12.boolean().default(true).describe("Include block-reference anchors (^id). Default true."),
+  includeSizes: z12.boolean().default(false).describe("Include per-section character length in each heading entry. Default false.")
 });
 async function outlineNote(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
-  const raw = await readFile5(absPath, "utf8");
+  const raw = await readFile6(absPath, "utf8");
   return buildOutline(raw, {
     includeBlocks: input.includeBlocks,
     includeSizes: input.includeSizes
@@ -1398,22 +1965,22 @@ async function outlineNote(ctx2, input) {
 }
 
 // src/tools/patch_frontmatter.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { parseDocument as parseDocument2 } from "yaml";
-import { z as z12 } from "zod";
-var PatchFrontmatterInput = z12.object({
-  path: z12.string().describe("Vault-relative path to the note."),
-  patch: z12.record(z12.string(), z12.unknown()).describe(
+import { z as z13 } from "zod";
+var PatchFrontmatterInput = z13.object({
+  path: z13.string().describe("Vault-relative path to the note."),
+  patch: z13.record(z13.string(), z13.unknown()).describe(
     "Key-value pairs to set in the frontmatter. Existing keys not in the patch are unchanged. Pass null as a value to remove a key."
   ),
-  prevHash: z12.string().optional().describe(
+  prevHash: z13.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
 async function patchFrontmatter(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
   assertWritable(ctx2.policy, input.path);
-  const original = await readFile6(absPath, "utf8");
+  const original = await readFile7(absPath, "utf8");
   if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, input.path);
   const fm = parseFrontmatter(original);
   const keysChanged = [];
@@ -1456,6 +2023,7 @@ ${original}`;
     const tail = opensWithCRLF ? "---\r\n" : "---\n";
     newContent = `${head}${doc.toString({ lineWidth: 0 })}${tail}${fm.body}`;
   }
+  await journalWrite(ctx2, "patch_frontmatter", input.path, original, newContent);
   await atomicWrite(absPath, newContent);
   const cached = ctx2.notes.get(input.path);
   if (cached) {
@@ -1473,22 +2041,22 @@ ${original}`;
 }
 
 // src/tools/patch_note.ts
-import { readFile as readFile7 } from "fs/promises";
-import { z as z13 } from "zod";
-var PatchNoteInput = z13.object({
-  path: z13.string().describe("Vault-relative path to the note."),
-  target: z13.union([
-    z13.object({ heading: z13.string().describe("Heading text (without # markers).") }),
-    z13.object({ block: z13.string().describe("Block reference ID (without the ^ prefix).") })
+import { readFile as readFile8 } from "fs/promises";
+import { z as z14 } from "zod";
+var PatchNoteInput = z14.object({
+  path: z14.string().describe("Vault-relative path to the note."),
+  target: z14.union([
+    z14.object({ heading: z14.string().describe("Heading text (without # markers).") }),
+    z14.object({ block: z14.string().describe("Block reference ID (without the ^ prefix).") })
   ]).describe("Target section. Provide exactly one of heading or block."),
-  operation: z13.enum(["append", "prepend", "replace"]).describe(
+  operation: z14.enum(["append", "prepend", "replace"]).describe(
     "append: insert after section content. prepend: insert after heading line. replace: swap section content."
   ),
-  content: z13.string().min(1).describe("Content to insert or replace with."),
-  createIfMissing: z13.boolean().default(false).describe(
+  content: z14.string().min(1).describe("Content to insert or replace with."),
+  createIfMissing: z14.boolean().default(false).describe(
     "If the heading target is not found, append a new heading (level 2) + content. Only valid for heading targets."
   ),
-  prevHash: z13.string().optional().describe(
+  prevHash: z14.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -1504,7 +2072,7 @@ function lineStart(raw, offset) {
 async function patchNote(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
   assertWritable(ctx2.policy, input.path);
-  const raw = await readFile7(absPath, "utf8");
+  const raw = await readFile8(absPath, "utf8");
   if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.path);
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
@@ -1522,6 +2090,7 @@ async function patchNote(ctx2, input) {
         const newContent2 = `${raw}${sep4}## ${targetText}
 
 ${input.content}${contentNl}`;
+        await journalWrite(ctx2, "patch_note", input.path, raw, newContent2);
         await atomicWrite(absPath, newContent2);
         await verifyFrontmatter(absPath, originalFmRegion);
         updateCache(ctx2, input.path, newContent2, fm.bodyStart);
@@ -1592,6 +2161,7 @@ ${input.content}${contentNl}`;
     default:
       throw new Error(`Unknown operation: ${String(input.operation)}`);
   }
+  await journalWrite(ctx2, "patch_note", input.path, raw, newContent);
   await atomicWrite(absPath, newContent);
   await verifyFrontmatter(absPath, originalFmRegion);
   updateCache(ctx2, input.path, newContent, fm.bodyStart);
@@ -1604,7 +2174,7 @@ ${input.content}${contentNl}`;
   };
 }
 async function verifyFrontmatter(absPath, originalFmRegion) {
-  const written = await readFile7(absPath, "utf8");
+  const written = await readFile8(absPath, "utf8");
   if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
     throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
   }
@@ -1619,10 +2189,10 @@ function updateCache(ctx2, path2, newContent, bodyStart) {
 }
 
 // src/tools/periodic_note.ts
-import { access as access4, mkdir as mkdir4, readFile as readFile8 } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
-import { z as z14 } from "zod";
-var PERIOD = z14.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
+import { access as access3, mkdir as mkdir5, readFile as readFile9 } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
+import { z as z15 } from "zod";
+var PERIOD = z15.enum(["daily", "weekly", "monthly", "quarterly", "yearly"]);
 var DEFAULTS = {
   daily: { folder: "", format: "YYYY-MM-DD", template: "" },
   weekly: { folder: "", format: "gggg-[W]ww", template: "" },
@@ -1632,7 +2202,7 @@ var DEFAULTS = {
 };
 async function readJson(absPath) {
   try {
-    return JSON.parse(await readFile8(absPath, "utf8"));
+    return JSON.parse(await readFile9(absPath, "utf8"));
   } catch {
     return null;
   }
@@ -1640,7 +2210,7 @@ async function readJson(absPath) {
 async function resolveConfig(vaultRoot2, period) {
   const defaults = DEFAULTS[period];
   if (period === "daily") {
-    const cfg2 = await readJson(join3(vaultRoot2, ".obsidian", "daily-notes.json"));
+    const cfg2 = await readJson(join4(vaultRoot2, ".obsidian", "daily-notes.json"));
     return {
       folder: cfg2?.folder ?? defaults.folder,
       format: cfg2?.format ?? defaults.format,
@@ -1648,7 +2218,7 @@ async function resolveConfig(vaultRoot2, period) {
     };
   }
   const cfg = await readJson(
-    join3(vaultRoot2, ".obsidian", "plugins", "periodic-notes", "data.json")
+    join4(vaultRoot2, ".obsidian", "plugins", "periodic-notes", "data.json")
   );
   const entry = cfg?.[period];
   return {
@@ -1687,12 +2257,12 @@ function resolveNotePath(cfg, date) {
   const filename = `${formatMomentDate(date, cfg.format)}.md`;
   return cfg.folder ? `${cfg.folder}/${filename}` : filename;
 }
-var GetPeriodicNoteInput = z14.object({
+var GetPeriodicNoteInput = z15.object({
   period: PERIOD.default("daily").describe(
     "Period type: daily (default), weekly, monthly, quarterly, or yearly."
   ),
-  date: z14.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
-  createIfMissing: z14.boolean().default(false).describe(
+  date: z15.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today when omitted."),
+  createIfMissing: z15.boolean().default(false).describe(
     "Create the note from the configured template if it does not exist. Default false \u2014 reports missing without creating."
   )
 });
@@ -1704,7 +2274,7 @@ async function getPeriodicNote(ctx2, rawInput) {
   const abs = resolveVaultPath(ctx2.vaultRoot, path2);
   let existed = false;
   try {
-    await access4(abs);
+    await access3(abs);
     existed = true;
   } catch {
   }
@@ -1718,21 +2288,22 @@ async function getPeriodicNote(ctx2, rawInput) {
         ctx2.vaultRoot,
         cfg.template.endsWith(".md") ? cfg.template : `${cfg.template}.md`
       );
-      body = await readFile8(templateAbs, "utf8");
+      body = await readFile9(templateAbs, "utf8");
     } catch {
     }
   }
-  await mkdir4(dirname3(abs), { recursive: true });
+  await mkdir5(dirname3(abs), { recursive: true });
+  await journalWrite(ctx2, "get_periodic_note", path2, null, body);
   await atomicWrite(abs, body);
   upsertDoc(ctx2, buildDoc(path2, body));
   return { path: path2, existed: false, created: true, contentHash: contentHash(body) };
 }
-var AppendPeriodicNoteInput = z14.object({
+var AppendPeriodicNoteInput = z15.object({
   period: PERIOD.default("daily").describe("Period type. Default: daily."),
-  date: z14.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
-  content: z14.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
-  createIfMissing: z14.boolean().default(true).describe("Create the note if it does not exist before appending. Default true."),
-  prevHash: z14.string().optional().describe(
+  date: z15.string().optional().describe("ISO date string (YYYY-MM-DD). Defaults to today."),
+  content: z15.string().min(1).describe("Text to append to the note body. Separated from existing content by a blank line."),
+  createIfMissing: z15.boolean().default(true).describe("Create the note if it does not exist before appending. Default true."),
+  prevHash: z15.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read of the resolved periodic note. Fails with hash_conflict if it changed since."
   )
 });
@@ -1745,7 +2316,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
   assertWritable(ctx2.policy, path2);
   let original = "";
   try {
-    original = await readFile8(abs, "utf8");
+    original = await readFile9(abs, "utf8");
     if (input.prevHash !== void 0) assertHashMatch(original, input.prevHash, path2);
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
@@ -1761,7 +2332,8 @@ async function appendPeriodicNote(ctx2, rawInput) {
       );
     }
     if (!input.createIfMissing) throw new Error(`Periodic note not found: ${path2}`);
-    await mkdir4(dirname3(abs), { recursive: true });
+    await mkdir5(dirname3(abs), { recursive: true });
+    await journalWrite(ctx2, "append_periodic_note", path2, null, input.content);
     await atomicWrite(abs, input.content);
     upsertDoc(ctx2, buildDoc(path2, input.content));
     return {
@@ -1777,6 +2349,7 @@ async function appendPeriodicNote(ctx2, rawInput) {
   const newBody = `${body}${separator}${input.content}`;
   const header = original.slice(0, fm.bodyStart);
   const newRaw = `${header}${newBody}`;
+  await journalWrite(ctx2, "append_periodic_note", path2, original, newRaw);
   await atomicWrite(abs, newRaw);
   const cached = ctx2.notes.get(path2);
   if (cached) {
@@ -1791,36 +2364,36 @@ async function appendPeriodicNote(ctx2, rawInput) {
 }
 
 // src/tools/query_notes.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var OPS_WITHOUT_VALUE = /* @__PURE__ */ new Set(["exists", "missing"]);
-var Predicate = z15.object({
-  key: z15.string().min(1).describe("Frontmatter key to test (top-level)."),
-  op: z15.enum(["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"]).describe(
+var Predicate = z16.object({
+  key: z16.string().min(1).describe("Frontmatter key to test (top-level)."),
+  op: z16.enum(["eq", "ne", "contains", "exists", "missing", "gt", "gte", "lt", "lte"]).describe(
     "eq/ne compare scalars; contains matches array membership or substring; exists/missing test key presence; gt/gte/lt/lte compare numbers or strings (ISO dates sort correctly)."
   ),
-  value: z15.union([z15.string(), z15.number(), z15.boolean()]).optional().describe("Comparison value. Required for every op except exists/missing.")
+  value: z16.union([z16.string(), z16.number(), z16.boolean()]).optional().describe("Comparison value. Required for every op except exists/missing.")
 }).refine((p) => OPS_WITHOUT_VALUE.has(p.op) || p.value !== void 0, {
   message: "value is required for this op"
 });
-var ISO_DATE = z15.string().refine((s) => !Number.isNaN(Date.parse(s)), { message: "not a parseable date" });
-var QueryNotesInput = z15.object({
-  where: z15.array(Predicate).max(20).default([]).describe("Frontmatter predicates. All must match (AND)."),
-  folder: z15.string().optional().describe("Restrict to notes under this vault-relative folder prefix."),
-  tag: z15.string().optional().describe("Restrict to notes with this tag (# prefix optional)."),
+var ISO_DATE = z16.string().refine((s) => !Number.isNaN(Date.parse(s)), { message: "not a parseable date" });
+var QueryNotesInput = z16.object({
+  where: z16.array(Predicate).max(20).default([]).describe("Frontmatter predicates. All must match (AND)."),
+  folder: z16.string().optional().describe("Restrict to notes under this vault-relative folder prefix."),
+  tag: z16.string().optional().describe("Restrict to notes with this tag (# prefix optional)."),
   modifiedAfter: ISO_DATE.optional().describe(
     "Only notes modified at or after this ISO 8601 date/time."
   ),
   modifiedBefore: ISO_DATE.optional().describe(
     "Only notes modified before this ISO 8601 date/time."
   ),
-  minSizeBytes: z15.number().int().min(0).optional().describe("Only notes at least this many bytes."),
-  maxSizeBytes: z15.number().int().min(0).optional().describe("Only notes at most this many bytes."),
-  select: z15.array(z15.string()).max(20).default([]).describe(
+  minSizeBytes: z16.number().int().min(0).optional().describe("Only notes at least this many bytes."),
+  maxSizeBytes: z16.number().int().min(0).optional().describe("Only notes at most this many bytes."),
+  select: z16.array(z16.string()).max(20).default([]).describe(
     'Extra fields to return per hit: frontmatter keys, or the specials "mtime", "size", "tags". Default returns only path + title, keeping the payload minimal.'
   ),
-  sort: z15.enum(["path", "title", "mtime", "size"]).default("path").describe("Sort field."),
-  order: z15.enum(["asc", "desc"]).default("asc").describe("Sort order."),
-  limit: z15.number().int().min(1).max(500).default(100).describe("Maximum number of results.")
+  sort: z16.enum(["path", "title", "mtime", "size"]).default("path").describe("Sort field."),
+  order: z16.enum(["asc", "desc"]).default("asc").describe("Sort order."),
+  limit: z16.number().int().min(1).max(500).default(100).describe("Maximum number of results.")
 });
 function scalarEq(a, b) {
   if (a === b) return true;
@@ -1918,17 +2491,17 @@ function queryNotes(ctx2, input) {
 }
 
 // src/tools/read_note.ts
-import { readFile as readFile9 } from "fs/promises";
-import { z as z16 } from "zod";
-var ReadNoteInput = z16.object({
-  path: z16.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
-  section: z16.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
-  block: z16.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
-  lines: z16.object({
-    from: z16.number().int().min(1).describe("First line (1-indexed, inclusive)."),
-    to: z16.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
+import { readFile as readFile10 } from "fs/promises";
+import { z as z17 } from "zod";
+var ReadNoteInput = z17.object({
+  path: z17.string().describe('Vault-relative path to the note, e.g. "Daily Notes/2026-05-29.md".'),
+  section: z17.string().optional().describe("Return only this heading section (heading text, # prefix optional)."),
+  block: z17.string().optional().describe("Return only the block anchored by this id (^ prefix optional)."),
+  lines: z17.object({
+    from: z17.number().int().min(1).describe("First line (1-indexed, inclusive)."),
+    to: z17.number().int().min(1).optional().describe("Last line (1-indexed, inclusive). Defaults to end of file.")
   }).optional().describe("Return only this line range (1-indexed, inclusive)."),
-  includeFrontmatter: z16.boolean().optional().describe(
+  includeFrontmatter: z17.boolean().optional().describe(
     "Include frontmatter in span results. Default false for section/block spans. No effect on lines or whole-note reads."
   )
 }).refine((v) => [v.section, v.block, v.lines].filter((x) => x !== void 0).length <= 1, {
@@ -1936,7 +2509,7 @@ var ReadNoteInput = z16.object({
 });
 async function readNote(ctx2, input) {
   const absPath = resolveVaultPath(ctx2.vaultRoot, input.path);
-  const raw = await readFile9(absPath, "utf8");
+  const raw = await readFile10(absPath, "utf8");
   const noteBytes = Buffer.byteLength(raw, "utf8");
   const hash = contentHash(raw);
   if (input.section === void 0 && input.block === void 0 && input.lines === void 0) {
@@ -2024,18 +2597,18 @@ async function readNote(ctx2, input) {
 }
 
 // src/tools/rename_heading.ts
-import { readFile as readFile10 } from "fs/promises";
-import { join as join4 } from "path";
-import { z as z17 } from "zod";
-var RenameHeadingInput = z17.object({
-  path: z17.string().describe("Vault-relative path of the note containing the heading."),
-  oldHeading: z17.string().min(1).describe(
+import { readFile as readFile11 } from "fs/promises";
+import { join as join5 } from "path";
+import { z as z18 } from "zod";
+var RenameHeadingInput = z18.object({
+  path: z18.string().describe("Vault-relative path of the note containing the heading."),
+  oldHeading: z18.string().min(1).describe(
     "Current heading text, without # markers. Matched case-insensitively; if the note has duplicate headings the first one wins, mirroring Obsidian link resolution."
   ),
-  newHeading: z17.string().min(1).refine((s) => !/[\n[\]|#]/.test(s), {
+  newHeading: z18.string().min(1).refine((s) => !/[\n[\]|#]/.test(s), {
     message: 'newHeading must not contain newlines, "[", "]", "|", or "#" \u2014 those break [[note#heading]] link syntax.'
   }).describe("New heading text, without # markers."),
-  prevHash: z17.string().optional().describe(
+  prevHash: z18.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read of this note. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2065,7 +2638,7 @@ async function renameHeading(ctx2, rawInput) {
   assertWritable(ctx2.policy, input.path);
   let raw;
   try {
-    raw = await readFile10(absPath, "utf8");
+    raw = await readFile11(absPath, "utf8");
   } catch {
     throw new Error(`Note not found: ${input.path}`);
   }
@@ -2099,21 +2672,11 @@ async function renameHeading(ctx2, rawInput) {
     (target) => target === "" || resolveLink(target, ctx2.notes) === input.path
   );
   newRaw = newRaw.slice(0, fm.bodyStart) + selfRewrite.content;
-  const originalFmRegion = raw.slice(0, fm.bodyStart);
-  await atomicWrite(absPath, newRaw);
-  const written = await readFile10(absPath, "utf8");
-  if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
-    throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
-  }
-  removeNoteBacklinks(ctx2, input.path);
-  upsertDoc(ctx2, buildDoc(input.path, newRaw));
-  addNoteBacklinks(ctx2, input.path, newRaw);
-  let notesRewritten = selfRewrite.count > 0 ? 1 : 0;
-  let linksRewritten = selfRewrite.count;
-  const skipped = [];
   const candidates = /* @__PURE__ */ new Set();
   for (const ref of ctx2.backlinks.get(input.path) ?? []) candidates.add(ref.path);
   candidates.delete(input.path);
+  const rewrites = [];
+  const skipped = [];
   for (const path2 of [...candidates].sort()) {
     const doc = ctx2.notes.get(path2);
     if (doc === void 0) continue;
@@ -2128,7 +2691,27 @@ async function renameHeading(ctx2, rawInput) {
       skipped.push(path2);
       continue;
     }
-    await atomicWrite(join4(ctx2.vaultRoot, path2), content);
+    rewrites.push({ path: path2, pre: doc.raw, content, count });
+  }
+  if (ctx2.journal) {
+    const txn = ctx2.journal.begin("rename_heading");
+    await txn.add(input.path, raw, newRaw);
+    for (const r of rewrites) await txn.add(r.path, r.pre, r.content);
+    await txn.commit();
+  }
+  const originalFmRegion = raw.slice(0, fm.bodyStart);
+  await atomicWrite(absPath, newRaw);
+  const written = await readFile11(absPath, "utf8");
+  if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
+    throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
+  }
+  removeNoteBacklinks(ctx2, input.path);
+  upsertDoc(ctx2, buildDoc(input.path, newRaw));
+  addNoteBacklinks(ctx2, input.path, newRaw);
+  let notesRewritten = selfRewrite.count > 0 ? 1 : 0;
+  let linksRewritten = selfRewrite.count;
+  for (const { path: path2, content, count } of rewrites) {
+    await atomicWrite(join5(ctx2.vaultRoot, path2), content);
     upsertDoc(ctx2, buildDoc(path2, content));
     notesRewritten++;
     linksRewritten += count;
@@ -2147,18 +2730,18 @@ async function renameHeading(ctx2, rawInput) {
 }
 
 // src/tools/replace_in_note.ts
-import { readFile as readFile11 } from "fs/promises";
-import { z as z18 } from "zod";
-var ReplaceInNoteInput = z18.object({
-  path: z18.string().describe("Vault-relative path to the note."),
-  find: z18.string().min(1).max(1e3).describe("Text or pattern to find (max 1000 chars; bounds regex-mode pattern size)."),
-  replace: z18.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
-  regex: z18.boolean().default(false).describe("Treat find as a regular expression."),
-  caseSensitive: z18.boolean().default(false).describe("Case-sensitive matching."),
-  wholeWord: z18.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
-  limit: z18.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
-  dryRun: z18.boolean().default(false).describe("If true, report matches without writing anything."),
-  prevHash: z18.string().optional().describe(
+import { readFile as readFile12 } from "fs/promises";
+import { z as z19 } from "zod";
+var ReplaceInNoteInput = z19.object({
+  path: z19.string().describe("Vault-relative path to the note."),
+  find: z19.string().min(1).max(1e3).describe("Text or pattern to find (max 1000 chars; bounds regex-mode pattern size)."),
+  replace: z19.string().describe("Replacement text. Supports $1, $2, \u2026 backreferences in regex mode."),
+  regex: z19.boolean().default(false).describe("Treat find as a regular expression."),
+  caseSensitive: z19.boolean().default(false).describe("Case-sensitive matching."),
+  wholeWord: z19.boolean().default(false).describe("Match whole words only (\\b word-boundary)."),
+  limit: z19.number().int().min(1).optional().describe("Maximum number of replacements. Omit to replace all."),
+  dryRun: z19.boolean().default(false).describe("If true, report matches without writing anything."),
+  prevHash: z19.string().optional().describe(
     "Optional compare-and-swap guard: the contentHash from a prior read. Fails with hash_conflict if the note changed since."
   )
 });
@@ -2184,7 +2767,7 @@ async function replaceInNote(ctx2, input) {
   } catch (err) {
     throw new Error(`Invalid regex: ${err instanceof Error ? err.message : String(err)}`);
   }
-  const raw = await readFile11(absPath, "utf8");
+  const raw = await readFile12(absPath, "utf8");
   if (input.prevHash !== void 0) assertHashMatch(raw, input.prevHash, input.path);
   const fm = parseFrontmatter(raw);
   const originalFmRegion = raw.slice(0, fm.bodyStart);
@@ -2218,8 +2801,9 @@ async function replaceInNote(ctx2, input) {
   }
   newBody += body.slice(lastIndex);
   const newContent = `${originalFmRegion}${newBody}`;
+  await journalWrite(ctx2, "replace_in_note", input.path, raw, newContent);
   await atomicWrite(absPath, newContent);
-  const written = await readFile11(absPath, "utf8");
+  const written = await readFile12(absPath, "utf8");
   if (written.slice(0, originalFmRegion.length) !== originalFmRegion) {
     throw new Error("Write-safety violation: frontmatter region changed unexpectedly");
   }
@@ -2239,6 +2823,123 @@ async function replaceInNote(ctx2, input) {
   };
 }
 
+// src/tools/undo_write.ts
+import { mkdir as mkdir6, readFile as readFile13, rm as rm3 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+import { z as z20 } from "zod";
+var UndoWriteInput = z20.object({
+  seq: z20.number().int().min(1).optional().describe(
+    "Journal entry to revert (from list_writes). Defaults to the most recent undoable write."
+  ),
+  force: z20.boolean().default(false).describe(
+    "Restore even if a file changed after the journaled write. The clobbered state is journaled first, so nothing is lost. Defaults to false \u2014 conflicts are refused."
+  )
+});
+async function undoWrite(ctx2, rawInput) {
+  const input = UndoWriteInput.parse(rawInput);
+  const journal = ctx2.journal;
+  if (!journal) {
+    throw new Error("Write journal is disabled (SEEKSTONE_HISTORY=0); nothing to undo.");
+  }
+  let entry;
+  if (input.seq === void 0) {
+    entry = journal.latestUndoable();
+    if (!entry) throw new Error("No undoable writes in the journal.");
+  } else {
+    entry = journal.get(input.seq);
+    if (!entry) throw new Error(`Journal entry ${input.seq} not found.`);
+    if (!journal.isUndoable(entry)) {
+      throw new Error(
+        JSON.stringify({
+          error: "entry_evicted",
+          seq: entry.seq,
+          hint: "Its pre-image was evicted by the retention cap (SEEKSTONE_HISTORY_MAX_SIZE); it can no longer be undone."
+        })
+      );
+    }
+  }
+  for (const f of entry.files) assertWritable(ctx2.policy, f.path);
+  const current = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  for (const f of entry.files) {
+    const abs = resolveVaultPath(ctx2.vaultRoot, f.path);
+    let cur = null;
+    try {
+      cur = await readFile13(abs, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    current.set(f.path, cur);
+    const actualHash = cur === null ? null : contentHash(cur);
+    if (actualHash !== f.postHash) {
+      conflicts.push({
+        path: f.path,
+        expectedHash: f.postHash,
+        actualHash,
+        expectedBytes: f.postHash === null ? null : await postBytes(journal, f.postHash),
+        actualBytes: cur === null ? null : Buffer.byteLength(cur, "utf8")
+      });
+    }
+  }
+  if (conflicts.length > 0 && !input.force) {
+    throw new Error(
+      JSON.stringify({
+        error: "undo_conflict",
+        seq: entry.seq,
+        conflicts,
+        hint: "A file changed after this write (by you or another tool). Re-check it, then pass force: true to restore anyway \u2014 the current state is journaled first."
+      })
+    );
+  }
+  const preimages = /* @__PURE__ */ new Map();
+  for (const f of entry.files) {
+    preimages.set(f.path, f.preHash === null ? null : await journal.preimage(f.preHash));
+  }
+  const txn = journal.begin("undo_write", entry.seq);
+  for (const f of entry.files) {
+    await txn.add(f.path, current.get(f.path) ?? null, preimages.get(f.path) ?? null);
+  }
+  const undoEntry = await txn.commit();
+  const restored = [];
+  for (const f of entry.files) {
+    const abs = resolveVaultPath(ctx2.vaultRoot, f.path);
+    const pre = preimages.get(f.path) ?? null;
+    if (pre === null) {
+      await rm3(abs, { force: true });
+      removeNoteBacklinks(ctx2, f.path);
+      if (ctx2.notes.has(f.path)) {
+        ctx2.index.discard(f.path);
+        ctx2.notes.delete(f.path);
+      }
+      restored.push({ path: f.path, restoredHash: null });
+    } else {
+      await mkdir6(dirname4(abs), { recursive: true });
+      await atomicWrite(abs, pre);
+      if (f.path.endsWith(".md")) {
+        removeNoteBacklinks(ctx2, f.path);
+        upsertDoc(ctx2, buildDoc(f.path, pre));
+        addNoteBacklinks(ctx2, f.path, pre);
+      }
+      restored.push({ path: f.path, restoredHash: contentHash(pre) });
+    }
+  }
+  const result = {
+    seq: entry.seq,
+    undoSeq: undoEntry.seq,
+    tool: entry.tool,
+    restored
+  };
+  if (conflicts.length > 0) result.overrode = conflicts;
+  return result;
+}
+async function postBytes(journal, hash) {
+  try {
+    return Buffer.byteLength(await journal.preimage(hash), "utf8");
+  } catch {
+    return null;
+  }
+}
+
 // src/dispatch.ts
 var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "create_note",
@@ -2249,7 +2950,8 @@ var WRITE_TOOLS = /* @__PURE__ */ new Set([
   "patch_frontmatter",
   "patch_note",
   "replace_in_note",
-  "append_periodic_note"
+  "append_periodic_note",
+  "undo_write"
 ]);
 var META_KEYS = [
   "path",
@@ -2273,7 +2975,9 @@ var META_KEYS = [
   "date",
   "permanent",
   "prevHash",
-  "budgetBytes"
+  "budgetBytes",
+  "seq",
+  "force"
 ];
 function safeMeta(args) {
   if (typeof args !== "object" || args === null) return {};
@@ -2297,7 +3001,7 @@ async function dispatch(ctx2, name, args, log2) {
   log2.debug("tool start", { tool: name, args });
   if (ctx2.policy.readOnly && WRITE_TOOLS.has(name)) {
     log2.info("tool rejected (read-only)", { tool: name, ...meta });
-    return {
+    const rejected = {
       content: [
         {
           type: "text",
@@ -2306,17 +3010,39 @@ async function dispatch(ctx2, name, args, log2) {
       ],
       isError: true
     };
+    return audit(ctx2, log2, rejected, {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      tool: name,
+      outcome: "policy_denied",
+      policy: "read_only",
+      error: "read_only",
+      durationMs: 0,
+      ...pathMeta(meta)
+    });
   }
   if (ctx2.policy.readOnly && name === "get_periodic_note") {
     if (typeof args === "object" && args !== null) {
       args = { ...args, createIfMissing: false };
     }
   }
+  const isWrite = WRITE_TOOLS.has(name) || name === "get_periodic_note";
+  const seqBefore = ctx2.journal?.lastSeq ?? 0;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    const result = await run(ctx2, name, args);
+    const { audit: detail, ...result } = await run(ctx2, name, args);
     const durationMs = Math.round((performance.now() - start) * 100) / 100;
     log2.info("tool ok", { tool: name, durationMs, resultBytes: resultBytes(result), ...meta });
-    return result;
+    if (!isWrite || detail === void 0) return result;
+    return audit(ctx2, log2, result, {
+      v: 1,
+      ts,
+      tool: name,
+      outcome: "ok",
+      durationMs,
+      ...journalFiles(ctx2, seqBefore, detail),
+      ...detail
+    });
   } catch (err) {
     const durationMs = Math.round((performance.now() - start) * 100) / 100;
     const message = err instanceof Error ? err.message : String(err);
@@ -2327,7 +3053,66 @@ async function dispatch(ctx2, name, args, log2) {
       stack: err instanceof Error ? err.stack : void 0,
       ...meta
     });
-    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+    const failed = {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+    if (!isWrite) return failed;
+    return audit(ctx2, log2, failed, {
+      v: 1,
+      ts,
+      tool: name,
+      ...classifyError(message),
+      durationMs,
+      ...pathMeta(meta)
+    });
+  }
+}
+function pathMeta(meta) {
+  const out = {};
+  for (const k of ["path", "from", "to", "seq"])
+    if (meta[k] !== void 0) out[k] = meta[k];
+  return out;
+}
+function journalFiles(ctx2, seqBefore, detail) {
+  const entry = ctx2.journal?.since(seqBefore).at(-1);
+  if (entry !== void 0) {
+    return {
+      seq: entry.seq,
+      files: entry.files.map((f) => ({
+        path: f.path,
+        hashBefore: f.preHash,
+        hashAfter: f.postHash
+      }))
+    };
+  }
+  if (typeof detail.path === "string" && typeof detail.contentHash === "string") {
+    return { files: [{ path: detail.path, hashAfter: detail.contentHash }] };
+  }
+  return {};
+}
+function audit(ctx2, log2, result, rec) {
+  if (!ctx2.audit) return result;
+  try {
+    ctx2.audit.record(rec);
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log2.error("audit write failed", { tool: rec.tool, error: message });
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${JSON.stringify({
+            error: "audit_failed",
+            tool: rec.tool,
+            outcome: rec.outcome,
+            hint: `The audit record could not be written (${message}). The vault operation itself ${rec.outcome === "ok" ? "DID complete" : "did not run"}; fix SEEKSTONE_AUDIT_FILE before continuing.`
+          })}`
+        }
+      ],
+      isError: true
+    };
   }
 }
 async function run(ctx2, name, args) {
@@ -2371,14 +3156,26 @@ async function run(ctx2, name, args) {
             type: "text",
             text: `Created ${result.path} (${result.bytesWritten} bytes). contentHash: ${result.contentHash}`
           }
-        ]
+        ],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          bytesWritten: result.bytesWritten,
+          overwrite: input.overwrite
+        }
       };
     }
     case "delete_note": {
       const input = DeleteNoteInput.parse(args);
       const result = await deleteNote(ctx2, input);
       const text = result.trashedTo ? `Moved ${result.path} to ${result.trashedTo} (recoverable \u2014 restore by moving it back).` : `Permanently deleted ${result.path}.`;
-      return { content: [{ type: "text", text }] };
+      const audit2 = {
+        path: result.path,
+        contentHash: result.contentHash,
+        permanent: result.permanent
+      };
+      if (result.trashedTo !== void 0) audit2.trashedTo = result.trashedTo;
+      return { content: [{ type: "text", text }], audit: audit2 };
     }
     case "move_note": {
       const input = MoveNoteInput.parse(args);
@@ -2387,7 +3184,17 @@ async function run(ctx2, name, args) {
       if (result.skipped?.length) {
         text += ` Skipped (outside SEEKSTONE_WRITE_PATHS): ${result.skipped.join(", ")}.`;
       }
-      return { content: [{ type: "text", text }] };
+      return {
+        content: [{ type: "text", text }],
+        audit: {
+          from: result.from,
+          to: result.to,
+          contentHash: result.contentHash,
+          notesRewritten: result.notesRewritten,
+          linksRewritten: result.linksRewritten,
+          ...result.skipped?.length ? { skipped: result.skipped } : {}
+        }
+      };
     }
     case "rename_heading": {
       const input = RenameHeadingInput.parse(args);
@@ -2396,7 +3203,17 @@ async function run(ctx2, name, args) {
       if (result.skipped?.length) {
         text += ` Skipped (outside SEEKSTONE_WRITE_PATHS): ${result.skipped.join(", ")}.`;
       }
-      return { content: [{ type: "text", text }] };
+      return {
+        content: [{ type: "text", text }],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          line: result.line,
+          notesRewritten: result.notesRewritten,
+          linksRewritten: result.linksRewritten,
+          ...result.skipped?.length ? { skipped: result.skipped } : {}
+        }
+      };
     }
     case "append_note": {
       const input = AppendNoteInput.parse(args);
@@ -2407,13 +3224,28 @@ async function run(ctx2, name, args) {
             type: "text",
             text: `Appended ${result.bytesWritten} bytes to ${result.path}. contentHash: ${result.contentHash}`
           }
-        ]
+        ],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          bytesWritten: result.bytesWritten
+        }
       };
     }
     case "patch_frontmatter": {
       const input = PatchFrontmatterInput.parse(args);
       const result = await patchFrontmatter(ctx2, input);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        // Key NAMES only — values are note content and never leave the tool.
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          keysChanged: result.keysChanged,
+          keysAdded: result.keysAdded,
+          keysRemoved: result.keysRemoved
+        }
+      };
     }
     case "outline_note": {
       const input = OutlineNoteInput.parse(args);
@@ -2423,7 +3255,16 @@ async function run(ctx2, name, args) {
     case "patch_note": {
       const input = PatchNoteInput.parse(args);
       const result = await patchNote(ctx2, input);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          bytesWritten: result.bytesWritten,
+          operation: input.operation,
+          targetLine: result.targetResolvedAt.line
+        }
+      };
     }
     case "get_backlinks": {
       const input = GetBacklinksInput.parse(args);
@@ -2438,12 +3279,26 @@ async function run(ctx2, name, args) {
     case "replace_in_note": {
       const input = ReplaceInNoteInput.parse(args);
       const result = await replaceInNote(ctx2, input);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          replacements: result.replacements,
+          dryRun: input.dryRun
+        }
+      };
     }
     case "get_periodic_note": {
       const input = GetPeriodicNoteInput.parse(args);
       const result = await getPeriodicNote(ctx2, input);
-      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      const out = {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+      if (result.created) {
+        out.audit = { path: result.path, contentHash: result.contentHash, created: true };
+      }
+      return out;
     }
     case "append_periodic_note": {
       const input = AppendPeriodicNoteInput.parse(args);
@@ -2454,7 +3309,29 @@ async function run(ctx2, name, args) {
             type: "text",
             text: `Appended ${result.bytesWritten} bytes to ${result.path}. contentHash: ${result.contentHash}`
           }
-        ]
+        ],
+        audit: {
+          path: result.path,
+          contentHash: result.contentHash,
+          bytesWritten: result.bytesWritten
+        }
+      };
+    }
+    case "list_writes": {
+      const input = ListWritesInput.parse(args);
+      const result = listWrites(ctx2, input);
+      return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    case "undo_write": {
+      const input = UndoWriteInput.parse(args);
+      const result = await undoWrite(ctx2, input);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        audit: {
+          undoOf: result.seq,
+          restored: result.restored.length,
+          ...result.overrode ? { forced: true, overrode: result.overrode.length } : {}
+        }
       };
     }
     default:
@@ -2463,12 +3340,12 @@ async function run(ctx2, name, args) {
 }
 
 // src/index/build.ts
-import { readFile as readFile12 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 import { basename as basename3, extname as extname4 } from "path";
 
 // ../core/src/walk.ts
-import { stat } from "fs/promises";
-import { extname as extname3, join as join5, relative, sep as sep2 } from "path";
+import { stat as stat2 } from "fs/promises";
+import { extname as extname3, join as join6, relative, sep as sep2 } from "path";
 import fg from "fast-glob";
 var IMAGE_EXTS = /* @__PURE__ */ new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".bmp", ".heic"]);
 var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".mov", ".webm", ".mkv", ".avi"]);
@@ -2476,6 +3353,7 @@ var AUDIO_EXTS = /* @__PURE__ */ new Set([".mp3", ".m4a", ".wav", ".flac", ".ogg
 var IGNORE_GLOBS = [
   "**/.obsidian/**",
   "**/.trash/**",
+  "**/.seekstone/**",
   "**/.git/**",
   "**/.DS_Store",
   "**/node_modules/**"
@@ -2507,7 +3385,7 @@ async function walkVault(vaultRoot2) {
   const entries = [];
   for (const m of matches2) {
     const absPath = typeof m === "string" ? m : m.path;
-    const stats = typeof m === "string" ? await stat(absPath) : m.stats;
+    const stats = typeof m === "string" ? await stat2(absPath) : m.stats;
     if (!stats) continue;
     const relPath = relative(vaultRoot2, absPath).split(sep2).join("/");
     const topDir = relPath.split("/")[0] ?? "";
@@ -2545,7 +3423,7 @@ async function buildIndex(vaultRoot2) {
   await Promise.all(
     noteEntries.map(async (entry) => {
       try {
-        const raw = await readFile12(entry.absPath, "utf8");
+        const raw = await readFile14(entry.absPath, "utf8");
         const fm = parseFrontmatter(raw);
         const inlineTags = extractInlineTags(fm.body);
         const fmTags = frontmatterTags(fm.data);
@@ -2598,8 +3476,8 @@ function buildBacklinks(notes2) {
 
 // src/init.ts
 import { execFileSync } from "child_process";
-import { access as access5, copyFile, mkdir as mkdir5, readdir, readFile as readFile13, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import path, { dirname as dirname4, join as join6 } from "path";
+import { access as access4, copyFile, mkdir as mkdir7, readdir as readdir2, readFile as readFile15, stat as stat3, writeFile as writeFile2 } from "fs/promises";
+import path, { dirname as dirname5, join as join7 } from "path";
 function parseInitArgs(argv) {
   const opts = { write: false, client: "desktop" };
   for (let i = 0; i < argv.length; i++) {
@@ -2642,7 +3520,7 @@ function cursorConfigPath(platform, env) {
   return j(env.home ?? "", ".cursor", "mcp.json");
 }
 function vscodeMcpConfigPath(cwd) {
-  return join6(cwd, ".vscode", "mcp.json");
+  return join7(cwd, ".vscode", "mcp.json");
 }
 function obsidianRegistryPath(platform, env) {
   if (platform === "win32") {
@@ -2698,13 +3576,13 @@ function mergeSeekstoneConfigVsCode(existing, vaultPath) {
 }
 async function validateVault(vaultPath) {
   try {
-    const st = await stat2(vaultPath);
+    const st = await stat3(vaultPath);
     if (!st.isDirectory()) return { ok: false, error: `Not a directory: ${vaultPath}` };
   } catch {
     return { ok: false, error: `Path does not exist: ${vaultPath}` };
   }
   try {
-    await access5(join6(vaultPath, ".obsidian"));
+    await access4(join7(vaultPath, ".obsidian"));
   } catch {
     return {
       ok: false,
@@ -2718,13 +3596,13 @@ async function countMarkdown(root) {
   async function walk(dir) {
     let entries;
     try {
-      entries = await readdir(dir, { withFileTypes: true });
+      entries = await readdir2(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (e.name.startsWith(".")) continue;
-      const full = join6(dir, e.name);
+      const full = join7(dir, e.name);
       if (e.isDirectory()) await walk(full);
       else if (e.name.endsWith(".md")) count++;
     }
@@ -2742,7 +3620,7 @@ async function runInit(opts, deps) {
       ]
     };
   }
-  const rf = deps.readFile ?? readFile13;
+  const rf = deps.readFile ?? readFile15;
   let vaultPath = opts.vault ?? deps.env.SEEKSTONE_VAULT;
   if (!vaultPath) {
     const registryPath = obsidianRegistryPath(deps.platform, {
@@ -2873,7 +3751,7 @@ async function runInit(opts, deps) {
   }
   const merged = opts.client === "vscode" ? mergeSeekstoneConfigVsCode(existing, vaultPath) : mergeSeekstoneConfig(existing, vaultPath);
   let backupPath;
-  await mkdir5(dirname4(configPath), { recursive: true });
+  await mkdir7(dirname5(configPath), { recursive: true });
   if (existingRaw !== null) {
     backupPath = `${configPath}.backup-${deps.timestamp}`;
     await copyFile(configPath, backupPath);
@@ -2889,107 +3767,6 @@ async function runInit(opts, deps) {
   return { ok: true, exitCode: 0, output: out, wrotePath: configPath, backupPath };
 }
 
-// src/log.ts
-import { appendFileSync, renameSync, statSync } from "fs";
-var ORDER = ["error", "warn", "info", "debug"];
-var DEFAULT_MAX_SIZE = 5 * 1024 * 1024;
-function parseLevel(raw, onBad) {
-  if (raw === void 0 || raw === "") return "info";
-  const v = raw.trim().toLowerCase();
-  for (const lvl of ORDER) {
-    if (lvl === v) return lvl;
-  }
-  onBad(`invalid SEEKSTONE_LOG_LEVEL=${JSON.stringify(raw)}; using "info"`);
-  return "info";
-}
-function parseSize(raw) {
-  if (raw === void 0) return DEFAULT_MAX_SIZE;
-  const m = /^(\d+(?:\.\d+)?)(b|kb|mb|gb)?$/i.exec(raw.trim());
-  if (m === null) return DEFAULT_MAX_SIZE;
-  const num = Number(m[1]);
-  const unit = (m[2] ?? "b").toLowerCase();
-  const mult = unit === "gb" ? 1e9 : unit === "mb" ? 1e6 : unit === "kb" ? 1e3 : 1;
-  return Math.max(1, Math.floor(num * mult));
-}
-function fmtFields(fields) {
-  const parts = [];
-  for (const [k, v] of Object.entries(fields)) {
-    if (v === void 0) continue;
-    parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
-  }
-  return parts.length > 0 ? ` ${parts.join(" ")}` : "";
-}
-function createLogger(opts = {}) {
-  const env = opts.env ?? process.env;
-  const stderr = opts.stderr ?? ((line) => void process.stderr.write(line));
-  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  const level = parseLevel(env.SEEKSTONE_LOG_LEVEL, (m) => {
-    stderr(`WARN  ${now().toISOString()} ${m}
-`);
-  });
-  const threshold = ORDER.indexOf(level);
-  const filePath = env.SEEKSTONE_LOG_FILE;
-  const maxSize = parseSize(env.SEEKSTONE_LOG_MAX_SIZE);
-  let fileOk = false;
-  let bytes = 0;
-  if (filePath !== void 0 && filePath !== "") {
-    try {
-      try {
-        bytes = statSync(filePath).size;
-      } catch {
-        bytes = 0;
-      }
-      appendFileSync(filePath, "");
-      fileOk = true;
-    } catch (err) {
-      const m = err instanceof Error ? err.message : String(err);
-      stderr(
-        `WARN  ${now().toISOString()} cannot write log file ${filePath}: ${m}; file logging disabled
-`
-      );
-    }
-  }
-  function writeFile5(record) {
-    if (!fileOk || filePath === void 0) return;
-    const line = `${JSON.stringify(record)}
-`;
-    const len = Buffer.byteLength(line);
-    try {
-      if (bytes > 0 && bytes + len > maxSize) {
-        renameSync(filePath, `${filePath}.1`);
-        bytes = 0;
-      }
-      appendFileSync(filePath, line);
-      bytes += len;
-    } catch {
-      fileOk = false;
-    }
-  }
-  function emit(lvl, msg, fields) {
-    if (ORDER.indexOf(lvl) > threshold) return;
-    const ts = now().toISOString();
-    const f = fields ?? {};
-    stderr(`${lvl.toUpperCase().padEnd(5)} ${ts} ${msg}${fmtFields(f)}
-`);
-    writeFile5({ t: ts, level: lvl, msg, ...f });
-  }
-  return {
-    level,
-    error: (m, f) => {
-      emit("error", m, f);
-    },
-    warn: (m, f) => {
-      emit("warn", m, f);
-    },
-    info: (m, f) => {
-      emit("info", m, f);
-    },
-    debug: (m, f) => {
-      emit("debug", m, f);
-    }
-  };
-}
-
 // src/process-guards.ts
 function installProcessGuards(log2) {
   const onUnhandledRejection = (reason) => {
@@ -3078,9 +3855,83 @@ function countWords(text) {
   return m ? m.length : 0;
 }
 
+// ../core/src/embed/maxsim.ts
+function maxsimScoreTokens(query, docs, tokenVector, opts = {}) {
+  const n = query.ids.length;
+  const weights = opts.weights;
+  if (weights !== void 0 && weights.length !== n) {
+    throw new Error(`maxsim: ${weights.length} weights for ${n} query tokens`);
+  }
+  const mean = (opts.aggregate ?? "sum") === "mean";
+  const out = new Array(docs.length).fill(0);
+  if (n === 0) return out;
+  const { dim } = query;
+  const q = query.vectors;
+  const simCache = /* @__PURE__ */ new Map();
+  const best = new Float64Array(n);
+  for (let d = 0; d < docs.length; d++) {
+    const ids = docs[d];
+    const m = ids.length;
+    if (m === 0) continue;
+    best.fill(Number.NEGATIVE_INFINITY);
+    for (let t = 0; t < m; t++) {
+      const id = ids[t];
+      let sims = simCache.get(id);
+      if (sims === void 0) {
+        sims = new Float64Array(n);
+        const vec = tokenVector(id);
+        if (vec.length !== dim) {
+          throw new Error(`maxsim: token vector dim ${vec.length} does not match query dim ${dim}`);
+        }
+        for (let i = 0; i < n; i++) {
+          const qBase = i * dim;
+          let dot = 0;
+          for (let j = 0; j < dim; j++) {
+            dot += q[qBase + j] * vec[j];
+          }
+          sims[i] = dot;
+        }
+        simCache.set(id, sims);
+      }
+      for (let i = 0; i < n; i++) {
+        const s = sims[i];
+        if (s > best[i]) best[i] = s;
+      }
+    }
+    let sum = 0;
+    let weightSum = 0;
+    for (let i = 0; i < n; i++) {
+      const w = weights === void 0 ? 1 : weights[i];
+      sum += w * best[i];
+      weightSum += w;
+    }
+    out[d] = mean ? weightSum > 0 ? sum / weightSum : 0 : sum;
+  }
+  return out;
+}
+function candidateSetIdf(queryIds, docs) {
+  const n = docs.length;
+  const docSets = [];
+  for (const doc of docs) {
+    const set = /* @__PURE__ */ new Set();
+    for (let t = 0; t < doc.length; t++) set.add(doc[t]);
+    docSets.push(set);
+  }
+  const out = new Array(queryIds.length);
+  for (let i = 0; i < queryIds.length; i++) {
+    const id = queryIds[i];
+    let df = 0;
+    for (const set of docSets) {
+      if (set.has(id)) df++;
+    }
+    out[i] = Math.log(1 + (n - df + 0.5) / (df + 0.5));
+  }
+  return out;
+}
+
 // ../core/src/embed/model2vec.ts
-import { readFile as readFile14 } from "fs/promises";
-import { basename as basename4, join as join8 } from "path";
+import { readFile as readFile16 } from "fs/promises";
+import { basename as basename4, join as join9 } from "path";
 
 // ../core/src/embed/safetensors.ts
 function readSafetensors(buf) {
@@ -3157,7 +4008,7 @@ function loadWordPieceTokenizer(tokenizerJson) {
   const specialIds = new Set(
     (tj.added_tokens ?? []).filter((t) => t.special).map((t) => t.id)
   );
-  function normalize(text) {
+  function normalize2(text) {
     let out = cleanText ? doCleanText(text) : text;
     if (handleCjk) out = padCjkChars(out);
     if (stripAccents) out = out.normalize("NFD").replace(new RegExp("\\p{Mn}", "gu"), "");
@@ -3193,7 +4044,7 @@ function loadWordPieceTokenizer(tokenizerJson) {
     specialIds,
     encode(text) {
       const ids = [];
-      for (const word of preTokenize(normalize(text))) {
+      for (const word of preTokenize(normalize2(text))) {
         for (const id of wordPiece(word)) ids.push(id);
       }
       return ids;
@@ -3261,9 +4112,9 @@ function isCjk(cp) {
 var TENSOR_NAME = "embeddings";
 async function loadModel2Vec(modelDir) {
   const [configRaw, tokenizerRaw, weights] = await Promise.all([
-    readFile14(join8(modelDir, "config.json"), "utf8"),
-    readFile14(join8(modelDir, "tokenizer.json"), "utf8"),
-    readFile14(join8(modelDir, "model.safetensors"))
+    readFile16(join9(modelDir, "config.json"), "utf8"),
+    readFile16(join9(modelDir, "tokenizer.json"), "utf8"),
+    readFile16(join9(modelDir, "model.safetensors"))
   ]);
   const config = JSON.parse(configRaw);
   const tokenizer = loadWordPieceTokenizer(JSON.parse(tokenizerRaw));
@@ -3289,20 +4140,27 @@ async function loadModel2Vec(modelDir) {
     );
   }
   const table = tensor.data;
+  function pooledIds(text) {
+    const ids = [];
+    for (const id of tokenizer.encode(text)) {
+      if (tokenizer.specialIds.has(id) && id !== tokenizer.unkId) continue;
+      ids.push(id);
+    }
+    return ids;
+  }
   return {
     id: basename4(modelDir),
     dim,
     embed(text) {
       const out = new Float32Array(dim);
-      let pooled = 0;
-      for (const id of tokenizer.encode(text)) {
-        if (tokenizer.specialIds.has(id) && id !== tokenizer.unkId) continue;
+      const ids = pooledIds(text);
+      for (const id of ids) {
         const base = id * dim;
         for (let j = 0; j < dim; j++) {
           out[j] = out[j] + table[base + j];
         }
-        pooled++;
       }
+      const pooled = ids.length;
       if (pooled === 0) return out;
       let sumSquares = 0;
       for (let j = 0; j < dim; j++) {
@@ -3315,27 +4173,121 @@ async function loadModel2Vec(modelDir) {
         for (let j = 0; j < dim; j++) out[j] = out[j] / norm;
       }
       return out;
+    },
+    tokenEmbed(text) {
+      const ids = pooledIds(text);
+      const vectors = new Float32Array(ids.length * dim);
+      for (let t = 0; t < ids.length; t++) {
+        writeNormalizedRow(ids[t], vectors, t * dim);
+      }
+      return { ids, dim, vectors };
+    },
+    tokenIds: pooledIds,
+    tokenVector(id) {
+      if (!Number.isInteger(id) || id < 0 || id >= tokenizer.vocabSize) {
+        throw new Error(`model2vec: token id ${id} outside vocab [0, ${tokenizer.vocabSize})`);
+      }
+      const out = new Float32Array(dim);
+      writeNormalizedRow(id, out, 0);
+      return out;
     }
   };
+  function writeNormalizedRow(id, out, offset) {
+    const base = id * dim;
+    let sumSquares = 0;
+    for (let j = 0; j < dim; j++) {
+      const x = table[base + j];
+      out[offset + j] = x;
+      sumSquares += x * x;
+    }
+    const norm = Math.sqrt(sumSquares);
+    if (norm > 0) {
+      for (let j = 0; j < dim; j++) {
+        out[offset + j] = out[offset + j] / norm;
+      }
+    }
+  }
+}
+
+// ../core/src/embed/pooling.ts
+var PoolAccumulator = class {
+  top = Number.NEGATIVE_INFINITY;
+  second = Number.NEGATIVE_INFINITY;
+  bestChunk = 0;
+  count = 0;
+  /** Σ w_i and Σ s_i·w_i with w_i = exp((s_i − 1) / τ); shift keeps exp() ≤ 1. */
+  sumW = 0;
+  sumSW = 0;
+  invTemp;
+  constructor(pooling) {
+    this.invTemp = typeof pooling === "object" && pooling.kind === "softmax" ? 1 / pooling.temperature : 0;
+  }
+  add(score, chunkIndex) {
+    this.count++;
+    if (score > this.top) {
+      this.second = this.top;
+      this.top = score;
+      this.bestChunk = chunkIndex;
+    } else if (score > this.second) {
+      this.second = score;
+    }
+    if (this.invTemp > 0) {
+      const w = Math.exp((score - 1) * this.invTemp);
+      this.sumW += w;
+      this.sumSW += score * w;
+    }
+  }
+  pool(pooling) {
+    if (this.count === 0) return Number.NEGATIVE_INFINITY;
+    if (pooling === "max") return this.top;
+    if (pooling === "top2mean") {
+      return this.second === Number.NEGATIVE_INFINITY ? this.top : (this.top + this.second) / 2;
+    }
+    if (pooling.kind === "logdiscount") return this.top - pooling.lambda * Math.log(this.count);
+    return this.sumW > 0 ? this.sumSW / this.sumW : this.top;
+  }
+};
+function assertValidPooling(p) {
+  const raw = p;
+  if (typeof p === "string") {
+    if (p !== "max" && p !== "top2mean") throw new Error(`pooling: unknown kind "${String(raw)}"`);
+    return;
+  }
+  if (p.kind === "logdiscount") {
+    if (!(p.lambda >= 0))
+      throw new Error(`pooling: logdiscount lambda must be \u2265 0 (got ${p.lambda})`);
+  } else if (p.kind === "softmax") {
+    if (!(p.temperature > 0)) {
+      throw new Error(`pooling: softmax temperature must be > 0 (got ${p.temperature})`);
+    }
+  } else {
+    const kind = typeof raw === "object" && raw !== null ? raw.kind : raw;
+    throw new Error(`pooling: unknown kind "${String(kind)}"`);
+  }
+}
+
+// ../core/src/embed/types.ts
+function isTokenEmbedder(e) {
+  return typeof e.tokenEmbed === "function";
 }
 
 // src/semantic/cache.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile15, rename as rename4, writeFile as writeFile3 } from "fs/promises";
-import { join as join9 } from "path";
+import { mkdir as mkdir8, readFile as readFile17, rename as rename5, writeFile as writeFile3 } from "fs/promises";
+import { join as join10 } from "path";
 var CACHE_VERSION = 2;
 function cachePathsFor(cacheDir, vaultRoot2, modelId) {
   const vaultKey = createHash2("sha256").update(vaultRoot2).digest("hex").slice(0, 16);
-  const dir = join9(cacheDir, "embeddings", vaultKey);
-  return { dir, bin: join9(dir, `${modelId}.bin`), manifest: join9(dir, `${modelId}.json`) };
+  const dir = join10(cacheDir, "embeddings", vaultKey);
+  return { dir, bin: join10(dir, `${modelId}.bin`), manifest: join10(dir, `${modelId}.json`) };
 }
 async function loadCache(paths, modelId, dim) {
   try {
-    const manifest = JSON.parse(await readFile15(paths.manifest, "utf8"));
+    const manifest = JSON.parse(await readFile17(paths.manifest, "utf8"));
     if (manifest.version !== CACHE_VERSION || manifest.modelId !== modelId || manifest.dim !== dim) {
       return void 0;
     }
-    const buf = await readFile15(paths.bin);
+    const buf = await readFile17(paths.bin);
     const totalChunks = manifest.entries.reduce((a, e) => a + e.chunks, 0);
     const vectorBytes = totalChunks * dim * 4;
     const spanBytes = totalChunks * 2 * 4;
@@ -3385,26 +4337,64 @@ async function saveCache(paths, modelId, dim, notes2, hashes) {
     spanOffset += note.spans.length;
   }
   const manifest = { version: CACHE_VERSION, modelId, dim, entries };
-  await mkdir6(paths.dir, { recursive: true });
+  await mkdir8(paths.dir, { recursive: true });
   await atomicWriteBytes(paths.bin, bin);
   await atomicWriteBytes(paths.manifest, new TextEncoder().encode(JSON.stringify(manifest)));
 }
 async function atomicWriteBytes(absPath, bytes) {
   const tmpPath = `${absPath}.seekstone-cache-tmp`;
   await writeFile3(tmpPath, bytes);
-  await rename4(tmpPath, absPath);
+  await rename5(tmpPath, absPath);
+}
+
+// src/semantic/state.ts
+init_config();
+
+// src/semantic/rerank.ts
+var MAXSIM_BETA = 0.5;
+var EMPTY = [];
+function maxsimRerankHits(embedder, query, hits, tokenIdsFor, beta = MAXSIM_BETA) {
+  if (hits.length < 2 || beta <= 0) return [...hits];
+  const qTok = embedder.tokenEmbed(query);
+  if (qTok.ids.length === 0) return [...hits];
+  const docs = hits.map((h) => tokenIdsFor(h) ?? EMPTY);
+  const weights = candidateSetIdf(qTok.ids, docs);
+  const maxsim = maxsimScoreTokens(qTok, docs, (id) => embedder.tokenVector(id), {
+    aggregate: "mean",
+    weights
+  });
+  const stage1 = normalize(hits.map((h) => h.score));
+  const rerank = normalize(maxsim);
+  return hits.map((h, i) => ({
+    ...h,
+    score: (1 - beta) * stage1[i] + beta * rerank[i]
+  })).sort((a, b) => b.score - a.score || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+function normalize(scores) {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+  for (const s of scores) {
+    if (s < min) min = s;
+    if (s > max) max = s;
+  }
+  const span = max - min;
+  return scores.map((s) => span > 0 ? (s - min) / span : 1);
 }
 
 // src/semantic/store.ts
+var DEFAULT_POOLING = "max";
 var SemanticStore = class {
   dim;
+  pooling;
   notes = /* @__PURE__ */ new Map();
   chunks = 0;
-  constructor(dim) {
+  constructor(dim, pooling = DEFAULT_POOLING) {
     if (!Number.isInteger(dim) || dim <= 0) {
       throw new Error(`semantic store: invalid dim ${dim}`);
     }
+    assertValidPooling(pooling);
     this.dim = dim;
+    this.pooling = pooling;
   }
   /** Total chunk vectors across all notes. */
   get chunkCount() {
@@ -3444,38 +4434,55 @@ var SemanticStore = class {
   entries() {
     return this.notes.entries();
   }
-  /** Top `k` notes by max-pooled chunk cosine, ties broken path-ascending. */
+  /**
+   * Top `k` notes by pooled chunk cosine, ties broken path-ascending. The
+   * returned chunk/span is always the note's single best chunk, whatever
+   * pooling ranked the note.
+   */
   topNotes(query, k) {
     if (query.length !== this.dim) {
       throw new Error(`semantic store: query dim ${query.length} does not match ${this.dim}`);
     }
-    const dim = this.dim;
     const hits = [];
-    for (const [path2, { packed, spans }] of this.notes) {
-      let best = Number.NEGATIVE_INFINITY;
-      let bestChunk = 0;
-      const n = packed.length / dim;
-      for (let c = 0; c < n; c++) {
-        const base = c * dim;
-        let score = 0;
-        for (let j = 0; j < dim; j++) {
-          score += packed[base + j] * query[j];
-        }
-        if (score > best) {
-          best = score;
-          bestChunk = c;
-        }
-      }
-      hits.push({
-        path: path2,
-        score: best,
-        chunkIndex: bestChunk,
-        start: spans[bestChunk * 2],
-        end: spans[bestChunk * 2 + 1]
-      });
+    for (const [path2, vectors] of this.notes) {
+      hits.push(this.scoreVectors(path2, vectors, query));
     }
     return hits.sort((a, b) => b.score - a.score || (a.path < b.path ? -1 : a.path > b.path ? 1 : 0)).slice(0, Math.max(0, k));
   }
+  /**
+   * Score a single note's cached chunk vectors against the query (SHA-315
+   * graph expansion gates candidates on this). Same pooling and best-chunk
+   * span as topNotes; undefined when the note has no vectors.
+   */
+  scoreNote(path2, query) {
+    if (query.length !== this.dim) {
+      throw new Error(`semantic store: query dim ${query.length} does not match ${this.dim}`);
+    }
+    const vectors = this.notes.get(path2);
+    return vectors === void 0 ? void 0 : this.scoreVectors(path2, vectors, query);
+  }
+  scoreVectors(path2, { packed, spans }, query) {
+    const dim = this.dim;
+    const pooling = this.pooling;
+    const acc = new PoolAccumulator(pooling);
+    const n = packed.length / dim;
+    for (let c = 0; c < n; c++) {
+      const base = c * dim;
+      let score = 0;
+      for (let j = 0; j < dim; j++) {
+        score += packed[base + j] * query[j];
+      }
+      acc.add(score, c);
+    }
+    const bestChunk = acc.bestChunk;
+    return {
+      path: path2,
+      score: acc.pool(pooling),
+      chunkIndex: bestChunk,
+      start: spans[bestChunk * 2],
+      end: spans[bestChunk * 2 + 1]
+    };
+  }
 };
 
 // src/semantic/state.ts
@@ -3490,11 +4497,21 @@ var Semantic = class _Semantic {
   saveDebounceMs;
   yieldEvery;
   hashes = /* @__PURE__ */ new Map();
+  /**
+   * Lazy per-note chunk token ids for the MaxSim rerank (SHA-314): filled on
+   * first rerank touch, dropped whenever the note changes or is removed.
+   * Only queried candidates are ever tokenized, so the memo stays a small
+   * fraction of the vault; it lives in memory only — the cache file format
+   * is untouched.
+   */
+  tokenIdCache = /* @__PURE__ */ new Map();
+  tokenEmbedder;
   pending = /* @__PURE__ */ new Map();
   saveTimer;
   stopped = false;
   constructor(embedder, ctx2, cfg, deps) {
     this.embedder = embedder;
+    this.tokenEmbedder = isTokenEmbedder(embedder) ? embedder : void 0;
     this.store = new SemanticStore(embedder.dim);
     this.ctx = ctx2;
     this.paths = cachePathsFor(cfg.cacheDir, ctx2.vaultRoot, embedder.id);
@@ -3516,7 +4533,7 @@ var Semantic = class _Semantic {
     } catch (err) {
       const reason = err instanceof Error ? err.message : String(err);
       throw new Error(
-        `semantic search: could not load the embedding model from ${cfg.modelDir} \u2014 run \`npx -y seekstone fetch-model\` to download it, or point SEEKSTONE_MODEL_PATH at a Model2Vec model directory (${reason})`
+        `semantic search: could not load the embedding model ${cfg.modelId} from ${cfg.modelDir} \u2014 run \`${fetchCommandFor(cfg.modelId)}\` to download it, or point SEEKSTONE_MODEL_PATH at a Model2Vec model directory (${reason})`
       );
     }
     const semantic = new _Semantic(embedder, ctx2, cfg, deps);
@@ -3591,9 +4608,35 @@ var Semantic = class _Semantic {
   embedQuery(query) {
     return this.embedder.embed(query);
   }
+  /**
+   * MaxSim-rerank stage-1 candidates (SHA-314). Pass-through when the
+   * embedder exposes no token vectors (alternative runtimes) — semantic
+   * search then ships stage-1 order unchanged.
+   */
+  rerank(query, hits) {
+    const embedder = this.tokenEmbedder;
+    if (!embedder) return [...hits];
+    return maxsimRerankHits(embedder, query, hits, (hit) => {
+      const ids = this.chunkTokenIds(hit.path);
+      return ids?.[hit.chunkIndex];
+    });
+  }
+  chunkTokenIds(path2) {
+    const cached = this.tokenIdCache.get(path2);
+    if (cached) return cached;
+    const embedder = this.tokenEmbedder;
+    const note = this.ctx.notes.get(path2);
+    if (!embedder || !note) return void 0;
+    const ids = chunkNote(note.title, note.body).map(
+      (chunk) => Uint32Array.from(embedder.tokenIds(chunk.text))
+    );
+    this.tokenIdCache.set(path2, ids);
+    return ids;
+  }
   /** Watcher hook: a note was added or changed (ctx.notes is already fresh). */
   noteChanged(path2) {
     if (this.stopped) return;
+    this.tokenIdCache.delete(path2);
     const existing = this.pending.get(path2);
     if (existing) clearTimeout(existing);
     const timer = setTimeout(() => {
@@ -3610,6 +4653,7 @@ var Semantic = class _Semantic {
       clearTimeout(existing);
       this.pending.delete(path2);
     }
+    this.tokenIdCache.delete(path2);
     if (this.hashes.has(path2) || this.store.getNote(path2)) {
       this.store.removeNote(path2);
       this.hashes.delete(path2);
@@ -4179,6 +5223,42 @@ var ALL_TOOLS = [
       },
       required: ["content"]
     }
+  },
+  {
+    name: "list_writes",
+    annotations: READ_ONLY_ANNOTATIONS,
+    description: "List recent writes from the journal \u2014 every write tool records the pre-image of each file it touches, so any of them can be reverted with undo_write. Returns compact metadata rows (seq, timestamp, tool, paths, undoable), never note content.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: {
+          type: "number",
+          description: "Max entries to return, newest first (1\u2013200, default 20)."
+        },
+        path: {
+          type: "string",
+          description: "Only entries that touched this vault-relative path."
+        }
+      }
+    }
+  },
+  {
+    name: "undo_write",
+    annotations: DESTRUCTIVE_WRITE_ANNOTATIONS,
+    description: "Revert a journaled write: restores every file it touched to its byte-identical pre-write state (a multi-file move or heading rename is restored whole; a delete is restored even if it was permanent). Defaults to the most recent undoable write. Refuses with undo_conflict if a file changed since that write, unless force: true. The undo is itself journaled \u2014 undo it to redo.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        seq: {
+          type: "number",
+          description: "Journal entry to revert (from list_writes). Defaults to the most recent undoable write."
+        },
+        force: {
+          type: "boolean",
+          description: "Restore even if a file changed after the journaled write; the clobbered state is journaled first so nothing is lost. Defaults to false."
+        }
+      }
+    }
   }
 ];
 function visibleTools(policy2) {
@@ -4188,8 +5268,8 @@ function visibleTools(policy2) {
 
 // src/watcher.ts
 import { realpathSync } from "fs";
-import { readFile as readFile16 } from "fs/promises";
-import { join as join10, relative as relative2, sep as sep3 } from "path";
+import { readFile as readFile18 } from "fs/promises";
+import { join as join11, relative as relative2, sep as sep3 } from "path";
 import chokidar from "chokidar";
 var DEFAULT_POLL_INTERVAL_MS = 1e4;
 function resolvePollInterval(optValue, envValue, log2) {
@@ -4220,7 +5300,7 @@ function startWatcher(ctx2, log2, opts) {
   const toRel = (abs) => relative2(vaultRoot2, abs).split(sep3).join("/");
   async function upsert(relPath, op) {
     try {
-      const raw = await readFile16(join10(vaultRoot2, relPath), "utf8");
+      const raw = await readFile18(join11(vaultRoot2, relPath), "utf8");
       removeNoteBacklinks(ctx2, relPath);
       upsertDoc(ctx2, buildDoc(relPath, raw));
       addNoteBacklinks(ctx2, relPath, raw);
@@ -4274,7 +5354,7 @@ function startWatcher(ctx2, log2, opts) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.16.0" : "0.0.0-dev";
+var VERSION = true ? "0.17.1" : "0.0.0-dev";
 var intent = parseCliIntent(process.argv.slice(2));
 if (intent === "version") {
   process.stdout.write(`${VERSION}
@@ -4305,7 +5385,11 @@ if (intent === "init") {
 if (intent === "fetch-model") {
   const { runFetchModel: runFetchModel2 } = await Promise.resolve().then(() => (init_fetch_model(), fetch_model_exports));
   const { homedir: homedir2 } = await import("os");
-  const result = await runFetchModel2({ env: process.env, homedir: homedir2() });
+  const result = await runFetchModel2({
+    env: process.env,
+    homedir: homedir2(),
+    argv: process.argv.slice(3)
+  });
   process.stdout.write(`${result.output.join("\n")}
 `);
   process.exit(result.exitCode);
@@ -4325,6 +5409,33 @@ log.info("building index", { vault: vaultRoot });
 var { index, notes, backlinks, buildMs } = await buildIndex(vaultRoot);
 log.info("index ready", { notes: notes.size, buildMs });
 var ctx = { vaultRoot, index, notes, backlinks, policy };
+var journalCfg = resolveJournalConfig(process.env);
+if (journalCfg && !policy.readOnly) {
+  try {
+    ctx.journal = await Journal.open(vaultRoot, journalCfg, { log });
+    log.info("write journal ready", {
+      entries: ctx.journal.list({ limit: 1 }).total,
+      maxBytes: journalCfg.maxBytes
+    });
+  } catch (err) {
+    log.error(`write journal failed to open: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+} else if (!journalCfg) {
+  log.info("write journal disabled", { env: "SEEKSTONE_HISTORY" });
+}
+var auditCfg = resolveAuditConfig(process.env);
+if (auditCfg) {
+  try {
+    ctx.audit = AuditLog.open(auditCfg);
+    log.info("audit log ready", { file: auditCfg.path, maxBytes: auditCfg.maxBytes });
+  } catch (err) {
+    log.error(
+      `audit log ${auditCfg.path} is not writable: ${err instanceof Error ? err.message : String(err)}`
+    );
+    process.exit(1);
+  }
+}
 var semanticCfg = resolveSemanticConfig(process.env, homedir());
 if (semanticCfg) {
   try {