slashvibe-mcp 0.8.18 → 0.8.20

package/capabilities.js

@@ -0,0 +1,133 @@
+/**
+ * The truthful local capability manifest — the runtime kernel's one answer to
+ * "what can this install actually do, right now, for this person?"
+ *
+ * Canon (platform PR #333 / epic #329): the runtime COORDINATES capabilities;
+ * it does not ingest or centralize them. Discovery must not read private data
+ * or silently install anything. Every capability reports exactly one of:
+ *
+ *   granted     — an explicit, revocable grant exists and the capability works
+ *   available   — the provider is present locally; no grant yet (or none needed)
+ *   off         — the person turned it off (env flag); presence not probed
+ *   unavailable — no provider detected; said plainly, never guessed around
+ *
+ * Detection is EXISTENCE-ONLY: fs.existsSync / lstat on well-known paths and
+ * PATH entries. No file contents are read here except the Mind bearer's
+ * permission bits (personal-mind.js, which reads its own 0600 token — that IS
+ * the grant). No subprocess runs. No network.
+ */
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const personalMind = require('./personal-mind');
+const authStore = require('./auth-store');
+
+const OFF_VALUES = new Set(['off', '0', 'false', 'no']);
+
+function envOff(name) {
+  return OFF_VALUES.has(String(process.env[name] || '').toLowerCase());
+}
+
+function onPath(binary) {
+  const entries = String(process.env.PATH || '').split(path.delimiter);
+  return entries.some((dir) => {
+    try {
+      return dir && fs.existsSync(path.join(dir, binary));
+    } catch {
+      return false;
+    }
+  });
+}
+
+function vibeCheckPresent() {
+  // Stan's collector: the db location is its documented contract. Existence
+  // only — the database is never opened by discovery.
+  return (
+    fs.existsSync(path.join(os.homedir(), '.vibe-check', 'vibe_check.db')) ||
+    onPath('vibe-check')
+  );
+}
+
+function executableFile(p) {
+  // Available must mean RUNNABLE: a regular file with an execute bit. A
+  // directory or a mode-0600 blob is not a provider (review P1).
+  try {
+    const st = fs.statSync(p);
+    return st.isFile() && (st.mode & 0o111) !== 0;
+  } catch {
+    return false;
+  }
+}
+
+function vibeStatsProvider() {
+  // Provider contract: an executable named `vibestats`, or an explicit path
+  // in VIBE_STATS_CLI. Executability is checked; nothing is executed during
+  // discovery.
+  const explicit = process.env.VIBE_STATS_CLI;
+  if (explicit) return executableFile(explicit) ? explicit : null;
+  const entries = String(process.env.PATH || '').split(path.delimiter);
+  for (const dir of entries) {
+    if (dir && executableFile(path.join(dir, 'vibestats'))) return path.join(dir, 'vibestats');
+  }
+  return null;
+}
+
+/**
+ * The manifest. Pure with respect to the wire: nothing here talks to the
+ * platform or any provider — states describe THIS machine, honestly.
+ */
+function manifest() {
+  // The CREDENTIAL answers, in memory — never the filesystem, and never a
+  // remembered username without a credential (review P1: a leftover name is
+  // not a principal). authStore hydrates once at server boot.
+  const message = authStore.isAuthenticated()
+    ? { state: 'granted', why: 'signed in as one /vibe principal' }
+    : { state: 'available', why: 'runtime installed; sign in with vibe start' };
+
+  let remember;
+  if (envOff('VIBE_REMEMBER')) {
+    remember = { state: 'off', why: 'VIBE_REMEMBER is off; providers not probed' };
+  } else if (personalMind.isAvailable()) {
+    remember = { state: 'granted', why: 'Personal Mind activation present (revocable: remove the activation file)' };
+  } else if (vibeCheckPresent()) {
+    remember = { state: 'available', why: 'VibeCheck detected locally; no Mind grant activated' };
+  } else {
+    remember = { state: 'unavailable', why: 'no local memory provider detected' };
+  }
+
+  let reflect;
+  if (envOff('VIBE_REFLECT')) {
+    reflect = { state: 'off', why: 'VIBE_REFLECT is off; providers not probed' };
+  } else {
+    const provider = vibeStatsProvider();
+    reflect = provider
+      ? { state: 'available', why: `VibeStats provider present (${path.basename(provider)})` }
+      : { state: 'unavailable', why: 'no local VibeStats provider detected' };
+  }
+
+  const call = envOff('VIBE_CALL')
+    ? { state: 'off', why: 'VIBE_CALL is off' }
+    : { state: 'available', why: 'explicit live-room handoff via calljimmy.ai; nothing joins without a person' };
+
+  return {
+    message: { provider: '/vibe', ...message },
+    remember: { provider: 'vibecheck', ...remember },
+    reflect: { provider: 'vibestats', ...reflect },
+    call: { provider: 'vibeconf', ...call },
+  };
+}
+
+const STATE_GLYPH = { granted: '●', available: '○', off: '·', unavailable: '—' };
+
+function renderLine(verb, cap) {
+  return `${STATE_GLYPH[cap.state] || '?'} ${verb} — ${cap.state} · ${cap.why}`;
+}
+
+function render(m = manifest()) {
+  return ['remember', 'reflect', 'message', 'call']
+    .map((verb) => renderLine(verb, m[verb]))
+    .join('\n');
+}
+
+module.exports = { manifest, render, _detect: { envOff, onPath, vibeCheckPresent, vibeStatsProvider } };

package/index.js

@@ -14,6 +14,7 @@ const presence = require('./presence');
 const config = require('./config');
 const store = require('./store');
 const prompts = require('./prompts');
+const toolPrivacy = require('./tool-privacy');
 const NotificationEmitter = require('./notification-emitter');
 const authStore = require('./auth-store');
 const actorSession = require('./actor-session');
@@ -47,7 +48,11 @@ const SERVER_CAPABILITIES = {
 };
 
 // Tools that shouldn't show presence footer (would be redundant/noisy)
-const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update'];
+// The local-only verbs make NO platform side effects (review P1): the
+// ambient footer performs platform requests, so remember/reflect/call and
+// the manifest never carry it.
+const SKIP_FOOTER_TOOLS = ['vibe_init', 'vibe_doctor', 'vibe_test', 'vibe_update',
+  'vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call'];
 
 // Progressive disclosure: only these tools are visible before authentication
 // After auth, the full toolset is revealed via tools/list_changed notification
@@ -59,12 +64,19 @@ const PRE_AUTH_TOOLS = new Set([
   'vibe_dm',      // Shown so users can try — triggers auth gate
   'vibe_inbox',   // Shown so users can try — triggers auth gate
   'vibe_status',  // Shown so users can try — triggers auth gate
-  'vibe_help'     // Always accessible
+  'vibe_help',    // Always accessible
+  // The truthful capability manifest is exactly what a fresh install should
+  // be able to ask: it reads no private data and reports message as
+  // "available · sign in with vibe start" until a principal exists.
+  'vibe_capabilities'
 ]);
 
 // Tools that genuinely work without authentication
 const NO_AUTH_REQUIRED = new Set([
-  'vibe_start', 'vibe_init', 'vibe_token', 'vibe_who', 'vibe_help'
+  'vibe_start', 'vibe_init', 'vibe_token', 'vibe_who', 'vibe_help',
+  // The manifest is local truth; signed out it must ANSWER (message:
+  // available · sign in), never start an auth flow (review P1).
+  'vibe_capabilities'
 ]);
 
 // "Is this session signed in" — the credential answers, not the filesystem.
@@ -305,6 +317,15 @@ const kernelTools = {
   // Utility
   vibe_help: require('./tools/help'),
   vibe_bye: require('./tools/bye'),
+
+  // ── The four verbs (canon PR #333 / epic #329) ─────────────────────────
+  // remember · reflect · message · call. Messaging IS vibe_dm/inbox/reply
+  // above; these three complete the verb set, and the manifest tells the
+  // truth about every one of them. Install once is not consent once.
+  vibe_capabilities: require('./tools/capabilities'),
+  vibe_remember: require('./tools/remember'),
+  vibe_reflect: require('./tools/reflect'),
+  vibe_call: require('./tools/call'),
 };
 
 // ─── Extras ──────────────────────────────────────────────────────────────
@@ -352,7 +373,13 @@ const adminTools = process.env.VIBE_ADMIN === 'true' ? {
   vibe_patterns: require('./tools/patterns'),
 } : {};
 
-// Combine tools — kernel always; extras only when opted in
+// The Personal Mind seam now answers through the verb: vibe_remember reports
+// the capability state honestly without a grant and consults the private edge
+// with one. The vibe_mind name is retired from tools/list; its engine
+// (tools/mind.js) is the granted path inside vibe_remember.
+
+// Combine tools — kernel always (the four verbs report their own truthful
+// states); extras only when opted in.
 const tools = { ...kernelTools, ...(EXTRAS_ENABLED ? extraTools : {}), ...adminTools };
 
 /**
@@ -559,16 +586,21 @@ class VibeMCPServer {
               global.vibeNotifier?.emitImmediate();
             }
 
-            return {
-              jsonrpc: '2.0',
-              id,
-              result: {
-                content: [{
-                  type: 'text',
-                  text: `> _You tried to **${actionName}** — signing you in first._\n\n${initDisplay}\n\n---\n💡 **You're in!** Try your \`${actionName}\` command again.`
-                }]
-              }
+            // Sign-in is non-blocking now: init returns auth_required and the
+            // person finishes in a browser. Only claim "You're in!" when the
+            // credential actually exists (review P1) — otherwise relay init's
+            // honest state and its structured mirror.
+            const signedIn = isAuthed();
+            const gateResult = {
+              content: [{
+                type: 'text',
+                text: signedIn
+                  ? `> _You tried to **${actionName}** — signing you in first._\n\n${initDisplay}\n\n---\n💡 **You're in!** Try your \`${actionName}\` command again.`
+                  : `> _You tried to **${actionName}** — sign in first._\n\n${initDisplay}\n\n---\n_Then say \`${actionName}\` again._`
+              }]
             };
+            if (initResult.structured) gateResult.structuredContent = initResult.structured;
+            return { jsonrpc: '2.0', id, result: gateResult };
           } catch (e) {
             return {
               jsonrpc: '2.0',
@@ -586,7 +618,13 @@ class VibeMCPServer {
         try {
           // Log prompt pattern (if _prompt passed) or infer from args
           const args = params.arguments || {};
-          const inferredPrompt = args._prompt || inferPromptFromArgs(params.name, args);
+          // Personal Mind inputs are unsent thought, not product analytics.
+          // Do not retain even a derived prompt or recipient for this tool.
+          const inferredPrompt = toolPrivacy.retainedPrompt(
+            params.name,
+            args,
+            inferPromptFromArgs,
+          );
           if (inferredPrompt) {
             prompts.log(inferredPrompt, {
               tool: params.name,
@@ -622,7 +660,7 @@ class VibeMCPServer {
           // State-changing tools bust the cache first so the footer reflects
           // what they just did (e.g. inbox read clears the unread badge).
           let footer = '';
-          if (!SKIP_FOOTER_TOOLS.includes(params.name)) {
+          if (toolPrivacy.shouldAppendAmbientFooter(params.name, SKIP_FOOTER_TOOLS)) {
             if (AMBIENT_CACHE_BUSTERS.has(params.name)) bustAmbientCache();
             footer = await resolveFooter(result, getPresenceFooter);
           }

package/notification-emitter.js

@@ -30,7 +30,7 @@ class NotificationEmitter {
     this.debounceTimers[reason] = setTimeout(() => {
       try {
         this.server.notification({
-          method: "notifications/list_changed"
+          method: "notifications/tools/list_changed"
         });
         delete this.debounceTimers[reason];
       } catch (e) {
@@ -47,7 +47,7 @@ class NotificationEmitter {
   emitImmediate() {
     try {
       this.server.notification({
-        method: "notifications/list_changed"
+        method: "notifications/tools/list_changed"
       });
     } catch (e) {
       // Silent fail

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "slashvibe-mcp",
-  "version": "0.8.18",
+  "version": "0.8.20",
   "mcpName": "io.github.vibecodinginc/vibe",
-  "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) — the /vibe kernel",
+  "description": "Presence + messaging for terminal coding agents (Claude Code, Codex, Cursor) \u2014 the /vibe kernel",
   "main": "index.js",
   "bin": {
     "slashvibe-mcp": "cli.js",
@@ -48,15 +48,16 @@
   },
   "files": [
     "README.md",
-    "api-auth.js",
     "actor-session.js",
+    "ambient-escapes.js",
+    "api-auth.js",
     "auth-store.js",
     "auto-update.js",
+    "capabilities.js",
     "cli.js",
     "config.js",
     "crypto.js",
     "discord.js",
-    "ambient-escapes.js",
     "footer.js",
     "games/chess.js",
     "hook-cli.js",
@@ -70,20 +71,23 @@
     "memory.js",
     "notification-emitter.js",
     "oauth-callback.js",
+    "personal-mind.js",
     "presence.js",
     "prompts.js",
     "protocol/handle.js",
     "protocol/index.js",
     "resources/presence-board.js",
     "resources/vibe-tokens.json",
-    "setup.js",
-    "vibe-home.js",
-    "session-start-hook.cjs",
+    "scripts/reflect-provider-canary.mjs",
+    "scripts/verb-canary.mjs",
     "session-start-hook-settings.js",
+    "session-start-hook.cjs",
+    "setup.js",
     "store/api.js",
     "store/index.js",
     "store/local.js",
     "store/profiles.js",
+    "tool-privacy.js",
     "tools/_actions.js",
     "tools/_discovery.js",
     "tools/_shared.js",
@@ -91,6 +95,8 @@
     "tools/admin-inbox.js",
     "tools/artifact-view.js",
     "tools/bye.js",
+    "tools/call.js",
+    "tools/capabilities.js",
     "tools/corpse.js",
     "tools/dm.js",
     "tools/doctor.js",
@@ -103,9 +109,12 @@
     "tools/inbox.js",
     "tools/init.js",
     "tools/intro.js",
+    "tools/mind.js",
     "tools/patterns.js",
     "tools/play.js",
     "tools/poem.js",
+    "tools/reflect.js",
+    "tools/remember.js",
     "tools/reply.js",
     "tools/ship.js",
     "tools/start.js",
@@ -116,6 +125,7 @@
     "tools/update.js",
     "tools/weave.js",
     "tools/who.js",
-    "version.json"
+    "version.json",
+    "vibe-home.js"
   ]
 }

package/personal-mind.js

@@ -0,0 +1,160 @@
+/**
+ * Private Personal Mind transport for terminal hosts.
+ *
+ * This module is deliberately unable to call Platform. It accepts only the
+ * unsent active draft and up to eight recent visible messages, calls one fixed
+ * Tailnet origin, and writes nothing. The bearer stays in a regular 0600 file
+ * under the current identity directory.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { vibeHome } = require('./vibe-home');
+
+const MIND_ORIGIN = 'http://100.121.205.111:7788';
+const MAX_HANDLE_BYTES = 64;
+const MAX_DRAFT_BYTES = 4_000;
+const MAX_CONTEXT_BYTES = 2_000;
+const MAX_RECENT_MESSAGES = 8;
+const MAX_RESPONSE_BYTES = 256 * 1_024;
+const PRIME_TIMEOUT_MS = 2_500;
+
+const UNAVAILABLE = Symbol('unavailable');
+
+function tokenPath() {
+  return path.join(vibeHome(), 'mind', 'runtime-token');
+}
+
+function readPrivateToken(file = tokenPath()) {
+  try {
+    const stat = fs.lstatSync(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0) return null;
+    const token = fs.readFileSync(file, 'utf8').trim();
+    const size = Buffer.byteLength(token, 'utf8');
+    if (size < 24 || size > 512 || /\s/.test(token)) return null;
+    return token;
+  } catch {
+    return null;
+  }
+}
+
+function isAvailable() {
+  return readPrivateToken() !== null;
+}
+
+function validHandle(handle) {
+  return typeof handle === 'string'
+    && Buffer.byteLength(handle, 'utf8') > 0
+    && Buffer.byteLength(handle, 'utf8') <= MAX_HANDLE_BYTES
+    && /^@?[a-zA-Z0-9_-]+$/.test(handle);
+}
+
+function utf8Prefix(value, limit) {
+  const text = String(value || '');
+  if (Buffer.byteLength(text, 'utf8') <= limit) return text;
+  let out = '';
+  for (const char of text) {
+    if (Buffer.byteLength(out + char, 'utf8') > limit) break;
+    out += char;
+  }
+  return out;
+}
+
+function recentContext(messages) {
+  if (!Array.isArray(messages)) return '';
+  const visible = messages.slice(-MAX_RECENT_MESSAGES).map((message) => {
+    const from = String(message?.from || '').replace(/[\r\n]/g, ' ').slice(0, 64);
+    const text = String(message?.text || '').replace(/\r\n?/g, '\n');
+    return `${from || 'unknown'}: ${text}`;
+  }).join('\n');
+  return utf8Prefix(visible, MAX_CONTEXT_BYTES);
+}
+
+async function boundedJSON(response) {
+  const declared = Number(response.headers?.get?.('content-length') || 0);
+  if (declared > MAX_RESPONSE_BYTES) return null;
+  if (!response.body?.getReader) {
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (bytes.length > MAX_RESPONSE_BYTES) return null;
+    return JSON.parse(bytes.toString('utf8'));
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let size = 0;
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    size += value.byteLength;
+    if (size > MAX_RESPONSE_BYTES) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(Buffer.from(value));
+  }
+  return JSON.parse(Buffer.concat(chunks, size).toString('utf8'));
+}
+
+async function post(route, payload, token, timeoutMs, fetchImpl = global.fetch) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(`${MIND_ORIGIN}${route}`, {
+      method: 'POST',
+      redirect: 'error',
+      signal: controller.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify(payload),
+    });
+    if (response.status === 401 || response.status === 403) return UNAVAILABLE;
+    if (!response.ok) return null;
+    return await boundedJSON(response);
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function ask({ handle, draft, recentMessages = [] }, fetchImpl = global.fetch) {
+  const normalizedHandle = String(handle || '').replace(/^@/, '').trim();
+  const activeDraft = String(draft || '');
+  if (!validHandle(normalizedHandle) || !activeDraft.trim()) return { error: 'invalid_input' };
+  if (Buffer.byteLength(activeDraft, 'utf8') > MAX_DRAFT_BYTES) {
+    return { error: 'draft_too_large' };
+  }
+  const token = readPrivateToken();
+  if (!token) return { error: 'unavailable' };
+
+  const context = recentContext(recentMessages);
+  if (context) {
+    // Priming is an optimization. A miss or timeout falls through to the same
+    // slow-path facet request; composing and sending never depend on it.
+    await post('/prime', { handle: normalizedHandle, context }, token, PRIME_TIMEOUT_MS, fetchImpl);
+  }
+  const facet = await post(
+    '/facet',
+    { handle: normalizedHandle, draft: activeDraft },
+    token,
+    90_000,
+    fetchImpl,
+  );
+  if (facet === UNAVAILABLE) return { error: 'unavailable' };
+  if (!facet || facet.silence) return { silence: true };
+  return { facet };
+}
+
+module.exports = {
+  MIND_ORIGIN,
+  MAX_DRAFT_BYTES,
+  MAX_CONTEXT_BYTES,
+  MAX_RECENT_MESSAGES,
+  PRIME_TIMEOUT_MS,
+  tokenPath,
+  readPrivateToken,
+  isAvailable,
+  recentContext,
+  ask,
+};

package/scripts/reflect-provider-canary.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+/**
+ * Real-provider reflect canary (vibe-mcp#24 acceptance): run vibe_reflect
+ * against the ACTUAL VibeStats executable named by VIBE_STATS_CLI and prove
+ * the integration — shape, provenance, and privacy (this canary prints NO
+ * reflection content, only verdicts).
+ */
+import { existsSync } from 'node:fs';
+
+const cli = process.env.VIBE_STATS_CLI;
+if (!cli || !existsSync(cli)) {
+  console.log('SKIP: set VIBE_STATS_CLI to the real vibestats executable');
+  process.exit(2);
+}
+const { createRequire } = await import('node:module');
+const require = createRequire(import.meta.url);
+const reflect = require('../tools/reflect.js');
+
+const res = await reflect.handler({});
+const d = res.data || {};
+// The canary certifies INTEGRATION: only a real reflection is a PASS
+// (review round 2: no_data must not pass vacuously — it exits 3, honest but
+// uncertified, so CI on a data-less machine cannot green-wash the contract).
+if (d.outcome === 'no_data') {
+  console.log(`NO_DATA: real provider ran but this machine has no /insights data — integration NOT certified here`);
+  process.exit(3);
+}
+const problems = [];
+if (d.outcome !== 'reflection') problems.push(`outcome ${d.outcome}, wanted reflection`);
+if (typeof d.archetype !== 'string' || !d.archetype.trim()) problems.push('no archetype string');
+if (!d.provenance || !d.provenance.version) problems.push('no provider version provenance');
+if (!/private reflection/.test(res.display)) problems.push('display missing private framing');
+const verdict = problems.length ? 'FAIL' : 'PASS';
+console.log(`${verdict}: real provider ${cli.split('/').slice(-2).join('/')} · archetype=[${d.archetype ? 'present, not printed' : 'absent'}] · version=${d.provenance?.version || 'n/a'}${problems.length ? ' · ' + problems.join(' | ') : ''}`);
+process.exit(problems.length ? 1 : 0);

package/scripts/verb-canary.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * Runtime-kernel canary (epic #329 acceptance 1 + 3): boot the REAL MCP
+ * server over stdio under Claude Code and Codex host environments; verify
+ * the four verbs + manifest register and every capability reports a legal,
+ * reasoned state. Machine-verifiable; exits non-zero on any dishonesty.
+ */
+import { spawn } from 'node:child_process';
+import { mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
+const VERBS = ['vibe_capabilities', 'vibe_remember', 'vibe_reflect', 'vibe_call', 'vibe_dm', 'vibe_inbox', 'vibe_reply'];
+const LEGAL = new Set(['granted', 'available', 'off', 'unavailable']);
+
+function rpc(child, msg) {
+  child.stdin.write(JSON.stringify(msg) + '\n');
+}
+
+function runHost(name, env) {
+  return new Promise((resolve, reject) => {
+    const home = mkdtempSync(join(tmpdir(), `verb-canary-${name}-`));
+    // A synthetic signed-in principal (same shape the test suite uses) so the
+    // canary sees the POST-auth surface; nothing here can reach the network.
+    const b64 = (o) => Buffer.from(JSON.stringify(o)).toString('base64url');
+    writeFileSync(join(home, 'config.json'), JSON.stringify({
+      username: 'canary',
+      authMethod: 'github',
+      authToken: `h.${b64({ sub: 'canary', exp: Math.floor(Date.now() / 1000) + 86400 })}.sig`,
+      one_liner: 'verb canary',
+    }));
+    const child = spawn('node', [join(ROOT, 'index.js')], {
+      env: { ...process.env, ...env, VIBE_HOME: home, VIBE_SETUP_NO_AUTORUN: '1' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const results = {};
+    let buffer = '';
+    const timer = setTimeout(() => { child.kill(); reject(new Error(`${name}: timeout`)); }, 15000);
+    child.stdout.on('data', (d) => {
+      buffer += d.toString();
+      let idx;
+      while ((idx = buffer.indexOf('\n')) >= 0) {
+        const line = buffer.slice(0, idx); buffer = buffer.slice(idx + 1);
+        if (!line.trim()) continue;
+        let msg; try { msg = JSON.parse(line); } catch { continue; }
+        if (msg.id === 1) {
+          rpc(child, { jsonrpc: '2.0', id: 2, method: 'tools/list' });
+        } else if (msg.id === 2) {
+          results.tools = (msg.result?.tools || []).map((t) => t.name);
+          rpc(child, { jsonrpc: '2.0', id: 3, method: 'tools/call', params: { name: 'vibe_capabilities', arguments: {} } });
+        } else if (msg.id === 3) {
+          const text = msg.result?.content?.[0]?.text || '';
+          results.manifestText = text;
+          clearTimeout(timer); child.kill();
+          resolve(results);
+        }
+      }
+    });
+    child.on('error', reject);
+    rpc(child, { jsonrpc: '2.0', id: 1, method: 'initialize', params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name, version: '1' } } });
+  });
+}
+
+// Deterministic expectations (review P2: no vacuous matching): the canary
+// pins each verb to ONE expected state on any machine — off flags make
+// remember/reflect/call machine-independent; the synthetic credential makes
+// message granted. Each verb must appear exactly once WITH a reason.
+const CONTROLLED_ENV = { VIBE_REMEMBER: 'off', VIBE_REFLECT: 'off', VIBE_CALL: 'off' };
+const EXPECTED = { remember: 'off', reflect: 'off', call: 'off', message: 'granted' };
+
+const hosts = {
+  'claude-code': { CLAUDECODE: '1', ...CONTROLLED_ENV },
+  codex: { CODEX_HOME: mkdtempSync(join(tmpdir(), 'codex-home-')), ...CONTROLLED_ENV },
+};
+
+let failed = false;
+for (const [name, env] of Object.entries(hosts)) {
+  const r = await runHost(name, env);
+  const missing = VERBS.filter((v) => !r.tools.includes(v));
+  const states = [...r.manifestText.matchAll(/(remember|reflect|message|call) — (\w+) · (.+)/g)];
+  const seen = new Map(states.map(([, verb, state, why]) => [verb, { state, why }]));
+  const problems = [];
+  if (states.length !== 4) problems.push(`expected 4 state lines, saw ${states.length}`);
+  for (const [verb, want] of Object.entries(EXPECTED)) {
+    const got = seen.get(verb);
+    if (!got) problems.push(`${verb}: missing`);
+    else {
+      if (!LEGAL.has(got.state)) problems.push(`${verb}: illegal state ${got.state}`);
+      if (got.state !== want) problems.push(`${verb}: expected ${want}, got ${got.state}`);
+      if (!got.why || got.why.trim().length < 5) problems.push(`${verb}: no reason given`);
+    }
+  }
+  if (missing.length) problems.push(`missing tools: ${missing}`);
+  if (r.tools.includes('vibe_mind')) problems.push('retired vibe_mind still listed');
+  if (r.tools.includes('vibe_doctor')) problems.push('admin doctor leaked into default list');
+  const ok = problems.length === 0;
+  console.log(`${ok ? 'PASS' : 'FAIL'} ${name}: ${r.tools.length} tools; ${[...seen].map(([v, g]) => `${v}=${g.state}`).join(' ')}${ok ? '' : '; PROBLEMS: ' + problems.join(' | ')}`);
+  if (!ok) failed = true;
+}
+process.exit(failed ? 1 : 0);