skillwiki 0.10.11 → 0.10.13

package/dist/cli.js

@@ -12,10 +12,12 @@ import {
   assessSourceIdentity,
   buildDegradedReasons,
   buildRemoteObjectPath,
+  canonicalEventJson,
   clearLastOp,
   configPath,
   evaluateDirtyVolumeGate,
   evaluateSatelliteRunHealth,
+  eventPathFor,
   extractCitationMarkers,
   extractTaxonomy,
   findPlugin,
@@ -78,8 +80,9 @@ import {
   scanConflictMarkerBlocksInText,
   taxonomyCommentForPage,
   upsertIndexEntry,
+  validateLogEvent,
   writeLogEvent
-} from "./chunk-P2FCRGKU.js";
+} from "./chunk-X2CPXF4T.js";
 import {
   normalizeDistTag,
   readCache,
@@ -88,6 +91,8 @@ import {
   writeCache
 } from "./chunk-7I2TPIV5.js";
 import {
+  UNMANAGED_END,
+  UNMANAGED_START,
   assertTargetInsideVault,
   atomicWriteText,
   extractFrontmatter,
@@ -99,13 +104,13 @@ import {
   scanVault,
   splitFrontmatter,
   writeRootIndexProjection
-} from "./chunk-U34B2XQJ.js";
+} from "./chunk-NMUYMNNB.js";
 import {
   acquireManagedWriteLock,
   releaseManagedWriteLock,
   runManagedWritePreflight,
   runManagedWriteTransaction
-} from "./chunk-3ZVZ2YEE.js";
+} from "./chunk-IIUMTKKA.js";
 import {
   FLEET_REL_PATH,
   git,
@@ -127,7 +132,7 @@ import {
   snapshotterAliasForLocalHost,
   supersedeStaleReviewRequiredJournals,
   writeDotenv
-} from "./chunk-TYN2IHBY.js";
+} from "./chunk-E3PMAHS3.js";
 import {
   ExitCode,
   MetaSchema,
@@ -138,7 +143,7 @@ import {
 } from "./chunk-C5OLZRRM.js";
 
 // src/cli.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -1683,10 +1688,265 @@ async function runProjectionsMaterialize(input, deps = defaultDeps) {
   };
 }
 
+// src/commands/projections-repair-legacy.ts
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
+import { join as join13 } from "path";
+var OPERATION_ID_RE = /^[0-9a-f]{64}$/;
+var LEGACY_KEYS = ["created", "kind", "note", "operation_id", "target"];
+var EVENT_KEYS = [
+  "actor",
+  "host_id",
+  "kind",
+  "metadata",
+  "note",
+  "occurred_at",
+  "operation_id",
+  "schema",
+  "target"
+];
+var defaultDeps2 = {
+  writeText: (path, text) => atomicWriteText(path, text)
+};
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  return actual.length === keys.length && actual.every((key, index) => key === keys[index]);
+}
+function count(text, token) {
+  return text.split(token).length - 1;
+}
+function planIndexRepair(current) {
+  if (count(current, UNMANAGED_START) !== 1 || count(current, UNMANAGED_END) !== 1) {
+    return err("SCHEME_REJECTED", {
+      path: "index.md",
+      message: "index.md must contain exactly one complete unmanaged marker pair"
+    });
+  }
+  const start = current.indexOf(UNMANAGED_START);
+  const end = current.indexOf(UNMANAGED_END);
+  if (start < end) return ok({ current, repaired: current, needed: false });
+  const between = current.slice(end + UNMANAGED_END.length, start);
+  if (!/^\s*$/.test(between)) {
+    return err("SCHEME_REJECTED", {
+      path: "index.md",
+      message: "reversed unmanaged markers must be adjacent except for whitespace"
+    });
+  }
+  const repaired = current.slice(0, end) + UNMANAGED_START + between + UNMANAGED_END + current.slice(start + UNMANAGED_START.length);
+  return ok({ current, repaired, needed: true });
+}
+function normalizeLegacyTimestamp(value) {
+  if (typeof value !== "string") {
+    return err("SCHEME_REJECTED", { message: "legacy event created must be a UTC timestamp" });
+  }
+  const match = value.match(/^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(?:\.(\d{3}))?Z$/);
+  if (!match) {
+    return err("SCHEME_REJECTED", { message: "legacy event created must be a UTC timestamp" });
+  }
+  const normalized = `${match[1]}.${match[2] ?? "000"}Z`;
+  const date = new Date(normalized);
+  if (Number.isNaN(date.getTime()) || date.toISOString() !== normalized) {
+    return err("SCHEME_REJECTED", { message: "legacy event created is not a valid timestamp" });
+  }
+  return ok(normalized);
+}
+async function findEventPath(vault, operationId2) {
+  const root = join13(vault, "meta", "log-events");
+  const matches = [];
+  let days;
+  try {
+    days = await readdir3(root, { withFileTypes: true });
+  } catch (error) {
+    return err("SCHEME_REJECTED", {
+      message: "log event root is missing or unreadable",
+      detail: String(error)
+    });
+  }
+  for (const day2 of days) {
+    if (!day2.isDirectory()) continue;
+    const dayPath = join13(root, day2.name);
+    const entries = await readdir3(dayPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isFile() || entry.name !== `${operationId2}.json`) continue;
+      matches.push({
+        absolute: join13(dayPath, entry.name),
+        relative: `meta/log-events/${day2.name}/${entry.name}`
+      });
+    }
+  }
+  if (matches.length !== 1) {
+    return err("SCHEME_REJECTED", {
+      message: "event operation ID must resolve to exactly one log event",
+      operation_id: operationId2,
+      matches: matches.map((match) => match.relative)
+    });
+  }
+  return ok(matches[0]);
+}
+function planCanonicalEvent(parsed, operationId2, relativePath, current) {
+  if (!hasExactKeys(parsed, EVENT_KEYS)) {
+    return err("SCHEME_REJECTED", { path: relativePath, message: "canonical event has unexpected fields" });
+  }
+  const validated = validateLogEvent(parsed);
+  if (!validated.ok) return validated;
+  if (validated.data.operation_id !== operationId2 || eventPathFor(validated.data) !== relativePath) {
+    return err("SCHEME_REJECTED", { path: relativePath, message: "path/identity mismatch" });
+  }
+  return ok({ current, repaired: current, needed: false });
+}
+function planLegacyEvent(parsed, operationId2, relativePath, current, hostId) {
+  if (!hasExactKeys(parsed, LEGACY_KEYS)) {
+    return err("SCHEME_REJECTED", {
+      path: relativePath,
+      message: "legacy event must contain exactly operation_id, kind, target, note, and created"
+    });
+  }
+  if (parsed.operation_id !== operationId2) {
+    return err("SCHEME_REJECTED", { path: relativePath, message: "path/identity mismatch" });
+  }
+  const { kind, target, note } = parsed;
+  if (typeof kind !== "string" || typeof target !== "string" || typeof note !== "string") {
+    return err("SCHEME_REJECTED", {
+      path: relativePath,
+      message: "legacy event kind, target, and note must be strings"
+    });
+  }
+  const occurredAt = normalizeLegacyTimestamp(parsed.created);
+  if (!occurredAt.ok) return occurredAt;
+  const event = {
+    schema: "skillwiki-log-event/v1",
+    operation_id: operationId2,
+    occurred_at: occurredAt.data,
+    host_id: hostId,
+    actor: "skillwiki-cli",
+    kind,
+    target,
+    note,
+    metadata: {}
+  };
+  const validated = validateLogEvent(event);
+  if (!validated.ok) return validated;
+  if (eventPathFor(validated.data) !== relativePath) {
+    return err("SCHEME_REJECTED", { path: relativePath, message: "path/date mismatch" });
+  }
+  return ok({ current, repaired: canonicalEventJson(validated.data), needed: true });
+}
+async function planEventRepair(vault, operationId2, hostId) {
+  const located = await findEventPath(vault, operationId2);
+  if (!located.ok) return located;
+  let current;
+  try {
+    current = await readFile4(located.data.absolute, "utf8");
+  } catch (error) {
+    return err("SCHEME_REJECTED", {
+      path: located.data.relative,
+      message: "event is unreadable",
+      detail: String(error)
+    });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(current);
+  } catch {
+    return err("SCHEME_REJECTED", { path: located.data.relative, message: "invalid JSON" });
+  }
+  if (!isPlainObject(parsed)) {
+    return err("SCHEME_REJECTED", { path: located.data.relative, message: "event must be an object" });
+  }
+  const plan = parsed.schema === "skillwiki-log-event/v1" ? planCanonicalEvent(parsed, operationId2, located.data.relative, current) : planLegacyEvent(parsed, operationId2, located.data.relative, current, hostId);
+  if (!plan.ok) return plan;
+  return ok({ ...plan.data, absolutePath: located.data.absolute, relativePath: located.data.relative });
+}
+async function runProjectionsRepairLegacy(input, deps = defaultDeps2) {
+  if (!OPERATION_ID_RE.test(input.eventOperationId)) {
+    return {
+      exitCode: ExitCode.SCHEME_REJECTED,
+      result: err("SCHEME_REJECTED", { message: "event operation ID must be 64 lowercase hex chars" })
+    };
+  }
+  let indexText;
+  try {
+    indexText = await readFile4(join13(input.vault, "index.md"), "utf8");
+  } catch (error) {
+    return {
+      exitCode: ExitCode.SCHEME_REJECTED,
+      result: err("SCHEME_REJECTED", { path: "index.md", message: "index.md is unreadable", detail: String(error) })
+    };
+  }
+  const indexPlan = planIndexRepair(indexText);
+  if (!indexPlan.ok) return { exitCode: ExitCode.SCHEME_REJECTED, result: indexPlan };
+  const eventPlan = await planEventRepair(
+    input.vault,
+    input.eventOperationId,
+    input.hostId ?? "standalone"
+  );
+  if (!eventPlan.ok) return { exitCode: ExitCode.SCHEME_REJECTED, result: eventPlan };
+  const baseOutput = {
+    event_path: eventPlan.data.relativePath,
+    index_repair_needed: indexPlan.data.needed,
+    event_repair_needed: eventPlan.data.needed
+  };
+  if (!input.write) {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        ...baseOutput,
+        index_changed: false,
+        event_changed: false,
+        rolled_back: false,
+        dry_run: true,
+        humanHint: `dry run: index_repair_needed=${indexPlan.data.needed} event_repair_needed=${eventPlan.data.needed}`
+      })
+    };
+  }
+  let indexChanged = false;
+  if (indexPlan.data.needed) {
+    const written = await deps.writeText(join13(input.vault, "index.md"), indexPlan.data.repaired);
+    if (!written.ok) return { exitCode: ExitCode.WRITE_FAILED, result: written };
+    indexChanged = written.data.changed;
+  }
+  let eventChanged = false;
+  if (eventPlan.data.needed) {
+    const written = await deps.writeText(eventPlan.data.absolutePath, eventPlan.data.repaired);
+    if (!written.ok) {
+      let rolledBack = false;
+      let rollbackError;
+      if (indexChanged) {
+        const rollback = await deps.writeText(join13(input.vault, "index.md"), indexPlan.data.current);
+        rolledBack = rollback.ok;
+        if (!rollback.ok) rollbackError = rollback;
+      }
+      return {
+        exitCode: ExitCode.WRITE_FAILED,
+        result: err("WRITE_FAILED", {
+          message: "event repair failed",
+          cause: written,
+          rolled_back: rolledBack,
+          rollback_error: rollbackError
+        })
+      };
+    }
+    eventChanged = written.data.changed;
+  }
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      ...baseOutput,
+      index_changed: indexChanged,
+      event_changed: eventChanged,
+      rolled_back: false,
+      dry_run: false,
+      humanHint: `repaired legacy projections index_changed=${indexChanged} event_changed=${eventChanged}`
+    })
+  };
+}
+
 // src/commands/claim.ts
-import { mkdir as mkdir4, writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile3, readFile as readFile5 } from "fs/promises";
 import { existsSync as existsSync2, statSync } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 function extractDate(filename) {
   const m = filename.match(/^(\d{4}-\d{2}-\d{2})/);
   return m?.[1] ?? "";
@@ -1701,11 +1961,11 @@ async function runClaim(input) {
   if (!existsSync2(input.vault) || !statSync(input.vault).isDirectory()) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { path: input.vault }) };
   }
-  const absTranscript = join13(input.vault, input.transcript);
+  const absTranscript = join14(input.vault, input.transcript);
   if (!existsSync2(absTranscript)) {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: input.transcript }) };
   }
-  const content = await readFile4(absTranscript, "utf8");
+  const content = await readFile5(absTranscript, "utf8");
   const fm = extractFrontmatter(content);
   let projectSlug = input.project;
   if (!projectSlug && fm.ok && typeof fm.data.project === "string") {
@@ -1717,7 +1977,7 @@ async function runClaim(input) {
       result: err("SCHEME_REJECTED", { message: "No project specified. Use --project or set project in transcript frontmatter." })
     };
   }
-  const projectDir = join13(input.vault, "projects", projectSlug);
+  const projectDir = join14(input.vault, "projects", projectSlug);
   if (!existsSync2(projectDir) || !statSync(projectDir).isDirectory()) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -1734,7 +1994,7 @@ async function runClaim(input) {
   }
   const workSlug = input.slug || extractSlugFromFilename(filename);
   const dirName = `${date}-${workSlug}`;
-  const workDir = join13(projectDir, "work", dirName);
+  const workDir = join14(projectDir, "work", dirName);
   const relWorkDir = `projects/${projectSlug}/work/${dirName}`;
   const relSpecPath = `${relWorkDir}/spec.md`;
   if (existsSync2(workDir)) {
@@ -1763,7 +2023,7 @@ async function runClaim(input) {
     `Claimed from ${input.transcript}`,
     ""
   ];
-  await writeFile3(join13(workDir, "spec.md"), specLines.join("\n"), "utf8");
+  await writeFile3(join14(workDir, "spec.md"), specLines.join("\n"), "utf8");
   appendLastOp(input.vault, {
     operation: "claim",
     summary: `claimed ${input.transcript} \u2192 ${relWorkDir}`,
@@ -1783,11 +2043,11 @@ async function runClaim(input) {
 
 // src/commands/work-complete.ts
 import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync10, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 
 // src/commands/work-validate.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync9 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function normalizeWorkItemRel(workItem) {
   return workItem.replace(/\\/g, "/").replace(/^\.?\//, "");
 }
@@ -1844,7 +2104,7 @@ function validatePrMetadata(meta, findings) {
 }
 async function runWorkValidate(input) {
   const rel = normalizeWorkItemRel(input.workItem);
-  const workDir = join14(input.vault, rel);
+  const workDir = join15(input.vault, rel);
   if (!existsSync3(workDir)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -1863,7 +2123,7 @@ async function runWorkValidate(input) {
     findings.push({ code: "missing_spec", path: `${rel}/spec.md`, message: "spec.md is required" });
   }
   for (const file of files) {
-    const abs = join14(workDir, file);
+    const abs = join15(workDir, file);
     let text;
     try {
       text = readFileSync9(abs, "utf8");
@@ -1960,7 +2220,7 @@ async function runWorkValidate(input) {
 
 // src/commands/work-complete.ts
 function workCompleteJournalPath(vault, opId) {
-  return join15(vault, ".skillwiki", "work-complete", `${opId}.env`);
+  return join16(vault, ".skillwiki", "work-complete", `${opId}.env`);
 }
 function readWorkJournal(vault, opId) {
   const path = workCompleteJournalPath(vault, opId);
@@ -1973,7 +2233,7 @@ function readWorkJournal(vault, opId) {
 }
 function writeWorkJournal(vault, opId, fields) {
   const path = workCompleteJournalPath(vault, opId);
-  const dir = join15(vault, ".skillwiki", "work-complete");
+  const dir = join16(vault, ".skillwiki", "work-complete");
   mkdirSync(dir, { recursive: true });
   const tmp = `${path}.tmp.${process.pid}`;
   const body = serializeJournalEnv(fields, [
@@ -1987,14 +2247,17 @@ function writeWorkJournal(vault, opId, fields) {
   writeFileSync3(tmp, body, "utf8");
   renameSync(tmp, path);
 }
+var DEFAULT_DEPS = {
+  writeEvidenceText: atomicWriteText
+};
 var PHASE_ORDER = ["validate", "evidence", "log", "projection", "commit", "done"];
 function resolveWorkDir(vault, workItem) {
   const rel = normalizeWorkItemRel(workItem);
-  const abs = join15(vault, rel);
+  const abs = join16(vault, rel);
   if (!existsSync4(abs)) {
     return err("FILE_NOT_FOUND", { path: rel });
   }
-  if (!existsSync4(join15(abs, "spec.md"))) {
+  if (!existsSync4(join16(abs, "spec.md"))) {
     return err("PREFLIGHT_FAILED", { reason: "missing-spec", path: rel });
   }
   return ok(abs);
@@ -2041,8 +2304,8 @@ ${body}`);
 async function setStatusCompleted(filePath) {
   return patchFrontmatterStatus(filePath);
 }
-async function writeEvidence(workDir, opId, phases) {
-  const path = join15(workDir, "evidence.md");
+async function writeEvidence(workDir, opId, phases, writeText) {
+  const path = join16(workDir, "evidence.md");
   const body = [
     "---",
     "title: work-complete evidence",
@@ -2057,10 +2320,10 @@ async function writeEvidence(workDir, opId, phases) {
     `- completed_at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
     ""
   ].join("\n");
-  return atomicWriteText(path, body);
+  return writeText(path, body);
 }
 async function markPlanComplete(workDir) {
-  const planPath = join15(workDir, "plan.md");
+  const planPath = join16(workDir, "plan.md");
   if (!existsSync4(planPath)) return ok(null);
   return patchFrontmatterStatus(planPath, (body) => body.replace(/- \[ \]/g, "- [x]"));
 }
@@ -2070,7 +2333,7 @@ function writeFailure(stage, result) {
     result: result.ok ? err("WRITE_FAILED", { stage, message: "unexpected ok" }) : result
   };
 }
-async function runWorkComplete(input) {
+async function runWorkComplete(input, deps = DEFAULT_DEPS) {
   const workDirResult = resolveWorkDir(input.vault, input.workItem);
   if (!workDirResult.ok) {
     return {
@@ -2147,11 +2410,16 @@ async function runWorkComplete(input) {
       advance("evidence");
     }
     if (phaseIndex(phase) <= phaseIndex("evidence")) {
-      const statusWrite = await setStatusCompleted(join15(workDir, "spec.md"));
+      const statusWrite = await setStatusCompleted(join16(workDir, "spec.md"));
       if (!statusWrite.ok) return writeFailure("evidence-spec", statusWrite);
       const planWrite = await markPlanComplete(workDir);
       if (!planWrite.ok) return writeFailure("evidence-plan", planWrite);
-      const evidenceWrite = await writeEvidence(workDir, opId, completedPhases);
+      const evidenceWrite = await writeEvidence(
+        workDir,
+        opId,
+        completedPhases,
+        deps.writeEvidenceText
+      );
       if (!evidenceWrite.ok) return writeFailure("evidence", evidenceWrite);
       if (input.failAfter === "evidence") {
         throw new Error("simulated failure after evidence");
@@ -2181,8 +2449,13 @@ async function runWorkComplete(input) {
       advance("projection");
     }
     if (phaseIndex(phase) <= phaseIndex("projection")) {
-      if (!existsSync4(join15(workDir, "evidence.md"))) {
-        const evidenceWrite = await writeEvidence(workDir, opId, completedPhases);
+      if (!existsSync4(join16(workDir, "evidence.md"))) {
+        const evidenceWrite = await writeEvidence(
+          workDir,
+          opId,
+          completedPhases,
+          deps.writeEvidenceText
+        );
         if (!evidenceWrite.ok) return writeFailure("projection-evidence", evidenceWrite);
       }
       const finalCheck = await runWorkValidate({
@@ -2206,7 +2479,7 @@ async function runWorkComplete(input) {
     }
     let committed = false;
     if (phaseIndex(phase) <= phaseIndex("commit")) {
-      if (!input.noCommit && existsSync4(join15(input.vault, ".git"))) {
+      if (!input.noCommit && existsSync4(join16(input.vault, ".git"))) {
         try {
           appendLastOp(input.vault, {
             operation: "work-complete",
@@ -2267,7 +2540,7 @@ async function runWorkComplete(input) {
 
 // src/commands/health.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync11, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname4, join as join16, resolve as resolve2 } from "path";
+import { dirname as dirname4, join as join17, resolve as resolve2 } from "path";
 import { platform } from "os";
 function statusFromCounts(counts) {
   if ((counts.error ?? 0) > 0) return "error";
@@ -2400,11 +2673,11 @@ function runVaultSyncHealth(home, syncMode) {
     };
   }
   const isMac = platform() === "darwin";
-  const shareDir = isMac ? join16(home, "Library", "Application Support", "vault-sync", "bin") : join16(home, ".local", "share", "vault-sync", "bin");
-  const logDir = isMac ? join16(home, "Library", "Logs") : join16(home, ".local", "state", "vault-sync", "log");
-  const filterPath = join16(home, ".config", "rclone", "wiki-push-filters.txt");
+  const shareDir = isMac ? join17(home, "Library", "Application Support", "vault-sync", "bin") : join17(home, ".local", "share", "vault-sync", "bin");
+  const logDir = isMac ? join17(home, "Library", "Logs") : join17(home, ".local", "state", "vault-sync", "log");
+  const filterPath = join17(home, ".config", "rclone", "wiki-push-filters.txt");
   const checks = [];
-  const pushScript = join16(shareDir, "wiki-push.sh");
+  const pushScript = join17(shareDir, "wiki-push.sh");
   if (syncMode === "optional" && !existsSync5(pushScript)) {
     return {
       status: "pass",
@@ -2420,20 +2693,20 @@ function runVaultSyncHealth(home, syncMode) {
   }
   checks.push(existsSync5(pushScript) ? { id: "vault_sync_installed", label: "Vault sync installed", status: "pass", detail: `Found: ${pushScript}` } : { id: "vault_sync_installed", label: "Vault sync installed", status: "error", detail: `Script missing: ${pushScript}` });
   if (isMac) {
-    const pushPlist = join16(home, "Library", "LaunchAgents", "com.karlchow.wiki-push.plist");
-    const fetchPlist = join16(home, "Library", "LaunchAgents", "com.karlchow.wiki-fetch.plist");
+    const pushPlist = join17(home, "Library", "LaunchAgents", "com.karlchow.wiki-push.plist");
+    const fetchPlist = join17(home, "Library", "LaunchAgents", "com.karlchow.wiki-fetch.plist");
     checks.push(existsSync5(pushPlist) && existsSync5(fetchPlist) ? { id: "vault_sync_jobs_enabled", label: "Vault sync jobs enabled", status: "pass", detail: "launchd unit files present (read-only mode)" } : { id: "vault_sync_jobs_enabled", label: "Vault sync jobs enabled", status: "warn", detail: "launchd unit files missing (read-only mode)" });
     checks.push({ id: "vault_sync_fuse_refresh_job", label: "Vault sync fuse refresh job", status: "pass", detail: "macOS host \u2014 check skipped" });
   } else {
-    const pushTimer = join16(home, ".config", "systemd", "user", "wiki-push.timer");
-    const fetchTimer = join16(home, ".config", "systemd", "user", "wiki-fetch.timer");
-    const fuseTimer = join16(home, ".config", "systemd", "user", "wiki-fuse-refresh.timer");
-    const fuseService = join16(home, ".config", "systemd", "user", "wiki-fuse-refresh.service");
+    const pushTimer = join17(home, ".config", "systemd", "user", "wiki-push.timer");
+    const fetchTimer = join17(home, ".config", "systemd", "user", "wiki-fetch.timer");
+    const fuseTimer = join17(home, ".config", "systemd", "user", "wiki-fuse-refresh.timer");
+    const fuseService = join17(home, ".config", "systemd", "user", "wiki-fuse-refresh.service");
     checks.push(existsSync5(pushTimer) && existsSync5(fetchTimer) ? { id: "vault_sync_jobs_enabled", label: "Vault sync jobs enabled", status: "pass", detail: "systemd timer unit files present (read-only mode)" } : { id: "vault_sync_jobs_enabled", label: "Vault sync jobs enabled", status: "warn", detail: "systemd timer unit files missing (read-only mode)" });
     checks.push(existsSync5(fuseTimer) && existsSync5(fuseService) ? { id: "vault_sync_fuse_refresh_job", label: "Vault sync fuse refresh job", status: "pass", detail: "wiki-fuse-refresh unit files present (read-only mode)" } : { id: "vault_sync_fuse_refresh_job", label: "Vault sync fuse refresh job", status: "warn", detail: "wiki-fuse-refresh unit files missing (read-only mode)" });
   }
-  checks.push(classifyLog(join16(logDir, "wiki-push.log"), "vault_sync_last_push_age", "Vault sync last push recency", /OK push/));
-  checks.push(classifyLog(join16(logDir, "wiki-fetch.log"), "vault_sync_last_fetch_status", "Vault sync last fetch status", /NOTIFY|OK behind|OK/));
+  checks.push(classifyLog(join17(logDir, "wiki-push.log"), "vault_sync_last_push_age", "Vault sync last push recency", /OK push/));
+  checks.push(classifyLog(join17(logDir, "wiki-fetch.log"), "vault_sync_last_fetch_status", "Vault sync last fetch status", /NOTIFY|OK behind|OK/));
   if (!existsSync5(filterPath)) {
     checks.push({ id: "vault_sync_filter_present", label: "Vault sync filter file present", status: "error", detail: `Filter missing: ${filterPath}` });
   } else {
@@ -2756,12 +3029,12 @@ async function runHealth(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename2, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join18, dirname as dirname5 } from "path";
+import { rename as rename2, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { join as join19, dirname as dirname5 } from "path";
 
 // src/utils/delete-intent.ts
-import { mkdir as mkdir5, writeFile as writeFile4, readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { join as join17 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile4, readdir as readdir4, readFile as readFile6 } from "fs/promises";
+import { join as join18 } from "path";
 var DELETE_INTENT_SCHEMA = "vault-delete-intent/v1";
 var DELETE_INTENT_DIR = "meta/delete-intents";
 function normalizeVaultRelPath(path) {
@@ -2792,10 +3065,10 @@ function buildDeleteIntent(input) {
   };
 }
 async function writeDeleteIntent(vault, intent) {
-  const dir = join17(vault, DELETE_INTENT_DIR);
+  const dir = join18(vault, DELETE_INTENT_DIR);
   await mkdir5(dir, { recursive: true });
   const rel = `${DELETE_INTENT_DIR}/${pathToIntentFilename(intent.path)}`;
-  await writeFile4(join17(vault, rel), JSON.stringify(intent, null, 2) + "\n", "utf8");
+  await writeFile4(join18(vault, rel), JSON.stringify(intent, null, 2) + "\n", "utf8");
   return rel;
 }
 
@@ -2833,7 +3106,7 @@ async function runArchive(input) {
   if (!relPath) return { exitCode: ExitCode.ARCHIVE_TARGET_NOT_FOUND, result: err("ARCHIVE_TARGET_NOT_FOUND", { page: input.page }) };
   if (relPath.startsWith("_archive/")) return { exitCode: ExitCode.ARCHIVE_ALREADY_ARCHIVED, result: err("ARCHIVE_ALREADY_ARCHIVED", { page: relPath }) };
   const slug = relPath.replace(/\.md$/, "").split("/").pop();
-  const archivePath = join18("_archive", relPath).replace(/\\/g, "/");
+  const archivePath = join19("_archive", relPath).replace(/\\/g, "/");
   const remoteRoot = normalizeRemoteRoot(input.remote);
   const remoteObjectPath = buildRemoteObjectPath(remoteRoot, relPath);
   let cascade;
@@ -2859,7 +3132,7 @@ async function runArchive(input) {
     const indexRefs = [];
     if (!isRaw) {
       try {
-        const idx = await readFile6(join18(input.vault, "index.md"), "utf8");
+        const idx = await readFile7(join19(input.vault, "index.md"), "utf8");
         idx.split("\n").forEach((line, i) => {
           if (line.includes(`[[${slug}]]`)) indexRefs.push({ line: i + 1, text: line });
         });
@@ -2886,8 +3159,8 @@ async function runArchive(input) {
   }
   if (input.cascade && input.apply && cascade) {
     for (const ref of cascade.source_array_refs) {
-      const absPath = join18(input.vault, ref.page);
-      const text = await readFile6(absPath, "utf8");
+      const absPath = join19(input.vault, ref.page);
+      const text = await readFile7(absPath, "utf8");
       const split = splitFrontmatter(text);
       if (!split.ok) continue;
       const before = split.data.rawFrontmatter;
@@ -2904,12 +3177,12 @@ ${fmRewritten}
       }
     }
   }
-  await mkdir6(dirname5(join18(input.vault, archivePath)), { recursive: true });
-  await rename2(join18(input.vault, relPath), join18(input.vault, archivePath));
+  await mkdir6(dirname5(join19(input.vault, archivePath)), { recursive: true });
+  await rename2(join19(input.vault, relPath), join19(input.vault, archivePath));
   let indexUpdated = false;
   if (!isRaw) {
-    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-VNJ3TLEK.js");
-    const before = await readFile6(join18(input.vault, "index.md"), "utf8").catch(() => "");
+    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-MHXG7QO2.js");
+    const before = await readFile7(join19(input.vault, "index.md"), "utf8").catch(() => "");
     const fullTarget = relPath.replace(/\.md$/, "");
     const bare = fullTarget.split("/").pop() ?? fullTarget;
     const hadIndexEntry = before.includes(`[[${fullTarget}]]`) || before.includes(`[[${bare}]]`);
@@ -2960,7 +3233,7 @@ ${fmRewritten}
 
 // src/commands/remove.ts
 import { unlink as unlink2, access } from "fs/promises";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function pathExists(abs) {
   try {
     await access(abs);
@@ -2986,7 +3259,7 @@ async function runRemove(input) {
   if (!relPath) {
     try {
       const candidate = normalizeVaultRelPath(input.page);
-      if (await pathExists(join19(input.vault, candidate))) {
+      if (await pathExists(join20(input.vault, candidate))) {
         relPath = candidate;
       }
     } catch {
@@ -3015,12 +3288,12 @@ async function runRemove(input) {
     reason: input.reason
   });
   const tombstonePath = await writeDeleteIntent(input.vault, intent);
-  await unlink2(join19(input.vault, relPath));
+  await unlink2(join20(input.vault, relPath));
   if (relPath.endsWith(".md") && !relPath.startsWith("raw/")) {
-    const { readFile: readFile16 } = await import("fs/promises");
+    const { readFile: readFile17 } = await import("fs/promises");
     const { join: pathJoin } = await import("path");
-    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-VNJ3TLEK.js");
-    const before = await readFile16(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
+    const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-MHXG7QO2.js");
+    const before = await readFile17(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
     const fullTarget = relPath.replace(/\.md$/, "");
     const bare = fullTarget.split("/").pop() ?? fullTarget;
     const hadIndexEntry = before.includes(`[[${fullTarget}]]`) || before.includes(`[[${bare}]]`);
@@ -3368,7 +3641,7 @@ ${migratedBody}${newFooter}`;
 
 // src/commands/update.ts
 import { execSync } from "child_process";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function parseCoreSemver(version) {
   const m = version.match(/^(\d+)\.(\d+)\.(\d+)/);
   if (!m) return null;
@@ -3399,7 +3672,7 @@ function resolveGlobalSkillsRoot() {
       encoding: "utf8",
       timeout: 5e3
     }).trim();
-    return join20(globalRoot, "skillwiki", "skills");
+    return join21(globalRoot, "skillwiki", "skills");
   } catch {
     return null;
   }
@@ -3427,7 +3700,7 @@ async function runUpdate(input) {
   const pkg2 = readCliPackageJson();
   const currentVersion = pkg2.version;
   const tag = normalizeDistTag(input.distTag);
-  const target = join20(input.home, ".claude", "skills");
+  const target = join21(input.home, ".claude", "skills");
   let latest;
   try {
     latest = execSync(`npm view skillwiki@${tag} version`, {
@@ -3508,13 +3781,13 @@ async function runUpdate(input) {
 // src/commands/self-update.ts
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync12 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = readCliPackageJson().version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
   const distTag = normalizeDistTag(input.distTag);
-  const localPkgPath = join21(sourceRoot, "packages", "cli", "package.json");
+  const localPkgPath = join22(sourceRoot, "packages", "cli", "package.json");
   const hasLocalSource = existsSync6(localPkgPath);
   if (input.check) {
     let availableVersion = null;
@@ -3646,21 +3919,21 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir4, stat as stat3, readFile as readFile8 } from "fs/promises";
-import { join as join22 } from "path";
+import { readdir as readdir5, stat as stat3, readFile as readFile9 } from "fs/promises";
+import { join as join23 } from "path";
 async function runTranscripts(input) {
-  const dir = join22(input.vault, "raw", "transcripts");
+  const dir = join23(input.vault, "raw", "transcripts");
   let entries;
   try {
-    entries = await readdir4(dir, { withFileTypes: true });
+    entries = await readdir5(dir, { withFileTypes: true });
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: { ok: false, error: "VAULT_PATH_INVALID", detail: `raw/transcripts/ not found: ${dir}` } };
   }
   const transcripts = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join22(dir, entry.name);
-    const content = await readFile8(filePath, "utf8");
+    const filePath = join23(dir, entry.name);
+    const content = await readFile9(filePath, "utf8");
     const fm = extractFrontmatter(content);
     if (!fm.ok) continue;
     const ingested = typeof fm.data.ingested === "string" ? fm.data.ingested : "";
@@ -3677,10 +3950,10 @@ async function runTranscripts(input) {
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile7, mkdir as mkdir7, readdir as readdir5, unlink as unlink3 } from "fs/promises";
-import { join as join23 } from "path";
+import { writeFile as writeFile7, mkdir as mkdir7, readdir as readdir6, unlink as unlink3 } from "fs/promises";
+import { join as join24 } from "path";
 import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile10 } from "fs/promises";
 var RETRO_HEADING_RE = /^## \[(\d{4}-\d{2}-\d{2})(?:\s+[^\]]+)?\] retro \| loop cycle(?: (\d+))?: (.+)$/;
 var FIELD_RE = {
   improve: /^-\s+\*?\*?Improve:?\*?\*?\s*(.+)$/m,
@@ -3778,17 +4051,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join23(input.vault, "log.md");
+  const logPath = join24(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile9(logPath, "utf8");
+    logText = await readFile10(logPath, "utf8");
   } catch {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
   }
   const entries = parseRetroEntries(logText);
   const promoted = [];
   const skipped = [];
-  const compoundDir = join23(input.vault, "projects", input.project, "compound");
+  const compoundDir = join24(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -3796,7 +4069,7 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join23(compoundDir, `${slug}.md`);
+    const compoundPath = join24(compoundDir, `${slug}.md`);
     if (existsSync7(compoundPath)) {
       skipped.push(entry.date);
       continue;
@@ -3857,7 +4130,7 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join23(input.vault, "projects", input.project);
+  const projectDir = join24(input.vault, "projects", input.project);
   if (!existsSync7(projectDir)) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -3865,7 +4138,7 @@ async function runCompoundDelete(input) {
     };
   }
   const entryName = input.entry.replace(/\.md$/, "");
-  const compoundPath = join23(projectDir, "compound", `${entryName}.md`);
+  const compoundPath = join24(projectDir, "compound", `${entryName}.md`);
   if (!existsSync7(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -3899,7 +4172,7 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join23(input.vault, "projects", input.project, "compound");
+  const compoundDir = join24(input.vault, "projects", input.project, "compound");
   if (!existsSync7(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
@@ -3914,7 +4187,7 @@ no compound directory found`
   }
   let dirents;
   try {
-    dirents = await readdir5(compoundDir, { withFileTypes: true });
+    dirents = await readdir6(compoundDir, { withFileTypes: true });
   } catch {
     return {
       exitCode: ExitCode.OK,
@@ -3930,10 +4203,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join23(compoundDir, dirent.name);
+    const filePath = join24(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile9(filePath, "utf8");
+      text = await readFile10(filePath, "utf8");
     } catch {
       continue;
     }
@@ -3962,8 +4235,8 @@ no compound entries found`;
 }
 
 // src/commands/session-brief.ts
-import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
-import { join as join24, relative, sep } from "path";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
+import { join as join25, relative, sep } from "path";
 var MAX_WORDS = 900;
 async function runSessionBrief(input) {
   const scan = await scanVault(input.vault);
@@ -4063,7 +4336,7 @@ async function resolveProject(input) {
   const envProject = input.env?.SKILLWIKI_PROJECT;
   if (envProject) return envProject;
   const cwd = input.cwd ?? process.cwd();
-  const projectDotenv = await readProjectSlug(join24(cwd, ".skillwiki", ".env"));
+  const projectDotenv = await readProjectSlug(join25(cwd, ".skillwiki", ".env"));
   if (projectDotenv) return projectDotenv;
   const inferred = inferProjectFromPath(input.vault, cwd);
   if (inferred) return inferred;
@@ -4072,7 +4345,7 @@ async function resolveProject(input) {
 async function readProjectSlug(file) {
   let text;
   try {
-    text = await readFile10(file, "utf8");
+    text = await readFile11(file, "utf8");
   } catch {
     return void 0;
   }
@@ -4149,7 +4422,7 @@ async function loadTrendDigests(typedPages) {
   return out;
 }
 async function loadSessionPins(vault, project) {
-  const text = await readIfExists(join24(vault, "meta", "session-pins.md"));
+  const text = await readIfExists(join25(vault, "meta", "session-pins.md"));
   if (!text) return [];
   const fm = extractFrontmatter(text);
   if (!fm.ok) return [];
@@ -4266,7 +4539,7 @@ function satelliteHealthWarnings(warning) {
   return warning ? [warning] : [];
 }
 async function loadHealthWarnings(vault) {
-  const text = await readIfExists(join24(vault, ".skillwiki", "health.json"));
+  const text = await readIfExists(join25(vault, ".skillwiki", "health.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -4279,7 +4552,7 @@ async function loadHealthWarnings(vault) {
   }
 }
 async function loadMemoryTopics(vault, project) {
-  const text = await readIfExists(join24(vault, ".skillwiki", "memory", project, "topics.json"));
+  const text = await readIfExists(join25(vault, ".skillwiki", "memory", project, "topics.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -4304,11 +4577,11 @@ async function loadMemoryTopics(vault, project) {
   }
 }
 async function writeBriefArtifacts(vault, input) {
-  const metaPath = join24(vault, "meta", "latest-session-brief.md");
-  const cacheMdPath = join24(vault, ".skillwiki", "session-brief.md");
-  const cacheJsonPath = join24(vault, ".skillwiki", "session-brief.json");
-  await mkdir8(join24(vault, "meta"), { recursive: true });
-  await mkdir8(join24(vault, ".skillwiki"), { recursive: true });
+  const metaPath = join25(vault, "meta", "latest-session-brief.md");
+  const cacheMdPath = join25(vault, ".skillwiki", "session-brief.md");
+  const cacheJsonPath = join25(vault, ".skillwiki", "session-brief.json");
+  await mkdir8(join25(vault, "meta"), { recursive: true });
+  await mkdir8(join25(vault, ".skillwiki"), { recursive: true });
   const committed = renderCommittedBrief(input);
   const previousComparable = comparableBrief(await readIfExists(metaPath));
   const nextComparable = comparableBrief(committed);
@@ -4378,7 +4651,7 @@ function renderCommittedBrief(input) {
   ].filter((line) => line !== "").join("\n");
 }
 async function rebuildRootIndexProjection(vault) {
-  const before = await readIfExists(join24(vault, "index.md"));
+  const before = await readIfExists(join25(vault, "index.md"));
   if (!before) return false;
   const projection = await renderRootIndex({ vault, currentText: before });
   if (!projection.ok) return false;
@@ -4388,7 +4661,7 @@ async function rebuildRootIndexProjection(vault) {
 }
 async function readIfExists(path) {
   try {
-    return await readFile10(path, "utf8");
+    return await readFile11(path, "utf8");
   } catch {
     return "";
   }
@@ -4430,15 +4703,15 @@ function dateFromPath(path) {
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile12, open, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
-import { join as join26 } from "path";
+import { readFile as readFile13, open, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
+import { join as join27 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/commands/page-publish.ts
 import { realpathSync } from "fs";
-import { readFile as readFile11 } from "fs/promises";
-import { join as join25, resolve as resolve3 } from "path";
-var DEFAULT_DEPS = {
+import { readFile as readFile12 } from "fs/promises";
+import { join as join26, resolve as resolve3 } from "path";
+var DEFAULT_DEPS2 = {
   afterStage: async () => void 0,
   preflight: (input) => runManagedWritePreflight(input)
 };
@@ -4507,7 +4780,7 @@ function preparePagePublicationFromContent(input) {
 async function preparePagePublication(input) {
   let content;
   try {
-    content = await readFile11(input.draftPath, "utf8");
+    content = await readFile12(input.draftPath, "utf8");
   } catch (error) {
     return err("FILE_NOT_FOUND", { path: input.draftPath, message: String(error) });
   }
@@ -4578,10 +4851,10 @@ async function runLockedPrimaryStages(input, vault, deps) {
       ExitCode.VAULT_PATH_INVALID
     );
   }
-  const schemaPath = join25(vault, "SCHEMA.md");
+  const schemaPath = join26(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile11(schemaPath, "utf8");
+    schemaText = await readFile12(schemaPath, "utf8");
   } catch (error) {
     return lockedFailure("schema", state, err("WRITE_FAILED", { message: String(error) }));
   }
@@ -4611,8 +4884,8 @@ async function runLockedPrimaryStages(input, vault, deps) {
   let visibleSchema;
   try {
     [visible, visibleSchema] = await Promise.all([
-      readFile11(input.targetPath, "utf8"),
-      readFile11(schemaPath, "utf8")
+      readFile12(input.targetPath, "utf8"),
+      readFile12(schemaPath, "utf8")
     ]);
   } catch (error) {
     return lockedFailure("verify", state, err("WRITE_FAILED", { message: String(error) }));
@@ -4697,17 +4970,17 @@ function renderPublicationLog(input, added) {
 }
 async function readPageChanged(targetPath, content) {
   try {
-    return ok(await readFile11(targetPath, "utf8") !== content);
+    return ok(await readFile12(targetPath, "utf8") !== content);
   } catch (error) {
     if (error.code === "ENOENT") return ok(true);
     return err("WRITE_FAILED", { path: targetPath, message: String(error) });
   }
 }
 async function previewPreparedPagePublication(input, vault) {
-  const schemaPath = join25(vault, "SCHEMA.md");
+  const schemaPath = join26(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile11(schemaPath, "utf8");
+    schemaText = await readFile12(schemaPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: schemaPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4719,10 +4992,10 @@ async function previewPreparedPagePublication(input, vault) {
   if (!reconciled.ok) return { exitCode: errorExitCode(reconciled.error), result: reconciled };
   const pageChanged = await readPageChanged(input.targetPath, input.page.content);
   if (!pageChanged.ok) return { exitCode: errorExitCode(pageChanged.error), result: pageChanged };
-  const indexPath = join25(vault, "index.md");
+  const indexPath = join26(vault, "index.md");
   let indexText;
   try {
-    indexText = await readFile11(indexPath, "utf8");
+    indexText = await readFile12(indexPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: indexPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4733,10 +5006,10 @@ async function previewPreparedPagePublication(input, vault) {
     type: input.page.type
   });
   if (!index.ok) return { exitCode: errorExitCode(index.error), result: index };
-  const logPath = join25(vault, "log.md");
+  const logPath = join26(vault, "log.md");
   let logText;
   try {
-    logText = await readFile11(logPath, "utf8");
+    logText = await readFile12(logPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: logPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4758,7 +5031,7 @@ async function previewPreparedPagePublication(input, vault) {
     true
   );
 }
-async function publishPreparedPage(input, vault, deps = DEFAULT_DEPS) {
+async function publishPreparedPage(input, vault, deps = DEFAULT_DEPS2) {
   const managed = acquireManagedWriteLock(vault, `page publish ${input.page.target}`);
   if (!managed.ok) return { exitCode: errorExitCode(managed.error), result: managed };
   try {
@@ -4913,7 +5186,7 @@ async function publishPreparedPage(input, vault, deps = DEFAULT_DEPS) {
     releaseManagedWriteLock(managed.data);
   }
 }
-async function runPagePublish(input, deps = DEFAULT_DEPS) {
+async function runPagePublish(input, deps = DEFAULT_DEPS2) {
   const prepared = await preparePagePublication(input);
   if (!prepared.ok) return { exitCode: errorExitCode(prepared.error), result: prepared };
   if (!input.write) return previewPreparedPagePublication(prepared.data, input.vault);
@@ -4998,7 +5271,7 @@ function buildTypedContent(title, ingested, type, tags, rawRelPath, provenance)
 }
 async function resolveRawCapture(input) {
   try {
-    const existing = await readFile12(input.path, "utf8");
+    const existing = await readFile13(input.path, "utf8");
     const frontmatter = extractFrontmatter(existing);
     if (!frontmatter.ok) {
       return err("INGEST_VALIDATION_FAILED", {
@@ -5137,7 +5410,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile12(input.source, "utf8");
+      sourceContent = await readFile13(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -5162,7 +5435,7 @@ async function runIngest(input) {
   const rawRelPath = `raw/articles/${slug}.md`;
   const typedDir = TYPE_DIR[input.type] ?? `${input.type}s`;
   const typedRelPath = `${typedDir}/${slug}.md`;
-  const rawAbsPath = join26(input.vault, rawRelPath);
+  const rawAbsPath = join27(input.vault, rawRelPath);
   const identity = assessSourceIdentity({
     rawPath: rawRelPath,
     sourceUrl: sourceUrl ?? void 0,
@@ -5206,11 +5479,11 @@ async function runIngest(input) {
   );
   if (!input.dryRun) {
     try {
-      await mkdir9(join26(input.vault, typedDir), { recursive: true });
+      await mkdir9(join27(input.vault, typedDir), { recursive: true });
     } catch (error) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
-        result: err("WRITE_FAILED", { path: join26(input.vault, typedDir), message: String(error) })
+        result: err("WRITE_FAILED", { path: join27(input.vault, typedDir), message: String(error) })
       };
     }
   }
@@ -5257,11 +5530,11 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir9(join26(input.vault, "raw", "articles"), { recursive: true });
+    await mkdir9(join27(input.vault, "raw", "articles"), { recursive: true });
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
-      result: err("WRITE_FAILED", { path: join26(input.vault, "raw", "articles"), message: String(error) })
+      result: err("WRITE_FAILED", { path: join27(input.vault, "raw", "articles"), message: String(error) })
     };
   }
   const rawWrite = await writeResolvedRaw({
@@ -5489,8 +5762,8 @@ ${body}`;
 }
 
 // src/commands/tag-reconcile.ts
-import { readFile as readFile13 } from "fs/promises";
-import { join as join27, posix } from "path";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join28, posix } from "path";
 var TYPED_TARGET_RE = /^(entities|concepts|comparisons|queries|meta)\/[a-z0-9][a-z0-9./_-]*\.md$/;
 function errorExitCode2(error) {
   switch (error) {
@@ -5533,7 +5806,7 @@ function asTagArray(frontmatter, path) {
 async function readTagsFromFile(path) {
   let text;
   try {
-    text = await readFile13(path, "utf8");
+    text = await readFile14(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path }) };
@@ -5554,7 +5827,7 @@ async function resolveRequestedTags(input, page) {
       result: err("INVALID_FRONTMATTER", { message: "explicit tags must be an array of strings" })
     };
   }
-  const source = input.from ?? (explicit.length === 0 ? join27(input.vault, page) : void 0);
+  const source = input.from ?? (explicit.length === 0 ? join28(input.vault, page) : void 0);
   if (!source) return { exitCode: ExitCode.OK, result: ok({ tags: [...new Set(explicit)].sort() }) };
   const sourced = await readTagsFromFile(source);
   if (!sourced.result.ok) return { exitCode: sourced.exitCode, result: sourced.result };
@@ -5565,7 +5838,7 @@ async function resolveRequestedTags(input, page) {
 }
 async function readSchema(schemaPath) {
   try {
-    return { exitCode: ExitCode.OK, result: ok(await readFile13(schemaPath, "utf8")) };
+    return { exitCode: ExitCode.OK, result: ok(await readFile14(schemaPath, "utf8")) };
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: schemaPath }) };
@@ -5593,7 +5866,7 @@ function previewResult(page, tags, reconciled, dryRun, filesChanged) {
   };
 }
 async function reconcileTagsWhileLocked(input, page, tags, comment) {
-  const schemaPath = join27(input.vault, "SCHEMA.md");
+  const schemaPath = join28(input.vault, "SCHEMA.md");
   const current = await readSchema(schemaPath);
   if (!current.result.ok) return { exitCode: current.exitCode, result: current.result };
   const next = reconcileTaxonomyDocument(current.result.data, { tags, comment });
@@ -5604,7 +5877,7 @@ async function reconcileTagsWhileLocked(input, page, tags, comment) {
   }
   let verifiedText;
   try {
-    verifiedText = await readFile13(schemaPath, "utf8");
+    verifiedText = await readFile14(schemaPath, "utf8");
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -5630,7 +5903,7 @@ async function runTagReconcile(input) {
   const comment = taxonomyCommentForPage(page.data, date, input.reason);
   if (!comment.ok) return { exitCode: ExitCode.SCHEME_REJECTED, result: comment };
   if (!input.write) {
-    const schema = await readSchema(join27(input.vault, "SCHEMA.md"));
+    const schema = await readSchema(join28(input.vault, "SCHEMA.md"));
     if (!schema.result.ok) return { exitCode: schema.exitCode, result: schema.result };
     const preview = reconcileTaxonomyDocument(schema.result.data, { tags, comment: comment.data });
     return previewResult(page.data, tags, preview, true, []);
@@ -5683,7 +5956,7 @@ async function runTagReconcile(input) {
 
 // src/commands/sync.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/utils/vault-git-pathspec.ts
@@ -5737,7 +6010,7 @@ function refHasPath(vault, ref, path) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync8(join28(vault, ".git"))) {
+  if (!existsSync8(join29(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -5844,7 +6117,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync8(join28(vault, ".git"))) {
+  if (!existsSync8(join29(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -6004,7 +6277,7 @@ function enableGitLongPathsOnWindows(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync8(join28(vault, ".git"))) {
+  if (!existsSync8(join29(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -6232,7 +6505,7 @@ function runSyncJournalClearStale(input) {
 
 // src/commands/backup.ts
 import { statSync as statSync2, readdirSync as readdirSync2, readFileSync as readFileSync13, mkdirSync as mkdirSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join29, relative as relative2, dirname as dirname6 } from "path";
+import { join as join30, relative as relative2, dirname as dirname6 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -6256,7 +6529,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join29(dir, entry.name);
+    const full = join30(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -6279,7 +6552,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join29(input.vault, relPath);
+    const absPath = join30(input.vault, relPath);
     const localStat = statSync2(absPath);
     let needsUpload = true;
     try {
@@ -6355,7 +6628,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join29(target, obj.Key);
+      const localPath = join30(target, obj.Key);
       try {
         const localStat = statSync2(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -6402,8 +6675,8 @@ async function runBackupRestore(input) {
 
 // src/commands/status.ts
 import { existsSync as existsSync9, statSync as statSync3 } from "fs";
-import { readFile as readFile14 } from "fs/promises";
-import { join as join30 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { join as join31 } from "path";
 async function runStatus(input) {
   if (!existsSync9(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
@@ -6430,7 +6703,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile14(join30(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile15(join31(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -6491,7 +6764,7 @@ async function runStatus(input) {
 
 // src/commands/seed.ts
 import { mkdir as mkdir10, writeFile as writeFile9, stat as stat4 } from "fs/promises";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -6560,29 +6833,29 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat4(join31(input.vault, "SCHEMA.md"));
+    await stat4(join32(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { root: input.vault, reason: "SCHEMA.md missing \u2014 run `skillwiki init` first" }) };
   }
   const created = [];
   const skipped = [];
   for (const [relPath, content] of Object.entries(EXAMPLE_PAGES)) {
-    const absPath = join31(input.vault, relPath);
+    const absPath = join32(input.vault, relPath);
     try {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir10(join31(absPath, ".."), { recursive: true });
+      await mkdir10(join32(absPath, ".."), { recursive: true });
       await writeFile9(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join31(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join32(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir10(join31(rawPath, ".."), { recursive: true });
+    await mkdir10(join32(rawPath, ".."), { recursive: true });
     await writeFile9(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
@@ -6605,9 +6878,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile15, writeFile as writeFile10 } from "fs/promises";
+import { readFile as readFile16, writeFile as writeFile10 } from "fs/promises";
 import { existsSync as existsSync10 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -6685,7 +6958,7 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join32(input.vault, ".skillwiki", "graph.json");
+  const graphPath = input.graphPath ?? join33(input.vault, ".skillwiki", "graph.json");
   if (!existsSync10(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -6697,7 +6970,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile15(graphPath, "utf8");
+    raw = await readFile16(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -6723,7 +6996,7 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join32(input.vault, "vault-graph.canvas");
+  const outPath = join33(input.vault, "vault-graph.canvas");
   try {
     await writeFile10(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
@@ -6748,12 +7021,12 @@ written: ${outPath}`
 import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
 import { execSync as nodeExecSync } from "child_process";
 import { hostname as nodeHostname, platform as nodePlatform } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var SSH_TIMEOUT_MS = 15e3;
 var TIMER_UNIT = "agent-memory-trends.timer";
 var SERVICE_UNIT = "agent-memory-trends.service";
 var SYSTEMD_SERVICE_FAILED_CLASS = "SYSTEMD_SERVICE_FAILED";
-function defaultDeps2() {
+function defaultDeps3() {
   return {
     platform: () => nodePlatform(),
     execSync: nodeExecSync
@@ -6973,12 +7246,12 @@ function rowHealthy(reachable, timer, runUnhealthy, timerBad, platform2) {
   return true;
 }
 async function runFleetHealth(input) {
-  const deps = input.deps ?? defaultDeps2();
+  const deps = input.deps ?? defaultDeps3();
   const env = input.env ?? process.env;
   const home = input.home ?? env.HOME ?? "";
   const osHostname = input.osHostname ?? env.HOSTNAME ?? nodeHostname();
   const vault = input.vault ?? env.WIKI_PATH;
-  const file = input.file ?? (vault ? join33(vault, FLEET_REL_PATH) : void 0);
+  const file = input.file ?? (vault ? join34(vault, FLEET_REL_PATH) : void 0);
   if (!file) {
     return {
       exitCode: ExitCode.NO_VAULT_CONFIGURED,
@@ -7063,14 +7336,14 @@ async function runFleetHealth(input) {
 
 // src/utils/auto-commit.ts
 import { existsSync as existsSync12 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   const autoCommit = process.env.AUTO_COMMIT ?? dotenv["AUTO_COMMIT"];
   if (autoCommit === "false") return;
-  if (!existsSync12(join34(vault, ".git"))) return;
+  if (!existsSync12(join35(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -7224,7 +7497,7 @@ async function emitManagedVaultWrite(vault, command, mutate, opts) {
   if (dirty) {
     return emit(dirty, void 0, { postCommit: false });
   }
-  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-7TWSEZJZ.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-4SWWFT75.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,
@@ -7249,7 +7522,7 @@ program.command("validate <file>").description("validate vault page frontmatter
   emit(await runValidate({ file, apply: !!opts.apply, vault }), vault);
 });
 program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path (default: <vault>/.skillwiki/graph.json)").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
-  const out = opts.out ?? join35(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join36(vault, ".skillwiki", "graph.json");
   return emitGuardedVaultWrite(vault, "graph build", () => runGraphBuild({ vault, out }));
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -7519,6 +7792,33 @@ projectionsCmd.command("materialize [vault]").description("preview or write root
     );
   } else emit(await runProjectionsMaterialize({ vault: v.vault, write: false }), v.vault);
 });
+projectionsCmd.command("repair-legacy [vault]").description("repair one supported legacy root-index marker pair and log event").requiredOption("--event-operation-id <id>", "exact legacy event operation ID").option("--write", "write the bounded repairs", false).option("--converge-vault <dir>", "Git vault used for managed pull and base-OID proof").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else if (opts.write) {
+    return emitManagedVaultWrite(
+      v.vault,
+      "projections repair-legacy",
+      (receipt) => runProjectionsRepairLegacy({
+        vault: v.vault,
+        eventOperationId: opts.eventOperationId,
+        write: true,
+        hostId: receipt.host_id
+      }),
+      { convergenceVault: opts.convergeVault, postCommit: false }
+    );
+  } else {
+    return emit(
+      await runProjectionsRepairLegacy({
+        vault: v.vault,
+        eventOperationId: opts.eventOperationId,
+        write: false
+      }),
+      v.vault,
+      { postCommit: false }
+    );
+  }
+});
 program.command("lint [vault]").description("run all vault health checks").option("--days <n>", "stale threshold", (s) => parseInt(s, 10), 90).option("--lines <n>", "pagesize threshold", (s) => parseInt(s, 10), 200).option("--log-threshold <n>", "log rotation threshold", (s) => parseInt(s, 10), 500).option("--fix", "auto-fix supported lint violations").option("--only <bucket>", "run only the specified lint bucket").option("--summary", "emit bounded bucket counts instead of full item arrays", false).option("--examples <n>", "example count per bucket in summary mode", (s) => parseInt(s, 10), 3).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });