deepflow 0.1.101 → 0.1.103

package/bin/install.js

@@ -256,6 +256,7 @@ async function configureHooks(claudeDir) {
   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 commandUsageCmd = `node "${path.join(claudeDir, 'hooks', 'df-command-usage.js')}"`;
 
   let settings = {};
 
@@ -333,10 +334,10 @@ async function configureHooks(claudeDir) {
     settings.hooks.SessionEnd = [];
   }
 
-  // Remove any existing quota logger / dashboard push from SessionEnd
+  // Remove any existing quota logger / dashboard push / command usage 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');
+    return !cmd.includes('df-quota-logger') && !cmd.includes('df-dashboard-push') && !cmd.includes('df-command-usage');
   });
 
   // Add quota logger to SessionEnd
@@ -354,17 +355,25 @@ async function configureHooks(claudeDir) {
       command: dashboardPushCmd
     }]
   });
-  log('Quota logger + dashboard push configured (SessionEnd)');
+
+  // Add command usage hook to SessionEnd (flush any pending command data)
+  settings.hooks.SessionEnd.push({
+    hooks: [{
+      type: 'command',
+      command: commandUsageCmd
+    }]
+  });
+  log('Quota logger + dashboard push + command usage configured (SessionEnd)');
 
   // Configure PostToolUse hook for tool usage instrumentation
   if (!settings.hooks.PostToolUse) {
     settings.hooks.PostToolUse = [];
   }
 
-  // Remove any existing deepflow tool usage / execution history / worktree guard / snapshot guard / invariant check hooks from PostToolUse
+  // Remove any existing deepflow tool usage / execution history / worktree guard / snapshot guard / invariant check / command usage 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');
+    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');
   });
 
   // Add tool usage hook
@@ -406,6 +415,14 @@ async function configureHooks(claudeDir) {
       command: invariantCheckCmd
     }]
   });
+
+  // Add command usage hook to PostToolUse
+  settings.hooks.PostToolUse.push({
+    hooks: [{
+      type: 'command',
+      command: commandUsageCmd
+    }]
+  });
   log('PostToolUse hook configured');
 
   // Configure SubagentStop hook for subagent registry
@@ -428,6 +445,26 @@ async function configureHooks(claudeDir) {
   });
   log('SubagentStop hook configured');
 
+  // Configure PreToolUse hook for command usage instrumentation
+  if (!settings.hooks.PreToolUse) {
+    settings.hooks.PreToolUse = [];
+  }
+
+  // Remove any existing deepflow command usage hooks from PreToolUse
+  settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(hook => {
+    const cmd = hook.hooks?.[0]?.command || '';
+    return !cmd.includes('df-command-usage');
+  });
+
+  // Add command usage hook to PreToolUse
+  settings.hooks.PreToolUse.push({
+    hooks: [{
+      type: 'command',
+      command: commandUsageCmd
+    }]
+  });
+  log('PreToolUse hook configured');
+
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
 }
 
@@ -611,7 +648,7 @@ async function uninstall() {
   ];
 
   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');
+    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', 'hooks/df-command-usage.js');
   }
 
   for (const item of toRemove) {
@@ -649,7 +686,7 @@ async function uninstall() {
         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');
+            return !cmd.includes('df-quota-logger') && !cmd.includes('df-dashboard-push') && !cmd.includes('df-command-usage');
           });
           if (settings.hooks.SessionEnd.length === 0) {
             delete settings.hooks.SessionEnd;
@@ -658,12 +695,21 @@ async function uninstall() {
         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');
+            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');
           });
           if (settings.hooks.PostToolUse.length === 0) {
             delete settings.hooks.PostToolUse;
           }
         }
+        if (settings.hooks?.PreToolUse) {
+          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;
+          }
+        }
         if (settings.hooks?.SubagentStop) {
           settings.hooks.SubagentStop = settings.hooks.SubagentStop.filter(hook => {
             const cmd = hook.hooks?.[0]?.command || '';
@@ -677,7 +723,7 @@ async function uninstall() {
           delete settings.hooks;
         }
         fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-        console.log(`  ${c.green}✓${c.reset} Removed SessionStart/SessionEnd/PostToolUse/SubagentStop hooks`);
+        console.log(`  ${c.green}✓${c.reset} Removed SessionStart/SessionEnd/PreToolUse/PostToolUse/SubagentStop hooks`);
       } 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
 // ---------------------------------------------------------------------------

package/bin/plan-consolidator.js

@@ -208,7 +208,8 @@ function consolidate(specEntries, fileConflicts) {
 
 /**
  * Render consolidated tasks as PLAN.md-compatible markdown.
- * Groups tasks under ### {specName} headings.
+ * Groups tasks under ### doing-{specName} headings with a details reference line.
+ * One line per task — no sub-bullets. Files omitted (live in mini-plans only).
  * Compatible with wave-runner's parsePlan regex (see wave-runner.js parsePlan).
  */
 function formatConsolidated(consolidated) {
@@ -221,11 +222,15 @@ function formatConsolidated(consolidated) {
 
   for (const task of consolidated) {
     if (task.specName !== lastSpec) {
-      lines.push(`### ${task.specName}\n`);
+      // Close previous spec with trailing blank line (already added after last task)
+      const doingName = `doing-${task.specName}`;
+      const planPath = `.deepflow/plans/${doingName}.md`;
+      lines.push(`### ${doingName}\n`);
+      lines.push(`> Details: [\`${planPath}\`](${planPath})\n`);
       lastSpec = task.specName;
     }
 
-    // Task header line
+    // Task header line — one line, no sub-bullets
     const tagPart = task.tags ? ` ${task.tags}` : '';
     // Append conflict annotations to description if any
     const conflictPart = task.conflictAnnotations.length > 0
@@ -233,23 +238,18 @@ function formatConsolidated(consolidated) {
       : '';
     const descPart = (task.description + conflictPart).trim();
     const headerDesc = descPart ? `: ${descPart}` : '';
-    lines.push(`- [ ] **${task.globalId}**${tagPart}${headerDesc}`);
 
-    // Files annotation
-    if (task.files.length > 0) {
-      lines.push(`  - Files: ${task.files.join(', ')}`);
-    }
-
-    // Blocked by annotation
-    if (task.blockedBy.length > 0) {
-      lines.push(`  - Blocked by: ${task.blockedBy.join(', ')}`);
-    } else {
-      lines.push('  - Blocked by: none');
-    }
+    // Blocked by suffix — omit entirely when empty
+    const blockedSuffix = task.blockedBy.length > 0
+      ? ` | Blocked by: ${task.blockedBy.join(', ')}`
+      : '';
 
-    lines.push('');
+    lines.push(`- [ ] **${task.globalId}**${tagPart}${headerDesc}${blockedSuffix}`);
   }
 
+  // Trailing newline after last task
+  lines.push('');
+
   return lines.join('\n');
 }
 

package/bin/wave-runner.js

@@ -85,14 +85,38 @@ function parsePlan(text) {
     // Match pending task header: - [ ] **T{N}**...
     const taskMatch = line.match(/^\s*-\s+\[\s+\]\s+\*\*T(\d+)\*\*(?:\s+\[[^\]]*\])?[:\s]*(.*)/);
     if (taskMatch) {
+      const rest = taskMatch[2].trim();
+
+      // Extract inline blocked-by (from " | Blocked by: T1, T2")
+      let inlineBlockedBy = [];
+      let descPart = rest;
+      const blockedInlineMatch = rest.match(/\s*\|\s*Blocked\s+by:\s+(.+)$/i);
+      if (blockedInlineMatch) {
+        descPart = rest.substring(0, rest.length - blockedInlineMatch[0].length).trim();
+        inlineBlockedBy = blockedInlineMatch[1]
+          .split(/[,\s]+/)
+          .map(s => s.trim())
+          .filter(s => /^T\d+$/.test(s));
+      }
+
+      // Extract inline model/effort (from " — model/effort")
+      let inlineModel = null;
+      let inlineEffort = null;
+      const modelInlineMatch = descPart.match(/\s*\u2014\s*(haiku|sonnet|opus)\/(low|medium|high)\s*$/i);
+      if (modelInlineMatch) {
+        descPart = descPart.substring(0, descPart.length - modelInlineMatch[0].length).trim();
+        inlineModel = modelInlineMatch[1].toLowerCase();
+        inlineEffort = modelInlineMatch[2].toLowerCase();
+      }
+
       current = {
         id: `T${taskMatch[1]}`,
         num: parseInt(taskMatch[1], 10),
-        description: taskMatch[2].trim(),
-        blockedBy: [],
-        model: null,
+        description: descPart,
+        blockedBy: inlineBlockedBy,
+        model: inlineModel,
         files: null,
-        effort: null,
+        effort: inlineEffort,
         spec: currentSpec,
       };
       tasks.push(current);
@@ -107,35 +131,43 @@ function parsePlan(text) {
     }
 
     if (current) {
-      // Match "Blocked by:" annotation
+      // Match "Blocked by:" annotation — only apply if inline parsing found no deps
       const blockedMatch = line.match(/^\s+-\s+Blocked\s+by:\s+(.+)/i);
       if (blockedMatch) {
-        const deps = blockedMatch[1]
-          .split(/[,\s]+/)
-          .map(s => s.trim())
-          .filter(s => /^T\d+$/.test(s));
-        current.blockedBy.push(...deps);
+        if (current.blockedBy.length === 0) {
+          const deps = blockedMatch[1]
+            .split(/[,\s]+/)
+            .map(s => s.trim())
+            .filter(s => /^T\d+$/.test(s));
+          current.blockedBy.push(...deps);
+        }
         continue;
       }
 
-      // Match "Model:" annotation
+      // Match "Model:" annotation — only apply if inline parsing found no model
       const modelMatch = line.match(/^\s+-\s+Model:\s+(.+)/i);
       if (modelMatch) {
-        current.model = modelMatch[1].trim();
+        if (current.model === null) {
+          current.model = modelMatch[1].trim();
+        }
         continue;
       }
 
-      // Match "Files:" annotation
+      // Match "Files:" annotation — always apply (no inline equivalent)
       const filesMatch = line.match(/^\s+-\s+Files:\s+(.+)/i);
       if (filesMatch) {
-        current.files = filesMatch[1].trim();
+        if (current.files === null) {
+          current.files = filesMatch[1].trim();
+        }
         continue;
       }
 
-      // Match "Effort:" annotation
+      // Match "Effort:" annotation — only apply if inline parsing found no effort
       const effortMatch = line.match(/^\s+-\s+Effort:\s+(.+)/i);
       if (effortMatch) {
-        current.effort = effortMatch[1].trim();
+        if (current.effort === null) {
+          current.effort = effortMatch[1].trim();
+        }
         continue;
       }
     }