@su-record/vibe 4.2.35 → 4.2.37

package/hooks/knowledge-projects.cjs

@@ -2,11 +2,25 @@
 // knowledge shown inside the wiki. The session hook and the CLI both use this, so they name a project alike.
 const fs = require('node:fs');
 const path = require('node:path');
+const { vibeConfig, SETTINGS } = require('./locations.cjs');
 const { createHash, randomBytes } = require('node:crypto');
 const { inside } = require('./private-store.cjs');
 const { syncedBy, realFolder } = require('./obsidian.cjs');
 
-const namesFile = home => path.join(home, '.config', 'vibe', 'knowledge-projects.json');
+const PROJECT_DIR = '.vibe';
+// Where the wiki keeps one page (or linked folder) per project.
+const PROJECTS_FOLDER = 'projects';
+const TEMP_SUFFIX_BYTES = 6;
+const NAME_MARK_CHARS = 6;
+const MAX_LISTED = 200;
+const START = '<!-- vibe:shared-knowledge -->';
+const END = '<!-- /vibe:shared-knowledge -->';
+
+/** The project's shared knowledge folder, which travels with it. */
+const sharedFolder = root => path.join(root, PROJECT_DIR, 'knowledge');
+const hasProjectDir = root => fs.statSync(path.join(root, PROJECT_DIR), { throwIfNoEntry: false })?.isDirectory() === true;
+
+const namesFile = home => vibeConfig(home, SETTINGS.knowledgeProjects);
 
 function readNames(home) {
   try {
@@ -24,11 +38,11 @@ function projectName(root, home, record = true) {
   const owned = Object.keys(names).find(name => names[name] === root);
   if (owned) return owned;
   const base = path.basename(root).replace(/[[\]|#^\r\n]/g, '-') || 'project';
-  const name = names[base] === undefined ? base : `${base}-${createHash('sha256').update(root).digest('hex').slice(0, 6)}`;
+  const name = names[base] === undefined ? base : `${base}-${createHash('sha256').update(root).digest('hex').slice(0, NAME_MARK_CHARS)}`;
   if (record) {
     const file = namesFile(home);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    const temporary = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+    const temporary = `${file}.${randomBytes(TEMP_SUFFIX_BYTES).toString('hex')}.tmp`;
     fs.writeFileSync(temporary, JSON.stringify({ names: { ...names, [name]: root } }, null, 2));
     fs.renameSync(temporary, file);
   }
@@ -45,12 +59,12 @@ function sameFolder(a, b) {
  * wiki, where the link could carry a client's knowledge off the computer, nor into a wiki inside the project.
  */
 function linkProject(root, wiki, name) {
-  if (!fs.statSync(path.join(root, '.vibe'), { throwIfNoEntry: false })?.isDirectory()) return 'none';
+  if (!hasProjectDir(root)) return 'none';
   if (syncedBy(wiki)) return 'synced';
   if (inside(root, realFolder(wiki))) return 'inside';
-  const target = path.join(root, '.vibe', 'knowledge');
+  const target = sharedFolder(root);
   fs.mkdirSync(target, { recursive: true });
-  const link = path.join(wiki, 'projects', name);
+  const link = path.join(wiki, PROJECTS_FOLDER, name);
   const existing = fs.lstatSync(link, { throwIfNoEntry: false });
   if (existing) return existing.isSymbolicLink() && sameFolder(link, target) ? 'linked' : 'taken';
   fs.mkdirSync(path.dirname(link), { recursive: true });
@@ -59,10 +73,6 @@ function linkProject(root, wiki, name) {
   return 'linked';
 }
 
-const MAX_LISTED = 200;
-const START = '<!-- vibe:shared-knowledge -->';
-const END = '<!-- /vibe:shared-knowledge -->';
-
 /** The shared folder's pages by subfolder, without links or dot folders; names that cannot be a [[link]] are left out. */
 function sharedPages(folder) {
   const groups = new Map();
@@ -84,7 +94,7 @@ function sharedPages(folder) {
 function writeIfChanged(file, text) {
   if (fs.existsSync(file) && fs.readFileSync(file, 'utf8') === text) return;
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  const temporary = `${file}.${randomBytes(6).toString('hex')}.tmp`;
+  const temporary = `${file}.${randomBytes(TEMP_SUFFIX_BYTES).toString('hex')}.tmp`;
   fs.writeFileSync(temporary, text);
   fs.renameSync(temporary, file);
 }
@@ -95,30 +105,49 @@ function writeIfChanged(file, text) {
  * Everything outside the block, and every other line of the index, is the model's and the person's.
  */
 function indexProject(root, wiki, name) {
-  const { groups, more } = sharedPages(path.join(root, '.vibe', 'knowledge'));
-  const lines = [...groups].map(([folder, pages]) => `- ${folder || 'pages'}: ${pages.map(p => `[[projects/${name}/${p}]]`).join(' · ')}`);
-  const block = [START, `Shared knowledge of this project (\`.vibe/knowledge\`), listed by vibe at each session start; edit outside this block.`,
-    ...(lines.length ? lines : ['- none yet']), ...(more ? [`- and ${more} more pages`] : []), END].join('\n');
-  const page = path.join(wiki, 'projects', `${name}.md`);
+  const page = path.join(wiki, PROJECTS_FOLDER, `${name}.md`);
   const current = fs.existsSync(page) ? fs.readFileSync(page, 'utf8') : `# ${name}\n`;
-  const at = current.indexOf(START), end = current.indexOf(END, at);
-  writeIfChanged(page, at >= 0 && end > at ? `${current.slice(0, at)}${block}${current.slice(end + END.length)}` : `${current.trimEnd()}\n\n${block}\n`);
+  writeIfChanged(page, withBlock(current, sharedBlock(root, name)));
   const index = path.join(wiki, 'index.md');
   const listed = fs.existsSync(index) ? fs.readFileSync(index, 'utf8') : '# Index\n';
-  if (!new RegExp(`\\[\\[projects/${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:\\.md)?[\\]|#]`).test(listed)) {
+  if (!linksProject(listed, name)) {
     writeIfChanged(index, `${listed.trimEnd()}\n- [[projects/${name}]] — this project's page and its shared knowledge\n`);
   }
 }
 
+/** The block listing the project's shared pages, one line per subfolder. */
+function sharedBlock(root, name) {
+  const { groups, more } = sharedPages(sharedFolder(root));
+  const lines = [...groups].map(([folder, pages]) => `- ${folder || 'pages'}: ${pages.map(p => `[[projects/${name}/${p}]]`).join(' · ')}`);
+  return [
+    START,
+    'Shared knowledge of this project (`.vibe/knowledge`), listed by vibe at each session start; edit outside this block.',
+    ...(lines.length ? lines : ['- none yet']),
+    ...(more ? [`- and ${more} more pages`] : []),
+    END,
+  ].join('\n');
+}
+
+/** The page with its marked block replaced, or the block appended when the page has none. */
+function withBlock(current, block) {
+  const at = current.indexOf(START), end = current.indexOf(END, at);
+  if (at >= 0 && end > at) return `${current.slice(0, at)}${block}${current.slice(end + END.length)}`;
+  return `${current.trimEnd()}\n\n${block}\n`;
+}
+
+const escapeRegExp = text => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/** Whether the index already links the project's page. */
+const linksProject = (index, name) => new RegExp(`\\[\\[projects/${escapeRegExp(name)}(?:\\.md)?[\\]|#]`).test(index);
+
 /**
  * Create the project's page when it is missing, so a log line's `[[projects/<name>]]` always resolves. Returns
  * whether it created one; an existing page is left as it is.
  */
 function projectPage(wiki, name, root) {
-  const page = path.join(wiki, 'projects', `${name}.md`);
+  const page = path.join(wiki, PROJECTS_FOLDER, `${name}.md`);
   if (fs.existsSync(page)) return false;
   writeIfChanged(page, `---\ntype: project\n---\n# ${name}\n${typeof root === 'string' ? `\nFolder: \`${root}\`\n` : ''}`);
   return true;
 }
 
-module.exports = { readNames, projectName, linkProject, indexProject, projectPage, writeIfChanged };
+module.exports = { PROJECT_DIR, sharedFolder, hasProjectDir, readNames, projectName, linkProject, indexProject, projectPage, writeIfChanged };

package/hooks/knowledge-recall.cjs

@@ -7,6 +7,7 @@ const path = require('node:path');
 const { pathToFileURL } = require('node:url');
 const { readPrivate, writePrivate } = require('./private-store.cjs');
 const { digest } = require('./session-files.cjs');
+const { sharedFolder } = require('./knowledge-projects.cjs');
 
 const SHOWN = 3;
 // A page scoring 6 matches a short prompt's words in its title or tags; a long prompt also touches big pages in passing,
@@ -14,7 +15,16 @@ const SHOWN = 3;
 // (2026-10-29): the hook, link and Stop questions found the vibe pages; "배포해" and "진행 상황 알려줘" found none.
 const ENOUGH = 6;
 const PROMPT_CHARS = 600;
+const SHOWN_MAX_BYTES = 64 * 1024;
+// Pages remembered as already shown, so a long session's list stays small.
+const SHOWN_KEPT = 200;
+// The finder is compiled TypeScript under the package's dist.
+const FINDER = path.join('dist', 'core', 'knowledge-find.js');
 
+const HEADING = [
+  '[vibe] Recorded knowledge matching this prompt, found before you chose;',
+  'read a page that bears on the work, then follow its decision, reuse its method or avoid its problem:',
+].join(' ');
 const shownEntry = (root, id) => `recall-${digest(`${root}\0${id}`)}.json`;
 
 /**
@@ -23,19 +33,19 @@ const shownEntry = (root, id) => `recall-${digest(`${root}\0${id}`)}.json`;
  */
 async function recall(text, { root, id }, dir, home) {
   const prompt = typeof text === 'string' ? text.trim().slice(0, PROMPT_CHARS) : '';
-  // The finder is compiled TypeScript; a hooks copy without the package's dist (Codex's plugin tree) skips the lookup.
-  const finder = path.join(__dirname, '..', 'dist', 'core', 'knowledge-find.js');
+  // A hooks copy without the package's dist (Codex's plugin tree) skips the lookup.
+  const finder = path.join(__dirname, '..', FINDER);
   if (!prompt || !fs.existsSync(finder)) return null;
   const { findKnowledge } = await import(pathToFileURL(finder).href);
-  const shared = path.join(root, '.vibe', 'knowledge');
+  const shared = sharedFolder(root);
   const { found } = findKnowledge(dir, prompt, fs.existsSync(shared) ? [shared] : []);
-  const shown = JSON.parse(readPrivate(root, shownEntry(root, id), 65536, home) ?? '[]');
+  const shown = JSON.parse(readPrivate(root, shownEntry(root, id), SHOWN_MAX_BYTES, home) ?? '[]');
   const bar = Math.max(ENOUGH, (found[0]?.score ?? 0) / 2);
   const fresh = found.filter(page => page.state === 'current' && page.score >= bar && !shown.includes(page.file)).slice(0, SHOWN);
   if (!fresh.length) return null;
-  writePrivate(root, shownEntry(root, id), JSON.stringify([...shown, ...fresh.map(page => page.file)].slice(-200)), home);
+  writePrivate(root, shownEntry(root, id), JSON.stringify([...shown, ...fresh.map(page => page.file)].slice(-SHOWN_KEPT)), home);
   const lines = fresh.map(page => `- ${page.title}${page.type ? ` [${page.type}]` : ''}: ${page.summary} (${page.file})`);
-  return ['[vibe] Recorded knowledge matching this prompt, found before you chose; read a page that bears on the work, then follow its decision, reuse its method or avoid its problem:', ...lines].join('\n');
+  return [HEADING, ...lines].join('\n');
 }
 
 module.exports = { recall, ENOUGH };

package/hooks/knowledge-upkeep.cjs

@@ -2,12 +2,14 @@
 // not settle; after enough changed pages or days, the turn also reviews those pages and the pages they link.
 const fs = require('node:fs');
 const path = require('node:path');
+const { vibeConfig, SETTINGS } = require('./locations.cjs');
 const { fixWiki, reviewScope } = require('./knowledge-lint.cjs');
 const { writeIfChanged } = require('./knowledge-projects.cjs');
+const { DAY } = require('./knowledge-journal.cjs');
 
-const DAY = 86400000;
 const SHOWN = 3;
 const LISTED = 20;
+const DATE_CHARS = 10;
 
 const few = (items, show) => `${items.slice(0, SHOWN).map(show).join(', ')}${items.length > SHOWN ? ` and ${items.length - SHOWN} more` : ''}`;
 
@@ -21,11 +23,27 @@ function tidy(dir, home) {
       lint.badType.length ? `unknown types ${few(lint.badType, b => `${b.page} "${b.type}"`)}` : '',
       lint.duplicates.length ? `pages sharing a title ${few(lint.duplicates, pages => pages.join(' = '))}` : '',
     ].filter(Boolean);
-    return left.length ? ` The wiki lint fixed what needs no judgement; left for you: ${left.join('; ')}. Settle them as the guide's "Keep the connections" says (\`vibe knowledge lint\` lists all).` : '';
+    if (!left.length) return '';
+    return [
+      ` The wiki lint fixed what needs no judgement; left for you: ${left.join('; ')}.`,
+      ' Settle them as the guide\'s "Keep the connections" says (`vibe knowledge lint` lists all).',
+    ].join('');
   } catch { return ''; }
 }
 
-const stateFile = home => path.join(home, '.config', 'vibe', 'knowledge-review.json');
+const pageList = items => `${items.slice(0, LISTED).map(p => `[[${p}]]`).join(', ')}${items.length > LISTED ? ` and ${items.length - LISTED} more` : ''}`;
+
+function reviewClause(scope, since) {
+  const date = new Date(since).toISOString().slice(0, DATE_CHARS);
+  const linked = scope.linked.length ? ` and the pages they link, ${pageList(scope.linked)},` : '';
+  return [
+    ` This is also a review turn (${scope.changed.length} pages changed since ${date}): read ${pageList(scope.changed)}${linked}`,
+    ' for claims that contradict each other, dated claims likely out of date and decisions a later one replaced,',
+    ' and correct them as the guide\'s "Review" says.',
+  ].join('');
+}
+
+const stateFile = home => vibeConfig(home, SETTINGS.knowledgeReview);
 
 /**
  * A review clause when `pages` pages changed since the last review, or one did and `days` days passed; '' otherwise.
@@ -41,8 +59,7 @@ function review(dir, home, pages, days, now = Date.now()) {
     const due = scope.changed.length >= pages || (scope.changed.length > 0 && days > 0 && now - since >= days * DAY);
     if (!due) return '';
     writeIfChanged(stateFile(home), JSON.stringify({ at: now }));
-    const list = items => `${items.slice(0, LISTED).map(p => `[[${p}]]`).join(', ')}${items.length > LISTED ? ` and ${items.length - LISTED} more` : ''}`;
-    return ` This is also a review turn (${scope.changed.length} pages changed since ${new Date(since).toISOString().slice(0, 10)}): read ${list(scope.changed)}${scope.linked.length ? ` and the pages they link, ${list(scope.linked)},` : ''} for claims that contradict each other, dated claims likely out of date and decisions a later one replaced, and correct them as the guide's "Review" says.`;
+    return reviewClause(scope, since);
   } catch { return ''; }
 }
 

package/hooks/locations.cjs

@@ -0,0 +1,35 @@
+// Where vibe and the clients it serves keep their files under the home folder, spelled once. The hooks require this
+// module and the CLI reads it through src/core/locations.ts, so a folder name never drifts between the two.
+const path = require('node:path');
+
+const CLAUDE_DIR = '.claude';
+const CODEX_DIR = '.codex';
+const AGENTS_DIR = '.agents';
+const VIBE_CONFIG_DIR = path.join('.config', 'vibe');
+
+/** A file or folder under ~/.config/vibe: the person's vibe settings, wiki, reader sessions and plugin tree. */
+const vibeConfig = (home, ...parts) => path.join(home, VIBE_CONFIG_DIR, ...parts);
+/** A file or folder under ~/.claude. */
+const claudeHome = (home, ...parts) => path.join(home, CLAUDE_DIR, ...parts);
+/** A file or folder under ~/.codex. */
+const codexHome = (home, ...parts) => path.join(home, CODEX_DIR, ...parts);
+
+/** The client files vibe reads or writes. */
+const claudeSettings = (home) => claudeHome(home, 'settings.json');
+const codexConfig = (home) => codexHome(home, 'config.toml');
+const codexHooks = (home) => codexHome(home, 'hooks.json');
+
+/** The person's vibe settings files under ~/.config/vibe. */
+const SETTINGS = {
+  knowledge: 'knowledge.json',
+  knowledgeProjects: 'knowledge-projects.json',
+  knowledgeReview: 'knowledge-review.json',
+  retest: 'retest.json',
+};
+/** Folders under ~/.config/vibe. */
+const FOLDERS = { knowledge: 'knowledge', reader: 'reader', plugin: 'plugin' };
+
+module.exports = {
+  CLAUDE_DIR, CODEX_DIR, AGENTS_DIR, VIBE_CONFIG_DIR, SETTINGS, FOLDERS,
+  vibeConfig, claudeHome, codexHome, claudeSettings, codexConfig, codexHooks,
+};

package/hooks/notify.js

@@ -19,12 +19,28 @@ 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 knowledgeJournal from './knowledge-journal.cjs';
 import retest from './retest.cjs';
 import sessionRuntime from './session-state.cjs';
 import sessionFiles from './session-files.cjs';
 import sliceRuntime from './slice-guard.cjs';
 
+const { claudeSettings } = locations;
+
+const NOTIFY_HOOK = 'hooks/notify.js';
+const SETTINGS_MAX_BYTES = 64 * 1024;
+const PROJECT_DIR = '.vibe';
+const STATE_TIMEOUT_MS = 15000;
+// An authorize record counts for this long.
+const MS_PER_MINUTE = 60 * 1000;
+const AUTHORIZE_WINDOW_MS = 10 * MS_PER_MINUTE;
+const DEFAULT_READ_ADVISE_LINES = sliceRuntime.READ_ADVISE_LINES;
+// Exit code that stops a tool call in Claude Code.
+const BLOCK_EXIT = 2;
+// Hook modes that run in a project with or without a .vibe folder.
+const ANYWHERE_MODES = ['stop', 'session', 'pre'];
+
 const mode = process.argv[2] || 'post';
 const asPlugin = process.argv.includes('--plugin');
 const personal = process.argv.includes('--personal');
@@ -38,11 +54,11 @@ if (asPlugin) {
   // The reader refuses a link anywhere in a path; a home under one (macOS /var → /private/var) is the person's own.
   let home = process.env.VIBE_HOME_DIR || os.homedir();
   try { home = fs.realpathSync(home); } catch { /* a missing home has no settings to read */ }
-  for (const file of [path.join(home, '.claude', 'settings.json')]) {
+  for (const file of [claudeSettings(home)]) {
     try {
-      const settings = JSON.parse(sessionFiles.optional(file, 65536) ?? '{}');
+      const settings = JSON.parse(sessionFiles.optional(file, SETTINGS_MAX_BYTES) ?? '{}');
       const owned = Object.values(settings.hooks ?? {}).some(entries => entries.some(entry =>
-        entry.hooks?.some(hook => hook.command?.replaceAll('\\', '/').includes('hooks/notify.js'))));
+        entry.hooks?.some(hook => hook.command?.replaceAll('\\', '/').includes(NOTIFY_HOOK))));
       if (owned) process.exit(0);
     } catch {
       /* no such file — keep going */
@@ -58,19 +74,17 @@ function readPayload() {
   catch { return { session_id: 'invalid payload' }; }
 }
 
-function structuralSession(payload) {
-  const view = sessionRuntime.sessionStatus(payload);
-  return sessionRuntime.message(view, view.status === 'bound' ? 'session status only; run vibe state for the procedure' : `${view.status}; use explicit vibe session bind in the intended worktree`);
-}
+const structuralSession = payload => sessionRuntime.structuralNote(sessionRuntime.sessionStatus(payload));
 function sliceClient() {
   const declared = process.env.VIBE_CLIENT;
   if (declared) return ['codex', 'chatgpt'].includes(declared) ? 'codex' : 'claude';
   return process.env.CODEX_THREAD_ID && !process.env.CLAUDE_SESSION_ID ? 'codex' : 'claude';
 }
 
-function emitContext(text) {
-  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: mode === 'post' ? 'PostToolUse' : 'PreToolUse', additionalContext: text } })}\n`);
+function emit(hookEventName, additionalContext) {
+  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext } })}\n`);
 }
+const emitContext = text => emit(mode === 'post' ? 'PostToolUse' : 'PreToolUse', text);
 
 // The same actions the check gate names (src/core/checks/mutation.ts), so a blocked tool call and a blocked
 // check ask for the same `vibe authorize --action`; `send` is the hook's own. A command that only reads —
@@ -91,10 +105,12 @@ const IRREVERSIBLE = [
 ];
 const READS_ONLY = /^\s*(?:grep|rg|cat|head|tail|less|ls|find|wc|echo|printf|sed\s+-n|git\s+(?:log|diff|show|status|grep|blame|branch|ls-files))\b/;
 
+const hasProjectDir = () => fs.existsSync(path.join(root, PROJECT_DIR));
+
 function recentAuthorize(action) {
   try {
-    const lines = fs.readFileSync(path.join(root, '.vibe', 'ledger.jsonl'), 'utf-8').trim().split('\n');
-    const cutoff = Date.now() - 10 * 60 * 1000;
+    const lines = fs.readFileSync(path.join(root, PROJECT_DIR, 'ledger.jsonl'), 'utf-8').trim().split('\n');
+    const cutoff = Date.now() - AUTHORIZE_WINDOW_MS;
     return lines.some((line) => {
       try {
         const e = JSON.parse(line);
@@ -108,16 +124,25 @@ function recentAuthorize(action) {
   }
 }
 
-if (!['stop', 'session', 'pre'].includes(mode) && !fs.existsSync(path.join(root, '.vibe'))) process.exit(0);
+if (!ANYWHERE_MODES.includes(mode) && !hasProjectDir()) process.exit(0);
+
+function irreversibleNotice(action, blocking) {
+  return [
+    `[vibe] "${action}" is irreversible and no authorize record exists in the last ${AUTHORIZE_WINDOW_MS / MS_PER_MINUTE} minutes —`,
+    `${blocking ? 'blocked: ' : ''}get a human token with \`vibe ask --needs authorize:${action}\``,
+    'and run `vibe authorize` first, as its own command: the gate reads the ledger before this command runs,',
+    'so an authorize chained in front of the action is not seen',
+  ].join(' ');
+}
 
 function tokenPolicy() {
   try {
-    return JSON.parse(fs.readFileSync(path.join(root, '.vibe', 'config.json'), 'utf-8')).tokens || 'off';
+    return JSON.parse(fs.readFileSync(path.join(root, PROJECT_DIR, 'config.json'), 'utf-8')).tokens || 'off';
   } catch {
     return 'off';
   }
 }
-const READ_ADVISE_LINES = Number(process.env.VIBE_READ_ADVISE_LINES || 400);
+const READ_ADVISE_LINES = Number(process.env.VIBE_READ_ADVISE_LINES || DEFAULT_READ_ADVISE_LINES);
 
 function countLines(file) {
   try {
@@ -134,7 +159,10 @@ function adviseRead(payload) {
   const lines = countLines(path.resolve(root, file));
   if (lines <= READ_ADVISE_LINES) return;
   const shown = (path.isAbsolute(file) ? path.relative(root, file) || file : file).split(path.sep).join('/');
-  emitContext(`[vibe] ${shown} is ${lines} lines — when it only has to be understood, not edited or debugged, \`vibe read ${shown} --ask "<question>"\` lets a low-reasoning model read it and returns the answer with line numbers`);
+  emitContext([
+    `[vibe] ${shown} is ${lines} lines — when it only has to be understood, not edited or debugged,`,
+    `\`vibe read ${shown} --ask "<question>"\` lets a low-reasoning model read it and returns the answer with line numbers`,
+  ].join(' '));
 }
 
 const cli = path.join(here, '..', 'dist', 'cli.js');
@@ -158,14 +186,14 @@ if (mode === 'stop') {
 if (mode === 'session') {
   const payload = readPayload();
   const recall = knowledgeAuto.start(payload);
-  process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: [structuralSession(payload), recall, codeMap.codeMap(root)].filter(Boolean).join('\n') } })}\n`);
+  emit('SessionStart', [structuralSession(payload), recall, codeMap.codeMap(root)].filter(Boolean).join('\n'));
   process.exit(0);
 }
 
 if (mode === 'pre') {
   const payload = readPayload();
   if (payload.tool_name === 'Read') {
-    if (fs.existsSync(path.join(root, '.vibe'))) adviseRead(payload);
+    if (hasProjectDir()) adviseRead(payload);
     process.exit(0);
   }
   const raw = payload.tool_input && payload.tool_input.command;
@@ -176,13 +204,13 @@ if (mode === 'pre') {
   const leave = (code) => { if (notes.length) emitContext(notes.join('\n')); process.exit(code); };
   let gate = null;
   try { gate = retest.before(payload, process.env.VIBE_HOME_DIR || os.homedir()); } catch { /* the command runs */ }
-  if (gate?.decision === 'block') { process.stderr.write(`${gate.message}\n`); process.exit(2); }
+  if (gate?.decision === 'block') { process.stderr.write(`${gate.message}\n`); process.exit(BLOCK_EXIT); }
   if (gate?.decision === 'warn') notes.push(gate.message);
   if (personal && tokenPolicy() === 'off') leave(0);
   const slice = personal ? { decision: 'allow' } : sliceRuntime.sliceGuard(root, command, sliceClient(), cwd);
-  if (slice.decision === 'block') { process.stderr.write(`${slice.message}\n`); process.exit(2); }
+  if (slice.decision === 'block') { process.stderr.write(`${slice.message}\n`); process.exit(BLOCK_EXIT); }
   if (slice.decision === 'warn') notes.push(slice.message);
-  if (!fs.existsSync(path.join(root, '.vibe'))) leave(0);
+  if (!hasProjectDir()) leave(0);
   // Every segment is judged — `echo x && git push`, `ls; rm -rf build`, `cat x | git push` carry the action in a later one
   // Vibe gates its own execution; its approval and inbox commands must remain reachable.
   const segments = command.split(/&&|\|\||;|\||\n/).map((s) => s.trim()).filter((s) => s && !READS_ONLY.test(s) && !/^vibe(?:\s|$)/.test(s));
@@ -190,8 +218,8 @@ if (mode === 'pre') {
   for (const [action, re] of IRREVERSIBLE) {
     if (segments.some((s) => re.test(s)) && !recentAuthorize(action)) {
       const blocking = tokenPolicy() !== 'off';
-      process.stderr.write(`[vibe] "${action}" is irreversible and no authorize record exists in the last 10 minutes — ${blocking ? 'blocked: ' : ''}get a human token with \`vibe ask --needs authorize:${action}\` and run \`vibe authorize\` first, as its own command: the gate reads the ledger before this command runs, so an authorize chained in front of the action is not seen\n`);
-      if (blocking) process.exit(2);
+      process.stderr.write(`${irreversibleNotice(action, blocking)}\n`);
+      if (blocking) process.exit(BLOCK_EXIT);
       leave(0);
     }
   }
@@ -200,8 +228,8 @@ if (mode === 'pre') {
 
 // Inside the npm package dist/cli.js sits next to us; inside a plugin tree it does not, so fall back to `vibe` on PATH.
 const result = fs.existsSync(cli)
-  ? spawnSync(process.execPath, [cli, 'state', '--json'], { cwd: root, encoding: 'utf-8', timeout: 15000 })
-  : spawnSync('vibe', ['state', '--json'], { cwd: root, encoding: 'utf-8', timeout: 15000, shell: process.platform === 'win32' });
+  ? spawnSync(process.execPath, [cli, 'state', '--json'], { cwd: root, encoding: 'utf-8', timeout: STATE_TIMEOUT_MS })
+  : spawnSync('vibe', ['state', '--json'], { cwd: root, encoding: 'utf-8', timeout: STATE_TIMEOUT_MS, shell: process.platform === 'win32' });
 if (result.status !== 0 || !result.stdout) process.exit(0);
 try {
   const view = JSON.parse(result.stdout);

package/hooks/obsidian.cjs

@@ -4,16 +4,22 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { createHash, randomBytes } = require('node:crypto');
 
+const REGISTRY_FILE = 'obsidian.json';
+const VAULT_ID_CHARS = 16;
+const TEMP_SUFFIX_BYTES = 6;
+
 function readJson(file) {
   try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
 }
 
 /** Where Obsidian keeps its vault list on each platform, including the Flatpak build on Linux. */
 function obsidianRegistries(home, platform = process.platform, env = process.env) {
-  if (platform === 'darwin') return [path.join(home, 'Library', 'Application Support', 'obsidian', 'obsidian.json')];
-  if (platform === 'win32') return [path.join(env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'obsidian', 'obsidian.json')];
-  return [path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'obsidian', 'obsidian.json'),
-    path.join(home, '.var', 'app', 'md.obsidian.Obsidian', 'config', 'obsidian', 'obsidian.json')];
+  if (platform === 'darwin') return [path.join(home, 'Library', 'Application Support', 'obsidian', REGISTRY_FILE)];
+  if (platform === 'win32') return [path.join(env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'obsidian', REGISTRY_FILE)];
+  return [
+    path.join(env.XDG_CONFIG_HOME || path.join(home, '.config'), 'obsidian', REGISTRY_FILE),
+    path.join(home, '.var', 'app', 'md.obsidian.Obsidian', 'config', 'obsidian', REGISTRY_FILE),
+  ];
 }
 
 /** Registered vaults that still exist, by real path: the open one first, then the most recently used. */
@@ -29,7 +35,11 @@ function obsidianVaults(home, platform, env) {
   return [...found.values()].sort((a, b) => Number(b.open) - Number(a.open) || b.ts - a.ts);
 }
 
-const CLOUD = [['Mobile Documents', 'iCloud'], ['iCloud', 'iCloud'], ['Dropbox', 'Dropbox'], ['OneDrive', 'OneDrive'], ['Google Drive', 'Google Drive'], ['CloudStorage', 'a cloud drive']];
+// A folder name in a path, and the service whose sync folder carries it.
+const CLOUD = [
+  ['Mobile Documents', 'iCloud'], ['iCloud', 'iCloud'], ['Dropbox', 'Dropbox'], ['OneDrive', 'OneDrive'],
+  ['Google Drive', 'Google Drive'], ['CloudStorage', 'a cloud drive'],
+];
 
 /** The service that copies this folder off the computer, when its path or Obsidian's own Sync plugin shows one. */
 function syncedBy(folder) {
@@ -76,9 +86,9 @@ function connectVault(folder, home, platform, env) {
   if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return 'waiting';
   const real = fs.realpathSync(folder);
   if (obsidianVaults(home, platform, env).some(v => real === v.path || real.startsWith(`${v.path}${path.sep}`))) return 'in-vault';
-  const id = createHash('sha256').update(real).digest('hex').slice(0, 16);
+  const id = createHash('sha256').update(real).digest('hex').slice(0, VAULT_ID_CHARS);
   const next = { ...doc, vaults: { ...(doc.vaults ?? {}), [id]: { path: real, ts: Date.now() } } };
-  const temporary = `${registry}.${randomBytes(6).toString('hex')}.tmp`;
+  const temporary = `${registry}.${randomBytes(TEMP_SUFFIX_BYTES).toString('hex')}.tmp`;
   fs.writeFileSync(temporary, JSON.stringify(next));
   fs.renameSync(temporary, registry);
   return 'connected';

package/hooks/private-store.cjs

@@ -3,31 +3,44 @@ const os = require('node:os');
 const path = require('node:path');
 const { randomBytes } = require('node:crypto');
 
+const STORE_DIR = '.vibe-runtime';
+const DIRECTORY_MODE = 0o700;
+const FILE_MODE = 0o600;
+// Any group or other permission bit.
+const OTHERS_MASK = 0o077;
+const DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
+const TEMP_SUFFIX_BYTES = 12;
+const ENTRY_NAME = /^[a-z0-9.-]+$/i;
+const LINKED_ENTRY = 'local store entry must be a real private directory or regular file, never linked';
+const PERMISSIONS = 'local store permissions must be owner-private (0700 directory, 0600 file)';
+const CHANGED_ENTRY = 'local store entry changed or exceeds its read limit';
+
 function inside(parent, file) {
   const relative = path.relative(parent, file);
   return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
 }
 function privateEntry(stat, directory) {
-  if (stat.isSymbolicLink() || (directory ? !stat.isDirectory() : !stat.isFile()) || (!directory && stat.nlink !== 1)) throw new Error('local store entry must be a real private directory or regular file, never linked');
-  if (process.platform !== 'win32' && (stat.uid !== process.getuid?.() || (stat.mode & 0o077) !== 0)) throw new Error('local store permissions must be owner-private (0700 directory, 0600 file)');
+  const wrongKind = directory ? !stat.isDirectory() : !stat.isFile();
+  if (stat.isSymbolicLink() || wrongKind || (!directory && stat.nlink !== 1)) throw new Error(LINKED_ENTRY);
+  if (process.platform !== 'win32' && (stat.uid !== process.getuid?.() || (stat.mode & OTHERS_MASK) !== 0)) throw new Error(PERMISSIONS);
   return stat;
 }
 function privateStat(file, directory) { return privateEntry(fs.lstatSync(file), directory); }
 function privateDirectory(root, create, homeDirectory = os.homedir()) {
   const home = fs.realpathSync(homeDirectory);
-  const dir = path.join(home, '.vibe-runtime');
+  const dir = path.join(home, STORE_DIR);
   if (inside(fs.realpathSync(root), dir)) throw new Error('local execution consent storage must be outside the project');
   if (!fs.lstatSync(dir, { throwIfNoEntry: false })) {
     if (!create) return dir;
-    fs.mkdirSync(dir, { mode: 0o700 });
+    fs.mkdirSync(dir, { mode: DIRECTORY_MODE });
   }
   privateStat(dir, true);
   return dir;
 }
 function entryName(name) {
-  if (!/^[a-z0-9.-]+$/i.test(name)) throw new Error('invalid local store entry name');
+  if (!ENTRY_NAME.test(name)) throw new Error('invalid local store entry name');
 }
-function readPrivate(root, name, maxBytes = 2097152, homeDirectory) {
+function readPrivate(root, name, maxBytes = DEFAULT_MAX_BYTES, homeDirectory) {
   entryName(name);
   const dir = privateDirectory(root, false, homeDirectory);
   if (!fs.existsSync(dir)) return null;
@@ -37,11 +50,13 @@ function readPrivate(root, name, maxBytes = 2097152, homeDirectory) {
   const fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
   try {
     const actual = privateEntry(fs.fstatSync(fd), false);
-    if (actual.dev !== before.dev || actual.ino !== before.ino || actual.size > maxBytes) throw new Error('local store entry changed or exceeds its read limit');
+    if (actual.dev !== before.dev || actual.ino !== before.ino || actual.size > maxBytes) throw new Error(CHANGED_ENTRY);
     const buffer = Buffer.alloc(maxBytes + 1);
     const length = fs.readSync(fd, buffer, 0, buffer.length, 0);
     const after = privateStat(file, false);
-    if (length > maxBytes || length !== actual.size || after.ino !== actual.ino || after.dev !== actual.dev || after.size !== actual.size || after.mtimeMs !== actual.mtimeMs || after.ctimeMs !== actual.ctimeMs) throw new Error('local store entry changed or exceeds its read limit');
+    const same = after.ino === actual.ino && after.dev === actual.dev && after.size === actual.size
+      && after.mtimeMs === actual.mtimeMs && after.ctimeMs === actual.ctimeMs;
+    if (length > maxBytes || length !== actual.size || !same) throw new Error(CHANGED_ENTRY);
     return buffer.subarray(0, length).toString('utf8');
   } finally { fs.closeSync(fd); }
 }
@@ -50,8 +65,8 @@ function writePrivate(root, name, text, homeDirectory) {
   const dir = privateDirectory(root, true, homeDirectory);
   const file = path.join(dir, name);
   if (fs.lstatSync(file, { throwIfNoEntry: false })) privateStat(file, false);
-  const temporary = path.join(dir, `${name}.${randomBytes(12).toString('hex')}.tmp`);
-  fs.writeFileSync(temporary, text, { flag: 'wx', mode: 0o600 });
+  const temporary = path.join(dir, `${name}.${randomBytes(TEMP_SUFFIX_BYTES).toString('hex')}.tmp`);
+  fs.writeFileSync(temporary, text, { flag: 'wx', mode: FILE_MODE });
   try { privateStat(dir, true); fs.renameSync(temporary, file); }
   finally { if (fs.existsSync(temporary)) fs.unlinkSync(temporary); }
   return file;