deepflow 0.1.105 → 0.1.106

package/hooks/df-invariant-check.test.js

@@ -15,7 +15,7 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { isBinaryAvailable } = require('./df-invariant-check');
+const { isBinaryAvailable, checkConfigYamlGuard } = require('./df-invariant-check');
 
 const HOOK_SOURCE = fs.readFileSync(
   path.resolve(__dirname, 'df-invariant-check.js'),
@@ -139,3 +139,177 @@ describe('extractDiffFromLastCommit implementation', () => {
     );
   });
 });
+
+// ---------------------------------------------------------------------------
+// 4. checkConfigYamlGuard — config.yaml/yml modification detection
+// ---------------------------------------------------------------------------
+
+describe('checkConfigYamlGuard', () => {
+  // Helper: build a minimal parsed-file object matching the shape used by check functions
+  function makeFiles(...paths) {
+    return paths.map((p) => ({ file: p, chunks: [] }));
+  }
+
+  test('detects .deepflow/config.yaml modification as HARD violation', () => {
+    const files = makeFiles('.deepflow/config.yaml');
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 1);
+    assert.equal(violations[0].tag, 'CONFIG_GUARD');
+    assert.equal(violations[0].file, '.deepflow/config.yaml');
+    assert.equal(violations[0].line, 1);
+    assert.ok(violations[0].description.includes('[CONFIG_GUARD]'));
+  });
+
+  test('detects .deepflow/config.yml variant as HARD violation', () => {
+    const files = makeFiles('.deepflow/config.yml');
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 1);
+    assert.equal(violations[0].tag, 'CONFIG_GUARD');
+    assert.equal(violations[0].file, '.deepflow/config.yml');
+  });
+
+  test('detects config.yaml inside a worktree sub-path', () => {
+    const worktreePath = '.claude/worktrees/agent-abc123/.deepflow/config.yaml';
+    const files = makeFiles(worktreePath);
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 1);
+    assert.equal(violations[0].tag, 'CONFIG_GUARD');
+    assert.equal(violations[0].file, worktreePath);
+  });
+
+  test('detects config.yml inside a deeply nested worktree path', () => {
+    const deepPath = 'some/deep/path/.deepflow/config.yml';
+    const files = makeFiles(deepPath);
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 1);
+    assert.equal(violations[0].tag, 'CONFIG_GUARD');
+  });
+
+  test('returns no violations for non-config files', () => {
+    const files = makeFiles(
+      'src/index.js',
+      'hooks/df-invariant-check.js',
+      'package.json',
+      '.deepflow/decisions.md'
+    );
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 0);
+  });
+
+  test('ignores files that partially match but are not config.yaml/yml', () => {
+    const files = makeFiles(
+      '.deepflow/config.yaml.bak',
+      '.deepflow/config.yamls',
+      '.deepflow/my-config.yaml',
+      'config.yaml'  // not under .deepflow/
+    );
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 0);
+  });
+
+  test('returns one violation per matching file when multiple configs present', () => {
+    const files = makeFiles(
+      '.deepflow/config.yaml',
+      '.claude/worktrees/agent-xyz/.deepflow/config.yml'
+    );
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.equal(violations.length, 2);
+    assert.equal(violations[0].tag, 'CONFIG_GUARD');
+    assert.equal(violations[1].tag, 'CONFIG_GUARD');
+  });
+
+  test('returns empty array when files list is empty', () => {
+    const violations = checkConfigYamlGuard([], '', 'implementation');
+    assert.equal(violations.length, 0);
+  });
+
+  test('works regardless of specContent and taskType arguments', () => {
+    const files = makeFiles('.deepflow/config.yaml');
+
+    // Different specContent and taskType should not affect the result
+    const v1 = checkConfigYamlGuard(files, 'some spec content', 'spike');
+    const v2 = checkConfigYamlGuard(files, '', 'bootstrap');
+
+    assert.equal(v1.length, 1);
+    assert.equal(v2.length, 1);
+  });
+
+  test('violation description mentions the offending file path', () => {
+    const targetPath = '.claude/worktrees/agent-foo/.deepflow/config.yaml';
+    const files = makeFiles(targetPath);
+    const violations = checkConfigYamlGuard(files, '', 'implementation');
+
+    assert.ok(
+      violations[0].description.includes(targetPath),
+      'description should include the exact file path'
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// 5. T3 — stdin hang fix: readStdinIfMain guard and no raw stdin listeners
+// ---------------------------------------------------------------------------
+
+describe('stdin hang fix (T3)', () => {
+  test('source does not contain process.stdin.on calls', () => {
+    // The old code used process.stdin.on('data') directly, which caused hangs
+    // when the file was required by tests. readStdinIfMain replaces this.
+    const lines = HOOK_SOURCE.split('\n');
+    const offendingLines = lines.filter((line) => {
+      if (line.trimStart().startsWith('//') || line.trimStart().startsWith('*')) return false;
+      return /process\.stdin\.on\b/.test(line);
+    });
+    assert.equal(
+      offendingLines.length,
+      0,
+      `Found process.stdin.on in source: ${offendingLines.map((l) => l.trim()).join('; ')}`
+    );
+  });
+
+  test('source calls readStdinIfMain', () => {
+    // readStdinIfMain(module, callback) should be the entry point for stdin reading
+    assert.ok(
+      /readStdinIfMain\s*\(\s*module\b/.test(HOOK_SOURCE),
+      'source should call readStdinIfMain(module, ...) to guard stdin reading'
+    );
+  });
+
+  test('source imports readStdinIfMain from hook-stdin', () => {
+    assert.ok(
+      /require\(['"]\.\/lib\/hook-stdin['"]\)/.test(HOOK_SOURCE),
+      'source should require ./lib/hook-stdin'
+    );
+    assert.ok(
+      /readStdinIfMain/.test(HOOK_SOURCE),
+      'readStdinIfMain should be destructured from the import'
+    );
+  });
+
+  test('--invariants CLI entry point is preserved', () => {
+    // The CLI path must still exist: require.main === module && --invariants
+    assert.ok(
+      /require\.main\s*===\s*module/.test(HOOK_SOURCE),
+      'source should have require.main === module guard for CLI mode'
+    );
+    assert.ok(
+      /--invariants/.test(HOOK_SOURCE),
+      'source should reference --invariants flag'
+    );
+  });
+
+  test('requiring the module does not hang (exits immediately)', () => {
+    // AC-5: node -e "require('./hooks/df-invariant-check.js')" should exit fast.
+    // We already required it at the top of this file without hanging,
+    // so reaching this test at all proves require() does not block.
+    // Additionally, verify the exported API is still accessible.
+    assert.equal(typeof isBinaryAvailable, 'function');
+    assert.equal(typeof checkConfigYamlGuard, 'function');
+  });
+});

package/hooks/df-snapshot-guard.js

@@ -19,6 +19,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 function loadSnapshotPaths(cwd) {
   try {
@@ -55,52 +56,43 @@ function isSnapshotFile(filePath, snapshotPaths, cwd) {
   return false;
 }
 
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(raw);
-    const toolName = data.tool_name || '';
-
-    // Only guard Write and Edit
-    if (toolName !== 'Write' && toolName !== 'Edit') {
-      process.exit(0);
-    }
+readStdinIfMain(module, (data) => {
+  const toolName = data.tool_name || '';
 
-    const filePath = (data.tool_input && data.tool_input.file_path) || '';
-    const cwd = data.cwd || process.cwd();
+  // Only guard Write and Edit
+  if (toolName !== 'Write' && toolName !== 'Edit') {
+    return;
+  }
 
-    if (!filePath) {
-      process.exit(0);
-    }
+  const filePath = (data.tool_input && data.tool_input.file_path) || '';
+  const cwd = data.cwd || process.cwd();
 
-    const snapshotPaths = loadSnapshotPaths(cwd);
+  if (!filePath) {
+    return;
+  }
 
-    // No snapshot file present — not a deepflow project or ratchet not initialized
-    if (snapshotPaths === null) {
-      process.exit(0);
-    }
+  const snapshotPaths = loadSnapshotPaths(cwd);
 
-    // Empty snapshot — nothing to protect
-    if (snapshotPaths.length === 0) {
-      process.exit(0);
-    }
+  // No snapshot file present — not a deepflow project or ratchet not initialized
+  if (snapshotPaths === null) {
+    return;
+  }
 
-    if (!isSnapshotFile(filePath, snapshotPaths, cwd)) {
-      process.exit(0);
-    }
+  // Empty snapshot — nothing to protect
+  if (snapshotPaths.length === 0) {
+    return;
+  }
 
-    // File is in the snapshot — block the write
-    console.error(
-      `[df-snapshot-guard] Blocked ${toolName} to "${filePath}" — this file is listed in ` +
-      `.deepflow/auto-snapshot.txt (ratchet baseline). ` +
-      `Pre-existing test files must not be modified by agents. ` +
-      `If you need to update this file, do so manually outside the autonomous loop.`
-    );
-    process.exit(1);
-  } catch (_e) {
-    // Parse or unexpected error — fail open so we never break non-deepflow projects
-    process.exit(0);
+  if (!isSnapshotFile(filePath, snapshotPaths, cwd)) {
+    return;
   }
+
+  // File is in the snapshot — block the write
+  console.error(
+    `[df-snapshot-guard] Blocked ${toolName} to "${filePath}" — this file is listed in ` +
+    `.deepflow/auto-snapshot.txt (ratchet baseline). ` +
+    `Pre-existing test files must not be modified by agents. ` +
+    `If you need to update this file, do so manually outside the autonomous loop.`
+  );
+  process.exit(1);
 });

package/hooks/df-statusline.js

@@ -8,6 +8,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 // ANSI colors
 const colors = {
@@ -21,18 +22,8 @@ const colors = {
   cyan: '\x1b[36m'
 };
 
-// Read JSON from stdin
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-    console.log(buildStatusLine(data));
-  } catch (e) {
-    // Fail silently to avoid breaking statusline
-    console.log('');
-  }
+readStdinIfMain(module, (data) => {
+  console.log(buildStatusLine(data));
 });
 
 function buildStatusLine(data) {

package/hooks/df-stdin-migration.test.js

@@ -0,0 +1,106 @@
+/**
+ * Tests for stdin migration (test-hang-fix T2)
+ *
+ * Verifies that all 9 migrated hooks use readStdinIfMain instead of inline
+ * process.stdin.on listeners. The core behavioral guarantee: require()'ing
+ * any hook no longer hangs the process waiting for stdin.
+ *
+ * Detailed behavioral tests for individual hooks live in their own test files.
+ */
+
+'use strict';
+
+const { test, describe, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+// Prevent the test runner from hanging on stdin after all tests complete.
+// The execFileSync calls inherit pipe handles that can keep the event loop alive.
+after(() => { process.stdin.destroy(); });
+
+const HOOKS_DIR = path.resolve(__dirname);
+
+/** All hooks that were migrated to readStdinIfMain */
+const MIGRATED_HOOKS = [
+  'df-command-usage.js',
+  'df-execution-history.js',
+  'df-explore-protocol.js',
+  'df-snapshot-guard.js',
+  'df-statusline.js',
+  'df-subagent-registry.js',
+  'df-tool-usage.js',
+  'df-tool-usage-spike.js',
+  'df-worktree-guard.js',
+];
+
+describe('stdin migration — no-hang on require()', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`require("${hookFile}") completes without hanging`, () => {
+      // Spawn a child that require()s the hook and exits.
+      // If stdin listeners are still inline, this will hang until timeout.
+      const script = `require(${JSON.stringify(hookPath)}); process.exit(0);`;
+      execFileSync(
+        process.execPath,
+        ['-e', script],
+        {
+          encoding: 'utf8',
+          timeout: 3000,  // 3s is generous — require should be <100ms
+        }
+      );
+      // If we reach here, require() didn't hang — that's the assertion.
+      assert.ok(true, `${hookFile} require() completed without timeout`);
+    });
+  }
+});
+
+describe('stdin migration — no inline process.stdin.on', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`${hookFile} has no direct process.stdin.on calls`, () => {
+      const content = fs.readFileSync(hookPath, 'utf8');
+      const matches = content.match(/process\.stdin\.on\s*\(/g);
+      assert.equal(
+        matches,
+        null,
+        `${hookFile} still contains process.stdin.on — migration incomplete`
+      );
+    });
+  }
+});
+
+describe('stdin migration — uses readStdinIfMain', () => {
+  for (const hookFile of MIGRATED_HOOKS) {
+    const hookPath = path.join(HOOKS_DIR, hookFile);
+
+    test(`${hookFile} imports readStdinIfMain`, () => {
+      const content = fs.readFileSync(hookPath, 'utf8');
+      assert.match(
+        content,
+        /readStdinIfMain/,
+        `${hookFile} does not reference readStdinIfMain`
+      );
+    });
+  }
+});
+
+describe('stdin migration — hook-stdin.js helper', () => {
+  test('hook-stdin.js exports readStdinIfMain function', () => {
+    const lib = require(path.join(HOOKS_DIR, 'lib', 'hook-stdin.js'));
+    assert.equal(typeof lib.readStdinIfMain, 'function');
+  });
+
+  test('readStdinIfMain is a no-op when caller is not main module', () => {
+    const lib = require(path.join(HOOKS_DIR, 'lib', 'hook-stdin.js'));
+    // When we require() hook-stdin from a test, module !== require.main
+    // so calling readStdinIfMain with our own module should be a no-op.
+    let callbackInvoked = false;
+    lib.readStdinIfMain(module, () => { callbackInvoked = true; });
+    // Give a tick for any async listener to fire (there shouldn't be one).
+    assert.equal(callbackInvoked, false, 'callback should not be invoked when not main module');
+  });
+});

package/hooks/df-subagent-registry.js

@@ -4,59 +4,53 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
-let raw = '';
-process.stdin.on('data', d => raw += d);
-process.stdin.on('end', () => {
-  try {
-    const event = JSON.parse(raw);
-    const { session_id, agent_type, agent_id, agent_transcript_path } = event;
+readStdinIfMain(module, (event) => {
+  const { session_id, agent_type, agent_id, agent_transcript_path } = event;
 
-    // Parse subagent transcript to extract real model and token usage
-    let model = 'unknown';
-    let tokens_in = 0, tokens_out = 0, cache_read = 0, cache_creation = 0;
+  // Parse subagent transcript to extract real model and token usage
+  let model = 'unknown';
+  let tokens_in = 0, tokens_out = 0, cache_read = 0, cache_creation = 0;
 
-    if (agent_transcript_path && fs.existsSync(agent_transcript_path)) {
-      const lines = fs.readFileSync(agent_transcript_path, 'utf-8').split('\n');
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        try {
-          const evt = JSON.parse(trimmed);
-          const msg = evt.message || {};
-          const usage = msg.usage || evt.usage;
-          // Extract model from assistant messages
-          const m = msg.model || evt.model;
-          if (m && m !== 'unknown') model = m;
-          // Accumulate tokens
-          if (usage) {
-            tokens_in += usage.input_tokens || 0;
-            tokens_out += usage.output_tokens || 0;
-            cache_read += usage.cache_read_input_tokens || usage.cache_read_tokens || 0;
-            cache_creation += usage.cache_creation_input_tokens || usage.cache_creation_tokens || 0;
-          }
-        } catch { /* skip malformed lines */ }
-      }
+  if (agent_transcript_path && fs.existsSync(agent_transcript_path)) {
+    const lines = fs.readFileSync(agent_transcript_path, 'utf-8').split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const evt = JSON.parse(trimmed);
+        const msg = evt.message || {};
+        const usage = msg.usage || evt.usage;
+        // Extract model from assistant messages
+        const m = msg.model || evt.model;
+        if (m && m !== 'unknown') model = m;
+        // Accumulate tokens
+        if (usage) {
+          tokens_in += usage.input_tokens || 0;
+          tokens_out += usage.output_tokens || 0;
+          cache_read += usage.cache_read_input_tokens || usage.cache_read_tokens || 0;
+          cache_creation += usage.cache_creation_input_tokens || usage.cache_creation_tokens || 0;
+        }
+      } catch { /* skip malformed lines */ }
     }
+  }
 
-    // Strip version suffix from model (e.g. claude-haiku-4-5-20251001 → claude-haiku-4-5)
-    model = model.replace(/-\d{8}$/, '').replace(/\[\d+[km]\]$/i, '');
+  // Strip version suffix from model (e.g. claude-haiku-4-5-20251001 → claude-haiku-4-5)
+  model = model.replace(/-\d{8}$/, '').replace(/\[\d+[km]\]$/i, '');
 
-    const entry = {
-      session_id,
-      agent_type,
-      agent_id,
-      model,
-      tokens_in,
-      tokens_out,
-      cache_read,
-      cache_creation,
-      timestamp: new Date().toISOString()
-    };
+  const entry = {
+    session_id,
+    agent_type,
+    agent_id,
+    model,
+    tokens_in,
+    tokens_out,
+    cache_read,
+    cache_creation,
+    timestamp: new Date().toISOString()
+  };
 
-    const registryPath = path.join(os.homedir(), '.claude', 'subagent-sessions.jsonl');
-    fs.appendFileSync(registryPath, JSON.stringify(entry) + '\n');
-  } catch {
-    process.exit(0);
-  }
+  const registryPath = path.join(os.homedir(), '.claude', 'subagent-sessions.jsonl');
+  fs.appendFileSync(registryPath, JSON.stringify(entry) + '\n');
 });

package/hooks/df-tool-usage-spike.js

@@ -11,31 +11,20 @@
 'use strict';
 
 const fs = require('fs');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    // Write raw payload for inspection
-    fs.writeFileSync('/tmp/df-posttooluse-payload.json', raw);
-
-    // Also append a minimal summary line for quick review
-    const data = JSON.parse(raw);
-    const summary = {
-      hook_event_name: data.hook_event_name,
-      tool_name: data.tool_name,
-      tool_use_id: data.tool_use_id,
-      session_id: data.session_id,
-      cwd: data.cwd,
-      permission_mode: data.permission_mode,
-      tool_input_keys: data.tool_input ? Object.keys(data.tool_input) : [],
-      tool_response_keys: data.tool_response ? Object.keys(data.tool_response) : [],
-      transcript_path: data.transcript_path,
-    };
-    fs.appendFileSync('/tmp/df-posttooluse-summary.jsonl', JSON.stringify(summary) + '\n');
-  } catch (_e) {
-    // Fail silently — never break tool execution
-  }
-  process.exit(0);
+readStdinIfMain(module, (data) => {
+  // Also append a minimal summary line for quick review
+  const summary = {
+    hook_event_name: data.hook_event_name,
+    tool_name: data.tool_name,
+    tool_use_id: data.tool_use_id,
+    session_id: data.session_id,
+    cwd: data.cwd,
+    permission_mode: data.permission_mode,
+    tool_input_keys: data.tool_input ? Object.keys(data.tool_input) : [],
+    tool_response_keys: data.tool_response ? Object.keys(data.tool_response) : [],
+    transcript_path: data.transcript_path,
+  };
+  fs.appendFileSync('/tmp/df-posttooluse-summary.jsonl', JSON.stringify(summary) + '\n');
 });

package/hooks/df-tool-usage.js

@@ -15,6 +15,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 const TOOL_USAGE_LOG = path.join(os.homedir(), '.claude', 'tool-usage.jsonl');
 
@@ -49,56 +50,45 @@ function extractTaskId(cwd) {
   return taskMatch ? taskMatch[1].toUpperCase() : null;
 }
 
-// Read all stdin, then process
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => { raw += chunk; });
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(raw);
-
-    const toolName = data.tool_name || null;
-    const toolResponse = data.tool_response;
-    const cwd = data.cwd || '';
-
-    let activeCommand = null;
-    try {
-      const markerPath = path.join(cwd || process.cwd(), '.deepflow', 'active-command.json');
-      const markerRaw = fs.readFileSync(markerPath, 'utf8');
-      activeCommand = JSON.parse(markerRaw).command || null;
-    } catch (_e) { /* no marker or unreadable — null */ }
+readStdinIfMain(module, (data) => {
+  const toolName = data.tool_name || null;
+  const toolResponse = data.tool_response;
+  const cwd = data.cwd || '';
 
-    // Extract a compact tool_input summary per tool type
-    const ti = data.tool_input || {};
-    let inputSummary = null;
-    if (toolName === 'Bash') inputSummary = ti.command || null;
-    else if (toolName === 'LSP') inputSummary = `${ti.operation || '?'}:${(ti.filePath || '').split('/').pop()}:${ti.line || '?'}`;
-    else if (toolName === 'Read') inputSummary = (ti.file_path || '').split('/').pop() + (ti.offset ? `:${ti.offset}-${ti.offset + (ti.limit || 0)}` : '');
-    else if (toolName === 'Grep') inputSummary = ti.pattern || null;
-    else if (toolName === 'Glob') inputSummary = ti.pattern || null;
-    else if (toolName === 'Agent') inputSummary = `${ti.subagent_type || '?'}/${ti.model || '?'}`;
-    else if (toolName === 'Edit' || toolName === 'Write') inputSummary = (ti.file_path || '').split('/').pop();
+  let activeCommand = null;
+  try {
+    const markerPath = path.join(cwd || process.cwd(), '.deepflow', 'active-command.json');
+    const markerRaw = fs.readFileSync(markerPath, 'utf8');
+    activeCommand = JSON.parse(markerRaw).command || null;
+  } catch (_e) { /* no marker or unreadable — null */ }
 
-    const record = {
-      timestamp: new Date().toISOString(),
-      session_id: data.session_id || null,
-      tool_name: toolName,
-      input: inputSummary,
-      output_size_est_tokens: Math.ceil(JSON.stringify(toolResponse).length / 4),
-      project: cwd ? path.basename(cwd) : null,
-      phase: inferPhase(cwd),
-      task_id: extractTaskId(cwd),
-      active_command: activeCommand,
-    };
+  // Extract a compact tool_input summary per tool type
+  const ti = data.tool_input || {};
+  let inputSummary = null;
+  if (toolName === 'Bash') inputSummary = ti.command || null;
+  else if (toolName === 'LSP') inputSummary = `${ti.operation || '?'}:${(ti.filePath || '').split('/').pop()}:${ti.line || '?'}`;
+  else if (toolName === 'Read') inputSummary = (ti.file_path || '').split('/').pop() + (ti.offset ? `:${ti.offset}-${ti.offset + (ti.limit || 0)}` : '');
+  else if (toolName === 'Grep') inputSummary = ti.pattern || null;
+  else if (toolName === 'Glob') inputSummary = ti.pattern || null;
+  else if (toolName === 'Agent') inputSummary = `${ti.subagent_type || '?'}/${ti.model || '?'}`;
+  else if (toolName === 'Edit' || toolName === 'Write') inputSummary = (ti.file_path || '').split('/').pop();
 
-    const logDir = path.dirname(TOOL_USAGE_LOG);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
+  const record = {
+    timestamp: new Date().toISOString(),
+    session_id: data.session_id || null,
+    tool_name: toolName,
+    input: inputSummary,
+    output_size_est_tokens: Math.ceil(JSON.stringify(toolResponse).length / 4),
+    project: cwd ? path.basename(cwd) : null,
+    phase: inferPhase(cwd),
+    task_id: extractTaskId(cwd),
+    active_command: activeCommand,
+  };
 
-    fs.appendFileSync(TOOL_USAGE_LOG, JSON.stringify(record) + '\n');
-  } catch (_e) {
-    // Fail silently — never break tool execution
+  const logDir = path.dirname(TOOL_USAGE_LOG);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
   }
-  process.exit(0);
+
+  fs.appendFileSync(TOOL_USAGE_LOG, JSON.stringify(record) + '\n');
 });