deepflow 0.1.102 → 0.1.104

package/bin/install.js

@@ -134,6 +134,13 @@ async function main() {
   );
   log('Agents installed');
 
+  // Copy templates (explore-protocol, explore-agent, etc.)
+  copyDir(
+    path.join(PACKAGE_DIR, 'templates'),
+    path.join(CLAUDE_DIR, 'templates')
+  );
+  log('Templates installed');
+
   // Copy bin utilities (plan-consolidator, wave-runner, ratchet)
   const binDest = path.join(CLAUDE_DIR, 'bin');
   fs.mkdirSync(binDest, { recursive: true });
@@ -198,8 +205,9 @@ async function main() {
   console.log('  skills/          — gap-discovery, atomic-commits, code-completeness, browse-fetch, browse-verify, auto-cycle');
   console.log('  agents/          — reasoner (/df:auto — autonomous execution via /loop)');
   console.log('  bin/             — plan-consolidator, wave-runner, ratchet');
+  console.log('  templates/       — explore-protocol (auto-injected into Explore agents via hook)');
   if (level === 'global') {
-    console.log('  hooks/           — statusline, update checker, invariant checker, worktree guard');
+    console.log('  hooks/           — statusline, update checker, invariant checker, worktree guard, explore protocol');
   }
   console.log('  hooks/df-spec-*  — spec validation (auto-enforced by /df:spec and /df:plan)');
   console.log('  env/             — ENABLE_LSP_TOOL (code navigation via goToDefinition, findReferences, workspaceSymbol)');
@@ -244,18 +252,82 @@ function copyDir(src, dest) {
   }
 }
 
+// Valid hook events (settings.hooks keys + special "statusLine")
+const VALID_HOOK_EVENTS = new Set([
+  'SessionStart', 'SessionEnd', 'PreToolUse', 'PostToolUse', 'SubagentStop', 'statusLine'
+]);
+
+/**
+ * Scan hook source files for @hook-event tags. Returns:
+ *   { eventMap: Map<event, [filename, ...]>, untagged: [filename, ...] }
+ */
+function scanHookEvents(hooksSourceDir) {
+  const eventMap = new Map();  // event → [filenames]
+  const untagged = [];
+
+  if (!fs.existsSync(hooksSourceDir)) return { eventMap, untagged };
+
+  for (const file of fs.readdirSync(hooksSourceDir)) {
+    if (!file.endsWith('.js') || file.endsWith('.test.js')) continue;
+
+    const content = fs.readFileSync(path.join(hooksSourceDir, file), 'utf8');
+    const firstLines = content.split('\n').slice(0, 10).join('\n');
+    const match = firstLines.match(/\/\/\s*@hook-event:\s*(.+)/);
+
+    if (!match) {
+      untagged.push(file);
+      continue;
+    }
+
+    const events = match[1].split(',').map(e => e.trim()).filter(Boolean);
+    let hasValidEvent = false;
+
+    for (const event of events) {
+      if (!VALID_HOOK_EVENTS.has(event)) {
+        console.log(`  ${c.yellow}!${c.reset} Warning: unknown event "${event}" in ${file} — skipped`);
+        continue;
+      }
+      hasValidEvent = true;
+      if (!eventMap.has(event)) eventMap.set(event, []);
+      eventMap.get(event).push(file);
+    }
+
+    if (!hasValidEvent) {
+      untagged.push(file);
+    }
+  }
+
+  return { eventMap, untagged };
+}
+
+/**
+ * Remove all deepflow hook entries (commands containing /hooks/df-) from settings.
+ * Preserves non-deepflow hooks.
+ */
+function removeDeepflowHooks(settings) {
+  const isDeepflow = (hook) => {
+    const cmd = hook.hooks?.[0]?.command || '';
+    return cmd.includes('/hooks/df-');
+  };
+
+  // Clean settings.hooks.*
+  if (settings.hooks) {
+    for (const event of Object.keys(settings.hooks)) {
+      settings.hooks[event] = settings.hooks[event].filter(h => !isDeepflow(h));
+      if (settings.hooks[event].length === 0) delete settings.hooks[event];
+    }
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+
+  // Clean settings.statusLine if it's a deepflow hook
+  if (settings.statusLine?.command && settings.statusLine.command.includes('/hooks/df-')) {
+    delete settings.statusLine;
+  }
+}
+
 async function configureHooks(claudeDir) {
   const settingsPath = path.join(claudeDir, 'settings.json');
-  const statuslineCmd = `node "${path.join(claudeDir, 'hooks', 'df-statusline.js')}"`;
-  const updateCheckCmd = `node "${path.join(claudeDir, 'hooks', 'df-check-update.js')}"`;
-  const quotaLoggerCmd = `node "${path.join(claudeDir, 'hooks', 'df-quota-logger.js')}"`;
-  const toolUsageCmd = `node "${path.join(claudeDir, 'hooks', 'df-tool-usage.js')}"`;
-  const dashboardPushCmd = `node "${path.join(claudeDir, 'hooks', 'df-dashboard-push.js')}"`;
-  const executionHistoryCmd = `node "${path.join(claudeDir, 'hooks', 'df-execution-history.js')}"`;
-  const worktreeGuardCmd = `node "${path.join(claudeDir, 'hooks', 'df-worktree-guard.js')}"`;
-  const snapshotGuardCmd = `node "${path.join(claudeDir, 'hooks', 'df-snapshot-guard.js')}"`;
-  const invariantCheckCmd = `node "${path.join(claudeDir, 'hooks', 'df-invariant-check.js')}"`;
-  const subagentRegistryCmd = `node "${path.join(claudeDir, 'hooks', 'df-subagent-registry.js')}"`;
+  const hooksSourceDir = path.join(PACKAGE_DIR, 'hooks');
 
   let settings = {};
 
@@ -276,158 +348,64 @@ async function configureHooks(claudeDir) {
   configurePermissions(settings);
   log('Agent permissions configured');
 
-  // Configure statusline
-  if (settings.statusLine) {
-    if (process.stdin.isTTY) {
-      const answer = await ask(
-        `  ${c.yellow}!${c.reset} Existing statusLine found. Replace with deepflow? [y/N] `
-      );
-      if (answer.toLowerCase() === 'y') {
-        settings.statusLine = { type: 'command', command: statuslineCmd };
-        log('Statusline configured');
-      } else {
-        console.log(`  ${c.yellow}!${c.reset} Skipped statusline configuration`);
-      }
-    } else {
-      // Non-interactive (e.g. Claude Code bash tool) — skip prompt, keep existing
-      console.log(`  ${c.yellow}!${c.reset} Existing statusLine found — kept (non-interactive mode)`);
-    }
-  } else {
-    settings.statusLine = { type: 'command', command: statuslineCmd };
-    log('Statusline configured');
-  }
+  // Scan hook files for @hook-event tags
+  const { eventMap, untagged } = scanHookEvents(hooksSourceDir);
 
-  // Configure SessionStart hook for update checking
-  if (!settings.hooks) {
-    settings.hooks = {};
-  }
-  if (!settings.hooks.SessionStart) {
-    settings.hooks.SessionStart = [];
-  }
+  // Remember if there was a pre-existing non-deepflow statusLine
+  const hadExternalStatusLine = settings.statusLine &&
+    !settings.statusLine.command?.includes('/hooks/df-');
 
-  // Remove any existing deepflow update check / quota logger hooks from SessionStart
-  settings.hooks.SessionStart = settings.hooks.SessionStart.filter(hook => {
-    const cmd = hook.hooks?.[0]?.command || '';
-    return !cmd.includes('df-check-update') && !cmd.includes('df-quota-logger');
-  });
-
-  // Add update check hook
-  settings.hooks.SessionStart.push({
-    hooks: [{
-      type: 'command',
-      command: updateCheckCmd
-    }]
-  });
-
-  // Add quota logger to SessionStart
-  settings.hooks.SessionStart.push({
-    hooks: [{
-      type: 'command',
-      command: quotaLoggerCmd
-    }]
-  });
-  log('SessionStart hook configured');
+  // Remove all existing deepflow hooks (orphan cleanup + idempotency)
+  removeDeepflowHooks(settings);
 
-  // Configure SessionEnd hook for quota logging
-  if (!settings.hooks.SessionEnd) {
-    settings.hooks.SessionEnd = [];
-  }
+  // Wire hooks by event
+  if (!settings.hooks) settings.hooks = {};
 
-  // Remove any existing quota logger / dashboard push from SessionEnd
-  settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(hook => {
-    const cmd = hook.hooks?.[0]?.command || '';
-    return !cmd.includes('df-quota-logger') && !cmd.includes('df-dashboard-push');
-  });
+  for (const [event, files] of eventMap) {
+    if (event === 'statusLine') {
+      // Handle statusLine separately — it's settings.statusLine, not settings.hooks
+      const statusFile = files[0]; // Only one statusline hook expected
+      const statusCmd = `node "${path.join(claudeDir, 'hooks', statusFile)}"`;
 
-  // Add quota logger to SessionEnd
-  settings.hooks.SessionEnd.push({
-    hooks: [{
-      type: 'command',
-      command: quotaLoggerCmd
-    }]
-  });
+      if (hadExternalStatusLine) {
+        if (process.stdin.isTTY) {
+          const answer = await ask(
+            `  ${c.yellow}!${c.reset} Existing statusLine found. Replace with deepflow? [y/N] `
+          );
+          if (answer.toLowerCase() === 'y') {
+            settings.statusLine = { type: 'command', command: statusCmd };
+            log('Statusline configured');
+          } else {
+            console.log(`  ${c.yellow}!${c.reset} Skipped statusline configuration`);
+          }
+        } else {
+          // Non-interactive (e.g. Claude Code bash tool) — skip prompt, keep existing
+          console.log(`  ${c.yellow}!${c.reset} Existing statusLine found — kept (non-interactive mode)`);
+        }
+      } else {
+        settings.statusLine = { type: 'command', command: statusCmd };
+        log('Statusline configured');
+      }
+      continue;
+    }
 
-  // Add dashboard push to SessionEnd (fire-and-forget, skips when dashboard_url unset)
-  settings.hooks.SessionEnd.push({
-    hooks: [{
-      type: 'command',
-      command: dashboardPushCmd
-    }]
-  });
-  log('Quota logger + dashboard push configured (SessionEnd)');
+    // Regular hook events
+    if (!settings.hooks[event]) settings.hooks[event] = [];
 
-  // Configure PostToolUse hook for tool usage instrumentation
-  if (!settings.hooks.PostToolUse) {
-    settings.hooks.PostToolUse = [];
+    for (const file of files) {
+      const cmd = `node "${path.join(claudeDir, 'hooks', file)}"`;
+      settings.hooks[event].push({
+        hooks: [{ type: 'command', command: cmd }]
+      });
+    }
+    log(`${event} hook configured`);
   }
 
-  // Remove any existing deepflow tool usage / execution history / worktree guard / snapshot guard / invariant check hooks from PostToolUse
-  settings.hooks.PostToolUse = settings.hooks.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');
-  });
-
-  // Add tool usage hook
-  settings.hooks.PostToolUse.push({
-    hooks: [{
-      type: 'command',
-      command: toolUsageCmd
-    }]
-  });
-
-  // Add execution history hook
-  settings.hooks.PostToolUse.push({
-    hooks: [{
-      type: 'command',
-      command: executionHistoryCmd
-    }]
-  });
-
-  // Add worktree guard hook (blocks Write/Edit to main-branch files when df/* worktree exists)
-  settings.hooks.PostToolUse.push({
-    hooks: [{
-      type: 'command',
-      command: worktreeGuardCmd
-    }]
-  });
-
-  // Add snapshot guard hook (blocks Write/Edit to ratchet-baseline files in auto-snapshot.txt)
-  settings.hooks.PostToolUse.push({
-    hooks: [{
-      type: 'command',
-      command: snapshotGuardCmd
-    }]
-  });
-
-  // Add invariant check hook (exits 1 on hard failures after git commit)
-  settings.hooks.PostToolUse.push({
-    hooks: [{
-      type: 'command',
-      command: invariantCheckCmd
-    }]
-  });
-  log('PostToolUse hook configured');
-
-  // Configure SubagentStop hook for subagent registry
-  if (!settings.hooks.SubagentStop) {
-    settings.hooks.SubagentStop = [];
+  // Log untagged files (copied but not wired)
+  for (const file of untagged) {
+    console.log(`  ${c.dim}${file} copied (no @hook-event tag — not wired)${c.reset}`);
   }
 
-  // Remove any existing subagent registry hooks
-  settings.hooks.SubagentStop = settings.hooks.SubagentStop.filter(hook => {
-    const cmd = hook.hooks?.[0]?.command || '';
-    return !cmd.includes('df-subagent-registry');
-  });
-
-  // Add subagent registry hook
-  settings.hooks.SubagentStop.push({
-    hooks: [{
-      type: 'command',
-      command: subagentRegistryCmd
-    }]
-  });
-  log('SubagentStop hook configured');
-
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 
@@ -607,11 +585,20 @@ async function uninstall() {
     'agents/reasoner.md',
     'bin/plan-consolidator.js',
     'bin/wave-runner.js',
-    'bin/ratchet.js'
+    'bin/ratchet.js',
+    'templates'
   ];
 
   if (level === 'global') {
-    toRemove.push('hooks/df-statusline.js', 'hooks/df-check-update.js', 'hooks/df-invariant-check.js', 'hooks/df-quota-logger.js', 'hooks/df-tool-usage.js', 'hooks/df-dashboard-push.js', 'hooks/df-execution-history.js', 'hooks/df-worktree-guard.js', 'hooks/df-snapshot-guard.js', 'hooks/df-subagent-registry.js');
+    // Dynamically find all df-*.js hook files to remove
+    const hooksDir = path.join(CLAUDE_DIR, 'hooks');
+    if (fs.existsSync(hooksDir)) {
+      for (const file of fs.readdirSync(hooksDir)) {
+        if (file.startsWith('df-') && file.endsWith('.js')) {
+          toRemove.push(`hooks/${file}`);
+        }
+      }
+    }
   }
 
   for (const item of toRemove) {
@@ -631,67 +618,25 @@ async function uninstall() {
     }
   }
 
-  // Remove SessionStart hook from settings
+  // Remove hook entries and settings from global settings.json
   if (level === 'global') {
     const settingsPath = path.join(CLAUDE_DIR, 'settings.json');
     if (fs.existsSync(settingsPath)) {
       try {
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-        if (settings.hooks?.SessionStart) {
-          settings.hooks.SessionStart = settings.hooks.SessionStart.filter(hook => {
-            const cmd = hook.hooks?.[0]?.command || '';
-            return !cmd.includes('df-check-update') && !cmd.includes('df-quota-logger');
-          });
-          if (settings.hooks.SessionStart.length === 0) {
-            delete settings.hooks.SessionStart;
-          }
-        }
-        if (settings.hooks?.SessionEnd) {
-          settings.hooks.SessionEnd = settings.hooks.SessionEnd.filter(hook => {
-            const cmd = hook.hooks?.[0]?.command || '';
-            return !cmd.includes('df-quota-logger') && !cmd.includes('df-dashboard-push');
-          });
-          if (settings.hooks.SessionEnd.length === 0) {
-            delete settings.hooks.SessionEnd;
-          }
-        }
-        if (settings.hooks?.PostToolUse) {
-          settings.hooks.PostToolUse = settings.hooks.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');
-          });
-          if (settings.hooks.PostToolUse.length === 0) {
-            delete settings.hooks.PostToolUse;
-          }
-        }
-        if (settings.hooks?.SubagentStop) {
-          settings.hooks.SubagentStop = settings.hooks.SubagentStop.filter(hook => {
-            const cmd = hook.hooks?.[0]?.command || '';
-            return !cmd.includes('df-subagent-registry');
-          });
-          if (settings.hooks.SubagentStop.length === 0) {
-            delete settings.hooks.SubagentStop;
-          }
-        }
-        if (settings.hooks && Object.keys(settings.hooks).length === 0) {
-          delete settings.hooks;
-        }
-        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-        console.log(`  ${c.green}✓${c.reset} Removed SessionStart/SessionEnd/PostToolUse/SubagentStop hooks`);
-      } catch (e) {
-        // Fail silently
-      }
-    }
 
-    // Remove ENABLE_LSP_TOOL and deepflow permissions from global settings
-    if (fs.existsSync(settingsPath)) {
-      try {
-        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        // Remove all deepflow hook wiring dynamically
+        removeDeepflowHooks(settings);
+        console.log(`  ${c.green}✓${c.reset} Removed deepflow hooks from settings`);
+
+        // Remove ENABLE_LSP_TOOL
         if (settings.env?.ENABLE_LSP_TOOL) {
           delete settings.env.ENABLE_LSP_TOOL;
           if (settings.env && Object.keys(settings.env).length === 0) delete settings.env;
           console.log(`  ${c.green}✓${c.reset} Removed ENABLE_LSP_TOOL from settings`);
         }
+
+        // Remove deepflow permissions
         if (settings.permissions?.allow) {
           const dfPerms = new Set(DEEPFLOW_PERMISSIONS);
           settings.permissions.allow = settings.permissions.allow.filter(p => !dfPerms.has(p));
@@ -699,6 +644,7 @@ async function uninstall() {
           if (settings.permissions && Object.keys(settings.permissions).length === 0) delete settings.permissions;
           console.log(`  ${c.green}✓${c.reset} Removed deepflow permissions from settings`);
         }
+
         fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
       } catch (e) {
         // Fail silently

package/bin/install.test.js

@@ -589,6 +589,220 @@ describe('Uninstaller — file removal and settings cleanup', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// T4. command-usage hook registration (PreToolUse, PostToolUse, SessionEnd)
+// ---------------------------------------------------------------------------
+
+describe('T4 — command-usage hook registration in install.js', () => {
+
+  // -- Source-level checks: verify install.js registers df-command-usage.js --
+
+  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('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'
+    );
+  });
+
+  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('source pushes command-usage hook to SessionEnd', () => {
+    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'
+    );
+  });
+
+  test('source creates PreToolUse 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'
+    );
+  });
+
+  // -- 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');
+    });
+
+    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('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('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'));
+  });
+
+  // -- 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'
+    );
+  });
+
+  test('uninstall SessionEnd filter removes df-command-usage', () => {
+    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'
+    );
+  });
+
+  test('uninstall PostToolUse filter removes df-command-usage', () => {
+    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'
+    );
+  });
+
+  test('uninstall cleans up PreToolUse hooks', () => {
+    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'
+    );
+  });
+
+  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'));
+  });
+});
+
 // ---------------------------------------------------------------------------
 // 4. isInstalled helper logic
 // ---------------------------------------------------------------------------