deepflow 0.1.105 → 0.1.107

package/bin/install.js

@@ -156,14 +156,21 @@ async function main() {
   if (level === 'global') {
     const hooksDir = path.join(PACKAGE_DIR, 'hooks');
     if (fs.existsSync(hooksDir)) {
-      for (const file of fs.readdirSync(hooksDir)) {
-        if (file.endsWith('.js')) {
-          fs.copyFileSync(
-            path.join(hooksDir, file),
-            path.join(CLAUDE_DIR, 'hooks', file)
-          );
+      const copyDirRecursive = (srcDir, destDir) => {
+        for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+          if (entry.isDirectory()) {
+            const subDest = path.join(destDir, entry.name);
+            fs.mkdirSync(subDest, { recursive: true });
+            copyDirRecursive(path.join(srcDir, entry.name), subDest);
+          } else if (entry.name.endsWith('.js')) {
+            fs.copyFileSync(
+              path.join(srcDir, entry.name),
+              path.join(destDir, entry.name)
+            );
+          }
         }
-      }
+      };
+      copyDirRecursive(hooksDir, path.join(CLAUDE_DIR, 'hooks'));
       log('Hooks installed');
     }
   }
@@ -620,6 +627,8 @@ async function uninstall() {
         }
       }
     }
+    // Remove hooks/lib (shared hook utilities)
+    toRemove.push('hooks/lib');
   }
 
   for (const item of toRemove) {
@@ -707,7 +716,13 @@ async function uninstall() {
   console.log('');
 }
 
-main().catch(err => {
-  console.error('Installation failed:', err.message);
-  process.exit(1);
-});
+// Export for testing
+module.exports = { scanHookEvents, removeDeepflowHooks };
+
+// Only run main when executed directly (not when required by tests)
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Installation failed:', err.message);
+    process.exit(1);
+  });
+}

package/bin/install.test.js

@@ -590,217 +590,143 @@ describe('Uninstaller — file removal and settings cleanup', () => {
 });
 
 // ---------------------------------------------------------------------------
-// T4. command-usage hook registration (PreToolUse, PostToolUse, SessionEnd)
+// T4. command-usage hook registration via dynamic @hook-event tags
 // ---------------------------------------------------------------------------
 
 describe('T4 — command-usage hook registration in install.js', () => {
 
-  // -- Source-level checks: verify install.js registers df-command-usage.js --
+  // -- @hook-event tag: verify df-command-usage.js declares correct events --
 
-  test('source defines commandUsageCmd variable', () => {
-    const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    const pattern = /commandUsageCmd\s*=\s*`node.*df-command-usage\.js/;
-    assert.ok(
-      pattern.test(src),
-      'install.js should define commandUsageCmd pointing to df-command-usage.js'
-    );
+  test('df-command-usage.js has @hook-event tag for PreToolUse, PostToolUse, SessionEnd', () => {
+    const hookPath = path.resolve(__dirname, '..', 'hooks', 'df-command-usage.js');
+    const content = fs.readFileSync(hookPath, 'utf8');
+    const firstLines = content.split('\n').slice(0, 10).join('\n');
+    const match = firstLines.match(/\/\/\s*@hook-event:\s*(.+)/);
+    assert.ok(match, 'df-command-usage.js should have @hook-event tag in first 10 lines');
+    const events = match[1].split(',').map(e => e.trim());
+    assert.ok(events.includes('PreToolUse'), 'Should declare PreToolUse event');
+    assert.ok(events.includes('PostToolUse'), 'Should declare PostToolUse event');
+    assert.ok(events.includes('SessionEnd'), 'Should declare SessionEnd event');
   });
 
-  test('source pushes command-usage hook to PreToolUse', () => {
-    const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    // Find PreToolUse section — should contain a push with commandUsageCmd
-    const preToolUseSection = src.match(/PreToolUse[\s\S]*?log\('PreToolUse hook configured'\)/);
-    assert.ok(preToolUseSection, 'Should have a PreToolUse configuration section');
-    assert.ok(
-      preToolUseSection[0].includes('commandUsageCmd'),
-      'PreToolUse section should push commandUsageCmd'
-    );
-  });
+  // -- scanHookEvents: verify dynamic hook scanning maps events correctly --
 
-  test('source pushes command-usage hook to PostToolUse', () => {
-    const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    // Find PostToolUse section
-    const postToolUseSection = src.match(/PostToolUse[\s\S]*?log\('PostToolUse hook configured'\)/);
-    assert.ok(postToolUseSection, 'Should have a PostToolUse configuration section');
-    assert.ok(
-      postToolUseSection[0].includes('commandUsageCmd'),
-      'PostToolUse section should push commandUsageCmd'
-    );
+  test('scanHookEvents maps df-command-usage.js to all three events', () => {
+    const { scanHookEvents } = require('./install.js');
+    const hooksDir = path.resolve(__dirname, '..', 'hooks');
+    const { eventMap } = scanHookEvents(hooksDir);
+    for (const event of ['PreToolUse', 'PostToolUse', 'SessionEnd']) {
+      assert.ok(eventMap.has(event), `eventMap should have ${event}`);
+      assert.ok(
+        eventMap.get(event).includes('df-command-usage.js'),
+        `${event} should include df-command-usage.js`
+      );
+    }
   });
 
-  test('source pushes command-usage hook to SessionEnd', () => {
+  // -- configureHooks uses dynamic wiring (no hardcoded per-hook variables) --
+
+  test('source uses scanHookEvents for dynamic hook wiring', () => {
     const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    // Find SessionEnd section — should include command-usage alongside quota-logger + dashboard-push
-    const sessionEndSection = src.match(/SessionEnd[\s\S]*?log\('Quota logger.*configured.*SessionEnd/);
-    assert.ok(sessionEndSection, 'Should have a SessionEnd configuration section');
-    assert.ok(
-      sessionEndSection[0].includes('commandUsageCmd'),
-      'SessionEnd section should push commandUsageCmd'
-    );
+    assert.ok(src.includes('scanHookEvents('), 'Should call scanHookEvents');
+    assert.ok(src.includes('for (const [event, files] of eventMap)'), 'Should iterate eventMap to wire hooks');
   });
 
-  test('source creates PreToolUse array if missing', () => {
+  test('source initializes event array if missing', () => {
     const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
     assert.ok(
-      src.includes("if (!settings.hooks.PreToolUse)"),
-      'install.js should initialize PreToolUse array if not present'
+      src.includes('if (!settings.hooks[event]) settings.hooks[event] = [];'),
+      'Should initialize event array dynamically'
     );
   });
 
-  // -- Dedup logic: filter removes existing command-usage before re-adding --
-
-  test('PreToolUse dedup filter removes existing df-command-usage entries', () => {
-    const preToolUse = [
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
-      { hooks: [{ type: 'command', command: 'node /usr/local/my-custom.js' }] },
-    ];
-
-    const filtered = preToolUse.filter(hook => {
-      const cmd = hook.hooks?.[0]?.command || '';
-      return !cmd.includes('df-command-usage');
-    });
+  // -- removeDeepflowHooks: generic removal of all /hooks/df- entries --
 
-    assert.equal(filtered.length, 1, 'Should remove existing df-command-usage hook');
-    assert.ok(filtered[0].hooks[0].command.includes('my-custom.js'), 'Should keep non-deepflow hooks');
+  test('removeDeepflowHooks removes df-command-usage from all events', () => {
+    const { removeDeepflowHooks } = require('./install.js');
+    const settings = {
+      hooks: {
+        PreToolUse: [
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
+          { hooks: [{ type: 'command', command: 'node /usr/local/my-custom.js' }] },
+        ],
+        PostToolUse: [
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-tool-usage.js' }] },
+        ],
+        SessionEnd: [
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
+          { hooks: [{ type: 'command', command: 'node /usr/local/keep.js' }] },
+        ],
+      }
+    };
+    removeDeepflowHooks(settings);
+    assert.equal(settings.hooks.PreToolUse.length, 1);
+    assert.ok(settings.hooks.PreToolUse[0].hooks[0].command.includes('my-custom.js'));
+    assert.ok(!('PostToolUse' in settings.hooks), 'PostToolUse should be deleted when only deepflow hooks');
+    assert.equal(settings.hooks.SessionEnd.length, 1);
+    assert.ok(settings.hooks.SessionEnd[0].hooks[0].command.includes('keep.js'));
   });
 
-  test('PostToolUse dedup filter removes df-command-usage alongside other deepflow hooks', () => {
-    const postToolUse = [
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-tool-usage.js' }] },
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-worktree-guard.js' }] },
-      { hooks: [{ type: 'command', command: 'node /usr/local/keep-me.js' }] },
-    ];
-
-    const filtered = postToolUse.filter(hook => {
-      const cmd = hook.hooks?.[0]?.command || '';
-      return !cmd.includes('df-tool-usage') &&
-             !cmd.includes('df-execution-history') &&
-             !cmd.includes('df-worktree-guard') &&
-             !cmd.includes('df-snapshot-guard') &&
-             !cmd.includes('df-invariant-check') &&
-             !cmd.includes('df-command-usage');
-    });
-
-    assert.equal(filtered.length, 1);
-    assert.ok(filtered[0].hooks[0].command.includes('keep-me.js'));
+  test('removeDeepflowHooks deletes event key when array becomes empty', () => {
+    const { removeDeepflowHooks } = require('./install.js');
+    const settings = {
+      hooks: {
+        PreToolUse: [
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
+        ],
+      }
+    };
+    removeDeepflowHooks(settings);
+    assert.ok(!('PreToolUse' in (settings.hooks || {})), 'PreToolUse should be deleted when empty');
   });
 
-  test('SessionEnd dedup filter removes df-command-usage alongside quota-logger and dashboard-push', () => {
-    const sessionEnd = [
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-quota-logger.js' }] },
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-dashboard-push.js' }] },
-      { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
-      { hooks: [{ type: 'command', command: 'node /usr/local/keep.js' }] },
-    ];
-
-    const filtered = sessionEnd.filter(hook => {
-      const cmd = hook.hooks?.[0]?.command || '';
-      return !cmd.includes('df-quota-logger') &&
-             !cmd.includes('df-dashboard-push') &&
-             !cmd.includes('df-command-usage');
-    });
-
-    assert.equal(filtered.length, 1);
-    assert.ok(filtered[0].hooks[0].command.includes('keep.js'));
+  test('removeDeepflowHooks keeps non-deepflow hooks intact', () => {
+    const { removeDeepflowHooks } = require('./install.js');
+    const settings = {
+      hooks: {
+        PreToolUse: [
+          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
+          { hooks: [{ type: 'command', command: 'node /usr/local/custom-pre-hook.js' }] },
+        ],
+      }
+    };
+    removeDeepflowHooks(settings);
+    assert.ok('PreToolUse' in settings.hooks, 'PreToolUse should be kept when custom hooks remain');
+    assert.equal(settings.hooks.PreToolUse.length, 1);
+    assert.ok(settings.hooks.PreToolUse[0].hooks[0].command.includes('custom-pre-hook.js'));
   });
 
-  // -- Uninstall cleanup --
-
-  test('uninstall toRemove includes df-command-usage.js', () => {
-    const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    // Find the toRemove.push(...) line for hooks in uninstall
-    assert.ok(
-      src.includes("'hooks/df-command-usage.js'"),
-      'toRemove should include hooks/df-command-usage.js for uninstall'
-    );
-  });
+  // -- Uninstall: dynamic df-*.js discovery --
 
-  test('uninstall SessionEnd filter removes df-command-usage', () => {
+  test('uninstall dynamically discovers df-*.js hooks to remove', () => {
     const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
-    // In the uninstall function, the SessionEnd filter should include df-command-usage
-    // Find the uninstall section's SessionEnd filter
     const uninstallSection = src.match(/async function uninstall[\s\S]+$/);
     assert.ok(uninstallSection, 'Should have uninstall function');
-    // Check SessionEnd filter in uninstall includes command-usage
-    const sessionEndFilter = uninstallSection[0].match(/SessionEnd[\s\S]*?\.filter[\s\S]*?\);/);
-    assert.ok(sessionEndFilter, 'Should have SessionEnd filter in uninstall');
     assert.ok(
-      sessionEndFilter[0].includes('df-command-usage'),
-      'Uninstall SessionEnd filter should remove df-command-usage hooks'
+      uninstallSection[0].includes("file.startsWith('df-')") &&
+      uninstallSection[0].includes("file.endsWith('.js')"),
+      'Uninstall should dynamically find df-*.js hook files'
     );
   });
 
-  test('uninstall PostToolUse filter removes df-command-usage', () => {
+  test('uninstall uses removeDeepflowHooks for settings cleanup', () => {
     const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
     const uninstallSection = src.match(/async function uninstall[\s\S]+$/);
-    const postToolUseFilter = uninstallSection[0].match(/PostToolUse[\s\S]*?\.filter[\s\S]*?\);/);
-    assert.ok(postToolUseFilter, 'Should have PostToolUse filter in uninstall');
     assert.ok(
-      postToolUseFilter[0].includes('df-command-usage'),
-      'Uninstall PostToolUse filter should remove df-command-usage hooks'
+      uninstallSection[0].includes('removeDeepflowHooks'),
+      'Uninstall should use removeDeepflowHooks for generic cleanup'
     );
   });
 
-  test('uninstall cleans up PreToolUse hooks', () => {
+  test('uninstall removes hooks/lib directory', () => {
     const src = fs.readFileSync(path.resolve(__dirname, 'install.js'), 'utf8');
     const uninstallSection = src.match(/async function uninstall[\s\S]+$/);
     assert.ok(
-      uninstallSection[0].includes('PreToolUse'),
-      'Uninstall function should handle PreToolUse cleanup'
-    );
-    // Verify it filters out df-command-usage from PreToolUse
-    const preToolUseFilter = uninstallSection[0].match(/PreToolUse[\s\S]*?\.filter[\s\S]*?\);/);
-    assert.ok(preToolUseFilter, 'Should have PreToolUse filter in uninstall');
-    assert.ok(
-      preToolUseFilter[0].includes('df-command-usage'),
-      'Uninstall PreToolUse filter should remove df-command-usage hooks'
+      uninstallSection[0].includes("hooks/lib"),
+      'Uninstall should remove hooks/lib directory'
     );
   });
-
-  test('uninstall deletes PreToolUse key when array becomes empty', () => {
-    // Reproduce the uninstall logic for PreToolUse
-    const settings = {
-      hooks: {
-        PreToolUse: [
-          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
-        ],
-      }
-    };
-
-    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(hook => {
-      const cmd = hook.hooks?.[0]?.command || '';
-      return !cmd.includes('df-command-usage');
-    });
-    if (settings.hooks.PreToolUse.length === 0) {
-      delete settings.hooks.PreToolUse;
-    }
-
-    assert.ok(!('PreToolUse' in settings.hooks), 'PreToolUse should be deleted when empty after filtering');
-  });
-
-  test('uninstall keeps PreToolUse when non-deepflow hooks remain', () => {
-    const settings = {
-      hooks: {
-        PreToolUse: [
-          { hooks: [{ type: 'command', command: 'node /home/.claude/hooks/df-command-usage.js' }] },
-          { hooks: [{ type: 'command', command: 'node /usr/local/custom-pre-hook.js' }] },
-        ],
-      }
-    };
-
-    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(hook => {
-      const cmd = hook.hooks?.[0]?.command || '';
-      return !cmd.includes('df-command-usage');
-    });
-    if (settings.hooks.PreToolUse.length === 0) {
-      delete settings.hooks.PreToolUse;
-    }
-
-    assert.ok('PreToolUse' in settings.hooks, 'PreToolUse should be kept when custom hooks remain');
-    assert.equal(settings.hooks.PreToolUse.length, 1);
-    assert.ok(settings.hooks.PreToolUse[0].hooks[0].command.includes('custom-pre-hook.js'));
-  });
 });
 
 // ---------------------------------------------------------------------------

package/hooks/df-command-usage.js

@@ -18,24 +18,20 @@
 
 const fs = require('fs');
 const path = require('path');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 const event = process.env.CLAUDE_HOOK_EVENT || '';
 
-// Read stdin for hook payload
-let raw = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', d => raw += d);
-process.stdin.on('end', () => {
+readStdinIfMain(module, (data) => {
   try {
-    main();
+    main(data);
   } catch (_e) {
     // REQ-8: never break Claude Code
   }
-  process.exit(0);
 });
 
-function main() {
-  const baseDir = findProjectDir();
+function main(data) {
+  const baseDir = findProjectDir(data);
   if (!baseDir) return;
 
   const deepflowDir = path.join(baseDir, '.deepflow');
@@ -44,20 +40,18 @@ function main() {
   const tokenHistoryPath = path.join(deepflowDir, 'token-history.jsonl');
 
   if (event === 'PreToolUse') {
-    handlePreToolUse(deepflowDir, markerPath, usagePath, tokenHistoryPath);
+    handlePreToolUse(data, deepflowDir, markerPath, usagePath, tokenHistoryPath);
   } else if (event === 'PostToolUse') {
-    handlePostToolUse(markerPath);
+    handlePostToolUse(data, markerPath);
   } else if (event === 'SessionStart') {
-    handleSessionStart(markerPath, usagePath, tokenHistoryPath);
+    handleSessionStart(data, markerPath, usagePath, tokenHistoryPath);
   } else if (event === 'SessionEnd') {
     handleSessionEnd(deepflowDir, markerPath, usagePath, tokenHistoryPath);
   }
 }
 
-function handlePreToolUse(deepflowDir, markerPath, usagePath, tokenHistoryPath) {
-  let payload;
-  try { payload = JSON.parse(raw); } catch { return; }
-
+function handlePreToolUse(data, deepflowDir, markerPath, usagePath, tokenHistoryPath) {
+  const payload = data;
   const toolName = payload.tool_name || '';
   const toolInput = payload.tool_input || {};
 
@@ -96,12 +90,11 @@ function handlePreToolUse(deepflowDir, markerPath, usagePath, tokenHistoryPath)
   safeWriteFile(markerPath, JSON.stringify(marker, null, 2));
 }
 
-function handlePostToolUse(markerPath) {
+function handlePostToolUse(data, markerPath) {
   if (!safeExists(markerPath)) return;
 
   // Don't count the Skill call itself (the one that opened the marker)
-  let payload;
-  try { payload = JSON.parse(raw); } catch { return; }
+  const payload = data;
   const toolName = payload.tool_name || '';
   const toolInput = payload.tool_input || {};
   if (toolName === 'Skill' && (toolInput.skill || '').startsWith('df:')) return;
@@ -119,10 +112,9 @@ function handlePostToolUse(markerPath) {
  * On /clear or /compact, context resets — close any orphaned marker.
  * Only fires for source=clear|compact (not startup/resume).
  */
-function handleSessionStart(markerPath, usagePath, tokenHistoryPath) {
+function handleSessionStart(data, markerPath, usagePath, tokenHistoryPath) {
   if (!safeExists(markerPath)) return;
-  let payload;
-  try { payload = JSON.parse(raw); } catch { return; }
+  const payload = data;
   const source = payload.source || '';
   if (source === 'clear' || source === 'compact') {
     closeCommand(markerPath, usagePath, tokenHistoryPath);
@@ -250,11 +242,10 @@ function parseTranscriptOutputTokens(transcriptPath, offset) {
 /**
  * Find the project directory from hook payload or environment.
  */
-function findProjectDir() {
+function findProjectDir(data) {
   try {
-    const payload = JSON.parse(raw);
-    if (payload.cwd) return payload.cwd;
-    if (payload.workspace && payload.workspace.current_dir) return payload.workspace.current_dir;
+    if (data && data.cwd) return data.cwd;
+    if (data && data.workspace && data.workspace.current_dir) return data.workspace.current_dir;
   } catch (_e) {
     // fall through
   }

package/hooks/df-execution-history.js

@@ -14,6 +14,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { readStdinIfMain } = require('./lib/hook-stdin');
 
 /**
  * Extract task_id from Agent prompt.
@@ -61,61 +62,50 @@ function resolveProjectRoot(cwd) {
   return cwd;
 }
 
-// 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);
-
-    // Only fire for Agent tool calls
-    if (data.tool_name !== 'Agent') {
-      process.exit(0);
-    }
-
-    const prompt = (data.tool_input && data.tool_input.prompt) || '';
-    const taskId = extractTaskId(prompt);
-
-    // Only record if we have a task_id
-    if (!taskId) {
-      process.exit(0);
-    }
-
-    const cwd = data.cwd || process.cwd();
-    const projectRoot = resolveProjectRoot(cwd);
-    const historyFile = path.join(projectRoot, '.deepflow', 'execution-history.jsonl');
-
-    const timestamp = new Date().toISOString();
-    const sessionId = data.session_id || null;
-    const spec = extractSpec(prompt);
-    const status = extractStatus(data.tool_response);
-
-    const startRecord = {
-      type: 'task_start',
-      task_id: taskId,
-      spec,
-      session_id: sessionId,
-      timestamp,
-    };
+readStdinIfMain(module, (data) => {
+  // Only fire for Agent tool calls
+  if (data.tool_name !== 'Agent') {
+    return;
+  }
 
-    const endRecord = {
-      type: 'task_end',
-      task_id: taskId,
-      session_id: sessionId,
-      status,
-      timestamp,
-    };
+  const prompt = (data.tool_input && data.tool_input.prompt) || '';
+  const taskId = extractTaskId(prompt);
 
-    const logDir = path.dirname(historyFile);
-    if (!fs.existsSync(logDir)) {
-      fs.mkdirSync(logDir, { recursive: true });
-    }
+  // Only record if we have a task_id
+  if (!taskId) {
+    return;
+  }
 
-    fs.appendFileSync(historyFile, JSON.stringify(startRecord) + '\n');
-    fs.appendFileSync(historyFile, JSON.stringify(endRecord) + '\n');
-  } catch (_e) {
-    // Fail silently — never break tool execution (REQ-8)
+  const cwd = data.cwd || process.cwd();
+  const projectRoot = resolveProjectRoot(cwd);
+  const historyFile = path.join(projectRoot, '.deepflow', 'execution-history.jsonl');
+
+  const timestamp = new Date().toISOString();
+  const sessionId = data.session_id || null;
+  const spec = extractSpec(prompt);
+  const status = extractStatus(data.tool_response);
+
+  const startRecord = {
+    type: 'task_start',
+    task_id: taskId,
+    spec,
+    session_id: sessionId,
+    timestamp,
+  };
+
+  const endRecord = {
+    type: 'task_end',
+    task_id: taskId,
+    session_id: sessionId,
+    status,
+    timestamp,
+  };
+
+  const logDir = path.dirname(historyFile);
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
   }
-  process.exit(0);
+
+  fs.appendFileSync(historyFile, JSON.stringify(startRecord) + '\n');
+  fs.appendFileSync(historyFile, JSON.stringify(endRecord) + '\n');
 });