@haposoft/cafekit 0.18.1 → 0.18.3

package/src/claude/hooks/__tests__/spec-state-touched.test.js

@@ -2,8 +2,8 @@
 
 // spec-state injects the active packet's tollgate on every prompt. With several sessions in
 // one checkout, a Claude session kept seeing a packet another session was working on. On
-// Claude the hook now speaks only about packets this session touched; omp, grok and
-// payloads without a Claude session id keep the old behaviour. Each case names the failure
+// Claude and omp the hook now speaks only about packets this session touched; grok and
+// payloads without a session id keep the old behaviour. Each case names the failure
 // it prevents.
 
 const { test } = require('node:test');
@@ -12,6 +12,7 @@ const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const crypto = require('node:crypto');
 
 const CLAUDE_ROOT = path.join(__dirname, '..', '..');
 
@@ -36,7 +37,7 @@ function fixture(packets, runtimeDir = '.claude') {
   fs.mkdirSync(path.join(hooks, 'lib'), { recursive: true });
   fs.mkdirSync(scripts, { recursive: true });
   fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'spec-state.cjs'), path.join(hooks, 'spec-state.cjs'));
-  for (const lib of ['runtime-dir.cjs', 'hook-payload.cjs', 'hook-state-dir.cjs']) {
+  for (const lib of ['runtime-dir.cjs', 'hook-payload.cjs', 'hook-state-dir.cjs', 'project-root.cjs', 'spec-touch.cjs']) {
     fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'lib', lib), path.join(hooks, 'lib', lib));
   }
   for (const file of ['provenance.cjs', 'spec-receipt.cjs', 'spec-resolver.cjs', 'workflow-policy.cjs']) {
@@ -48,23 +49,61 @@ function fixture(packets, runtimeDir = '.claude') {
     const git = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
     assert.strictEqual(git.status, 0, git.stderr);
   }
+  let lastSession = null;
   const run = (payload) => {
+    lastSession = payload.session_id;
+    const env = { ...process.env };
+    delete env.CLAUDE_PROJECT_DIR;
+    delete env.PROJECT_ROOT;
     const result = spawnSync(process.execPath, [path.join(hooks, 'spec-state.cjs')], {
-      cwd: root, env: { ...process.env, PROJECT_ROOT: root },
+      cwd: root, env,
       input: JSON.stringify({ cwd: root, ...payload }), encoding: 'utf8',
     });
     assert.strictEqual(result.status, 0, result.stderr);
     return result.stdout.trim();
   };
   const prompt = (session, text) => run({ hook_event_name: 'UserPromptSubmit', session_id: session, prompt: text });
-  const cacheFile = path.join(hooks, '.logs', 'tollgate-last.txt');
-  return { root, hooks, run, prompt, cacheFile, cleanup: () => fs.rmSync(root, { recursive: true, force: true }) };
+  return {
+    root, hooks, run, prompt,
+    get cacheFile() {
+      const name = ['.claude', '.omp'].includes(runtimeDir) && typeof lastSession === 'string' && lastSession
+        ? `tollgate-last-${crypto.createHash('sha256').update(lastSession).digest('hex').slice(0, 16)}.txt`
+        : 'tollgate-last.txt';
+      return path.join(hooks, '.logs', name);
+    },
+    cleanup: () => fs.rmSync(root, { recursive: true, force: true }),
+  };
 }
 
 function within(fx, fn) {
   try { return fn(fx); } finally { fx.cleanup(); }
 }
 
+test('Claude spec-state says receipt revalidation never grants approval', () => {
+  within(fixture(['auth-flow']), fx => {
+    assert.match(fx.prompt('message-session', 'specs/auth-flow'), /^- Hooks revalidate receipt bytes but never grant approval\.$/m);
+  });
+});
+
+test('Claude subagent rules include the shared simplicity and reporting instructions', () => {
+  within(fixture([]), fx => {
+    fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks/agent.cjs'), path.join(fx.hooks, 'agent.cjs'));
+    fs.writeFileSync(path.join(fx.root, '.claude/runtime.json'), '{}');
+    const env = { ...process.env };
+    delete env.CLAUDE_PROJECT_DIR;
+    delete env.PROJECT_ROOT;
+    const result = spawnSync(process.execPath, [path.join(fx.hooks, 'agent.cjs')], {
+      cwd: fx.root, env, encoding: 'utf8', input: JSON.stringify({ cwd: fx.root, hook_event_name: 'SubagentStart', agent_type: 'checker' }),
+    });
+    assert.strictEqual(result.status, 0, result.stderr);
+    const context = JSON.parse(result.stdout).hookSpecificOutput.additionalContext;
+    const rules = context.split('## Rules\n')[1];
+    assert.ok(rules, 'the rules section must be present');
+    assert.match(rules, /^- YAGNI · KISS · DRY$/m);
+    assert.match(rules, /^- Be concise\. List unresolved questions at end\.$/m);
+  });
+});
+
 test('an untouched packet prints nothing on Claude', () => {
   within(fixture(['auth-flow']), (fx) => {
     assert.strictEqual(fx.prompt('s1', 'Continue'), '');
@@ -72,6 +111,58 @@ test('an untouched packet prints nothing on Claude', () => {
   });
 });
 
+test('a touched packet respects the project tollgate toggle from a nested cwd', () => {
+  within(fixture(['auth-flow']), fx => {
+    assert.match(fx.prompt('s1', 'specs/auth-flow'), /Spec state changed/);
+    fs.writeFileSync(path.join(fx.root, '.claude/runtime.json'), JSON.stringify({ spec: { tollgate: false } }));
+    const cwd = path.join(fx.root, 'sub/dir');
+    fs.mkdirSync(cwd, { recursive: true });
+    assert.strictEqual(fx.run({ cwd, session_id: 's1', hook_event_name: 'UserPromptSubmit', prompt: 'Continue' }), '');
+  });
+});
+
+test('an explicitly failed edit does not touch its packet', () => {
+  within(fixture(['auth-flow']), fx => {
+    fx.run({ session_id: 's1', hook_event_name: 'PostToolUse', tool_name: 'Edit',
+      tool_input: { file_path: path.join(fx.root, 'specs/auth-flow/plan.md') }, tool_response: { is_error: true } });
+    assert.strictEqual(fx.prompt('s1', 'Continue'), '');
+  });
+});
+
+test('written content mentioning failure still touches its packet', () => {
+  within(fixture(['auth-flow']), fx => {
+    fx.run({ session_id: 's1', hook_event_name: 'PostToolUse', tool_name: 'Write',
+      tool_input: { file_path: path.join(fx.root, 'specs/auth-flow/plan.md') }, tool_response: { content: 'Failed x' } });
+    assert.match(fx.prompt('s1', 'Continue'), /Spec state changed/);
+  });
+});
+
+test('a configured specs prefix names a plain lowercase packet', () => {
+  within(fixture(['auth']), fx => {
+    fs.renameSync(path.join(fx.root, 'specs'), path.join(fx.root, 'planning'));
+    fs.writeFileSync(path.join(fx.root, '.claude/runtime.json'), JSON.stringify({ paths: { specs: 'planning' } }));
+    assert.match(fx.prompt('s1', 'Continue planning/auth'), /Spec state changed: `auth`/);
+  });
+});
+
+test('an explicit packet path records the session touch', () => {
+  within(fixture(['auth']), fx => {
+    assert.match(fx.run({ session_id: 's1', hook_event_name: 'UserPromptSubmit',
+      specPath: path.join(fs.realpathSync(fx.root), 'specs/auth'), prompt: 'Continue' }), /Spec state changed: `auth`/);
+    assert.match(fx.prompt('s1', 'Continue'), /Tollgate active/);
+  });
+});
+
+test('another session does not displace the compact tollgate cache', () => {
+  within(fixture(['auth-flow']), fx => {
+    assert.match(fx.prompt('session-a', 'specs/auth-flow'), /Spec state changed/);
+    assert.match(fx.prompt('session-b', 'specs/auth-flow'), /Spec state changed/);
+    const again = fx.prompt('session-a', 'Continue');
+    assert.match(again, /Tollgate active/);
+    assert.doesNotMatch(again, /Spec state changed/);
+  });
+});
+
 test('naming the packet in the prompt touches it and keeps the full block', () => {
   within(fixture(['auth-flow']), (fx) => {
     assert.strictEqual(fx.prompt('s1', 'Continue'), '');
@@ -113,10 +204,15 @@ test("another session's touch does not leak", () => {
   });
 });
 
-test('omp, grok and session-less payloads keep the old behaviour', () => {
+test('omp filters by touch like Claude', () => {
   within(fixture(['auth-flow'], '.omp'), (fx) => {
-    assert.match(fx.prompt('s5', 'Continue'), /Spec state changed/, 'omp is unchanged');
+    assert.strictEqual(fx.prompt('s5', 'Continue'), '', 'an untouched packet is silent under omp');
+    assert.match(fx.prompt('s5', 'specs/auth-flow'), /Spec state changed/);
+    assert.strictEqual(fx.prompt('s5b', 'Continue'), '', "another omp session's touch does not leak");
   });
+});
+
+test('grok and session-less payloads keep the old behaviour', () => {
   within(fixture(['auth-flow']), (fx) => {
     assert.match(fx.run({ hook_event_name: 'UserPromptSubmit', sessionId: 's6', prompt: 'Continue' }), /Spec/, 'grok sends sessionId');
   });
@@ -133,6 +229,53 @@ test('a prompt touch is remembered even when two packets are active', () => {
   });
 });
 
+test('an untouched session stays quiet with two active packets', () => {
+  within(fixture(['auth-flow', 'billing-2']), (fx) => {
+    assert.strictEqual(fx.prompt('s1', 'Continue'), '');
+  });
+});
+
+function invalidateTask(root, feature) {
+  fs.writeFileSync(path.join(root, 'specs', feature, 'task-01-work.md'),
+    '# Task 01: broken\n\n## Verification Plan\n\n- Command: node --test\n');
+}
+
+test('an untouched session stays quiet when a packet is invalid', () => {
+  within(fixture(['broken-flow']), (fx) => {
+    invalidateTask(fx.root, 'broken-flow');
+    assert.strictEqual(fx.prompt('s1', 'Continue'), '');
+  });
+});
+
+test('touching an invalid packet still prints its warning', () => {
+  within(fixture(['broken-flow']), (fx) => {
+    invalidateTask(fx.root, 'broken-flow');
+    assert.match(fx.prompt('s1', 'Continue specs/broken-flow'), /Invalid workflow packet/);
+  });
+});
+
+test('a session-less prompt still warns about two active packets', () => {
+  within(fixture(['auth-flow', 'billing-2']), (fx) => {
+    assert.match(fx.run({ hook_event_name: 'UserPromptSubmit', prompt: 'Continue' }), /Multiple active specs/);
+  });
+});
+
+test('a touched valid packet prints its tollgate when another packet is invalid', () => {
+  within(fixture(['auth-flow', 'broken-flow']), (fx) => {
+    invalidateTask(fx.root, 'broken-flow');
+    const output = fx.prompt('s1', 'Continue specs/auth-flow');
+    assert.match(output, /Spec state changed: `auth-flow`/);
+    assert.doesNotMatch(output, /Invalid workflow packet/);
+  });
+});
+
+test('an invalid specs root still warns an untouched session', () => {
+  within(fixture(['auth-flow']), (fx) => {
+    fs.writeFileSync(path.join(fx.root, '.claude/runtime.json'), JSON.stringify({ paths: { specs: '../outside' } }));
+    assert.match(fx.prompt('s1', 'Continue'), /Invalid workflow packet detected: <specs>/);
+  });
+});
+
 function writeLegacyPacket(root, name) {
   const dir = path.join(root, 'specs', name);
   fs.mkdirSync(path.join(dir, 'tasks'), { recursive: true });
@@ -158,3 +301,56 @@ test('a legacy packet is noticed even when it is the only packet', () => {
     assert.match(fx.prompt('s1', 'Continue'), LEGACY_NOTICE);
   });
 });
+
+test('Claude spec-state uses one snapshot for done task receipts', (t) => {
+  within(fixture(['auth-flow']), (fx) => {
+    const trace = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-snapshot-count-'));
+    try {
+      const feature = path.join(fx.root, 'specs/auth-flow');
+      const tasks = ['task-01-work.md', 'task-02-work.md'];
+      for (const name of tasks) fs.writeFileSync(path.join(feature, name), taskContent('done'));
+      fs.writeFileSync(path.join(feature, 'task-03-work.md'), taskContent('in_progress'));
+      const scripts = path.join(fx.root, '.claude/scripts');
+      const provenance = require(path.join(scripts, 'provenance.cjs'));
+      const policy = require(path.join(scripts, 'workflow-policy.cjs'));
+      const receipt = require(path.join(scripts, 'spec-receipt.cjs'));
+      const context = provenance.deriveRuntimeContext({ projectRoot: fx.root,
+        specsRoot: path.join(fx.root, 'specs'), specFile: path.join(feature, 'plan.md'),
+        featureName: 'auth-flow', runtimeSession: 'one-snapshot' });
+      for (const name of tasks) {
+        fs.appendFileSync(path.join(feature, name), [
+          '\n## Receipt', '', 'Verification: PASS', 'Command: node --test', 'Exit: 0',
+          `Base: ${context.base}`, `Head: ${context.head}`, '```text', '1 test passed', '```', '',
+        ].join('\n'));
+        assert.deepStrictEqual(receipt.checkWorkflowTaskReceipt(feature, name, context, policy).failures, []);
+      }
+      const countFile = path.join(trace, 'git-status.txt');
+      const preload = path.join(trace, 'count.cjs');
+      fs.writeFileSync(preload, `
+const cp = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+for (const method of ['spawnSync', 'execFileSync']) {
+  const original = cp[method];
+  cp[method] = function(command, args, ...rest) {
+    if (path.basename(String(command)) === 'git' && Array.isArray(args) && args.includes('status'))
+      fs.appendFileSync(${JSON.stringify(countFile)}, 'status\\n');
+    return original.call(this, command, args, ...rest);
+  };
+}
+`);
+      const result = spawnSync(process.execPath, [path.join(fx.hooks, 'spec-state.cjs')], {
+        cwd: fx.root, encoding: 'utf8',
+        env: { ...process.env, PROJECT_ROOT: fx.root,
+          NODE_OPTIONS: `${process.env.NODE_OPTIONS || ''} --require ${JSON.stringify(preload)}` },
+        input: JSON.stringify({ cwd: fx.root, hook_event_name: 'UserPromptSubmit',
+          session_id: 'one-snapshot', prompt: 'Continue specs/auth-flow' }),
+      });
+      assert.strictEqual(result.status, 0, result.stderr);
+      assert.match(result.stdout, /Spec state changed/);
+      const count = fs.readFileSync(countFile, 'utf8').trim().split('\n').length;
+      t.diagnostic(`Claude git status calls: ${count}`);
+      assert.ok(count > 0 && count <= 2, `git status calls: ${count}; expected at most 2`);
+    } finally { fs.rmSync(trace, { recursive: true, force: true }); }
+  });
+});

package/src/claude/hooks/__tests__/state.test.js

@@ -6,9 +6,13 @@ const { spawnSync } = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const crypto = require('node:crypto');
 
 const CLAUDE_ROOT = path.join(__dirname, '..', '..');
 const STATE_HOOK = path.join(CLAUDE_ROOT, 'hooks', 'state.cjs');
+const HOOK_ENV = { ...process.env };
+delete HOOK_ENV.CLAUDE_PROJECT_DIR;
+delete HOOK_ENV.PROJECT_ROOT;
 const POLICY = require(path.join(CLAUDE_ROOT, 'scripts', 'workflow-policy.cjs'));
 
 function processTaskContent(title, status, dependency = 'none') {
@@ -44,6 +48,9 @@ function inInstalledProcessSpecStateFixture(run) {
     fs.mkdirSync(scripts, { recursive: true });
     fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'spec-state.cjs'), path.join(hooks, 'spec-state.cjs'));
     fs.mkdirSync(path.join(hooks, 'lib'), { recursive: true });
+    for (const lib of ['project-root.cjs', 'spec-touch.cjs']) {
+      fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'lib', lib), path.join(hooks, 'lib', lib));
+    }
     fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'lib', 'runtime-dir.cjs'), path.join(hooks, 'lib', 'runtime-dir.cjs'));
     fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks', 'lib', 'hook-payload.cjs'), path.join(hooks, 'lib', 'hook-payload.cjs'));
     fs.copyFileSync(
@@ -92,7 +99,7 @@ function inInstalledProcessSpecStateFixture(run) {
       encoding: 'utf8',
     });
     return run({
-      cacheFile: path.join(hooks, '.logs', 'tollgate-last.txt'),
+      cacheFile: path.join(hooks, '.logs', `tollgate-last-${crypto.createHash('sha256').update('session-auth-state').digest('hex').slice(0, 16)}.txt`),
       dir,
       feature,
       hooks,
@@ -277,6 +284,7 @@ test('Stop snapshot includes tracked modifications and untracked files', () => {
     fs.writeFileSync(path.join(dir, 'new-untracked.json'), '{}\n');
     const result = spawnSync(process.execPath, [STATE_HOOK], {
       cwd: dir,
+      env: HOOK_ENV,
       input: JSON.stringify({ hook_event_name: 'Stop', cwd: dir }),
       encoding: 'utf8',
     });
@@ -302,6 +310,7 @@ test('Stop snapshot includes untracked files before the first commit', () => {
 
     const result = spawnSync(process.execPath, [STATE_HOOK], {
       cwd: dir,
+      env: HOOK_ENV,
       input: JSON.stringify({ hook_event_name: 'Stop', cwd: dir }),
       encoding: 'utf8',
     });
@@ -344,7 +353,7 @@ const PLACEHOLDER_STATE = [
   '',
 ].join('\n');
 
-function sessionStartWith(content, runtimeFolder = '.claude') {
+function sessionStartWith(content, runtimeFolder = '.claude', readingSession = 'start-1') {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-state-start-'));
   try {
     let hook = STATE_HOOK;
@@ -352,17 +361,19 @@ function sessionStartWith(content, runtimeFolder = '.claude') {
       const hooks = path.join(dir, runtimeFolder, 'hooks');
       fs.mkdirSync(path.join(hooks, 'lib'), { recursive: true });
       fs.copyFileSync(STATE_HOOK, path.join(hooks, 'state.cjs'));
-      for (const lib of ['parser.cjs', 'runtime-dir.cjs', 'hook-payload.cjs', 'hook-state-dir.cjs']) {
+      for (const lib of ['parser.cjs', 'runtime-dir.cjs', 'hook-payload.cjs', 'hook-state-dir.cjs', 'project-root.cjs', 'secret-keywords.cjs']) {
         fs.copyFileSync(path.join(path.dirname(STATE_HOOK), 'lib', lib), path.join(hooks, 'lib', lib));
       }
       hook = path.join(hooks, 'state.cjs');
     }
-    const stateFolder = path.join(dir, runtimeFolder, 'session-state');
+    const stateFolder = path.join(dir, runtimeFolder, 'session-state',
+      ...(['.claude', '.omp'].includes(runtimeFolder) ? [crypto.createHash('sha256').update('start-1').digest('hex').slice(0, 16)] : []));
     fs.mkdirSync(stateFolder, { recursive: true });
     fs.writeFileSync(path.join(stateFolder, 'latest.md'), content.replace('GENERATED', new Date().toISOString()));
     const result = spawnSync(process.execPath, [hook], {
       cwd: dir,
-      input: JSON.stringify({ hook_event_name: 'SessionStart', session_id: 'start-1', cwd: dir }),
+      env: HOOK_ENV,
+      input: JSON.stringify({ hook_event_name: 'SessionStart', session_id: readingSession, cwd: dir }),
       encoding: 'utf8',
     });
     assert.strictEqual(result.status, 0, result.stderr);
@@ -381,6 +392,195 @@ test('SessionStart prints prior context that has a completed todo', () => {
   assert.match(sessionStartWith(withTodo), /Prior Execution Context[\s\S]*Ship the statusline/);
 });
 
-test('SessionStart under .omp keeps printing placeholder-only context', () => {
-  assert.match(sessionStartWith(PLACEHOLDER_STATE, '.omp'), /Prior Execution Context/);
+test('SessionStart under .omp drops placeholder-only context like Claude', () => {
+  assert.strictEqual(sessionStartWith(PLACEHOLDER_STATE, '.omp'), '');
+});
+
+test('two omp sessions keep separate state', () => {
+  const withTodo = PLACEHOLDER_STATE.replace('- (No completed tasks recorded)', '- Ship the statusline');
+  assert.match(sessionStartWith(withTodo, '.omp'), /Ship the statusline/, 'the same session reads its own state');
+  assert.strictEqual(sessionStartWith(withTodo, '.omp', 'start-2'), '', 'another omp session does not');
+});
+
+function inSessionStateFixture(run) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-state-sessions-'));
+  try {
+    const hooks = path.join(dir, '.claude/hooks');
+    fs.mkdirSync(path.join(hooks, 'lib'), { recursive: true });
+    fs.copyFileSync(STATE_HOOK, path.join(hooks, 'state.cjs'));
+    for (const lib of ['parser.cjs', 'runtime-dir.cjs', 'hook-payload.cjs', 'hook-state-dir.cjs', 'project-root.cjs', 'secret-keywords.cjs']) {
+      fs.copyFileSync(path.join(CLAUDE_ROOT, 'hooks/lib', lib), path.join(hooks, 'lib', lib));
+    }
+    const invoke = (payload) => {
+      const result = spawnSync(process.execPath, [path.join(hooks, 'state.cjs')], {
+        cwd: dir, env: HOOK_ENV, encoding: 'utf8', input: JSON.stringify({ cwd: dir, ...payload }),
+      });
+      assert.strictEqual(result.status, 0, result.stderr);
+      return result.stdout;
+    };
+    const write = (session, todo) => {
+      const transcript = path.join(dir, `${session}.jsonl`);
+      fs.writeFileSync(transcript, JSON.stringify({ message: { content: [{
+        type: 'tool_use', id: 'todo-write', name: 'TodoWrite',
+        input: { todos: [{ content: todo, status: 'completed' }] },
+      }] } }) + '\n');
+      invoke({ hook_event_name: 'PostToolUse', session_id: session, tool_name: 'TodoWrite', transcript_path: transcript });
+    };
+    run({ dir, invoke, write, stateRoot: path.join(dir, '.claude/session-state') });
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+function savedSession(stateRoot, session = 'robust-session') {
+  return path.join(stateRoot, crypto.createHash('sha256').update(session).digest('hex').slice(0, 16));
+}
+
+test('Agent refreshes the installed state from transcript todos and is parsed as an agent', () => {
+  inSessionStateFixture(({ dir, invoke, stateRoot }) => {
+    const transcript = path.join(dir, 'agent.jsonl');
+    const agent = { type: 'tool_use', id: 'agent-call', name: 'Agent', input: { subagent_type: 'tester' } };
+    fs.writeFileSync(transcript, JSON.stringify({ message: { content: [agent, {
+      type: 'tool_use', id: 'todos', name: 'TodoWrite', input: { todos: [{ content: 'Verify agent snapshot', status: 'pending' }] },
+    }] } }) + '\n');
+    invoke({ hook_event_name: 'PostToolUse', tool_name: 'Agent', session_id: 'robust-session', transcript_path: transcript });
+    const file = path.join(savedSession(stateRoot), 'latest.md');
+    assert.ok(fs.existsSync(file), 'Agent must create the state snapshot');
+    assert.match(fs.readFileSync(file, 'utf8'), /Verify agent snapshot/);
+    const agents = new Map();
+    const tools = new Map();
+    require('../lib/parser.cjs').processEntry({ message: { content: [agent] } }, tools, agents, [], {});
+    assert.ok(agents.has('agent-call'));
+    assert.ok(!tools.has('agent-call'));
+  });
+});
+
+test('Stop persists a bounded summary of the last assistant message', () => {
+  inSessionStateFixture(({ invoke, stateRoot }) => {
+    invoke({ hook_event_name: 'Stop', session_id: 'robust-session', last_assistant_message: 'Verified the change. ' + 'x'.repeat(700) });
+    const state = fs.readFileSync(path.join(savedSession(stateRoot), 'latest.md'), 'utf8');
+    assert.match(state, /## Latest Assistant Message\nVerified the change\./);
+    assert.ok(!state.includes('x'.repeat(601)), 'the summary must be bounded');
+  });
+});
+
+test('Stop omits secret-related assistant messages before saving state', () => {
+  inSessionStateFixture(({ invoke, stateRoot }) => {
+    const message = 'API key handling was discussed in this synthetic test.';
+    invoke({ hook_event_name: 'Stop', session_id: 'robust-session', last_assistant_message: message });
+    const state = fs.readFileSync(path.join(savedSession(stateRoot), 'latest.md'), 'utf8');
+    assert.ok(state.includes('[omitted: possible secret]'));
+    assert.ok(!state.includes(message));
+  });
+});
+
+test('SubagentStop saves the assistant summary and omits secret-related content', () => {
+  inSessionStateFixture(({ invoke, stateRoot }) => {
+    invoke({ hook_event_name: 'SubagentStop', session_id: 'robust-session', agent_type: 'tester', last_assistant_message: 'Checks passed.' });
+    const file = path.join(savedSession(stateRoot), 'latest.md');
+    assert.match(fs.readFileSync(file, 'utf8'), /Checks passed\./);
+    const message = 'Credentials handling was discussed in this synthetic test.';
+    invoke({ hook_event_name: 'SubagentStop', session_id: 'robust-session', agent_type: 'reviewer', last_assistant_message: message });
+    const state = fs.readFileSync(file, 'utf8');
+    assert.ok(state.includes('[omitted: possible secret]'));
+    assert.ok(!state.includes(message));
+  });
+});
+
+test('a fresh state write lock skips the snapshot without changing existing bytes', () => {
+  inSessionStateFixture(({ invoke, stateRoot }) => {
+    const dir = savedSession(stateRoot);
+    fs.mkdirSync(path.join(dir, '.write-lock'), { recursive: true });
+    const file = path.join(dir, 'latest.md');
+    fs.writeFileSync(file, 'Prior state must survive\n');
+    const before = fs.readFileSync(file);
+    invoke({ hook_event_name: 'Stop', session_id: 'robust-session', last_assistant_message: 'New snapshot' });
+    assert.deepStrictEqual(fs.readFileSync(file), before);
+    assert.ok(fs.existsSync(path.join(dir, '.write-lock')));
+  });
+});
+
+test('a stale state write lock is removed and the snapshot is saved', () => {
+  inSessionStateFixture(({ invoke, stateRoot }) => {
+    const dir = savedSession(stateRoot);
+    const lock = path.join(dir, '.write-lock');
+    fs.mkdirSync(lock, { recursive: true });
+    const old = new Date(Date.now() - 20000);
+    fs.utimesSync(lock, old, old);
+    invoke({ hook_event_name: 'Stop', session_id: 'robust-session' });
+    assert.ok(fs.existsSync(path.join(dir, 'latest.md')));
+    assert.ok(!fs.existsSync(lock), 'the stale lock must be released');
+  });
+});
+
+test('consecutive PostToolUse snapshots both save their todos and release the write lock', () => {
+  inSessionStateFixture(({ write, stateRoot }) => {
+    const dir = savedSession(stateRoot);
+    for (const todo of ['First saved todo', 'Second saved todo']) {
+      write('robust-session', todo);
+      assert.ok(fs.readFileSync(path.join(dir, 'latest.md'), 'utf8').includes(todo));
+      assert.ok(!fs.existsSync(path.join(dir, '.write-lock')));
+    }
+  });
+});
+
+test('malformed state input exits successfully and records a crash', () => {
+  inSessionStateFixture(({ dir }) => {
+    const hooks = path.join(dir, '.claude/hooks');
+    const result = spawnSync(process.execPath, [path.join(hooks, 'state.cjs')], { cwd: dir, input: '{', encoding: 'utf8' });
+    assert.strictEqual(result.status, 0);
+    const file = path.join(hooks, '.logs/hook-log.jsonl');
+    assert.ok(fs.existsSync(file), 'the asynchronous failure must be logged');
+    const rows = fs.readFileSync(file, 'utf8').trim().split('\n').map(line => JSON.parse(line));
+    assert.strictEqual(rows.length, 1);
+    assert.strictEqual(rows[0].hook, 'state');
+    assert.strictEqual(rows[0].status, 'crash');
+  });
+});
+
+test('a new Claude session startup does not inherit another session context', () => {
+  inSessionStateFixture(({ write, invoke }) => {
+    write('session-a', 'Completed work for session A');
+    const output = invoke({ hook_event_name: 'SessionStart', session_id: 'session-b', source: 'startup' });
+    assert.doesNotMatch(output, /Prior Execution Context/);
+  });
+});
+
+test('a Claude session resumes its own saved todo', () => {
+  inSessionStateFixture(({ write, invoke, stateRoot }) => {
+    write('session-a', 'Completed work for session A');
+    const key = crypto.createHash('sha256').update('session-a').digest('hex').slice(0, 16);
+    assert.match(fs.readFileSync(path.join(stateRoot, key, 'latest.md'), 'utf8'), /Completed work for session A/);
+    const output = invoke({ hook_event_name: 'SessionStart', session_id: 'session-a', source: 'resume' });
+    assert.match(output, /Prior Execution Context[\s\S]*Completed work for session A/);
+  });
+});
+
+test('two Claude sessions resume only their own completed todos', () => {
+  inSessionStateFixture(({ write, invoke }) => {
+    write('session-a', 'Completed work for session A');
+    write('session-b', 'Completed work for session B');
+    for (const [session, own, other] of [['session-a', 'session A', 'session B'], ['session-b', 'session B', 'session A']]) {
+      const output = invoke({ hook_event_name: 'SessionStart', session_id: session, source: 'resume' });
+      const verified = output.split('## What Worked (Verified)')[1]?.split("## What's Left")[0] || '';
+      assert.match(output, /Prior Execution Context/);
+      assert.ok(verified.includes(own));
+      assert.ok(!verified.includes(other));
+    }
+  });
+});
+
+test('a session-less payload still reads project-level context', () => {
+  inSessionStateFixture(({ stateRoot, invoke }) => {
+    fs.mkdirSync(stateRoot, { recursive: true });
+    fs.writeFileSync(path.join(stateRoot, 'latest.md'), PLACEHOLDER_STATE.replace('GENERATED', new Date().toISOString())
+      .replace('- (No completed tasks recorded)', '- Legacy project todo'));
+    assert.match(invoke({ hook_event_name: 'SessionStart' }), /Prior Execution Context[\s\S]*Legacy project todo/);
+  });
+});
+
+test('Claude SessionStart does not create state directories', () => {
+  inSessionStateFixture(({ stateRoot, invoke }) => {
+    assert.strictEqual(fs.existsSync(stateRoot), false);
+    assert.strictEqual(invoke({ hook_event_name: 'SessionStart', session_id: 'new-session', source: 'startup' }).trim(), '');
+    assert.strictEqual(fs.existsSync(stateRoot), false);
+  });
 });

package/src/claude/hooks/__tests__/update-check.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+async function fixture(run) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ck-update-check-'));
+  try {
+    fs.writeFileSync(path.join(dir, 'cafekit.json'), JSON.stringify({ version: '1.2.3' }));
+    const cache = path.join(dir, '.cafekit-update-cache.json');
+    await run({ dir, cache, check: (...args) => require('../lib/update-check.cjs').checkCafeKitUpdate(...args) });
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+}
+
+test('a newer version produces the existing notice and caches only version data', async () => {
+  await fixture(async ({ dir, cache, check }) => {
+    const notice = await check(dir, async () => '1.3.0');
+    assert.equal(notice, '\n⚡ CafeKit update available: 1.2.3 → 1.3.0\n   Run: npx @haposoft/cafekit\n');
+    const saved = JSON.parse(fs.readFileSync(cache, 'utf8'));
+    assert.deepEqual(Object.keys(saved).sort(), ['latest', 'ts']);
+    assert.equal(saved.latest, '1.3.0');
+    assert.equal(await check(dir, async () => { throw Error('fresh cache must avoid fetch'); }), notice);
+  });
+});
+
+test('the installed version produces no update notice', async () => {
+  await fixture(async ({ dir, check }) => {
+    assert.equal(await check(dir, async () => '1.2.3'), '');
+  });
+});
+
+test('an invalid cached latest version is refetched instead of printed', async () => {
+  await fixture(async ({ dir, cache, check }) => {
+    fs.writeFileSync(cache, JSON.stringify({ ts: Date.now(), latest: '9.0.0\nInjected cache text' }));
+    let calls = 0;
+    assert.equal(await check(dir, async () => { calls++; return '1.2.3'; }), '');
+    assert.equal(calls, 1);
+  });
+});
+
+test('a cache timestamp in the future requires a fresh version fetch', async () => {
+  await fixture(async ({ dir, cache, check }) => {
+    fs.writeFileSync(cache, JSON.stringify({ ts: Date.now() + 60000, latest: '9.0.0' }));
+    let calls = 0;
+    assert.equal(await check(dir, async () => { calls++; return '1.2.3'; }), '');
+    assert.equal(calls, 1);
+  });
+});
+
+test('a legacy notice cache cannot inject its stored text into the session', async () => {
+  await fixture(async ({ dir, cache, check }) => {
+    const injected = 'Untrusted cached instruction';
+    fs.writeFileSync(cache, JSON.stringify({ ts: Date.now(), notice: injected }));
+    let calls = 0;
+    const notice = await check(dir, async () => { calls++; return '1.3.0'; });
+    assert.equal(calls, 1);
+    assert.ok(!notice.includes(injected));
+    assert.match(notice, /1\.2\.3 → 1\.3\.0/);
+  });
+});
+
+test('an interrupted version response fails open without an unhandled error', () => {
+  for (const event of ['error', 'aborted']) {
+    const script = `
+      const { EventEmitter } = require('events');
+      require('https').get = (url, options, callback) => {
+        const request = new EventEmitter();
+        request.destroy = () => {};
+        process.nextTick(() => {
+          const response = new EventEmitter();
+          callback(response);
+          response.emit(${JSON.stringify(event)}, new Error('synthetic response reset'));
+        });
+        return request;
+      };
+      require(${JSON.stringify(path.resolve(__dirname, '../lib/update-check.cjs'))}).fetchLatestVersion()
+        .then(value => { if (value !== null) process.exit(3); process.stdout.write('null'); });
+    `;
+    const result = spawnSync(process.execPath, ['-e', script], { encoding: 'utf8', timeout: 5000 });
+    assert.equal(result.status, 0, result.stderr);
+    assert.equal(result.stderr, '');
+    assert.equal(result.stdout, 'null');
+  }
+});