@su-record/vibe 4.1.25 → 4.1.26

package/hooks/session-state.cjs

@@ -0,0 +1,166 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { readPrivate, writePrivate } = require('./private-store.cjs');
+const { optional, json, digest, revision, projectFingerprint } = require('./session-files.cjs');
+const { repairData, repairMessage } = require('./session-repair.cjs');
+const { contextStatus } = require('./session-context.cjs');
+
+const ID = /^[a-z0-9][a-z0-9-]{0,39}$/;
+const HASH = /^[a-f0-9]{16,64}$/;
+const STATUSES = ['pass', 'fail', 'pending', 'blocked', 'stale', 'handoff'];
+const name = (kind, value) => `${kind}-${digest(value)}.json`;
+function identity(payload = {}, env = process.env) {
+  const ids = [payload.session_id, env.CODEX_THREAD_ID, env.CLAUDE_SESSION_ID].filter(Boolean);
+  if (ids.some(id => typeof id !== 'string' || !/^[a-zA-Z0-9._:-]{1,256}$/.test(id))) throw new Error('session-identity-invalid');
+  if (new Set(ids).size > 1) throw new Error('session-identity-conflict');
+  if (!ids.length) throw new Error('session-identity-missing');
+  return ids[0];
+}
+function hostRoot(payload = {}, env = process.env, cwd = process.cwd()) {
+  const roots = [cwd, payload.cwd, env.CLAUDE_PROJECT_DIR].filter(Boolean);
+  if (roots.some(root => typeof root !== 'string' || !path.isAbsolute(root))) throw new Error('session-root-invalid');
+  const canonical = roots.map(root => fs.realpathSync(root));
+  if (new Set(canonical).size !== 1) throw new Error('session-root-conflict');
+  return canonical[0];
+}
+function bindSession(root, id, scenarios = []) {
+  root = fs.realpathSync(root);
+  identity({ session_id: id });
+  if (scenarios.length > 1000 || scenarios.some(s => !ID.test(s.id) || (s.needs ?? []).some(id => !ID.test(id)))) throw new Error('invalid session scenarios');
+  const guard = readPrivate(root, name('guard', id), 4096);
+  if (guard !== null) {
+    const existing = JSON.parse(guard);
+    if (!Number.isInteger(existing.count) || existing.count < 0 || existing.count > 3 || (existing.key !== null && !/^[a-f0-9]{64}$/.test(existing.key))) throw new Error('invalid session guard');
+  }
+  const binding = { schemaVersion: 1, root, id, revision: revision(root), scenarios: scenarios.map(s => ({ id: s.id, needs: s.needs ?? [] })) };
+  writePrivate(root, name('session', id), JSON.stringify(binding));
+  if (guard === null) writePrivate(root, name('guard', id), JSON.stringify({ key: null, count: 0 }));
+  return { status: 'bound', ...binding };
+}
+function workflow(root) {
+  const questions = new Map(), answered = new Set(), handed = new Set(), changes = [];
+  const inbox = optional(path.join(root, '.vibe/inbox.jsonl')) ?? '';
+  for (const line of inbox.split('\n').filter(Boolean)) {
+    const e = JSON.parse(line);
+    if (typeof e.id !== 'string' || !/^[a-zA-Z0-9-]{1,80}$/.test(e.id)) continue;
+    if (e.type === 'question') questions.set(e.id, false);
+    if (e.type === 'answer' && typeof e.answer === 'string' && e.answer.trim()) answered.add(e.id);
+    if (e.type === 'answer' || e.type === 'resolve') questions.delete(e.id);
+  }
+  const state = json(path.join(root, '.vibe/state.json'));
+  const repairQuestion = state.repair?.questionId;
+  if (state.repair?.waiting && typeof repairQuestion === 'string' && /^[a-zA-Z0-9-]{1,80}$/.test(repairQuestion) && !answered.has(repairQuestion)) questions.set(repairQuestion, false);
+  const ledger = optional(path.join(root, '.vibe/ledger.jsonl'), 2097152) ?? '';
+  for (const line of ledger.split('\n').filter(Boolean)) {
+    const e = JSON.parse(line), item = e.handoff;
+    if (!item || item.intentHash !== state.intentHash || !ID.test(item.scenario)) continue;
+    if (e.event === 'handoff') handed.add(item.scenario);
+    if (e.event === 'reopen') handed.delete(item.scenario);
+    if (e.event === 'handoff' || e.event === 'reopen') changes.push([e.event, item.scenario]);
+  }
+  return { intentHash: state.intentHash, approvalWaiting: state.state === 'DRAFT', abandoned: state.state === 'ABANDONED', waiting: [...questions.keys()].sort(), handed: [...handed].sort(), changes: digest(JSON.stringify(changes)) };
+}
+function validEvidence(input) {
+  return input && /^r-\d+$/.test(input.run) && HASH.test(input.intentHash) && typeof input.done === 'boolean' &&
+    Array.isArray(input.scenarios) && input.scenarios.length <= 1000 &&
+    input.scenarios.every(s => s && ID.test(s.id) && STATUSES.includes(s.status)) &&
+    new Set(input.scenarios.map(s => s.id)).size === input.scenarios.length &&
+    (!input.done || input.scenarios.every(s => s.status === 'pass'));
+}
+function stopSnapshot(root, plan) {
+  let currentRevision = 'unavailable';
+  try {
+    currentRevision = revision(root);
+    const context = contextStatus(root, plan);
+    if (context !== 'fresh') return { snapshotStatus: context, failureCode: 'stop-context-unavailable', revision: currentRevision, files: null, workflow: null };
+    return { snapshotStatus: 'complete', revision: currentRevision, files: projectFingerprint(root), workflow: workflow(root).changes };
+  } catch {
+    return { snapshotStatus: 'unavailable', failureCode: 'stop-snapshot-unavailable', revision: currentRevision, files: null, workflow: null };
+  }
+}
+function recordStopEvidence(root, input) {
+  root = fs.realpathSync(root);
+  if (!validEvidence(input)) throw new Error('invalid Stop evidence');
+  const proof = { schemaVersion: 2, root, run: input.run, intentHash: input.intentHash, done: input.done,
+    scenarios: input.scenarios, repair: input.repair ?? null, failures: input.failures ?? [], executionPlan: input.executionPlan, ...stopSnapshot(root, input.executionPlan) };
+  writePrivate(root, name('proof', root), JSON.stringify(proof));
+  return proof;
+}
+function unavailableStatus(root, binding, proof) {
+  let currentRevision = 'unavailable';
+  let waiting = [];
+  try { currentRevision = revision(root); } catch { /* Only fixed diagnostic text leaves the hook. */ }
+  try { waiting = workflow(root).waiting; } catch { /* An unavailable inbox cannot supply question ids. */ }
+  return { root, revision: currentRevision, intent: proof.intentHash, complete: false, fresh: false, snapshotStatus: 'unavailable',
+    remaining: proof.scenarios.map(s => s.id), repair: repairData(proof.repair), failures: proof.failures ?? [], waiting, handed: [], graph: binding.scenarios };
+}
+function structuralStatus(root, binding) {
+  const raw = readPrivate(root, name('proof', root));
+  const proof = raw === null ? null : JSON.parse(raw);
+  if (proof && (proof.schemaVersion !== 2 || proof.root !== root || !validEvidence(proof))) throw new Error('invalid private proof');
+  if (proof && proof.snapshotStatus !== 'complete') return unavailableStatus(root, binding, proof);
+  if (proof && contextStatus(root, proof.executionPlan) !== 'fresh') return unavailableStatus(root, binding, proof);
+  const flow = workflow(root);
+  const currentRevision = revision(root);
+  const scenarios = proof?.scenarios ?? binding.scenarios;
+  if (scenarios.length > 1000 || scenarios.some(s => !ID.test(s.id))) throw new Error('invalid private scenarios');
+  const filesFresh = Boolean(proof && proof.intentHash === flow.intentHash && proof.revision === currentRevision && proof.files === projectFingerprint(root));
+  const fresh = Boolean(filesFresh && proof.workflow === flow.changes);
+  const complete = Boolean(fresh && proof.done && proof.scenarios.length && proof.scenarios.every(s => s.status === 'pass') && !flow.waiting.length && !flow.handed.length && !flow.approvalWaiting && !flow.abandoned);
+  const remaining = complete ? [] : scenarios.filter(s => !filesFresh || s.status !== 'pass' || flow.handed.includes(s.id)).map(s => s.id);
+  const hash = proof?.intentHash ?? 'unverified';
+  return { root, revision: currentRevision, intent: hash, complete, fresh, approvalWaiting: flow.approvalWaiting, abandoned: flow.abandoned, waiting: flow.waiting, handed: flow.handed, graph: binding.scenarios,
+    remaining, repair: repairData(proof?.repair), failures: proof?.failures ?? [], progress: digest(JSON.stringify({ statuses: proof?.scenarios?.map(s => [s.id, s.status]).sort() ?? [] })) };
+}
+function sessionStatus(payload = {}, env = process.env, cwd = process.cwd()) {
+  let root;
+  try {
+    root = hostRoot(payload, env, cwd);
+    const id = identity(payload, env);
+    const raw = readPrivate(root, name('session', id), 131072);
+    if (!raw) return { status: 'session-unbound', root, revision: revision(root) };
+    const binding = JSON.parse(raw);
+    if (binding.schemaVersion !== 1 || binding.id !== id || !Array.isArray(binding.scenarios) || binding.scenarios.length > 1000 ||
+      binding.scenarios.some(s => !s || !ID.test(s.id) || !Array.isArray(s.needs) || s.needs.length > 1000 || s.needs.some(n => !ID.test(n)))) throw new Error('session-unavailable');
+    if (binding.root !== root) return { status: 'session-root-mismatch', root, revision: revision(root) };
+    return { status: 'bound', id, ...structuralStatus(root, binding) };
+  } catch (error) {
+    const allowed = ['session-identity-invalid', 'session-identity-conflict', 'session-identity-missing', 'session-root-invalid', 'session-root-conflict'];
+    return { status: allowed.includes(error.message) ? error.message : 'session-unavailable', root: root ?? null, revision: 'unavailable' };
+  }
+}
+function message(view, status) {
+  const root = view.root ? encodeURIComponent(view.root).slice(0, 600) : 'unavailable';
+  const ids = (view.remaining ?? []).slice(0, 12).map(id => `${view.intent}/${id}`).join(',') || 'unresolved';
+  const questions = (view.waiting ?? []).filter(id => /^[a-zA-Z0-9-]{1,80}$/.test(id)).slice(0, 12);
+  return `[vibe] ${status}; root=${root}; revision=${view.revision}; scenarios=${ids}${questions.length ? `; questions=${questions.join(',')}` : ''}. Stop ran no checks.${repairMessage(view)}`;
+}
+function allHanded(view) {
+  if (!view.handed.length || !view.remaining.length) return false;
+  const covered = new Set(view.handed);
+  let changed;
+  do {
+    changed = false;
+    for (const s of view.graph) if (!covered.has(s.id) && s.needs.some(id => covered.has(id))) { covered.add(s.id); changed = true; }
+  } while (changed);
+  return view.remaining.every(id => covered.has(id));
+}
+function stopDecision(payload = {}, env = process.env, cwd = process.cwd()) {
+  const view = sessionStatus(payload, env, cwd);
+  if (view.status !== 'bound') return { systemMessage: message(view, `${view.status}; unmet; use explicit vibe session bind in the intended worktree`) };
+  if (view.snapshotStatus === 'unavailable') return { systemMessage: message(view, 'explicit-check snapshot unavailable; unmet') };
+  if (view.complete) return { systemMessage: message(view, 'verified completion from an explicit check') };
+  if (view.approvalWaiting) return { systemMessage: message(view, 'waiting for approval; unmet') };
+  if (view.abandoned) return { systemMessage: message(view, 'intent abandoned; unmet') };
+  if (view.waiting.length) return { systemMessage: message(view, 'waiting for an answer; unmet') };
+  if (allHanded(view)) return { systemMessage: message(view, 'required work is in handoff; unmet') };
+  try {
+    const raw = readPrivate(view.root, name('guard', view.id), 4096);
+    const old = raw ? JSON.parse(raw) : {};
+    const count = old.key === view.progress && Number.isInteger(old.count) && old.count >= 0 && old.count <= 3 ? Math.min(old.count + 1, 3) : 1;
+    writePrivate(view.root, name('guard', view.id), JSON.stringify({ key: view.progress, count }));
+    const reason = message(view, count > 2 ? 'same-state retry limit reached; unmet' : 'work remains unmet; build then explicitly run vibe check');
+    return count > 2 ? { systemMessage: reason } : { decision: 'block', reason };
+  } catch { return { systemMessage: message(view, 'session guard unavailable; unmet') }; }
+}
+module.exports = { identity, hostRoot, bindSession, recordStopEvidence, sessionStatus, stopDecision, message };

package/hooks/session.js

@@ -1,76 +1,27 @@
 #!/usr/bin/env node
-/**
- * SessionStart hook for the marketplace plugins (Claude Code · Codex · ChatGPT desktop).
- *
- * A plugin cannot write the client's CLAUDE.md / AGENTS.md, so the always-on card is handed to
- * the model here as context instead, with one line about the `vibe` CLI the skills call (the
- * npm package that registered this plugin; never installed from here). If the client home already
- * carries the card, the plugin steps back: one card, one hook, never two. Always exits 0.
- */
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
+// A packaged SessionStart reader: no CLI lookup, parent search or check execution.
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import sessionRuntime from './session-state.cjs';
+import sessionFiles from './session-files.cjs';
 
 const client = process.argv[2] || 'claude';
-const here = path.dirname(fileURLToPath(import.meta.url));
-const root = path.join(here, '..');
+const root = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
 const home = process.env.VIBE_HOME_DIR || os.homedir();
-const CARD_START = '<!-- vibe:start -->';
-
-function read(file) {
-  try {
-    return fs.readFileSync(file, 'utf-8');
-  } catch {
-    return '';
-  }
-}
-
-const version = (() => {
-  try {
-    return JSON.parse(read(path.join(root, 'package.json'))).version || '0.0.0';
-  } catch {
-    return '0.0.0';
-  }
-})();
-const card = read(path.join(root, 'card.md')).trim();
-const homeCard = client === 'claude' ? path.join(home, '.claude', 'CLAUDE.md') : path.join(home, '.codex', 'AGENTS.md');
-const homeOwns = read(homeCard).includes(CARD_START); // the npm install owns the card for this client; the state is still handed over below
-
-function cliVersion() {
-  const r = spawnSync('vibe', ['--version'], { encoding: 'utf-8', timeout: 10000, shell: process.platform === 'win32' });
-  return r.status === 0 ? (r.stdout || '').trim() : null;
+function read(file, limit = 65536) {
+  try { return sessionFiles.optional(file, limit) ?? ''; }
+  catch { return ''; }
 }
-
-function newer(a, b) {
-  const pa = a.split('.').map(Number);
-  const pb = b.split('.').map(Number);
-  for (let i = 0; i < 3; i += 1) if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) > (pb[i] || 0);
-  return false;
+function payload() {
+  try { return sessionFiles.readPayload(); }
+  catch { return { session_id: 'invalid payload' }; }
 }
-
-const installed = cliVersion();
-const cliNote = installed && !newer(version, installed)
-  ? `vibe CLI ${installed} on PATH`
-  : `vibe CLI ${installed ? `${installed} is older than this plugin (${version})` : 'is not on PATH'} — run: npm i -g @su-record/vibe@${version}`;
-
-/** The project's `vibe state`, when the session starts inside one — the model's first command, handed over for free. */
-function stateNote() {
-  const cwd = process.env.CLAUDE_PROJECT_DIR || process.cwd();
-  let dir = cwd;
-  for (;;) {
-    if (fs.existsSync(path.join(dir, '.vibe', 'state.json'))) break;
-    const up = path.dirname(dir);
-    if (up === dir || fs.existsSync(path.join(dir, '.git'))) return '';
-    dir = up;
-  }
-  const r = spawnSync('vibe', ['state'], { cwd: dir, encoding: 'utf-8', timeout: 60000, shell: process.platform === 'win32', env: { ...process.env, VIBE_SKIP_SETUP: '1' } });
-  return r.status === 0 && r.stdout ? `\n\n[vibe state — this is the first command already run; continue from its next line]\n${r.stdout.trim()}` : '';
-}
-
-const state = stateNote();
-if (homeOwns && !state) process.exit(0);
-const text = homeOwns ? state.trim() : `${card}\n\n[vibe plugin ${version}] ${cliNote}${state}`;
+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 view = sessionRuntime.sessionStatus(payload());
+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 text = homeOwns ? note : `${card}\n\n${note}`;
 process.stdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } })}\n`);
-process.exit(0);

package/hooks/slice-command.cjs

@@ -0,0 +1,121 @@
+const path = require('node:path');
+
+// A bounded lexical recognizer, never a shell evaluator. Dynamic expansions remain unresolved.
+function tokenize(text) {
+  if (typeof text !== 'string' || text.length > 65536) return null;
+  const tokens = [];
+  let word = '', quote = '';
+  const flush = () => { if (word) tokens.push(word); word = ''; };
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === quote) quote = '';
+      else if (ch === '\\' && quote === '"' && ['"', '\\'].includes(text[i + 1])) word += text[++i];
+      else word += ch;
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === '\\' && /[\s'"|;&<>]/.test(text[i + 1] ?? '')) word += text[++i];
+    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 (quote) return null;
+  flush();
+  return tokens;
+}
+function sections(tokens) {
+  const out = [];
+  let words = [], pipe = false;
+  for (const token of tokens) {
+    if (['|', '||', ';', '&', '&&', '\n'].includes(token)) {
+      if (words.length) out.push({ words, pipe });
+      words = []; pipe = token === '|';
+    } else words.push(token);
+  }
+  if (words.length) out.push({ words, pipe });
+  return out;
+}
+function command(words) {
+  let index = 0;
+  const redirects = [];
+  if (words[0] === 'env') index++;
+  for (;;) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(words[index] ?? '')) index++;
+    else if (['<', '>', '>>'].includes(words[index]) && words[index + 1]) { redirects.push(words[index], words[index + 1]); index += 2; }
+    else break;
+  }
+  return { name: path.basename(words[index] ?? '').replace(/\.exe$/i, ''), args: [...words.slice(index + 1), ...redirects] };
+}
+function operands(args, valued = []) {
+  const out = [];
+  let options = true;
+  for (let i = 0; i < args.length; i++) {
+    const word = args[i];
+    if (word === '--') { options = false; continue; }
+    if (word === '>' || word === '>>') { i++; continue; }
+    if (word === '<') { if (args[i + 1]) out.push(args[++i]); continue; }
+    if (options && valued.includes(word)) { i++; continue; }
+    if (options && word.startsWith('-')) continue;
+    out.push(word);
+  }
+  return out;
+}
+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 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']);
+  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]);
+  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 (['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']);
+    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');
+    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: [] };
+  const found = new Set();
+  let input = [], directory = cwd;
+  for (const section of sections(tokens)) {
+    if (!section.pipe) input = [];
+    const { name, args } = command(section.words);
+    if (name === 'cd' && args[0] && !/[`$*?]/.test(args[0])) { directory = path.resolve(directory, args[0]); continue; }
+    if (['bash', 'sh', 'zsh'].includes(name) && /^-[a-z]*c$/.test(args[0] ?? '')) {
+      const nested = sliceTargets(args[1] ?? '', directory, depth + 1);
+      if (nested.unavailable) return nested;
+      for (const file of nested.files) found.add(file);
+    }
+    const info = readerInfo(name, args);
+    if (!info) { input = []; continue; }
+    const files = info.files.filter(file => file !== '-' && !/[`$]/.test(file)).map(file => path.resolve(directory, file));
+    if (!files.length && !section.pipe && info.implicit) files.push(directory);
+    if (files.length) input = files;
+    if (info.slice) for (const file of input) found.add(file);
+    if (info.namesOnly) input = [];
+  }
+  return { unavailable: false, files: [...found].slice(0, 256) };
+}
+module.exports = { sliceTargets };

package/hooks/slice-guard.cjs

@@ -0,0 +1,41 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { sliceTargets } = require('./slice-command.cjs');
+const { readTargets, recordSlice } = require('./slice-store.cjs');
+
+function within(directory, file) {
+  const relative = path.relative(directory, file);
+  return !path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`);
+}
+function exempt(root, file) {
+  const relative = path.relative(root, file).split(path.sep).join('/');
+  return /(?:^|\/)\.dev(?:\/|$)/.test(relative) || /\.log(?:\.[\w-]+)?$/i.test(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;
+  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;
+  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.`;
+}
+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 }; }
+  const targets = sliceTargets(command, cwd);
+  if (targets.unavailable) return { decision: 'none', unavailable: true };
+  const files = targets.files.filter(file => !exempt(root, file));
+  if (!files.length) return { decision: 'none', unavailable: false };
+  const mirror = readTargets(root);
+  const decision = files.some(file => protectedFile(root, file, mirror.files)) ? 'block' : files.some(sourceFile) ? 'warn' : 'none';
+  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.' : ''}` };
+}
+module.exports = { sliceGuard };

package/hooks/slice-store.cjs

@@ -0,0 +1,72 @@
+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 prefix = root => `slice-${digest(root)}-`;
+const markerName = root => `slice-counts-${digest(root)}.json`;
+function explicitHome(env) {
+  if (env === undefined) return undefined;
+  const home = process.platform === 'win32' ? env.USERPROFILE : env.HOME;
+  if (typeof home !== 'string' || !path.isAbsolute(home)) throw new Error('fixture home required');
+  return home;
+}
+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;
+    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));
+    return true;
+  } catch { return false; }
+}
+function readTargets(root) {
+  try {
+    const raw = readPrivate(root, `read-targets-${digest(root)}.json`, 131072);
+    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: [] };
+    return { available: true, files: saved.files };
+  } catch { return { available: false, files: [] }; }
+}
+function recordSlice(root, decision) {
+  try {
+    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));
+    return true;
+  } catch { return false; }
+}
+function initializeSliceCounts(root, env) {
+  try {
+    root = fs.realpathSync(root);
+    const home = explicitHome(env);
+    const raw = readPrivate(root, markerName(root), 4096, 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;
+  } catch { return false; }
+}
+function readSliceCounts(root, env) {
+  try {
+    root = fs.realpathSync(root);
+    const home = explicitHome(env);
+    const marker = JSON.parse(readPrivate(root, markerName(root), 4096, 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;
+    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));
+      if (!((value.blocked === 1 && value.warned === 0) || (value.blocked === 0 && value.warned === 1))) return null;
+      counts.blocked += value.blocked; counts.warned += value.warned;
+    }
+    return counts;
+  } catch { return null; }
+}
+module.exports = { recordReadTargets, readTargets, recordSlice, initializeSliceCounts, readSliceCounts };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@su-record/vibe",
-  "version": "4.1.25",
+  "version": "4.1.26",
   "description": "An AX/FDE harness for Claude Code, Codex CLI and ChatGPT desktop. Say what you need, approve the scenarios once; the harness proves the work by running the checks itself. Memory in plain files, human tokens for irreversible actions, a ledger instead of claims.",
   "type": "module",
   "bin": {

package/skills/vibe/SKILL.md

@@ -13,6 +13,7 @@ If `vibe` is not on PATH, run `npm i -g @su-record/vibe` once; every command bel
 ## Procedure
 
 1. Run `vibe state --json`. A directory without `.vibe/` answers NONE; the first record creates it.
+   - Once the intended worktree is known, run `vibe session bind` when the host supplies `CODEX_THREAD_ID` or `CLAUDE_SESSION_ID`; otherwise use its actual session ID with `--session`. Never invent an ID or bind from inherited ledger entries. SessionStart and Stop read status only; run checks explicitly.
 2. If `notices` is non-empty, show them to the user first.
 3. If work is in progress (`state` is not NONE or ABANDONED) and the user's request is a new one, ask in one line: continue or start over? Starting over means `vibe abandon --reason "…"` first.
 4. Follow the `next` line. It is the procedure; a stage skill is loaded only when `next` names one:
@@ -20,15 +21,15 @@ If `vibe` is not on PATH, run `npm i -g @su-record/vibe` once; every command bel
 | `next` starts with | do |
 |---|---|
 | `discover` | load `vibe-discover` |
-| `approve` | load `vibe-scope` — the draft, `vibe intent analyze`, research, one approval message |
+| `approve` | load `vibe-scope` — sufficient agreement, runnable checks, `vibe intent analyze`, one approval message; research only for an unresolved gap |
 The card starts at `vibe state` and loads only the skill `next` names; this router is for an explicit `/vibe` and says the same thing.
 
 | `build …` | build what it lists first, then one `vibe check --all`; on a failure, fix what the check names; `vibe context <id>` when that is not enough, then `vibe check <id>` for that scenario only; load `vibe-build` only for a full task with parallel or irreversible scenarios |
 | `check --all` | run it |
-| `prove — STUCK` · `answer inbox` | answer the question, then `vibe check --all`; load `vibe-prove` on a second STUCK |
+| `prove — STUCK` | load `vibe-prove`; at two same-hash failures diagnose with context and change approach; at five relay the question id and cause, then wait; never invent an answer |
 | `report` | the completion report (card rule 9); HANDOFF.md only if the intent asks; no further checks after DONE |
 
-With an approved intent, never re-enter scope: a second draft voids the approval and doubles the work.
+Reuse an approved intent and unchanged evidence. Re-enter scope only for a changed outcome, constraint, or evidence basis: a new draft voids the previous approval.
 
 ## Never
 

package/skills/vibe-build/SKILL.md

@@ -12,10 +12,10 @@ user-invocable: false
 1. Take scenarios in the order of `remaining` from `vibe state --json` — parents before their `needs` dependents (`vibe state --graph` shows the edges). Put scenarios marked `irreversible` last.
    - Scenarios with no edge between them may be built by parallel agents, each in its own worktree, merged before `vibe check --all`. Never two agents in one working tree. Batch scenarios of one shape into one dispatch; never a nested subagent (a reviewer's reviewer counts for nothing). Hand artifacts to an agent as files, never pasted. When the context is nearly full, start a new session from `.vibe/` instead of compacting.
 2. Build only what each scenario needs, and make sure the check itself (`check.cmd`, `check.path`) can actually run. `vibe map` and `vibe context {id}` are tools for a question — where a symbol lives, what a change reaches — not a step before every scenario.
-   - Orientation reads ("what does this module do", "where is X handled") go through `vibe read <files> --ask "<question>"` — a low-reasoning model reads and answers with line numbers; read the file yourself only to edit or debug it.
+   - Read fewer files from state, each in full (Claude Read; Codex `cat`); grep/rg/find locate files or lines, never substitute content slices. Over 400 lines when not editing: `vibe read <files> --ask "<question>"`.
 3. When everything is built, `vibe check --all --json`; on a failure, fix what the check names — the failed line carries the scenario's files — and `vibe check {id} --json` for that scenario only; `vibe context {id}` when the files are not enough: the decisions, regressions and notes around them.
    - Pass (`code 0`): the next failing scenario, or `vibe check --all` when none is left.
-   - Fail (`code 1`): read `tail` and fix. If the same failure happens twice the harness marks STUCK and leaves an inbox question — stop and show that question to the user.
+   - Fail (`code 1`): use the error summary and named files; raw output requires explicit `--diagnostics` and stays private. The same failure twice requires `vibe context` and a changed approach; ask after five failed attempts or outside your authority, including the error and attempts.
    - Blocked (`status: blocked`): a parent has not passed; `vibe check {id}` runs unpassed parents first, so fix the parent named in `blockedBy`.
 4. When a project-local skill (`vibe skill list`) applies to the scenario, follow it and run `vibe skill used {name}` — prune decisions read the ledger.
 5. Record a fixed failure with `vibe regress record --scenario {id} --title "…" --check-from-evidence {run}`.
@@ -35,3 +35,4 @@ If the response carries a token, show it to the user and execute only after they
 
 - Weaken a check to make it pass (editing scenarios.yaml voids the approval — the harness enforces this).
 - Claim a pass without `vibe check`.
+- Rely on Stop to run checks. It blocks unchanged unfinished work twice, then releases it as unmet; inbox waits and scenario handoffs also release without success.

package/skills/vibe-discover/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: vibe-discover
-description: Discover — turn a vague request into "what counts as success". At most three questions, each with a default. Surface anomalies in the sample before being asked.
+description: Discover — find the customer's problem and agree on success from evidence. Ask only about consequential unknowns; stop when the scope is sufficient.
 user-invocable: false
 ---
 
@@ -8,19 +8,20 @@ user-invocable: false
 
 ## Procedure
 
-Order the questions by impact: scope first, then security and privacy, then the reader's or user's experience, then technical detail. A question further down the list is asked only when the earlier ones are settled.
+Resolve the problem and success criteria before implementation choices. A clear request can need no interview. If the request is to find work AI can take over, read [work-opportunities.md](work-opportunities.md) for that procedure; do not load it for other tasks.
 
-1. Read what the user attached through the harness, so every client sees the same thing:
+1. Use accessible evidence before asking the customer:
+   - on resumption, reuse the intent's compact findings when `vibe intent show --json` reports their `sourceBasis` unchanged; re-evaluate only findings affected by changed or missing sources
    - before asking, scan `docs/`, `README*` and `*.md` for relevant rules even when the brief does not name them; read those documents before deciding what is unknown
-   - table (csv · tsv · jsonl · json · xlsx) → `vibe profile {file} --json` [`--sheet`]: columns, types, missing counts, duplicates, up to three anomalies with numbers
+   - when a table can resolve a relevant unknown (csv · tsv · jsonl · json · xlsx), use `vibe profile {file} --json` [`--sheet`]: columns, types, missing counts, duplicates, up to three anomalies with numbers
    - document (xlsx · docx · pptx · pdf · hwp · hwpx · html) → `vibe read {file} --json` [`--sheet` · `--pages`]; it says which reader it used (pdf: `pdftotext` when installed, else built-in)
    - long material that only needs an answer ("what does this contract require", "which sheet holds the totals") → `vibe read {files} --ask "{question}"`; a low-reasoning model reads it and only the answer enters your context
    - image → your own file reader; vibe does not read images
-   - code or plain text → your file reader, the whole file — never a grep excerpt
-   If there is no sample, ask for one that the success condition can be checked against.
-2. Say the profile's anomalies before asking questions — at most three, each with its number. Do not add anomalies the profile did not find.
-3. Ask **at most three questions**, each with a default. No answer means the default applies. Every question must serve one purpose: deciding what counts as success.
-4. With the answers, write the intent draft (`.vibe/intent.md`, in English):
+   - code or plain text → fewer relevant files, each in full (Claude Read; Codex `cat`); grep/rg/find locate only, never content slices; over 400 lines when not editing → `vibe read --ask`
+   If a required sample is absent, name what cannot be established and request the smallest useful sample. Do not demand a sample for a task already defined and checkable without one.
+2. Report relevant observed anomalies first — at most three, each with its number and source. Do not invent a profile finding, duration, saving, probability, or missing requirement.
+3. Ask only when the answer changes the problem, success condition, constraint, or permitted action. Bundle at most three high-impact questions per round; explain the decision each resolves. An optional proposal is labelled as a proposal. Silence never answers a material question or authorizes an action; ask a focused follow-up if an important unknown remains. Reports belong in chat, not `vibe ask`.
+4. Write the compact intent (`.vibe/intent.md`, in English), retaining source references, the customer's decisions, and explicit unknowns:
 
 ```
 # {one-line title}
@@ -35,10 +36,10 @@ Order the questions by impact: scope first, then security and privacy, then the
 - {existing systems, data, deadlines}
 ```
 
-5. Once at least one success condition is a checkable statement, move to `vibe-scope`.
+5. Move to `vibe-scope` once the selected outcome, evidence basis, material constraints, executable acceptance conditions, and action boundaries are clear. Reuse an existing approved scope unless evidence or the requested outcome changes. Do not expand into another task just to fill a question or scenario quota.
 
 ## Message format
 
-- Questions as a numbered list, each ending with `(default: …)`.
+- Questions as a short numbered list when there is more than one; attach the decision, not an invented default.
 - Anomalies start with "Looking at the sample, …" and carry the number.
 - Talk to the user in the user's language; the intent file itself is English.