@su-record/vibe 4.2.35 → 4.2.37

package/hooks/session.js

@@ -5,13 +5,25 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import codeMap from './code-map.cjs';
 import knowledgeAuto from './knowledge-auto.cjs';
+import locations from './locations.cjs';
 import sessionRuntime from './session-state.cjs';
 import sessionFiles from './session-files.cjs';
 
+const { claudeHome, codexHome } = locations;
+
+const READ_MAX_BYTES = 64 * 1024;
+const CARD_MAX_BYTES = 4096;
+const CARD_FILE = 'card.md';
+// The marker vibe's installer wraps its section of the home instruction file in.
+const HOME_MARKER = '<!-- vibe:start -->';
+
 const client = process.argv[2] || 'claude';
 const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 const home = process.env.VIBE_HOME_DIR || os.homedir();
-function read(file, limit = 65536) {
+const emit = (hookEventName, additionalContext, extra = {}) => {
+  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext }, ...extra })}\n`);
+};
+function read(file, limit = READ_MAX_BYTES) {
   try { return sessionFiles.optional(file, limit) ?? ''; }
   catch { return ''; }
 }
@@ -19,21 +31,20 @@ function payload() {
   try { return sessionFiles.readPayload(); }
   catch { return { session_id: 'invalid payload' }; }
 }
-const card = read(path.join(root, 'card.md'), 4096).trim();
-const homeCard = client === 'claude' ? path.join(home, '.claude', 'CLAUDE.md') : path.join(home, '.codex', 'AGENTS.md');
-const homeOwns = read(homeCard).includes('<!-- vibe:start -->');
+const card = read(path.join(root, CARD_FILE), CARD_MAX_BYTES).trim();
+const homeCard = client === 'claude' ? claudeHome(home, 'CLAUDE.md') : codexHome(home, 'AGENTS.md');
+const homeOwns = read(homeCard).includes(HOME_MARKER);
 // SubagentStart: session context never reaches a subagent, so each one gets the card the home card does not already carry.
 if (process.argv[3] === 'subagent') {
-  if (!homeOwns && card) process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SubagentStart', additionalContext: card } })}\n`);
+  if (!homeOwns && card) emit('SubagentStart', card);
   process.exit(0);
 }
 const input = payload();
 const recall = knowledgeAuto.start(input);
 const view = sessionRuntime.sessionStatus(input);
-const status = view.status === 'bound' ? 'session status only; run vibe state for the procedure' : `${view.status}; use explicit vibe session bind in the intended worktree`;
-const note = sessionRuntime.message(view, status);
+const note = sessionRuntime.structuralNote(view);
 const map = codeMap.codeMap(process.env.CLAUDE_PROJECT_DIR || input.cwd || process.cwd());
 const text = [homeOwns ? note : `${card}\n\n${note}`, recall, map].filter(Boolean).join('\n');
 // Codex has no status surface a plugin can draw on; a systemMessage is the one line it shows the person.
 const line = client === 'codex' && view.root ? sessionRuntime.overview(view.root) : null;
-process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text }, ...(line ? { systemMessage: line } : {}) })}\n`);
+emit('SessionStart', text, line ? { systemMessage: line } : {});

package/hooks/slice-command.cjs

@@ -1,8 +1,14 @@
 const path = require('node:path');
 
+const MAX_COMMAND_CHARS = 64 * 1024;
+const MAX_TOKENS = 2048;
+const MAX_TARGETS = 256;
+// A nested `bash -c` is followed once.
+const MAX_NESTING = 1;
+
 // A bounded lexical recognizer, never a shell evaluator. Dynamic expansions remain unresolved.
 function tokenize(text) {
-  if (typeof text !== 'string' || text.length > 65536) return null;
+  if (typeof text !== 'string' || text.length > MAX_COMMAND_CHARS) return null;
   const tokens = [];
   let word = '', quote = '';
   const flush = () => { if (word) tokens.push(word); word = ''; };
@@ -17,7 +23,7 @@ function tokenize(text) {
     else if (/[\n|;&<>]/.test(ch)) { flush(); tokens.push(['|', '&', '<', '>'].includes(ch) && text[i + 1] === ch ? ch + text[++i] : ch); }
     else if (/\s/.test(ch)) flush();
     else word += ch;
-    if (tokens.length > 2048) return null;
+    if (tokens.length > MAX_TOKENS) return null;
   }
   if (quote) return null;
   flush();
@@ -60,43 +66,58 @@ function operands(args, valued = []) {
   }
   return out;
 }
+const NAMES_ONLY_OPTION = /^--files(?:-with-matches|-without-match)?$|^-(?!-)[A-Za-z]*[lL][A-Za-z]*$/;
+// grep and rg options whose next word is a value, not a file.
+const GREP_VALUED = [
+  '-e', '--regexp', '-f', '--file', '-g', '--glob', '-t', '--type', '-T', '--type-not', '-m', '--max-count', '--max-columns', '--max-depth',
+  '-A', '-B', '-C',
+];
+// Options of the line transformers whose next word is a value, not a file.
+const TRANSFORM_VALUED = {
+  nl: [
+    '-b', '-d', '-f', '-h', '-i', '-l', '-n', '-s', '-v', '--body-numbering', '--section-delimiter', '--footer-numbering',
+    '--header-numbering', '--line-increment', '--join-blank-lines', '--number-format', '--number-separator', '--starting-line-number',
+  ],
+  sort: ['-k', '-t', '-o', '-T', '-S', '--key', '--field-separator', '--output', '--temporary-directory', '--buffer-size', '--parallel'],
+  uniq: ['-f', '-s', '-w', '--skip-fields', '--skip-chars', '--check-chars'],
+};
+const CUT_VALUED = ['-b', '-c', '-f', '-d', '--bytes', '--characters', '--fields', '--delimiter', '--output-delimiter'];
+const HEAD_VALUED = ['-n', '-c', '--lines', '--bytes', '--sleep-interval'];
+const SCRIPT_VALUED = ['-e', '-f', '--expression', '--file', '-F', '-v'];
 function grepInfo(name, args) {
   const options = args.filter(word => word.startsWith('-'));
-  const namesOnly = options.some(word => /^--files(?:-with-matches|-without-match)?$|^-(?!-)[A-Za-z]*[lL][A-Za-z]*$/.test(word));
+  const namesOnly = options.some(word => NAMES_ONLY_OPTION.test(word));
   const locations = namesOnly || options.some(word => word === '--line-number' || /^-[^-]*n/.test(word));
   const explicitPattern = args.some(word => ['-e', '--regexp', '-f', '--file'].includes(word) || /^--(?:regexp|file)=/.test(word));
-  const files = operands(args, ['-e', '--regexp', '-f', '--file', '-g', '--glob', '-t', '--type', '-T', '--type-not', '-m', '--max-count', '--max-columns', '--max-depth', '-A', '-B', '-C']);
+  const files = operands(args, GREP_VALUED);
   if (!explicitPattern && !options.includes('--files')) files.shift();
   return { files, slice: !locations, namesOnly, implicit: name === 'rg' || options.some(word => /^-[^-]*[rR]/.test(word)) };
 }
 function transformInfo(name, args) {
   if (name === 'tr') return { files: args.flatMap((word, index) => word === '<' && args[index + 1] ? [args[index + 1]] : []), slice: false };
-  const values = {
-    nl: ['-b', '-d', '-f', '-h', '-i', '-l', '-n', '-s', '-v', '--body-numbering', '--section-delimiter', '--footer-numbering', '--header-numbering', '--line-increment', '--join-blank-lines', '--number-format', '--number-separator', '--starting-line-number'],
-    sort: ['-k', '-t', '-o', '-T', '-S', '--key', '--field-separator', '--output', '--temporary-directory', '--buffer-size', '--parallel'],
-    uniq: ['-f', '-s', '-w', '--skip-fields', '--skip-chars', '--check-chars'],
-  };
-  if (!Object.hasOwn(values, name)) return null;
-  const files = operands(args, values[name]);
+  if (!Object.hasOwn(TRANSFORM_VALUED, name)) return null;
+  const files = operands(args, TRANSFORM_VALUED[name]);
   return { files: name === 'uniq' ? files.slice(0, 1) : files, slice: false };
 }
 function readerInfo(name, args) {
   if (['grep', 'rg'].includes(name)) return grepInfo(name, args);
   if (name === 'cat') return { files: operands(args), slice: false };
-  if (['head', 'tail'].includes(name)) return { files: operands(args, ['-n', '-c', '--lines', '--bytes', '--sleep-interval']), slice: true };
-  if (name === 'cut') return { files: operands(args, ['-b', '-c', '-f', '-d', '--bytes', '--characters', '--fields', '--delimiter', '--output-delimiter']), slice: true };
+  if (['head', 'tail'].includes(name)) return { files: operands(args, HEAD_VALUED), slice: true };
+  if (name === 'cut') return { files: operands(args, CUT_VALUED), slice: true };
   if (['sed', 'awk'].includes(name)) {
     const explicit = args.some(word => ['-e', '-f', '--expression', '--file'].includes(word));
-    const files = operands(args, ['-e', '-f', '--expression', '--file', '-F', '-v']);
+    const files = operands(args, SCRIPT_VALUED);
     if (!explicit) files.shift();
-    const slice = name === 'awk' ? args.some(word => /\bNR\b|\bprint\b/.test(word)) : args.some(word => /^-[^-]*n/.test(word) || word === '--quiet' || word === '--silent');
+    const awkSlice = word => /\bNR\b|\bprint\b/.test(word);
+    const sedSlice = word => /^-[^-]*n/.test(word) || word === '--quiet' || word === '--silent';
+    const slice = args.some(name === 'awk' ? awkSlice : sedSlice);
     return { files, slice };
   }
   return transformInfo(name, args);
 }
 function sliceTargets(text, cwd, depth = 0) {
   const tokens = tokenize(text);
-  if (!tokens || tokens.includes('<<') || depth > 1) return { unavailable: true, files: [] };
+  if (!tokens || tokens.includes('<<') || depth > MAX_NESTING) return { unavailable: true, files: [] };
   const found = new Set();
   let input = [], directory = cwd;
   for (const section of sections(tokens)) {
@@ -116,6 +137,6 @@ function sliceTargets(text, cwd, depth = 0) {
     if (info.slice) for (const file of input) found.add(file);
     if (info.namesOnly) input = [];
   }
-  return { unavailable: false, files: [...found].slice(0, 256) };
+  return { unavailable: false, files: [...found].slice(0, MAX_TARGETS) };
 }
 module.exports = { sliceTargets };

package/hooks/slice-guard.cjs

@@ -2,6 +2,15 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { sliceTargets } = require('./slice-command.cjs');
 const { readTargets, recordSlice } = require('./slice-store.cjs');
+/** Past this many lines a file only to be understood is better read by `vibe read --ask`. */
+const READ_ADVISE_LINES = 400;
+
+const SOURCE_EXTENSION = /\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|c|cpp|h|cs|rb|sh|sql|md|mdx|txt|rst|json|ya?ml|toml|ini|xml|html|css|csv|tsv)$/i;
+const SOURCE_NAME = /^(?:README|Dockerfile|Makefile)(?:\..*)?$/i;
+const PROTECTED_PATH = /(?:^|\/)scenarios\.ya?ml$|(?:^|\/)specs?(?:\/|$)/i;
+const BLOCKED = 'Partial reading of a protected file is blocked.';
+const WARNED = 'Partial source/document reading can omit requirements.';
+const INTENT_FILES = ['.vibe', '.vibe/intent.md'];
 
 function within(directory, file) {
   const relative = path.relative(directory, file);
@@ -13,17 +22,20 @@ function exempt(root, file) {
 }
 function protectedFile(root, file, files) {
   const relative = path.relative(root, file).split(path.sep).join('/');
-  if (relative === '.vibe' || relative === '.vibe/intent.md' || /(?:^|\/)scenarios\.ya?ml$/i.test(relative) || /(?:^|\/)specs?(?:\/|$)/i.test(relative)) return true;
+  if (INTENT_FILES.includes(relative) || PROTECTED_PATH.test(relative)) return true;
   return files.some(protectedPath => file === protectedPath || within(file, protectedPath));
 }
 function sourceFile(file) {
-  if (/\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|c|cpp|h|cs|rb|sh|sql|md|mdx|txt|rst|json|ya?ml|toml|ini|xml|html|css|csv|tsv)$/i.test(file)) return true;
-  if (/^(?:README|Dockerfile|Makefile)(?:\..*)?$/i.test(path.basename(file))) return true;
+  if (SOURCE_EXTENSION.test(file) || SOURCE_NAME.test(path.basename(file))) return true;
   try { return fs.lstatSync(file).isDirectory(); } catch { return false; }
 }
 function guidance(client) {
   const tool = client === 'codex' ? 'cat (the entire file)' : 'the Read tool (the entire file)';
-  return `Open the selected files in full with ${tool}. Read fewer files from vibe state; use grep/rg/find only to locate files or lines. For over 400 lines when not editing, use vibe read --ask.`;
+  return [
+    `Open the selected files in full with ${tool}.`,
+    'Read fewer files from vibe state; use grep/rg/find only to locate files or lines.',
+    `For over ${READ_ADVISE_LINES} lines when not editing, use vibe read --ask.`,
+  ].join(' ');
 }
 function sliceGuard(root, command, client = 'claude', cwd = root) {
   try { root = fs.realpathSync(root); cwd = fs.realpathSync(path.resolve(root, cwd)); } catch { return { decision: 'none', unavailable: true }; }
@@ -36,6 +48,8 @@ function sliceGuard(root, command, client = 'claude', cwd = root) {
   if (decision === 'none') return { decision, unavailable: !mirror.available };
   const recorded = recordSlice(root, decision);
   const unavailable = !mirror.available || !recorded;
-  return { decision, unavailable, recorded, message: `[vibe] ${decision === 'block' ? 'Partial reading of a protected file is blocked.' : 'Partial source/document reading can omit requirements.'} ${guidance(client)}${unavailable ? ' Read-target mirror or count storage unavailable.' : ''}` };
+  const headline = decision === 'block' ? BLOCKED : WARNED;
+  const storage = unavailable ? ' Read-target mirror or count storage unavailable.' : '';
+  return { decision, unavailable, recorded, message: `[vibe] ${headline} ${guidance(client)}${storage}` };
 }
-module.exports = { sliceGuard };
+module.exports = { READ_ADVISE_LINES, sliceGuard };

package/hooks/slice-store.cjs

@@ -2,8 +2,17 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { randomBytes } = require('node:crypto');
 const { privateDirectory, readPrivate, writePrivate } = require('./private-store.cjs');
-const { digest, json } = require('./session-files.cjs');
+const { STATE_FILE, INTENT_HASH, digest, json } = require('./session-files.cjs');
 
+const MAX_TARGETS = 2048;
+const MAX_PATH_CHARS = 4096;
+const TARGETS_MAX_BYTES = 128 * 1024;
+const MARKER_MAX_BYTES = 4096;
+// One tiny file per recorded slice; a directory with more than this many store files is not read.
+const MAX_STORE_FILES = 32768;
+const COUNT_MAX_BYTES = 128;
+const COUNT_SUFFIX_BYTES = 12;
+const targetsName = root => `read-targets-${digest(root)}.json`;
 const prefix = root => `slice-${digest(root)}-`;
 const markerName = root => `slice-counts-${digest(root)}.json`;
 function explicitHome(env) {
@@ -15,20 +24,24 @@ function explicitHome(env) {
 function recordReadTargets(root, input, env) {
   try {
     root = fs.realpathSync(root);
-    if (!input || !/^[a-f0-9]{16,64}$/.test(input.intentHash) || !Array.isArray(input.files) || input.files.length > 2048 || input.files.some(file => typeof file !== 'string' || file.length >= 4096)) return false;
+    if (!input || !INTENT_HASH.test(input.intentHash) || !Array.isArray(input.files) || input.files.length > MAX_TARGETS) return false;
+    if (input.files.some(file => typeof file !== 'string' || file.length >= MAX_PATH_CHARS)) return false;
     const files = [...new Set(input.files.map(file => path.resolve(root, file)))];
     const body = JSON.stringify({ schemaVersion: 1, root, intentHash: input.intentHash, files });
-    if (Buffer.byteLength(body) > 131072) return false;
-    writePrivate(root, `read-targets-${digest(root)}.json`, body, explicitHome(env));
+    if (Buffer.byteLength(body) > TARGETS_MAX_BYTES) return false;
+    writePrivate(root, targetsName(root), body, explicitHome(env));
     return true;
   } catch { return false; }
 }
 function readTargets(root) {
   try {
-    const raw = readPrivate(root, `read-targets-${digest(root)}.json`, 131072);
+    const raw = readPrivate(root, targetsName(root), TARGETS_MAX_BYTES);
     if (raw === null) return { available: false, files: [] };
-    const saved = JSON.parse(raw), state = json(path.join(root, '.vibe/state.json'));
-    if (saved.schemaVersion !== 1 || saved.root !== root || saved.intentHash !== state.intentHash || !Array.isArray(saved.files) || saved.files.length > 2048 || saved.files.some(file => typeof file !== 'string' || !path.isAbsolute(file))) return { available: false, files: [] };
+    const saved = JSON.parse(raw), state = json(path.join(root, STATE_FILE));
+    const valid = saved.schemaVersion === 1 && saved.root === root && saved.intentHash === state.intentHash
+      && Array.isArray(saved.files) && saved.files.length <= MAX_TARGETS
+      && saved.files.every(file => typeof file === 'string' && path.isAbsolute(file));
+    if (!valid) return { available: false, files: [] };
     return { available: true, files: saved.files };
   } catch { return { available: false, files: [] }; }
 }
@@ -37,7 +50,7 @@ function recordSlice(root, decision) {
     if (!['block', 'warn'].includes(decision)) return false;
     if (!initializeSliceCounts(root)) return false;
     const counts = { blocked: Number(decision === 'block'), warned: Number(decision === 'warn') };
-    writePrivate(root, `${prefix(root)}${randomBytes(12).toString('hex')}.json`, JSON.stringify(counts));
+    writePrivate(root, `${prefix(root)}${randomBytes(COUNT_SUFFIX_BYTES).toString('hex')}.json`, JSON.stringify(counts));
     return true;
   } catch { return false; }
 }
@@ -45,7 +58,7 @@ function initializeSliceCounts(root, env) {
   try {
     root = fs.realpathSync(root);
     const home = explicitHome(env);
-    const raw = readPrivate(root, markerName(root), 4096, home);
+    const raw = readPrivate(root, markerName(root), MARKER_MAX_BYTES, home);
     if (raw !== null) { const value = JSON.parse(raw); return value.schemaVersion === 1 && value.root === root; }
     writePrivate(root, markerName(root), JSON.stringify({ schemaVersion: 1, root }), home);
     return true;
@@ -55,14 +68,14 @@ function readSliceCounts(root, env) {
   try {
     root = fs.realpathSync(root);
     const home = explicitHome(env);
-    const marker = JSON.parse(readPrivate(root, markerName(root), 4096, home));
+    const marker = JSON.parse(readPrivate(root, markerName(root), MARKER_MAX_BYTES, home));
     if (!marker || marker.schemaVersion !== 1 || marker.root !== root) return null;
     const directory = privateDirectory(root, false, home);
     const files = fs.readdirSync(directory);
-    if (files.length > 32768) return null;
+    if (files.length > MAX_STORE_FILES) return null;
     const counts = { blocked: 0, warned: 0 };
     for (const file of files.filter(file => file.startsWith(prefix(root)))) {
-      const value = JSON.parse(readPrivate(root, file, 128, home));
+      const value = JSON.parse(readPrivate(root, file, COUNT_MAX_BYTES, home));
       if (!((value.blocked === 1 && value.warned === 0) || (value.blocked === 0 && value.warned === 1))) return null;
       counts.blocked += value.blocked; counts.warned += value.warned;
     }

package/internal/guides/code.md

@@ -38,6 +38,8 @@ Apply these antislop criteria while writing and revising the affected code, with
 - Name the operation or domain concept. Comments explain reasons and constraints rather than restating the code; errors identify the failed operation without leaking secrets.
 - Remove introduced dead code, placeholder implementations and swallowed errors. Preserve intentional recovery and established compatibility layers.
 - Test observable outcomes when tests are warranted. Do not add tests solely to mirror internal calls or prove cosmetic edits.
+- A test must be able to fail on a wrong result. Never write a fake test: one that asserts whatever the code returns now without knowing it is right, recomputes the expected value with a copy of the code's logic, asserts only that a mock was called, reads source code as text instead of running it, or asserts something always true.
+- After adding or changing tests, run `vibe mutate`: it plants small bugs in the changed source files with the project's mutation tool and lists the ones no test caught. For each: a boundary → add a case at that value; an untested branch → add an input that enters it; a constant such as a log message → leave it; the same behavior (an equivalent mutant) → skip it. The count is a sensor, not a target: never write a test only to raise it.
 
 Patterns are evidence to examine, not banned syntax: a single-implementation interface, defensive check or TODO can be justified. Fix a specific behavior or maintenance problem, not an aesthetic preference. Do not read the full legacy skill or run its editorial chain as an automatic follow-up.
 

package/mcpb/server/index.js

@@ -17,6 +17,22 @@ import readline from 'node:readline';
 const PROTOCOL = '2025-06-18';
 const VERSION = process.env.VIBE_MCPB_VERSION || '0.0.0';
 const project = process.env.VIBE_PROJECT_DIR || process.cwd();
+const VIBE_CLIENT = 'claude-app';
+const RUN_TIMEOUT_MS = 10 * 60 * 1000; // a check run may build and test the whole project
+const TOOL_PREFIX = 'vibe_';
+const INVALID_PARAMS = -32602;
+const METHOD_NOT_FOUND = -32601;
+const PARSE_ERROR = -32700;
+const INSTALL_HINT = 'npm i -g @su-record/vibe';
+const INSTRUCTIONS_TAIL = [
+  'Use the vibe tool with operation brief first; discover returns an internal operation schema.',
+  'The brief includes the personal FDE entry guidance; no extra model review by default.',
+  "Talk to the user in the user's language; write every record in English.",
+].join(' ');
+const ENTRY_DESCRIPTION = [
+  'Your personal FDE: project context, internal guidance, tools and skill extensions.',
+  'Use discover to inspect an operation before calling it.',
+].join(' ');
 
 const str = (description) => ({ type: 'string', description });
 const TOOLS = [
@@ -73,8 +89,11 @@ function findVibe() {
 const VIBE = findVibe();
 
 function runVibe(args, input) {
-  if (!VIBE) return { isError: true, text: 'the vibe CLI was not found — install it with `npm i -g @su-record/vibe`, or set its path in the extension settings (vibe executable)' };
-  const r = spawnSync(VIBE, [...args, '--json'], { cwd: project, encoding: 'utf-8', input, timeout: 600000, env: { ...process.env, VIBE_CLIENT: 'claude-app', PATH: `${path.dirname(VIBE)}${path.delimiter}${process.env.PATH || ''}` }, shell: process.platform === 'win32' });
+  if (!VIBE) {
+    return { isError: true, text: `the vibe CLI was not found — install it with \`${INSTALL_HINT}\`, or set its path in the extension settings (vibe executable)` };
+  }
+  const env = { ...process.env, VIBE_CLIENT, PATH: `${path.dirname(VIBE)}${path.delimiter}${process.env.PATH || ''}` };
+  const r = spawnSync(VIBE, [...args, '--json'], { cwd: project, encoding: 'utf-8', input, timeout: RUN_TIMEOUT_MS, env, shell: process.platform === 'win32' });
   if (r.error) return { isError: true, text: `could not run ${VIBE}: ${r.error.message}` };
   const text = (r.stdout || '').trim() || (r.stderr || '').trim() || `exit ${r.status}`;
   return { isError: r.status !== 0, text };
@@ -103,31 +122,40 @@ function handle(msg) {
   if (msg.id === undefined) return; // notification
   const { id, method, params = {} } = msg;
   if (method === 'initialize') {
-    return respond(id, { protocolVersion: params.protocolVersion || PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: 'vibe', version: VERSION }, instructions: `vibe project: ${project}${fs.existsSync(`${project}/.vibe`) ? '' : ' (no .vibe yet — the first intent draft creates it)'} · CLI ${VIBE || 'not found — npm i -g @su-record/vibe'}. Use the vibe tool with operation brief first; discover returns an internal operation schema. The brief includes the personal FDE entry guidance; no extra model review by default. Talk to the user in the user's language; write every record in English.` });
+    const fresh = fs.existsSync(`${project}/.vibe`) ? '' : ' (no .vibe yet — the first intent draft creates it)';
+    const instructions = `vibe project: ${project}${fresh} · CLI ${VIBE || `not found — ${INSTALL_HINT}`}. ${INSTRUCTIONS_TAIL}`;
+    return respond(id, { protocolVersion: params.protocolVersion || PROTOCOL, capabilities: { tools: {} }, serverInfo: { name: 'vibe', version: VERSION }, instructions });
   }
   if (method === 'ping') return respond(id, {});
   if (method === 'tools/list') {
-    return respond(id, { tools: [{ name: 'vibe', description: 'Your personal FDE: project context, internal guidance, tools and skill extensions. Use discover to inspect an operation before calling it.', inputSchema: { type: 'object', properties: { operation: { type: 'string', enum: ['discover', ...TOOLS.map(t => t.name.slice(5))] }, arguments: { type: 'object', description: 'Arguments for the selected operation. discover accepts an optional operation name.' } }, required: ['operation'], additionalProperties: false } }] });
+    const operations = ['discover', ...TOOLS.map(t => t.name.slice(TOOL_PREFIX.length))];
+    const properties = {
+      operation: { type: 'string', enum: operations },
+      arguments: { type: 'object', description: 'Arguments for the selected operation. discover accepts an optional operation name.' },
+    };
+    const inputSchema = { type: 'object', properties, required: ['operation'], additionalProperties: false };
+    return respond(id, { tools: [{ name: 'vibe', description: ENTRY_DESCRIPTION, inputSchema }] });
   }
   if (method === 'tools/call') {
     const envelope = params.arguments || {};
     if (params.name === 'vibe' && envelope.operation === 'discover') {
       const selected = envelope.arguments?.operation;
-      const entries = selected ? TOOLS.filter(t => t.name === `vibe_${selected}`) : TOOLS;
-      if (!entries.length) return fail(id, -32602, `unknown operation: ${selected}`);
-      const result = entries.map(t => ({ operation: t.name.slice(5), description: t.description, ...(selected ? { inputSchema: { type: 'object', properties: t.args, required: t.required || [], additionalProperties: false } } : {}) }));
+      const entries = selected ? TOOLS.filter(t => t.name === `${TOOL_PREFIX}${selected}`) : TOOLS;
+      if (!entries.length) return fail(id, INVALID_PARAMS, `unknown operation: ${selected}`);
+      const schema = (t) => ({ type: 'object', properties: t.args, required: t.required || [], additionalProperties: false });
+      const result = entries.map(t => ({ operation: t.name.slice(TOOL_PREFIX.length), description: t.description, ...(selected ? { inputSchema: schema(t) } : {}) }));
       return respond(id, { content: [{ type: 'text', text: JSON.stringify(result) }] });
     }
-    const name = params.name === 'vibe' ? `vibe_${envelope.operation}` : params.name;
+    const name = params.name === 'vibe' ? `${TOOL_PREFIX}${envelope.operation}` : params.name;
     const tool = TOOLS.find((t) => t.name === name);
-    if (!tool) return fail(id, -32602, `unknown tool: ${params.name}`);
+    if (!tool) return fail(id, INVALID_PARAMS, `unknown tool: ${params.name}`);
     const a = params.name === 'vibe' ? envelope.arguments || {} : envelope;
     const invalid = invalidArguments(tool, a);
-    if (invalid) return fail(id, -32602, invalid);
+    if (invalid) return fail(id, INVALID_PARAMS, invalid);
     const r = runVibe(tool.cmd(a), tool.stdin ? tool.stdin(a) : undefined);
     return respond(id, { content: [{ type: 'text', text: r.text }], isError: r.isError });
   }
-  return fail(id, -32601, `method not found: ${method}`);
+  return fail(id, METHOD_NOT_FOUND, `method not found: ${method}`);
 }
 
 readline.createInterface({ input: process.stdin }).on('line', (line) => {
@@ -135,6 +163,6 @@ readline.createInterface({ input: process.stdin }).on('line', (line) => {
   try {
     handle(JSON.parse(line));
   } catch (error) {
-    fail(null, -32700, `parse error: ${error.message}`);
+    fail(null, PARSE_ERROR, `parse error: ${error.message}`);
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "4.2.35",
+  "version": "4.2.37",
   "description": "Your personal FDE in Claude and Codex. Understand the work, use the right tools, deliver and retain useful context. One entry: vibe.",
   "type": "module",
   "bin": {