skillwiki 0.2.6 → 0.3.0

package/dist/cli.js

@@ -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,16 +1886,106 @@ 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) {
+      unclaimedTranscripts.push({ path: t.relPath, reason: `${meta.kind} for ${meta.project} \u2014 no work item` });
     }
   }
   const doneWorkItems = [];
@@ -1987,17 +2080,19 @@ 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}`));
   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,
@@ -2268,7 +2363,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 });
@@ -4392,7 +4487,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,
@@ -5944,10 +6039,10 @@ 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 }), v.vault);
+  else emit(await runStale({ vault: v.vault, days: opts.days, archive: !!opts.archive, forceScan: !!opts.forceScan }), 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 +6204,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({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "type": "module",
   "bin": {
     "skillwiki": "dist/cli.js"

package/skills/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 18 prompt-only skills (wiki-*, proj-*, using-skillwiki) backed by the deterministic `skillwiki` CLI.",
   "author": {

package/skills/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillwiki/skills",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "private": true,
   "files": [
     "wiki-*",

package/skills/wiki-add-task/SKILL.md

@@ -29,22 +29,23 @@ Run `skillwiki lang` at the start. Entry prose and `--human` summaries use the r
 0. **Resolve vault and language.** Run `skillwiki path` (fail if NO_VAULT_CONFIGURED) and `skillwiki lang`.
 1. **Parse arguments.** Extract from the user's message:
    - `text` — the idea/bug/task/note content (required)
-   - `type` — one of: `idea`, `bug`, `task`, `note` (default: `idea`)
-   - `project` — optional project slug to cross-reference (e.g., `llm-wiki`)
+   - `type` — one of: `idea`, `bug`, `task`, `note` (default: `task`)
+   - `project` — project slug for claim detection (e.g., `llm-wiki`). Required for `task` and `bug` types to appear in `skillwiki stale` unclaimed list.
 2. **Build filename.** Derive a slug from the first ~6 words of the text (lowercased, hyphens for spaces, non-alphanumeric stripped). The capture file is `raw/transcripts/YYYY-MM-DD-{type}-{slug}.md`. Each capture gets its own file — never append to an existing file.
 3. **Write frontmatter.** Create the file with ad-hoc capture frontmatter:
    ```yaml
    ---
    source_url:
-   ingested: YYYY-MM-DD
+   created: YYYY-MM-DD
+   ingested:          # filled by ingest pipeline
    kind: {type}
    project: "[[{slug}]]"
    ---
    ```
    - Set `kind` to the parsed type (`idea`, `bug`, `task`, `note`).
-   - If a `project` slug was provided, set `project: "[[slug]]"`.
-   - If no project, omit the `project` field entirely.
+   - Set `project: "[[slug]]"` — **required for claim detection**. Without this field, the transcript is invisible to `skillwiki stale`. If no project context exists, ask the user which project this capture belongs to.
    - `source_url` is null (these are locally originated captures).
+   - `created` — today's date. `ingested` is left empty for the ingest pipeline.
    - No `sha256` — ad-hoc captures are mutable working notes, not immutable sources.
 4. **Write body.** Below the frontmatter, write:
    ```markdown
@@ -72,7 +73,8 @@ Each capture is a standalone file with ad-hoc capture frontmatter:
 ```yaml
 ---
 source_url:
-ingested: 2026-05-08
+created: 2026-05-08
+ingested:
 kind: idea
 project: "[[llm-wiki]]"
 ---
@@ -84,7 +86,7 @@ Fix the template mismatch between wiki-add-task and the vault template.
 
 The `kind` field uses the capture type and must be one of: `idea`, `bug`, `task`, `note` (plus the existing `postmortem`, `session-log`, `meeting-notes`, `other` for non-capture raw sources).
 
-The `project` and `kind` fields can be set independently — they do not require `work_item`. The `work_item` field is only used when the raw source is directly tied to a project work item (set by `proj-work`).
+The `project` field is **required for claim detection**. Without it, `skillwiki stale` cannot surface the transcript as unclaimed work. The `kind` and `project` fields can be set independently — they do not require `work_item`. The `work_item` field is only used when the raw source is directly tied to a project work item (set by `proj-work`).
 
 Ad-hoc captures omit `sha256` — they are mutable working notes, not immutable sources. The `sha256` field is reserved for ingested raw sources that require integrity verification.
 
@@ -106,14 +108,25 @@ Ad-hoc captures omit `sha256` — they are mutable working notes, not immutable
 When you're not in a Claude session, drop files directly into `raw/transcripts/`:
 
 1. Create a `.md` file in `raw/transcripts/` — name it descriptively (e.g., `2026-05-08-idea-fix-template.md`)
-2. Use ad-hoc capture frontmatter: `source_url:`, `ingested:`, `kind:`, and optionally `project:`
+2. Use ad-hoc capture frontmatter: `source_url:`, `ingested:`, `kind:`, and `project:` (required for `task`/`bug`)
 3. Write your idea/bug/task/note below the frontmatter
 
-No special format required — the dev-loop QUERY step will discover new files on the next cycle and surface them as claimable work. Mark the type with a heading like `## idea`, `## bug`, `## task`, or just write freeform.
+**For claim detection**, `kind` must be `task` or `bug` AND `project: "[[slug]]"` must be set. Without both fields, the transcript won't appear in `skillwiki stale` unclaimed list.
+
+No special format required — `skillwiki stale --days 0` will detect unclaimed task/bug transcripts on the next run. Mark the type with a heading like `## idea`, `## bug`, `## task`, or just write freeform.
 
 ## Dev-loop discovery
 
-When the dev-loop QUERY step runs, it should scan `raw/transcripts/` for files with `ingested:` date newer than the last cycle. New files are surfaced as claimable work items. The agent then decides whether to:
-- Create a work item via `proj-work` (for tasks and bugs)
+`skillwiki stale` detects unclaimed transcripts automatically. A transcript is **unclaimed** when:
+- `kind` is `task` or `bug`
+- `project` field is set (e.g., `project: "[[llm-wiki]]"`)
+- No work item matches it (via date-prefix or `source:` frontmatter reference in spec.md)
+
+Run `skillwiki stale --days 0 --human` to see all unclaimed transcripts. The output includes an `unclaimed_transcripts` section listing each capture that needs a work item.
+
+The agent then decides whether to:
+- Create a work item via `proj-work` (for tasks and bugs) — set `source:` in spec.md to the transcript path for cross-date linking
 - Ingest as a knowledge page via `wiki-ingest` (for ideas with sources)
 - Leave in place (for notes that don't need action yet)
+
+Transcripts without `kind` or `project` fields (e.g., `loop-cycle-*` session logs) are excluded from claim detection.

package/templates/capture.md

@@ -0,0 +1,11 @@
+---
+source_url:
+created: {{date:YYYY-MM-DD}}
+ingested:          # filled by ingest pipeline
+kind: {{kind}}
+project: "[[{{project}}]]"
+---
+
+# {{kind}}: {{title}}
+
+{{description}}