skillwiki 0.10.25 → 0.10.26

package/dist/{chunk-SYKSL3JQ.js → chunk-VXMHHXVP.js}

@@ -787,20 +787,75 @@ function extractBodyWikilinks(body) {
   return out;
 }
 
+// src/utils/wikilink-resolver.ts
+var EXCLUDED_PREFIXES = [
+  ".git/",
+  ".skillwiki/",
+  "_archive/",
+  "drafts/",
+  "tmp/"
+];
+var RESOLVABLE_PROJECT_ARTIFACT_RE = /^projects\/[^/]+\/(?:knowledge\.md|README\.md|(?:compound|requirements|architecture|history|work)\/(?:[^/]+\/)*[^/]+\.md)$/i;
+function normalizeTarget(target) {
+  return target.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\.md$/i, "").replace(/^\/+/, "").replace(/\/+/g, "/").toLowerCase();
+}
+function isResolvableProjectArtifact(relPath) {
+  return RESOLVABLE_PROJECT_ARTIFACT_RE.test(relPath);
+}
+function isResolvablePath(relPath) {
+  const normalized = relPath.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (EXCLUDED_PREFIXES.some((prefix) => normalized.startsWith(prefix))) return false;
+  return !normalized.startsWith("projects/") || isResolvableProjectArtifact(normalized);
+}
+function buildWikilinkResolver(pages) {
+  const exact = /* @__PURE__ */ new Map();
+  const byBasename = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    if (!isResolvablePath(page.relPath)) continue;
+    const normalizedPath = normalizeTarget(page.relPath);
+    exact.set(normalizedPath, page.relPath);
+    const basename3 = normalizedPath.split("/").pop();
+    const candidates = byBasename.get(basename3) ?? [];
+    candidates.push(page.relPath);
+    byBasename.set(basename3, candidates);
+  }
+  for (const candidates of byBasename.values()) candidates.sort();
+  return {
+    resolve(target) {
+      const normalized = normalizeTarget(target);
+      const exactPath = exact.get(normalized);
+      if (exactPath) return { target, path: exactPath, ambiguous: false };
+      if (normalized.startsWith("projects/")) {
+        return {
+          target,
+          ambiguous: false,
+          reason: isResolvablePath(`${normalized}.md`) ? "missing" : "unsupported"
+        };
+      }
+      const candidates = byBasename.get(normalized) ?? [];
+      if (candidates.length === 1) {
+        return { target, path: candidates[0], ambiguous: false };
+      }
+      if (candidates.length > 1) {
+        return { target, ambiguous: true, reason: "ambiguous" };
+      }
+      return { target, ambiguous: false, reason: "missing" };
+    }
+  };
+}
+
 // src/utils/community.ts
-async function buildWikilinkAdjacency(typedKnowledge, pageTextCache) {
+async function buildWikilinkAdjacency(typedKnowledge, pageTextCache, allPages = typedKnowledge) {
   const adjacency = {};
-  const slugToPath = {};
-  for (const p of typedKnowledge) {
-    const slug = p.relPath.replace(/\.md$/, "").split("/").pop();
-    slugToPath[slug] = p.relPath;
-  }
+  const resolver = buildWikilinkResolver(allPages);
   await mapWithConcurrency(typedKnowledge, vaultIoConcurrency(), async (p) => {
     const text = await readPageCached(p, pageTextCache);
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     const links = extractBodyWikilinks(body);
-    adjacency[p.relPath] = links.map((slug) => slugToPath[slug.split("/").pop()]).filter((x) => Boolean(x));
+    const targets = links.map((target) => resolver.resolve(target).path).filter((x) => Boolean(x));
+    adjacency[p.relPath] = targets;
+    for (const target of targets) adjacency[target] ??= [];
   });
   return adjacency;
 }
@@ -917,7 +972,7 @@ function findSparseCommunities(adj, opts = {}) {
 async function runGraphBuild(input) {
   const scan = await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge);
+  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge, void 0, scan.data.allMarkdown);
   const adamicAdar = computeAdamicAdar(adjacency);
   const edge_count = Object.values(adjacency).reduce((acc, arr) => acc + arr.length, 0);
   try {
@@ -926,9 +981,10 @@ async function runGraphBuild(input) {
   } catch (e) {
     return { exitCode: ExitCode.WRITE_FAILED, result: err("WRITE_FAILED", { message: String(e) }) };
   }
+  const node_count = Object.keys(adjacency).length;
   return {
     exitCode: ExitCode.OK,
-    result: ok({ out_path: input.out, node_count: scan.data.typedKnowledge.length, edge_count, humanHint: `nodes: ${scan.data.typedKnowledge.length}, edges: ${edge_count}
+    result: ok({ out_path: input.out, node_count, edge_count, humanHint: `nodes: ${node_count}, edges: ${edge_count}
 written: ${input.out}` })
   };
 }
@@ -1282,23 +1338,12 @@ async function validateCompoundReferences(vault, existingScan, pageTextCache) {
   return ok(findings);
 }
 
-// src/utils/slug.ts
-function buildSlugMap(pages) {
-  const map = /* @__PURE__ */ new Map();
-  for (const p of pages) {
-    const slug = p.relPath.replace(/\.md$/, "").split("/").pop();
-    map.set(slug.toLowerCase(), slug);
-  }
-  return map;
-}
-
 // src/commands/links.ts
 async function runLinks(input) {
   const scanResult = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scanResult.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scanResult };
   const scan = scanResult.data;
-  const allPages = [...scan.typedKnowledge, ...scan.raw, ...scan.workItems, ...scan.compound];
-  const slugs = buildSlugMap(allPages);
+  const resolver = buildWikilinkResolver(scan.allMarkdown);
   const perPage = await mapWithConcurrency(scan.typedKnowledge, vaultIoConcurrency(), async (p) => {
     const text = await readPageCached(p, input.pageTextCache);
     const split = splitFrontmatter(text);
@@ -1306,8 +1351,8 @@ async function runLinks(input) {
     const lines = body.split("\n");
     const broken2 = [];
     for (const slug of extractBodyWikilinks(body)) {
-      const tail = slug.split("/").pop().replace(/\.md$/, "");
-      if (!slugs.has(tail.toLowerCase())) {
+      const resolution = resolver.resolve(slug);
+      if (!resolution.path) {
         const line = lines.findIndex((l) => l.includes(`[[${slug}`));
         broken2.push({ page: p.relPath, slug, line: line >= 0 ? line + 1 : 0 });
       }
@@ -1738,8 +1783,7 @@ Autogenerated by \`skillwiki project-index\` on ${today}.
 
 `;
     for (const item of items) {
-      const pageRef = item.page.replace(/\.md$/, "");
-      body += `- [[${pageRef}]] \u2014 ${item.title}
+      body += `- [[${item.page.replace(/\.md$/, "")}]] \u2014 ${item.title}
 `;
     }
     body += "\n";
@@ -3077,7 +3121,11 @@ import { join as join16, relative as relative2, sep as sep2 } from "path";
 async function runSparseCommunity(input) {
   const scan = input.scan ? ok(input.scan) : await scanVault(input.vault);
   if (!scan.ok) return { exitCode: ExitCode.VAULT_PATH_INVALID, result: scan };
-  const adjacency = await buildWikilinkAdjacency(scan.data.typedKnowledge, input.pageTextCache);
+  const adjacency = await buildWikilinkAdjacency(
+    scan.data.typedKnowledge,
+    input.pageTextCache,
+    scan.data.allMarkdown
+  );
   const communities = findSparseCommunities(adjacency, {
     minSize: input.minSize,
     maxCohesion: input.maxCohesion
@@ -4092,8 +4140,7 @@ async function runLint(input) {
   if (compoundRefs.ok && compoundRefs.data.length > 0) buckets.compound_refs = compoundRefs.data;
   const pathCheck = await runPathTooLong({ vault: lintVault, scan });
   if (pathCheck.result.ok && pathCheck.result.data.violations.length > 0) buckets.path_too_long = pathCheck.result.data.violations;
-  const allPages = [...scan.typedKnowledge, ...scan.raw, ...scan.workItems, ...scan.compound];
-  const slugs = buildSlugMap(allPages);
+  const wikilinkResolver = buildWikilinkResolver(scan.allMarkdown);
   {
     const allPageResults = await mapWithConcurrency(scan.allMarkdown, vaultIoConcurrency(), async (page) => {
       const sensitiveFlags2 = [];
@@ -4196,8 +4243,7 @@ async function runLint(input) {
         const fmLinks = rawFm.match(/\[\[([^\[\]|]+)(?:\|[^\[\]]*)?\]\]/g) ?? [];
         for (const link of fmLinks) {
           const target = link.replace(/^\[\[/, "").replace(/(?:\|[^\[\]]*)?\]\]$/, "").trim();
-          const tail = target.split("/").pop().replace(/\.md$/, "");
-          if (!slugs.has(tail.toLowerCase())) {
+          if (!wikilinkResolver.resolve(target).path) {
             result.fmWikilinkFlags.push(`${page.relPath}: [[${target}]] does not resolve`);
           }
         }
@@ -7211,8 +7257,9 @@ async function vaultMetrics(resolvedPath) {
   const scan = await scanVault(scanRoot);
   if (!scan.ok) return noVault();
   const tk = scan.data.typedKnowledge;
+  const typedCount = tk.length;
   const perType = METRIC_TYPES.map((d) => `${d} ${tk.filter((p) => p.relPath.startsWith(d + "/")).length}`).join(", ");
-  const adj = await buildWikilinkAdjacency(tk);
+  const adj = await buildWikilinkAdjacency(tk, void 0, scan.data.allMarkdown);
   const g = toUndirectedWeighted(adj);
   const nodes = [...g.keys()];
   const total = nodes.length;
@@ -7239,7 +7286,7 @@ async function vaultMetrics(resolvedPath) {
   } catch {
   }
   return [
-    check("info", "vault_metric_pages", "Vault pages by type", `${total} typed (${perType})`),
+    check("info", "vault_metric_pages", "Vault pages by type", `${total} graph node(s) (${typedCount} typed; ${perType})`),
     check("info", "vault_metric_orphans", "Vault orphan rate", `${orphanRate}% (${orphanCount}/${total} degree-0)`),
     check("info", "vault_metric_bridges", "Vault bridge count", `${bridges} page(s) link >= 3 communities`),
     check("info", "vault_metric_cohesion", "Mean community cohesion", `${meanCohesion} across ${cohesions.length} communities (size >= 2)`),
@@ -8957,6 +9004,8 @@ var W_WIKILINK = 3;
 var W_ADAMIC_ADAR = 1.5;
 var W_TYPE_AFFINITY = 1;
 var NON_SEED_FACTOR = 0.4;
+var HISTORICAL_CYCLE_FACTOR = 0.55;
+var HISTORICAL_CYCLE_RE = /(?:^|\/)(?:\d{4}-\d{2}-\d{2}-)?.*\b(?:daily|deep|maintenance|research|office[- ]hours|sleep)\b.*\b(?:cycle|run|review|research)\b/i;
 var CONCEPT_INDICATORS = /* @__PURE__ */ new Set([
   "what",
   "how",
@@ -8996,11 +9045,26 @@ async function runQuery(input) {
     const split = splitFrontmatter(text);
     const body = split.ok ? split.data.body : text;
     const keywordScore = computeKeywordScore(queryTerms, title, tags, body);
-    pages.push({ relPath: p.relPath, title, type, tags, sources, keywordScore });
+    pages.push({
+      relPath: p.relPath,
+      title,
+      type,
+      tags,
+      sources,
+      keywordScore,
+      historicalCycle: isHistoricalCyclePage(p.relPath, title)
+    });
   }
-  const seedPaths = new Set(
-    pages.filter((p) => p.keywordScore > 0).map((p) => p.relPath)
-  );
+  const seedPaths = /* @__PURE__ */ new Set();
+  let historicalCyclePageCount = 0;
+  let hasDirectOperationalSeed = false;
+  for (const page of pages) {
+    if (page.historicalCycle) historicalCyclePageCount += 1;
+    if (page.keywordScore <= 0) continue;
+    seedPaths.add(page.relPath);
+    if (!page.historicalCycle) hasDirectOperationalSeed = true;
+  }
+  const suppressRepetitiveHistoricalCycles = historicalCyclePageCount >= 3 && hasDirectOperationalSeed;
   const results = pages.map((page) => {
     const sourceOverlap = scoreSourceOverlap(page, pages, seedPaths);
     const wikilink = scoreWikilink(page.relPath, seedPaths, graph);
@@ -9009,9 +9073,10 @@ async function runQuery(input) {
     const isSeed = page.keywordScore > 0;
     const structuralBoost = sourceOverlap * W_SOURCE_OVERLAP + wikilink * W_WIKILINK + aa * W_ADAMIC_ADAR;
     const composite = isSeed ? page.keywordScore * W_KEYWORD + structuralBoost + typeAffinity * W_TYPE_AFFINITY : structuralBoost * NON_SEED_FACTOR + typeAffinity * W_TYPE_AFFINITY;
+    const guardedComposite = suppressRepetitiveHistoricalCycles && page.historicalCycle ? composite * HISTORICAL_CYCLE_FACTOR : composite;
     return {
       path: page.relPath,
-      score: Math.round(composite * 1e3) / 1e3,
+      score: Math.round(guardedComposite * 1e3) / 1e3,
       title: page.title,
       type: page.type
     };
@@ -9028,9 +9093,18 @@ async function runQuery(input) {
   }
   const humanHint = results.length === 0 ? pendingSources && pendingSources.length > 0 ? `no matching typed pages found
 ${pendingSources.length} matching pending source(s)` : "no matching pages found" : results.map((r) => `${r.path} (score: ${r.score})`).join("\n");
+  const rankingGuardrails = suppressRepetitiveHistoricalCycles ? {
+    repetitive_historical_cycles_suppressed: true,
+    historical_cycle_page_count: historicalCyclePageCount
+  } : void 0;
   return {
     exitCode: ExitCode.OK,
-    result: ok({ results, ...pendingSources ? { pending_sources: pendingSources } : {}, humanHint })
+    result: ok({
+      results,
+      ...pendingSources ? { pending_sources: pendingSources } : {},
+      ...rankingGuardrails ? { ranking_guardrails: rankingGuardrails } : {},
+      humanHint
+    })
   };
 }
 function scoreSourceOverlap(page, allPages, seedPaths) {
@@ -9069,6 +9143,9 @@ function scoreTypeAffinity(pageType, queryTerms) {
   if (!hasConceptIntent && pageType === "entity") return 0.5;
   return 0;
 }
+function isHistoricalCyclePage(relPath, title) {
+  return HISTORICAL_CYCLE_RE.test(`${relPath} ${title}`);
+}
 function tokenize(text) {
   return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
 }

package/dist/cli.js

@@ -81,7 +81,7 @@ import {
   snapshotterHealthChecks,
   taxonomyCommentForPage,
   upsertIndexEntry
-} from "./chunk-SYKSL3JQ.js";
+} from "./chunk-VXMHHXVP.js";
 import {
   normalizeDistTag,
   readCache,
@@ -4873,14 +4873,14 @@ function dateFromPath(path) {
 }
 
 // src/commands/ingest.ts
-import { readFile as readFile13, open, unlink as unlink4, mkdir as mkdir9 } from "fs/promises";
+import { readFile as readFile13, open, unlink as unlink4, mkdir as mkdir10 } from "fs/promises";
 import { join as join26 } from "path";
 import { createHash as createHash4 } from "crypto";
 
 // src/commands/page-publish.ts
 import { readFileSync as readFileSync12, realpathSync } from "fs";
-import { readFile as readFile12 } from "fs/promises";
-import { join as join25, resolve as resolve3 } from "path";
+import { mkdir as mkdir9, readFile as readFile12 } from "fs/promises";
+import { dirname as dirname6, join as join25, resolve as resolve3 } from "path";
 
 // src/utils/publication-approval.ts
 import { createHash as createHash3 } from "crypto";
@@ -5140,6 +5140,8 @@ function errorExitCode(error) {
       return ExitCode.APPROVAL_MISMATCH;
     case "TARGET_DRIFT":
       return ExitCode.TARGET_DRIFT;
+    case "PROJECT_NOT_FOUND":
+      return ExitCode.PROJECT_NOT_FOUND;
     case "USAGE":
       return ExitCode.USAGE;
     case "EVENT_IDENTITY_COLLISION":
@@ -5149,6 +5151,48 @@ function errorExitCode(error) {
       return ExitCode.INVALID_FRONTMATTER;
   }
 }
+function projectSlugForTarget(target) {
+  const match = target.match(/^projects\/([^/]+)\/(?:requirements|work|architecture|history|compound)\//);
+  return match?.[1];
+}
+function projectSlugsForPublication(target, content) {
+  const slugs = /* @__PURE__ */ new Set();
+  const pathSlug = projectSlugForTarget(target);
+  if (pathSlug) slugs.add(pathSlug);
+  const frontmatter = extractFrontmatter(content);
+  if (frontmatter.ok && Array.isArray(frontmatter.data.provenance_projects)) {
+    for (const entry of frontmatter.data.provenance_projects) {
+      const match = String(entry).match(/^\[\[([^\]]+)\]\]$/);
+      if (match && /^[a-z0-9][a-z0-9-]*$/i.test(match[1])) slugs.add(match[1]);
+    }
+  }
+  return [...slugs].sort();
+}
+async function refreshProjectIndexForTarget(vault, projectSlugs, today) {
+  const paths = [];
+  for (const slug of projectSlugs) {
+    const rendered = await renderProjectIndex(vault, slug, { today });
+    if (!rendered.ok) return rendered;
+    const indexPath = join25(vault, rendered.data.index_path);
+    try {
+      await mkdir9(dirname6(indexPath), { recursive: true });
+    } catch (error) {
+      return err("WRITE_FAILED", { path: indexPath, message: String(error) });
+    }
+    const written = await atomicWriteText(indexPath, rendered.data.text);
+    if (!written.ok) return written;
+    try {
+      const visible = await readFile12(indexPath, "utf8");
+      if (visible !== rendered.data.text) {
+        return err("WRITE_FAILED", { path: indexPath, message: "project index verification failed" });
+      }
+    } catch (error) {
+      return err("WRITE_FAILED", { path: indexPath, message: String(error) });
+    }
+    if (written.data.changed) paths.push(rendered.data.index_path);
+  }
+  return ok({ changed: paths.length > 0, paths });
+}
 function resolveRootAggregateMode(env = process.env) {
   if (env.SKILLWIKI_ROOT_AGGREGATE_MODE === "source-only") return "source-only";
   return "dual";
@@ -5248,6 +5292,7 @@ function emptyLockedState() {
     taxonomyAdded: [],
     pageChanged: false,
     indexUpdated: false,
+    projectIndexUpdated: false,
     published: false,
     changed: /* @__PURE__ */ new Set()
   };
@@ -5335,6 +5380,15 @@ async function runLockedPrimaryStages(input, vault, deps) {
   }
   const verifyHook = await observeStage(deps, "verify");
   if (verifyHook) return lockedFailure("verify", state, verifyHook);
+  const projectSlugs = projectSlugsForPublication(input.page.target, input.page.content);
+  if (projectSlugs.length > 0) {
+    const projectIndex = await refreshProjectIndexForTarget(vault, projectSlugs, input.date);
+    if (!projectIndex.ok) return lockedFailure("project-index", state, projectIndex);
+    state.projectIndexUpdated = projectIndex.data.changed;
+    for (const path of projectIndex.data.paths) state.changed.add(path);
+    const projectIndexHook = await observeStage(deps, "project-index");
+    if (projectIndexHook) return lockedFailure("project-index", state, projectIndexHook);
+  }
   const index = await upsertIndexEntry({
     vault,
     target: input.page.target,
@@ -5372,7 +5426,7 @@ function phaseFailure(stage, input, published, cause, context = {}, exitCode = E
     })
   };
 }
-function successReceipt(input, taxonomyAdded, pageChanged, indexUpdated, logAppended, filesChanged, dryRun = false, receipt = null, approvalToken) {
+function successReceipt(input, taxonomyAdded, pageChanged, indexUpdated, projectIndexUpdated, logAppended, filesChanged, dryRun = false, receipt = null, approvalToken) {
   return {
     exitCode: ExitCode.OK,
     result: ok({
@@ -5382,6 +5436,7 @@ function successReceipt(input, taxonomyAdded, pageChanged, indexUpdated, logAppe
       taxonomy_added: [...taxonomyAdded],
       page_changed: pageChanged,
       index_updated: indexUpdated,
+      project_index_updated: projectIndexUpdated,
       log_appended: logAppended,
       operation_id: input.operationId,
       dry_run: dryRun,
@@ -5449,6 +5504,21 @@ async function previewPreparedPagePublication(input, vault) {
     type: input.page.type
   });
   if (!index.ok) return { exitCode: errorExitCode(index.error), result: index };
+  let projectIndexUpdated = false;
+  const projectIndexPaths = [];
+  for (const projectSlug of projectSlugsForPublication(input.page.target, input.page.content)) {
+    const renderedProject = await renderProjectIndex(vault, projectSlug, { today: input.date });
+    if (!renderedProject.ok) return { exitCode: errorExitCode(renderedProject.error), result: renderedProject };
+    const projectIndexPath = join25(vault, renderedProject.data.index_path);
+    const projectIndexChanged = await readPageChanged(projectIndexPath, renderedProject.data.text);
+    if (!projectIndexChanged.ok) {
+      return { exitCode: errorExitCode(projectIndexChanged.error), result: projectIndexChanged };
+    }
+    if (projectIndexChanged.data || pageChanged.data) {
+      projectIndexUpdated = true;
+      projectIndexPaths.push(renderedProject.data.index_path);
+    }
+  }
   const logPath = join25(vault, "log.md");
   let logText;
   try {
@@ -5461,6 +5531,7 @@ async function previewPreparedPagePublication(input, vault) {
   const filesChanged = [
     ...reconciled.data.changed ? ["SCHEMA.md"] : [],
     ...pageChanged.data ? [input.page.target] : [],
+    ...projectIndexPaths,
     ...index.data.changed ? ["index.md"] : [],
     ...logAppended ? ["log.md"] : []
   ];
@@ -5471,6 +5542,7 @@ async function previewPreparedPagePublication(input, vault) {
     reconciled.data.added,
     pageChanged.data,
     index.data.changed,
+    projectIndexUpdated,
     logAppended,
     filesChanged,
     true,
@@ -5622,6 +5694,7 @@ async function publishPreparedPageWithReceipt(input, vault, writeReceipt, deps =
     state.taxonomyAdded,
     state.pageChanged,
     state.indexUpdated,
+    state.projectIndexUpdated,
     logAppended,
     [...state.changed],
     false,
@@ -5951,7 +6024,7 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
   );
   if (!input.dryRun) {
     try {
-      await mkdir9(join26(input.vault, typedDir), { recursive: true });
+      await mkdir10(join26(input.vault, typedDir), { recursive: true });
     } catch (error) {
       return {
         exitCode: ExitCode.WRITE_FAILED,
@@ -6009,7 +6082,7 @@ async function runIngest(input, pagePublishDeps = defaultPagePublishDeps()) {
     preflight: pagePublishDeps.preflight,
     mutate: async (receipt) => {
       try {
-        await mkdir9(join26(input.vault, "raw", "articles"), { recursive: true });
+        await mkdir10(join26(input.vault, "raw", "articles"), { recursive: true });
       } catch (error) {
         return {
           exitCode: ExitCode.WRITE_FAILED,
@@ -6443,12 +6516,12 @@ async function runTagReconcile(input) {
 
 // src/commands/project-page-publish.ts
 import { realpathSync as realpathSync4 } from "fs";
-import { mkdir as mkdir10, readFile as readFile15 } from "fs/promises";
-import { dirname as dirname8, join as join29, resolve as resolve5 } from "path";
+import { mkdir as mkdir11, readFile as readFile15 } from "fs/promises";
+import { dirname as dirname9, join as join29, resolve as resolve5 } from "path";
 
 // src/utils/architecture-page.ts
 import { lstatSync, realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname6, posix as posix2, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
+import { dirname as dirname7, posix as posix2, relative as relative2, resolve as resolve4, sep as sep2 } from "path";
 var PROJECT_SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
 var ARCH_TARGET_RE = /^projects\/([a-z0-9][a-z0-9-]*)\/architecture\/([a-z0-9][a-z0-9._-]*\.md)$/;
 function invalidFrontmatter(target, issues) {
@@ -6495,7 +6568,7 @@ function assertArchitectureTargetInsideVault(vault, target, project) {
     return err("VAULT_PATH_INVALID", { target, message: "vault realpath failed" });
   }
   const absolutePath = resolve4(vaultReal, target);
-  const parent = dirname6(absolutePath);
+  const parent = dirname7(absolutePath);
   let parentReal;
   try {
     parentReal = realpathSync2(parent);
@@ -6605,7 +6678,7 @@ import {
   writeFileSync as writeFileSync5
 } from "fs";
 import { homedir } from "os";
-import { dirname as dirname7, join as join28 } from "path";
+import { dirname as dirname8, join as join28 } from "path";
 var PUBLICATION_JOURNAL_SCHEMA = "skillwiki-publication-operation-v1";
 var PHASE_ORDER2 = [
   "locked",
@@ -6654,7 +6727,7 @@ function ensurePrivateDir(dir) {
   }
 }
 function atomicWriteJson(path, body) {
-  ensurePrivateDir(dirname7(path));
+  ensurePrivateDir(dirname8(path));
   const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
   writeFileSync5(tmp, body, { encoding: "utf8", mode: 384 });
   try {
@@ -7276,7 +7349,7 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
   }
   if (!phaseAtLeast(currentPhase, "page")) {
     try {
-      await mkdir10(dirname8(prepared.targetPath), { recursive: true });
+      await mkdir11(dirname9(prepared.targetPath), { recursive: true });
     } catch (error) {
       return {
         ok: false,
@@ -7372,7 +7445,7 @@ async function runLockedStages(prepared, vault, deps, journalHome) {
     }
     const knowledgePath = join29(vault, rendered.data.index_path);
     try {
-      await mkdir10(dirname8(knowledgePath), { recursive: true });
+      await mkdir11(dirname9(knowledgePath), { recursive: true });
     } catch (error) {
       return {
         ok: false,
@@ -8018,22 +8091,22 @@ async function runSyncPush(input) {
     })
   };
 }
-function enumerateStashes(vault) {
-  const output = git(vault, ["log", "--format=%gd%x09%s%x09%ct", "-g", "stash"]);
+function enumerateStashes(vault, nowMs = Date.now()) {
+  const output = git(vault, ["log", "--format=%gd%x09%H%x09%s%x09%ct", "-g", "stash"]);
   if (!output) return [];
-  const now = Date.now();
   const stashes = [];
   const lines = output.split("\n").filter((l) => l.trim().length > 0);
   for (const line of lines) {
     const parts = line.split("	");
-    if (parts.length < 3) continue;
+    if (parts.length < 4) continue;
     const ref = parts[0];
-    const message = parts[1];
-    const ctStr = parts[2];
+    const oid = parts[1];
+    const message = parts[2];
+    const ctStr = parts[3];
     const ct = parseInt(ctStr, 10);
     if (isNaN(ct)) continue;
-    const age_minutes = Math.floor((now - ct * 1e3) / (60 * 1e3));
-    stashes.push({ ref, message, age_minutes });
+    const age_minutes = Math.floor((nowMs - ct * 1e3) / (60 * 1e3));
+    stashes.push({ ref, oid, message, age_minutes });
   }
   return stashes;
 }
@@ -8112,16 +8185,73 @@ async function runSyncPull(input) {
     })
   };
 }
+var STASH_RECENT_MINUTES = 120;
+var MANAGED_WRITER_PATTERNS = [
+  ["wiki-push", /(?:^|[\s/\\])wiki-push(?:\.[a-z0-9_-]+)?(?:\s|$)/i],
+  ["rclone", /(?:^|[\s/\\])rclone(?:\.[a-z0-9_-]+)?(?:\s|$)/i],
+  ["vault-sync", /(?:^|[\s/\\])vault-sync(?:\.[a-z0-9_-]+)?(?:\s|$)/i]
+];
+function classifyStash(ageMinutes, sessionId, currentSession) {
+  if (sessionId && sessionId === currentSession) return "self_or_local_recovery_stash";
+  if (sessionId && ageMinutes <= STASH_RECENT_MINUTES) return "recent_known_peer_stash";
+  if (ageMinutes > STASH_RECENT_MINUTES) return "stale_stash_backlog";
+  return "unknown_stash_ownership";
+}
+function classifyManagedWriterProcesses(snapshot, currentPid = process.pid) {
+  const kinds = /* @__PURE__ */ new Set();
+  let count2 = 0;
+  for (const line of snapshot.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let pid;
+    let processName = "";
+    const csvMatch = trimmed.match(/^"([^"]*)","(\d+)"(?:,|$)/);
+    if (csvMatch) {
+      processName = csvMatch[1];
+      pid = Number(csvMatch[2]);
+    } else {
+      const pidMatch = trimmed.match(/^(\d+)\s+(.*)$/);
+      if (!pidMatch) continue;
+      pid = Number(pidMatch[1]);
+      processName = pidMatch[2];
+    }
+    if (pid === currentPid) continue;
+    const kind = MANAGED_WRITER_PATTERNS.find(([, pattern]) => pattern.test(processName))?.[0];
+    if (!kind) continue;
+    count2 += 1;
+    kinds.add(kind);
+  }
+  return { count: count2, kinds: [...kinds].sort(), blocking: count2 > 0 };
+}
+function managedWriterSnapshot() {
+  try {
+    if (process.platform === "win32") {
+      return execFileSync3("tasklist", ["/FO", "CSV", "/NH"], {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    return execFileSync3("ps", ["-axo", "pid=,command="], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return "";
+  }
+}
 function runSyncPeers(input) {
   const vault = input.vault;
+  const currentSession = input.sessionId ?? getSessionId();
   const locks = [];
   const existingLock = readLock(vault);
   if (existingLock) {
-    const self = existingLock.session_id === (input.sessionId ?? getSessionId());
+    const self = existingLock.session_id === currentSession;
     locks.push({ ...existingLock, is_self: self });
   }
-  const allStashes = enumerateStashes(vault);
+  const allStashes = enumerateStashes(vault, input.nowMs);
   const stashes = [];
+  const wikiSyncAudit = [];
+  const otherStashAudit = [];
   for (const stash of allStashes) {
     let actualMessage = stash.message;
     const prefixMatch = stash.message.match(/^On [^:]+:\s*(.*)/);
@@ -8129,29 +8259,63 @@ function runSyncPeers(input) {
       actualMessage = prefixMatch[1];
     }
     const match = actualMessage.match(/^wiki-sync:([^:]+):([^:]+):(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z):(.*)$/);
-    if (!match) continue;
-    const session_id = match[1];
-    const cwd_hash = match[2];
-    const timestamp = match[3];
-    const summary = match[4];
-    stashes.push({
+    if (match) {
+      const session_id = match[1];
+      const cwd_hash = match[2];
+      const timestamp = match[3];
+      const summary = match[4];
+      stashes.push({
+        ref: stash.ref,
+        oid: stash.oid,
+        session_id,
+        cwd_hash,
+        timestamp,
+        summary,
+        age_minutes: stash.age_minutes
+      });
+      wikiSyncAudit.push({
+        ref: stash.ref,
+        oid: stash.oid,
+        age_minutes: stash.age_minutes,
+        classification: classifyStash(stash.age_minutes, session_id, currentSession),
+        format: "wiki-sync",
+        session_id
+      });
+      continue;
+    }
+    const vaultSyncMatch = actualMessage.match(/^vault-sync\s+op=([^\s]+)(?:\s+.*)?$/i);
+    const operationId2 = vaultSyncMatch?.[1];
+    const manualPeer = /^peer$/i.test(actualMessage.trim());
+    const format = operationId2 ? "vault-sync" : manualPeer ? "manual" : "unknown";
+    const classification = operationId2 ? stash.age_minutes <= STASH_RECENT_MINUTES ? "recent_known_peer_stash" : "stale_stash_backlog" : "unknown_stash_ownership";
+    otherStashAudit.push({
       ref: stash.ref,
-      session_id,
-      cwd_hash,
-      timestamp,
-      summary,
-      age_minutes: stash.age_minutes
+      oid: stash.oid,
+      age_minutes: stash.age_minutes,
+      classification,
+      format,
+      ...operationId2 ? { operation_id: operationId2 } : {}
     });
   }
+  const stashAudit = [...wikiSyncAudit, ...otherStashAudit];
+  const managedWriters = classifyManagedWriterProcesses(
+    input.processSnapshot ?? managedWriterSnapshot()
+  );
   const hintParts = [];
   if (locks.length > 0) hintParts.push(`${locks.length} lock(s)`);
   if (stashes.length > 0) hintParts.push(`${stashes.length} wiki-sync stash(es)`);
+  if (managedWriters.count > 0) hintParts.push(`${managedWriters.count} live writer overlap(s)`);
+  if (stashAudit.length > 0) hintParts.push(`${stashAudit.length} stash audit item(s)`);
+  const blocking = locks.some((lock) => !lock.is_self) || managedWriters.blocking || stashAudit.some((entry) => entry.classification === "recent_known_peer_stash");
   const humanHint = hintParts.length > 0 ? hintParts.join(", ") : "no peers detected";
   return {
     exitCode: ExitCode.OK,
     result: ok({
       locks,
       stashes,
+      stash_audit: stashAudit,
+      managed_writers: managedWriters,
+      blocking,
       humanHint
     })
   };
@@ -8585,7 +8749,7 @@ function releaseSnapshotFlock(handle) {
 
 // src/commands/backup.ts
 import { statSync as statSync2, readdirSync as readdirSync2, readFileSync as readFileSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "fs";
-import { join as join32, relative as relative3, dirname as dirname9 } from "path";
+import { join as join32, relative as relative3, dirname as dirname10 } from "path";
 import { PutObjectCommand, HeadObjectCommand, ListObjectsV2Command, GetObjectCommand, DeleteObjectsCommand } from "@aws-sdk/client-s3";
 
 // src/utils/s3-client.ts
@@ -8721,7 +8885,7 @@ async function runBackupRestore(input) {
         const resp = await client.send(new GetObjectCommand({ Bucket: input.bucket, Key: obj.Key }));
         const body = await resp.Body?.transformToByteArray();
         if (body) {
-          mkdirSync5(dirname9(localPath), { recursive: true });
+          mkdirSync5(dirname10(localPath), { recursive: true });
           writeFileSync6(localPath, Buffer.from(body));
           downloaded++;
         }
@@ -8843,7 +9007,7 @@ async function runStatus(input) {
 }
 
 // src/commands/seed.ts
-import { mkdir as mkdir11, writeFile as writeFile8, stat as stat4 } from "fs/promises";
+import { mkdir as mkdir12, writeFile as writeFile8, stat as stat4 } from "fs/promises";
 import { join as join34 } from "path";
 var TODAY = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 var EXAMPLE_PAGES = {
@@ -8925,7 +9089,7 @@ async function runSeed(input) {
       await stat4(absPath);
       skipped.push(relPath);
     } catch {
-      await mkdir11(join34(absPath, ".."), { recursive: true });
+      await mkdir12(join34(absPath, ".."), { recursive: true });
       await writeFile8(absPath, content, "utf8");
       created.push(relPath);
     }
@@ -8935,7 +9099,7 @@ async function runSeed(input) {
     await stat4(rawPath);
     skipped.push("raw/articles/example-source.md");
   } catch {
-    await mkdir11(join34(rawPath, ".."), { recursive: true });
+    await mkdir12(join34(rawPath, ".."), { recursive: true });
     await writeFile8(rawPath, EXAMPLE_RAW, "utf8");
     created.push("raw/articles/example-source.md");
   }

package/dist/skillwiki-mcp.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runSkillwikiMcpStdio
-} from "./chunk-SYKSL3JQ.js";
+} from "./chunk-VXMHHXVP.js";
 import "./chunk-7I2TPIV5.js";
 import "./chunk-QBZYEEBD.js";
 import "./chunk-PQG26AGJ.js";

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "skillwiki",
-  "version": "0.10.25",
+  "version": "0.10.26",
   "skills": "./",
   "description": "Project-aware Karpathy-style knowledge base for Claude Code: 19 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.10.25",
+  "version": "0.10.26",
   "description": "Project-aware Karpathy-style knowledge base for Codex with 19 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.10.25",
+  "version": "0.10.26",
   "private": true,
   "files": [
     "wiki-*",