klypix-mcp 1.69.0 → 1.71.0

package/README.md

@@ -85,28 +85,55 @@ It verifies 15 required coordination behaviours — not the 26 tools, and not th
 
 ## Quick start
 
-**Claude Code + Codex:**
+Run this **inside your project**:
 
 ```bash
 npx klypix-mcp install
 ```
 
-This copies the engine and a local MCP runtime into `~/.claude/project-brain`, wires Claude Code's
-four lifecycle hooks, writes Codex's global `~/.codex/AGENTS.md` guidance block, and wires Codex's
-MCP connection **for the project you run it in**.
+One command, every editor. It finds the project root (walking up, so running it from `src/` is
+fine), gives the project a brain if it doesn't have one, wires the agent tools you actually have
+installed, registers the lossless `.klypix` merge driver if it's a git repo, and then **proves the
+result** before it exits:
+
+```text
+  project   E:\work\api  (git repository root)
+  brain     created brain.klypix — a starter brain, ready for its first decision
+  editors   Claude Code · Cursor · Codex · Gemini CLI · Antigravity · VS Code
+  wired     9 file(s) · 9 updated   (skipped 5 for tools you don't have)
+  git       lossless .klypix merge driver registered
+  verified  ✓ 26 tools reachable via .mcp.json (892ms)
+```
+
+That last line is the point. MCP config fails **silently** — a wrong entry means the server never
+starts, the agent quietly loses every brain verb, and nothing reports an error. So `install` opens
+a real stdio handshake against the config it just wrote and counts the tools that answered. A
+broken entry dies in ~100ms with `Connection closed` and is reported, not shipped.
+
+What goes where:
+
+- **Machine-global, once** — the engine + runtime in `~/.claude/project-brain`, Claude Code's four
+  lifecycle hooks in `~/.claude/settings.json`, and the `~/.codex/AGENTS.md` guidance block. Claude
+  Code is therefore covered in every project on that machine that has a `./brain.klypix`.
+- **Per project** — MCP config and rules for Cursor, Codex, Cline, Windsurf, Copilot, Gemini CLI /
+  Antigravity and Aider. Run `install` once inside each project.
 
-Be precise about what "machine-global" covers:
+Three things it deliberately will **not** do:
 
-- **Machine-global** — the engine + runtime in `~/.claude/project-brain`, the four Claude Code
-  hooks in `~/.claude/settings.json`, and the `~/.codex/AGENTS.md` guidance. Claude Code is
-  therefore covered in every project on that machine that has a `./brain.klypix`.
-- **Per project** — Codex's MCP connection. `install` writes it into `<cwd>/.codex/config.toml`,
-  only when that directory has a `brain.klypix`, and it deliberately **removes** any *global*
-  `~/.codex/config.toml` KLYPIX entry (a global entry resolves its `--vault` from the wrong
-  directory and binds the wrong brain). Run `install` — or `link` — once inside each brain project
-  you want Codex wired to.
+- **Write for editors you don't have.** Config is projected only for hosts detected on this
+  machine — a two-person team using one editor no longer commits rules for six they never opened.
+  A file your project *already* carries stays maintained regardless, so you can't silently stop
+  updating your team's committed configs.
+- **Wire a directory that isn't a project.** It refuses your home folder, a drive root, and
+  anything with no brain, no git repo and no project manifest. A mistyped command can't seed a
+  brain into `C:\Users\you`.
+- **Replace a project-owned server.** A repo-relative launch like
+  `node scripts/klypix-mcp-server.mjs` is deliberate — it resolves offline and rides a bundle the
+  repo version-gates — so it's left byte-identical and reported. An explicit `link` still rewrites
+  everything: an action you didn't ask for stays more conservative than one you did.
 
-It does **not** set up Cursor, Cline, Windsurf, Copilot, Gemini CLI or Aider — those need `link`.
+Opt out with `--no-project` (CI images, scripted provisioning). `--json` emits the report as
+structured data; `--verify-all` handshakes every written config instead of one.
 
 Optional, opt-in, and approved inside Codex itself:
 
@@ -119,15 +146,16 @@ file-overlap warning. Codex owns the trust decision and will ask you to review t
 `brain_doctor` reports this layer separately as off, execution-unverified, or active. Even with it
 on, **Codex never captures decisions automatically** — the Codex hook never writes the brain.
 
-**Every other agent tool — one command per project:**
+**Re-project everything explicitly:**
 
 ```bash
 npx klypix-mcp link
 ```
 
-Writes 14 managed, hash-stamped files: MCP server config for six hosts, plus rules files for
-eight. Managed blocks are merged into your existing instruction files and never clobber your
-content.
+`install` already does this for the editors you have. Reach for `link` when you want all 14
+managed, hash-stamped files regardless of what's installed — MCP server config for six hosts plus
+rules files for eight — or to repair drift. Managed blocks are merged into your existing
+instruction files and never clobber your content.
 
 ```bash
 npx klypix-mcp link --check    # audits without writing; exits non-zero on drift
@@ -481,8 +509,8 @@ The MCP verbs below are what agents call. These are what **you** call:
 | Command | What it does |
 |---|---|
 | `npx klypix-mcp init` | Seed a starter `brain.klypix` here and print an MCP config |
-| `npx klypix-mcp install` | Install the engine + Claude Code hooks on this machine (see Quick start) |
-| `npx klypix-mcp link` | Wire this project for Cursor, Cline, Windsurf, Copilot, Gemini CLI, Aider (`--check` audits) |
+| `npx klypix-mcp install` | Set up everything: machine engine + hooks, then this project — brain, config for the editors you have, merge driver, verified (see Quick start) |
+| `npx klypix-mcp link` | Re-project all 14 managed files regardless of what is installed (`--check` audits) |
 | `npx klypix-mcp doctor` | One verdict: version, hosts, live sessions, tool count, drift. Exits non-zero — usable as a CI gate |
 | `npx klypix-mcp runtime` | Passive per-connection process/RAM attribution (`--json`, optional `--watch seconds`); never kills or deduplicates |
 | `npx klypix-mcp conformance` | Launch two real MCP clients against this build and verify coordination behaviour |

package/bin/klypix-install.mjs

@@ -34,6 +34,7 @@ import {
 import { brainInstallDecision, deploySourceDecision } from '../src/install-version.mjs';
 import { acquireInstallLockSync, releaseInstallLockSync } from '../src/install-lock.mjs';
 import { collectRepoState } from '../src/repo-state.mjs';
+import { runSetup, renderBrief } from '../src/setup.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PKG_ROOT = path.resolve(__dirname, '..');
@@ -48,6 +49,12 @@ 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');
+// Project wiring is the default because it is the step users did not know
+// existed. These opt OUT for the cases that genuinely want machine-only:
+// CI images, scripted provisioning, and anyone wiring the project by hand.
+const NO_PROJECT = process.argv.includes('--no-project');
+const VERIFY_ALL = process.argv.includes('--verify-all');
+const SETUP_JSON = process.argv.includes('--json');
 // 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).
@@ -480,6 +487,24 @@ try {
         console.log('  Enhanced Codex auto-context + pre-edit overlap guard: re-run with `--codex-hooks`, then approve/review KLYPIX once in a Codex surface that supports hook trust.');
     }
     console.log('  Compatible brain-core updates hot-swap behind the same MCP connection. Only the one-time legacy→supervisor migration, a supervisor change, or an intentionally breaking tool/protocol change needs reconnect.');
+
+    // 9) PROJECT setup (1.71.0) — the step users never knew they had to take.
+    //    `install` wired the machine; without this it wired nothing a Cursor,
+    //    Antigravity, Codex, Cline or Copilot user could see, and the failure
+    //    was silent. A runtime-only refresh deliberately skips it: that path
+    //    exists to preserve every host/project config byte.
+    if (!RUNTIME_ONLY && !NO_PROJECT) {
+        try {
+            const report = await runSetup({ verifyAll: VERIFY_ALL });
+            if (SETUP_JSON) console.log(JSON.stringify(report, null, 2));
+            else console.log(renderBrief(report));
+        } catch (e) {
+            // The machine install already succeeded and is independently
+            // useful; a project-wiring failure must report itself, not undo it.
+            console.error(`⚠ project setup could not finish: ${e?.message || e}`);
+            console.error('  The machine install is intact — re-run inside your project, or use `npx klypix-mcp link`.');
+        }
+    }
     console.log('  Verify anytime: `npx klypix-mcp doctor`; prove two-client behavior with `npx klypix-mcp conformance`.');
 } catch (e) {
     releaseInstallLockSync(installLock);

package/bin/klypix-mcp.mjs

@@ -19,13 +19,14 @@ 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.`,
   '',
   'Verbs:',
-  '  install [--force] [--codex-hooks]   install/update this machine\'s brain engine + Claude Code hooks',
+  '  install [--force] [--codex-hooks]   set up everything: machine engine + Claude hooks, then THIS project —',
+  '          [--no-project] [--json]     brain, config for the editors you actually have, merge driver, verified',
   '  link [dir] [--check]                project this project\'s 14 managed agent config files (--check audits, writes nothing, exits 1 on drift)',
   '  doctor [--npm] [--all] [--json]     read-only self-check; exits 1 on drift',
   '  runtime [--json] [--watch seconds]  passive MCP process/RAM attribution; never terminates a process',
@@ -38,6 +39,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.69.0",
+  "version": "1.71.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/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/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/presence-liveness.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": "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/undeclared-active.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/one-command-setup.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"