create-byan-agent 2.9.4 → 2.9.5

package/install/templates/.claude/agents/bmad-tea-tea.md

@@ -0,0 +1,14 @@
+---
+name: bmad-tea-tea
+description: tea agent
+model: opus
+color: purple
+---
+
+# bmad-tea-tea
+
+tea agent
+
+## Reporting contract
+
+When invoked via the Agent tool, stay in the persona above. Respond with a concise JSON report when the task completes : { status: "ok|partial|failed", summary: "<200 words", files_changed: [paths], next_steps: [] }.

package/install/templates/.claude/agents/bmad-yanstaller.md

@@ -0,0 +1,47 @@
+---
+name: bmad-yanstaller
+description: Yanstaller - Multi-Platform BYAN Installer Agent
+model: sonnet
+color: blue
+---
+
+# bmad-yanstaller
+
+Yanstaller - Multi-Platform BYAN Installer Agent
+
+## Persona
+
+Installation Expert + Platform Detection Specialist + Zero-Config Automation
+  Elite installer agent that automates BYAN deployment across multiple AI platforms. Detects environments, validates dependencies, installs agents, and configures everything with zero user interaction. Applies Ockham's Razor - simplest installation that works.
+  Concise logs, clear progress indicators, actionable error messages. No questions in auto mode. Emojis for visual feedback only (✓, ⚠, ✗).
+  
+  
+    • Zero-Config First: Auto-detect everything possible
+    • Trust But Verify: Validate all detections
+    • Ockham's Razor: Simplest approach that works
+    • Fail-Safe: Continue on optional failures (Turbo Whisper)
+    • User Override: Respect --skip-* and explicit configs
+    • Clean Logs: Progress, not noise
+  
+  
+  
+    #37 Ockham's Razor, #39 Consequences, IA-1 Trust But Verify, IA-23 No Emoji in code/commits, IA-24 Clean Code
+
+## Operating rules
+
+- ALWAYS use gpt-5-mini model (unless --model override)
+- Interview mode → Pure JSON output (parseable)
+- Install mode → Workflow execution with logs
+- Agent only orchestrates, workflows do the work
+- Keep agent lean (under 3 KB)
+
+## Menu commands
+
+- [AUTO] Auto-install (all platforms)
+- [DETECT] Detect platforms only
+- [HELP] Installation help
+- [EXIT] Exit Yanstaller
+
+## Reporting contract
+
+When invoked via the Agent tool, stay in the persona above. Respond with a concise JSON report when the task completes : { status: "ok|partial|failed", summary: "<200 words", files_changed: [paths], next_steps: [] }.

package/install/templates/.claude/hooks/fact-check-absolutes.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook — fact-check absolutes guard.
+ *
+ * Scans Edit/Write tool inputs on markdown/documentation paths for
+ * absolute claims (`always`, `never`, `obviously`, `faster`, `better`,
+ * `toujours`, `jamais`, `forcement`) without an accompanying source
+ * reference.
+ *
+ * When an unsourced absolute is detected on a doc file, the hook exits
+ * with decision=block and a clear reason, forcing the author to cite a
+ * source (matching `_byan/knowledge/sources.md`, `RFC`, `CVE-`, a URL,
+ * or a `[CLAIM L<n>]` prefix) before writing.
+ *
+ * Non-blocking outside of Edit/Write tools or when the target is code
+ * (not documentation).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const ABSOLUTES = [
+  /\btoujours\b/i,
+  /\bjamais\b/i,
+  /\bforc[eé]ment\b/i,
+  /\bobviously\b/i,
+  /\balways\b/i,
+  /\bnever\b/i,
+  /\bclearly\b/i,
+  /\bundoubtedly\b/i,
+  /\bfaster than\b/i,
+  /\bbetter than\b/i,
+  /\bplus rapide que\b/i,
+  /\bmeilleur que\b/i,
+];
+
+const SOURCE_MARKERS = [
+  /\bRFC\s*\d+/i,
+  /\bCVE-\d{4}-\d+/i,
+  /https?:\/\//,
+  /\[CLAIM\s+L[1-5]\]/i,
+  /\[FACT\s+USER-VERIFIED/i,
+  /\bsource\s*:/i,
+  /_byan\/knowledge\/sources\.md/,
+];
+
+const DOC_EXTS = ['.md', '.mdx', '.rst', '.txt'];
+
+// Paths exempted from scanning — these files DESCRIBE the rule or meta-docs
+// where absolutes appear as examples, not as claims.
+const EXEMPT_PATH_PATTERNS = [
+  /\.claude\/hooks\//,
+  /\.claude\/agents\/bmad-compliance\.md$/,
+  /_byan\/mcp\/byan-mcp-server\/lib\/(peer-review|fd-state)\.js$/,
+  /_byan\/mcp\/byan-mcp-server\/test\//,
+  /_byan\/knowledge\/(fact-check|mantras)/i,
+  /\/fact-check-absolutes\.js$/,
+  /\.claude\/skills\/byan-fact-check\//,
+  /install\/__tests__\/.*fact-check/i,
+  /__tests__\/.*fact-check/i,
+];
+
+function isExemptPath(filePath) {
+  if (!filePath) return false;
+  return EXEMPT_PATH_PATTERNS.some((re) => re.test(filePath));
+}
+
+// Strip content that cannot be a claim :
+//   - fenced code blocks ``` ... ```
+//   - inline backticks `...`
+//   - block quotes (lines starting with >)
+//   - regex / array syntax that contains the word as a token
+function stripNonClaimZones(text) {
+  if (!text) return '';
+  return text
+    // Fenced code blocks
+    .replace(/```[\s\S]*?```/g, '')
+    // Inline code
+    .replace(/`[^`\n]+`/g, '')
+    // Markdown block quotes
+    .replace(/^> .*$/gm, '')
+    // Lines that look like list of patterns (e.g. "- toujours")
+    .replace(/^[\s-]*['"]?\b(toujours|jamais|forc[eé]ment|obviously|always|never|clearly|undoubtedly)\b['"]?/gim, '');
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+function isDoc(filePath) {
+  if (!filePath) return false;
+  return DOC_EXTS.some((ext) => filePath.toLowerCase().endsWith(ext));
+}
+
+function extractText(toolName, input) {
+  if (!input) return '';
+  if (toolName === 'Write') return String(input.content || '');
+  if (toolName === 'Edit') {
+    return [input.new_string, input.old_string].filter(Boolean).join('\n');
+  }
+  return '';
+}
+
+function findUnsourced(text) {
+  if (!text) return null;
+  for (const re of ABSOLUTES) {
+    const match = text.match(re);
+    if (!match) continue;
+    const idx = match.index || 0;
+    const windowStart = Math.max(0, idx - 240);
+    const windowEnd = Math.min(text.length, idx + match[0].length + 240);
+    const ctx = text.slice(windowStart, windowEnd);
+    const hasSource = SOURCE_MARKERS.some((sm) => sm.test(ctx));
+    if (!hasSource) {
+      return { absolute: match[0], context: text.slice(Math.max(0, idx - 80), idx + 80) };
+    }
+  }
+  return null;
+}
+
+(async () => {
+  const raw = await readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch {
+    payload = {};
+  }
+
+  const toolName = payload.tool_name || payload.toolName || '';
+  const input = payload.tool_input || payload.toolInput || {};
+  const target = input.file_path || '';
+
+  if (!['Edit', 'Write'].includes(toolName) || !isDoc(target) || isExemptPath(target)) {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'allow',
+        },
+      })
+    );
+    process.exit(0);
+  }
+
+  const rawText = extractText(toolName, input);
+  const text = stripNonClaimZones(rawText);
+  const hit = findUnsourced(text);
+
+  if (!hit) {
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'allow',
+        },
+      })
+    );
+    process.exit(0);
+  }
+
+  const reason = [
+    `BYAN fact-check guard : unsourced absolute "${hit.absolute}" detected in ${path.basename(target)}.`,
+    `Context : ...${hit.context}...`,
+    `Add a source (RFC, CVE, URL, [CLAIM L<n>], or entry in _byan/knowledge/sources.md) before writing this. `,
+    `Alternative : reformulate with hedging ("often", "in my tests", "tends to") to drop the absolute claim.`,
+  ].join('\n');
+
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: reason,
+      },
+    })
+  );
+  process.exit(0);
+})();

package/install/templates/.claude/hooks/fd-phase-guard.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * UserPromptSubmit hook — FD phase guard.
+ *
+ * When an FD cycle is active (fd-state.json exists and phase is not
+ * COMPLETED/ABORTED), inject a strong reminder into additionalContext
+ * describing the current phase and its hard rules. Makes it mechanical
+ * for Claude to stay in the right phase instead of drifting.
+ *
+ * Non-blocking : if fd-state is missing or invalid, emit empty context.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const statePath = path.join(projectDir, '_byan-output', 'fd-state.json');
+
+const PHASE_RULES = {
+  BRAINSTORM: [
+    'Quantity > quality. No idea rejected. Role-play Carson (brainstorming coach).',
+    'Use YES AND to extend every user seed. Apply inversion, analogies.',
+    'DO NOT ask pruning questions. DO NOT apply Ockham yet. Push ideas.',
+    'Prefix every response with [FD:BRAINSTORM].',
+    'Exit only when user says "stop brainstorm" / "ok j\'ai mes idees", or raw_ideas >= 10.',
+  ],
+  PRUNE: [
+    'Challenge Before Confirm (Mantra IA-16). Apply Ockham\'s Razor (#37). YAGNI.',
+    'For each idea : ask "probleme resolu ?" "necessaire MAINTENANT ?" "MVP ?"',
+    'Cluster similar ideas, kill redundant, priority-rank what survives (P1/P2/P3).',
+    'Prefix every response with [FD:PRUNE].',
+    'Exit only when user says "OK backlog" or equivalent explicit validation.',
+  ],
+  DISPATCH: [
+    'Map each feature to {component × specialist × model × strategy × est_tokens}.',
+    'Use byan_dispatch MCP to compute strategy if uncertain. Surface missing specialist.',
+    'Prefix every response with [FD:DISPATCH].',
+    'Exit only when user validates the dispatch table explicitly.',
+  ],
+  BUILD: [
+    'Delegate to byan-hermes-dispatch. One commit per feature. TDD : tests before code.',
+    'Atomic commits : `type: description`, no emoji, zero cross-feature noise.',
+    'Prefix every response with [FD:BUILD].',
+    'Exit only when all backlog items show status=done AND user validates the diffs.',
+  ],
+  VALIDATE: [
+    'Run npm test. Zero regression on previously-passing tests.',
+    'MantraValidator >= 80% on changed agent/skill files. Fact-check any absolute claim.',
+    'Prefix every response with [FD:VALIDATE].',
+    'Exit only when tests green + user says "ok validate" OR retry cycle on BUILD.',
+  ],
+};
+
+function readState() {
+  try {
+    if (!fs.existsSync(statePath)) return null;
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+const state = readState();
+let additionalContext = '';
+
+if (state && !['COMPLETED', 'ABORTED'].includes(state.phase)) {
+  const rules = PHASE_RULES[state.phase] || ['(unknown phase — fall back to conservative behavior)'];
+  const header = `FD active — phase ${state.phase} — feature ${state.feature_name || '?'} (id ${state.fd_id || '?'})`;
+  const body = rules.map((r) => `  - ${r}`).join('\n');
+  additionalContext = [
+    header,
+    '',
+    'Hard rules for this turn :',
+    body,
+    '',
+    `Use byan_fd_status MCP to read full state if needed. Do not hand-edit fd-state.json.`,
+  ].join('\n');
+}
+
+process.stdout.write(
+  JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: additionalContext,
+    },
+  })
+);

package/install/templates/.claude/hooks/fd-response-check.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Stop hook — FD response check.
+ *
+ * When an FD cycle is active, verify my most recent assistant response
+ * starts with a `[FD:<PHASE>]` header matching the current phase. If
+ * missing, return decision=block with a reason, forcing me to
+ * reformulate with the correct phase marker.
+ *
+ * When no FD is active, do nothing.
+ *
+ * Non-blocking on any IO/parse error — the hook never prevents Stop
+ * when it can't tell.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const statePath = path.join(projectDir, '_byan-output', 'fd-state.json');
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+function readState() {
+  try {
+    if (!fs.existsSync(statePath)) return null;
+    return JSON.parse(fs.readFileSync(statePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function extractLastAssistantText(payload) {
+  if (!payload || typeof payload !== 'object') return '';
+  const tx = payload.transcript || payload.messages || [];
+  if (!Array.isArray(tx)) return '';
+  for (let i = tx.length - 1; i >= 0; i--) {
+    const m = tx[i];
+    if (m && m.role === 'assistant') {
+      if (typeof m.content === 'string') return m.content;
+      if (Array.isArray(m.content)) {
+        return m.content
+          .map((c) => (typeof c === 'object' && c.text ? c.text : ''))
+          .join(' ');
+      }
+    }
+  }
+  return '';
+}
+
+(async () => {
+  const state = readState();
+  if (!state || ['COMPLETED', 'ABORTED'].includes(state.phase)) {
+    process.stdout.write(JSON.stringify({ continue: true }));
+    process.exit(0);
+  }
+
+  const raw = await readStdin();
+  let payload = {};
+  try {
+    payload = raw ? JSON.parse(raw) : {};
+  } catch {
+    payload = {};
+  }
+
+  const text = extractLastAssistantText(payload);
+  const expected = `[FD:${state.phase}]`;
+
+  if (!text || text.includes(expected)) {
+    process.stdout.write(JSON.stringify({ continue: true }));
+    process.exit(0);
+  }
+
+  const reason = `FD active (phase=${state.phase}) but your last response did not include the required header "${expected}". Reformulate your answer starting with ${expected} to confirm you are operating in the correct phase. If you wanted to exit or change phase, call byan_fd_advance first.`;
+
+  process.stdout.write(
+    JSON.stringify({
+      decision: 'block',
+      reason,
+      systemMessage: reason,
+    })
+  );
+  process.exit(2);
+})();

package/install/templates/.claude/hooks/lib/failure-detector.js

@@ -10,10 +10,19 @@ const ERROR_PATTERNS = [
   /tool_use_error/i,
 ];
 
+// Tools whose response echoes user-authored or file content (Write/Edit
+// return file paths + content fragments, Read echoes file content
+// verbatim). Pattern match on their response fires false positives when
+// the file content itself contains the literal phrase "internal error"
+// (e.g. a doc about errors, a test fixture, a hook that detects errors).
+// For these, only trust the explicit is_error flag.
+const ECHO_TOOLS = new Set(['Write', 'Edit', 'NotebookEdit', 'Read']);
+
 function detectFailure(payload) {
   if (!payload || typeof payload !== 'object') return null;
 
   const resp = payload.tool_response ?? payload.toolResponse ?? payload.response;
+  const toolName = payload.tool_name || payload.toolName || '';
 
   if (resp && typeof resp === 'object') {
     if (resp.is_error === true || resp.isError === true) {
@@ -21,6 +30,11 @@ function detectFailure(payload) {
     }
   }
 
+  // Do not pattern-match on echo-heavy tools — only trust is_error flag.
+  if (ECHO_TOOLS.has(toolName)) {
+    return null;
+  }
+
   const combined = [
     JSON.stringify(resp ?? ''),
     JSON.stringify(payload.error ?? ''),

package/install/templates/.claude/hooks/pre-compact-save.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+/**
+ * PreCompact hook — snapshot critical BYAN state before Claude Code
+ * compacts the context window.
+ *
+ * Writes _byan-output/compact-snapshots/<timestamp>.md with :
+ *   - active FD state (phase, backlog, dispatch table)
+ *   - last 50 tool-log.jsonl entries (activity trail)
+ *   - soul-memory.md head (who BYAN is, red lines)
+ *   - recent commits (git log -10)
+ *
+ * Emits a short systemMessage telling Claude : compact happened, key
+ * state preserved at <path>, read it if you lose track mid-session.
+ *
+ * Never blocks compaction. Exit 0 always, even on partial failure.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const outDir = path.join(projectDir, '_byan-output', 'compact-snapshots');
+
+function readTextSafe(filePath, maxBytes = 4000) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return raw.length > maxBytes ? raw.slice(0, maxBytes) + '\n\n... [truncated]' : raw;
+  } catch {
+    return null;
+  }
+}
+
+function readJsonSafe(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function tailJsonl(filePath, n) {
+  try {
+    if (!fs.existsSync(filePath)) return [];
+    const lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+    return lines.slice(-n).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function recentCommits() {
+  try {
+    return execSync('git log -10 --oneline', {
+      cwd: projectDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return '(git log unavailable)';
+  }
+}
+
+function stamp() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}${pad(d.getSeconds())}`;
+}
+
+function renderSnapshot() {
+  const lines = [];
+  lines.push(`# BYAN pre-compact snapshot — ${new Date().toISOString()}`);
+  lines.push('');
+
+  const fd = readJsonSafe(path.join(projectDir, '_byan-output', 'fd-state.json'));
+  if (fd) {
+    lines.push('## Active FD state');
+    lines.push('');
+    lines.push('```json');
+    lines.push(JSON.stringify(fd, null, 2).slice(0, 3000));
+    lines.push('```');
+    lines.push('');
+  } else {
+    lines.push('## Active FD state');
+    lines.push('');
+    lines.push('(none)');
+    lines.push('');
+  }
+
+  lines.push('## Recent commits');
+  lines.push('');
+  lines.push('```');
+  lines.push(recentCommits());
+  lines.push('```');
+  lines.push('');
+
+  const tool = tailJsonl(path.join(projectDir, '_byan-output', 'tool-log.jsonl'), 50);
+  lines.push(`## Last ${tool.length} tool calls`);
+  lines.push('');
+  for (const e of tool) {
+    const ts = e.timestamp || '?';
+    const phase = e.phase || '?';
+    const summary = e.summary || (e.ok === false ? `FAIL ${e.failure_kind}` : 'ok');
+    lines.push(`- ${ts} ${phase} ${e.tool || '?'} — ${String(summary).slice(0, 120)}`);
+  }
+  lines.push('');
+
+  const soul = readTextSafe(path.join(projectDir, '_byan', 'soul.md'), 2000);
+  if (soul) {
+    lines.push('## Soul (head)');
+    lines.push('');
+    lines.push(soul);
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+(function main() {
+  try {
+    fs.mkdirSync(outDir, { recursive: true });
+    const outPath = path.join(outDir, `${stamp()}.md`);
+    fs.writeFileSync(outPath, renderSnapshot());
+
+    const relative = path.relative(projectDir, outPath);
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: `BYAN pre-compact snapshot written to ${relative}. Critical state (FD phase, commits, tool activity, soul) preserved outside the context window. Read it after compaction if you lose track.`,
+      })
+    );
+  } catch (err) {
+    // Must never block compaction
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: `pre-compact-save hook error (non-blocking) : ${err.message}`,
+      })
+    );
+  }
+  process.exit(0);
+})();

package/install/templates/.claude/hooks/tool-failure-guard.js

@@ -55,12 +55,18 @@ function readStdin() {
   const toolName = payload.tool_name || payload.toolName || 'unknown';
   const hit = detectFailure(payload);
 
+  const respStr = JSON.stringify(
+    payload.tool_response ?? payload.toolResponse ?? payload.response ?? {}
+  );
+  const estOutputTokens = Math.ceil(respStr.length / 4);
+
   appendToolLog({
     timestamp: new Date().toISOString(),
     phase: 'post',
     tool: toolName,
     ok: !hit,
     failure_kind: hit ? hit.kind : null,
+    est_output_tokens: estOutputTokens,
   });
 
   if (!hit) {

package/install/templates/.claude/hooks/tool-transparency.js

@@ -69,11 +69,15 @@ function appendLog(entry) {
   const input = payload.tool_input || payload.toolInput || {};
   const summary = summarizeInput(toolName, input);
 
+  const inputStr = JSON.stringify(input || {});
+  const estInputTokens = Math.ceil(inputStr.length / 4);
+
   appendLog({
     timestamp: new Date().toISOString(),
     phase: 'pre',
     tool: toolName,
     summary,
+    est_input_tokens: estInputTokens,
   });
 
   const systemMessage = summary ? `${toolName}: ${summary}` : `${toolName}`;

package/install/templates/.claude/settings.json

@@ -26,6 +26,10 @@
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/soul-memory-triggers.js"
+          },
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fd-phase-guard.js"
           }
         ]
       }
@@ -37,6 +41,10 @@
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/mantra-validate.js"
+          },
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fd-response-check.js"
           }
         ]
       }
@@ -48,6 +56,10 @@
           {
             "type": "command",
             "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/tool-transparency.js"
+          },
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/fact-check-absolutes.js"
           }
         ]
       }
@@ -62,6 +74,17 @@
           }
         ]
       }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR\"/.claude/hooks/pre-compact-save.js"
+          }
+        ]
+      }
     ]
   }
 }