skillwiki 0.2.6 → 0.4.0

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
 
 // src/cli.ts
 import { readFileSync as readFileSync9 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { Command } from "commander";
 
 // ../shared/src/exit-codes.ts
@@ -1845,6 +1845,7 @@ async function runStale(input) {
   const incompleteWorkItems = [];
   const archived = [];
   const workDirs = /* @__PURE__ */ new Map();
+  const workDirsBySlug = /* @__PURE__ */ new Map();
   const projectsDir = join13(input.vault, "projects");
   let projectSlugs = [];
   try {
@@ -1859,6 +1860,7 @@ async function runStale(input) {
     } catch {
       continue;
     }
+    const slugDirs = /* @__PURE__ */ new Map();
     for (const e of entries) {
       if (!e.isDirectory()) continue;
       const relDir = `projects/${slug}/work/${e.name}`;
@@ -1869,6 +1871,7 @@ async function runStale(input) {
         files = await readdir4(absDir);
       } catch {
         workDirs.set(relDir, "");
+        slugDirs.set(e.name, "");
         continue;
       }
       for (const f of files) {
@@ -1883,18 +1886,110 @@ async function runStale(input) {
         }
       }
       workDirs.set(relDir, status);
+      slugDirs.set(e.name, status);
     }
+    workDirsBySlug.set(slug, slugDirs);
+  }
+  function extractSlug(projectField) {
+    return projectField.replace(/^\[\[/, "").replace(/\]\]$/, "").replace(/^"|"$/g, "");
   }
+  const KIND_FROM_FILENAME = /^(?:\d{4}-\d{2}-\d{2})-(task|bug|idea|note|observation)-.+\.md$/;
+  const LOOP_CYCLE_PATTERN = /loop-cycle-/;
   const transcripts = scan.data.raw.filter((p) => p.relPath.startsWith("raw/transcripts/") && p.relPath.endsWith(".md"));
+  const claimedPaths = /* @__PURE__ */ new Set();
+  const transcriptMeta = /* @__PURE__ */ new Map();
+  for (const t of transcripts) {
+    try {
+      const content = await readFile10(join13(input.vault, t.relPath), "utf8");
+      const fm = extractFrontmatter(content);
+      let kind = fm.ok && typeof fm.data.kind === "string" ? fm.data.kind : "";
+      let project = fm.ok && typeof fm.data.project === "string" ? fm.data.project : "";
+      let inferred = false;
+      if (input.forceScan && !kind) {
+        const basename = t.relPath.split("/").pop();
+        if (!LOOP_CYCLE_PATTERN.test(basename)) {
+          const m = basename.match(KIND_FROM_FILENAME);
+          if (m) {
+            kind = m[1];
+            inferred = true;
+          }
+        }
+      }
+      if (input.forceScan && !project && kind) {
+        const bodyStart = content.indexOf("---", 4);
+        if (bodyStart > 0) {
+          const body = content.slice(bodyStart);
+          const wikilink2 = body.match(/\[\[([a-z0-9-]+)\]\]/);
+          if (wikilink2) {
+            const candidate = wikilink2[1];
+            if (workDirsBySlug.has(candidate)) {
+              project = `[[${candidate}]]`;
+              inferred = true;
+            }
+          }
+        }
+      }
+      transcriptMeta.set(t.relPath, { kind, project, slug: extractSlug(project), inferred });
+    } catch {
+    }
+  }
   for (const t of transcripts) {
     const datePrefix = t.relPath.split("/").pop().slice(0, 10);
-    for (const [dir, status] of workDirs) {
-      if (dir.split("/").pop().startsWith(datePrefix) && (status === "done" || status === "invalid")) {
-        staleTranscripts.push({ path: t.relPath, reason: `work item ${dir} is ${status}` });
-        break;
+    const meta = transcriptMeta.get(t.relPath);
+    const slug = meta?.slug || "";
+    if (slug && workDirsBySlug.has(slug)) {
+      const slugDirs = workDirsBySlug.get(slug);
+      const tSlug = t.relPath.split("/").pop().replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/\.md$/, "").replace(/^(task|bug|idea|note|observation)-/, "");
+      for (const [dirName, status] of slugDirs) {
+        if (!dirName.startsWith(datePrefix)) continue;
+        const wSlug = dirName.replace(/^\d{4}-\d{2}-\d{2}-/, "");
+        const tWords = new Set(tSlug.split("-").filter((w) => w.length >= 3));
+        const wWords = wSlug.split("-").filter((w) => w.length >= 3);
+        const overlap = wWords.filter((w) => tWords.has(w)).length;
+        if (dirName.includes(tSlug) || tSlug.includes(wSlug) || overlap >= 1) {
+          claimedPaths.add(t.relPath);
+          if (status === "done" || status === "invalid") {
+            staleTranscripts.push({ path: t.relPath, reason: `work item projects/${slug}/work/${dirName} is ${status}` });
+          }
+          break;
+        }
+      }
+    } else if (!slug) {
+      for (const [dir, status] of workDirs) {
+        if (dir.split("/").pop().startsWith(datePrefix)) {
+          claimedPaths.add(t.relPath);
+          if (status === "done" || status === "invalid") {
+            staleTranscripts.push({ path: t.relPath, reason: `work item ${dir} is ${status}` });
+          }
+          break;
+        }
       }
     }
   }
+  for (const [relDir] of workDirs) {
+    const specPath = join13(input.vault, relDir, "spec.md");
+    try {
+      const specContent = await readFile10(specPath, "utf8");
+      const specFm = extractFrontmatter(specContent);
+      if (specFm.ok && typeof specFm.data.source === "string") {
+        const sourcePath = specFm.data.source;
+        if (sourcePath.startsWith("raw/transcripts/")) claimedPaths.add(sourcePath);
+      }
+    } catch {
+    }
+  }
+  const unclaimedTranscripts = [];
+  const CLAIMABLE_KINDS = /* @__PURE__ */ new Set(["task", "bug"]);
+  for (const t of transcripts) {
+    if (claimedPaths.has(t.relPath)) continue;
+    const meta = transcriptMeta.get(t.relPath);
+    if (!meta) continue;
+    if (CLAIMABLE_KINDS.has(meta.kind) && meta.project) {
+      const projectSlug = extractSlug(meta.project);
+      const hint = `skillwiki claim ${t.relPath} --project ${projectSlug}`;
+      unclaimedTranscripts.push({ path: t.relPath, reason: `${meta.kind} for ${meta.project} \u2014 no work item`, hint });
+    }
+  }
   const doneWorkItems = [];
   for (const [relDir, status] of workDirs) {
     const dirName = relDir.split("/").pop();
@@ -1987,17 +2082,20 @@ async function runStale(input) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
-  const total = stale.length + staleTranscripts.length + incompleteWorkItems.length + doneWorkItems.length;
+  const total = stale.length + staleTranscripts.length + unclaimedTranscripts.length + incompleteWorkItems.length + doneWorkItems.length;
   const hintLines = [];
   if (stale.length > 0) hintLines.push(`stale_pages: ${stale.length}`, ...stale.map((p) => `  ${p.page}: ${p.reason}`));
   if (staleTranscripts.length > 0) hintLines.push(`stale_transcripts: ${staleTranscripts.length}`, ...staleTranscripts.map((t) => `  ${t.path}: ${t.reason}`));
+  if (unclaimedTranscripts.length > 0) hintLines.push(`unclaimed_transcripts: ${unclaimedTranscripts.length}`, ...unclaimedTranscripts.map((t) => `  ${t.path}: ${t.reason}${t.hint ? `
+    hint: ${t.hint}` : ""}`));
   if (incompleteWorkItems.length > 0) hintLines.push(`incomplete_work_items: ${incompleteWorkItems.length}`, ...incompleteWorkItems.map((w) => `  ${w.path}: ${w.reason}`));
   if (doneWorkItems.length > 0) hintLines.push(`done_work_items: ${doneWorkItems.length}`, ...doneWorkItems.map((w) => `  ${w.path}: ${w.reason}`));
   if (archived.length > 0) hintLines.push(`archived: ${archived.length}`, ...archived.map((a) => `  ${a}`));
   if (hintLines.length === 0) hintLines.push("no stale transcripts or incomplete work items");
   return { exitCode: total > 0 ? ExitCode.STALE_PAGE : ExitCode.OK, result: ok({
-    stale: [...stale, ...staleTranscripts.map((t) => ({ page: t.path, reason: t.reason })), ...incompleteWorkItems.map((w) => ({ page: w.path, reason: w.reason })), ...doneWorkItems.map((w) => ({ page: w.path, reason: w.reason }))],
+    stale: [...stale, ...staleTranscripts.map((t) => ({ page: t.path, reason: t.reason })), ...unclaimedTranscripts.map((t) => ({ page: t.path, reason: t.reason })), ...incompleteWorkItems.map((w) => ({ page: w.path, reason: w.reason })), ...doneWorkItems.map((w) => ({ page: w.path, reason: w.reason }))],
     stale_transcripts: staleTranscripts,
+    unclaimed_transcripts: unclaimedTranscripts,
     incomplete_work_items: incompleteWorkItems,
     done_work_items: doneWorkItems,
     archived,
@@ -2005,6 +2103,104 @@ async function runStale(input) {
   }) };
 }
 
+// src/commands/claim.ts
+import { mkdir as mkdir7, writeFile as writeFile6, readFile as readFile11 } from "fs/promises";
+import { existsSync as existsSync2, statSync } from "fs";
+import { join as join14 } from "path";
+function extractDate(filename) {
+  const m = filename.match(/^(\d{4}-\d{2}-\d{2})/);
+  return m?.[1] ?? "";
+}
+function extractSlugFromFilename(filename) {
+  return filename.replace(/^\d{4}-\d{2}-\d{2}-/, "").replace(/^(task|bug|idea|note|observation)-/, "").replace(/\.md$/, "");
+}
+function extractProjectSlug(projectField) {
+  return projectField.replace(/^\[\[/, "").replace(/\]\]$/, "").replace(/^"|"$/g, "");
+}
+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);
+  if (!existsSync2(absTranscript)) {
+    return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: input.transcript }) };
+  }
+  const content = await readFile11(absTranscript, "utf8");
+  const fm = extractFrontmatter(content);
+  let projectSlug = input.project;
+  if (!projectSlug && fm.ok && typeof fm.data.project === "string") {
+    projectSlug = extractProjectSlug(fm.data.project);
+  }
+  if (!projectSlug) {
+    return {
+      exitCode: ExitCode.SCHEME_REJECTED,
+      result: err("SCHEME_REJECTED", { message: "No project specified. Use --project or set project in transcript frontmatter." })
+    };
+  }
+  const projectDir = join14(input.vault, "projects", projectSlug);
+  if (!existsSync2(projectDir) || !statSync(projectDir).isDirectory()) {
+    return {
+      exitCode: ExitCode.PROJECT_NOT_FOUND,
+      result: err("PROJECT_NOT_FOUND", { project: projectSlug })
+    };
+  }
+  const filename = input.transcript.split("/").pop();
+  const date = extractDate(filename);
+  if (!date) {
+    return {
+      exitCode: ExitCode.SCHEME_REJECTED,
+      result: err("SCHEME_REJECTED", { message: `Cannot extract date from filename: ${filename}` })
+    };
+  }
+  const workSlug = input.slug || extractSlugFromFilename(filename);
+  const dirName = `${date}-${workSlug}`;
+  const workDir = join14(projectDir, "work", dirName);
+  const relWorkDir = `projects/${projectSlug}/work/${dirName}`;
+  const relSpecPath = `${relWorkDir}/spec.md`;
+  if (existsSync2(workDir)) {
+    return {
+      exitCode: ExitCode.OK,
+      result: ok({
+        workItemPath: relWorkDir,
+        specPath: relSpecPath,
+        source: input.transcript,
+        humanHint: `work item already exists: ${relWorkDir}`
+      })
+    };
+  }
+  await mkdir7(workDir, { recursive: true });
+  const kind = fm.ok && typeof fm.data.kind === "string" ? fm.data.kind : "task";
+  const specLines = [
+    "---",
+    `source: ${input.transcript}`,
+    `status: planned`,
+    `kind: ${kind}`,
+    `created: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`,
+    "---",
+    "",
+    `# ${workSlug}`,
+    "",
+    `Claimed from ${input.transcript}`,
+    ""
+  ];
+  await writeFile6(join14(workDir, "spec.md"), specLines.join("\n"), "utf8");
+  appendLastOp(input.vault, {
+    operation: "claim",
+    summary: `claimed ${input.transcript} \u2192 ${relWorkDir}`,
+    files: [relSpecPath],
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    exitCode: ExitCode.OK,
+    result: ok({
+      workItemPath: relWorkDir,
+      specPath: relSpecPath,
+      source: input.transcript,
+      humanHint: `claimed ${input.transcript} \u2192 ${relWorkDir}`
+    })
+  };
+}
+
 // src/commands/pagesize.ts
 async function runPagesize(input) {
   const scan = await scanVault(input.vault);
@@ -2022,19 +2218,19 @@ async function runPagesize(input) {
 }
 
 // src/commands/log-rotate.ts
-import { readFile as readFile11, rename as rename3, writeFile as writeFile6, stat as stat5 } from "fs/promises";
-import { join as join14 } from "path";
+import { readFile as readFile12, rename as rename3, writeFile as writeFile7, stat as stat5 } from "fs/promises";
+import { join as join15 } from "path";
 var ENTRY_RE = /^## \[(\d{4})-\d{2}-\d{2}\]/gm;
 async function runLogRotate(input) {
   try {
-    await stat5(join14(input.vault, "SCHEMA.md"));
+    await stat5(join15(input.vault, "SCHEMA.md"));
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
-  const logPath = join14(input.vault, "log.md");
+  const logPath = join15(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile11(logPath, "utf8");
+    logText = await readFile12(logPath, "utf8");
   } catch {
     return { exitCode: ExitCode.FILE_NOT_FOUND, result: err("FILE_NOT_FOUND", { path: logPath }) };
   }
@@ -2051,7 +2247,7 @@ async function runLogRotate(input) {
   }
   const newestYear = matches[matches.length - 1][1];
   const rotatedName = `log-${newestYear}.md`;
-  const rotatedPath = join14(input.vault, rotatedName);
+  const rotatedPath = join15(input.vault, rotatedName);
   try {
     await rename3(logPath, rotatedPath);
     const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -2063,7 +2259,7 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
 
 - Previous log moved to ${rotatedName}
 `;
-    await writeFile6(logPath, fresh, "utf8");
+    await writeFile7(logPath, fresh, "utf8");
   } catch (e) {
     return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { message: String(e) }) };
   }
@@ -2077,9 +2273,9 @@ Chronological action log. Newest entries last. Skill writes append entries; lint
 }
 
 // src/commands/lint.ts
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile13, writeFile as writeFile7 } from "fs/promises";
-import { join as join17 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
+import { join as join18 } from "path";
 
 // src/commands/topic-map-check.ts
 var DEFAULT_THRESHOLD = 200;
@@ -2101,13 +2297,13 @@ async function runTopicMapCheck(input) {
 }
 
 // src/commands/index-link-format.ts
-import { readFile as readFile12 } from "fs/promises";
-import { join as join15 } from "path";
+import { readFile as readFile13 } from "fs/promises";
+import { join as join16 } from "path";
 var MD_LINK_RE = /\[[^\[\]]+\]\([^)]+\.md\)/;
 async function runIndexLinkFormat(input) {
   let text = "";
   try {
-    text = await readFile12(join15(input.vault, "index.md"), "utf8");
+    text = await readFile13(join16(input.vault, "index.md"), "utf8");
   } catch {
   }
   const markdown_links = [];
@@ -2121,7 +2317,7 @@ ${markdown_links.map((l) => `  line ${l.line}: ${l.text}`).join("\n")}`;
 
 // src/commands/dedup.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2 } from "fs";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function runDedup(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -2149,7 +2345,7 @@ async function runDedup(input) {
       }
     }
     for (const page of scan.data.typedKnowledge) {
-      const text = readFileSync3(join16(input.vault, page.relPath), "utf-8");
+      const text = readFileSync3(join17(input.vault, page.relPath), "utf-8");
       let updated = text;
       let changed = false;
       for (const [oldPath, newPath] of replacements) {
@@ -2167,12 +2363,12 @@ async function runDedup(input) {
         }
       }
       if (changed) {
-        writeFileSync2(join16(input.vault, page.relPath), updated);
+        writeFileSync2(join17(input.vault, page.relPath), updated);
         rewired.push(page.relPath);
       }
     }
     for (const [oldPath] of replacements) {
-      const fullPath = join16(input.vault, oldPath);
+      const fullPath = join17(input.vault, oldPath);
       try {
         unlinkSync2(fullPath);
         removed.push(oldPath);
@@ -2268,7 +2464,7 @@ async function runLint(input) {
   const staleResult = await runStale({ vault: input.vault, days: input.days });
   if (staleResult.result.ok) {
     const st = staleResult.result.data;
-    const staleList = [...st.stale_transcripts.map((t) => t.path), ...st.incomplete_work_items.map((w) => w.path), ...(st.done_work_items ?? []).map((w) => w.path)];
+    const staleList = [...st.stale_transcripts.map((t) => t.path), ...(st.unclaimed_transcripts ?? []).map((t) => t.path), ...st.incomplete_work_items.map((w) => w.path), ...(st.done_work_items ?? []).map((w) => w.path)];
     if (staleList.length > 0) buckets.stale_page = staleList;
   }
   const pagesize = await runPagesize({ vault: input.vault, lines: input.lines });
@@ -2319,7 +2515,7 @@ async function runLint(input) {
         let rawPath = entry.replace(/^"/, "").replace(/"$/, "").replace(/^'/, "").replace(/'$/, "");
         rawPath = rawPath.replace(/^\^\[/, "").replace(/\]$/, "");
         if (!rawPath.startsWith("raw/") && !rawPath.startsWith("_archive/raw/")) continue;
-        if (!existsSync2(join17(input.vault, rawPath)) && !existsSync2(join17(input.vault, rawPath + ".md")) && !rawPath.startsWith("_archive/") && !existsSync2(join17(input.vault, "_archive", rawPath)) && !existsSync2(join17(input.vault, "_archive", rawPath + ".md"))) {
+        if (!existsSync3(join18(input.vault, rawPath)) && !existsSync3(join18(input.vault, rawPath + ".md")) && !rawPath.startsWith("_archive/") && !existsSync3(join18(input.vault, "_archive", rawPath)) && !existsSync3(join18(input.vault, "_archive", rawPath + ".md"))) {
           brokenSourceFlags.push(`${page.relPath}: ${rawPath}`);
         }
       }
@@ -2404,11 +2600,11 @@ async function runLint(input) {
         const slugMatch = String(entry).match(/\[\[([^\]]+)\]\]/);
         if (!slugMatch) continue;
         const slug = slugMatch[1];
-        const knowledgePath = join17(input.vault, "projects", slug, "knowledge.md");
-        if (!existsSync2(knowledgePath)) continue;
+        const knowledgePath = join18(input.vault, "projects", slug, "knowledge.md");
+        if (!existsSync3(knowledgePath)) continue;
         const pageRef = page.relPath.replace(/\.md$/, "");
         try {
-          const knowledgeContent = await readFile13(knowledgePath, "utf8");
+          const knowledgeContent = await readFile14(knowledgePath, "utf8");
           if (!knowledgeContent.includes(`[[${pageRef}]]`)) {
             orphanedProjectPages.push(`${page.relPath}: not in projects/${slug}/knowledge.md`);
           }
@@ -2423,7 +2619,7 @@ async function runLint(input) {
       for (const relPath of legacyPages) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
+          const raw = await readFile14(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -2501,7 +2697,7 @@ async function runLint(input) {
 ${rawFm}
 ---
 ${newBody}`;
-          await writeFile7(absPath, newContent, "utf8");
+          await writeFile8(absPath, newContent, "utf8");
           fixed.push(relPath);
         } catch {
           unresolved.push(relPath);
@@ -2518,7 +2714,7 @@ ${newBody}`;
       for (const relPath of noOverview) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
+          const raw = await readFile14(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -2539,7 +2735,7 @@ ${rawFm}
 ${overviewSection}
 
 ${trimmedBody}`;
-          await writeFile7(absPath, newContent, "utf8");
+          await writeFile8(absPath, newContent, "utf8");
           fixed.push(relPath);
         } catch {
           unresolved.push(relPath);
@@ -2555,7 +2751,7 @@ ${trimmedBody}`;
       for (const relPath of missingTldrFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
+          const raw = await readFile14(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -2573,7 +2769,7 @@ ${rawFm}
 - Pending summary.
 
 ${trimmedBody}`;
-          await writeFile7(absPath, newContent, "utf8");
+          await writeFile8(absPath, newContent, "utf8");
           fixed.push(relPath);
         } catch {
           unresolved.push(relPath);
@@ -2591,7 +2787,7 @@ ${trimmedBody}`;
       for (const relPath of wikilinkCitationFlags) {
         try {
           const absPath = `${input.vault}/${relPath}`;
-          const raw = await readFile13(absPath, "utf8");
+          const raw = await readFile14(absPath, "utf8");
           const split = splitFrontmatter(raw);
           if (!split.ok) {
             unresolved.push(relPath);
@@ -2655,7 +2851,7 @@ ${trimmedBody}`;
 ${rawFm}
 ---
 ${newBody}`;
-          await writeFile7(absPath, newContent, "utf8");
+          await writeFile8(absPath, newContent, "utf8");
           wikilinkFixed.push(relPath);
         } catch {
           unresolved.push(relPath);
@@ -2712,14 +2908,14 @@ ${newBody}`;
 }
 
 // src/commands/config.ts
-import { readFile as readFile14 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import { join as join18 } from "path";
+import { readFile as readFile15 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join19 } from "path";
 function validateKey(key) {
   return CONFIG_KEYS.includes(key) || isValidWikiProfileKey(key);
 }
 function configPath(home) {
-  return join18(home, ".skillwiki", ".env");
+  return join19(home, ".skillwiki", ".env");
 }
 async function runConfigGet(input) {
   if (!validateKey(input.key)) {
@@ -2737,7 +2933,7 @@ async function runConfigSet(input) {
   try {
     let originalContent;
     try {
-      originalContent = await readFile14(filePath, "utf8");
+      originalContent = await readFile15(filePath, "utf8");
     } catch {
     }
     const existing = originalContent !== void 0 ? parseDotenvText(originalContent) : {};
@@ -2769,17 +2965,17 @@ async function runConfigList(input) {
 }
 async function runConfigPath(input) {
   const filePath = configPath(input.home);
-  return { exitCode: ExitCode.OK, result: ok({ path: filePath, exists: existsSync3(filePath), humanHint: filePath }) };
+  return { exitCode: ExitCode.OK, result: ok({ path: filePath, exists: existsSync4(filePath), humanHint: filePath }) };
 }
 
 // src/commands/doctor.ts
-import { existsSync as existsSync5, lstatSync, readlinkSync, readdirSync, statSync } from "fs";
-import { join as join21, resolve as resolve4 } from "path";
+import { existsSync as existsSync6, lstatSync, readlinkSync, readdirSync, statSync as statSync2 } from "fs";
+import { join as join22, resolve as resolve4 } from "path";
 import { execSync } from "child_process";
 
 // src/utils/auto-update.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
-import { join as join19, dirname as dirname8 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { join as join20, dirname as dirname8 } from "path";
 import { spawn } from "child_process";
 
 // src/utils/update-consts.ts
@@ -2790,7 +2986,7 @@ var CLI_DISABLE_FLAG = "--no-update-notifier";
 
 // src/utils/auto-update.ts
 function cachePath(home) {
-  return join19(home, ".skillwiki", CACHE_FILENAME);
+  return join20(home, ".skillwiki", CACHE_FILENAME);
 }
 function readCacheRaw(home) {
   try {
@@ -2828,7 +3024,7 @@ function triggerAutoUpdate(home, currentVersion) {
   const { isStale } = readCache(home);
   if (!isStale) return;
   const bgScript = new URL("../auto-update-bg.js", import.meta.url).pathname;
-  if (!existsSync4(bgScript)) return;
+  if (!existsSync5(bgScript)) return;
   const child = spawn(process.execPath, [bgScript, home, currentVersion], {
     detached: true,
     stdio: "ignore"
@@ -2840,12 +3036,12 @@ function triggerAutoUpdate(home, currentVersion) {
 
 // src/utils/plugin-registry.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { join as join20 } from "path";
-var REGISTRY_PATH = join20(".claude", "plugins", "installed_plugins.json");
+import { join as join21 } from "path";
+var REGISTRY_PATH = join21(".claude", "plugins", "installed_plugins.json");
 var PLUGIN_KEY = "skillwiki@llm-wiki";
 function readInstalledPlugins(home) {
   try {
-    const raw = readFileSync5(join20(home, REGISTRY_PATH), "utf8");
+    const raw = readFileSync5(join21(home, REGISTRY_PATH), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -2888,13 +3084,13 @@ function detectCliChannels(argv, home) {
   }
   const plugin = findPlugin(home);
   if (plugin) {
-    const pluginBin = join21(plugin.installPath, "bin", "skillwiki");
-    if (existsSync5(pluginBin)) {
+    const pluginBin = join22(plugin.installPath, "bin", "skillwiki");
+    if (existsSync6(pluginBin)) {
       channels.push({ name: "plugin", path: pluginBin, isDevLink: false });
     }
   }
-  const installBin = join21(home, ".claude", "skills", "bin", "skillwiki");
-  if (existsSync5(installBin)) {
+  const installBin = join22(home, ".claude", "skills", "bin", "skillwiki");
+  if (existsSync6(installBin)) {
     channels.push({ name: "install", path: installBin, isDevLink: false });
   }
   return channels;
@@ -2946,7 +3142,7 @@ function checkCliChannels(argv, home) {
 }
 async function checkConfigFile(home) {
   const cfgPath = configPath(home);
-  if (!existsSync5(cfgPath)) {
+  if (!existsSync6(cfgPath)) {
     return check("warn", "config_file", "Config file exists", `${cfgPath} not found`);
   }
   try {
@@ -2961,7 +3157,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 (existsSync5(resolvedPath) && statSync(resolvedPath).isDirectory()) {
+  if (existsSync6(resolvedPath) && statSync2(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`);
@@ -2970,13 +3166,13 @@ function checkVaultStructure(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync5(resolvedPath)) {
+  if (!existsSync6(resolvedPath)) {
     return check("error", "vault_structure", "Vault structure valid", "Cannot check \u2014 vault directory does not exist");
   }
   const missing = [];
-  if (!existsSync5(join21(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
+  if (!existsSync6(join22(resolvedPath, "SCHEMA.md"))) missing.push("SCHEMA.md");
   for (const dir of ["raw", "entities", "concepts", "meta"]) {
-    if (!existsSync5(join21(resolvedPath, dir))) missing.push(dir + "/");
+    if (!existsSync6(join22(resolvedPath, dir))) missing.push(dir + "/");
   }
   if (missing.length === 0) {
     return check("pass", "vault_structure", "Vault structure valid", "All required files and directories present");
@@ -2984,8 +3180,8 @@ function checkVaultStructure(resolvedPath) {
   return check("warn", "vault_structure", "Vault structure valid", `Missing: ${missing.join(", ")} \u2014 run \`skillwiki init\` to add CodeWiki structure`);
 }
 function checkSkillsInstalled(home, cwd) {
-  const srcDir = cwd ? join21(cwd, "packages", "skills") : void 0;
-  if (srcDir && existsSync5(srcDir)) {
+  const srcDir = cwd ? join22(cwd, "packages", "skills") : void 0;
+  if (srcDir && existsSync6(srcDir)) {
     const found = findSkillMd(srcDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (source)`);
@@ -2998,8 +3194,8 @@ function checkSkillsInstalled(home, cwd) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (plugin v${plugin.version})`);
     }
   }
-  const skillsDir = join21(home, ".claude", "skills");
-  if (existsSync5(skillsDir)) {
+  const skillsDir = join22(home, ".claude", "skills");
+  if (existsSync6(skillsDir)) {
     const found = findSkillMd(skillsDir);
     if (found.length > 0) {
       return check("pass", "skills_installed", "Skills installed", `${found.length} SKILL.md file(s) found (CLI install)`);
@@ -3009,10 +3205,10 @@ function checkSkillsInstalled(home, cwd) {
 }
 function checkDuplicateSkills(home) {
   const plugin = findPlugin(home);
-  const skillsDir = join21(home, ".claude", "skills");
+  const skillsDir = join22(home, ".claude", "skills");
   const agentSkillDirs = [
-    { label: "~/.codex/skills/", path: join21(home, ".codex", "skills") },
-    { label: "~/.agents/skills/", path: join21(home, ".agents", "skills") }
+    { label: "~/.codex/skills/", path: join22(home, ".codex", "skills") },
+    { label: "~/.agents/skills/", path: join22(home, ".agents", "skills") }
   ];
   if (!plugin) {
     return check("pass", "skills_duplicate", "Skills not duplicated", "Single install channel");
@@ -3089,8 +3285,8 @@ async function checkProfiles(home) {
 }
 async function checkProjectLocalOverride(cwd) {
   const dir = cwd ?? process.cwd();
-  const envPath = join21(dir, ".skillwiki", ".env");
-  if (existsSync5(envPath)) {
+  const envPath = join22(dir, ".skillwiki", ".env");
+  if (existsSync6(envPath)) {
     return check("pass", "project_local", "Project-local config", `Found: ${envPath}`);
   }
   return check("pass", "project_local", "Project-local config", "None");
@@ -3099,7 +3295,7 @@ function checkVaultGitRemote(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "vault_git_remote", "Vault git remote", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync5(join21(resolvedPath, ".git"))) {
+  if (!existsSync6(join22(resolvedPath, ".git"))) {
     return check("warn", "vault_git_remote", "Vault git remote", "Vault is not a git repository \u2014 sync features unavailable");
   }
   try {
@@ -3122,9 +3318,9 @@ function checkObsidianTemplates(resolvedPath) {
     return check("error", "obsidian_templates", "Obsidian templates", "Cannot check \u2014 WIKI_PATH not resolved");
   }
   const missing = [];
-  if (!existsSync5(join21(resolvedPath, "_Templates"))) missing.push("_Templates/");
-  if (!existsSync5(join21(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
-  if (!existsSync5(join21(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
+  if (!existsSync6(join22(resolvedPath, "_Templates"))) missing.push("_Templates/");
+  if (!existsSync6(join22(resolvedPath, ".obsidian", "templates.json"))) missing.push(".obsidian/templates.json");
+  if (!existsSync6(join22(resolvedPath, ".obsidian", "app.json"))) missing.push(".obsidian/app.json");
   if (missing.length === 0) {
     return check("pass", "obsidian_templates", "Obsidian templates", "Template folder and config present");
   }
@@ -3134,8 +3330,8 @@ function checkDotStoreClean(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "dsstore_clean", "No .DS_Store in raw/", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  const rawDir = join21(resolvedPath, "raw");
-  if (!existsSync5(rawDir)) {
+  const rawDir = join22(resolvedPath, "raw");
+  if (!existsSync6(rawDir)) {
     return check("pass", "dsstore_clean", "No .DS_Store in raw/", "raw/ directory not found \u2014 check skipped");
   }
   const found = [];
@@ -3150,7 +3346,7 @@ function checkDotStoreClean(resolvedPath) {
       if (entry.name === ".DS_Store") {
         found.push(rel ? `${rel}/.DS_Store` : ".DS_Store");
       } else if (entry.isDirectory()) {
-        walk2(join21(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
+        walk2(join22(dir, entry.name), rel ? `${rel}/${entry.name}` : entry.name);
       }
     }
   })(rawDir, "");
@@ -3163,7 +3359,7 @@ function checkSyncLastPush(resolvedPath) {
   if (resolvedPath === void 0) {
     return check("error", "sync_last_push", "Vault sync recency", "Cannot check \u2014 WIKI_PATH not resolved");
   }
-  if (!existsSync5(join21(resolvedPath, ".git"))) {
+  if (!existsSync6(join22(resolvedPath, ".git"))) {
     return check("pass", "sync_last_push", "Vault sync recency", "No git repo \u2014 sync check skipped");
   }
   let timestamp;
@@ -3205,9 +3401,9 @@ function findSkillMd(dir) {
   }
   for (const entry of entries) {
     if (entry.isFile() && entry.name === "SKILL.md") {
-      results.push(join21(dir, entry.name));
+      results.push(join22(dir, entry.name));
     } else if (entry.isDirectory()) {
-      results.push(...findSkillMd(join21(dir, entry.name)));
+      results.push(...findSkillMd(join22(dir, entry.name)));
     }
   }
   return results;
@@ -3221,7 +3417,7 @@ function findSkillNames(dir) {
     return results;
   }
   for (const entry of entries) {
-    if (entry.isDirectory() && existsSync5(join21(dir, entry.name, "SKILL.md"))) {
+    if (entry.isDirectory() && existsSync6(join22(dir, entry.name, "SKILL.md"))) {
       results.push(entry.name);
     }
   }
@@ -3274,8 +3470,8 @@ async function runDoctor(input) {
 }
 
 // src/commands/archive.ts
-import { rename as rename4, mkdir as mkdir7, readFile as readFile15, writeFile as writeFile8 } from "fs/promises";
-import { join as join22, dirname as dirname9 } from "path";
+import { rename as rename4, mkdir as mkdir8, readFile as readFile16, writeFile as writeFile9 } from "fs/promises";
+import { join as join23, dirname as dirname9 } from "path";
 async function runArchive(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -3291,25 +3487,25 @@ 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 archivePath = join22("_archive", relPath).replace(/\\/g, "/");
-  await mkdir7(dirname9(join22(input.vault, archivePath)), { recursive: true });
+  const archivePath = join23("_archive", relPath).replace(/\\/g, "/");
+  await mkdir8(dirname9(join23(input.vault, archivePath)), { recursive: true });
   let indexUpdated = false;
   if (!isRaw) {
-    const indexPath = join22(input.vault, "index.md");
+    const indexPath = join23(input.vault, "index.md");
     try {
-      const idx = await readFile15(indexPath, "utf8");
+      const idx = await readFile16(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 writeFile8(indexPath, filtered.join("\n"), "utf8");
+        await writeFile9(indexPath, filtered.join("\n"), "utf8");
         indexUpdated = true;
       }
     } catch (e) {
       if (e instanceof Error && "code" in e && e.code !== "ENOENT") throw e;
     }
   }
-  await rename4(join22(input.vault, relPath), join22(input.vault, archivePath));
+  await rename4(join23(input.vault, relPath), join23(input.vault, archivePath));
   appendLastOp(input.vault, {
     operation: "archive",
     summary: `moved ${relPath} to ${archivePath}`,
@@ -3321,7 +3517,7 @@ async function runArchive(input) {
 
 // src/commands/drift.ts
 import { createHash as createHash2 } from "crypto";
-import { writeFile as writeFile9 } from "fs/promises";
+import { writeFile as writeFile10 } from "fs/promises";
 
 // src/utils/fetch.ts
 async function controlledFetch(url, opts) {
@@ -3408,7 +3604,7 @@ async function runDrift(input) {
 ${newFm}
 ---
 ${body}`;
-      await writeFile9(raw.absPath, newText, "utf8");
+      await writeFile10(raw.absPath, newText, "utf8");
       results.push({
         raw_path: raw.relPath,
         source_url: sourceUrl,
@@ -3451,7 +3647,7 @@ ${body}`;
 }
 
 // src/commands/migrate-citations.ts
-import { writeFile as writeFile10 } from "fs/promises";
+import { writeFile as writeFile11 } from "fs/promises";
 var MARKER_RE2 = /\^\[(raw\/[^\]]+)\]/g;
 function moveMarkersToParagraphEnd(body) {
   const lines = body.split("\n");
@@ -3574,7 +3770,7 @@ ${migratedBody}${newFooter}`;
       continue;
     }
     if (!input.dryRun) {
-      await writeFile10(page.absPath, newText, "utf8");
+      await writeFile11(page.absPath, newText, "utf8");
     }
     migrated.push(page.relPath);
   }
@@ -3604,7 +3800,7 @@ ${migratedBody}${newFooter}`;
 }
 
 // src/commands/frontmatter-fix.ts
-import { writeFile as writeFile11 } from "fs/promises";
+import { writeFile as writeFile12 } from "fs/promises";
 function isoToday() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
@@ -3646,7 +3842,7 @@ ${newBody}`;
       continue;
     }
     if (!input.dryRun) {
-      await writeFile11(page.absPath, newText, "utf8");
+      await writeFile12(page.absPath, newText, "utf8");
     }
     fixed.push(page.relPath);
   }
@@ -3679,14 +3875,14 @@ ${newBody}`;
 // src/commands/update.ts
 import { execSync as execSync2 } from "child_process";
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function resolveGlobalSkillsRoot() {
   try {
     const globalRoot = execSync2("npm root -g", {
       encoding: "utf8",
       timeout: 5e3
     }).trim();
-    return join23(globalRoot, "skillwiki", "skills");
+    return join24(globalRoot, "skillwiki", "skills");
   } catch {
     return null;
   }
@@ -3712,7 +3908,7 @@ async function runUpdate(input) {
   );
   const currentVersion = pkg2.version;
   const tag = input.distTag ?? "latest";
-  const target = join23(input.home, ".claude", "skills");
+  const target = join24(input.home, ".claude", "skills");
   let latest;
   try {
     latest = execSync2(`npm view skillwiki@${tag} version`, {
@@ -3782,16 +3978,16 @@ async function runUpdate(input) {
 
 // src/commands/self-update.ts
 import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
+import { join as join25 } from "path";
 var DEFAULT_SOURCE_ROOT_SUFFIX = "/Desktop/code/llm-wiki";
 async function runSelfUpdate(input) {
   const currentVersion = JSON.parse(
     readFileSync7(new URL("../../package.json", import.meta.url), "utf8")
   ).version;
   const sourceRoot = input.sourceRoot ?? `${input.home}${DEFAULT_SOURCE_ROOT_SUFFIX}`;
-  const localPkgPath = join24(sourceRoot, "packages", "cli", "package.json");
-  const hasLocalSource = existsSync6(localPkgPath);
+  const localPkgPath = join25(sourceRoot, "packages", "cli", "package.json");
+  const hasLocalSource = existsSync7(localPkgPath);
   if (input.check) {
     let availableVersion = null;
     let source;
@@ -3922,10 +4118,10 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir5, stat as stat6, readFile as readFile16 } from "fs/promises";
-import { join as join25 } from "path";
+import { readdir as readdir5, stat as stat6, readFile as readFile17 } from "fs/promises";
+import { join as join26 } from "path";
 async function runTranscripts(input) {
-  const dir = join25(input.vault, "raw", "transcripts");
+  const dir = join26(input.vault, "raw", "transcripts");
   let entries;
   try {
     entries = await readdir5(dir, { withFileTypes: true });
@@ -3935,8 +4131,8 @@ async function runTranscripts(input) {
   const transcripts = [];
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join25(dir, entry.name);
-    const content = await readFile16(filePath, "utf8");
+    const filePath = join26(dir, entry.name);
+    const content = await readFile17(filePath, "utf8");
     const fm = extractFrontmatter(content);
     if (!fm.ok) continue;
     const ingested = typeof fm.data.ingested === "string" ? fm.data.ingested : "";
@@ -3953,12 +4149,12 @@ async function runTranscripts(input) {
 }
 
 // src/commands/project-index.ts
-import { readdir as readdir6, readFile as readFile17, writeFile as writeFile12, mkdir as mkdir8 } from "fs/promises";
-import { join as join26, dirname as dirname10 } from "path";
+import { readdir as readdir6, readFile as readFile18, writeFile as writeFile13, mkdir as mkdir9 } from "fs/promises";
+import { join as join27, dirname as dirname10 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 async function runProjectIndex(input) {
   const slug = input.slug;
-  const projectDir = join26(input.vault, "projects", slug);
+  const projectDir = join27(input.vault, "projects", slug);
   try {
     await readdir6(projectDir);
   } catch {
@@ -3969,15 +4165,15 @@ async function runProjectIndex(input) {
   }
   const wikilinkPattern = `[[${slug}]]`;
   const entries = [];
-  const compoundDir = join26(input.vault, "projects", slug, "compound");
+  const compoundDir = join27(input.vault, "projects", slug, "compound");
   try {
     const compoundFiles = await readdir6(compoundDir, { withFileTypes: true });
     for (const entry of compoundFiles) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join26(compoundDir, entry.name);
+      const filePath = join27(compoundDir, entry.name);
       let text;
       try {
-        text = await readFile17(filePath, "utf8");
+        text = await readFile18(filePath, "utf8");
       } catch {
         continue;
       }
@@ -3994,16 +4190,16 @@ async function runProjectIndex(input) {
   for (const dir of LAYER2_DIRS) {
     let files;
     try {
-      files = await readdir6(join26(input.vault, dir), { withFileTypes: true });
+      files = await readdir6(join27(input.vault, dir), { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of files) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const filePath = join26(input.vault, dir, entry.name);
+      const filePath = join27(input.vault, dir, entry.name);
       let text;
       try {
-        text = await readFile17(filePath, "utf8");
+        text = await readFile18(filePath, "utf8");
       } catch {
         continue;
       }
@@ -4024,11 +4220,11 @@ async function runProjectIndex(input) {
     const tb = typeOrder[b.type] ?? 99;
     return ta !== tb ? ta - tb : a.title.localeCompare(b.title);
   });
-  const indexPath = join26(projectDir, "knowledge.md");
+  const indexPath = join27(projectDir, "knowledge.md");
   let existing = false;
   let stale = false;
   try {
-    const existingText = await readFile17(indexPath, "utf8");
+    const existingText = await readFile18(indexPath, "utf8");
     existing = true;
     const existingEntries = existingText.split("\n").filter((l) => l.startsWith("- [["));
     const existingPages = new Set(existingEntries.map((l) => {
@@ -4068,8 +4264,8 @@ Autogenerated by \`skillwiki project-index\` on ${today}.
   }
   if (input.apply) {
     try {
-      await mkdir8(dirname10(indexPath), { recursive: true });
-      await writeFile12(indexPath, body, "utf8");
+      await mkdir9(dirname10(indexPath), { recursive: true });
+      await writeFile13(indexPath, body, "utf8");
     } catch (e) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
@@ -4097,10 +4293,10 @@ ${entries.map((e) => `  ${e.type}: [[${e.page.replace(/\.md$/, "")}]] \u2014 ${e
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile13, mkdir as mkdir9, readdir as readdir7, unlink as unlink2 } from "fs/promises";
-import { join as join27 } from "path";
-import { existsSync as existsSync7 } from "fs";
-import { readFile as readFile18 } from "fs/promises";
+import { writeFile as writeFile14, mkdir as mkdir10, readdir as readdir7, unlink as unlink2 } from "fs/promises";
+import { join as join28 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { readFile as readFile19 } 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,
@@ -4198,17 +4394,17 @@ function extractRetroFields(date, cycleName, block) {
   };
 }
 async function runCompound(input) {
-  const logPath = join27(input.vault, "log.md");
+  const logPath = join28(input.vault, "log.md");
   let logText;
   try {
-    logText = await readFile18(logPath, "utf8");
+    logText = await readFile19(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 = join27(input.vault, "projects", input.project, "compound");
+  const compoundDir = join28(input.vault, "projects", input.project, "compound");
   for (const entry of entries) {
     const generalizeValue = entry.generalize.trim();
     if (!/^yes/i.test(generalizeValue)) {
@@ -4216,8 +4412,8 @@ async function runCompound(input) {
       continue;
     }
     const slug = slugify(entry.cycleName);
-    const compoundPath = join27(compoundDir, `${slug}.md`);
-    if (existsSync7(compoundPath)) {
+    const compoundPath = join28(compoundDir, `${slug}.md`);
+    if (existsSync8(compoundPath)) {
       skipped.push(entry.date);
       continue;
     }
@@ -4255,10 +4451,10 @@ async function runCompound(input) {
     ].join("\n");
     const content = frontmatter + "\n" + body;
     if (!input.dryRun) {
-      if (!existsSync7(compoundDir)) {
-        await mkdir9(compoundDir, { recursive: true });
+      if (!existsSync8(compoundDir)) {
+        await mkdir10(compoundDir, { recursive: true });
       }
-      await writeFile13(compoundPath, content, "utf8");
+      await writeFile14(compoundPath, content, "utf8");
     }
     promoted.push(`${slug}.md`);
   }
@@ -4277,16 +4473,16 @@ async function runCompound(input) {
   };
 }
 async function runCompoundDelete(input) {
-  const projectDir = join27(input.vault, "projects", input.project);
-  if (!existsSync7(projectDir)) {
+  const projectDir = join28(input.vault, "projects", input.project);
+  if (!existsSync8(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 = join27(projectDir, "compound", `${entryName}.md`);
-  if (!existsSync7(compoundPath)) {
+  const compoundPath = join28(projectDir, "compound", `${entryName}.md`);
+  if (!existsSync8(compoundPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", { path: compoundPath })
@@ -4319,8 +4515,8 @@ knowledge.md regenerated`
   };
 }
 async function runCompoundList(input) {
-  const compoundDir = join27(input.vault, "projects", input.project, "compound");
-  if (!existsSync7(compoundDir)) {
+  const compoundDir = join28(input.vault, "projects", input.project, "compound");
+  if (!existsSync8(compoundDir)) {
     return {
       exitCode: ExitCode.OK,
       result: ok({
@@ -4350,10 +4546,10 @@ could not read compound directory`
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isFile() || !dirent.name.endsWith(".md")) continue;
-    const filePath = join27(compoundDir, dirent.name);
+    const filePath = join28(compoundDir, dirent.name);
     let text;
     try {
-      text = await readFile18(filePath, "utf8");
+      text = await readFile19(filePath, "utf8");
     } catch {
       continue;
     }
@@ -4382,9 +4578,9 @@ no compound entries found`;
 }
 
 // src/commands/observe.ts
-import { mkdir as mkdir10, writeFile as writeFile14 } from "fs/promises";
-import { existsSync as existsSync8, statSync as statSync2 } from "fs";
-import { join as join28 } from "path";
+import { mkdir as mkdir11, writeFile as writeFile15 } from "fs/promises";
+import { existsSync as existsSync9, statSync as statSync3 } from "fs";
+import { join as join29 } from "path";
 import { createHash as createHash3 } from "crypto";
 var ALLOWED_KINDS = /* @__PURE__ */ new Set(["note", "bug", "task", "idea", "session-log"]);
 function slugify2(text) {
@@ -4392,7 +4588,7 @@ function slugify2(text) {
   return words || "untitled";
 }
 async function runObserve(input) {
-  const kind = input.kind || "note";
+  const kind = input.kind || "task";
   if (!ALLOWED_KINDS.has(kind)) {
     return {
       exitCode: ExitCode.SCHEME_REJECTED,
@@ -4407,15 +4603,15 @@ async function runObserve(input) {
       result: err("SCHEME_REJECTED", { message: "Text must not be empty" })
     };
   }
-  if (!existsSync8(input.vault) || !statSync2(input.vault).isDirectory()) {
+  if (!existsSync9(input.vault) || !statSync3(input.vault).isDirectory()) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("VAULT_PATH_INVALID", { path: input.vault })
     };
   }
-  const transcriptsDir = join28(input.vault, "raw", "transcripts");
+  const transcriptsDir = join29(input.vault, "raw", "transcripts");
   try {
-    await mkdir10(transcriptsDir, { recursive: true });
+    await mkdir11(transcriptsDir, { recursive: true });
   } catch {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
@@ -4425,7 +4621,7 @@ async function runObserve(input) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const slug = slugify2(input.text);
   const fileName = `${today}-observation-${slug}.md`;
-  const filePath = join28(transcriptsDir, fileName);
+  const filePath = join29(transcriptsDir, fileName);
   const body = `
 ${input.text.trim()}
 `;
@@ -4443,7 +4639,7 @@ ${input.text.trim()}
   frontmatterLines.push("---");
   const content = frontmatterLines.join("\n") + body;
   try {
-    await writeFile14(filePath, content, "utf8");
+    await writeFile15(filePath, content, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -4465,8 +4661,8 @@ ${input.text.trim()}
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile19, writeFile as writeFile15, mkdir as mkdir11 } from "fs/promises";
-import { join as join29 } from "path";
+import { readFile as readFile20, writeFile as writeFile16, mkdir as mkdir12 } from "fs/promises";
+import { join as join30 } from "path";
 import { createHash as createHash4 } from "crypto";
 var ALLOWED_TYPES = /* @__PURE__ */ new Set(["entity", "concept", "comparison", "query"]);
 var TYPE_DIR = {
@@ -4625,7 +4821,7 @@ async function runIngest(input) {
     sourceContent = fetchResult.data.body;
   } else {
     try {
-      sourceContent = await readFile19(input.source, "utf8");
+      sourceContent = await readFile20(input.source, "utf8");
     } catch {
       return {
         exitCode: ExitCode.FILE_NOT_FOUND,
@@ -4640,8 +4836,8 @@ 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 = join29(input.vault, rawRelPath);
-  const typedAbsPath = join29(input.vault, typedRelPath);
+  const rawAbsPath = join30(input.vault, rawRelPath);
+  const typedAbsPath = join30(input.vault, typedRelPath);
   const rawContent = buildRawContent(sourceUrl, today, sha256, sourceContent);
   const typedContent = buildTypedContent(
     input.title,
@@ -4704,8 +4900,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir11(join29(input.vault, "raw", "articles"), { recursive: true });
-    await writeFile15(rawAbsPath, rawContent, "utf8");
+    await mkdir12(join30(input.vault, "raw", "articles"), { recursive: true });
+    await writeFile16(rawAbsPath, rawContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -4713,8 +4909,8 @@ async function runIngest(input) {
     };
   }
   try {
-    await mkdir11(join29(input.vault, typedDir), { recursive: true });
-    await writeFile15(typedAbsPath, typedContent, "utf8");
+    await mkdir12(join30(input.vault, typedDir), { recursive: true });
+    await writeFile16(typedAbsPath, typedContent, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -4745,7 +4941,7 @@ async function runIngest(input) {
 }
 
 // src/commands/tag-sync.ts
-import { writeFile as writeFile16 } from "fs/promises";
+import { writeFile as writeFile17 } from "fs/promises";
 var ENUM_MIRRORS = {
   provenance: ["research", "project", "mixed"],
   confidence: ["high", "medium", "low"]
@@ -4860,7 +5056,7 @@ ${newFm}
 ---
 ${body}`;
     if (!input.dryRun) {
-      await writeFile16(page.absPath, newText, "utf8");
+      await writeFile17(page.absPath, newText, "utf8");
     }
     synced.push(page.relPath);
   }
@@ -4889,11 +5085,11 @@ ${body}`;
 }
 
 // src/commands/sync.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join31 } from "path";
 function runSyncStatus(input) {
   const vault = input.vault;
-  if (!existsSync9(join30(vault, ".git"))) {
+  if (!existsSync10(join31(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: ok({
@@ -4962,7 +5158,7 @@ function runSyncStatus(input) {
 }
 async function runSyncPush(input) {
   const vault = input.vault;
-  if (!existsSync9(join30(vault, ".git"))) {
+  if (!existsSync10(join31(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5047,7 +5243,7 @@ async function runSyncPush(input) {
 }
 async function runSyncPull(input) {
   const vault = input.vault;
-  if (!existsSync9(join30(vault, ".git"))) {
+  if (!existsSync10(join31(vault, ".git"))) {
     return {
       exitCode: ExitCode.VAULT_PATH_INVALID,
       result: err("NOT_A_GIT_REPO", { path: vault })
@@ -5122,8 +5318,8 @@ async function runSyncPull(input) {
 }
 
 // src/commands/backup.ts
-import { statSync as statSync3, readdirSync as readdirSync2, readFileSync as readFileSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join31, relative as relative3, dirname as dirname11 } from "path";
+import { statSync as statSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join32, relative as relative3, dirname as dirname11 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -5147,7 +5343,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", "_archive", "node_
 function* walkMarkdown(dir, base) {
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
     if (SKIP_DIRS.has(entry.name)) continue;
-    const full = join31(dir, entry.name);
+    const full = join32(dir, entry.name);
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
@@ -5170,8 +5366,8 @@ async function runBackupSync(input) {
   let failed = 0;
   const files = [...walkMarkdown(input.vault, input.vault)];
   for (const relPath of files) {
-    const absPath = join31(input.vault, relPath);
-    const localStat = statSync3(absPath);
+    const absPath = join32(input.vault, relPath);
+    const localStat = statSync4(absPath);
     let needsUpload = true;
     try {
       const head = await client.send(new HeadObjectCommand({ Bucket: input.bucket, Key: relPath }));
@@ -5246,9 +5442,9 @@ async function runBackupRestore(input) {
     const objects = list.Contents ?? [];
     for (const obj of objects) {
       if (!obj.Key) continue;
-      const localPath = join31(target, obj.Key);
+      const localPath = join32(target, obj.Key);
       try {
-        const localStat = statSync3(localPath);
+        const localStat = statSync4(localPath);
         if (obj.LastModified && localStat.mtime > obj.LastModified) {
           conflicts++;
           continue;
@@ -5292,11 +5488,11 @@ async function runBackupRestore(input) {
 }
 
 // src/commands/status.ts
-import { existsSync as existsSync10, statSync as statSync4 } from "fs";
-import { readFile as readFile20 } from "fs/promises";
-import { join as join32 } from "path";
+import { existsSync as existsSync11, statSync as statSync5 } from "fs";
+import { readFile as readFile21 } from "fs/promises";
+import { join as join33 } from "path";
 async function runStatus(input) {
-  if (!existsSync10(input.vault)) {
+  if (!existsSync11(input.vault)) {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: err("VAULT_PATH_INVALID", { vault: input.vault }) };
   }
   const scan = await scanVault(input.vault);
@@ -5321,7 +5517,7 @@ async function runStatus(input) {
   const compound = scan.data.compound.length;
   let schemaVersion = "v1";
   try {
-    const schemaContent = await readFile20(join32(input.vault, "SCHEMA.md"), "utf8");
+    const schemaContent = await readFile21(join33(input.vault, "SCHEMA.md"), "utf8");
     const versionMatch = schemaContent.match(/version:\s*["']?([^"'\s\n]+)/i);
     if (versionMatch) schemaVersion = versionMatch[1];
   } catch {
@@ -5337,7 +5533,7 @@ async function runStatus(input) {
   let maxTime = 0;
   for (const page of allPages) {
     try {
-      const st = statSync4(page.absPath);
+      const st = statSync5(page.absPath);
       if (st.mtimeMs > maxTime) {
         maxTime = st.mtimeMs;
         lastModified = st.mtime.toISOString();
@@ -5381,8 +5577,8 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir12, writeFile as writeFile17, stat as stat7 } from "fs/promises";
-import { join as join33 } from "path";
+import { mkdir as mkdir13, writeFile as writeFile18, stat as stat7 } from "fs/promises";
+import { join as join34 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
   "entities/example-project.md": `---
@@ -5451,30 +5647,30 @@ Real sources are immutable after ingestion \u2014 never edit them.
 `;
 async function runSeed(input) {
   try {
-    await stat7(join33(input.vault, "SCHEMA.md"));
+    await stat7(join34(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 = join33(input.vault, relPath);
+    const absPath = join34(input.vault, relPath);
     try {
       await stat7(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir12(join33(absPath, ".."), { recursive: true });
-      await writeFile17(absPath, content, "utf8");
+      await mkdir13(join34(absPath, ".."), { recursive: true });
+      await writeFile18(absPath, content, "utf8");
       created.push(relPath);
     }
   }
-  const rawPath = join33(input.vault, "raw", "articles", "example-source.md");
+  const rawPath = join34(input.vault, "raw", "articles", "example-source.md");
   try {
     await stat7(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir12(join33(rawPath, ".."), { recursive: true });
-    await writeFile17(rawPath, EXAMPLE_RAW, "utf8");
+    await mkdir13(join34(rawPath, ".."), { recursive: true });
+    await writeFile18(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }
   if (created.length > 0) {
@@ -5496,9 +5692,9 @@ async function runSeed(input) {
 }
 
 // src/commands/canvas.ts
-import { readFile as readFile21, writeFile as writeFile18 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import { join as join34 } from "path";
+import { readFile as readFile22, writeFile as writeFile19 } from "fs/promises";
+import { existsSync as existsSync12 } from "fs";
+import { join as join35 } from "path";
 var NODE_WIDTH = 240;
 var NODE_HEIGHT = 60;
 var COLUMN_SPACING = 400;
@@ -5576,8 +5772,8 @@ function buildCanvasEdges(adjacency) {
   return edges;
 }
 async function runCanvasGenerate(input) {
-  const graphPath = input.graphPath ?? join34(input.vault, ".skillwiki", "graph.json");
-  if (!existsSync11(graphPath)) {
+  const graphPath = input.graphPath ?? join35(input.vault, ".skillwiki", "graph.json");
+  if (!existsSync12(graphPath)) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
       result: err("FILE_NOT_FOUND", {
@@ -5588,7 +5784,7 @@ async function runCanvasGenerate(input) {
   }
   let raw;
   try {
-    raw = await readFile21(graphPath, "utf8");
+    raw = await readFile22(graphPath, "utf8");
   } catch (e) {
     return {
       exitCode: ExitCode.FILE_NOT_FOUND,
@@ -5614,9 +5810,9 @@ async function runCanvasGenerate(input) {
   const nodes = buildCanvasNodes(paths);
   const edges = buildCanvasEdges(graph.adjacency);
   const canvas = { nodes, edges };
-  const outPath = join34(input.vault, "vault-graph.canvas");
+  const outPath = join35(input.vault, "vault-graph.canvas");
   try {
-    await writeFile18(outPath, JSON.stringify(canvas, null, 2));
+    await writeFile19(outPath, JSON.stringify(canvas, null, 2));
   } catch (e) {
     return {
       exitCode: ExitCode.WRITE_FAILED,
@@ -5636,8 +5832,8 @@ written: ${outPath}`
 }
 
 // src/commands/query.ts
-import { readFile as readFile22, stat as stat8 } from "fs/promises";
-import { join as join35 } from "path";
+import { readFile as readFile23, stat as stat8 } from "fs/promises";
+import { join as join36 } from "path";
 var W_KEYWORD = 2;
 var W_SOURCE_OVERLAP = 4;
 var W_WIKILINK = 3;
@@ -5758,7 +5954,7 @@ function computeKeywordScore(terms, title, tags, body) {
   return score;
 }
 async function loadOrBuildGraph(vault) {
-  const graphPath = join35(vault, ".skillwiki", "graph.json");
+  const graphPath = join36(vault, ".skillwiki", "graph.json");
   let needsBuild = false;
   try {
     const fileStat = await stat8(graphPath);
@@ -5772,7 +5968,7 @@ async function loadOrBuildGraph(vault) {
     if (buildResult.exitCode !== 0) return null;
   }
   try {
-    const raw = await readFile22(graphPath, "utf8");
+    const raw = await readFile23(graphPath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5780,14 +5976,14 @@ async function loadOrBuildGraph(vault) {
 }
 
 // src/utils/auto-commit.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join36 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join37 } from "path";
 async function postCommit(vault, exitCode) {
   if (exitCode !== 0) return;
   const home = process.env.HOME ?? "";
   const dotenv = await parseDotenvFile(configPath(home));
   if (dotenv["AUTO_COMMIT"] === "false") return;
-  if (!existsSync12(join36(vault, ".git"))) return;
+  if (!existsSync13(join37(vault, ".git"))) return;
   const lastOps = readLastOp(vault);
   if (lastOps.length === 0) return;
   const porcelain = git(vault, ["status", "--porcelain"]);
@@ -5838,7 +6034,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 ?? join37(vault, ".skillwiki", "graph.json");
+  const out = opts.out ?? join38(vault, ".skillwiki", "graph.json");
   emit(await runGraphBuild({ vault, out }), vault);
 });
 var canvasCmd = program.command("canvas").description("manage Obsidian canvas files");
@@ -5944,10 +6140,15 @@ program.command("topic-map-check [vault]").description("check whether a topic ma
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runTopicMapCheck({ vault: v.vault, threshold: opts.threshold }), v.vault);
 });
-program.command("stale [vault]").description("identify stale transcripts and incomplete work items").option("--archive", "move stale items to _archive/", false).option("--days <n>", "staleness threshold in days", (s) => parseInt(s, 10), 3).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("stale [vault]").description("identify stale transcripts and incomplete work items").option("--archive", "move stale items to _archive/", false).option("--days <n>", "staleness threshold in days", (s) => parseInt(s, 10), 3).option("--force-scan", "infer kind/project from filename and content when frontmatter is missing", 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 runStale({ vault: v.vault, days: opts.days, archive: !!opts.archive, forceScan: !!opts.forceScan }), v.vault);
+});
+program.command("claim <transcript> [vault]").description("claim an unclaimed transcript by creating a work item with source: link").option("--project <slug>", "project slug (overrides transcript frontmatter)").option("--slug <slug>", "work-item slug (defaults to transcript filename without date/kind prefix)").option("--wiki <name>", "wiki profile name").action(async (transcript, 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, archive: !!opts.archive }), v.vault);
+  else emit(await runClaim({ vault: v.vault, transcript, project: opts.project, slug: opts.slug }), v.vault);
 });
 program.command("pagesize [vault]").description("report page sizes and flag oversized pages").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);
@@ -6109,7 +6310,7 @@ program.command("seed [vault]").description("populate a vault with example conte
   if (!v.ok) emit({ exitCode: v.exitCode, result: v.payload });
   else emit(await runSeed({ vault: v.vault }), v.vault);
 });
-program.command("observe [vault]").description("create a raw transcript observation entry").requiredOption("--text <text>", "observation text").option("--kind <kind>", "observation kind (note|bug|task|idea|session-log)", "note").option("--project <slug>", "associated project slug").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+program.command("observe [vault]").description("create a raw transcript observation entry").requiredOption("--text <text>", "observation text").option("--kind <kind>", "observation kind (note|bug|task|idea|session-log)", "task").option("--project <slug>", "associated project slug (required for task/bug claim detection)").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 runObserve({