klypix-mcp 1.68.0 → 1.70.0

package/bin/klypix-install.mjs

@@ -10,6 +10,8 @@
 //   npx klypix-mcp install            # install / update the brain on this machine
 //   npx klypix-mcp install --force    # overwrite even a newer / dev-deployed brain
 //   npx klypix-mcp install --codex-hooks  # optional prompt/file awareness; Codex asks for trust
+//   npx klypix-mcp install --allow-untagged  # acknowledge deploying an UNTAGGED source checkout
+//                                            # (dev deploy; also KLYPIX_MCP_ALLOW_UNTAGGED=1)
 //
 // Never-throws-silently: it's an explicit CLI, so it reports what it did and exits
 // non-zero on a real failure. Never wires a broken settings.json (refuse + restore).
@@ -17,7 +19,7 @@ import fs from 'fs';
 import os from 'os';
 import path from 'path';
 import crypto from 'crypto';
-import { spawn } from 'child_process';
+import { execFileSync, spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import {
     connectCodexMcpServer,
@@ -29,8 +31,9 @@ import {
     codexPresenceHookStatus,
     mergeCodexPresenceHooks,
 } from '../src/codex-hooks.mjs';
-import { brainInstallDecision } from '../src/install-version.mjs';
+import { brainInstallDecision, deploySourceDecision } from '../src/install-version.mjs';
 import { acquireInstallLockSync, releaseInstallLockSync } from '../src/install-lock.mjs';
+import { collectRepoState } from '../src/repo-state.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, '..');
@@ -45,6 +48,11 @@ const VERSION = (() => { try { return JSON.parse(fs.readFileSync(path.join(PKG_R
 const FORCE = process.argv.includes('--force');
 const CODEX_HOOKS = process.argv.includes('--codex-hooks');
 const RUNTIME_ONLY = process.argv.includes('--runtime-only');
+// Released-tag deploy-guard acknowledgement. Deliberately a SEPARATE axis from
+// --force: --force is destination authority (overwrite what is installed),
+// this is source authority (knowingly deploy an untagged working tree).
+const ALLOW_UNTAGGED = process.argv.includes('--allow-untagged')
+    || process.env.KLYPIX_MCP_ALLOW_UNTAGGED === '1';
 
 const HOME = os.homedir();
 const CLAUDE_DIR = path.join(HOME, '.claude');
@@ -224,6 +232,52 @@ try {
         if (!RUNTIME_ONLY) reportCodex(wireCodex());
         process.exit(0);
     }
+
+    // ── Released-tag deploy guard (2026-08-14 bundle-currency incident) ──────
+    // A source checkout whose HEAD does not carry the release tag for its own
+    // package version is UNRELEASED code, yet this installer used to lay it
+    // down machine-globally with receipts claiming a clean npm delivery — the
+    // exact twin of the desktop near-miss that shipped this wave. Only
+    // PKG_ROOT's own git state is interrogated (never process.cwd(): the
+    // auto-update child runs the installer with the PROJECT as cwd), and only
+    // when PKG_ROOT itself contains a .git entry — an npm/npx tarball install
+    // has none and IS the released artifact, so it stays exempt; the registry
+    // channel is already tag-bound by publish.yml. The tag must point at HEAD
+    // (`git tag --points-at HEAD` semantics inside collectRepoState): the
+    // release tag names the exact evidence commit, so any non-HEAD comparison
+    // would certify code the tag never covered.
+    const checkout = exists(path.join(PKG_ROOT, '.git')) ? collectRepoState(PKG_ROOT) : null;
+    const sourceDecision = deploySourceDecision({ checkout, allowUntagged: ALLOW_UNTAGGED });
+    const checkoutLabel = `v${VERSION}, branch ${checkout?.branch || '(detached)'}, head ${checkout?.headShort || '?'}`;
+    if (sourceDecision.action === 'refuse') {
+        releaseInstallLockSync(installLock);
+        console.error(`✗ refusing to deploy an UNRELEASED source checkout machine-globally: ${checkoutLabel} — no release tag v${VERSION} at HEAD; no files were changed.`);
+        console.error('  Released installs come from the registry: npx -y klypix-mcp@latest install');
+        console.error('  To deliberately deploy this working tree (a dev deploy), acknowledge it: re-run with --allow-untagged or KLYPIX_MCP_ALLOW_UNTAGGED=1.');
+        console.error('  An acknowledged dev deploy is stamped dev-owned, so brain_doctor shows it and auto-update will not silently replace it.');
+        process.exit(1);
+    }
+    const untaggedSource = sourceDecision.source === 'untagged-working-tree';
+    // Deploy-time snapshot for ANY git-checkout deploy (tagged or acknowledged-
+    // untagged): the release tag certifies HEAD's bytes, not the working
+    // tree's, so uncommitted changes make even a TAGGED deploy differ from
+    // what was released — a clean `dirty:false` stamp would lie about exactly
+    // that (the receipt-honesty defect this wave exists to kill). An
+    // unreadable status degrades to false rather than inventing a DIRTY nag
+    // in every session brief. Tarball installs (checkout null) skip the spawn.
+    const sourceDirty = Boolean(checkout) && (() => {
+        try {
+            return execFileSync('git', ['status', '--porcelain'], {
+                cwd: PKG_ROOT, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 1500,
+            }).trim().length > 0;
+        } catch { return false; }
+    })();
+    if (untaggedSource) {
+        console.log(`• untagged source deploy acknowledged: ${checkoutLabel}${sourceDirty ? ' (working tree DIRTY)' : ''} — receipts record a dev-owned install; a later released install needs --force.`);
+    } else if (sourceDirty) {
+        console.log(`⚠ release-tagged checkout has uncommitted changes (${checkoutLabel}) — deployed bytes differ from the release; stamping dirty:true so brain_doctor surfaces it.`);
+    }
+
     fs.mkdirSync(BRAIN_DIR, { recursive: true });
     // 1) runtime dependency CLOSURE (jszip+fractional-indexing for the hook/engine,
     //    @modelcontextprotocol/sdk+zod for the local MCP server). Resolve each via
@@ -281,7 +335,7 @@ try {
     // canvas-view-app.html is the canvas_view MCP App UI — staged raw (an HTML
     // file must never get a JS-comment banner) beside the flat server, which
     // resolves it via its ./canvas-view-app.html candidate path.
-    for (const f of ['global-brain-hook.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'brain-note.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'remote-client.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
+    for (const f of ['global-brain-hook.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'brain-note.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'repo-state.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'remote-client.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
         const s = path.join(SRC, f); if (exists(s)) staged.push({ dst: f, content: fs.readFileSync(s, 'utf8') });
     }
     for (const [src, dst] of [
@@ -344,19 +398,38 @@ try {
     // a crash between receipts remains recoverable because the next installer
     // compares both and keeps the highest valid Brain Core version.
     const installedAt = new Date().toISOString();
+    // Receipt honesty (2026-08-14): an acknowledged untagged source deploy is
+    // a DEV delivery — stamping it 'npm'/dirty:false made unreleased code
+    // byte-for-byte indistinguishable from a released install. 'dev' is
+    // existing receipt vocabulary (brainInstallDecision's dev-owned preserve,
+    // auto-update's dev skip, doctor's channel/dev/dirty rendering all consume
+    // it); sourceSha/branch are additive fields for post-hoc audit. dev:true
+    // goes in BOTH receipts because the runtime receipt commits first — a
+    // crash between the two writes must not leave a dev deploy unmarked.
     const runtime = {
         protocol: 1,
         version: VERSION,
         worker: 'klypix-mcp-worker.mjs',
-        channel: 'npm',
+        channel: untaggedSource ? 'dev' : 'npm',
+        ...(untaggedSource ? { dev: true, sourceSha: checkout?.headShort || null, branch: checkout?.branch || null } : {}),
         installedAt,
         files: Object.fromEntries(staged.map(st => [st.dst, crypto.createHash('sha256').update(st.content).digest('hex')])),
     };
     const runtimePath = path.join(BRAIN_DIR, '.mcp-runtime.json');
     fs.writeFileSync(runtimePath + '.klypix-new', JSON.stringify(runtime, null, 2) + '\n', 'utf8');
     fs.renameSync(runtimePath + '.klypix-new', runtimePath);
+    // A tagged-but-DIRTY checkout keeps via:'npm' (the tag still names the
+    // payload identity, and dev:true would stop auto-update from healing the
+    // machine back to clean released bytes) but stamps dirty:true + the audit
+    // fields — doctor's DIRTY line and the hook's dirty nag both read the
+    // stamp. The clean released path stays byte-identical to pre-guard.
+    const versionStamp = untaggedSource
+        ? { brainVersion: VERSION, via: 'dev', dev: true, dirty: sourceDirty, sourceSha: checkout?.headShort || null, branch: checkout?.branch || null, installedAt }
+        : sourceDirty
+            ? { brainVersion: VERSION, via: 'npm', dirty: true, sourceSha: checkout?.headShort || null, branch: checkout?.branch || null, installedAt }
+            : { brainVersion: VERSION, via: 'npm', dirty: false, installedAt };
     const versionPath = path.join(BRAIN_DIR, '.brain-version.json');
-    fs.writeFileSync(versionPath + '.klypix-new', JSON.stringify({ brainVersion: VERSION, via: 'npm', dirty: false, installedAt }, null, 2), 'utf8');
+    fs.writeFileSync(versionPath + '.klypix-new', JSON.stringify(versionStamp, null, 2), 'utf8');
     fs.renameSync(versionPath + '.klypix-new', versionPath);
 
     // 7) migrate THIS project's .mcp.json off npx onto the now-installed local bundle

package/bin/klypix-mcp.mjs

@@ -19,7 +19,7 @@ const PKG_VERSION = (() => {
   }
 })();
 
-const DIRECT = new Set(['install', 'link', 'doctor', 'runtime', 'conformance', 'garden-code', 'init', 'git-driver', 'git-hook', 'brain-history', 'brain-deleted', 'diff', 'pr-brief', 'uninstall', 'bench']);
+const DIRECT = new Set(['install', 'link', 'doctor', 'runtime', 'conformance', 'garden-code', 'init', 'git-driver', 'git-hook', 'brain-history', 'brain-deleted', 'orphans', 'diff', 'pr-brief', 'uninstall', 'bench']);
 
 const USAGE = [
   `klypix-mcp ${PKG_VERSION} — shared project brain + MCP coordination server.`,
@@ -38,6 +38,7 @@ const USAGE = [
   '  git-hook [install|remove|status]    wire the agent-neutral commit-capture hook (any agent/branch/worktree → brain cards)',
   '  brain-history [list|restore <id>]   restore points for this brain — undo an accidental delete, edit, or overwrite',
   '  brain-deleted [list|restore|purge]  recycle bin for this brain — cards you deleted, kept recoverable',
+  '  orphans [brain] [--apply|--areas]   orphan gardener backfill: report unconnected cards, link the confident subset (dry-run default)',
   '  diff [ref] [--brain <path>]         readable brain diff vs a git ref (default HEAD) — markdown to stdout',
   '  pr-brief [baseRef] [--brain <path>] brain decisions touching the files changed since baseRef — PR-comment markdown',
   '',

package/bin/klypix-orphans.mjs

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+// klypix-orphans — `npx klypix-mcp orphans`. The orphan gardener's backfill pass:
+// report how many live decision/milestone cards have NO connections, and link the
+// CONFIDENT subset in one pass using the same selector capture uses
+// (proposeOrphanAnchorLinks): at most ONE lexical-anchor edge per card — exact
+// [[wikilink]], exact file-slug tag, or an unambiguous ≥0.6 title overlap —
+// never a fan-out, never a guess among multiple candidates.
+//
+//   npx klypix-mcp orphans [brain]        # DRY RUN (default) — report, write nothing
+//   npx klypix-mcp orphans --apply        # draw the confident edges (restore point first)
+//   npx klypix-mcp orphans --areas        # ALSO include each orphan's area-container edge
+//   npx klypix-mcp orphans --json         # machine-readable report
+//
+// Contract: additive + lossless — no card is archived, rewritten, or moved; every
+// arrow remains individually removable in KLYPIX. `--apply` takes a FORCED restore
+// point via the brain-history machinery before writing, so the whole pass is one
+// `brain-history restore` away from undone. Dry-run is the default because a
+// backfill touches history, not just this session's capture.
+//
+// `--areas` is opt-in for backfill (unlike capture, where the area edge is part
+// of the no-new-orphans contract): mass-adding hundreds of containment edges to
+// an old brain is a layout decision the human should make deliberately.
+//
+// Synchronous top-level by design: the dispatcher does `await import(this);
+// process.exit(0)`, so all work must complete during module evaluation. ARGV is
+// the standalone shape — the dispatcher splices its verb out first (runVerb).
+import fs from 'fs';
+import path from 'path';
+import { parseKlypix, brainInsights, proposeOrphanAnchorLinks, addBrainConnections, atomicWrite } from '../src/klypix-format.mjs';
+import { snapshotBrain } from '../src/brain-history.mjs';
+import { withAdvisoryWriteLock, brainCaptureLockPath } from '../src/brain-write-lock.mjs';
+
+const isDir = (p) => { try { return fs.statSync(p).isDirectory(); } catch { return false; } };
+
+try {
+  const raw = process.argv.slice(2);
+  const argv = (raw[0] === 'orphans' && !isDir(path.resolve(raw[0]))) ? raw.slice(1) : raw;
+  const apply = argv.includes('--apply');
+  const withAreas = argv.includes('--areas');
+  const json = argv.includes('--json');
+  const pathArg = argv.find(a => !a.startsWith('-'));
+  const file = path.resolve(process.cwd(), pathArg || 'brain.klypix');
+  if (!fs.existsSync(file)) {
+    console.error(`No brain at ${file} — run from the project folder (or pass a path).`);
+    process.exit(1);
+  }
+
+  const { struct } = await parseKlypix(fs.readFileSync(file));
+  const before = brainInsights(struct).orphans;
+  const byId = new Map(struct.cards.map(c => [c.id, c]));
+  const flat = (id) => {
+    const c = byId.get(id);
+    if (!c) return id;
+    const s = c.type === 'container' ? `[area] ${c.title || ''}` : String(c.text || '').replace(/\s+/g, ' ').trim();
+    return s.slice(0, 70);
+  };
+
+  const proposals = proposeOrphanAnchorLinks(struct);
+  const anchored = proposals.filter(p => p.anchor);
+  // The confident subset: anchor edges always; area edges only with --areas.
+  // Reversed twins (A anchors B, B anchors A) collapse to ONE edge here so the
+  // dry-run list, the drawn count, and the apply receipt all agree exactly.
+  const seenPair = new Set();
+  const edges = [];
+  for (const p of proposals) {
+    if (p.anchor) {
+      const key = [p.cardId, p.anchor.toId].sort().join('|');
+      if (!seenPair.has(key)) {
+        seenPair.add(key);
+        edges.push({ fromId: p.cardId, toId: p.anchor.toId, relationship: 'relates_to', label: 'auto', why: p.anchor.why });
+      }
+    }
+    if (withAreas && p.areaId) edges.push({ fromId: p.cardId, toId: p.areaId, relationship: 'relates_to', label: 'in area', color: 'rgba(120,120,135,0.45)', width: 1, style: 'dashed', why: 'area container' });
+  }
+  // An anchor edge between two orphans repairs BOTH endpoints — project on the
+  // orphan set, not just the source card.
+  const orphanIdSet = new Set(before.map(o => o.id));
+  const repairable = new Set();
+  for (const e of edges) {
+    if (orphanIdSet.has(e.fromId)) repairable.add(e.fromId);
+    if (orphanIdSet.has(e.toId)) repairable.add(e.toId);
+  }
+  const projected = Math.max(0, before.length - repairable.size);
+
+  if (json && !apply) {
+    console.log(JSON.stringify({
+      brain: file, dryRun: true, orphans: before.length, confident: anchored.length,
+      projectedOrphans: projected,
+      edges: edges.map(e => ({ fromId: e.fromId, toId: e.toId, label: e.label, why: e.why })),
+    }, null, 2));
+    process.exit(0);
+  }
+
+  if (!apply) {
+    console.log(`# orphan gardener — ${path.basename(file)} (DRY RUN, nothing written)`);
+    console.log('');
+    console.log(`Orphans now: ${before.length} live decision/milestone card(s) with no connections.`);
+    console.log(`Confident subset: ${anchored.length} card(s) have exactly one unambiguous lexical anchor${withAreas ? `; --areas adds ${proposals.filter(p => p.areaId).length} area-container edge(s)` : ''}.`);
+    console.log(`Projected after --apply: ${projected} orphan(s) remain (the rest need brain_connect review or a human).`);
+    if (edges.length) {
+      console.log('');
+      for (const e of edges) console.log(`  - ${flat(e.fromId)}  →  ${flat(e.toId)}  (${e.why})`);
+      console.log('');
+      console.log('Re-run with --apply to draw these. Additive only: no card is archived or rewritten;');
+      console.log('a forced restore point is taken first (undo: npx klypix-mcp brain-history).');
+    } else {
+      console.log('');
+      console.log(before.length
+        ? 'No edge clears the confidence bar — review the rest with brain_connect (dry-run receipts).'
+        : 'Nothing to do — this brain has no orphaned decision/milestone cards.');
+    }
+    process.exit(0);
+  }
+
+  if (!edges.length) {
+    console.log(before.length
+      ? `No edge clears the confidence bar — ${before.length} orphan(s) remain for brain_connect review. Nothing written.`
+      : 'Nothing to do — this brain has no orphaned decision/milestone cards. Nothing written.');
+    process.exit(0);
+  }
+
+  // APPLY — one locked snapshot + read-modify-write. The restore point is taken
+  // INSIDE the advisory lock (forced: an additive pass never trips the shrink
+  // rule, and the throttle must not skip the one snapshot that makes a whole
+  // backfill reversible): taken outside it, a concurrent capture landing between
+  // snapshot and write would be silently rolled back by a later restore.
+  let snap = null;
+  const result = await withAdvisoryWriteLock(brainCaptureLockPath(file), async (locked) => {
+    if (!locked) return { ok: false, error: 'brain is busy (another writer holds the capture lock) — retry in a moment; nothing written' };
+    snap = snapshotBrain(file, { reason: 'orphan-backfill', force: true });
+    const { buffer, added } = await addBrainConnections(fs.readFileSync(file), edges);
+    if (!added) return { ok: true, added: 0, after: before.length };
+    await atomicWrite(file, buffer, { snapshot: false });   // the forced pre-apply snapshot above is the restore point
+    let after = projected;
+    try { after = brainInsights((await parseKlypix(buffer)).struct).orphans.length; } catch { /* projected stays the honest fallback */ }
+    return { ok: true, added, after };
+  });
+  if (!result.ok) { console.error(`✗ ${result.error}`); process.exit(1); }
+
+  // A drawn count below the planned count means the brain changed between the
+  // dry-run read and the locked write (a pair already present, an endpoint
+  // gone) — slicing the planned list by count would then name the WRONG edges,
+  // so the per-edge list is only printed when it is exact.
+  const exact = result.added === edges.length;
+  // An 'unchanged' skip means the newest restore point already holds these
+  // exact bytes — the pass is just as reversible as a fresh snapshot.
+  const covered = snap && (snap.saved || snap.skipped === 'unchanged');
+  if (json) {
+    console.log(JSON.stringify({
+      brain: file, dryRun: false, added: result.added,
+      orphansBefore: before.length, orphansAfter: result.after,
+      restorePoint: covered ? (snap.id || true) : null,
+      edges: exact ? edges.map(e => ({ fromId: e.fromId, toId: e.toId, label: e.label, why: e.why })) : null,
+      ...(exact ? {} : { edgesNote: `${edges.length - result.added} planned edge(s) were skipped (already present or endpoint missing) — re-run the dry run for the current pair list` }),
+    }, null, 2));
+    process.exit(0);
+  }
+  console.log(`✓ Drew ${result.added} additive connection(s). Orphan receipt: ${before.length} → ${result.after} (${Math.max(0, before.length - result.after)} repaired).`);
+  console.log(covered
+    ? 'Restore point taken first — undo the whole pass: npx klypix-mcp brain-history'
+    : 'Restore point: not saved (best-effort) — arrows remain individually removable in KLYPIX.');
+  if (exact) for (const e of edges) console.log(`  - ${flat(e.fromId)}  →  ${flat(e.toId)}  (${e.why})`);
+  else console.log(`  (${edges.length - result.added} planned edge(s) were already present or lost an endpoint — re-run the dry run for the current pair list)`);
+  process.exit(0);
+} catch (e) {
+  console.error(`✗ orphans failed (brain unchanged): ${e?.message || e}`);
+  process.exit(1);
+}

package/bin/klypix-worker.mjs

@@ -131,6 +131,11 @@ await runVerb('brain-history', './klypix-brain-history.mjs');
 // the card's bytes to graveyard/ instead of destroying them; this lists, restores
 // and (permanently) purges them.
 await runVerb('brain-deleted', './klypix-brain-deleted.mjs');
+// `npx klypix-mcp orphans` — the orphan gardener's backfill: report how many live
+// cards sit outside the graph, link the CONFIDENT subset (one unambiguous lexical
+// anchor each — never a fan-out). Dry-run by default; --apply takes a forced
+// restore point first, so the whole pass is one brain-history restore from undone.
+await runVerb('orphans', './klypix-orphans.mjs');
 await runVerb('diff', './klypix-diff.mjs');
 await runVerb('pr-brief', './klypix-pr-brief.mjs');
 
@@ -868,8 +873,12 @@ server.registerTool('brain_sync', {
     // marker before rejecting them. A strict transport schema rejected first,
     // allowing a later result-less completion to bypass that state entirely.
     results: z.unknown().optional().describe('On phase complete, 1-8 result manifests for stable claim keys. The in-handler versioned validator rejects malformed, empty, unknown-field, or incomparable evidence and retains task scope.'),
+    releaseIntent: z.object({
+      version: z.string().max(64).describe('The version this session intends to release (e.g. "1.70.0").'),
+      ref: z.string().max(200).describe('The git ref (branch or tag) the release will be cut from.'),
+    }).optional().describe('Declare EXCLUSIVE intent to prepare a release of this project. The first declarer takes a ~2h lease (refreshed by checkpoints, freed by phase "complete", by expiry, or when the holder session ends); a second declarer gets a structured hard conflict naming the holder, version, and ref. While any lease is active every peer\'s sync gains a "release in preparation" footer line.'),
   },
-}, async ({ project, intent, files, phase, include_context, results }, extra) => {
+}, async ({ project, intent, files, phase, include_context, results, releaseIntent }, extra) => {
   const totalStartedAt = Date.now();
   const report = mcpPresence.sync({
     project,
@@ -877,6 +886,7 @@ server.registerTool('brain_sync', {
     files,
     phase,
     results,
+    releaseIntent,
     deliverMessages: include_context !== false,
     actionId: extra?.klypixRequestIdentity?.actionId || '',
     preflight: extra?.klypixBrainSyncPreflight,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klypix-mcp",
-  "version": "1.68.0",
+  "version": "1.70.0",
   "description": "Shared project brain and MCP coordination server for multi-agent coding.",
   "type": "module",
   "license": "Apache-2.0",
@@ -44,7 +44,8 @@
     "klypix-append": "bin/klypix-append.mjs",
     "klypix-install": "bin/klypix-install.mjs",
     "klypix-uninstall": "bin/klypix-uninstall.mjs",
-    "klypix-project-map": "bin/klypix-project-map.mjs"
+    "klypix-project-map": "bin/klypix-project-map.mjs",
+    "klypix-orphans": "bin/klypix-orphans.mjs"
   },
   "main": "index.mjs",
   "exports": {
@@ -83,7 +84,7 @@
     "bench": "node bin/klypix-mcp.mjs bench",
     "test:bench": "node test/bench.mjs",
     "pretest": "node test/publish-workflow.mjs",
-    "test": "node test/publish-verdict.mjs && node test/remote-client.mjs && node test/project-graph.mjs && node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/context-gateway.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/brief-and-recall.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/evidence-anchors.mjs && node test/presence-visibility.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/git-tools.mjs && node test/uninstall.mjs",
+    "test": "node test/publish-verdict.mjs && node test/remote-client.mjs && node test/project-graph.mjs && node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/context-gateway.mjs && node test/repo-state.mjs && node test/released-tag-guard.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/orphan-gardener.mjs && node test/brief-and-recall.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/retrieval-fusion.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/evidence-anchors.mjs && node test/presence-visibility.mjs && node test/presence-liveness.mjs && node test/observed-scope.mjs && node test/release-lease.mjs && node test/completion-guard.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/git-tools.mjs && node test/uninstall.mjs",
     "test:memory": "node test/memory-runtime.mjs",
     "test:memory:soak": "node --expose-gc test/memory-soak.mjs",
     "runtime": "node bin/klypix-runtime.mjs"