deepflow 0.1.101 → 0.1.103

package/hooks/df-subagent-registry.js

@@ -9,34 +9,53 @@ 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;
 
-    // Extract required fields from SubagentStop event
-    const { session_id, agent_type, agent_id } = 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;
 
-    // Map agent_type to model (case-sensitive)
-    const MODEL_MAP = {
-      'reasoner': 'claude-opus-4-6',
-      'Explore': 'claude-haiku-4-5'
-    };
-    const model = MODEL_MAP[agent_type] ?? 'claude-sonnet-4-6';
+    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 */ }
+      }
+    }
 
-    // Generate timestamp
-    const timestamp = new Date().toISOString();
+    // 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, '');
 
-    // Build registry entry
     const entry = {
       session_id,
       agent_type,
       agent_id,
       model,
-      timestamp
+      tokens_in,
+      tokens_out,
+      cache_read,
+      cache_creation,
+      timestamp: new Date().toISOString()
     };
 
-    // Append to registry file (fire-and-forget)
     const registryPath = path.join(os.homedir(), '.claude', 'subagent-sessions.jsonl');
     fs.appendFileSync(registryPath, JSON.stringify(entry) + '\n');
   } catch {
-    // Exit 0 on any error (fail-open)
     process.exit(0);
   }
 });

package/hooks/df-tool-usage.js

@@ -60,6 +60,13 @@ process.stdin.on('end', () => {
     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 */ }
+
     const record = {
       timestamp: new Date().toISOString(),
       session_id: data.session_id || null,
@@ -71,6 +78,7 @@ process.stdin.on('end', () => {
       project: cwd ? path.basename(cwd) : null,
       phase: inferPhase(cwd),
       task_id: extractTaskId(cwd),
+      active_command: activeCommand,
     };
 
     const logDir = path.dirname(TOOL_USAGE_LOG);

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

@@ -0,0 +1,200 @@
+/**
+ * Tests for hooks/df-tool-usage.js — T3: active_command field in tool-usage records
+ *
+ * Validates that the tool usage hook reads .deepflow/active-command.json marker
+ * and includes the active_command field in tool-usage.jsonl records.
+ *
+ * Uses Node.js built-in node:test to avoid adding dependencies.
+ */
+
+'use strict';
+
+const { test, describe, beforeEach, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('os');
+const { execFileSync } = require('node:child_process');
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const HOOK_PATH = path.resolve(__dirname, 'df-tool-usage.js');
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'df-tool-usage-test-'));
+}
+
+function rmrf(dir) {
+  if (fs.existsSync(dir)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Run the tool usage hook as a child process with JSON piped to stdin.
+ * Overrides HOME so tool-usage.jsonl goes to a temp location.
+ * Returns { stdout, stderr, code }.
+ */
+function runHook(input, { cwd, env: extraEnv } = {}) {
+  const json = typeof input === 'string' ? input : JSON.stringify(input);
+  const env = { ...process.env, ...extraEnv };
+  // Override HOME so the log file goes to our temp dir
+  env.HOME = cwd || os.tmpdir();
+  try {
+    const stdout = execFileSync(
+      process.execPath,
+      [HOOK_PATH],
+      {
+        input: json,
+        cwd: cwd || os.tmpdir(),
+        encoding: 'utf8',
+        timeout: 5000,
+        env,
+      }
+    );
+    return { stdout, stderr: '', code: 0 };
+  } catch (err) {
+    return {
+      stdout: err.stdout || '',
+      stderr: err.stderr || '',
+      code: err.status ?? 1,
+    };
+  }
+}
+
+/**
+ * Build a minimal PostToolUse event payload.
+ */
+function makeToolInput(cwd) {
+  return {
+    session_id: 'tool-test-session',
+    tool_name: 'Read',
+    tool_input: { file_path: '/tmp/test.js' },
+    tool_response: { content: 'file contents here' },
+    cwd: cwd,
+  };
+}
+
+/**
+ * Read the last record from tool-usage.jsonl.
+ */
+function readLastToolRecord(homeDir) {
+  const logPath = path.join(homeDir, '.claude', 'tool-usage.jsonl');
+  if (!fs.existsSync(logPath)) return null;
+  const lines = fs.readFileSync(logPath, 'utf8').trim().split('\n');
+  return JSON.parse(lines[lines.length - 1]);
+}
+
+// ---------------------------------------------------------------------------
+// T3: active_command field in tool-usage records
+// ---------------------------------------------------------------------------
+
+describe('T3 — tool-usage active_command field', () => {
+  let tmpDir;
+  let deepflowDir;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+    deepflowDir = path.join(tmpDir, '.deepflow');
+    fs.mkdirSync(deepflowDir, { recursive: true });
+    // Create .claude dir for tool-usage.jsonl output
+    fs.mkdirSync(path.join(tmpDir, '.claude'), { recursive: true });
+  });
+
+  afterEach(() => {
+    rmrf(tmpDir);
+  });
+
+  test('active_command is set when active-command.json marker exists', () => {
+    fs.writeFileSync(
+      path.join(deepflowDir, 'active-command.json'),
+      JSON.stringify({ command: 'df:plan', started_at: new Date().toISOString() })
+    );
+
+    const input = makeToolInput(tmpDir);
+    const { code } = runHook(input, { cwd: tmpDir });
+    assert.equal(code, 0, 'Hook should exit successfully');
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record, 'Tool usage record should exist');
+    assert.equal(record.active_command, 'df:plan', 'active_command should match marker');
+  });
+
+  test('active_command is null when no marker file exists', () => {
+    const input = makeToolInput(tmpDir);
+    const { code } = runHook(input, { cwd: tmpDir });
+    assert.equal(code, 0);
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record, 'Tool usage record should exist');
+    assert.equal(record.active_command, null, 'active_command should be null without marker');
+  });
+
+  test('active_command is null when marker file contains corrupt JSON', () => {
+    fs.writeFileSync(
+      path.join(deepflowDir, 'active-command.json'),
+      '{{corrupt json'
+    );
+
+    const input = makeToolInput(tmpDir);
+    const { code } = runHook(input, { cwd: tmpDir });
+    assert.equal(code, 0, 'Hook should not crash on corrupt marker');
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record);
+    assert.equal(record.active_command, null, 'active_command should be null for corrupt marker');
+  });
+
+  test('active_command is null when marker has no command field', () => {
+    fs.writeFileSync(
+      path.join(deepflowDir, 'active-command.json'),
+      JSON.stringify({ other_field: 'value' })
+    );
+
+    const input = makeToolInput(tmpDir);
+    const { code } = runHook(input, { cwd: tmpDir });
+    assert.equal(code, 0);
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record);
+    assert.equal(record.active_command, null, 'active_command should be null when command field missing');
+  });
+
+  test('active_command field always present in tool-usage record schema', () => {
+    const input = makeToolInput(tmpDir);
+    runHook(input, { cwd: tmpDir });
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record);
+    assert.ok('active_command' in record, 'active_command key must always be present');
+    // Verify other expected fields
+    assert.ok('timestamp' in record);
+    assert.ok('session_id' in record);
+    assert.ok('tool_name' in record);
+    assert.ok('phase' in record);
+  });
+
+  test('active_command reads df:execute correctly', () => {
+    fs.writeFileSync(
+      path.join(deepflowDir, 'active-command.json'),
+      JSON.stringify({ command: 'df:execute' })
+    );
+
+    const input = makeToolInput(tmpDir);
+    runHook(input, { cwd: tmpDir });
+
+    const record = readLastToolRecord(tmpDir);
+    assert.ok(record);
+    assert.equal(record.active_command, 'df:execute');
+  });
+
+  test('hook exits 0 even when marker is unreadable (permissions)', () => {
+    // Write marker then make the deepflow dir inaccessible won't work on all OS.
+    // Instead, set cwd to a non-existent path to trigger the fallback.
+    const input = makeToolInput('/nonexistent/path/that/does/not/exist');
+    const { code } = runHook(input, { cwd: tmpDir });
+    assert.equal(code, 0, 'Hook should always exit 0');
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepflow",
-  "version": "0.1.101",
+  "version": "0.1.103",
   "description": "Doing reveals what thinking can't predict — spec-driven iterative development for Claude Code",
   "keywords": [
     "claude",

package/src/commands/df/execute.md

@@ -83,7 +83,7 @@ Load PLAN.md (required), specs/doing-*.md, .deepflow/config.yaml. Missing → "N
 ```
 PLAN_TASK_FILES=!`ls .deepflow/plans/doing-*.md 2>/dev/null | tr '\n' ' ' || echo 'NOT_FOUND'`
 ```
-When `PLAN_TASK_FILES` is not `NOT_FOUND`, each file `.deepflow/plans/doing-{task_id}.md` contains the full task detail block (Steps, ACs, Impact) for that task. Load a task's detail file on demand when building its agent prompt (§6), falling back to the PLAN.md inline block if the file is absent.
+When `PLAN_TASK_FILES` is not `NOT_FOUND`, each file `.deepflow/plans/doing-{specName}.md` contains the full task detail (Files, Steps, ACs, Impact) for all tasks in that spec. Load a task's detail on demand when building its agent prompt (§6). PLAN.md is a slim index — Files and Impact live only in mini-plans.
 
 ### 2.5. REGISTER NATIVE TASKS
 
@@ -134,7 +134,7 @@ Context ≥50% → checkpoint and exit. Before spawning: `TaskUpdate(status: "in
 
 **Intra-wave isolation:** For standard (non-spike, non-optimize) parallel tasks, use `isolation: "worktree"` so each agent works in its own isolated branch. Spikes use sub-worktrees managed by §5.7. Optimize tasks run one at a time in the shared worktree.
 
-**File conflicts (1 file = 1 writer):** Check `Files:` lists. Overlap → spawn lowest-numbered only; rest stay pending. Log: `"⏳ T{N} deferred — file conflict with T{M} on {filename}"`
+**File conflicts (1 file = 1 writer):** Check `Files:` from wave-runner JSON output or from mini-plan detail files (`.deepflow/plans/doing-{specName}.md`). Overlap → spawn lowest-numbered only; rest stay pending. Log: `"⏳ T{N} deferred — file conflict with T{M} on {filename}"`
 
 **≥2 [SPIKE] tasks same problem →** Parallel Spike Probes (§5.7). **[OPTIMIZE] tasks →** Optimize Cycle (§5.9), one at a time.
 

package/src/commands/df/plan.md

@@ -161,28 +161,23 @@ You are a spec planner. Your job is to independently analyze a spec and produce
 
 ## OUTPUT FORMAT — MANDATORY (no deviations)
 Return ONLY a markdown task list. Use local T-numbering starting at T1.
-Each task MUST follow this exact format:
+Each task is ONE LINE. No sub-bullets in the output.
 
 ### {spec-name}
 
 - [ ] **T{N}**: {Task description}
-  - Files: {comma-separated file paths}
-  - Blocked by: none | T{N}[, T{M}...]
-
-Optional fields (add when applicable):
-  - Model: haiku | sonnet | opus
-  - Effort: low | medium | high
-  - Impact: {blast radius details, L3 only}
-  - Optimize: {metric block, for metric ACs only}
+- [ ] **T{N}** [SPIKE]: {Task description} | Blocked by: T{M}
+- [ ] **T{N}**: {Task description} | Blocked by: T{M}, T{K}
 
 Rules:
-- "Blocked by: none" is required (not "N/A", not empty)
+- No blockers → omit `| Blocked by:` entirely (do NOT write "none")
+- Has blockers → append ` | Blocked by: T{N}[, T{M}...]` to end of line
 - T-numbers are local to this spec (T1, T2, T3...)
 - One task = one atomic commit
 - Spike tasks use: **T{N}** [SPIKE]: {description}
 - L0-L1 specs: ONLY spike tasks allowed
 - L2+ specs: spikes + implementation tasks allowed
-- L3 specs: include Impact: blocks from impact analysis
+- Files, Impact, Model, Effort live ONLY in the mini-plan file (NOT in this output)
 ```
 
 #### 4.7.3. Collect & Persist Mini-Plans
@@ -246,11 +241,13 @@ Shell-inject the consolidator output:
 
 `` !`node "${HOME}/.claude/bin/plan-consolidator.js" --plans-dir .deepflow/plans/ 2>/dev/null || node .claude/bin/plan-consolidator.js --plans-dir .deepflow/plans/ 2>/dev/null || true` ``
 
-This produces the `## Tasks` section with:
+This produces a slim `## Tasks` section with:
 - Globally sequential T-ids (no gaps, no duplicates) — AC-4
-- Remapped `Blocked by` references (local → global)
+- Remapped `Blocked by` references (local → global), inline on task line
 - `[file-conflict: {filename}]` annotations on cross-spec file overlaps
+- Mini-plan reference links (`> Details: ...`) per spec section
 - Mini-plan files left byte-identical (read-only) — AC-5
+- **No Files, Impact, Model, or Effort** — those live only in mini-plans
 
 If the consolidator output is empty or contains `(no mini-plan files found` → abort, report error.
 
@@ -319,14 +316,18 @@ Defaults: sonnet / medium.
 
 ## Tasks
 
-{Insert the consolidated tasks from plan-consolidator verbatim, adding ONLY `Model:` and `Effort:` lines to each task. Do NOT alter T-ids, descriptions, Files, Blocked by, or conflict annotations.}
+{Insert the consolidated tasks from plan-consolidator verbatim, adding ` — model/effort` to each task line per the routing matrix. Do NOT alter T-ids, descriptions, Blocked by, or conflict annotations.}
+
+Example transformation:
+  Input:  `- [ ] **T3**: Create pkg/engine/go.mod | Blocked by: T8`
+  Output: `- [ ] **T3**: Create pkg/engine/go.mod — haiku/low | Blocked by: T8`
 
 Rules:
 - Do NOT renumber T-ids — they are already globally sequential from plan-consolidator
-- Do NOT modify Blocked by lines or conflict annotations — they are mechanical outputs
-- ONLY add Model: and Effort: lines per the routing matrix
-- Preserve all existing fields (Impact:, Optimize:, tags, etc.)
+- Do NOT modify Blocked by or conflict annotations — they are mechanical outputs
+- Insert ` — {model}/{effort}` BEFORE ` | Blocked by:` (or at end if no blocker)
 - Spike tasks keep their [SPIKE] or [OPTIMIZE] markers
+- One line per task — no sub-bullets
 ```
 
 **Post-consolidation:**
@@ -423,7 +424,16 @@ Prune stale `done-*` sections and orphaned headers. Recalculate Summary. Empty
 
 **Fan-out path:** Run ONLY after §5B consolidation is complete (AC-13). Operate on successfully planned specs only — specs whose sub-agents failed (§4.7.3) are NOT renamed and NOT appended to PLAN.md.
 
-Append tasks grouped by `### doing-{spec-name}`. Rename `specs/feature.md` → `specs/doing-feature.md` for each successfully planned spec only.
+Write PLAN.md as a **slim index** with progressive disclosure:
+- Summary table (counts)
+- Spec Gaps (from Opus output)
+- Cross-Spec Resolution narrative (from Opus output, if >1 spec)
+- Tasks grouped by `### doing-{spec-name}` with `> Details:` reference to mini-plan
+- One line per task: `- [ ] **T{N}**: desc — model/effort [| Blocked by: ...]`
+
+Files, Impact, Steps live ONLY in mini-plans (`.deepflow/plans/doing-{name}.md`).
+
+Rename `specs/feature.md` → `specs/doing-feature.md` for each successfully planned spec only.
 
 Report:
 ```