@viloforge/vfkb 0.4.1 → 0.6.0

package/dist/broadcast.js

@@ -8,9 +8,9 @@ import { execFileSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { addEntry } from './engine.js';
-import { writeManifest } from './manifest.js';
+import { manifestNeedsStamp, writeManifest } from './manifest.js';
 import { defaultProject } from './storage.js';
-import { SCHEMA_VERSION } from './version.js';
+import { ENGINE_COMMIT, SCHEMA_VERSION } from './version.js';
 /** The resident-pin tags a broadcast record must never carry (ADR-0063 §1). */
 const FORBIDDEN_TAGS = new Set(['handoff', 'next']);
 function targetBrainDir(target) {
@@ -76,7 +76,14 @@ export function broadcast(text, targets, opts = {}) {
         const repoDir = resolve(brain, '..');
         const manifestPath = join(brain, 'manifest.json');
         let healed = false;
-        if (!existsSync(manifestPath)) {
+        let upgraded = false;
+        // #212 — the heal used to fire ONLY on absence, so a brain stamped by a
+        // dist-path build (engine_commit "dev") stayed unknown forever: nothing in
+        // any routine path ever re-stamped it, and doctor reported it against every
+        // real-sha engine. A running engine that knows its own commit is a genuine
+        // provenance upgrade for a brain that does not — unknown -> known.
+        const needsStamp = manifestNeedsStamp(brain, opts.engineCommit ?? ENGINE_COMMIT);
+        if (needsStamp) {
             // §3's rule is "never bootstrap a WIRE-LESS brain". A brain with a live
             // entries.jsonl is wired — the manifest is just missing because only
             // `vfkb init` ever writes it (plugin-born brains, vfkb#193). Heal it
@@ -86,16 +93,20 @@ export function broadcast(text, targets, opts = {}) {
                 results.push({ target, ok: false, reason: `no brain (no entries.jsonl in ${brain}) — never bootstrap a wire-less brain (ADR-0063 §3)` });
                 continue;
             }
+            const absent = !existsSync(manifestPath);
             try {
-                writeManifest(brain);
+                writeManifest(brain, { engineCommit: opts.engineCommit, engineVersion: opts.engineVersion });
             }
             catch (err) {
                 // Per-target and loud, never a thrown abort — a heal failure on one
                 // target must not swallow the rest of a partial broadcast.
-                results.push({ target, ok: false, reason: `manifest heal failed: ${err.message}` });
+                results.push({ target, ok: false, reason: `manifest ${absent ? 'heal' : 'provenance upgrade'} failed: ${err.message}` });
                 continue;
             }
-            healed = true;
+            if (absent)
+                healed = true;
+            else
+                upgraded = true;
         }
         let schema;
         try {
@@ -116,12 +127,12 @@ export function broadcast(text, targets, opts = {}) {
             process.env.VFKB_DATA_DIR = brain;
             const e = addEntry('fact', stamped, { role: 'executor', tags: [...new Set(['cross-repo', ...extraTags])] });
             written.add(brain);
-            results.push({ target, ok: true, id: e.id, posture: gitPosture(repoDir), ...(healed ? { healed } : {}) });
+            results.push({ target, ok: true, id: e.id, posture: gitPosture(repoDir), ...(healed ? { healed } : {}), ...(upgraded ? { upgraded } : {}) });
         }
         catch (err) {
             // healed still reported on failure — the manifest stamp happened even
             // though the record did not land (heal is never silent).
-            results.push({ target, ok: false, reason: err.message, ...(healed ? { healed } : {}) });
+            results.push({ target, ok: false, reason: err.message, ...(healed ? { healed } : {}), ...(upgraded ? { upgraded } : {}) });
         }
         finally {
             if (prev === undefined)

package/dist/bundles/vfkb-mcp.mjs

@@ -30954,6 +30954,9 @@ var StdioServerTransport = class {
 
 // src/engine.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname3, join as join6, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // src/storage.ts
 import { basename, dirname as dirname2, join as join4, resolve } from "node:path";
@@ -31775,6 +31778,16 @@ function latestCrossRepo(all = readAll(), today = nowIso().slice(0, 10), superse
   }
   return latest;
 }
+var CLI_FACES = ["vfkb.mjs", "cli.js", "cli.mjs"];
+function resolveCliFace(engineDir) {
+  return CLI_FACES.map((f) => join6(engineDir, f)).find((p) => existsSync4(p));
+}
+function renderCaptureFallback(engineDir = dirname3(fileURLToPath(import.meta.url))) {
+  const cli = resolveCliFace(engineDir);
+  const target = cli ? `node "${cli}"` : `node <vfkb CLI not found beside the engine at ${engineDir} \u2014 locate vfkb.mjs or cli.js>`;
+  return `capture fallback: if the kb_* tools error or disappear, the CLI still writes (same engine, separate process; journaled per ADR-0064) \u2014
+  VFKB_DATA_DIR="${resolvePath(brainDir())}" ${target} add <type> "\u2026" [--tags a,b] [--why "\u2026"]`;
+}
 function renderContextBundle(project = defaultProject(), budget = SESSION_BUDGET_CHARS) {
   const all = readAll();
   const today = nowIso().slice(0, 10);
@@ -31813,6 +31826,7 @@ function renderContextBundle(project = defaultProject(), budget = SESSION_BUDGET
 `;
   }
   body += renderContextMap() + "\n\n";
+  body += renderCaptureFallback() + "\n\n";
   const kept = [];
   let keptLen = 0;
   let dropped = 0;
@@ -32007,7 +32021,7 @@ function queryExplained(opts = {}) {
 }
 
 // src/version.ts
-var ENGINE_VERSION = true ? "0.4.1" : ownPackageVersion();
+var ENGINE_VERSION = true ? "0.6.0" : ownPackageVersion();
 
 // src/mcp-server.ts
 var SEARCH_DEFAULT_LIMIT = 25;