skillwiki 0.9.19 → 0.9.21

package/dist/cli.js

@@ -2866,9 +2866,9 @@ ${content}
 
 // src/commands/lint.ts
 import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile17 } from "fs/promises";
+import { readFile as readFile17, readdir as readdir5 } from "fs/promises";
 import { createHash as createHash5 } from "crypto";
-import { join as join23 } from "path";
+import { join as join23, relative as relative3, sep as sep3 } from "path";
 
 // src/commands/sparse-community.ts
 async function runSparseCommunity(input) {
@@ -3527,8 +3527,8 @@ function buildCliSurface() {
   backupCmd2.command("restore").option("--bucket <name>").option("--endpoint <url>").option("--region <region>").option("--target <dir>").option("--wiki <name>");
   const memoryCmd2 = program2.commands.find((c) => c.name() === "memory");
   memoryCmd2.command("topics").option("--project <slug>").option("--limit <n>").option("--wiki <name>");
-  memoryCmd2.command("index").requiredOption("--project <slug>").option("--wiki <name>");
-  memoryCmd2.command("recall").requiredOption("--project <slug>").requiredOption("--topic <slug>").option("--limit <n>").option("--wiki <name>");
+  memoryCmd2.command("index").requiredOption("--project <slug>").option("--check").option("--if-stale").option("--wiki <name>");
+  memoryCmd2.command("recall").requiredOption("--project <slug>").requiredOption("--topic <slug>").option("--scope <scope>").option("--limit <n>").option("--wiki <name>");
   memoryCmd2.command("import").requiredOption("--from <path>").requiredOption("--project <slug>").option("--dry-run").option("--apply").option("--max-bytes <n>").option("--wiki <name>");
   const fleetCmd2 = program2.commands.find((c) => c.name() === "fleet");
   fleetCmd2.command("validate");
@@ -3714,6 +3714,7 @@ var ERROR_ORDER = ["sensitive_content", "broken_wikilinks", "invalid_frontmatter
 var WARNING_ORDER = ["raw_body_duplicate", "raw_subdirectory_duplicate", "file_source_url", "index_incomplete", "index_link_format", "stale_page", "page_too_large", "log_rotate_needed", "orphans", "compound_refs", "legacy_citation_style", "orphaned_citations", "duplicate_frontmatter", "work_item_health", "orphaned_project_pages", "missing_overview", "missing_diagram"];
 var INFO_ORDER = ["bridges", "sparse_community", "page_structure", "topic_map_recommended", "frontmatter_wikilink", "wikilink_citation", "missing_tldr", "stale_sections", "cli_refs"];
 var KNOWN_BUCKETS = [...ERROR_ORDER, ...WARNING_ORDER, ...INFO_ORDER];
+var CLI_REFS_TYPED_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -3786,6 +3787,63 @@ function summarizeLintOutput(output, examplesLimit = 3) {
     humanHint: lines.join("\n")
   };
 }
+async function walkMarkdownFiles(absDir, vaultRoot) {
+  const entries = await readdir5(absDir, { withFileTypes: true });
+  const pages = [];
+  for (const entry of entries) {
+    const absPath = join23(absDir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === ".git" || entry.name === "node_modules") continue;
+      pages.push(...await walkMarkdownFiles(absPath, vaultRoot));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      pages.push({ absPath, relPath: relative3(vaultRoot, absPath).split(sep3).join("/") });
+    }
+  }
+  return pages;
+}
+async function collectCliRefsPages(vault) {
+  if (!existsSync6(join23(vault, "SCHEMA.md"))) {
+    return err("VAULT_PATH_INVALID", { root: vault, reason: "SCHEMA.md missing" });
+  }
+  const pages = [];
+  for (const dir of CLI_REFS_TYPED_DIRS) {
+    const absDir = join23(vault, dir);
+    if (!existsSync6(absDir)) continue;
+    pages.push(...await walkMarkdownFiles(absDir, vault));
+  }
+  return ok(pages);
+}
+async function runCliRefsOnly(input) {
+  const pages = await collectCliRefsPages(input.vault);
+  if (!pages.ok) {
+    return { exitCode: ExitCode.VAULT_PATH_INVALID, result: pages };
+  }
+  const cliRefFlags = [];
+  const cliSurface = buildCliSurface();
+  for (const page of pages.data) {
+    const text = await readPage(page);
+    const violations = validateCliRefs(text, page.relPath, cliSurface);
+    for (const v of violations) {
+      cliRefFlags.push(`${v.page}: ${v.ref} (${v.reason})`);
+    }
+  }
+  const infoOut = cliRefFlags.length > 0 ? [{ kind: "cli_refs", items: cliRefFlags }] : [];
+  const summary = { errors: 0, warnings: 0, info: cliRefFlags.length };
+  const exitCode = cliRefFlags.length > 0 ? ExitCode.LINT_HAS_WARNINGS : ExitCode.OK;
+  const output = {
+    vault: { path: input.vault, source: input.source ?? "resolved" },
+    summary,
+    by_severity: { error: [], warning: [], info: infoOut },
+    fixed: [],
+    unresolved: [],
+    humanHint: `--only cli_refs
+${cliRefFlags.length === 0 ? "0 violations" : `  cli_refs: ${cliRefFlags.length}`}`
+  };
+  return {
+    exitCode,
+    result: ok(input.summary ? summarizeLintOutput(output, input.examplesLimit) : output)
+  };
+}
 async function runLint(input) {
   if (input.only && !KNOWN_BUCKETS.includes(input.only)) {
     return {
@@ -3793,6 +3851,9 @@ async function runLint(input) {
       result: { ok: false, error: "UNKNOWN_BUCKET", detail: `Unknown bucket "${input.only}". Valid: ${KNOWN_BUCKETS.join(", ")}` }
     };
   }
+  if (input.only === "cli_refs") {
+    return runCliRefsOnly(input);
+  }
   const shouldFix = (bucket) => !!input.fix && (!input.only || input.only === bucket);
   const buckets = {};
   const fixed = [];
@@ -8001,13 +8062,13 @@ async function runSelfUpdate(input) {
 }
 
 // src/commands/transcripts.ts
-import { readdir as readdir5, stat as stat8, readFile as readFile22 } from "fs/promises";
+import { readdir as readdir6, stat as stat8, readFile as readFile22 } from "fs/promises";
 import { join as join34 } from "path";
 async function runTranscripts(input) {
   const dir = join34(input.vault, "raw", "transcripts");
   let entries;
   try {
-    entries = await readdir5(dir, { withFileTypes: true });
+    entries = await readdir6(dir, { withFileTypes: true });
   } catch {
     return { exitCode: ExitCode.VAULT_PATH_INVALID, result: { ok: false, error: "VAULT_PATH_INVALID", detail: `raw/transcripts/ not found: ${dir}` } };
   }
@@ -8032,14 +8093,14 @@ async function runTranscripts(input) {
 }
 
 // src/commands/project-index.ts
-import { readdir as readdir6, readFile as readFile23, writeFile as writeFile11, mkdir as mkdir10 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile23, writeFile as writeFile11, mkdir as mkdir10 } from "fs/promises";
 import { join as join35, dirname as dirname13 } from "path";
 var LAYER2_DIRS = ["entities", "concepts", "comparisons", "queries", "meta"];
 async function runProjectIndex(input) {
   const slug = input.slug;
   const projectDir = join35(input.vault, "projects", slug);
   try {
-    await readdir6(projectDir);
+    await readdir7(projectDir);
   } catch {
     return {
       exitCode: ExitCode.PROJECT_NOT_FOUND,
@@ -8050,7 +8111,7 @@ async function runProjectIndex(input) {
   const entries = [];
   const compoundDir = join35(input.vault, "projects", slug, "compound");
   try {
-    const compoundFiles = await readdir6(compoundDir, { withFileTypes: true });
+    const compoundFiles = await readdir7(compoundDir, { withFileTypes: true });
     for (const entry of compoundFiles) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
       const filePath = join35(compoundDir, entry.name);
@@ -8073,7 +8134,7 @@ async function runProjectIndex(input) {
   for (const dir of LAYER2_DIRS) {
     let files;
     try {
-      files = await readdir6(join35(input.vault, dir), { withFileTypes: true });
+      files = await readdir7(join35(input.vault, dir), { withFileTypes: true });
     } catch {
       continue;
     }
@@ -8176,7 +8237,7 @@ ${entries.map((e) => `  ${e.type}: [[${e.page.replace(/\.md$/, "")}]] \u2014 ${e
 }
 
 // src/commands/compound.ts
-import { writeFile as writeFile12, mkdir as mkdir11, readdir as readdir7, unlink as unlink4 } from "fs/promises";
+import { writeFile as writeFile12, mkdir as mkdir11, readdir as readdir8, unlink as unlink4 } from "fs/promises";
 import { join as join36 } from "path";
 import { existsSync as existsSync14 } from "fs";
 import { readFile as readFile24 } from "fs/promises";
@@ -8413,7 +8474,7 @@ no compound directory found`
   }
   let dirents;
   try {
-    dirents = await readdir7(compoundDir, { withFileTypes: true });
+    dirents = await readdir8(compoundDir, { withFileTypes: true });
   } catch {
     return {
       exitCode: ExitCode.OK,
@@ -8545,7 +8606,7 @@ ${input.text.trim()}
 
 // src/commands/session-brief.ts
 import { mkdir as mkdir13, readFile as readFile25, writeFile as writeFile14 } from "fs/promises";
-import { join as join38, relative as relative3, sep as sep3 } from "path";
+import { join as join38, relative as relative4, sep as sep4 } from "path";
 var MAX_WORDS = 900;
 async function runSessionBrief(input) {
   const scan = await scanVault(input.vault);
@@ -8649,7 +8710,7 @@ async function readProjectSlug(file) {
   return void 0;
 }
 function inferProjectFromPath(vault, cwd) {
-  const rel = relative3(vault, cwd).split(sep3).join("/");
+  const rel = relative4(vault, cwd).split(sep4).join("/");
   const match = rel.match(/^projects\/([^/]+)(?:\/|$)/);
   return match?.[1];
 }
@@ -8938,8 +8999,8 @@ function dateFromPath(path) {
 
 // src/commands/memory.ts
 import { createHash as createHash8 } from "crypto";
-import { mkdir as mkdir14, readFile as readFile26, readdir as readdir8, stat as stat9, writeFile as writeFile15 } from "fs/promises";
-import { basename as basename2, extname, join as join39, relative as relative4, sep as sep4 } from "path";
+import { mkdir as mkdir14, readFile as readFile26, readdir as readdir9, stat as stat9, writeFile as writeFile15 } from "fs/promises";
+import { basename as basename2, extname, join as join39, relative as relative5, sep as sep5 } from "path";
 async function runMemoryTopics(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
@@ -8983,24 +9044,34 @@ async function runMemoryTopics(input) {
 async function runMemoryIndex(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const warnings = [];
-  const sourcePages = dedupePages(scan.data.allMarkdown);
-  const sources = [];
-  for (const page of sourcePages) {
-    const source = await readMemorySource(page, input.project, warnings);
-    if (source) sources.push(source);
+  const state = await buildMemoryIndexState(scan.data.allMarkdown, input.project);
+  let status;
+  if (input.check || input.ifStale) {
+    const checked = await checkMemoryIndex(input.vault, input.project, state);
+    if (!checked.ok) return checked.error;
+    status = checked.data;
+    if (input.check || !status.stale) {
+      return {
+        exitCode: ExitCode.OK,
+        result: ok({
+          ...status,
+          files_written: [],
+          warnings: state.warnings,
+          humanHint: renderMemoryIndexStatusHint(status)
+        })
+      };
+    }
   }
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-  const topics = buildTopics(input.project, sources);
   const relCachePath = memoryCacheRelPath(input.project);
   const absCachePath = join39(input.vault, relCachePath);
   await mkdir14(join39(input.vault, ".skillwiki", "memory", input.project), { recursive: true });
   await writeFile15(absCachePath, `${JSON.stringify({
     generated_at: generatedAt,
     project: input.project,
-    topics,
-    sources,
-    warnings
+    topics: state.topics,
+    sources: state.sources,
+    warnings: state.warnings
   }, null, 2)}
 `, "utf8");
   return {
@@ -9008,18 +9079,31 @@ async function runMemoryIndex(input) {
     result: ok({
       project: input.project,
       generated_at: generatedAt,
-      topic_count: topics.length,
-      source_count: sources.length,
-      topics,
+      cache_present: status?.cache_present ?? true,
+      stale: status?.stale ?? false,
+      drift: status?.drift ?? emptyMemoryIndexDrift(),
+      topic_count: state.topics.length,
+      source_count: state.sources.length,
+      topics: state.topics,
       files_written: [relCachePath],
-      warnings,
-      humanHint: `indexed ${sources.length} memory sources into ${topics.length} topics for ${input.project}`
+      warnings: state.warnings,
+      humanHint: `indexed ${state.sources.length} memory sources into ${state.topics.length} topics for ${input.project}`
     })
   };
 }
 async function runMemoryRecall(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
+  const scope = normalizeRecallScope(input.scope);
+  if (input.scope && !scope) {
+    return {
+      exitCode: ExitCode.WRITE_FAILED,
+      result: err("WRITE_FAILED", {
+        path: "memory recall --scope",
+        message: `invalid memory recall scope: ${String(input.scope)}`
+      })
+    };
+  }
   const cacheText = await readMemoryCache(input.vault, input.project);
   if (!cacheText) {
     return {
@@ -9027,6 +9111,7 @@ async function runMemoryRecall(input) {
       result: ok({
         project: input.project,
         topic: input.topic,
+        ...scope ? { scope } : {},
         sources: [],
         humanHint: `no memory topics cache found for project ${input.project}`
       })
@@ -9045,12 +9130,13 @@ async function runMemoryRecall(input) {
     };
   }
   const limit = normalizeLimit(input.limit);
-  const sources = normalizeSources(parsed.sources).filter((source) => source.topics.includes(input.topic)).filter((source) => source.memory_privacy !== "secret-blocked").sort(compareSources).slice(0, limit);
+  const sources = normalizeSources(parsed.sources).filter((source) => source.topics.includes(input.topic)).filter((source) => source.memory_privacy !== "secret-blocked").filter((source) => source.memory_status !== "archived" && source.memory_status !== "rejected").filter((source) => recallScopeMatches(source, input.project, scope)).sort((a, b) => compareRecallSources(a, b, input.project, scope)).slice(0, limit);
   return {
     exitCode: ExitCode.OK,
     result: ok({
       project: input.project,
       topic: input.topic,
+      ...scope ? { scope } : {},
       sources,
       humanHint: renderRecallHint(input.topic, sources)
     })
@@ -9111,6 +9197,115 @@ async function runMemoryImport(input) {
     })
   };
 }
+async function buildMemoryIndexState(pages, project) {
+  const warnings = [];
+  const sourcePages = dedupePages(pages);
+  const sources = [];
+  for (const page of sourcePages) {
+    const source = await readMemorySource(page, project, warnings);
+    if (source) sources.push(source);
+  }
+  return {
+    sources,
+    topics: buildTopics(project, sources),
+    warnings
+  };
+}
+async function checkMemoryIndex(vault, project, current) {
+  const relCachePath = memoryCacheRelPath(project);
+  const cacheText = await readIfExists3(join39(vault, relCachePath));
+  if (!cacheText) {
+    return {
+      ok: true,
+      data: {
+        project,
+        cache_present: false,
+        stale: true,
+        topic_count: current.topics.length,
+        source_count: current.sources.length,
+        topics: current.topics,
+        drift: emptyMemoryIndexDrift(),
+        files_written: [],
+        warnings: current.warnings,
+        humanHint: ""
+      }
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(cacheText);
+  } catch (e) {
+    return {
+      ok: false,
+      error: {
+        exitCode: ExitCode.WRITE_FAILED,
+        result: err("WRITE_FAILED", {
+          path: relCachePath,
+          message: `invalid memory topics cache: ${String(e)}`
+        })
+      }
+    };
+  }
+  const cachedSources = normalizeSources(parsed.sources);
+  const cachedTopics = normalizeTopics(parsed.topics);
+  const drift = compareMemorySources(current.sources, cachedSources);
+  const stale = drift.missing_sources.length > 0 || drift.removed_sources.length > 0 || drift.changed_sources.length > 0 || !sameStringSet(current.topics.map((topic) => topic.name), cachedTopics.map((topic) => topic.name));
+  return {
+    ok: true,
+    data: {
+      project,
+      generated_at: stringField2(parsed.generated_at) || void 0,
+      cache_present: true,
+      stale,
+      topic_count: current.topics.length,
+      source_count: current.sources.length,
+      topics: current.topics,
+      drift,
+      files_written: [],
+      warnings: current.warnings,
+      humanHint: ""
+    }
+  };
+}
+function compareMemorySources(current, cached) {
+  const currentByPath = new Map(current.map((source) => [source.path, source]));
+  const cachedByPath = new Map(cached.map((source) => [source.path, source]));
+  const missing_sources = current.filter((source) => !cachedByPath.has(source.path)).map((source) => source.path).sort((a, b) => a.localeCompare(b));
+  const removed_sources = cached.filter((source) => !currentByPath.has(source.path)).map((source) => source.path).sort((a, b) => a.localeCompare(b));
+  const changed_sources = current.filter((source) => {
+    const cachedSource = cachedByPath.get(source.path);
+    return !!cachedSource && !sameMemorySource(source, cachedSource);
+  }).map((source) => source.path).sort((a, b) => a.localeCompare(b));
+  return { missing_sources, removed_sources, changed_sources };
+}
+function sameMemorySource(a, b) {
+  return a.hash === b.hash && a.updated === b.updated && (a.project ?? "") === (b.project ?? "") && (a.memory_kind ?? "") === (b.memory_kind ?? "") && (a.memory_scope ?? "") === (b.memory_scope ?? "") && (a.memory_policy ?? "") === (b.memory_policy ?? "") && a.memory_privacy === b.memory_privacy && a.memory_status === b.memory_status && sameStringSet(a.topics, b.topics);
+}
+function sameStringSet(a, b) {
+  if (a.length !== b.length) return false;
+  const left = [...a].sort((x, y) => x.localeCompare(y));
+  const right = [...b].sort((x, y) => x.localeCompare(y));
+  return left.every((value, index) => value === right[index]);
+}
+function emptyMemoryIndexDrift() {
+  return {
+    missing_sources: [],
+    removed_sources: [],
+    changed_sources: []
+  };
+}
+function renderMemoryIndexStatusHint(status) {
+  if (!status.cache_present) {
+    return `memory index cache missing for ${status.project}; rebuild with memory index --project ${status.project}`;
+  }
+  if (!status.stale) {
+    return `memory index cache current for ${status.project}: ${status.source_count} sources, ${status.topic_count} topics`;
+  }
+  const changed = status.drift.changed_sources.length;
+  const missing = status.drift.missing_sources.length;
+  const removed = status.drift.removed_sources.length;
+  return `memory index cache stale for ${status.project}: ${missing} missing, ${removed} removed, ${changed} changed sources`;
+}
 async function readIfExists3(path) {
   try {
     return await readFile26(path, "utf8");
@@ -9126,7 +9321,7 @@ async function collectImportFiles(source) {
   return files.sort((a, b) => a.localeCompare(b));
 }
 async function walkImportFiles(dir, out) {
-  const entries = await readdir8(dir, { withFileTypes: true });
+  const entries = await readdir9(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git" || entry.name === "node_modules") continue;
     const path = join39(dir, entry.name);
@@ -9179,7 +9374,7 @@ async function buildImportEntry(file, sourceRoot, project, today, maxBytes) {
   const redacted = redactSensitiveContent(extracted, { file });
   const privacy = redacted.findings.length > 0 ? "sensitive" : "local";
   const sourceSlug = slugify3(basename2(file, extname(file)));
-  const relSource = relative4(sourceRoot, file).split(sep4).join("/");
+  const relSource = relative5(sourceRoot, file).split(sep5).join("/");
   const entry = {
     ...baseEntry,
     status: "ready",
@@ -9251,7 +9446,7 @@ function hiddenString(entry, key) {
   return entry[key] ?? "";
 }
 function classifyImportSource(file) {
-  const rel = file.split(sep4).join("/");
+  const rel = file.split(sep5).join("/");
   const name = basename2(file);
   if (rel.includes("/.codex/memories/")) return "codex-memory";
   if (rel.includes("/.codex/rules/")) return "codex-rule";
@@ -9340,6 +9535,26 @@ function compareTopics(a, b) {
 function compareSources(a, b) {
   return b.updated.localeCompare(a.updated) || a.path.localeCompare(b.path);
 }
+function normalizeRecallScope(value) {
+  if (!value) return void 0;
+  return isRecallScope(value) ? value : void 0;
+}
+function isRecallScope(value) {
+  return value === "project" || value === "global" || value === "cross-agent" || value === "all";
+}
+function recallScopeMatches(source, project, scope) {
+  if (!scope || scope === "all") return true;
+  if (scope === "project") return isProjectMemorySource(source, project);
+  return source.memory_scope === scope;
+}
+function compareRecallSources(a, b, project, scope) {
+  if (scope !== "all") return compareSources(a, b);
+  return b.updated.localeCompare(a.updated) || Number(isProjectMemorySource(b, project)) - Number(isProjectMemorySource(a, project)) || a.path.localeCompare(b.path);
+}
+function isProjectMemorySource(source, project) {
+  const scope = source.memory_scope || "project";
+  return scope === "project" && (!source.project || source.project === project);
+}
 function renderHumanHint(topics) {
   if (topics.length === 0) return "no memory topics found";
   return topics.map((topic) => {
@@ -10498,7 +10713,7 @@ function runSyncUnlock(input) {
 
 // src/commands/backup.ts
 import { statSync as statSync5, readdirSync as readdirSync3, readFileSync as readFileSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
-import { join as join43, relative as relative5, dirname as dirname14 } from "path";
+import { join as join43, relative as relative6, dirname as dirname14 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -10526,7 +10741,7 @@ function* walkMarkdown(dir, base) {
     if (entry.isDirectory()) {
       yield* walkMarkdown(full, base);
     } else if (entry.name.endsWith(".md")) {
-      yield relative5(base, full).replace(/\\/g, "/");
+      yield relative6(base, full).replace(/\\/g, "/");
     }
   }
 }
@@ -11170,7 +11385,7 @@ async function postCommit(vault, exitCode) {
   if (!porcelain || porcelain.trim().length === 0) return;
   const { gitStrict: gitStrict2 } = await import("./git-M4WGJ5G3.js");
   try {
-    gitStrict2(vault, ["add", "-A", "--", ...VAULT_COMMIT_PATHSPEC]);
+    gitStrict2(vault, ["add", "-A", "--", "."]);
     for (const generatedPath of VAULT_GENERATED_COMMIT_PATHS) {
       try {
         gitStrict2(vault, ["reset", "HEAD", "--", generatedPath]);
@@ -11595,21 +11810,24 @@ memoryCmd.command("topics [vault]").description("list topic-oriented memory from
     limit: opts.limit
   }), v.vault, { postCommit: false });
 });
-memoryCmd.command("index [vault]").description("build the derived project memory topic cache").requiredOption("--project <slug>", "project slug").option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+memoryCmd.command("index [vault]").description("build the derived project memory topic cache").requiredOption("--project <slug>", "project slug").option("--check", "report whether the local project memory cache is missing or stale without writing", false).option("--if-stale", "rebuild the local project memory cache only when it is missing or stale", 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 runMemoryIndex({
     vault: v.vault,
-    project: opts.project
-  }), v.vault);
+    project: opts.project,
+    check: !!opts.check,
+    ifStale: !!opts.ifStale
+  }), v.vault, { postCommit: !opts.check });
 });
-memoryCmd.command("recall [vault]").description("recall bounded source summaries for a memory topic").requiredOption("--project <slug>", "project slug").requiredOption("--topic <slug>", "memory topic slug").option("--limit <n>", "maximum sources to return", (s) => parseInt(s, 10), 10).option("--wiki <name>", "wiki profile name").action(async (vault, opts) => {
+memoryCmd.command("recall [vault]").description("recall bounded source summaries for a memory topic").requiredOption("--project <slug>", "project slug").requiredOption("--topic <slug>", "memory topic slug").option("--scope <scope>", "memory scope: project, global, cross-agent, or all").option("--limit <n>", "maximum sources to return", (s) => parseInt(s, 10), 10).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 runMemoryRecall({
     vault: v.vault,
     project: opts.project,
     topic: opts.topic,
+    scope: opts.scope,
     limit: opts.limit
   }), v.vault, { postCommit: false });
 });

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "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/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.9.19",
+  "version": "0.9.21",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 18 prompt-only skills backed by the deterministic skillwiki CLI.",
   "author": {
     "name": "karlorz",

package/skills/package.json

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