@haposoft/cafekit 0.16.0-rc.7 → 0.16.0

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

@@ -0,0 +1,196 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const STATUS_PATH = path.resolve(__dirname, '..', '..', 'status.cjs');
+const GOLDEN_PATH = path.join(__dirname, 'fixtures', 'statusline-default.golden');
+const NBSP = / /g;
+
+const cleanupDirs = [];
+process.on('exit', () => {
+  for (const dir of cleanupDirs) fs.rmSync(dir, { recursive: true, force: true });
+});
+
+function basePayload(overrides = {}) {
+  return {
+    model: { display_name: 'TestModel' },
+    workspace: { current_dir: '/fixture/dir' },
+    cwd: '/fixture/dir',
+    context_window: {
+      context_window_size: 200000,
+      current_usage: {
+        input_tokens: 40000,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 20000,
+      },
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Spawn status.cjs as a child process under a fully pinned environment:
+ * - cwd: a fixture root carrying its own .claude/runtime.json
+ * - TMPDIR/TEMP/TMP: an isolated per-case temp root (git + usage + context caches)
+ * - NO_COLOR/FORCE_COLOR scrubbed unless the case provides them
+ * - COLUMNS pinned so responsive wrapping is deterministic
+ */
+function runStatus({ runtime = { statusline: 'full', statuslineColors: true }, payload = basePayload(), envExtra = {}, tmpFiles = {} } = {}) {
+  const caseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-case-'));
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-tmp-'));
+  try {
+    fs.mkdirSync(path.join(caseDir, '.claude'));
+    fs.writeFileSync(path.join(caseDir, '.claude', 'runtime.json'), JSON.stringify(runtime));
+    for (const [name, content] of Object.entries(tmpFiles)) {
+      fs.writeFileSync(path.join(tmpDir, name), JSON.stringify(content));
+    }
+    const env = {
+      PATH: process.env.PATH,
+      HOME: process.env.HOME,
+      TMPDIR: tmpDir,
+      TEMP: tmpDir,
+      TMP: tmpDir,
+      COLUMNS: '200',
+      ...envExtra,
+    };
+    const result = spawnSync(process.execPath, [STATUS_PATH], {
+      cwd: caseDir,
+      env,
+      input: Buffer.from(JSON.stringify(payload)),
+    });
+    return {
+      status: result.status,
+      stdoutBuffer: result.stdout,
+      stdout: result.stdout.toString('utf8'),
+      stderr: result.stderr.toString('utf8'),
+      readTmpFile(name) {
+        const p = path.join(tmpDir, name);
+        return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+      },
+    };
+  } finally {
+    // Defer cleanup so readTmpFile still works after the spawn returns.
+    cleanupDirs.push(caseDir, tmpDir);
+  }
+}
+
+function freshUsageCache(now = Date.now()) {
+  return {
+    status: 'available',
+    timestamp: now,
+    data: {
+      five_hour: { utilization: 20, resets_at: new Date(now + 2 * 3600 * 1000 + 29 * 60 * 1000).toISOString() },
+      seven_day: { utilization: 45, resets_at: new Date(now + (2 * 86400 + 5 * 3600) * 1000).toISOString() },
+    },
+  };
+}
+
+test('statusline default output is byte-identical to the golden fixture when no layout is configured', () => {
+  const golden = fs.readFileSync(GOLDEN_PATH);
+  const run = runStatus();
+  assert.equal(run.status, 0, run.stderr);
+  assert.ok(run.stdoutBuffer.equals(golden),
+    `default output drifted from golden\nexpected: ${JSON.stringify(golden.toString('utf8'))}\nactual:   ${JSON.stringify(run.stdout)}`);
+});
+
+test('statusline custom layout renders named sections in order per line', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['directory', 'model']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  const dirIndex = run.stdout.indexOf('📁');
+  const modelIndex = run.stdout.indexOf('🤖');
+  assert.ok(dirIndex >= 0 && modelIndex >= 0, run.stdout);
+  assert.ok(dirIndex < modelIndex, `directory must precede model: ${JSON.stringify(run.stdout)}`);
+});
+
+test('statusline ignores unknown section ids without crashing or rendering placeholders', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model', 'bogus']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  assert.match(run.stdout, /🤖/);
+  assert.doesNotMatch(run.stdout, /bogus/);
+});
+
+test('statusline modes slice the layout line count (minimal renders only the first line)', () => {
+  const run = runStatus({
+    runtime: { statusline: 'minimal', statuslineColors: true, statuslineLayout: { lines: [['model'], ['directory']] } },
+  });
+  assert.equal(run.status, 0, run.stderr);
+  assert.match(run.stdout, /🤖/);
+  assert.doesNotMatch(run.stdout, /📁/);
+});
+
+test('statusline empty or invalid layout falls back to the default renderers', () => {
+  const golden = fs.readFileSync(GOLDEN_PATH);
+  for (const layout of [{}, { lines: [] }, { lines: [['bogus']] }, 'nonsense']) {
+    const run = runStatus({
+      runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: layout },
+    });
+    assert.equal(run.status, 0, run.stderr);
+    assert.ok(run.stdoutBuffer.equals(golden), `fallback drifted for layout ${JSON.stringify(layout)}: ${JSON.stringify(run.stdout)}`);
+  }
+});
+
+test('statusline shows five-hour and weekly windows with countdowns when the cache is fresh', () => {
+  const run = runStatus({ tmpFiles: { 'ck-usage-limits-cache.json': freshUsageCache() } });
+  assert.equal(run.status, 0, run.stderr);
+  const plain = run.stdout.replace(NBSP, ' ');
+  assert.match(plain, /⌛ \d+h \d+m left \(20% used\)/, plain);
+  assert.match(plain, /wk 45% \(\d+d \d+h\)/, plain);
+});
+
+test('statusline hides the quota area when the cache is stale', () => {
+  const stale = freshUsageCache(Date.now() - 10 * 60 * 1000);
+  stale.timestamp = Date.now() - 10 * 60 * 1000;
+  const run = runStatus({ tmpFiles: { 'ck-usage-limits-cache.json': stale } });
+  assert.equal(run.status, 0, run.stderr);
+  assert.doesNotMatch(run.stdout, /⌛/);
+  assert.doesNotMatch(run.stdout, /wk /);
+});
+
+test('statusline cost renders only when the layout enables it, billing is api, and data exists', () => {
+  const costLayout = { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model', 'cost']] } };
+  const withCost = basePayload({ cost: { total_cost_usd: '1.2345' } });
+
+  const enabled = runStatus({ runtime: costLayout, payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(enabled.status, 0, enabled.stderr);
+  const plain = enabled.stdout.replace(NBSP, ' ');
+  assert.match(plain, /💵 \$1\.23(?!\d)/, plain);
+
+  const wrongBilling = runStatus({ runtime: costLayout, payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'subscription' } });
+  assert.equal(wrongBilling.status, 0, wrongBilling.stderr);
+  assert.doesNotMatch(wrongBilling.stdout, /💵/);
+
+  const noData = runStatus({ runtime: costLayout, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(noData.status, 0, noData.stderr);
+  assert.doesNotMatch(noData.stdout, /💵/);
+
+  const noLayout = runStatus({ payload: withCost, envExtra: { CLAUDE_BILLING_MODE: 'api' } });
+  assert.equal(noLayout.status, 0, noLayout.stderr);
+  assert.doesNotMatch(noLayout.stdout, /💵/);
+});
+
+test('statusline writes the ck-context session file regardless of layout', () => {
+  const run = runStatus({
+    runtime: { statusline: 'full', statuslineColors: true, statuslineLayout: { lines: [['model']] } },
+    payload: basePayload({ session_id: 'ctxcase' }),
+  });
+  assert.equal(run.status, 0, run.stderr);
+  const contextFile = run.readTmpFile('ck-context-ctxcase.json');
+  assert.ok(contextFile, 'ck-context-ctxcase.json must be written even under a custom layout');
+  assert.equal(typeof contextFile.percent, 'number');
+  assert.equal(typeof contextFile.tokens, 'number');
+});
+
+test('statusline honors NO_COLOR with no ANSI escapes in output', () => {
+  const run = runStatus({ envExtra: { NO_COLOR: '1' } });
+  assert.equal(run.status, 0, run.stderr);
+  assert.doesNotMatch(run.stdout, /\[/);
+});

package/src/claude/hooks/agent.cjs

@@ -90,7 +90,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'agent', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/docs-sync.cjs

@@ -14,7 +14,7 @@
 try {
   const fs = require('fs');
   const path = require('path');
-  const { execSync } = require('child_process');
+  const { execFileSync } = require('child_process');
   const { loadConfig } = require('./lib/config.cjs');
 
   // Đọc stdin theo chuẩn hook
@@ -24,6 +24,9 @@ try {
   const config = loadConfig({ cwd, includeProject: false, includeAssertions: false, includeLocale: false });
 
   const docsDir = path.join(cwd, config.paths?.docs || 'docs');
+  const specsDir = path.join(cwd, config.paths?.specs || 'specs');
+  const docsRelative = path.relative(cwd, docsDir).replace(/\\/g, '/');
+  const specsRelative = path.relative(cwd, specsDir).replace(/\\/g, '/');
   
   // Xác định dự án đã có cốt lõi code hay chưa?
   const hasCode = fs.existsSync(path.join(cwd, 'src')) ||
@@ -46,16 +49,18 @@ try {
     lines.push('> Source exists but `docs/` does not. Create baseline docs first:');
     lines.push('> 1. `docs/system-architecture.md` — system architecture and flows');
     lines.push('> 2. `docs/project-overview-pdr.md` — overview, goals, features');
-    lines.push('> 3. Write current hash to `docs/.sync_hash` via `git log -1 --format="%H" -- . ":(exclude)docs"`');
+    lines.push('> 3. Write the latest non-docs/non-Specs source hash to `docs/.sync_hash`.');
     lines.push('');
   }
   // Case 2: docs exist — check continuous sync vs source-only git hash
   else {
     try {
       // Latest SOURCE-only hash (ignore docs-only commits)
-      const currentHash = execSync('git log -1 --format="%H" -- . ":(exclude)docs"', { 
-        cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] 
-      }).trim();
+      const currentHash = execFileSync('git', [
+        'log', '-1', '--format=%H', '--', '.',
+        `:(exclude,literal)${docsRelative}`,
+        `:(exclude,literal)${specsRelative}`,
+      ], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
 
       if (currentHash) {
         const syncTrackingFile = path.join(docsDir, '.sync_hash');
@@ -87,11 +92,8 @@ try {
 } catch (e) {
   // Ghi log lỗi ẩn danh nếu sập hook
   try {
-    const fs = require('fs'), p = require('path'), os = require('os');
-    const isSourceTree = __dirname.includes(`${p.sep}packages${p.sep}spec${p.sep}src`);
-    const d = isSourceTree
-      ? p.join(os.tmpdir(), 'cafekit-hook-logs', 'claude-docs-sync')
-      : p.join(__dirname, '.logs');
+    const fs = require('fs'), p = require('path');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'docs-sync', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/inspect-block.cjs

@@ -115,7 +115,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'inspect-block', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/lib/config.cjs

@@ -520,6 +520,9 @@ function loadConfig(options = {}) {
     // Statusline mode
     result.statusline = merged.statusline || 'full';
     result.statuslineColors = merged.statuslineColors !== false;
+    if (merged.statuslineLayout && typeof merged.statuslineLayout === 'object') {
+      result.statuslineLayout = merged.statuslineLayout;
+    }
 
     return sanitizeConfig(result, projectRoot);
   } catch (e) {

package/src/claude/hooks/lib/hook-state-dir.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+/**
+ * Where a Claude hook keeps its own generated state: crash logs and the
+ * gate/tollgate caches.
+ *
+ * Hooks run from two places. In an installed project they live in
+ * `.claude/hooks/`, whose `.logs/` is gitignored, so writing beside the hook is
+ * correct. During this package's tests they run straight from
+ * `packages/spec/src/claude/hooks/`, where the same write lands inside the
+ * source tree as an untracked directory. That changes the worktree digest the
+ * receipt provenance is bound to, and the completion gate then reports every
+ * done task as stale. It surfaced three times as a false alarm before the cause
+ * was found, so source-tree runs write to a temp directory instead.
+ *
+ * Keeping the rule here means a new hook cannot reintroduce the bug by copying
+ * the old `path.join(__dirname, '.logs')` line.
+ */
+
+const os = require('os');
+const path = require('path');
+
+// This module ships in `hooks/lib/`, so the hook directory is always its parent.
+const HOOKS_DIR = path.join(__dirname, '..');
+const SOURCE_MARKER = `${path.sep}packages${path.sep}spec${path.sep}src`;
+
+/** True when `dir` sits inside this package's source tree rather than an install. */
+function isSourceTree(dir) {
+  return String(dir || '').includes(SOURCE_MARKER);
+}
+
+/** Absolute directory for hook-generated state; create it before writing. */
+function hookStateDir() {
+  return isSourceTree(HOOKS_DIR)
+    ? path.join(os.tmpdir(), 'cafekit-hook-logs', 'claude')
+    : path.join(HOOKS_DIR, '.logs');
+}
+
+module.exports = { hookStateDir, isSourceTree };

package/src/claude/hooks/lib/secret-keywords.cjs

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * Secret-output guardrail keyword matcher.
+ *
+ * These patterns detect prompts about credential handling. They are deliberately
+ * separate from the privacy hooks: those gate whether a sensitive file may be READ,
+ * while this list drives a soft reminder about whether a value may be PRINTED.
+ * Approval for the first is not approval for the second.
+ */
+
+const SECRET_KEYWORD_PATTERNS = [
+  /\.env(?:\b|$)/i,
+  /(?:^|[^A-Za-z0-9])credentials?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])secrets?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])api[\s_-]*keys?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])access[\s_-]*keys?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])tokens?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])bearer(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])jwts?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])private[\s_-]*keys?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])oauth(?:[\s_-]+client)?[\s_-]*secrets?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])client[\s_-]*secrets?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])cloud[\s_-]*keys?(?:$|[^A-Za-z0-9])/i,
+  /(?:^|[^A-Za-z0-9])env[\s_-]+files?(?:$|[^A-Za-z0-9])/i,
+];
+
+/** The reminder text. It names no value and quotes no prompt. */
+const REMINDER = [
+  '## Secret handling',
+  '- Do not print raw credentials, API keys, tokens, JWTs, private keys, or secret values into the conversation.',
+  '- Use [redacted], variable names, counts, or high-level status instead.',
+  '- Approval to read a sensitive file or command output does not grant permission to print raw values.',
+  '- If a value is needed for a machine action, pass it through a non-echoing path and report only success or failure.',
+].join('\n');
+
+function containsSecretKeyword(prompt) {
+  if (typeof prompt !== 'string' || prompt.trim() === '') return false;
+  return SECRET_KEYWORD_PATTERNS.some((pattern) => pattern.test(prompt));
+}
+
+module.exports = { SECRET_KEYWORD_PATTERNS, REMINDER, containsSecretKeyword };

package/src/claude/hooks/precompact.cjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * PreCompact Hook — precompact.cjs
+ * Implements: https://docs.anthropic.com/en/docs/claude-code/hooks
+ *
+ * Compaction drops the transcript that told the session where it was. The
+ * existing SessionStart warning tells the operator something was lost but not
+ * what, so recovery starts from a blank slate and the session re-derives facts
+ * it already had. This hook writes down the machine-checkable anchors just
+ * before the drop: branch, HEAD, how dirty the tree is, and which task the
+ * packet says is in flight. `session.cjs` prints them back on the compact
+ * restart.
+ *
+ * Only facts the runtime can re-derive are recorded. Nothing here is proof of
+ * work and nothing here grants an authorization; a compacted session must still
+ * re-ask for a pending confirmation.
+ *
+ * Storage: the hook state directory (temp when run from source).
+ * Exit: 0 always (fail-open).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const RECOVERY_FILE = 'compact-recovery.json';
+
+function gitLine(root, args) {
+  const result = spawnSync('git', ['-C', root, ...args], { encoding: 'utf8' });
+  if (result.error || result.status !== 0) return null;
+  const value = String(result.stdout || '').trim();
+  return value === '' ? null : value;
+}
+
+function projectRoot(payload) {
+  const configured = typeof process.env.CLAUDE_PROJECT_DIR === 'string' ? process.env.CLAUDE_PROJECT_DIR.trim() : '';
+  const candidates = [configured, typeof payload.cwd === 'string' ? payload.cwd.trim() : '', process.cwd()];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    try { return fs.realpathSync(path.resolve(candidate)); } catch { /* next */ }
+  }
+  return process.cwd();
+}
+
+/** The one task the packet currently says is in flight, if any. */
+function activeTask(root) {
+  try {
+    const RESOLVER = require(path.join(__dirname, '..', 'scripts', 'spec-resolver.cjs'));
+    if (typeof RESOLVER.resolveWorkflowCandidate !== 'function') return null;
+    const resolved = RESOLVER.resolveWorkflowCandidate({ projectRoot: root, runtime: {}, target: null });
+    if (!resolved || resolved.error || resolved.layoutKind !== 'process-v3') return null;
+    const registry = resolved.taskRegistry || {};
+    const inProgress = Object.keys(registry).filter((taskPath) => registry[taskPath]?.status === 'in_progress');
+    return {
+      feature: resolved.featureName || null,
+      in_progress: inProgress,
+      counts: Object.values(registry).reduce((acc, task) => {
+        const status = task?.status || 'pending';
+        acc[status] = (acc[status] || 0) + 1;
+        return acc;
+      }, {}),
+    };
+  } catch {
+    return null;
+  }
+}
+
+try {
+  const stdin = fs.readFileSync(0, 'utf8').trim();
+  const payload = stdin ? JSON.parse(stdin) : {};
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) process.exit(0);
+
+  const root = projectRoot(payload);
+  const status = gitLine(root, ['status', '--porcelain']);
+  const record = {
+    captured_at: new Date().toISOString(),
+    trigger: typeof payload.trigger === 'string' ? payload.trigger : null,
+    session_id: typeof payload.session_id === 'string' ? payload.session_id : null,
+    project_root: root,
+    branch: gitLine(root, ['rev-parse', '--abbrev-ref', 'HEAD']),
+    head: gitLine(root, ['rev-parse', '--short', 'HEAD']),
+    dirty_count: status === null ? null : status.split('\n').filter((line) => line.trim() !== '').length,
+    workflow: activeTask(root),
+  };
+
+  const dir = require('./lib/hook-state-dir.cjs').hookStateDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const target = path.join(dir, RECOVERY_FILE);
+  const temp = `${target}.${process.pid}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(record, null, 2)}\n`);
+  fs.renameSync(temp, target);
+  process.exit(0);
+} catch (error) {
+  try {
+    const dir = require('./lib/hook-state-dir.cjs').hookStateDir();
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(
+      path.join(dir, 'hook-log.jsonl'),
+      `${JSON.stringify({ ts: new Date().toISOString(), hook: 'precompact', status: 'crash', error: error.message })}\n`,
+    );
+  } catch (_) { /* fail-open */ }
+  process.exit(0);
+}

package/src/claude/hooks/rules.cjs

@@ -93,7 +93,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'rules', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/secret-output-guardrail.cjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2026 Haposoft. MIT License.
+ *
+ * UserPromptSubmit Hook — secret-output-guardrail.cjs
+ * Implements: https://docs.anthropic.com/en/docs/claude-code/hooks
+ *
+ * The privacy hook gates whether a sensitive file may be read. Nothing gated what
+ * happens after that approval, so an approved read could still put a raw key into
+ * the transcript — where it survives compaction, is written to disk, and is replayed
+ * to the model on every later turn. This injects a reminder when the prompt itself is
+ * about credential handling.
+ *
+ * It reads the prompt and never echoes it: no prompt text and no matched value is
+ * written out, so the guardrail cannot itself become the leak.
+ *
+ * Exit: 0 always (fail-open)
+ */
+
+try {
+  const fs = require('fs');
+  const { REMINDER, containsSecretKeyword } = require('./lib/secret-keywords.cjs');
+
+  const stdin = fs.readFileSync(0, 'utf8').trim();
+  if (!stdin) process.exit(0);
+
+  const payload = JSON.parse(stdin);
+  const prompt = String(payload.prompt || payload.user_prompt || '');
+  if (!containsSecretKeyword(prompt)) process.exit(0);
+
+  console.log(REMINDER);
+  process.exit(0);
+
+} catch (e) {
+  try {
+    const fs = require('fs'), p = require('path');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
+    if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
+    fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
+      JSON.stringify({ ts: new Date().toISOString(), hook: 'secret-output-guardrail', status: 'crash', error: e.message }) + '\n');
+  } catch (_) {}
+  process.exit(0);
+}

package/src/claude/hooks/session.cjs

@@ -261,6 +261,32 @@ try {
     console.log('Any pending confirmations requested via AskUserQuestion might have been lost.');
     console.log('Do not proceed without explicitly asking the user again to ensure safety.');
     console.log('Use AskUserQuestion: "The chat context was compressed. Do I still have permission to proceed?"');
+
+    // Anchors captured by the PreCompact hook. These are re-derivable facts, not
+    // proof and not an authorization: they save the session from rebuilding its
+    // bearings, and nothing more.
+    try {
+      const fs2 = require('fs'), p2 = require('path');
+      const file = p2.join(require('./lib/hook-state-dir.cjs').hookStateDir(), 'compact-recovery.json');
+      const record = JSON.parse(fs2.readFileSync(file, 'utf8'));
+      const parts = [];
+      if (record.branch) parts.push(`branch ${record.branch}`);
+      if (record.head) parts.push(`HEAD ${record.head}`);
+      if (typeof record.dirty_count === 'number') parts.push(`${record.dirty_count} uncommitted path(s)`);
+      console.log('\n=== State before compaction ===');
+      if (record.captured_at) console.log(`Captured: ${record.captured_at}`);
+      if (parts.length) console.log(`Repository: ${parts.join(' | ')}`);
+      const workflow = record.workflow;
+      if (workflow && workflow.feature) {
+        const counts = Object.entries(workflow.counts || {}).map(([k, v]) => `${v} ${k}`).join(', ');
+        console.log(`Feature: ${workflow.feature}${counts ? ` (${counts})` : ''}`);
+        if (Array.isArray(workflow.in_progress) && workflow.in_progress.length > 0) {
+          console.log(`In flight: ${workflow.in_progress.join(', ')}`);
+        }
+      }
+      console.log('Re-read these from disk before acting; they describe the moment before compaction.');
+      console.log('=== End of pre-compaction state ===');
+    } catch (_) { /* no capture available */ }
   }
 
   process.exit(0);
@@ -269,7 +295,7 @@ try {
 } catch (e) {
   try {
     const fs = require('fs'), p = require('path');
-    const d = p.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(p.join(d, 'hook-log.jsonl'),
       JSON.stringify({ ts: new Date().toISOString(), hook: 'session', status: 'crash', error: e.message }) + '\n');

package/src/claude/hooks/spec-gate.cjs

@@ -44,7 +44,7 @@ function projectRoot(payload = {}) {
 
 function logCrash(error) {
   try {
-    const d = path.join(__dirname, '.logs');
+    const d = require('./lib/hook-state-dir.cjs').hookStateDir();
     if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
     fs.appendFileSync(
       path.join(d, 'hook-log.jsonl'),
@@ -202,7 +202,7 @@ try {
     process.exit(0);
   }
   const taskRegistry = resolved.taskRegistry || activeSpec.task_registry || {};
-  const cacheFile = path.join(__dirname, '.logs', 'spec-gate-last.json');
+  const cacheFile = path.join(require('./lib/hook-state-dir.cjs').hookStateDir(), 'spec-gate-last.json');
   const cacheExists = fs.existsSync(cacheFile);
   let cache = {};
   if (cacheExists) {
@@ -220,7 +220,7 @@ try {
   if (staleFlashTasks.length > 0) {
     process.stdout.write(JSON.stringify({
       decision: 'block',
-      reason: `Completion gate: ${staleFlashTasks.length} task(s) marked done with FLASH_UNVERIFIED (${staleFlashTasks.join(', ')}). Run /hapo:test for exact proof, then use explicit sync-finalize.`
+      reason: `Completion gate: ${staleFlashTasks.length} task(s) marked done with FLASH_UNVERIFIED (${staleFlashTasks.join(', ')}). Run /cf:test for exact proof, then use explicit sync-finalize.`
     }) + '\n');
     process.exit(0);
   }