skillwiki 0.10.7 → 0.10.8

package/dist/cli.js

@@ -26,6 +26,7 @@ import {
   readCliPackageJson,
   readLastOp,
   readLock,
+  readLogEvents,
   readSatelliteLatestRunFromText,
   reconcileTaxonomyDocument,
   releaseLock,
@@ -67,9 +68,11 @@ import {
   runValidate,
   safeWritePage,
   satelliteLatestRunPath,
+  scanConflictMarkerBlocksInText,
   taxonomyCommentForPage,
-  upsertIndexEntry
-} from "./chunk-45SMQAWC.js";
+  upsertIndexEntry,
+  writeLogEvent
+} from "./chunk-AVCGIWSL.js";
 import {
   normalizeDistTag,
   readCache,
@@ -95,7 +98,7 @@ import {
   releaseManagedWriteLock,
   runManagedWritePreflight,
   runManagedWriteTransaction
-} from "./chunk-4KGCTQM3.js";
+} from "./chunk-3ZVZ2YEE.js";
 import {
   FLEET_REL_PATH,
   git,
@@ -106,16 +109,18 @@ import {
   loadFleetManifestAndHost,
   parseDotenvFile,
   parseDotenvText,
+  parseJournalEnv,
   profileKey,
   readJournal,
   resolveFleetHostId,
   runFleetContext,
   runFleetValidate,
   runVaultSyncPullHelper,
+  serializeJournalEnv,
   snapshotterAliasForLocalHost,
   supersedeStaleReviewRequiredJournals,
   writeDotenv
-} from "./chunk-R6BKJWVC.js";
+} from "./chunk-TYN2IHBY.js";
 import {
   ExitCode,
   MetaSchema,
@@ -126,7 +131,7 @@ import {
 } from "./chunk-C5OLZRRM.js";
 
 // src/cli.ts
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -466,6 +471,15 @@ async function runInstall(input) {
 }
 
 // src/commands/path.ts
+function toPathOutput(path, source, plain, chain) {
+  return {
+    path,
+    source,
+    ...chain ? { chain } : {},
+    ...plain ? { plain: true } : {},
+    humanHint: plain ? path : `${path} (via ${source})`
+  };
+}
 async function runPath(input) {
   if (input.initTime) {
     const r2 = await resolveInitTimePath({
@@ -475,7 +489,10 @@ async function runPath(input) {
       cwd: input.cwd,
       explain: input.explain
     });
-    return { exitCode: ExitCode.OK, result: ok({ path: r2.path, source: r2.source, ...r2.chain ? { chain: r2.chain } : {}, humanHint: `${r2.path} (via ${r2.source})` }) };
+    return {
+      exitCode: ExitCode.OK,
+      result: ok(toPathOutput(r2.path, r2.source, input.plain, r2.chain))
+    };
   }
   const r = await resolveRuntimePath({
     flag: input.flag,
@@ -489,7 +506,10 @@ async function runPath(input) {
     const exitCode = r.error === "UNKNOWN_WIKI_PROFILE" ? ExitCode.UNKNOWN_WIKI_PROFILE : ExitCode.NO_VAULT_CONFIGURED;
     return { exitCode, result: r };
   }
-  return { exitCode: ExitCode.OK, result: ok({ path: r.data.path, source: r.data.source, ...r.data.chain ? { chain: r.data.chain } : {}, humanHint: `${r.data.path} (via ${r.data.source})` }) };
+  return {
+    exitCode: ExitCode.OK,
+    result: ok(toPathOutput(r.data.path, r.data.source, input.plain, r.data.chain))
+  };
 }
 
 // src/utils/lang.ts
@@ -992,7 +1012,7 @@ import { mkdtempSync, writeFileSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { join as join8 } from "path";
 var ENTRY_RE = /^## \[/m;
-var PUBLISH_MARKER_RE = /<!--\s*skillwiki-page-publish:([a-f0-9]{64})\s*-->/i;
+var OPERATION_MARKER_RE = /<!--\s*skillwiki-(?:page-publish|log-op):([a-f0-9]{64})\s*-->/i;
 function splitLog(text) {
   const normalized = text.replace(/\r\n/g, "\n");
   const match = ENTRY_RE.exec(normalized);
@@ -1006,7 +1026,7 @@ function splitLog(text) {
   return { preamble, entries };
 }
 function publishId(entry) {
-  return PUBLISH_MARKER_RE.exec(entry)?.[1]?.toLowerCase();
+  return OPERATION_MARKER_RE.exec(entry)?.[1]?.toLowerCase();
 }
 function unionUnstructured(base, ours, theirs) {
   const dir = mkdtempSync(join8(tmpdir(), "log-union-"));
@@ -1187,21 +1207,21 @@ function rollbackPath(vault, path, stage2, stage3) {
 }
 function hasMarkers(path, text) {
   const lines = text.split(/\r?\n/);
-  let open3 = false;
+  let open2 = false;
   let sep2 = false;
   for (const line of lines) {
     if (line.startsWith("<<<<<<< ")) {
-      open3 = true;
+      open2 = true;
       sep2 = false;
       continue;
     }
-    if (line === "=======" && open3) {
+    if (line === "=======" && open2) {
       sep2 = true;
       continue;
     }
-    if (line.startsWith(">>>>>>> ") && open3 && sep2) return true;
+    if (line.startsWith(">>>>>>> ") && open2 && sep2) return true;
     if (line.startsWith(">>>>>>> ")) {
-      open3 = false;
+      open2 = false;
       sep2 = false;
     }
   }
@@ -1304,144 +1324,7 @@ async function runDerivedConflictResolution(input) {
 
 // src/commands/log-materialize.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join11 } from "path";
-
-// src/utils/log-events.ts
-import { mkdir as mkdir4, open, readFile as readFile4, readdir as readdir3 } from "fs/promises";
 import { join as join10 } from "path";
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function canonicalize(value) {
-  if (Array.isArray(value)) return value.map(canonicalize);
-  if (!isPlainObject(value)) return value;
-  const out = {};
-  for (const key of Object.keys(value).sort()) {
-    out[key] = canonicalize(value[key]);
-  }
-  return out;
-}
-function eventPathFor(event) {
-  const day2 = event.occurred_at.slice(0, 10);
-  return `meta/log-events/${day2}/${event.operation_id}.json`;
-}
-function validateLogEvent(event) {
-  if (event.schema !== "skillwiki-log-event/v1") {
-    return err("SCHEME_REJECTED", { message: "invalid event schema" });
-  }
-  if (!/^[0-9a-f]{64}$/.test(event.operation_id)) {
-    return err("SCHEME_REJECTED", { message: "operation_id must be 64 hex chars" });
-  }
-  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(event.occurred_at)) {
-    return err("SCHEME_REJECTED", { message: "occurred_at must be UTC ISO with milliseconds" });
-  }
-  for (const field of ["host_id", "actor", "kind", "target", "note"]) {
-    const v = event[field];
-    if (typeof v !== "string" || v.trim().length === 0 || v.length > 500) {
-      return err("SCHEME_REJECTED", { message: `invalid ${field}` });
-    }
-  }
-  if (!isPlainObject(event.metadata)) {
-    return err("SCHEME_REJECTED", { message: "metadata must be a plain object" });
-  }
-  const sensitive = scanSensitiveContent(JSON.stringify(event));
-  if (sensitive.length > 0) {
-    return err("SENSITIVE_CONTENT_DETECTED", { findings: sensitive });
-  }
-  return ok({
-    schema: "skillwiki-log-event/v1",
-    operation_id: event.operation_id,
-    occurred_at: event.occurred_at,
-    host_id: event.host_id,
-    actor: event.actor,
-    kind: event.kind,
-    target: event.target,
-    note: event.note,
-    metadata: canonicalize(event.metadata)
-  });
-}
-function canonicalEventJson(event) {
-  const ordered = {
-    schema: event.schema,
-    operation_id: event.operation_id,
-    occurred_at: event.occurred_at,
-    host_id: event.host_id,
-    actor: event.actor,
-    kind: event.kind,
-    target: event.target,
-    note: event.note,
-    metadata: event.metadata
-  };
-  return `${JSON.stringify(ordered, null, 2)}
-`;
-}
-async function writeLogEvent(vault, event) {
-  const validated = validateLogEvent(event);
-  if (!validated.ok) return validated;
-  const rel = eventPathFor(validated.data);
-  const abs = join10(vault, rel);
-  await mkdir4(join10(vault, "meta", "log-events", validated.data.occurred_at.slice(0, 10)), {
-    recursive: true
-  });
-  const body = canonicalEventJson(validated.data);
-  try {
-    const handle = await open(abs, "wx");
-    try {
-      await handle.writeFile(body, "utf8");
-    } finally {
-      await handle.close();
-    }
-    return ok({ path: rel, created: true });
-  } catch (error) {
-    if (error.code === "EEXIST") {
-      let existing;
-      try {
-        existing = await readFile4(abs, "utf8");
-      } catch (readErr) {
-        return err("WRITE_FAILED", { path: rel, message: String(readErr) });
-      }
-      if (existing === body) return ok({ path: rel, created: false });
-      return err("EVENT_IDENTITY_COLLISION", { path: rel });
-    }
-    return err("WRITE_FAILED", { path: rel, message: String(error) });
-  }
-}
-async function readLogEvents(vault) {
-  const root = join10(vault, "meta", "log-events");
-  let days;
-  try {
-    days = (await readdir3(root, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
-  } catch {
-    return ok([]);
-  }
-  const events = [];
-  for (const day2 of days) {
-    const files = (await readdir3(join10(root, day2))).filter((f) => f.endsWith(".json")).sort();
-    for (const file of files) {
-      const text = await readFile4(join10(root, day2, file), "utf8");
-      let parsed;
-      try {
-        parsed = JSON.parse(text);
-      } catch {
-        return err("SCHEME_REJECTED", { path: `meta/log-events/${day2}/${file}`, message: "invalid JSON" });
-      }
-      const validated = validateLogEvent(parsed);
-      if (!validated.ok) return validated;
-      if (eventPathFor(validated.data) !== `meta/log-events/${day2}/${file}`) {
-        return err("SCHEME_REJECTED", {
-          path: `meta/log-events/${day2}/${file}`,
-          message: "path/identity mismatch"
-        });
-      }
-      events.push(validated.data);
-    }
-  }
-  events.sort((a, b) => {
-    if (a.occurred_at !== b.occurred_at) return a.occurred_at < b.occurred_at ? -1 : 1;
-    return a.operation_id < b.operation_id ? -1 : a.operation_id > b.operation_id ? 1 : 0;
-  });
-  return ok(events);
-}
 
 // src/utils/log-projection.ts
 function day(event) {
@@ -1547,7 +1430,7 @@ async function runLogMaterialize(input) {
   const text = renderLogProjection(events.data);
   let current = "";
   try {
-    current = readFileSync6(join11(input.vault, "log.md"), "utf8");
+    current = readFileSync6(join10(input.vault, "log.md"), "utf8");
   } catch {
     current = "";
   }
@@ -1591,9 +1474,9 @@ async function runLogMaterialize(input) {
       })
     };
   }
-  const written = await atomicWriteText(join11(input.vault, "log.md"), text);
+  const written = await atomicWriteText(join10(input.vault, "log.md"), text);
   if (!written.ok) return { exitCode: ExitCode.WRITE_FAILED, result: written };
-  const installed = readFileSync6(join11(input.vault, "log.md"), "utf8");
+  const installed = readFileSync6(join10(input.vault, "log.md"), "utf8");
   if (installed !== text) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -1613,7 +1496,7 @@ async function runLogMaterialize(input) {
 
 // src/commands/log-migrate-legacy.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { join as join12 } from "path";
+import { join as join11 } from "path";
 
 // src/utils/operation-id.ts
 import { createHash as createHash2 } from "crypto";
@@ -1642,7 +1525,7 @@ function splitLegacyBlocks(text) {
 async function runLogMigrateLegacy(input) {
   let text = "";
   try {
-    text = readFileSync7(join12(input.vault, "log.md"), "utf8");
+    text = readFileSync7(join11(input.vault, "log.md"), "utf8");
   } catch {
     return {
       exitCode: ExitCode.OK,
@@ -1699,7 +1582,7 @@ async function runLogMigrateLegacy(input) {
 
 // src/commands/projections-materialize.ts
 import { readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 var defaultDeps = {
   writeText: (path, text) => atomicWriteText(path, text)
 };
@@ -1715,11 +1598,11 @@ async function runProjectionsMaterialize(input, deps = defaultDeps) {
   let curIndex = "";
   let curLog = "";
   try {
-    curIndex = readFileSync8(join13(input.vault, "index.md"), "utf8");
+    curIndex = readFileSync8(join12(input.vault, "index.md"), "utf8");
   } catch {
   }
   try {
-    curLog = readFileSync8(join13(input.vault, "log.md"), "utf8");
+    curLog = readFileSync8(join12(input.vault, "log.md"), "utf8");
   } catch {
   }
   const indexDrift = curIndex !== indexProj.data.text;
@@ -1753,8 +1636,8 @@ async function runProjectionsMaterialize(input, deps = defaultDeps) {
       })
     };
   }
-  const indexPath = join13(input.vault, "index.md");
-  const logPath = join13(input.vault, "log.md");
+  const indexPath = join12(input.vault, "index.md");
+  const logPath = join12(input.vault, "log.md");
   const indexWrite = await deps.writeText(indexPath, indexProj.data.text);
   if (!indexWrite.ok) return { exitCode: ExitCode.WRITE_FAILED, result: indexWrite };
   const logWrite = await deps.writeText(logPath, logText);
@@ -1794,9 +1677,9 @@ async function runProjectionsMaterialize(input, deps = defaultDeps) {
 }
 
 // src/commands/claim.ts
-import { mkdir as mkdir5, writeFile as writeFile3, readFile as readFile5 } from "fs/promises";
+import { mkdir as mkdir4, writeFile as writeFile3, readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync2, statSync } from "fs";
-import { join as join14 } from "path";
+import { join as join13 } from "path";
 function extractDate(filename) {
   const m = filename.match(/^(\d{4}-\d{2}-\d{2})/);
   return m?.[1] ?? "";
@@ -1811,11 +1694,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 = join14(input.vault, input.transcript);
+  const absTranscript = join13(input.vault, input.transcript);
   if (!existsSync2(absTranscript)) {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: input.transcript }) };
   }
-  const content = await readFile5(absTranscript, "utf8");
+  const content = await readFile4(absTranscript, "utf8");
   const fm = extractFrontmatter(content);
   let projectSlug = input.project;
   if (!projectSlug && fm.ok && typeof fm.data.project === "string") {
@@ -1827,7 +1710,7 @@ async function runClaim(input) {
       result: err("SCHEME_REJECTED", { message: "No project specified. Use --project or set project in transcript frontmatter." })
     };
   }
-  const projectDir = join14(input.vault, "projects", projectSlug);
+  const projectDir = join13(input.vault, "projects", projectSlug);
   if (!existsSync2(projectDir) || !statSync(projectDir).isDirectory()) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -1844,7 +1727,7 @@ async function runClaim(input) {
   }
   const workSlug = input.slug || extractSlugFromFilename(filename);
   const dirName = `${date}-${workSlug}`;
-  const workDir = join14(projectDir, "work", dirName);
+  const workDir = join13(projectDir, "work", dirName);
   const relWorkDir = `projects/${projectSlug}/work/${dirName}`;
   const relSpecPath = `${relWorkDir}/spec.md`;
   if (existsSync2(workDir)) {
@@ -1858,7 +1741,7 @@ async function runClaim(input) {
       })
     };
   }
-  await mkdir5(workDir, { recursive: true });
+  await mkdir4(workDir, { recursive: true });
   const kind = fm.ok && typeof fm.data.kind === "string" ? fm.data.kind : "task";
   const specLines = [
     "---",
@@ -1873,7 +1756,7 @@ async function runClaim(input) {
     `Claimed from ${input.transcript}`,
     ""
   ];
-  await writeFile3(join14(workDir, "spec.md"), specLines.join("\n"), "utf8");
+  await writeFile3(join13(workDir, "spec.md"), specLines.join("\n"), "utf8");
   appendLastOp(input.vault, {
     operation: "claim",
     summary: `claimed ${input.transcript} \u2192 ${relWorkDir}`,
@@ -1891,9 +1774,483 @@ 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";
+
+// src/commands/work-validate.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync9 } from "fs";
+import { join as join14 } from "path";
+function normalizeWorkItemRel(workItem) {
+  return workItem.replace(/\\/g, "/").replace(/^\.?\//, "");
+}
+function scanFileConflicts(relPath, text) {
+  return scanConflictMarkerBlocksInText(relPath, text).length;
+}
+function countUnchecked(text) {
+  return [...text.matchAll(/^- \[ \]/gm)].length;
+}
+function extractPrMetadata(fm) {
+  const keys = [
+    "pr_url",
+    "pr_number",
+    "merge_commit",
+    "merged",
+    "merge_method",
+    "merge_auto_approved"
+  ];
+  const out = {};
+  let any = false;
+  for (const k of keys) {
+    if (k in fm) {
+      out[k] = fm[k];
+      any = true;
+    }
+  }
+  return any ? out : null;
+}
+function validatePrMetadata(meta, findings) {
+  if (!meta) return;
+  if ("pr_number" in meta && meta.pr_number !== null && meta.pr_number !== void 0) {
+    if (typeof meta.pr_number !== "number" && !/^\d+$/.test(String(meta.pr_number))) {
+      findings.push({
+        code: "bad_pr_metadata",
+        message: `pr_number must be numeric, got ${JSON.stringify(meta.pr_number)}`
+      });
+    }
+  }
+  if ("pr_url" in meta && meta.pr_url != null) {
+    const url = String(meta.pr_url);
+    if (url && !/^https?:\/\//.test(url)) {
+      findings.push({
+        code: "bad_pr_metadata",
+        message: `pr_url must be an http(s) URL, got ${url}`
+      });
+    }
+  }
+  if (meta.merged === true && !meta.merge_commit && !meta.pr_number && !meta.pr_url) {
+    findings.push({
+      code: "bad_pr_metadata",
+      message: "merged: true requires merge_commit or pr_number/pr_url"
+    });
+  }
+}
+async function runWorkValidate(input) {
+  const rel = normalizeWorkItemRel(input.workItem);
+  const workDir = join14(input.vault, rel);
+  if (!existsSync3(workDir)) {
+    return {
+      exitCode: ExitCode.FILE_NOT_FOUND,
+      result: err("FILE_NOT_FOUND", { path: rel })
+    };
+  }
+  const findings = [];
+  const status = {};
+  let evidencePresent = false;
+  let unchecked = 0;
+  let conflicts = 0;
+  let decisionsPresent = false;
+  let prMetadata = null;
+  const files = readdirSync(workDir).filter((f) => f.endsWith(".md"));
+  if (!files.includes("spec.md")) {
+    findings.push({ code: "missing_spec", path: `${rel}/spec.md`, message: "spec.md is required" });
+  }
+  for (const file of files) {
+    const abs = join14(workDir, file);
+    let text;
+    try {
+      text = readFileSync9(abs, "utf8");
+    } catch {
+      findings.push({ code: "unreadable", path: `${rel}/${file}`, message: "cannot read file" });
+      continue;
+    }
+    const c = scanFileConflicts(`${rel}/${file}`, text);
+    conflicts += c;
+    if (c > 0) {
+      findings.push({
+        code: "conflict_markers",
+        path: `${rel}/${file}`,
+        message: `${c} conflict marker block(s)`
+      });
+    }
+    unchecked += countUnchecked(text);
+    const fm = extractFrontmatter(text);
+    if (file === "spec.md" && fm.ok) {
+      status.spec = typeof fm.data.status === "string" ? fm.data.status : void 0;
+      prMetadata = extractPrMetadata(fm.data);
+      validatePrMetadata(prMetadata, findings);
+    }
+    if (file === "plan.md" && fm.ok) {
+      status.plan = typeof fm.data.status === "string" ? fm.data.status : void 0;
+    }
+    if (file === "evidence.md" || file === "retro.md") {
+      evidencePresent = true;
+    }
+    if (file === "decisions.md" || /##\s+Decisions/i.test(text) || /structured.decisions/i.test(text)) {
+      decisionsPresent = true;
+    }
+    if (/^- \*\*Decision\*\*:/m.test(text) || /^## Decision/m.test(text)) {
+      decisionsPresent = true;
+    }
+  }
+  if (input.requireComplete) {
+    if (status.spec && status.spec !== "completed" && status.spec !== "complete" && status.spec !== "done") {
+      findings.push({
+        code: "spec_not_completed",
+        path: `${rel}/spec.md`,
+        message: `spec status is ${status.spec}, expected completed`
+      });
+    }
+    if (!status.spec) {
+      findings.push({
+        code: "spec_status_missing",
+        path: `${rel}/spec.md`,
+        message: "spec frontmatter status missing for completion"
+      });
+    }
+    if (!evidencePresent) {
+      findings.push({
+        code: "missing_evidence",
+        path: rel,
+        message: "completion requires evidence.md or retro.md"
+      });
+    }
+    if (unchecked > 0) {
+      findings.push({
+        code: "unchecked_steps",
+        path: rel,
+        message: `${unchecked} unchecked completion step(s) remain`
+      });
+    }
+  }
+  if (status.plan === "completed" || status.plan === "complete") {
+    if (!evidencePresent) {
+      findings.push({
+        code: "missing_evidence",
+        path: rel,
+        message: "plan is completed but evidence/retro is missing"
+      });
+    }
+  }
+  const valid = findings.length === 0;
+  const hint = valid ? `work item valid: ${rel}` : `work item invalid (${findings.length}): ${findings.map((f) => f.code).join(", ")}`;
+  return {
+    exitCode: valid ? ExitCode.OK : ExitCode.PREFLIGHT_FAILED,
+    result: ok({
+      work_item: rel,
+      valid,
+      findings,
+      status,
+      evidence_present: evidencePresent,
+      unchecked_steps: unchecked,
+      conflict_markers: conflicts,
+      decisions_present: decisionsPresent,
+      pr_metadata: prMetadata,
+      humanHint: hint
+    })
+  };
+}
+
+// src/commands/work-complete.ts
+function workCompleteJournalPath(vault, opId) {
+  return join15(vault, ".skillwiki", "work-complete", `${opId}.env`);
+}
+function readWorkJournal(vault, opId) {
+  const path = workCompleteJournalPath(vault, opId);
+  if (!existsSync4(path)) return null;
+  try {
+    return parseJournalEnv(readFileSync10(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeWorkJournal(vault, opId, fields) {
+  const path = workCompleteJournalPath(vault, opId);
+  const dir = join15(vault, ".skillwiki", "work-complete");
+  mkdirSync(dir, { recursive: true });
+  const tmp = `${path}.tmp.${process.pid}`;
+  const body = serializeJournalEnv(fields, [
+    "operation_id",
+    "phase",
+    "retry_count",
+    "work_item",
+    "committed",
+    "reason"
+  ]);
+  writeFileSync3(tmp, body, "utf8");
+  renameSync(tmp, path);
+}
+var PHASE_ORDER = ["validate", "evidence", "log", "projection", "commit", "done"];
+function resolveWorkDir(vault, workItem) {
+  const rel = normalizeWorkItemRel(workItem);
+  const abs = join15(vault, rel);
+  if (!existsSync4(abs)) {
+    return err("FILE_NOT_FOUND", { path: rel });
+  }
+  if (!existsSync4(join15(abs, "spec.md"))) {
+    return err("PREFLIGHT_FAILED", { reason: "missing-spec", path: rel });
+  }
+  return ok(abs);
+}
+function deriveOpId(vault, workItem) {
+  return operationId("skillwiki-work-complete-v1", [vault, workItem]);
+}
+function phaseIndex(phase) {
+  const i = PHASE_ORDER.indexOf(phase);
+  return i < 0 ? 0 : i;
+}
+async function patchFrontmatterStatus(filePath, extraBody) {
+  let text;
+  try {
+    text = readFileSync10(filePath, "utf8");
+  } catch {
+    return;
+  }
+  const split = splitFrontmatter(text);
+  if (!split.ok || !split.data.rawFrontmatter) {
+    if (extraBody) {
+      await atomicWriteText(filePath, extraBody(text));
+    }
+    return;
+  }
+  let fm = split.data.rawFrontmatter;
+  if (/^status:\s*/m.test(fm)) {
+    fm = fm.replace(/^status:\s*.*$/m, "status: completed");
+  } else {
+    fm = `status: completed
+${fm}`;
+  }
+  if (!/^completed:\s*/m.test(fm)) {
+    fm = `completed: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}
+${fm}`;
+  }
+  let body = split.data.body;
+  if (extraBody) body = extraBody(body);
+  await atomicWriteText(filePath, `---
+${fm}
+---
+${body}`);
+}
+async function setStatusCompleted(filePath) {
+  await patchFrontmatterStatus(filePath);
+}
+async function writeEvidence(workDir, opId, phases) {
+  const path = join15(workDir, "evidence.md");
+  const body = [
+    "---",
+    "title: work-complete evidence",
+    "status: completed",
+    `operation_id: ${opId}`,
+    "---",
+    "",
+    "# Work-complete evidence",
+    "",
+    `- operation_id: \`${opId}\``,
+    `- phases: ${phases.join(", ")}`,
+    `- completed_at: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ""
+  ].join("\n");
+  await atomicWriteText(path, body);
+}
+async function markPlanComplete(workDir) {
+  const planPath = join15(workDir, "plan.md");
+  if (!existsSync4(planPath)) return;
+  await patchFrontmatterStatus(planPath, (body) => body.replace(/- \[ \]/g, "- [x]"));
+}
+async function runWorkComplete(input) {
+  const workDirResult = resolveWorkDir(input.vault, input.workItem);
+  if (!workDirResult.ok) {
+    return {
+      exitCode: workDirResult.error === "FILE_NOT_FOUND" ? ExitCode.FILE_NOT_FOUND : ExitCode.PREFLIGHT_FAILED,
+      result: workDirResult
+    };
+  }
+  const workDir = workDirResult.data;
+  const opId = input.operationId || deriveOpId(input.vault, input.workItem);
+  if (!/^[0-9a-f]{64}$/.test(opId)) {
+    return { exitCode: ExitCode.USAGE, result: err("USAGE", { message: "operationId must be SHA-256 hex" }) };
+  }
+  const journal = readWorkJournal(input.vault, opId) || {
+    operation_id: opId,
+    phase: "validate",
+    retry_count: "0",
+    work_item: input.workItem
+  };
+  const startPhase = journal.phase || "validate";
+  if (startPhase === "done") {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        operation_id: opId,
+        work_item: input.workItem,
+        phases: ["done"],
+        completed: true,
+        retried: true,
+        committed: journal.committed === "true",
+        humanHint: `work-complete already finished (${opId.slice(0, 12)})`
+      })
+    };
+  }
+  const completedPhases = [];
+  let phase = PHASE_ORDER.includes(startPhase) ? startPhase : "validate";
+  const retried = Number(journal.retry_count || "0") > 0;
+  const advance = (next, extra = {}) => {
+    phase = next;
+    writeWorkJournal(input.vault, opId, {
+      ...journal,
+      operation_id: opId,
+      phase: next,
+      work_item: input.workItem,
+      retry_count: journal.retry_count || "0",
+      ...extra
+    });
+    Object.assign(journal, { phase: next, ...extra });
+    completedPhases.push(next);
+  };
+  if (phaseIndex(startPhase) > 0) {
+    journal.retry_count = String(Number(journal.retry_count || "0") + 1);
+  }
+  writeWorkJournal(input.vault, opId, {
+    ...journal,
+    operation_id: opId,
+    phase: startPhase,
+    work_item: input.workItem
+  });
+  try {
+    if (phaseIndex(phase) <= phaseIndex("validate")) {
+      const cross = await runWorkValidate({ vault: input.vault, workItem: input.workItem, requireComplete: false });
+      if (!cross.result.ok || cross.exitCode !== ExitCode.OK) {
+        return {
+          exitCode: cross.exitCode || ExitCode.PREFLIGHT_FAILED,
+          result: err("PREFLIGHT_FAILED", {
+            reason: "work-validate-failed",
+            detail: cross.result.ok ? cross.result.data : cross.result
+          })
+        };
+      }
+      if (input.failAfter === "validate") {
+        throw new Error("simulated failure after validate");
+      }
+      advance("evidence");
+    }
+    if (phaseIndex(phase) <= phaseIndex("evidence")) {
+      await setStatusCompleted(join15(workDir, "spec.md"));
+      await markPlanComplete(workDir);
+      await writeEvidence(workDir, opId, completedPhases);
+      if (input.failAfter === "evidence") {
+        throw new Error("simulated failure after evidence");
+      }
+      advance("log");
+    }
+    if (phaseIndex(phase) <= phaseIndex("log")) {
+      const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+      const log = await runLogAppend({
+        vault: input.vault,
+        content: `## [${date}] work-complete | ${input.workItem}
+
+- operation_id: ${opId}`,
+        operationId: opId,
+        writeEvent: true,
+        eventKind: "work-complete",
+        eventTarget: input.workItem,
+        eventNote: `work-complete ${input.workItem}`,
+        recordLastOp: false
+      });
+      if (!log.result.ok) {
+        return { exitCode: log.exitCode, result: log.result };
+      }
+      if (input.failAfter === "log") {
+        throw new Error("simulated failure after log");
+      }
+      advance("projection");
+    }
+    if (phaseIndex(phase) <= phaseIndex("projection")) {
+      if (!existsSync4(join15(workDir, "evidence.md"))) {
+        await writeEvidence(workDir, opId, completedPhases);
+      }
+      const finalCheck = await runWorkValidate({
+        vault: input.vault,
+        workItem: input.workItem,
+        requireComplete: true
+      });
+      if (!finalCheck.result.ok || finalCheck.result.ok && !finalCheck.result.data.valid) {
+        return {
+          exitCode: ExitCode.PREFLIGHT_FAILED,
+          result: err("PREFLIGHT_FAILED", {
+            reason: "completion-validation-failed",
+            detail: finalCheck.result.ok ? finalCheck.result.data : finalCheck.result
+          })
+        };
+      }
+      if (input.failAfter === "projection") {
+        throw new Error("simulated failure after projection");
+      }
+      advance("commit");
+    }
+    let committed = false;
+    if (phaseIndex(phase) <= phaseIndex("commit")) {
+      if (!input.noCommit && existsSync4(join15(input.vault, ".git"))) {
+        try {
+          appendLastOp(input.vault, {
+            operation: "work-complete",
+            summary: `completed ${input.workItem}`,
+            files: [input.workItem],
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          git(input.vault, ["add", "--", input.workItem, "log.md", "meta/log-events"]);
+          const porcelain = git(input.vault, ["status", "--porcelain"]);
+          if (porcelain && porcelain.trim()) {
+            gitStrict(input.vault, ["commit", "-m", `work-complete: ${input.workItem} (${opId.slice(0, 12)})`]);
+            committed = true;
+          }
+        } catch (e) {
+          return {
+            exitCode: ExitCode.WRITE_FAILED,
+            result: err("WRITE_FAILED", { stage: "commit", message: String(e) })
+          };
+        }
+      }
+      if (input.failAfter === "commit") {
+        throw new Error("simulated failure after commit");
+      }
+      advance("done", { committed: committed ? "true" : "false" });
+    }
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        operation_id: opId,
+        work_item: input.workItem,
+        phases: completedPhases,
+        completed: true,
+        retried,
+        committed,
+        humanHint: `work-complete finished ${input.workItem} (${opId.slice(0, 12)})`
+      })
+    };
+  } catch (error) {
+    writeWorkJournal(input.vault, opId, {
+      ...journal,
+      operation_id: opId,
+      phase,
+      work_item: input.workItem,
+      retry_count: String(Number(journal.retry_count || "0") + 1),
+      reason: String(error)
+    });
+    return {
+      exitCode: ExitCode.WRITE_FAILED,
+      result: err("WRITE_FAILED", {
+        stage: phase,
+        message: String(error),
+        operation_id: opId,
+        resumable: true
+      })
+    };
+  }
+}
+
 // src/commands/health.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync9, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname4, join as join15, resolve as resolve2 } from "path";
+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 { platform } from "os";
 function statusFromCounts(counts) {
   if ((counts.error ?? 0) > 0) return "error";
@@ -2004,8 +2361,8 @@ function summarizeChecks(checks) {
   };
 }
 function classifyLog(path, id, label, okPattern) {
-  if (!existsSync3(path)) return { id, label, status: "warn", detail: `log file missing: ${path}` };
-  const lines = readFileSync9(path, "utf8").split(/\r?\n/).filter(Boolean);
+  if (!existsSync5(path)) return { id, label, status: "warn", detail: `log file missing: ${path}` };
+  const lines = readFileSync11(path, "utf8").split(/\r?\n/).filter(Boolean);
   if (lines.length === 0) return { id, label, status: "warn", detail: `log file empty: ${path}` };
   const statusLine = [...lines].reverse().find(
     (line) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z /.test(line) && (okPattern.test(line) || /\bFAIL\b|\bERROR\b/i.test(line))
@@ -2026,12 +2383,12 @@ function runVaultSyncHealth(home, syncMode) {
     };
   }
   const isMac = platform() === "darwin";
-  const shareDir = isMac ? join15(home, "Library", "Application Support", "vault-sync", "bin") : join15(home, ".local", "share", "vault-sync", "bin");
-  const logDir = isMac ? join15(home, "Library", "Logs") : join15(home, ".local", "state", "vault-sync", "log");
-  const filterPath = join15(home, ".config", "rclone", "wiki-push-filters.txt");
+  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 checks = [];
-  const pushScript = join15(shareDir, "wiki-push.sh");
-  if (syncMode === "optional" && !existsSync3(pushScript)) {
+  const pushScript = join16(shareDir, "wiki-push.sh");
+  if (syncMode === "optional" && !existsSync5(pushScript)) {
     return {
       status: "pass",
       blocking: false,
@@ -2044,26 +2401,26 @@ function runVaultSyncHealth(home, syncMode) {
       }]
     };
   }
-  checks.push(existsSync3(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}` });
+  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 = join15(home, "Library", "LaunchAgents", "com.karlchow.wiki-push.plist");
-    const fetchPlist = join15(home, "Library", "LaunchAgents", "com.karlchow.wiki-fetch.plist");
-    checks.push(existsSync3(pushPlist) && existsSync3(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)" });
+    const pushPlist = join16(home, "Library", "LaunchAgents", "com.karlchow.wiki-push.plist");
+    const fetchPlist = join16(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 = join15(home, ".config", "systemd", "user", "wiki-push.timer");
-    const fetchTimer = join15(home, ".config", "systemd", "user", "wiki-fetch.timer");
-    const fuseTimer = join15(home, ".config", "systemd", "user", "wiki-fuse-refresh.timer");
-    const fuseService = join15(home, ".config", "systemd", "user", "wiki-fuse-refresh.service");
-    checks.push(existsSync3(pushTimer) && existsSync3(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(existsSync3(fuseTimer) && existsSync3(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(join15(logDir, "wiki-push.log"), "vault_sync_last_push_age", "Vault sync last push recency", /OK push/));
-  checks.push(classifyLog(join15(logDir, "wiki-fetch.log"), "vault_sync_last_fetch_status", "Vault sync last fetch status", /NOTIFY|OK behind|OK/));
-  if (!existsSync3(filterPath)) {
+    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");
+    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/));
+  if (!existsSync5(filterPath)) {
     checks.push({ id: "vault_sync_filter_present", label: "Vault sync filter file present", status: "error", detail: `Filter missing: ${filterPath}` });
   } else {
-    const content = readFileSync9(filterPath, "utf8");
+    const content = readFileSync11(filterPath, "utf8");
     const missing = [
       "remotely-save/data.json",
       ".skillwiki/sync.lock",
@@ -2156,10 +2513,10 @@ function buildHumanHint(report) {
   return lines.join("\n");
 }
 function writeReport(out, report) {
-  mkdirSync(dirname4(out), { recursive: true });
+  mkdirSync2(dirname4(out), { recursive: true });
   const tmp = `${out}.tmp-${process.pid}-${Date.now()}`;
-  writeFileSync3(tmp, JSON.stringify(ok(report), null, 2) + "\n", "utf8");
-  renameSync(tmp, out);
+  writeFileSync4(tmp, JSON.stringify(ok(report), null, 2) + "\n", "utf8");
+  renameSync2(tmp, out);
 }
 function buildIncompleteReport(input, syncMode) {
   const vaultSource = input.vaultSource ?? "resolved";
@@ -2382,12 +2739,12 @@ async function runHealth(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename2, mkdir as mkdir7, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
-import { join as join17, dirname as dirname5 } from "path";
+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";
 
 // src/utils/delete-intent.ts
-import { mkdir as mkdir6, writeFile as writeFile4, readdir as readdir4, readFile as readFile6 } from "fs/promises";
-import { join as join16 } from "path";
+import { mkdir as mkdir5, writeFile as writeFile4, readdir as readdir3, readFile as readFile5 } from "fs/promises";
+import { join as join17 } from "path";
 var DELETE_INTENT_SCHEMA = "vault-delete-intent/v1";
 var DELETE_INTENT_DIR = "meta/delete-intents";
 function normalizeVaultRelPath(path) {
@@ -2418,10 +2775,10 @@ function buildDeleteIntent(input) {
   };
 }
 async function writeDeleteIntent(vault, intent) {
-  const dir = join16(vault, DELETE_INTENT_DIR);
-  await mkdir6(dir, { recursive: true });
+  const dir = join17(vault, DELETE_INTENT_DIR);
+  await mkdir5(dir, { recursive: true });
   const rel = `${DELETE_INTENT_DIR}/${pathToIntentFilename(intent.path)}`;
-  await writeFile4(join16(vault, rel), JSON.stringify(intent, null, 2) + "\n", "utf8");
+  await writeFile4(join17(vault, rel), JSON.stringify(intent, null, 2) + "\n", "utf8");
   return rel;
 }
 
@@ -2459,7 +2816,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 = join17("_archive", relPath).replace(/\\/g, "/");
+  const archivePath = join18("_archive", relPath).replace(/\\/g, "/");
   const remoteRoot = normalizeRemoteRoot(input.remote);
   const remoteObjectPath = buildRemoteObjectPath(remoteRoot, relPath);
   let cascade;
@@ -2485,7 +2842,7 @@ async function runArchive(input) {
     const indexRefs = [];
     if (!isRaw) {
       try {
-        const idx = await readFile7(join17(input.vault, "index.md"), "utf8");
+        const idx = await readFile6(join18(input.vault, "index.md"), "utf8");
         idx.split("\n").forEach((line, i) => {
           if (line.includes(`[[${slug}]]`)) indexRefs.push({ line: i + 1, text: line });
         });
@@ -2512,8 +2869,8 @@ async function runArchive(input) {
   }
   if (input.cascade && input.apply && cascade) {
     for (const ref of cascade.source_array_refs) {
-      const absPath = join17(input.vault, ref.page);
-      const text = await readFile7(absPath, "utf8");
+      const absPath = join18(input.vault, ref.page);
+      const text = await readFile6(absPath, "utf8");
       const split = splitFrontmatter(text);
       if (!split.ok) continue;
       const before = split.data.rawFrontmatter;
@@ -2530,12 +2887,12 @@ ${fmRewritten}
       }
     }
   }
-  await mkdir7(dirname5(join17(input.vault, archivePath)), { recursive: true });
-  await rename2(join17(input.vault, relPath), join17(input.vault, archivePath));
+  await mkdir6(dirname5(join18(input.vault, archivePath)), { recursive: true });
+  await rename2(join18(input.vault, relPath), join18(input.vault, archivePath));
   let indexUpdated = false;
   if (!isRaw) {
     const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-VNJ3TLEK.js");
-    const before = await readFile7(join17(input.vault, "index.md"), "utf8").catch(() => "");
+    const before = await readFile6(join18(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}]]`);
@@ -2586,7 +2943,7 @@ ${fmRewritten}
 
 // src/commands/remove.ts
 import { unlink as unlink2, access } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 async function pathExists(abs) {
   try {
     await access(abs);
@@ -2612,7 +2969,7 @@ async function runRemove(input) {
   if (!relPath) {
     try {
       const candidate = normalizeVaultRelPath(input.page);
-      if (await pathExists(join18(input.vault, candidate))) {
+      if (await pathExists(join19(input.vault, candidate))) {
         relPath = candidate;
       }
     } catch {
@@ -2641,12 +2998,12 @@ async function runRemove(input) {
     reason: input.reason
   });
   const tombstonePath = await writeDeleteIntent(input.vault, intent);
-  await unlink2(join18(input.vault, relPath));
+  await unlink2(join19(input.vault, relPath));
   if (relPath.endsWith(".md") && !relPath.startsWith("raw/")) {
-    const { readFile: readFile17 } = await import("fs/promises");
+    const { readFile: readFile16 } = await import("fs/promises");
     const { join: pathJoin } = await import("path");
     const { renderRootIndex: renderRootIndex2, writeRootIndexProjection: writeRootIndexProjection2 } = await import("./index-projection-VNJ3TLEK.js");
-    const before = await readFile17(pathJoin(input.vault, "index.md"), "utf8").catch(() => "");
+    const before = await readFile16(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}]]`);
@@ -2994,7 +3351,7 @@ ${migratedBody}${newFooter}`;
 
 // src/commands/update.ts
 import { execSync } from "child_process";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function parseCoreSemver(version) {
   const m = version.match(/^(\d+)\.(\d+)\.(\d+)/);
   if (!m) return null;
@@ -3025,7 +3382,7 @@ function resolveGlobalSkillsRoot() {
       encoding: "utf8",
       timeout: 5e3
     }).trim();
-    return join19(globalRoot, "skillwiki", "skills");
+    return join20(globalRoot, "skillwiki", "skills");
   } catch {
     return null;
   }
@@ -3053,7 +3410,7 @@ async function runUpdate(input) {
   const pkg2 = readCliPackageJson();
   const currentVersion = pkg2.version;
   const tag = normalizeDistTag(input.distTag);
-  const target = join19(input.home, ".claude", "skills");
+  const target = join20(input.home, ".claude", "skills");
   let latest;
   try {
     latest = execSync(`npm view skillwiki@${tag} version`, {
@@ -3133,22 +3490,22 @@ async function runUpdate(input) {
 
 // src/commands/self-update.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync10 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync12 } from "fs";
+import { join as join21 } 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 = join20(sourceRoot, "packages", "cli", "package.json");
-  const hasLocalSource = existsSync4(localPkgPath);
+  const localPkgPath = join21(sourceRoot, "packages", "cli", "package.json");
+  const hasLocalSource = existsSync6(localPkgPath);
   if (input.check) {
     let availableVersion = null;
     let source;
     if (hasLocalSource) {
       source = "local";
       try {
-        availableVersion = JSON.parse(readFileSync10(localPkgPath, "utf8")).version ?? null;
+        availableVersion = JSON.parse(readFileSync12(localPkgPath, "utf8")).version ?? null;
       } catch {
         availableVersion = null;
       }
@@ -3206,7 +3563,7 @@ async function runSelfUpdate(input) {
     }
     const newVersion = (() => {
       try {
-        return JSON.parse(readFileSync10(localPkgPath, "utf8")).version ?? "unknown";
+        return JSON.parse(readFileSync12(localPkgPath, "utf8")).version ?? "unknown";
       } catch {
         return "unknown";
       }
@@ -3272,21 +3629,21 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir5, stat as stat3, readFile as readFile9 } from "fs/promises";
-import { join as join21 } from "path";
+import { readdir as readdir4, stat as stat3, readFile as readFile8 } from "fs/promises";
+import { join as join22 } from "path";
 async function runTranscripts(input) {
-  const dir = join21(input.vault, "raw", "transcripts");
+  const dir = join22(input.vault, "raw", "transcripts");
   let entries;
   try {
-    entries = await readdir5(dir, { withFileTypes: true });
+    entries = await readdir4(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 = join21(dir, entry.name);
-    const content = await readFile9(filePath, "utf8");
+    const filePath = join22(dir, entry.name);
+    const content = await readFile8(filePath, "utf8");
     const fm = extractFrontmatter(content);
     if (!fm.ok) continue;
     const ingested = typeof fm.data.ingested === "string" ? fm.data.ingested : "";
@@ -3303,10 +3660,10 @@ async function runTranscripts(input) {
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile7, mkdir as mkdir8, readdir as readdir6, unlink as unlink3 } from "fs/promises";
-import { join as join22 } from "path";
-import { existsSync as existsSync5 } from "fs";
-import { readFile as readFile10 } from "fs/promises";
+import { writeFile as writeFile7, mkdir as mkdir7, readdir as readdir5, unlink as unlink3 } from "fs/promises";
+import { join as join23 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { readFile as readFile9 } 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,
@@ -3404,17 +3761,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join22(input.vault, "log.md");
+  const logPath = join23(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile10(logPath, "utf8");
+    logText = await readFile9(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 = join22(input.vault, "projects", input.project, "compound");
+  const compoundDir = join23(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -3422,8 +3779,8 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join22(compoundDir, `${slug}.md`);
-    if (existsSync5(compoundPath)) {
+    const compoundPath = join23(compoundDir, `${slug}.md`);
+    if (existsSync7(compoundPath)) {
       skipped.push(entry.date);
       continue;
     }
@@ -3461,8 +3818,8 @@ async function runCompound(input) {
     ].join("\n");
     const content = frontmatter + "\n" + body;
     if (!input.dryRun) {
-      if (!existsSync5(compoundDir)) {
-        await mkdir8(compoundDir, { recursive: true });
+      if (!existsSync7(compoundDir)) {
+        await mkdir7(compoundDir, { recursive: true });
       }
       await writeFile7(compoundPath, content, "utf8");
     }
@@ -3483,16 +3840,16 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join22(input.vault, "projects", input.project);
-  if (!existsSync5(projectDir)) {
+  const projectDir = join23(input.vault, "projects", input.project);
+  if (!existsSync7(projectDir)) {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
       result: err("PROJECT_NOT_FOUND", { slug: input.project, path: projectDir })
     };
   }
   const entryName = input.entry.replace(/\.md$/, "");
-  const compoundPath = join22(projectDir, "compound", `${entryName}.md`);
-  if (!existsSync5(compoundPath)) {
+  const compoundPath = join23(projectDir, "compound", `${entryName}.md`);
+  if (!existsSync7(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", { path: compoundPath })
@@ -3525,8 +3882,8 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join22(input.vault, "projects", input.project, "compound");
-  if (!existsSync5(compoundDir)) {
+  const compoundDir = join23(input.vault, "projects", input.project, "compound");
+  if (!existsSync7(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
       result: ok({
@@ -3540,7 +3897,7 @@ no compound directory found`
   }
   let dirents;
   try {
-    dirents = await readdir6(compoundDir, { withFileTypes: true });
+    dirents = await readdir5(compoundDir, { withFileTypes: true });
   } catch {
     return {
       exitCode: ExitCode.OK,
@@ -3556,10 +3913,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join22(compoundDir, dirent.name);
+    const filePath = join23(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile10(filePath, "utf8");
+      text = await readFile9(filePath, "utf8");
     } catch {
       continue;
     }
@@ -3588,8 +3945,8 @@ no compound entries found`;
 }
 
 // src/commands/session-brief.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile8 } from "fs/promises";
-import { join as join23, relative, sep } from "path";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile8 } from "fs/promises";
+import { join as join24, relative, sep } from "path";
 var MAX_WORDS = 900;
 async function runSessionBrief(input) {
   const scan = await scanVault(input.vault);
@@ -3689,7 +4046,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(join23(cwd, ".skillwiki", ".env"));
+  const projectDotenv = await readProjectSlug(join24(cwd, ".skillwiki", ".env"));
   if (projectDotenv) return projectDotenv;
   const inferred = inferProjectFromPath(input.vault, cwd);
   if (inferred) return inferred;
@@ -3698,7 +4055,7 @@ async function resolveProject(input) {
 async function readProjectSlug(file) {
   let text;
   try {
-    text = await readFile11(file, "utf8");
+    text = await readFile10(file, "utf8");
   } catch {
     return void 0;
   }
@@ -3775,7 +4132,7 @@ async function loadTrendDigests(typedPages) {
   return out;
 }
 async function loadSessionPins(vault, project) {
-  const text = await readIfExists(join23(vault, "meta", "session-pins.md"));
+  const text = await readIfExists(join24(vault, "meta", "session-pins.md"));
   if (!text) return [];
   const fm = extractFrontmatter(text);
   if (!fm.ok) return [];
@@ -3892,7 +4249,7 @@ function satelliteHealthWarnings(warning) {
   return warning ? [warning] : [];
 }
 async function loadHealthWarnings(vault) {
-  const text = await readIfExists(join23(vault, ".skillwiki", "health.json"));
+  const text = await readIfExists(join24(vault, ".skillwiki", "health.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -3905,7 +4262,7 @@ async function loadHealthWarnings(vault) {
   }
 }
 async function loadMemoryTopics(vault, project) {
-  const text = await readIfExists(join23(vault, ".skillwiki", "memory", project, "topics.json"));
+  const text = await readIfExists(join24(vault, ".skillwiki", "memory", project, "topics.json"));
   if (!text) return [];
   try {
     const parsed = JSON.parse(text);
@@ -3930,11 +4287,11 @@ async function loadMemoryTopics(vault, project) {
   }
 }
 async function writeBriefArtifacts(vault, input) {
-  const metaPath = join23(vault, "meta", "latest-session-brief.md");
-  const cacheMdPath = join23(vault, ".skillwiki", "session-brief.md");
-  const cacheJsonPath = join23(vault, ".skillwiki", "session-brief.json");
-  await mkdir9(join23(vault, "meta"), { recursive: true });
-  await mkdir9(join23(vault, ".skillwiki"), { recursive: true });
+  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 committed = renderCommittedBrief(input);
   const previousComparable = comparableBrief(await readIfExists(metaPath));
   const nextComparable = comparableBrief(committed);
@@ -4004,7 +4361,7 @@ function renderCommittedBrief(input) {
   ].filter((line) => line !== "").join("\n");
 }
 async function rebuildRootIndexProjection(vault) {
-  const before = await readIfExists(join23(vault, "index.md"));
+  const before = await readIfExists(join24(vault, "index.md"));
   if (!before) return false;
   const projection = await renderRootIndex({ vault, currentText: before });
   if (!projection.ok) return false;
@@ -4014,7 +4371,7 @@ async function rebuildRootIndexProjection(vault) {
 }
 async function readIfExists(path) {
   try {
-    return await readFile11(path, "utf8");
+    return await readFile10(path, "utf8");
   } catch {
     return "";
   }
@@ -4056,14 +4413,14 @@ function dateFromPath(path) {
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile13, open as open2, unlink as unlink4, mkdir as mkdir10 } from "fs/promises";
-import { join as join25 } from "path";
+import { readFile as readFile12, open, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
+import { join as join26 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/commands/page-publish.ts
 import { realpathSync } from "fs";
-import { readFile as readFile12 } from "fs/promises";
-import { join as join24, resolve as resolve3 } from "path";
+import { readFile as readFile11 } from "fs/promises";
+import { join as join25, resolve as resolve3 } from "path";
 var DEFAULT_DEPS = {
   afterStage: async () => void 0,
   preflight: (input) => runManagedWritePreflight(input)
@@ -4133,7 +4490,7 @@ function preparePagePublicationFromContent(input) {
 async function preparePagePublication(input) {
   let content;
   try {
-    content = await readFile12(input.draftPath, "utf8");
+    content = await readFile11(input.draftPath, "utf8");
   } catch (error) {
     return err("FILE_NOT_FOUND", { path: input.draftPath, message: String(error) });
   }
@@ -4204,10 +4561,10 @@ async function runLockedPrimaryStages(input, vault, deps) {
       ExitCode.VAULT_PATH_INVALID
     );
   }
-  const schemaPath = join24(vault, "SCHEMA.md");
+  const schemaPath = join25(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile12(schemaPath, "utf8");
+    schemaText = await readFile11(schemaPath, "utf8");
   } catch (error) {
     return lockedFailure("schema", state, err("WRITE_FAILED", { message: String(error) }));
   }
@@ -4237,8 +4594,8 @@ async function runLockedPrimaryStages(input, vault, deps) {
   let visibleSchema;
   try {
     [visible, visibleSchema] = await Promise.all([
-      readFile12(input.targetPath, "utf8"),
-      readFile12(schemaPath, "utf8")
+      readFile11(input.targetPath, "utf8"),
+      readFile11(schemaPath, "utf8")
     ]);
   } catch (error) {
     return lockedFailure("verify", state, err("WRITE_FAILED", { message: String(error) }));
@@ -4323,17 +4680,17 @@ function renderPublicationLog(input, added) {
 }
 async function readPageChanged(targetPath, content) {
   try {
-    return ok(await readFile12(targetPath, "utf8") !== content);
+    return ok(await readFile11(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 = join24(vault, "SCHEMA.md");
+  const schemaPath = join25(vault, "SCHEMA.md");
   let schemaText;
   try {
-    schemaText = await readFile12(schemaPath, "utf8");
+    schemaText = await readFile11(schemaPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: schemaPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4345,10 +4702,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 = join24(vault, "index.md");
+  const indexPath = join25(vault, "index.md");
   let indexText;
   try {
-    indexText = await readFile12(indexPath, "utf8");
+    indexText = await readFile11(indexPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: indexPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4359,10 +4716,10 @@ async function previewPreparedPagePublication(input, vault) {
     type: input.page.type
   });
   if (!index.ok) return { exitCode: errorExitCode(index.error), result: index };
-  const logPath = join24(vault, "log.md");
+  const logPath = join25(vault, "log.md");
   let logText;
   try {
-    logText = await readFile12(logPath, "utf8");
+    logText = await readFile11(logPath, "utf8");
   } catch (error) {
     const result = err("FILE_NOT_FOUND", { path: logPath, message: String(error) });
     return { exitCode: ExitCode.FILE_NOT_FOUND, result };
@@ -4624,7 +4981,7 @@ function buildTypedContent(title, ingested, type, tags, rawRelPath, provenance)
 }
 async function resolveRawCapture(input) {
   try {
-    const existing = await readFile13(input.path, "utf8");
+    const existing = await readFile12(input.path, "utf8");
     const frontmatter = extractFrontmatter(existing);
     if (!frontmatter.ok) {
       return err("INGEST_VALIDATION_FAILED", {
@@ -4682,7 +5039,7 @@ async function acquireRawCaptureLock(path) {
   const lockPath = `${path}.ingest.lock`;
   for (let attempt = 0; attempt < 200; attempt++) {
     try {
-      const handle = await open2(lockPath, "wx");
+      const handle = await open(lockPath, "wx");
       await handle.close();
       return ok(lockPath);
     } catch (error) {
@@ -4763,7 +5120,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile13(input.source, "utf8");
+      sourceContent = await readFile12(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -4788,7 +5145,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 = join25(input.vault, rawRelPath);
+  const rawAbsPath = join26(input.vault, rawRelPath);
   const identity = assessSourceIdentity({
     rawPath: rawRelPath,
     sourceUrl: sourceUrl ?? void 0,
@@ -4832,11 +5189,11 @@ async function runIngest(input) {
   );
   if (!input.dryRun) {
     try {
-      await mkdir10(join25(input.vault, typedDir), { recursive: true });
+      await mkdir9(join26(input.vault, typedDir), { recursive: true });
     } catch (error) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
-        result: err("WRITE_FAILED", { path: join25(input.vault, typedDir), message: String(error) })
+        result: err("WRITE_FAILED", { path: join26(input.vault, typedDir), message: String(error) })
       };
     }
   }
@@ -4883,11 +5240,11 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir10(join25(input.vault, "raw", "articles"), { recursive: true });
+    await mkdir9(join26(input.vault, "raw", "articles"), { recursive: true });
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
-      result: err("WRITE_FAILED", { path: join25(input.vault, "raw", "articles"), message: String(error) })
+      result: err("WRITE_FAILED", { path: join26(input.vault, "raw", "articles"), message: String(error) })
     };
   }
   const rawWrite = await writeResolvedRaw({
@@ -5115,8 +5472,8 @@ ${body}`;
 }
 
 // src/commands/tag-reconcile.ts
-import { readFile as readFile14 } from "fs/promises";
-import { join as join26, posix } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join27, posix } from "path";
 var TYPED_TARGET_RE = /^(entities|concepts|comparisons|queries|meta)\/[a-z0-9][a-z0-9./_-]*\.md$/;
 function errorExitCode2(error) {
   switch (error) {
@@ -5159,7 +5516,7 @@ function asTagArray(frontmatter, path) {
 async function readTagsFromFile(path) {
   let text;
   try {
-    text = await readFile14(path, "utf8");
+    text = await readFile13(path, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path }) };
@@ -5180,7 +5537,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 ? join26(input.vault, page) : void 0);
+  const source = input.from ?? (explicit.length === 0 ? join27(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 };
@@ -5191,7 +5548,7 @@ async function resolveRequestedTags(input, page) {
 }
 async function readSchema(schemaPath) {
   try {
-    return { exitCode: ExitCode.OK, result: ok(await readFile14(schemaPath, "utf8")) };
+    return { exitCode: ExitCode.OK, result: ok(await readFile13(schemaPath, "utf8")) };
   } catch (error) {
     if (error.code === "ENOENT") {
       return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: schemaPath }) };
@@ -5219,7 +5576,7 @@ function previewResult(page, tags, reconciled, dryRun, filesChanged) {
   };
 }
 async function reconcileTagsWhileLocked(input, page, tags, comment) {
-  const schemaPath = join26(input.vault, "SCHEMA.md");
+  const schemaPath = join27(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 });
@@ -5230,7 +5587,7 @@ async function reconcileTagsWhileLocked(input, page, tags, comment) {
   }
   let verifiedText;
   try {
-    verifiedText = await readFile14(schemaPath, "utf8");
+    verifiedText = await readFile13(schemaPath, "utf8");
   } catch (error) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -5256,7 +5613,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(join26(input.vault, "SCHEMA.md"));
+    const schema = await readSchema(join27(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, []);
@@ -5308,8 +5665,8 @@ async function runTagReconcile(input) {
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join28 } from "path";
 import { execFileSync as execFileSync3 } from "child_process";
 
 // src/utils/vault-git-pathspec.ts
@@ -5363,7 +5720,7 @@ function refHasPath(vault, ref, path) {
 function runSyncStatus(input) {
   const vault = input.vault;
   const includeStashes = input.includeStashes ?? false;
-  if (!existsSync6(join27(vault, ".git"))) {
+  if (!existsSync8(join28(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -5470,7 +5827,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync6(join27(vault, ".git"))) {
+  if (!existsSync8(join28(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5630,7 +5987,7 @@ function enableGitLongPathsOnWindows(vault) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync6(join27(vault, ".git"))) {
+  if (!existsSync8(join28(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5745,7 +6102,7 @@ function runSyncPeers(input) {
 }
 function runSyncLock(input) {
   const vault = input.vault;
-  if (!existsSync6(vault)) {
+  if (!existsSync8(vault)) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: vault })
@@ -5780,7 +6137,7 @@ function runSyncLock(input) {
 }
 function runSyncUnlock(input) {
   const vault = input.vault;
-  if (!existsSync6(vault)) {
+  if (!existsSync8(vault)) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: vault })
@@ -5857,8 +6214,8 @@ function runSyncJournalClearStale(input) {
 }
 
 // src/commands/backup.ts
-import { statSync as statSync2, readdirSync, readFileSync as readFileSync11, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join28, relative as relative2, dirname as dirname6 } from "path";
+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 { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -5880,9 +6237,9 @@ function createS3Client(config) {
 // src/commands/backup.ts
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_modules", ".skillwiki"]);
 function* walkMarkdown(dir, base) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join28(dir, entry.name);
+    const full = join29(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -5905,7 +6262,7 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join28(input.vault, relPath);
+    const absPath = join29(input.vault, relPath);
     const localStat = statSync2(absPath);
     let needsUpload = true;
     try {
@@ -5924,7 +6281,7 @@ async function runBackupSync(input) {
       continue;
     }
     try {
-      const body = readFileSync11(absPath);
+      const body = readFileSync13(absPath);
       await client.send(new PutObjectCommand({ Bucket: input.bucket, Key: relPath, Body: body }));
       uploaded++;
     } catch {
@@ -5981,7 +6338,7 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join28(target, obj.Key);
+      const localPath = join29(target, obj.Key);
       try {
         const localStat = statSync2(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
@@ -5994,8 +6351,8 @@ async function runBackupRestore(input) {
         const resp = await client.send(new GetObjectCommand({ Bucket: input.bucket, Key: obj.Key }));
         const body = await resp.Body?.transformToByteArray();
         if (body) {
-          mkdirSync2(dirname6(localPath), { recursive: true });
-          writeFileSync4(localPath, Buffer.from(body));
+          mkdirSync3(dirname6(localPath), { recursive: true });
+          writeFileSync5(localPath, Buffer.from(body));
           downloaded++;
         }
       } catch {
@@ -6027,11 +6384,11 @@ async function runBackupRestore(input) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync7, statSync as statSync3 } from "fs";
-import { readFile as readFile15 } from "fs/promises";
-import { join as join29 } from "path";
+import { existsSync as existsSync9, statSync as statSync3 } from "fs";
+import { readFile as readFile14 } from "fs/promises";
+import { join as join30 } from "path";
 async function runStatus(input) {
-  if (!existsSync7(input.vault)) {
+  if (!existsSync9(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
   const scan = await scanVault(input.vault);
@@ -6056,7 +6413,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile15(join29(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile14(join30(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -6116,8 +6473,8 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir11, writeFile as writeFile9, stat as stat4 } from "fs/promises";
-import { join as join30 } from "path";
+import { mkdir as mkdir10, writeFile as writeFile9, stat as stat4 } from "fs/promises";
+import { join as join31 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -6186,29 +6543,29 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat4(join30(input.vault, "SCHEMA.md"));
+    await stat4(join31(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 = join30(input.vault, relPath);
+    const absPath = join31(input.vault, relPath);
     try {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir11(join30(absPath, ".."), { recursive: true });
+      await mkdir10(join31(absPath, ".."), { recursive: true });
       await writeFile9(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join30(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join31(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir11(join30(rawPath, ".."), { recursive: true });
+    await mkdir10(join31(rawPath, ".."), { recursive: true });
     await writeFile9(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
@@ -6231,9 +6588,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile16, writeFile as writeFile10 } from "fs/promises";
-import { existsSync as existsSync8 } from "fs";
-import { join as join31 } from "path";
+import { readFile as readFile15, writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync10 } from "fs";
+import { join as join32 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -6311,8 +6668,8 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join31(input.vault, ".skillwiki", "graph.json");
-  if (!existsSync8(graphPath)) {
+  const graphPath = input.graphPath ?? join32(input.vault, ".skillwiki", "graph.json");
+  if (!existsSync10(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", {
@@ -6323,7 +6680,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile16(graphPath, "utf8");
+    raw = await readFile15(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -6349,7 +6706,7 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join31(input.vault, "vault-graph.canvas");
+  const outPath = join32(input.vault, "vault-graph.canvas");
   try {
     await writeFile10(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
@@ -6371,10 +6728,10 @@ written: ${outPath}`
 }
 
 // src/commands/fleet-health.ts
-import { existsSync as existsSync9, readFileSync as readFileSync12 } from "fs";
+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 join32 } from "path";
+import { join as join33 } from "path";
 var SSH_TIMEOUT_MS = 15e3;
 var TIMER_UNIT = "agent-memory-trends.timer";
 var SERVICE_UNIT = "agent-memory-trends.service";
@@ -6471,9 +6828,9 @@ function applyServiceFailedOverlay(run, serviceFailed) {
 function probeLocal(vaultPath, deps) {
   const latestPath = satelliteLatestRunPath(vaultPath);
   let parsed = null;
-  if (existsSync9(latestPath)) {
+  if (existsSync11(latestPath)) {
     try {
-      const wire = readSatelliteLatestRunFromText(readFileSync12(latestPath, "utf8"));
+      const wire = readSatelliteLatestRunFromText(readFileSync14(latestPath, "utf8"));
       if (wire) {
         parsed = {
           status: wire.status,
@@ -6604,7 +6961,7 @@ async function runFleetHealth(input) {
   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 ? join32(vault, FLEET_REL_PATH) : void 0);
+  const file = input.file ?? (vault ? join33(vault, FLEET_REL_PATH) : void 0);
   if (!file) {
     return {
       exitCode: ExitCode.NO_VAULT_CONFIGURED,
@@ -6688,15 +7045,15 @@ async function runFleetHealth(input) {
 }
 
 // src/utils/auto-commit.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join33 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join34 } 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 (!existsSync10(join33(vault, ".git"))) return;
+  if (!existsSync12(join34(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain", "--", ...VAULT_COMMIT_PATHSPEC]);
@@ -6758,7 +7115,7 @@ async function emitManagedVaultWrite(vault, command, mutate, opts) {
   if (guard.blocked) {
     return emit({ exitCode: guard.exitCode, result: guard.result }, void 0, { postCommit: false });
   }
-  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-57DQZI2N.js");
+  const { runManagedWriteTransaction: runManagedWriteTransaction2 } = await import("./managed-write-preflight-7TWSEZJZ.js");
   const run = await runManagedWriteTransaction2({
     vault,
     command,
@@ -6783,7 +7140,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 ?? join34(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join35(vault, ".skillwiki", "graph.json");
   return emitGuardedVaultWrite(vault, "graph build", () => runGraphBuild({ vault, out }));
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -6814,18 +7171,25 @@ program.command("install").description("install skillwiki SKILL.md files into ~/
   const skillsRoot = opts.skillsRoot ?? new URL("../skills/", import.meta.url).pathname;
   emit(await runInstall({ skillsRoot, target: opts.target, dryRun: !!opts.dryRun, symlink: !!opts.symlink, home: process.env.HOME ?? "", force: !!opts.force }));
 });
-program.command("path").description("show the resolved vault path").option("--vault <dir>", "explicit vault override (runtime)").option("--target <dir>", "explicit target override (init-time)").option("--wiki <name>", "wiki profile name").option("--init-time", "use init-time chain instead of runtime", false).option("--explain", "include resolution chain in output", false).action(async (opts) => {
+program.command("path").description("show the resolved vault path").option("--vault <dir>", "explicit vault override (runtime)").option("--target <dir>", "explicit target override (init-time)").option("--wiki <name>", "wiki profile name").option("--init-time", "use init-time chain instead of runtime", false).option("--explain", "include resolution chain in output", false).option("--plain", "print only the vault path (no JSON wrapper)", false).action(async (opts) => {
   const initTime = !!opts.initTime;
   const flag = initTime ? opts.target : opts.vault;
-  emit(await runPath({
+  const r = await runPath({
     flag,
     envValue: process.env.WIKI_PATH,
     home: process.env.HOME ?? "",
     initTime,
     wiki: opts.wiki,
     cwd: process.cwd(),
-    explain: !!opts.explain
-  }));
+    explain: !!opts.explain,
+    plain: !!opts.plain
+  });
+  if (opts.plain && r.result.ok) {
+    process.stdout.write(`${r.result.data.path}
+`);
+    process.exit(r.exitCode);
+  }
+  emit(r);
 });
 program.command("lang").description("get or set the vault language").option("--lang <code>", "explicit language override").option("--explain", "include resolution chain in output", false).action(async (opts) => {
   emit(await runLang({
@@ -6971,15 +7335,44 @@ program.command("log-rotate [vault]").description("rotate or trim the vault log
   );
   else emit(await runLogRotate({ vault: v.vault, threshold: opts.threshold, apply: false }), v.vault);
 });
-program.command("log-append [vault]").description("append a single entry to the vault log under a short advisory lock").requiredOption("--content <text>", "log entry text to append").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("log-append [vault]").description("append a single entry to the vault log under a short advisory lock").requiredOption("--content <text>", "log entry text to append").option("--operation-id <id>", "stable SHA-256 operation id for retry-safe append + immutable event").option("--write-event", "also write meta/log-events (requires --operation-id)", false).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 return emitManagedVaultWrite(
     v.vault,
     "log-append",
-    () => runLogAppend({ vault: v.vault, content: opts.content })
+    () => runLogAppend({
+      vault: v.vault,
+      content: opts.content,
+      operationId: opts.operationId,
+      writeEvent: !!opts.writeEvent || !!opts.operationId
+    })
+  );
+});
+program.command("work-complete [vault]").description("atomically complete a work item (validate, evidence, log, projection, commit)").requiredOption("--work-item <path>", "work item directory relative to vault (e.g. projects/x/work/yyyy-mm-dd-slug)").option("--operation-id <id>", "stable SHA-256 operation id (derived when omitted)").option("--no-commit", "skip git commit").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 return emitManagedVaultWrite(
+    v.vault,
+    "work-complete",
+    () => runWorkComplete({
+      vault: v.vault,
+      workItem: opts.workItem,
+      operationId: opts.operationId,
+      noCommit: opts.commit === false
+    }),
+    { postCommit: false }
   );
 });
+program.command("work-validate [vault]").description("cross-check a work item for status, evidence, PR metadata, unchecked steps, and conflict markers").requiredOption("--work-item <path>", "work item directory relative to vault").option("--require-complete", "require completed status and evidence", false).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 emit(await runWorkValidate({
+    vault: v.vault,
+    workItem: opts.workItem,
+    requireComplete: !!opts.requireComplete
+  }), v.vault, { postCommit: false });
+});
 var logCmd = program.command("log").description("immutable log events and projections");
 logCmd.command("materialize [vault]").description("preview or write root log.md from immutable events").option("--write", "write projected log.md", false).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
   const v = await resolveVaultArg(vault, opts.wiki);