skillwiki 0.2.0-beta.7 → 0.2.0

package/dist/cli.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  semverGt
+} from "./chunk-XM5IYZX7.js";
 
 // src/cli.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { Command } from "commander";
 
 // src/utils/output.ts
@@ -63,7 +66,14 @@ var ExitCode = {
   INVALID_CONFIG_KEY: 26,
   CONFIG_WRITE_FAILED: 27,
   DOCTOR_HAS_WARNINGS: 28,
-  DOCTOR_HAS_ERRORS: 29
+  DOCTOR_HAS_ERRORS: 29,
+  ARCHIVE_TARGET_NOT_FOUND: 30,
+  ARCHIVE_ALREADY_ARCHIVED: 31,
+  DRIFT_DETECTED: 32,
+  RAW_DEDUP_DETECTED: 33,
+  MIGRATION_APPLIED: 34,
+  UNKNOWN_WIKI_PROFILE: 35,
+  DEDUP_APPLIED: 36
 };
 
 // ../shared/src/json-output.ts
@@ -103,10 +113,10 @@ var TypedKnowledgeSchema = z.object({
 });
 var sha256Hex = z.string().regex(/^[0-9a-f]{64}$/);
 var RawSourceSchema = z.object({
-  title: z.string().min(1),
-  source_url: z.string().url().nullable(),
+  title: z.string().min(1).optional(),
+  source_url: z.string().nullable(),
   ingested: isoDate,
-  ingested_by: z.enum(["wiki-ingest", "proj-work", "manual"]),
+  ingested_by: z.enum(["wiki-ingest", "proj-work", "manual"]).optional(),
   sha256: sha256Hex,
   project: wikilink.optional(),
   work_item: wikilink.optional(),
@@ -241,7 +251,7 @@ async function runHash(input) {
   const sha256 = createHash("sha256").update(bodyBytes).digest("hex");
   return {
     exitCode: ExitCode.OK,
-    result: ok({ path: input.file, sha256, byte_count: bodyBytes.byteLength })
+    result: ok({ path: input.file, sha256, byte_count: bodyBytes.byteLength, humanHint: sha256 })
   };
 }
 
@@ -271,7 +281,7 @@ function runFetchGuardSync(input) {
       result: err("HOST_BLOCKED", { sanitized_url: sanitized, host: u.hostname })
     };
   }
-  return { exitCode: ExitCode.OK, result: ok({ allowed: true, sanitized_url: sanitized }) };
+  return { exitCode: ExitCode.OK, result: ok({ allowed: true, sanitized_url: sanitized, humanHint: `ALLOWED: ${sanitized}` }) };
 }
 function sanitizeUrl(u) {
   const clone = new URL(u.toString());
@@ -311,17 +321,18 @@ async function runValidate(input) {
   }
   const det = detectSchema(fm.data);
   if (!det.schema) {
-    return { exitCode: ExitCode.SCHEMA_NOT_DETECTED, result: ok({ schema: null, valid: false, errors: [] }) };
+    return { exitCode: ExitCode.SCHEMA_NOT_DETECTED, result: ok({ schema: null, valid: false, errors: [], humanHint: "schema not detected" }) };
   }
   const parsed = SCHEMAS[det.schema].safeParse(fm.data);
   if (!parsed.success) {
     const errors = parsed.error.issues.map((i) => ({ path: i.path.join("."), message: i.message }));
     return {
       exitCode: ExitCode.INVALID_FRONTMATTER,
-      result: ok({ schema: det.schema, valid: false, errors })
+      result: ok({ schema: det.schema, valid: false, errors, humanHint: `INVALID (${det.schema})
+${errors.map((e) => `  ${e.path}: ${e.message}`).join("\n")}` })
     };
   }
-  return { exitCode: ExitCode.OK, result: ok({ schema: det.schema, valid: true, errors: [] }) };
+  return { exitCode: ExitCode.OK, result: ok({ schema: det.schema, valid: true, errors: [], humanHint: `VALID (${det.schema})` }) };
 }
 
 // src/commands/graph.ts
@@ -407,7 +418,8 @@ async function runGraphBuild(input) {
   }
   return {
     exitCode: ExitCode.OK,
-    result: ok({ out_path: input.out, node_count: scan.data.typedKnowledge.length, edge_count })
+    result: ok({ out_path: input.out, node_count: scan.data.typedKnowledge.length, edge_count, humanHint: `nodes: ${scan.data.typedKnowledge.length}, edges: ${edge_count}
+written: ${input.out}` })
   };
 }
 function computeAdamicAdar(adj) {
@@ -482,7 +494,8 @@ async function runOverlap(input) {
       }
     return { id, members, score };
   });
-  return { exitCode: ExitCode.OK, result: ok({ clusters }) };
+  const humanHint = clusters.length === 0 ? "no overlap clusters found" : clusters.map((c) => `cluster (${c.members.length} pages, score ${c.score}): ${c.members.join(", ")}`).join("\n");
+  return { exitCode: ExitCode.OK, result: ok({ clusters, humanHint }) };
 }
 
 // src/utils/wiki-path.ts
@@ -493,6 +506,16 @@ import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2 } from
 import { dirname as dirname2 } from "path";
 var CONFIG_KEYS = ["WIKI_PATH", "WIKI_LANG"];
 var _whitelist = new Set(CONFIG_KEYS);
+var PROFILE_PATH_RE = /^WIKI_([A-Z][A-Z0-9_]{0,31})_PATH$/;
+var PROFILE_LANG_RE = /^WIKI_([A-Z][A-Z0-9_]{0,31})_LANG$/;
+var PROFILE_DEFAULT_RE = /^WIKI_DEFAULT$/;
+function isValidWikiProfileKey(key) {
+  if (key === "WIKI_PATH" || key === "WIKI_LANG") return false;
+  return PROFILE_PATH_RE.test(key) || PROFILE_LANG_RE.test(key) || PROFILE_DEFAULT_RE.test(key);
+}
+function profileKey(name, suffix) {
+  return `WIKI_${name.toUpperCase().replace(/-/g, "_").replace(/[^A-Z0-9_]/g, "")}_${suffix}`;
+}
 function parseDotenvText(text) {
   const out = {};
   for (const rawLine of text.split(/\r?\n/)) {
@@ -502,7 +525,7 @@ function parseDotenvText(text) {
     if (eq <= 0) continue;
     const key = line.slice(0, eq).trim();
     const value = line.slice(eq + 1).trim();
-    if (!_whitelist.has(key)) continue;
+    if (!_whitelist.has(key) && !isValidWikiProfileKey(key)) continue;
     if (value.length === 0) continue;
     out[key] = value;
   }
@@ -587,6 +610,14 @@ async function resolveInitTimePath(input) {
     return { path: hermes.WIKI_PATH, source: "hermes-dotenv", ...input.explain ? { chain } : {} };
   }
   if (input.explain) chain.push({ source: "hermes-dotenv", matched: false });
+  if (input.cwd) {
+    const projCfg = await parseDotenvFile(join2(input.cwd, ".skillwiki", ".env"));
+    if (projCfg.WIKI_PATH !== void 0) {
+      if (input.explain) chain.push({ source: "project-dotenv", matched: true, value: projCfg.WIKI_PATH });
+      return { path: projCfg.WIKI_PATH, source: "project-dotenv", ...input.explain ? { chain } : {} };
+    }
+  }
+  if (input.explain) chain.push({ source: "project-dotenv", matched: false });
   const fallback = join2(input.home, "wiki");
   if (input.explain) chain.push({ source: "default", matched: true, value: fallback });
   return { path: fallback, source: "default", ...input.explain ? { chain } : {} };
@@ -598,15 +629,73 @@ async function resolveRuntimePath(input) {
     return ok({ path: input.flag, source: "flag", ...input.explain ? { chain } : {} });
   }
   if (input.explain) chain.push({ source: "flag", matched: false });
+  const swGlobal = await parseDotenvFile(join2(input.home, ".skillwiki", ".env"));
+  const wikiName = input.wiki;
+  if (wikiName !== void 0 && wikiName.length > 0) {
+    if (wikiName.toLowerCase() === "default") {
+      const path2 = swGlobal.WIKI_PATH;
+      if (path2 !== void 0) {
+        if (input.explain) chain.push({ source: "wiki-profile", matched: true, value: path2 });
+        return ok({ path: path2, source: "skillwiki-dotenv", ...input.explain ? { chain } : {} });
+      }
+      if (input.explain) chain.push({ source: "wiki-profile", matched: false });
+      return err("UNKNOWN_WIKI_PROFILE", {
+        message: `Wiki profile "default" not found. Set it with: skillwiki config set wiki.path <dir>`
+      });
+    }
+    const key = profileKey(wikiName, "PATH");
+    const path = swGlobal[key];
+    if (path !== void 0) {
+      if (input.explain) chain.push({ source: "wiki-profile", matched: true, value: path });
+      return ok({ path, source: "wiki-profile", ...input.explain ? { chain } : {} });
+    }
+    if (input.explain) chain.push({ source: "wiki-profile", matched: false });
+    return err("UNKNOWN_WIKI_PROFILE", {
+      message: `Wiki profile "${wikiName}" not found. Set it with: skillwiki config set wiki.${wikiName}.path <dir>`
+    });
+  }
+  if (input.wikiEnv !== void 0 && input.wikiEnv.length > 0) {
+    const key = profileKey(input.wikiEnv, "PATH");
+    const path = swGlobal[key];
+    if (path !== void 0) {
+      if (input.explain) chain.push({ source: "wiki-profile", matched: true, value: path });
+      return ok({ path, source: "wiki-profile", ...input.explain ? { chain } : {} });
+    }
+    if (input.explain) chain.push({ source: "wiki-profile", matched: false });
+    return err("UNKNOWN_WIKI_PROFILE", {
+      message: `Wiki profile "${input.wikiEnv}" not found (from $WIKI env). Set it with: skillwiki config set wiki.${input.wikiEnv}.path <dir>`
+    });
+  }
+  if (input.explain) chain.push({ source: "wiki-profile", matched: false });
   if (input.envValue !== void 0 && input.envValue.length > 0) {
     if (input.explain) chain.push({ source: "env", matched: true, value: input.envValue });
     return ok({ path: input.envValue, source: "env", ...input.explain ? { chain } : {} });
   }
   if (input.explain) chain.push({ source: "env", matched: false });
-  const sw = await parseDotenvFile(join2(input.home, ".skillwiki", ".env"));
-  if (sw.WIKI_PATH !== void 0) {
-    if (input.explain) chain.push({ source: "skillwiki-dotenv", matched: true, value: sw.WIKI_PATH });
-    return ok({ path: sw.WIKI_PATH, source: "skillwiki-dotenv", ...input.explain ? { chain } : {} });
+  if (input.cwd) {
+    const projCfg = await parseDotenvFile(join2(input.cwd, ".skillwiki", ".env"));
+    if (projCfg.WIKI_PATH !== void 0) {
+      if (input.explain) chain.push({ source: "project-dotenv", matched: true, value: projCfg.WIKI_PATH });
+      return ok({ path: projCfg.WIKI_PATH, source: "project-dotenv", ...input.explain ? { chain } : {} });
+    }
+    if (input.explain) chain.push({ source: "project-dotenv", matched: false });
+  }
+  const defaultProfile = swGlobal["WIKI_DEFAULT"];
+  if (defaultProfile !== void 0) {
+    const key = profileKey(defaultProfile, "PATH");
+    const path = swGlobal[key];
+    if (path !== void 0) {
+      if (input.explain) chain.push({ source: "wiki-default", matched: true, value: path });
+      return ok({ path, source: "wiki-default", ...input.explain ? { chain } : {} });
+    }
+    if (input.explain) chain.push({ source: "wiki-default", matched: false });
+    return err("UNKNOWN_WIKI_PROFILE", {
+      message: `Default wiki profile "${defaultProfile}" not found. Set it with: skillwiki config set wiki.${defaultProfile}.path <dir>`
+    });
+  }
+  if (swGlobal.WIKI_PATH !== void 0) {
+    if (input.explain) chain.push({ source: "skillwiki-dotenv", matched: true, value: swGlobal.WIKI_PATH });
+    return ok({ path: swGlobal.WIKI_PATH, source: "skillwiki-dotenv", ...input.explain ? { chain } : {} });
   }
   if (input.explain) chain.push({ source: "skillwiki-dotenv", matched: false });
   return err("NO_VAULT_CONFIGURED", {
@@ -620,15 +709,21 @@ async function runOrphans(input) {
   if (input.vault) {
     vault = input.vault;
   } else {
-    const r = await resolveRuntimePath({ flag: void 0, envValue: input.envValue, home: input.home ?? "" });
-    if (!r.ok) return { exitCode: ExitCode.NO_VAULT_CONFIGURED, result: r };
+    const r = await resolveRuntimePath({ flag: void 0, envValue: input.envValue, home: input.home ?? "", wiki: input.wiki });
+    if (!r.ok) {
+      const exitCode = r.error === "UNKNOWN_WIKI_PROFILE" ? ExitCode.UNKNOWN_WIKI_PROFILE : ExitCode.NO_VAULT_CONFIGURED;
+      return { exitCode, result: r };
+    }
     vault = r.data.path;
   }
   const scan = await scanVault(vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
   const slugToPath = {};
   for (const p of scan.data.typedKnowledge) {
-    slugToPath[p.relPath.replace(/\.md$/, "").split("/").pop()] = p.relPath;
+    const rel = p.relPath.replace(/\.md$/, "");
+    slugToPath[rel] = p.relPath;
+    const filename = rel.split("/").pop();
+    if (!(filename in slugToPath)) slugToPath[filename] = p.relPath;
   }
   const adj = {};
   for (const p of scan.data.typedKnowledge) adj[p.relPath] = /* @__PURE__ */ new Set();
@@ -637,7 +732,7 @@ async function runOrphans(input) {
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     for (const slug of extractBodyWikilinks(body)) {
-      const tgt = slugToPath[slug.split("/").pop()];
+      const tgt = slugToPath[slug] ?? slugToPath[slug.split("/").pop()];
       if (tgt) {
         adj[p.relPath].add(tgt);
         adj[tgt].add(p.relPath);
@@ -668,7 +763,11 @@ async function runOrphans(input) {
       }
     }
   }
-  return { exitCode: ExitCode.OK, result: ok({ orphans, bridges }) };
+  const hintLines = [];
+  if (orphans.length > 0) hintLines.push(`orphans: ${orphans.length}`, ...orphans.map((o) => `  ${o}`));
+  if (bridges.length > 0) hintLines.push(`bridges: ${bridges.length}`, ...bridges.map((b) => `  ${b.path}`));
+  if (hintLines.length === 0) hintLines.push("no orphans or bridges");
+  return { exitCode: ExitCode.OK, result: ok({ orphans, bridges, humanHint: hintLines.join("\n") }) };
 }
 function simulateRemoval(adj, removed) {
   const seen = /* @__PURE__ */ new Set();
@@ -693,16 +792,92 @@ import { dirname as dirname3, resolve, join as join3 } from "path";
 
 // src/parsers/citations.ts
 var FENCE2 = /```[\s\S]*?```/g;
+var INLINE_CODE = /`[^`\n]+`/g;
+var MARKER_RE = /\^\[(raw\/[^\]]+)\]/g;
+function stripFences(body) {
+  return body.replace(FENCE2, "").replace(INLINE_CODE, "");
+}
+function stripFencedBlocks(body) {
+  return body.replace(FENCE2, "");
+}
 function extractCitationMarkers(body) {
-  const stripped = body.replace(FENCE2, "");
+  const stripped = stripFences(body);
   const out = [];
-  const re = /\^\[(raw\/[^\]]+)\]/g;
   let m;
-  while ((m = re.exec(stripped)) !== null) {
+  while ((m = MARKER_RE.exec(stripped)) !== null) {
     out.push({ marker: m[0], target: m[1] });
   }
   return out;
 }
+function hasSourcesFooter(body) {
+  return /^## Sources\s*$/m.test(stripFencedBlocks(body));
+}
+function isLegacyCitationStyle(body) {
+  const markers = extractCitationMarkers(body);
+  if (markers.length === 0) return false;
+  if (!hasSourcesFooter(body)) return true;
+  const lines = stripFences(body).split("\n");
+  let inSources = false;
+  for (const line of lines) {
+    if (/^## Sources\b/.test(line.trim())) {
+      inSources = true;
+      continue;
+    }
+    if (inSources) continue;
+    const markerOnly = line.replace(MARKER_RE, "").trim();
+    if (markerOnly.length === 0 && /\^\[raw\//.test(line)) return true;
+    const lastMarkerIdx = line.lastIndexOf("^[raw/");
+    if (lastMarkerIdx >= 0) {
+      const afterLast = line.slice(lastMarkerIdx).replace(MARKER_RE, "").trim();
+      if (afterLast.length > 0) return true;
+      const beforeFirst = line.slice(0, line.indexOf("^[raw/")).trim();
+      if (beforeFirst.length > 0 && !/[.!?]\s*$/.test(beforeFirst)) return true;
+    }
+  }
+  return false;
+}
+function hasOrphanedCitations(body) {
+  const stripped = stripFences(body);
+  const lines = stripped.split("\n");
+  let inSources = false;
+  let sourcesEnded = false;
+  let sourcesStartLine = -1;
+  let lastNonBlankInSources = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (/^## Sources\b/.test(trimmed)) {
+      inSources = true;
+      sourcesStartLine = i;
+      continue;
+    }
+    if (!inSources || sourcesEnded) continue;
+    if (trimmed.length === 0) {
+      if (lastNonBlankInSources >= 0) {
+        sourcesEnded = true;
+      }
+      continue;
+    }
+    const isListItem = /^\s*[-*]\s+/.test(line);
+    const hasMarker = /\^\[raw\//.test(line);
+    if (isListItem && hasMarker) {
+      lastNonBlankInSources = i;
+    } else if (hasMarker && !isListItem) {
+      return true;
+    } else {
+      sourcesEnded = true;
+    }
+  }
+  if (sourcesStartLine === -1) return false;
+  if (sourcesEnded) {
+    for (let i = lastNonBlankInSources + 1; i < lines.length; i++) {
+      if (/\^\[raw\//.test(lines[i])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 
 // src/commands/audit.ts
 async function runAudit(input) {
@@ -727,17 +902,40 @@ async function runAudit(input) {
       return { ...m, resolved: false };
     }
   }));
-  const sources = fm.data.sources ?? [];
+  const sources = (fm.data.sources ?? []).map((s) => s.replace(/^\^\[/, "").replace(/\]$/, ""));
   const referenced = new Set(resolved.map((m) => m.target));
   const unused_sources = sources.filter((s) => !referenced.has(s));
   const missing_from_sources = [...referenced].filter((t) => !sources.includes(t));
+  const broken = resolved.filter((m) => !m.resolved);
+  const footerMatch = body.match(/\n## Sources\n([\s\S]*)$/);
+  let footer_consistency;
+  if (footerMatch) {
+    const footerTargets = /* @__PURE__ */ new Set();
+    const footerRe = /\^\[(raw\/[^\]]+)\]/g;
+    let mm;
+    while ((mm = footerRe.exec(footerMatch[1])) !== null) footerTargets.add(mm[1]);
+    const bodyTargets = new Set(resolved.map((m) => m.target));
+    const missing_from_footer = [...bodyTargets].filter((t) => !footerTargets.has(t));
+    const extra_in_footer = [...footerTargets].filter((t) => !bodyTargets.has(t));
+    footer_consistency = { missing_from_footer, extra_in_footer };
+  }
+  const hintLines = [];
+  hintLines.push(`markers: ${resolved.length}, broken: ${broken.length}`);
+  if (unused_sources.length > 0) hintLines.push(`unused_sources: ${unused_sources.length}`);
+  if (missing_from_sources.length > 0) hintLines.push(`missing_from_sources: ${missing_from_sources.length}`);
+  if (footer_consistency) {
+    if (footer_consistency.missing_from_footer.length > 0) hintLines.push(`missing_from_footer: ${footer_consistency.missing_from_footer.length}`);
+    if (footer_consistency.extra_in_footer.length > 0) hintLines.push(`extra_in_footer: ${footer_consistency.extra_in_footer.length}`);
+  }
+  if (broken.length === 0 && unused_sources.length === 0 && missing_from_sources.length === 0) hintLines.push("OK");
+  const humanHint = hintLines.join("\n");
   if (resolved.some((m) => !m.resolved)) {
-    return { exitCode: ExitCode.UNRESOLVED_MARKERS, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources } }) };
+    return { exitCode: ExitCode.UNRESOLVED_MARKERS, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources }, footer_consistency, humanHint }) };
   }
   if (unused_sources.length > 0 || missing_from_sources.length > 0) {
-    return { exitCode: ExitCode.SOURCES_INCONSISTENT, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources } }) };
+    return { exitCode: ExitCode.SOURCES_INCONSISTENT, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources }, footer_consistency, humanHint }) };
   }
-  return { exitCode: ExitCode.OK, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources } }) };
+  return { exitCode: ExitCode.OK, result: ok({ markers: resolved, sources_consistency: { unused_sources, missing_from_sources }, footer_consistency, humanHint }) };
 }
 async function findVaultRoot(start) {
   let cur = start;
@@ -815,9 +1013,28 @@ async function runInstall(input) {
     installed.push(dst);
     if (r.data.backupPath) backed_up.push(r.data.backupPath);
   }
+  const binSrc = join4(input.skillsRoot, "bin", "skillwiki");
+  try {
+    await stat4(binSrc);
+    const binDst = join4(input.target, "bin", "skillwiki");
+    if (!input.dryRun) {
+      const r = await atomicCopyWithBackup(binSrc, binDst);
+      if (!r.ok) return { exitCode: ExitCode.ATOMIC_COPY_FAILED, result: r };
+      installed.push(binDst);
+      if (r.data.backupPath) backed_up.push(r.data.backupPath);
+    } else {
+      installed.push(binDst);
+    }
+  } catch {
+  }
   const manifest_path = join4(input.target, "wiki-manifest.json");
   if (!input.dryRun) await writeManifest(manifest_path, { installed, backed_up });
-  return { exitCode: ExitCode.OK, result: ok({ installed, backed_up, manifest_path }) };
+  const hintLines = [
+    `installed: ${installed.length}`,
+    input.dryRun ? "(dry run)" : `backed up: ${backed_up.length}`,
+    `manifest: ${manifest_path}`
+  ];
+  return { exitCode: ExitCode.OK, result: ok({ installed, backed_up, manifest_path, humanHint: hintLines.join("\n") }) };
 }
 
 // src/commands/path.ts
@@ -829,16 +1046,20 @@ async function runPath(input) {
       home: input.home,
       explain: input.explain
     });
-    return { exitCode: ExitCode.OK, result: ok({ path: r2.path, source: r2.source, ...r2.chain ? { chain: r2.chain } : {} }) };
+    return { exitCode: ExitCode.OK, result: ok({ path: r2.path, source: r2.source, ...r2.chain ? { chain: r2.chain } : {}, humanHint: `${r2.path} (via ${r2.source})` }) };
   }
   const r = await resolveRuntimePath({
     flag: input.flag,
     envValue: input.envValue,
     home: input.home,
+    wiki: input.wiki,
     explain: input.explain
   });
-  if (!r.ok) return { exitCode: ExitCode.NO_VAULT_CONFIGURED, result: r };
-  return { exitCode: ExitCode.OK, result: ok({ path: r.data.path, source: r.data.source, ...r.data.chain ? { chain: r.data.chain } : {} }) };
+  if (!r.ok) {
+    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})` }) };
 }
 
 // src/utils/lang.ts
@@ -892,7 +1113,8 @@ async function runLang(input) {
       value: resolved.value,
       source: resolved.source,
       canonical: resolved.canonical,
-      ...chain ? { chain } : {}
+      ...chain ? { chain } : {},
+      humanHint: `${resolved.value} (via ${resolved.source})`
     })
   };
 }
@@ -949,8 +1171,10 @@ var VAULT_DIRS = [
   "comparisons",
   "queries",
   "meta",
-  "projects"
+  "projects",
+  ".obsidian"
 ];
+var ATTACHMENT_FOLDER = "raw/assets";
 function extractDomainFromSchema(text) {
   const m = text.match(/^##\s+Domain\s*\n([\s\S]*?)(?=\n\n|\n##|\s*$)/m);
   if (!m) return "";
@@ -1005,13 +1229,13 @@ async function runInit(input) {
   }
   const existingEnv = parseDotenvText(existingEnvRaw);
   const swDotenvHadPath = existingEnv.WIKI_PATH !== void 0;
-  if (existingEnv.WIKI_PATH !== void 0 && existingEnv.WIKI_PATH !== target && !input.force) {
+  if (!input.profile && existingEnv.WIKI_PATH !== void 0 && existingEnv.WIKI_PATH !== target && !input.force) {
     return {
       exitCode: ExitCode.ENV_WRITE_CONFLICT,
       result: err("ENV_WRITE_CONFLICT", { key: "WIKI_PATH", existing: existingEnv.WIKI_PATH, attempted: target })
     };
   }
-  if (existingEnv.WIKI_LANG !== void 0 && existingEnv.WIKI_LANG !== canonicalLang && !input.force) {
+  if (!input.profile && existingEnv.WIKI_LANG !== void 0 && existingEnv.WIKI_LANG !== canonicalLang && !input.force) {
     return {
       exitCode: ExitCode.ENV_WRITE_CONFLICT,
       result: err("ENV_WRITE_CONFLICT", { key: "WIKI_LANG", existing: existingEnv.WIKI_LANG, attempted: canonicalLang })
@@ -1080,23 +1304,43 @@ async function runInit(input) {
     return tpl.replace("{{INIT_DATE}}", today);
   });
   if (err1) return err1;
-  const err2 = await writeOrPreserve("log.md", async () => {
+  const errObsidian = await writeOrPreserve(".obsidian/app.json", async () => {
+    return JSON.stringify({ attachmentFolderPath: ATTACHMENT_FOLDER }, null, 2) + "\n";
+  });
+  if (errObsidian) return errObsidian;
+  const err22 = await writeOrPreserve("log.md", async () => {
     const tpl = await readFile6(join7(input.templates, "log.md"), "utf8");
     return tpl.replace(/\{\{INIT_DATE\}\}/g, today).replace("{{DOMAIN}}", domain).replace("{{WIKI_LANG}}", canonicalLang);
   });
-  if (err2) return err2;
-  const isTempPath = target.startsWith("/tmp/") || target === "/tmp" || target.startsWith("/var/tmp/") || target === "/var/tmp" || target.startsWith("/private/tmp/");
-  const skipEnv = !!input.noEnv || isTempPath;
+  if (err22) return err22;
+  const skipEnv = !!input.noEnv;
   let envWritten = "";
   if (!skipEnv) {
     try {
-      await writeDotenv(envPath, { WIKI_PATH: target, WIKI_LANG: canonicalLang }, existingEnvRaw);
+      const envEntries = {};
+      if (input.profile) {
+        envEntries[profileKey(input.profile, "PATH")] = target;
+        envEntries[profileKey(input.profile, "LANG")] = canonicalLang;
+        envEntries["WIKI_DEFAULT"] = input.profile;
+      } else {
+        envEntries["WIKI_PATH"] = target;
+        envEntries["WIKI_LANG"] = canonicalLang;
+      }
+      await writeDotenv(envPath, envEntries, existingEnvRaw);
       envWritten = envPath;
     } catch (e) {
       return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { file: envPath, message: String(e) }) };
     }
   }
   const importedFromHermes = pathRes.source === "hermes-dotenv" && !swDotenvHadPath;
+  const humanHint = [
+    `vault: ${target}`,
+    `domain: ${domain}`,
+    `lang: ${canonicalLang}`,
+    `created: ${created.length}, preserved: ${preserved.length}`,
+    `discovered tags: ${discovered_tags}`,
+    skipEnv ? "env: skipped" : `env: ${envWritten}`
+  ].join("\n");
   return {
     exitCode: ExitCode.OK,
     result: ok({
@@ -1109,7 +1353,8 @@ async function runInit(input) {
       env_written: envWritten,
       env_skipped: skipEnv,
       imported_from_hermes: importedFromHermes,
-      discovered_tags
+      discovered_tags,
+      humanHint
     })
   };
 }
@@ -1128,7 +1373,8 @@ function buildSlugMap(pages) {
 async function runLinks(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const slugs = buildSlugMap(scan.data.typedKnowledge);
+  const allPages = [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound];
+  const slugs = buildSlugMap(allPages);
   const broken = [];
   for (const p of scan.data.typedKnowledge) {
     const text = await readPage(p);
@@ -1136,7 +1382,7 @@ async function runLinks(input) {
     const body = split.ok ? split.data.body : text;
     const lines = body.split("\n");
     for (const slug of extractBodyWikilinks(body)) {
-      const tail = slug.split("/").pop();
+      const tail = slug.split("/").pop().replace(/\.md$/, "");
       if (!slugs.has(tail.toLowerCase())) {
         const line = lines.findIndex((l) => l.includes(`[[${slug}`));
         broken.push({ page: p.relPath, slug, line: line >= 0 ? line + 1 : 0 });
@@ -1144,9 +1390,10 @@ async function runLinks(input) {
     }
   }
   if (broken.length > 0) {
-    return { exitCode: ExitCode.BROKEN_WIKILINKS, result: ok({ broken }) };
+    return { exitCode: ExitCode.BROKEN_WIKILINKS, result: ok({ broken, humanHint: `broken: ${broken.length}
+${broken.map((b) => `  ${b.page}:[[${b.slug}]] (line ${b.line})`).join("\n")}` }) };
   }
-  return { exitCode: ExitCode.OK, result: ok({ broken }) };
+  return { exitCode: ExitCode.OK, result: ok({ broken, humanHint: "no broken wikilinks" }) };
 }
 
 // src/commands/tag-audit.ts
@@ -1173,9 +1420,9 @@ async function runTagAudit(input) {
     }
   }
   if (violations.length > 0) {
-    return { exitCode: ExitCode.TAG_NOT_IN_TAXONOMY, result: ok({ violations, taxonomy: tax.data }) };
+    return { exitCode: ExitCode.TAG_NOT_IN_TAXONOMY, result: ok({ violations, taxonomy: tax.data, humanHint: violations.map((v) => `${v.page}: "${v.tag}" not in taxonomy`).join("\n") }) };
   }
-  return { exitCode: ExitCode.OK, result: ok({ violations, taxonomy: tax.data }) };
+  return { exitCode: ExitCode.OK, result: ok({ violations, taxonomy: tax.data, humanHint: "all tags valid" }) };
 }
 
 // src/commands/index-check.ts
@@ -1208,10 +1455,14 @@ async function runIndexCheck(input) {
   for (const [lower, orig] of indexSlugsLower) {
     if (!fileSlugsLower.has(lower)) ghost_entries.push(orig);
   }
+  const hintLines = [];
+  if (missing_from_index.length > 0) hintLines.push(`missing from index: ${missing_from_index.length}`, ...missing_from_index.map((p) => `  ${p}`));
+  if (ghost_entries.length > 0) hintLines.push(`ghost entries: ${ghost_entries.length}`, ...ghost_entries.map((g) => `  ${g}`));
+  if (hintLines.length === 0) hintLines.push("index OK");
   if (missing_from_index.length > 0 || ghost_entries.length > 0) {
-    return { exitCode: ExitCode.INDEX_INCOMPLETE, result: ok({ missing_from_index, ghost_entries }) };
+    return { exitCode: ExitCode.INDEX_INCOMPLETE, result: ok({ missing_from_index, ghost_entries, humanHint: hintLines.join("\n") }) };
   }
-  return { exitCode: ExitCode.OK, result: ok({ missing_from_index, ghost_entries }) };
+  return { exitCode: ExitCode.OK, result: ok({ missing_from_index, ghost_entries, humanHint: hintLines.join("\n") }) };
 }
 
 // src/commands/stale.ts
@@ -1251,8 +1502,8 @@ async function runStale(input) {
       stale.push({ page: p.relPath, page_updated: updated, newest_source_ingested: newest, gap_days: gap });
     }
   }
-  if (stale.length > 0) return { exitCode: ExitCode.STALE_PAGE, result: ok({ stale }) };
-  return { exitCode: ExitCode.OK, result: ok({ stale }) };
+  if (stale.length > 0) return { exitCode: ExitCode.STALE_PAGE, result: ok({ stale, humanHint: stale.map((s) => `${s.page} (${s.gap_days}d stale)`).join("\n") }) };
+  return { exitCode: ExitCode.OK, result: ok({ stale, humanHint: "no stale pages" }) };
 }
 
 // src/commands/pagesize.ts
@@ -1267,8 +1518,8 @@ async function runPagesize(input) {
     const count = body.split("\n").length;
     if (count > input.lines) oversized.push({ page: p.relPath, lines: count });
   }
-  if (oversized.length > 0) return { exitCode: ExitCode.PAGE_TOO_LARGE, result: ok({ oversized }) };
-  return { exitCode: ExitCode.OK, result: ok({ oversized }) };
+  if (oversized.length > 0) return { exitCode: ExitCode.PAGE_TOO_LARGE, result: ok({ oversized, humanHint: oversized.map((p) => `${p.page}: ${p.lines} lines`).join("\n") }) };
+  return { exitCode: ExitCode.OK, result: ok({ oversized, humanHint: "all pages within size limit" }) };
 }
 
 // src/commands/log-rotate.ts
@@ -1291,12 +1542,12 @@ async function runLogRotate(input) {
   const matches = [...logText.matchAll(ENTRY_RE)];
   const entries = matches.length;
   if (entries < input.threshold) {
-    return { exitCode: ExitCode.OK, result: ok({ entries, threshold: input.threshold, rotated: false }) };
+    return { exitCode: ExitCode.OK, result: ok({ entries, threshold: input.threshold, rotated: false, humanHint: `${entries}/${input.threshold} entries \u2014 no rotation needed` }) };
   }
   if (!input.apply) {
     return {
       exitCode: ExitCode.LOG_ROTATE_NEEDED,
-      result: ok({ entries, threshold: input.threshold, rotated: false })
+      result: ok({ entries, threshold: input.threshold, rotated: false, humanHint: `${entries}/${input.threshold} entries \u2014 rotation needed (use --apply)` })
     };
   }
   const newestYear = matches[matches.length - 1][1];
@@ -1317,13 +1568,143 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
   } catch (e) {
     return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { message: String(e) }) };
   }
-  return { exitCode: ExitCode.OK, result: ok({ entries, threshold: input.threshold, rotated: true, rotated_to: rotatedName }) };
+  return { exitCode: ExitCode.OK, result: ok({ entries, threshold: input.threshold, rotated: true, rotated_to: rotatedName, humanHint: `rotated ${entries} entries to ${rotatedName}` }) };
+}
+
+// src/commands/topic-map-check.ts
+var DEFAULT_THRESHOLD = 200;
+async function runTopicMapCheck(input) {
+  const threshold = input.threshold ?? DEFAULT_THRESHOLD;
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const page_count = scan.data.typedKnowledge.length;
+  const recommended = page_count >= threshold;
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      recommended,
+      page_count,
+      threshold,
+      humanHint: recommended ? `topic map recommended (${page_count} pages >= ${threshold} threshold)` : `topic map not needed (${page_count} pages < ${threshold} threshold)`
+    })
+  };
+}
+
+// src/commands/index-link-format.ts
+import { readFile as readFile11 } from "fs/promises";
+import { join as join12 } from "path";
+var MD_LINK_RE = /\[[^\[\]]+\]\([^)]+\.md\)/;
+async function runIndexLinkFormat(input) {
+  let text = "";
+  try {
+    text = await readFile11(join12(input.vault, "index.md"), "utf8");
+  } catch {
+  }
+  const markdown_links = [];
+  for (const [i, line] of text.split("\n").entries()) {
+    if (MD_LINK_RE.test(line)) markdown_links.push({ line: i + 1, text: line.trim() });
+  }
+  const humanHint = markdown_links.length === 0 ? "all index links use wikilink format" : `markdown links found: ${markdown_links.length}
+${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
+  return { exitCode: ExitCode.OK, result: ok({ markdown_links, humanHint }) };
+}
+
+// src/commands/dedup.ts
+import { readFileSync, writeFileSync, unlinkSync } from "fs";
+import { join as join13 } from "path";
+async function runDedup(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const hashMap = /* @__PURE__ */ new Map();
+  let totalFiles = 0;
+  for (const raw of scan.data.raw) {
+    const fm = extractFrontmatter(await readPage(raw));
+    if (!fm.ok) continue;
+    const sha = typeof fm.data.sha256 === "string" ? fm.data.sha256 : null;
+    if (!sha || sha.length !== 64) continue;
+    totalFiles++;
+    const existing = hashMap.get(sha);
+    if (existing) existing.push(raw.relPath);
+    else hashMap.set(sha, [raw.relPath]);
+  }
+  const duplicates = [...hashMap.entries()].filter(([, files]) => files.length > 1).map(([sha256, files]) => ({ sha256, files }));
+  const rewired = [];
+  const removed = [];
+  if (input.apply && duplicates.length > 0) {
+    const replacements = /* @__PURE__ */ new Map();
+    for (const group of duplicates) {
+      const canonical = group.files[0];
+      for (let i = 1; i < group.files.length; i++) {
+        replacements.set(group.files[i], canonical);
+      }
+    }
+    for (const page of scan.data.typedKnowledge) {
+      const text = readFileSync(join13(input.vault, page.relPath), "utf-8");
+      let updated = text;
+      let changed = false;
+      for (const [oldPath, newPath] of replacements) {
+        const oldMarker = `^[${oldPath}]`;
+        const newMarker = `^[${newPath}]`;
+        if (updated.includes(oldMarker)) {
+          updated = updated.replaceAll(oldMarker, newMarker);
+          changed = true;
+        }
+        const oldFm = `- "^[${oldPath}]"`;
+        const newFm = `- "^[${newPath}]"`;
+        if (updated.includes(oldFm)) {
+          updated = updated.replaceAll(oldFm, newFm);
+          changed = true;
+        }
+      }
+      if (changed) {
+        writeFileSync(join13(input.vault, page.relPath), updated);
+        rewired.push(page.relPath);
+      }
+    }
+    for (const [oldPath] of replacements) {
+      const fullPath = join13(input.vault, oldPath);
+      try {
+        unlinkSync(fullPath);
+        removed.push(oldPath);
+      } catch {
+      }
+    }
+  }
+  const exitCode = duplicates.length > 0 ? input.apply ? ExitCode.DEDUP_APPLIED : ExitCode.RAW_DEDUP_DETECTED : ExitCode.OK;
+  const hintLines = [`scanned: ${totalFiles} raw files`];
+  if (duplicates.length > 0) {
+    hintLines.push(`duplicates: ${duplicates.length}`);
+    for (const d of duplicates) hintLines.push(`  ${d.sha256.slice(0, 12)}... \u2192 ${d.files.join(", ")}`);
+    if (input.apply) {
+      hintLines.push(`rewired: ${rewired.length} pages`);
+      hintLines.push(`removed: ${removed.length} raw files`);
+    }
+  } else {
+    hintLines.push("0 duplicates");
+  }
+  return {
+    exitCode,
+    result: ok({ scanned: totalFiles, duplicates, rewired, removed, humanHint: hintLines.join("\n") })
+  };
 }
 
 // src/commands/lint.ts
-var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_drift", "tag_not_in_taxonomy"];
-var WARNING_ORDER = ["index_incomplete", "stale_page", "page_too_large", "log_rotate_needed", "contested", "orphans"];
-var INFO_ORDER = ["bridges", "low_confidence_single_source"];
+var STRUCT_MIN_BODY_LINES = 60;
+var STRUCT_MIN_SECTIONS = 3;
+function hasDuplicateFrontmatter(body) {
+  if (/^---\r?\n/.test(body)) return true;
+  const lines = body.split(/\r?\n/);
+  const limit = Math.min(lines.length, 20);
+  let seenYamlKey = false;
+  for (let i = 0; i < limit; i++) {
+    if (/^\w[\w-]*:/.test(lines[i].trim())) seenYamlKey = true;
+    if (seenYamlKey && lines[i].trim() === "---") return true;
+  }
+  return false;
+}
+var ERROR_ORDER = ["broken_wikilinks", "invalid_frontmatter", "raw_dedup", "tag_not_in_taxonomy"];
+var WARNING_ORDER = ["index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "missing_overview"];
+var INFO_ORDER = ["bridges", "page_structure", "topic_map_recommended", "frontmatter_wikilink"];
 async function runLint(input) {
   const buckets = {};
   const links = await runLinks({ vault: input.vault });
@@ -1343,6 +1724,10 @@ async function runLint(input) {
       ghost_entries: idx.result.data.ghost_entries
     }];
   }
+  const linkFmt = await runIndexLinkFormat({ vault: input.vault });
+  if (linkFmt.result.ok && linkFmt.result.data.markdown_links.length > 0) {
+    buckets.index_link_format = linkFmt.result.data.markdown_links;
+  }
   const stale = await runStale({ vault: input.vault, days: input.days });
   if (stale.result.ok && stale.result.data.stale.length > 0) buckets.stale_page = stale.result.data.stale;
   const pagesize = await runPagesize({ vault: input.vault, lines: input.lines });
@@ -1356,6 +1741,60 @@ async function runLint(input) {
     if (orphans.result.data.orphans.length > 0) buckets.orphans = orphans.result.data.orphans;
     if (orphans.result.data.bridges.length > 0) buckets.bridges = orphans.result.data.bridges;
   }
+  const topicMap = await runTopicMapCheck({ vault: input.vault });
+  if (topicMap.result.ok && topicMap.result.data.recommended) {
+    buckets.topic_map_recommended = [{ page_count: topicMap.result.data.page_count, threshold: topicMap.result.data.threshold }];
+  }
+  const dedup = await runDedup({ vault: input.vault });
+  if (dedup.result.ok && dedup.result.data.duplicates.length > 0) buckets.raw_dedup = dedup.result.data.duplicates;
+  const scan = await scanVault(input.vault);
+  const allPages = scan.ok ? [...scan.data.typedKnowledge, ...scan.data.raw, ...scan.data.workItems, ...scan.data.compound] : [];
+  const slugs = scan.ok ? buildSlugMap(allPages) : /* @__PURE__ */ new Map();
+  if (scan.ok) {
+    const legacyPages = [];
+    const orphanedPages = [];
+    const structFlags = [];
+    const dupFrontmatter = [];
+    const noOverview = [];
+    const fmWikilinkFlags = [];
+    for (const page of scan.data.typedKnowledge) {
+      const text = await readPage(page);
+      const split = splitFrontmatter(text);
+      if (!split.ok) continue;
+      const body = split.data.body;
+      const rawFm = split.data.rawFrontmatter;
+      if (hasDuplicateFrontmatter(body)) dupFrontmatter.push(page.relPath);
+      if (isLegacyCitationStyle(body)) legacyPages.push(page.relPath);
+      if (hasOrphanedCitations(body)) orphanedPages.push(page.relPath);
+      const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
+      for (const link of fmLinks) {
+        const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
+        const tail = target.split("/").pop().replace(/\.md$/, "");
+        if (!slugs.has(tail.toLowerCase())) {
+          fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
+        }
+      }
+      const bodyLines = body.split("\n").filter((l) => l.trim().length > 0).length;
+      const hasOverview = /^## Overview/m.test(body);
+      if (!hasOverview) noOverview.push(page.relPath);
+      if (bodyLines < STRUCT_MIN_BODY_LINES) {
+        const hasRelated = /^## (Related|Relationships)/m.test(body);
+        const sectionCount = (body.match(/^## /gm) ?? []).length;
+        if (!hasRelated || sectionCount < STRUCT_MIN_SECTIONS) {
+          const reasons = [];
+          if (!hasRelated) reasons.push("no Related or Relationships");
+          if (sectionCount < STRUCT_MIN_SECTIONS) reasons.push(`only ${sectionCount} sections`);
+          structFlags.push(`${page.relPath}: ${bodyLines} lines, ${reasons.join(", ")}`);
+        }
+      }
+    }
+    if (legacyPages.length > 0) buckets.legacy_citation_style = legacyPages;
+    if (orphanedPages.length > 0) buckets.orphaned_citations = orphanedPages;
+    if (structFlags.length > 0) buckets.page_structure = structFlags;
+    if (dupFrontmatter.length > 0) buckets.duplicate_frontmatter = dupFrontmatter;
+    if (noOverview.length > 0) buckets.missing_overview = noOverview;
+    if (fmWikilinkFlags.length > 0) buckets.frontmatter_wikilink = fmWikilinkFlags;
+  }
   const errorOut = ERROR_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const warningOut = WARNING_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
   const infoOut = INFO_ORDER.flatMap((k) => buckets[k] ? [{ kind: k, items: buckets[k] }] : []);
@@ -1367,25 +1806,35 @@ async function runLint(input) {
   let exitCode = ExitCode.OK;
   if (summary.errors > 0) exitCode = ExitCode.LINT_HAS_ERRORS;
   else if (summary.warnings > 0 || summary.info > 0) exitCode = ExitCode.LINT_HAS_WARNINGS;
+  const hintLines = [];
+  if (summary.errors > 0) hintLines.push(`errors: ${summary.errors}`);
+  if (summary.warnings > 0) hintLines.push(`warnings: ${summary.warnings}`);
+  if (summary.info > 0) hintLines.push(`info: ${summary.info}`);
+  const allBuckets = [...errorOut, ...warningOut, ...infoOut];
+  for (const b of allBuckets) {
+    hintLines.push(`  ${b.kind}: ${b.items.length}`);
+  }
+  if (hintLines.length === 0) hintLines.push("0 errors, 0 warnings, 0 info");
   return {
     exitCode,
     result: ok({
       vault: { path: input.vault, source: input.source ?? "resolved" },
       summary,
-      by_severity: { error: errorOut, warning: warningOut, info: infoOut }
+      by_severity: { error: errorOut, warning: warningOut, info: infoOut },
+      humanHint: hintLines.join("\n")
     })
   };
 }
 
 // src/commands/config.ts
-import { readFile as readFile11 } from "fs/promises";
+import { readFile as readFile12 } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join12 } from "path";
+import { join as join14 } from "path";
 function validateKey(key) {
-  return CONFIG_KEYS.includes(key);
+  return CONFIG_KEYS.includes(key) || isValidWikiProfileKey(key);
 }
 function configPath(home) {
-  return join12(home, ".skillwiki", ".env");
+  return join14(home, ".skillwiki", ".env");
 }
 async function runConfigGet(input) {
   if (!validateKey(input.key)) {
@@ -1403,7 +1852,7 @@ async function runConfigSet(input) {
   try {
     let originalContent;
     try {
-      originalContent = await readFile11(filePath, "utf8");
+      originalContent = await readFile12(filePath, "utf8");
     } catch {
     }
     const existing = originalContent !== void 0 ? parseDotenvText(originalContent) : {};
@@ -1417,7 +1866,21 @@ async function runConfigSet(input) {
 async function runConfigList(input) {
   const map = await parseDotenvFile(configPath(input.home));
   const entries = Object.entries(map).map(([key, value]) => ({ key, value: value ?? "" }));
-  return { exitCode: ExitCode.OK, result: ok({ entries, humanHint: entries.map((e) => `${e.key}=${e.value}`).join("\n") }) };
+  let profiles;
+  if (input.profiles) {
+    const defaultProfile = map["WIKI_DEFAULT"];
+    profiles = [];
+    for (const key of Object.keys(map)) {
+      const m = key.match(/^WIKI_([A-Z][A-Z0-9_]{0,31})_PATH$/);
+      if (m && key !== "WIKI_PATH") {
+        const name = m[1].toLowerCase().replace(/_/g, "-");
+        profiles.push({ name, path: map[key] ?? "", isDefault: name === defaultProfile });
+      }
+    }
+    profiles.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  const hint = profiles ? profiles.map((p) => `${p.isDefault ? "* " : "  "}${p.name} \u2192 ${p.path}`).join("\n") || "(no profiles)" : entries.map((e) => `${e.key}=${e.value}`).join("\n");
+  return { exitCode: ExitCode.OK, result: ok({ entries, profiles, humanHint: hint }) };
 }
 async function runConfigPath(input) {
   const filePath = configPath(input.home);
@@ -1425,9 +1888,72 @@ async function runConfigPath(input) {
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync2, readdirSync, statSync } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync3, statSync } from "fs";
+import { join as join16 } from "path";
 import { execSync } from "child_process";
+
+// src/utils/auto-update.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
+import { join as join15, dirname as dirname6 } from "path";
+import { spawn } from "child_process";
+
+// src/utils/update-consts.ts
+var CACHE_FILENAME = ".update-cache.json";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var ENV_DISABLE_KEY = "NO_UPDATE_NOTIFIER";
+var CLI_DISABLE_FLAG = "--no-update-notifier";
+
+// src/utils/auto-update.ts
+function cachePath(home) {
+  return join15(home, ".skillwiki", CACHE_FILENAME);
+}
+function readCacheRaw(home) {
+  try {
+    const raw = readFileSync2(cachePath(home), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readCache(home) {
+  const cache = readCacheRaw(home);
+  if (!cache) return { cache: null, hasUpdate: false, isStale: true };
+  const isStale = Date.now() - cache.lastCheck >= CHECK_INTERVAL_MS;
+  const hasUpdate = !!cache.latestVersion && semverGt(cache.latestVersion, cache.currentVersion);
+  return { cache, hasUpdate, isStale };
+}
+function writeCache(home, cache) {
+  const p = cachePath(home);
+  mkdirSync(dirname6(p), { recursive: true });
+  writeFileSync2(p, JSON.stringify(cache, null, 2));
+}
+function latestFromCache(home, currentVersion) {
+  const { cache } = readCache(home);
+  if (!cache || !cache.latestVersion) return { hasUpdate: false, latest: null };
+  return {
+    hasUpdate: semverGt(cache.latestVersion, currentVersion),
+    latest: cache.latestVersion
+  };
+}
+function isDisabled() {
+  return !!(process.env[ENV_DISABLE_KEY] || process.env.NODE_ENV === "test" || process.argv.includes(CLI_DISABLE_FLAG));
+}
+function triggerAutoUpdate(home, currentVersion) {
+  if (isDisabled()) return;
+  const { isStale } = readCache(home);
+  if (!isStale) return;
+  const bgScript = new URL("../auto-update-bg.js", import.meta.url).pathname;
+  if (!existsSync2(bgScript)) return;
+  const child = spawn(process.execPath, [bgScript, home, currentVersion], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+
+// src/commands/doctor.ts
 function check(status, id, label, detail) {
   return { id, label, status, detail };
 }
@@ -1454,7 +1980,7 @@ function checkCliOnPath(argv) {
 }
 async function checkConfigFile(home) {
   const cfgPath = configPath(home);
-  if (!existsSync2(cfgPath)) {
+  if (!existsSync3(cfgPath)) {
     return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
   }
   try {
@@ -1469,7 +1995,7 @@ function checkWikiPathExists(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "wiki_path_exists", "Vault directory exists", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (existsSync2(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+  if (existsSync3(resolvedPath) && statSync(resolvedPath).isDirectory()) {
     return check("pass", "wiki_path_exists", "Vault directory exists", resolvedPath);
   }
   return check("error", "wiki_path_exists", "Vault directory exists", `${resolvedPath} does not exist or is not a directory`);
@@ -1478,22 +2004,22 @@ function checkVaultStructure(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync2(resolvedPath)) {
+  if (!existsSync3(resolvedPath)) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
   const missing = [];
-  if (!existsSync2(join13(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  if (!existsSync3(join16(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
   for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync2(join13(resolvedPath, dir))) missing.push(dir + "/");
+    if (!existsSync3(join16(resolvedPath, dir))) missing.push(dir + "/");
   }
   if (missing.length === 0) {
     return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
   }
-  return check("error", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")}`);
+  return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
 function checkSkillsInstalled(home) {
-  const skillsDir = join13(home, ".claude", "skills");
-  if (!existsSync2(skillsDir)) {
+  const skillsDir = join16(home, ".claude", "skills");
+  if (!existsSync3(skillsDir)) {
     return check("warn", "skills_installed", "Skills installed", `${skillsDir} not found`);
   }
   const found = findSkillMd(skillsDir);
@@ -1502,6 +2028,70 @@ function checkSkillsInstalled(home) {
   }
   return check("warn", "skills_installed", "Skills installed", "No SKILL.md files found in ~/.claude/skills/");
 }
+function checkNpmUpdate(home, currentVersion) {
+  const { hasUpdate, latest } = latestFromCache(home, currentVersion);
+  if (!latest) {
+    return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (no cache yet)`);
+  }
+  if (hasUpdate) {
+    return check("warn", "npm_update", "npm CLI version", `v${currentVersion} \u2014 update available: v${latest}. Run \`skillwiki update\`.`);
+  }
+  return check("pass", "npm_update", "npm CLI version", `v${currentVersion} (latest: v${latest})`);
+}
+function checkPluginVersionDrift(home, currentVersion) {
+  const pluginJsonPath = join16(home, ".claude", "plugins", "cache", "llm-wiki", "plugin.json");
+  if (!existsSync3(pluginJsonPath)) {
+    return check("pass", "plugin_version_drift", "Plugin/CLI version", "Plugin cache not found \u2014 plugin not installed");
+  }
+  try {
+    const content = readFileSync3(pluginJsonPath, { encoding: "utf8" });
+    const pluginData = JSON.parse(content);
+    const pluginVersion = pluginData.version;
+    if (!pluginVersion) {
+      return check("pass", "plugin_version_drift", "Plugin/CLI version", "Plugin version not found in cache");
+    }
+    if (pluginVersion === currentVersion) {
+      return check("pass", "plugin_version_drift", "Plugin/CLI version", `Both at v${currentVersion}`);
+    }
+    const updateCmd = semverGt(pluginVersion, currentVersion) ? "npm install -g skillwiki@beta" : "claude plugin update skillwiki@llm-wiki";
+    return check(
+      "warn",
+      "plugin_version_drift",
+      "Plugin/CLI version",
+      `Plugin v${pluginVersion} \u2260 CLI v${currentVersion} \u2014 run \`${updateCmd}\``
+    );
+  } catch {
+    return check("pass", "plugin_version_drift", "Plugin/CLI version", "Could not read plugin cache");
+  }
+}
+async function checkProfiles(home) {
+  const map = await parseDotenvFile(configPath(home));
+  const profiles = [];
+  for (const key of Object.keys(map)) {
+    if (key.startsWith("WIKI_") && key.endsWith("_PATH") && key !== "WIKI_PATH") {
+      const name = key.slice(5, -5).toLowerCase().replace(/_/g, "-");
+      profiles.push(name);
+    }
+  }
+  if (profiles.length === 0) {
+    return check("pass", "wiki_profiles", "Wiki profiles", "No named profiles configured");
+  }
+  const defaultProfile = map["WIKI_DEFAULT"] ?? "(none)";
+  return check(
+    "pass",
+    "wiki_profiles",
+    "Wiki profiles",
+    `${profiles.length} profile(s): ${profiles.join(", ")}; default: ${defaultProfile}`
+  );
+}
+async function checkProjectLocalOverride(cwd) {
+  const dir = cwd ?? process.cwd();
+  const envPath = join16(dir, ".skillwiki", ".env");
+  if (existsSync3(envPath)) {
+    return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
+  }
+  return check("pass", "project_local", "Project-local config", "None");
+}
 function findSkillMd(dir) {
   const results = [];
   let entries;
@@ -1512,9 +2102,9 @@ function findSkillMd(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join13(dir, entry.name));
+      results.push(join16(dir, entry.name));
     } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join13(dir, entry.name)));
+      results.push(...findSkillMd(join16(dir, entry.name)));
     }
   }
   return results;
@@ -1524,6 +2114,8 @@ async function runDoctor(input) {
   checks.push(checkNodeVersion());
   checks.push(checkCliOnPath(input.argv));
   checks.push(await checkConfigFile(input.home));
+  checks.push(await checkProfiles(input.home));
+  checks.push(await checkProjectLocalOverride(input.cwd));
   const resolved = await resolveRuntimePath({ flag: void 0, envValue: input.envValue, home: input.home });
   if (resolved.ok) {
     checks.push(check("pass", "wiki_path_set", "WIKI_PATH configured", `Resolved via ${resolved.data.source}: ${resolved.data.path}`));
@@ -1534,6 +2126,8 @@ async function runDoctor(input) {
   checks.push(checkWikiPathExists(resolvedPath));
   checks.push(checkVaultStructure(resolvedPath));
   checks.push(checkSkillsInstalled(input.home));
+  checks.push(checkNpmUpdate(input.home, input.currentVersion));
+  checks.push(checkPluginVersionDrift(input.home, input.currentVersion));
   const summary = {
     pass: checks.filter((c) => c.status === "pass").length,
     warn: checks.filter((c) => c.status === "warn").length,
@@ -1552,8 +2146,419 @@ async function runDoctor(input) {
   return { exitCode, result: ok({ checks, summary, humanHint }) };
 }
 
+// src/commands/archive.ts
+import { rename as rename3, mkdir as mkdir5, readFile as readFile13, writeFile as writeFile6 } from "fs/promises";
+import { join as join17, dirname as dirname7 } from "path";
+async function runArchive(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  let relPath;
+  if (input.page.includes("/")) {
+    relPath = scan.data.typedKnowledge.find((p) => p.relPath === input.page)?.relPath;
+  } else {
+    relPath = scan.data.typedKnowledge.find((p) => p.relPath.replace(/\.md$/, "").split("/").pop() === input.page)?.relPath;
+  }
+  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 archivePath = join17("_archive", relPath);
+  await mkdir5(dirname7(join17(input.vault, archivePath)), { recursive: true });
+  let indexUpdated = false;
+  const indexPath = join17(input.vault, "index.md");
+  try {
+    const idx = await readFile13(indexPath, "utf8");
+    const slug = relPath.replace(/\.md$/, "").split("/").pop();
+    const originalLines = idx.split("\n");
+    const filtered = originalLines.filter((l) => !l.includes(`[[${slug}]]`));
+    if (filtered.length !== originalLines.length) {
+      await writeFile6(indexPath, filtered.join("\n"), "utf8");
+      indexUpdated = true;
+    }
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw e;
+  }
+  await rename3(join17(input.vault, relPath), join17(input.vault, archivePath));
+  return { exitCode: ExitCode.OK, result: ok({ archived_from: relPath, archived_to: archivePath, index_updated: indexUpdated, humanHint: `${relPath} -> ${archivePath}${indexUpdated ? " (index updated)" : ""}` }) };
+}
+
+// src/commands/drift.ts
+import { createHash as createHash2 } from "crypto";
+import { writeFile as writeFile7 } from "fs/promises";
+
+// src/utils/fetch.ts
+async function controlledFetch(url, opts) {
+  let current = url;
+  for (let hop = 0; hop <= opts.maxRedirects; hop++) {
+    const guard = runFetchGuardSync({ url: current });
+    if (!guard.result.ok) return guard.result;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), opts.timeoutMs);
+    let res;
+    try {
+      res = await fetch(current, { redirect: "manual", signal: ctrl.signal });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e?.name === "AbortError") return err("FETCH_TIMEOUT", { url: current });
+      return err("FETCH_FAILED", { message: String(e) });
+    }
+    clearTimeout(timer);
+    if (res.status >= 300 && res.status < 400) {
+      const loc = res.headers.get("location");
+      if (!loc) return err("FETCH_FAILED", { reason: "redirect without Location" });
+      current = new URL(loc, current).toString();
+      continue;
+    }
+    const declared = Number(res.headers.get("content-length") ?? "0");
+    if (declared > opts.maxBytes) return err("FETCH_TOO_LARGE", { declared, limit: opts.maxBytes });
+    const buf = new Uint8Array(await res.arrayBuffer());
+    if (buf.byteLength > opts.maxBytes) return err("FETCH_TOO_LARGE", { actual: buf.byteLength, limit: opts.maxBytes });
+    return ok({ url: current, status: res.status, body: new TextDecoder().decode(buf), bytes: buf.byteLength });
+  }
+  return err("FETCH_FAILED", { reason: "too many redirects", limit: opts.maxRedirects });
+}
+
+// src/commands/drift.ts
+var FETCH_OPTS = { timeoutMs: 1e4, maxBytes: 5e6, maxRedirects: 5 };
+async function runDrift(input) {
+  const doFetch = input.fetchFn ?? controlledFetch;
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const results = [];
+  for (const raw of scan.data.raw) {
+    const text = await readPage(raw);
+    const split = splitFrontmatter(text);
+    if (!split.ok) continue;
+    const { rawFrontmatter, body } = split.data;
+    const sourceUrlMatch = rawFrontmatter.match(/^source_url:\s*(.+)$/m);
+    const storedHashMatch = rawFrontmatter.match(/^sha256:\s*([a-f0-9]+)$/m);
+    if (!sourceUrlMatch || !storedHashMatch) continue;
+    const sourceUrl = sourceUrlMatch[1].trim();
+    const storedHash = storedHashMatch[1];
+    const resp = await doFetch(sourceUrl, FETCH_OPTS);
+    if (!resp.ok) {
+      results.push({
+        raw_path: raw.relPath,
+        source_url: sourceUrl,
+        stored_sha256: storedHash,
+        current_sha256: null,
+        status: "fetch_failed",
+        fetch_error: resp.error
+      });
+      continue;
+    }
+    const currentHash = createHash2("sha256").update(Buffer.from(resp.data.body, "utf8")).digest("hex");
+    const drifted2 = currentHash !== storedHash;
+    if (drifted2 && input.apply) {
+      const newFm = rawFrontmatter.replace(/^sha256:\s*[a-f0-9]+$/m, `sha256: ${currentHash}`);
+      const newText = `---
+${newFm}
+---
+${body}`;
+      await writeFile7(raw.absPath, newText, "utf8");
+      results.push({
+        raw_path: raw.relPath,
+        source_url: sourceUrl,
+        stored_sha256: storedHash,
+        current_sha256: currentHash,
+        status: "updated"
+      });
+    } else {
+      results.push({
+        raw_path: raw.relPath,
+        source_url: sourceUrl,
+        stored_sha256: storedHash,
+        current_sha256: currentHash,
+        status: drifted2 ? "drifted" : "unchanged"
+      });
+    }
+  }
+  const drifted = results.filter((r) => r.status === "drifted");
+  const fetchFailed = results.filter((r) => r.status === "fetch_failed");
+  const updated = results.filter((r) => r.status === "updated");
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  const exitCode = drifted.length > 0 ? ExitCode.DRIFT_DETECTED : ExitCode.OK;
+  const hintLines = [`scanned: ${results.length}, unchanged: ${unchanged}`];
+  if (drifted.length > 0) hintLines.push(`drifted: ${drifted.length}`, ...drifted.map((d) => `  ${d.raw_path}`));
+  if (fetchFailed.length > 0) hintLines.push(`fetch_failed: ${fetchFailed.length}`, ...fetchFailed.map((f) => `  ${f.raw_path}: ${f.fetch_error}`));
+  if (updated.length > 0) hintLines.push(`updated: ${updated.length}`, ...updated.map((u) => `  ${u.raw_path}`));
+  return {
+    exitCode,
+    result: ok({ scanned: results.length, drifted, fetch_failed: fetchFailed, updated, unchanged, humanHint: hintLines.join("\n") })
+  };
+}
+
+// src/commands/migrate-citations.ts
+import { writeFile as writeFile8 } from "fs/promises";
+var MARKER_RE2 = /\^\[(raw\/[^\]]+)\]/g;
+function moveMarkersToParagraphEnd(body) {
+  const lines = body.split("\n");
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trimStart().startsWith("```")) {
+      result.push(line);
+      if (!line.trimEnd().endsWith("```") || line.trim() === "```") {
+        for (let j = i + 1; j < lines.length; j++) {
+          result.push(lines[j]);
+          if (lines[j].trimStart().startsWith("```")) {
+            i = j;
+            break;
+          }
+        }
+      }
+      continue;
+    }
+    if (/^## Sources\b/.test(line.trim())) {
+      result.push(line);
+      continue;
+    }
+    const markers = [...line.matchAll(MARKER_RE2)];
+    if (markers.length === 0) {
+      result.push(line);
+      continue;
+    }
+    const proseOnly = line.replace(MARKER_RE2, "").trim();
+    if (proseOnly.length === 0) {
+      const markerStr = " " + markers.map((m) => m[0]).join(" ");
+      let merged = false;
+      for (let k = result.length - 1; k >= 0; k--) {
+        if (result[k].trim().length > 0) {
+          result[k] = result[k].trimEnd() + markerStr;
+          merged = true;
+          break;
+        }
+      }
+      if (!merged) result.push(line);
+      continue;
+    }
+    const lastMarkerIdx = line.lastIndexOf("^[raw/");
+    const afterLast = line.slice(lastMarkerIdx).replace(MARKER_RE2, "").trim();
+    const firstMarkerIdx = line.indexOf("^[raw/");
+    const beforeFirst = line.slice(0, firstMarkerIdx).trim();
+    const alreadyAtEnd = afterLast.length === 0 && (beforeFirst.length === 0 || /[.!?]\s*$/.test(beforeFirst));
+    if (alreadyAtEnd) {
+      result.push(line);
+      continue;
+    }
+    let cleaned = line.replace(/\s*\^\[raw\/[^\]]+\]\s*/g, " ").trimEnd();
+    cleaned = cleaned.replace(/  +/g, " ").trimEnd();
+    const markerStrings = markers.map((m) => m[0]);
+    if (cleaned.length > 0 && /[.!?]$/.test(cleaned)) {
+      cleaned += " " + markerStrings.join(" ");
+    } else if (cleaned.length > 0) {
+      cleaned += ". " + markerStrings.join(" ");
+    } else {
+      cleaned = markerStrings.join(" ");
+    }
+    result.push(cleaned);
+  }
+  return result.join("\n");
+}
+function buildSourcesFooter(targets) {
+  return "\n## Sources\n" + targets.map((t) => `- ^[${t}]`).join("\n") + "\n";
+}
+function reorderSourcesFm(rawFm, targets) {
+  const sourcesLineRe = /^sources:\s*\[([^\]]*)\]\s*$/m;
+  const match = rawFm.match(sourcesLineRe);
+  if (!match) return rawFm;
+  const existing = match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter((s) => s.length > 0);
+  const targetSet = new Set(targets);
+  const reordered = [
+    ...targets,
+    ...existing.filter((s) => !targetSet.has(s))
+  ];
+  const newLine = `sources: [${reordered.join(", ")}]`;
+  return rawFm.replace(sourcesLineRe, newLine);
+}
+function removeExistingFooter(body) {
+  const footerRe = /\n## Sources\n[\s\S]*$/;
+  return body.replace(footerRe, "");
+}
+async function runMigrateCitations(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const migrated = [];
+  const skipped = [];
+  let unchanged = 0;
+  for (const page of scan.data.typedKnowledge) {
+    const text = await readPage(page);
+    const split = splitFrontmatter(text);
+    if (!split.ok) continue;
+    const { rawFrontmatter, body } = split.data;
+    const markers = extractCitationMarkers(body);
+    if (markers.length === 0) {
+      unchanged++;
+      continue;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueTargets = [];
+    for (const m of markers) {
+      if (!seen.has(m.target)) {
+        seen.add(m.target);
+        uniqueTargets.push(m.target);
+      }
+    }
+    const bodyWithoutFooter = removeExistingFooter(body);
+    const migratedBody = moveMarkersToParagraphEnd(bodyWithoutFooter);
+    const newFooter = buildSourcesFooter(uniqueTargets);
+    const newFm = reorderSourcesFm(rawFrontmatter, uniqueTargets);
+    const newText = `---
+${newFm}
+---
+${migratedBody}${newFooter}`;
+    if (newText === text) {
+      skipped.push(page.relPath);
+      continue;
+    }
+    if (!input.dryRun) {
+      await writeFile8(page.absPath, newText, "utf8");
+    }
+    migrated.push(page.relPath);
+  }
+  const exitCode = migrated.length > 0 ? ExitCode.MIGRATION_APPLIED : ExitCode.OK;
+  const hintLines = [`scanned: ${migrated.length + skipped.length + unchanged}`];
+  if (migrated.length > 0) hintLines.push(`migrated: ${migrated.length}`);
+  if (skipped.length > 0) hintLines.push(`skipped (already clean): ${skipped.length}`);
+  if (unchanged > 0) hintLines.push(`unchanged (no markers): ${unchanged}`);
+  return {
+    exitCode,
+    result: ok({
+      scanned: migrated.length + skipped.length + unchanged,
+      migrated,
+      skipped,
+      unchanged,
+      humanHint: hintLines.join("\n")
+    })
+  };
+}
+
+// src/commands/frontmatter-fix.ts
+import { writeFile as writeFile9 } from "fs/promises";
+function isoToday() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function fixFrontmatter(rawFm) {
+  const additions = [];
+  if (!/^created:/m.test(rawFm)) additions.push(`created: ${isoToday()}`);
+  if (!/^updated:/m.test(rawFm)) additions.push(`updated: ${isoToday()}`);
+  if (!/^tags:/m.test(rawFm)) additions.push("tags: []");
+  if (!/^sources:/m.test(rawFm)) additions.push("sources: []");
+  if (!/^provenance:/m.test(rawFm)) additions.push("provenance: research");
+  if (additions.length === 0) return rawFm;
+  return rawFm.trimEnd() + "\n" + additions.join("\n") + "\n";
+}
+function removeOrphanTagsLines(body) {
+  return body.split("\n").filter((line) => !/^tags:\s*\[/.test(line.trim())).join("\n");
+}
+async function runFrontmatterFix(input) {
+  const scan = await scanVault(input.vault);
+  if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const fixed = [];
+  const skipped = [];
+  let unchanged = 0;
+  for (const page of scan.data.typedKnowledge) {
+    const text = await readPage(page);
+    const split = splitFrontmatter(text);
+    if (!split.ok) {
+      skipped.push(page.relPath);
+      continue;
+    }
+    const { rawFrontmatter, body } = split.data;
+    const newFm = fixFrontmatter(rawFrontmatter);
+    const newBody = removeOrphanTagsLines(body);
+    const newText = `---
+${newFm}
+---
+${newBody}`;
+    if (newText === text) {
+      unchanged++;
+      continue;
+    }
+    if (!input.dryRun) {
+      await writeFile9(page.absPath, newText, "utf8");
+    }
+    fixed.push(page.relPath);
+  }
+  const exitCode = fixed.length > 0 ? ExitCode.MIGRATION_APPLIED : ExitCode.OK;
+  const hintLines = [`scanned: ${fixed.length + skipped.length + unchanged}`];
+  if (fixed.length > 0) hintLines.push(`fixed: ${fixed.length}`);
+  if (skipped.length > 0) hintLines.push(`skipped (parse error): ${skipped.length}`);
+  if (unchanged > 0) hintLines.push(`unchanged: ${unchanged}`);
+  if (input.dryRun && fixed.length > 0) hintLines.push("(dry run \u2014 no files written)");
+  return {
+    exitCode,
+    result: ok({
+      scanned: fixed.length + skipped.length + unchanged,
+      fixed,
+      skipped,
+      unchanged,
+      humanHint: hintLines.join("\n")
+    })
+  };
+}
+
+// src/commands/update.ts
+import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync4 } from "fs";
+async function runUpdate(input) {
+  const pkg2 = JSON.parse(
+    readFileSync4(new URL("../../package.json", import.meta.url), "utf8")
+  );
+  const currentVersion = pkg2.version;
+  const tag = input.distTag ?? "beta";
+  let latest;
+  try {
+    latest = execSync2(`npm view skillwiki@${tag} version`, {
+      encoding: "utf8",
+      timeout: 15e3
+    }).trim();
+  } catch (e) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", { message: `Failed to query npm registry: ${String(e)}` })
+    };
+  }
+  const cache = {
+    lastCheck: Date.now(),
+    latestVersion: latest,
+    currentVersion
+  };
+  if (latest === currentVersion) {
+    writeCache(input.home, cache);
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        previousVersion: currentVersion,
+        newVersion: null,
+        wasAlreadyLatest: true,
+        humanHint: `Already on latest ${tag}: v${currentVersion}`
+      })
+    };
+  }
+  try {
+    execSync2(`npm install -g skillwiki@${tag}`, {
+      stdio: "pipe",
+      timeout: 6e4
+    });
+  } catch (e) {
+    return {
+      exitCode: ExitCode.PREFLIGHT_FAILED,
+      result: err("PREFLIGHT_FAILED", { message: `npm install failed: ${String(e)}` })
+    };
+  }
+  writeCache(input.home, { ...cache, updateAppliedAt: Date.now() });
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      previousVersion: currentVersion,
+      newVersion: latest,
+      wasAlreadyLatest: false,
+      humanHint: `Updated skillwiki ${currentVersion} \u2192 ${latest}`
+    })
+  };
+}
+
 // src/cli.ts
-var pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+var pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
 var program = new Command();
 program.name("skillwiki").description("Deterministic helpers for CodeWiki skills").version(pkg.version);
 program.option("--human", "render terminal-readable output instead of JSON");
@@ -1565,19 +2570,20 @@ function emit(r) {
 program.command("hash <file>").action(async (file) => emit(await runHash({ file })));
 program.command("fetch-guard <url>").action(async (url) => emit(await runFetchGuard({ url })));
 program.command("validate <file>").action(async (file) => emit(await runValidate({ file })));
-program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path", ".skillwiki/graph.json").action(async (vault, opts) => emit(await runGraphBuild({ vault, out: opts.out })));
+program.command("graph").description("graph subcommands").command("build <vault>").option("--out <path>", "graph output path", ".skillwiki/graph.json").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => emit(await runGraphBuild({ vault, out: opts.out })));
 program.command("overlap <vault>").action(async (vault) => emit(await runOverlap({ vault })));
-program.command("orphans [vault]").action(async (vault) => emit(await runOrphans({
+program.command("orphans [vault]").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => emit(await runOrphans({
   vault,
   envValue: process.env.WIKI_PATH,
-  home: process.env.HOME ?? ""
+  home: process.env.HOME ?? "",
+  wiki: opts.wiki
 })));
 program.command("audit <file>").action(async (file) => emit(await runAudit({ file })));
 program.command("install").option("--target <dir>", "target install directory", `${process.env.HOME ?? ""}/.claude/skills/`).option("--dry-run", "preview only", false).option("--skills-root <dir>", "source skills directory (defaults to packaged)").action(async (opts) => {
   const skillsRoot = opts.skillsRoot ?? new URL("../skills/", import.meta.url).pathname;
   emit(await runInstall({ skillsRoot, target: opts.target, dryRun: !!opts.dryRun }));
 });
-program.command("path").option("--vault <dir>", "explicit vault override (runtime)").option("--target <dir>", "explicit target override (init-time)").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").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) => {
   const initTime = !!opts.initTime;
   const flag = initTime ? opts.target : opts.vault;
   emit(await runPath({
@@ -1585,6 +2591,7 @@ program.command("path").option("--vault <dir>", "explicit vault override (runtim
     envValue: process.env.WIKI_PATH,
     home: process.env.HOME ?? "",
     initTime,
+    wiki: opts.wiki,
     explain: !!opts.explain
   }));
 });
@@ -1596,7 +2603,7 @@ program.command("lang").option("--lang <code>", "explicit language override").op
     explain: !!opts.explain
   }));
 });
-program.command("init").option("--target <dir>", "explicit target directory").requiredOption("--domain <text>", "knowledge domain seed").option("--taxonomy <csv>", "comma-separated tag list").option("--lang <code>", "output language (BCP 47 or alias)").option("--force", "override existing target / env conflict", false).option("--no-env", "skip writing ~/.skillwiki/.env").action(async (opts) => {
+program.command("init").option("--target <dir>", "explicit target directory").requiredOption("--domain <text>", "knowledge domain seed").option("--taxonomy <csv>", "comma-separated tag list").option("--lang <code>", "output language (BCP 47 or alias)").option("--force", "override existing target / env conflict", false).option("--no-env", "skip writing ~/.skillwiki/.env").option("--profile <name>", "write as named wiki profile instead of WIKI_PATH").action(async (opts) => {
   const templates = new URL("../templates/", import.meta.url).pathname;
   const taxonomy = typeof opts.taxonomy === "string" ? opts.taxonomy.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : void 0;
   emit(await runInit({
@@ -1608,51 +2615,57 @@ program.command("init").option("--target <dir>", "explicit target directory").re
     taxonomy,
     lang: opts.lang,
     force: !!opts.force,
-    noEnv: opts.env === false
+    noEnv: opts.env === false,
+    profile: opts.profile
   }));
 });
-async function resolveVaultArg(arg) {
+async function resolveVaultArg(arg, wiki) {
   if (arg) return { ok: true, vault: arg };
   const r = await resolveRuntimePath({
     flag: void 0,
     envValue: process.env.WIKI_PATH,
-    home: process.env.HOME ?? ""
+    wikiEnv: process.env.WIKI,
+    home: process.env.HOME ?? "",
+    wiki
   });
-  if (!r.ok) return { ok: false, exitCode: 25, payload: r };
+  if (!r.ok) {
+    const exitCode = r.error === "UNKNOWN_WIKI_PROFILE" ? 35 : 25;
+    return { ok: false, exitCode, payload: r };
+  }
   return { ok: true, vault: r.data.path };
 }
-program.command("links [vault]").action(async (vault) => {
-  const v = await resolveVaultArg(vault);
+program.command("links [vault]").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 runLinks({ vault: v.vault }));
 });
-program.command("tag-audit [vault]").action(async (vault) => {
-  const v = await resolveVaultArg(vault);
+program.command("tag-audit [vault]").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 runTagAudit({ vault: v.vault }));
 });
-program.command("index-check [vault]").action(async (vault) => {
-  const v = await resolveVaultArg(vault);
+program.command("index-check [vault]").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 runIndexCheck({ vault: v.vault }));
 });
-program.command("stale [vault]").option("--days <n>", "staleness threshold in days", (s) => parseInt(s, 10), 90).action(async (vault, opts) => {
-  const v = await resolveVaultArg(vault);
+program.command("stale [vault]").option("--days <n>", "staleness threshold in days", (s) => parseInt(s, 10), 90).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 runStale({ vault: v.vault, days: opts.days }));
 });
-program.command("pagesize [vault]").option("--lines <n>", "max body lines", (s) => parseInt(s, 10), 200).action(async (vault, opts) => {
-  const v = await resolveVaultArg(vault);
+program.command("pagesize [vault]").option("--lines <n>", "max body lines", (s) => parseInt(s, 10), 200).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 runPagesize({ vault: v.vault, lines: opts.lines }));
 });
-program.command("log-rotate [vault]").option("--threshold <n>", "entry count threshold", (s) => parseInt(s, 10), 500).option("--apply", "actually rotate", false).action(async (vault, opts) => {
-  const v = await resolveVaultArg(vault);
+program.command("log-rotate [vault]").option("--threshold <n>", "entry count threshold", (s) => parseInt(s, 10), 500).option("--apply", "actually rotate", 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 runLogRotate({ vault: v.vault, threshold: opts.threshold, apply: !!opts.apply }));
 });
-program.command("lint [vault]").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).action(async (vault, opts) => {
-  const v = await resolveVaultArg(vault);
+program.command("lint [vault]").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("--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 runLint({
     vault: v.vault,
@@ -1665,13 +2678,45 @@ program.command("lint [vault]").option("--days <n>", "stale threshold", (s) => p
 var configCmd = program.command("config").description("manage skillwiki configuration");
 configCmd.command("get <key>").description("print the value of a config key").action(async (key) => emit(await runConfigGet({ key, home: process.env.HOME ?? "" })));
 configCmd.command("set <key> <value>").description("set a config key value").action(async (key, value) => emit(await runConfigSet({ key, value, home: process.env.HOME ?? "" })));
-configCmd.command("list").description("list all config key=value pairs").action(async () => emit(await runConfigList({ home: process.env.HOME ?? "" })));
+configCmd.command("list").option("--profiles", "show wiki profiles summary", false).description("list all config key=value pairs").action(async (opts) => emit(await runConfigList({ home: process.env.HOME ?? "", profiles: !!opts.profiles })));
 configCmd.command("path").description("print the config file path").action(async () => emit(await runConfigPath({ home: process.env.HOME ?? "" })));
 program.command("doctor").description("diagnose skillwiki setup issues").action(async () => emit(await runDoctor({
   home: process.env.HOME ?? "",
   envValue: process.env.WIKI_PATH,
-  argv: process.argv
+  argv: process.argv,
+  currentVersion: pkg.version,
+  cwd: process.cwd()
+})));
+program.command("archive <page> [vault]").description("archive a typed-knowledge page").option("--wiki <name>", "wiki profile name").action(async (page, vault, opts) => {
+  const v = await resolveVaultArg(vault, opts.wiki);
+  if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
+  else emit(await runArchive({ vault: v.vault, page }));
+});
+program.command("drift [vault]").description("detect content drift in raw sources").option("--apply", "update sha256 in drifted sources").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 runDrift({ vault: v.vault, apply: opts.apply }));
+});
+program.command("dedup [vault]").description("detect duplicate raw sources by sha256").option("--apply", "rewire citations and remove duplicate raw files", 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 runDedup({ vault: v.vault, apply: opts.apply }));
+});
+program.command("migrate-citations [vault]").description("migrate ^[raw/...] markers to paragraph-end citations").option("--dry-run", "preview changes without writing", 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 runMigrateCitations({ vault: v.vault, dryRun: !!opts.dryRun }));
+});
+program.command("frontmatter-fix [vault]").description("fix common frontmatter issues on typed-knowledge pages").option("--dry-run", "preview changes without writing", 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 runFrontmatterFix({ vault: v.vault, dryRun: !!opts.dryRun }));
+});
+program.command("update").description("update skillwiki CLI to the latest version").option("--tag <tag>", "npm dist-tag", "beta").action(async (opts) => emit(await runUpdate({
+  home: process.env.HOME ?? "",
+  distTag: opts.tag
 })));
+triggerAutoUpdate(process.env.HOME ?? "", pkg.version);
 program.parseAsync(process.argv).catch((e) => {
   process.stdout.write(JSON.stringify({ ok: false, error: "INTERNAL", detail: { message: String(e) } }) + "\n");
   process.exit(1);