deepflow 0.1.87 → 0.1.89

package/hooks/df-statusline.js

@@ -75,11 +75,14 @@ function buildContextMeter(contextWindow, data) {
   percentage = Math.min(100, Math.round(percentage));
 
   // Write context usage to file for deepflow commands
-  writeContextUsage(percentage);
+  writeContextUsage(percentage, data);
 
   // Write token history for instrumentation
   writeTokenHistory(contextWindow, data);
 
+  // Write cache history for cross-session persistence
+  writeCacheHistory(contextWindow, data);
+
   // Build 10-segment bar
   const segments = 10;
   const filled = Math.round((percentage / 100) * segments);
@@ -112,9 +115,10 @@ function checkForUpdate() {
   return null;
 }
 
-function writeContextUsage(percentage) {
+function writeContextUsage(percentage, data) {
   try {
-    const deepflowDir = path.join(process.cwd(), '.deepflow');
+    const baseDir = data?.workspace?.current_dir || process.cwd();
+    const deepflowDir = path.join(baseDir, '.deepflow');
     if (!fs.existsSync(deepflowDir)) {
       fs.mkdirSync(deepflowDir, { recursive: true });
     }
@@ -130,7 +134,8 @@ function writeContextUsage(percentage) {
 
 function writeTokenHistory(contextWindow, data) {
   try {
-    const deepflowDir = path.join(process.cwd(), '.deepflow');
+    const baseDir = data?.workspace?.current_dir || process.cwd();
+    const deepflowDir = path.join(baseDir, '.deepflow');
     if (!fs.existsSync(deepflowDir)) {
       fs.mkdirSync(deepflowDir, { recursive: true });
     }
@@ -142,6 +147,9 @@ function writeTokenHistory(contextWindow, data) {
     const contextWindowSize = contextWindow.context_window_size || 0;
     const usedPercentage = contextWindow.used_percentage || 0;
 
+    const agentRole = process.env.DEEPFLOW_AGENT_ROLE || 'orchestrator';
+    const taskId = process.env.DEEPFLOW_TASK_ID || null;
+
     const record = {
       timestamp,
       input_tokens: usage.input_tokens || 0,
@@ -150,7 +158,9 @@ function writeTokenHistory(contextWindow, data) {
       context_window_size: contextWindowSize,
       used_percentage: usedPercentage,
       model,
-      session_id: sessionId
+      session_id: sessionId,
+      agent_role: agentRole,
+      task_id: taskId
     };
 
     const tokenHistoryPath = path.join(deepflowDir, 'token-history.jsonl');
@@ -159,3 +169,65 @@ function writeTokenHistory(contextWindow, data) {
     // Fail silently
   }
 }
+
+function writeCacheHistory(contextWindow, data) {
+  try {
+    const usage = contextWindow.current_usage || {};
+    const sessionId = data.session_id || 'unknown';
+
+    const inputTokens = usage.input_tokens || 0;
+    const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+    const cacheReadTokens = usage.cache_read_input_tokens || 0;
+    const totalTokens = inputTokens + cacheCreationTokens + cacheReadTokens;
+
+    // Compute cache hit ratio: cache_read / total
+    const cacheHitRatio = totalTokens > 0 ? cacheReadTokens / totalTokens : 0;
+
+    const model = data.model?.id || data.model?.display_name || 'unknown';
+    const agentRole = process.env.DEEPFLOW_AGENT_ROLE || 'orchestrator';
+    const taskId = process.env.DEEPFLOW_TASK_ID || null;
+
+    const cacheHistoryPath = path.join(os.homedir(), '.claude', 'cache-history.jsonl');
+
+    // Dedup: only write if session_id differs from last written record
+    let lastSessionId = null;
+    if (fs.existsSync(cacheHistoryPath)) {
+      const content = fs.readFileSync(cacheHistoryPath, 'utf8');
+      const lines = content.trimEnd().split('\n');
+      if (lines.length > 0) {
+        try {
+          const lastRecord = JSON.parse(lines[lines.length - 1]);
+          lastSessionId = lastRecord.session_id;
+        } catch (e) {
+          // Ignore parse errors on last line
+        }
+      }
+    }
+
+    if (sessionId === lastSessionId) {
+      return;
+    }
+
+    const record = {
+      timestamp: new Date().toISOString(),
+      session_id: sessionId,
+      cache_hit_ratio: Math.round(cacheHitRatio * 10000) / 10000,
+      total_tokens: totalTokens,
+      agent_breakdown: {
+        agent_role: agentRole,
+        task_id: taskId,
+        model
+      }
+    };
+
+    // Ensure ~/.claude directory exists
+    const claudeDir = path.join(os.homedir(), '.claude');
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    }
+
+    fs.appendFileSync(cacheHistoryPath, JSON.stringify(record) + '\n');
+  } catch (e) {
+    // Fail silently
+  }
+}

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

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Spike hook: capture raw PostToolUse stdin payload
+ * Writes the raw JSON to /tmp/df-posttooluse-payload.json for inspection.
+ * Safe to install temporarily — exits cleanly (code 0) always.
+ *
+ * Usage in ~/.claude/settings.json:
+ *   "PostToolUse": [{ "hooks": [{ "type": "command", "command": "node /path/to/df-tool-usage-spike.js" }] }]
+ */
+
+'use strict';
+
+const fs = require('fs');
+
+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);
+});

package/hooks/df-tool-usage.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * deepflow tool usage logger
+ * Logs every PostToolUse event to ~/.claude/tool-usage.jsonl for token instrumentation.
+ * Exits silently (code 0) on all errors — never breaks tool execution.
+ *
+ * Output record fields (REQ-2):
+ *   timestamp, session_id, tool_name, command, output_size_est_tokens,
+ *   project, phase, task_id
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const TOOL_USAGE_LOG = path.join(os.homedir(), '.claude', 'tool-usage.jsonl');
+
+/**
+ * Infer phase from cwd.
+ * If cwd contains .deepflow/worktrees/, parse the worktree dir name for phase.
+ * Worktree dirs are named "execute", "verify", or task-specific names.
+ * Default: "manual"
+ */
+function inferPhase(cwd) {
+  if (!cwd) return 'manual';
+  const match = cwd.match(/\.deepflow[/\\]worktrees[/\\]([^/\\]+)/);
+  if (!match) return 'manual';
+  const worktreeName = match[1].toLowerCase();
+  if (worktreeName === 'execute') return 'execute';
+  if (worktreeName === 'verify') return 'verify';
+  // Could be a task-specific worktree — still inside worktrees/, treat as execute
+  return 'execute';
+}
+
+/**
+ * Extract task_id from worktree directory name.
+ * Pattern: T{n} prefix, e.g. "T3-feature" → "T3", "T12" → "T12"
+ * Returns null if not in a worktree or no task prefix found.
+ */
+function extractTaskId(cwd) {
+  if (!cwd) return null;
+  const match = cwd.match(/\.deepflow[/\\]worktrees[/\\]([^/\\]+)/);
+  if (!match) return null;
+  const worktreeName = match[1];
+  const taskMatch = worktreeName.match(/^(T\d+)/i);
+  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 || '';
+
+    const record = {
+      timestamp: new Date().toISOString(),
+      session_id: data.session_id || null,
+      tool_name: toolName,
+      command: (toolName === 'Bash' && data.tool_input && data.tool_input.command != null)
+        ? data.tool_input.command
+        : null,
+      output_size_est_tokens: Math.ceil(JSON.stringify(toolResponse).length / 4),
+      project: cwd ? path.basename(cwd) : null,
+      phase: inferPhase(cwd),
+      task_id: extractTaskId(cwd),
+    };
+
+    const logDir = path.dirname(TOOL_USAGE_LOG);
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+
+    fs.appendFileSync(TOOL_USAGE_LOG, JSON.stringify(record) + '\n');
+  } catch (_e) {
+    // Fail silently — never break tool execution
+  }
+  process.exit(0);
+});

package/hooks/df-worktree-guard.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * deepflow worktree guard
+ * PostToolUse hook: blocks Write/Edit to main-branch files when a df/* worktree exists.
+ *
+ * REQ-3 AC-4: exit(1) to block the tool call when all conditions hold:
+ *   1. tool_name is Write or Edit
+ *   2. current branch is main (or master)
+ *   3. a df/* worktree branch exists
+ *   4. file_path is NOT on the allowlist (.deepflow/, PLAN.md, specs/)
+ *
+ * REQ-3 AC-5: allowlisted paths always pass through (no false positives).
+ *
+ * Exits silently (code 0) on parse errors or git failures — never breaks tool
+ * execution in non-deepflow projects.
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+
+// Paths that are always allowed regardless of worktree state
+const ALLOWLIST = [
+  /(?:^|\/)\.deepflow\//,
+  /(?:^|\/)PLAN\.md$/,
+  /(?:^|\/)specs\//,
+];
+
+function isAllowlisted(filePath) {
+  return ALLOWLIST.some(re => re.test(filePath));
+}
+
+function currentBranch(cwd) {
+  try {
+    return execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      encoding: 'utf8',
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch (_) {
+    return null;
+  }
+}
+
+function dfWorktreeExists(cwd) {
+  try {
+    const out = execFileSync('git', ['branch', '--list', 'df/*'], {
+      encoding: 'utf8',
+      cwd,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out.trim().length > 0;
+  } catch (_) {
+    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);
+    }
+
+    const filePath = (data.tool_input && data.tool_input.file_path) || '';
+    const cwd = data.cwd || process.cwd();
+
+    // Allowlisted paths always pass
+    if (isAllowlisted(filePath)) {
+      process.exit(0);
+    }
+
+    const branch = currentBranch(cwd);
+
+    // Only guard when on main/master
+    if (branch !== 'main' && branch !== 'master') {
+      process.exit(0);
+    }
+
+    // Block only when a df/* worktree branch exists
+    if (!dfWorktreeExists(cwd)) {
+      process.exit(0);
+    }
+
+    // All conditions met — block the write
+    console.error(
+      `[df-worktree-guard] Blocked ${toolName} to "${filePath}" on main branch ` +
+      `while df/* worktree exists. Make changes inside the worktree branch instead.`
+    );
+    process.exit(1);
+  } catch (_e) {
+    // Parse or unexpected error — fail open so we never break non-deepflow projects
+    process.exit(0);
+  }
+});

package/package.json

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