wogiflow 2.9.0 → 2.10.0

package/scripts/flow-standards-gate.js

@@ -15,7 +15,8 @@ const {
   readFile,
   safeJsonParse,
   getConfig,
-  color
+  color,
+  isPathWithinProject
 } = require('./flow-utils');
 
 const {
@@ -56,9 +57,9 @@ function loadTaskContext(taskId) {
     return null;
   }
 
-  // Load spec if available
+  // Load spec if available (validate path is within project for defense-in-depth)
   let spec = null;
-  if (task.specPath && fileExists(task.specPath)) {
+  if (task.specPath && isPathWithinProject(path.resolve(task.specPath)) && fileExists(task.specPath)) {
     spec = readFile(task.specPath, '');
   }
 
@@ -245,9 +246,33 @@ function runTaskStandardsCheck(taskContext, files, options = {}) {
     preventionPrompts = standardsLearner.getPreventionPrompts(taskType, files.map(f => f.path));
   }
 
+  // Constructor-to-test-mock drift detection
+  // Runs on any task that changes service/controller files
+  let constructorMockDrift = null;
+  const changedFilePaths = files.map(f => f.path);
+  const hasServiceFiles = changedFilePaths.some(f =>
+    /\.(service|controller|guard|interceptor|resolver|middleware|provider)\./i.test(f)
+  );
+
+  if (hasServiceFiles) {
+    constructorMockDrift = checkConstructorMockDrift(changedFilePaths);
+    if (constructorMockDrift.driftDetected) {
+      // Add drift violations to the main violations list
+      for (const drift of constructorMockDrift.drifts) {
+        results.violations.push({
+          type: 'constructor-mock-drift',
+          file: drift.sourceFile,
+          message: `Constructor changed but test mock not updated: ${drift.testFile} missing mocks for [${drift.missingInTest.join(', ')}]`,
+          severity: drift.severity,
+          suggestion: `Update the test file's mock providers to include: ${drift.missingInTest.join(', ')}`
+        });
+      }
+    }
+  }
+
   return {
     ...results,
-    blocked: shouldBlock,
+    blocked: mode === 'block' && (shouldBlock || (constructorMockDrift?.driftDetected ?? false)),
     mode,
     taskType,
     taskId: taskContext?.id,
@@ -257,7 +282,8 @@ function runTaskStandardsCheck(taskContext, files, options = {}) {
     reuseCandidateContext,
     aiAsJudge,
     learningResults,
-    preventionPrompts
+    preventionPrompts,
+    constructorMockDrift
   };
 }
 
@@ -504,6 +530,112 @@ Examples:
   process.exit(results.blocked ? 1 : 0);
 }
 
+// ============================================================================
+// Constructor-to-Test-Mock Drift Detection
+// ============================================================================
+
+/**
+ * Detect constructor signature changes in diff and verify corresponding test
+ * mock/provider setups match the new signature.
+ *
+ * When a constructor adds/removes dependency injection parameters, the test
+ * mock providers must be updated too. This check identifies the drift.
+ *
+ * Source: Backend mistake #4 — constructor changes forgotten in tests 6 times.
+ *
+ * @param {string[]} changedFiles - List of changed file paths
+ * @returns {{ driftDetected: boolean, drifts: Object[], message: string }}
+ */
+function checkConstructorMockDrift(changedFiles) {
+  const drifts = [];
+
+  for (const filePath of changedFiles) {
+    // Only check TypeScript service/controller files (not test files themselves)
+    if (!/\.(ts|tsx)$/.test(filePath)) continue;
+    if (/\.spec\.|\.test\.|__tests__/.test(filePath)) continue;
+    if (!/\.(service|controller|guard|interceptor|resolver|middleware|provider)\./i.test(filePath)) continue;
+
+    // Read the file to find constructor parameters
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf-8');
+    } catch (_err) {
+      continue;
+    }
+
+    // Extract constructor parameters
+    const constructorMatch = content.match(/constructor\s*\(([\s\S]*?)\)\s*\{/);
+    if (!constructorMatch) continue;
+
+    const params = constructorMatch[1]
+      .split(',')
+      .map(p => p.trim())
+      .filter(p => p.length > 0)
+      .map(p => {
+        // Extract parameter name and type: "private readonly userService: UserService"
+        const parts = p.replace(/^(private|protected|public|readonly)\s+/g, '').trim();
+        const nameMatch = parts.match(/(\w+)\s*:/);
+        return nameMatch ? nameMatch[1] : parts.split(/\s/)[0];
+      })
+      .filter(Boolean);
+
+    if (params.length === 0) continue;
+
+    // Find corresponding test file(s)
+    const dir = path.dirname(filePath);
+    const baseName = path.basename(filePath, path.extname(filePath));
+    const possibleTestFiles = [
+      path.join(dir, `${baseName}.spec.ts`),
+      path.join(dir, `${baseName}.test.ts`),
+      path.join(dir, '__tests__', `${baseName}.spec.ts`),
+      path.join(dir, '__tests__', `${baseName}.test.ts`)
+    ];
+
+    for (const testPath of possibleTestFiles) {
+      let testContent;
+      try {
+        testContent = fs.readFileSync(testPath, 'utf-8');
+      } catch (_err) {
+        continue; // Test file doesn't exist — separate concern
+      }
+
+      // Check if test has providers/mocks for each constructor param
+      const missingMocks = [];
+      for (const param of params) {
+        // Look for the parameter name in providers array or mock setup
+        // Common patterns: { provide: ParamType, useValue: ... }
+        //                   ParamType as jest.Mocked<ParamType>
+        //                   mock(ParamType)
+        const paramPattern = new RegExp(param, 'i');
+        if (!paramPattern.test(testContent)) {
+          missingMocks.push(param);
+        }
+      }
+
+      if (missingMocks.length > 0) {
+        drifts.push({
+          sourceFile: filePath,
+          testFile: testPath,
+          constructorParams: params,
+          missingInTest: missingMocks,
+          severity: 'must-fix'
+        });
+      }
+    }
+  }
+
+  return {
+    driftDetected: drifts.length > 0,
+    drifts,
+    message: drifts.length > 0
+      ? `Constructor-to-test-mock drift detected in ${drifts.length} file(s). ` +
+        drifts.map(d =>
+          `${d.sourceFile} → ${d.testFile}: missing mocks for [${d.missingInTest.join(', ')}]`
+        ).join('; ')
+      : 'No constructor-mock drift detected'
+  };
+}
+
 // ============================================================================
 // Exports
 // ============================================================================
@@ -513,6 +645,7 @@ module.exports = {
   extractFilesToChange,
   inferTaskType,
   runTaskStandardsCheck,
+  checkConstructorMockDrift,
   formatViolationsForRetry,
   formatReuseCandidatesForAI,
   hasPassedStandards,

package/scripts/flow-statusline-setup.js

@@ -40,11 +40,17 @@ const FORMATS = {
   },
   detailed: {
     name: 'Detailed',
-    description: 'Full info including skill',
-    format: '{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}% used{{#if skill}} | {{skill}}{{/if}}'
+    description: 'Full info including skill and worktree',
+    format: '{{#if workspace.git_worktree}}[WT] {{/if}}{{#if task}}[{{task.id}}] {{task.title}} | {{/if}}{{model}} | {{context_window.used_percentage}}% used{{#if skill}} | {{skill}}{{/if}}'
   }
 };
 
+// Default refresh interval (seconds) — re-runs status line every N seconds
+// so live values like task.id, context_window, and skill stay current.
+// Available in Claude Code 2.1.97+. 0 disables auto-refresh.
+const DEFAULT_REFRESH_INTERVAL = 5;
+const MAX_REFRESH_INTERVAL = 3600;
+
 // Claude settings file location
 const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
 
@@ -71,6 +77,41 @@ function saveClaudeSettings(settings) {
   }
 }
 
+/**
+ * Parse and validate a refresh interval string.
+ * Returns the integer value, or null if invalid.
+ * Accepts 0 (disable) through MAX_REFRESH_INTERVAL.
+ */
+function parseRefreshInterval(arg) {
+  if (arg === undefined || arg === null || arg === '') return null;
+  const n = Number(arg);
+  if (!Number.isInteger(n) || n < 0 || n > MAX_REFRESH_INTERVAL) return null;
+  return n;
+}
+
+/**
+ * Build a statusLine config that preserves any existing fields the caller
+ * isn't explicitly overriding. This prevents `--format X` from wiping out
+ * a user's previously-configured refreshInterval (and vice versa).
+ *
+ * `refreshInterval` semantics:
+ *   - undefined → don't touch existing value
+ *   - 0         → delete the field (disable auto-refresh)
+ *   - N > 0     → set to N seconds
+ */
+function buildStatusLine(existing, { format, refreshInterval } = {}) {
+  const next = { ...(existing || {}), enabled: true };
+  if (format !== undefined) next.format = format;
+  if (refreshInterval !== undefined) {
+    if (refreshInterval === 0) {
+      delete next.refreshInterval;
+    } else {
+      next.refreshInterval = refreshInterval;
+    }
+  }
+  return next;
+}
+
 function showCurrentConfig() {
   const settings = loadClaudeSettings();
   const statusLine = settings.statusLine || {};
@@ -82,6 +123,11 @@ function showCurrentConfig() {
   } else if (statusLine.format) {
     console.log(`${colors.dim}Status: ${colors.green}Enabled${colors.reset}`);
     console.log(`${colors.dim}Format:${colors.reset} ${statusLine.format}`);
+    if (statusLine.refreshInterval) {
+      console.log(`${colors.dim}Refresh:${colors.reset} every ${statusLine.refreshInterval}s ${colors.dim}(Claude Code 2.1.97+)${colors.reset}`);
+    } else {
+      console.log(`${colors.dim}Refresh:${colors.reset} ${colors.yellow}off${colors.reset} ${colors.dim}(updates on prompt only)${colors.reset}`);
+    }
   } else {
     console.log(`${colors.dim}Status: ${colors.yellow}Not configured${colors.reset}`);
   }
@@ -120,13 +166,29 @@ async function interactiveSetup() {
     process.exit(1);
   }
 
+  const refreshAnswer = await question(
+    `\nAuto-refresh interval in seconds (0 = off, blank = ${DEFAULT_REFRESH_INTERVAL}, requires Claude Code 2.1.97+): `
+  );
+  let refreshInterval;
+  if (refreshAnswer.trim() === '') {
+    refreshInterval = DEFAULT_REFRESH_INTERVAL;
+  } else {
+    refreshInterval = parseRefreshInterval(refreshAnswer.trim());
+    if (refreshInterval === null) {
+      errorMsg(`Refresh interval must be an integer between 0 and ${MAX_REFRESH_INTERVAL}`);
+      rl.close();
+      process.exit(1);
+    }
+  }
+
   const settings = loadClaudeSettings();
-  settings.statusLine = {
-    enabled: true,
-    format: FORMATS[selectedFormat].format
-  };
+  settings.statusLine = buildStatusLine(settings.statusLine, {
+    format: FORMATS[selectedFormat].format,
+    refreshInterval
+  });
 
-  const confirm = await question(`\nApply "${FORMATS[selectedFormat].name}" format? (y/N): `);
+  const refreshLabel = refreshInterval === 0 ? 'no auto-refresh' : `refresh every ${refreshInterval}s`;
+  const confirm = await question(`\nApply "${FORMATS[selectedFormat].name}" format with ${refreshLabel}? (y/N): `);
 
   if (confirm.toLowerCase() === 'y') {
     if (saveClaudeSettings(settings)) {
@@ -151,21 +213,31 @@ Wogi Flow - Status Line Setup
 Configure Claude Code's status line to show task and context info.
 
 Usage:
-  flow statusline-setup             Interactive setup
-  flow statusline-setup --format X  Set format directly
-  flow statusline-setup --show      Show current config
-  flow statusline-setup --disable   Disable status line
-  flow statusline-setup --formats   List available formats
+  flow statusline-setup                    Interactive setup
+  flow statusline-setup --format X         Set format directly
+  flow statusline-setup --refresh-interval N
+                                           Set auto-refresh interval (seconds, 0 to disable)
+  flow statusline-setup --show             Show current config
+  flow statusline-setup --disable          Disable status line
+  flow statusline-setup --formats          List available formats
 
 Formats:
   minimal   - Model + context %
   compact   - Task ID + model + context %
   standard  - Task ID + model + labeled context (recommended)
-  detailed  - Full info including skill name
+  detailed  - Worktree + task + model + context % + skill
+
+Refresh interval (Claude Code 2.1.97+):
+  Re-runs the status line every N seconds so live values like task ID,
+  context %, and active skill stay current between prompts.
+  Default when configured via this tool: ${DEFAULT_REFRESH_INTERVAL}s. Range: 0–${MAX_REFRESH_INTERVAL}.
+  0 disables auto-refresh (status line only updates on prompt).
 
 Examples:
   flow statusline-setup --format standard
-  flow statusline-setup --format detailed
+  flow statusline-setup --format detailed --refresh-interval 5
+  flow statusline-setup --refresh-interval 10
+  flow statusline-setup --refresh-interval 0
 `);
     process.exit(0);
   }
@@ -182,13 +254,29 @@ Examples:
 
   if (args.includes('--disable')) {
     const settings = loadClaudeSettings();
-    settings.statusLine = { enabled: false };
+    settings.statusLine = { ...(settings.statusLine || {}), enabled: false };
     if (saveClaudeSettings(settings)) {
       success('Status line disabled.');
     }
     process.exit(0);
   }
 
+  // Parse --refresh-interval (may be combined with --format, or used alone)
+  const refreshIndex = args.indexOf('--refresh-interval');
+  let cliRefreshInterval;
+  if (refreshIndex >= 0) {
+    const refreshArg = args[refreshIndex + 1];
+    if (refreshArg === undefined || refreshArg.startsWith('--')) {
+      errorMsg('--refresh-interval requires a value (integer between 0 and ' + MAX_REFRESH_INTERVAL + ')');
+      process.exit(1);
+    }
+    cliRefreshInterval = parseRefreshInterval(refreshArg);
+    if (cliRefreshInterval === null) {
+      errorMsg(`--refresh-interval must be an integer between 0 and ${MAX_REFRESH_INTERVAL}`);
+      process.exit(1);
+    }
+  }
+
   const formatIndex = args.indexOf('--format');
   if (formatIndex >= 0) {
     const format = args[formatIndex + 1];
@@ -198,18 +286,47 @@ Examples:
     }
 
     const settings = loadClaudeSettings();
-    settings.statusLine = {
-      enabled: true,
-      format: FORMATS[format].format
-    };
+    settings.statusLine = buildStatusLine(settings.statusLine, {
+      format: FORMATS[format].format,
+      refreshInterval: cliRefreshInterval
+    });
 
     if (saveClaudeSettings(settings)) {
-      success(`Status line configured with "${format}" format.`);
+      let refreshNote;
+      if (cliRefreshInterval !== undefined) {
+        refreshNote = cliRefreshInterval === 0 ? ' (auto-refresh off)' : ` (refresh every ${cliRefreshInterval}s)`;
+      } else if (settings.statusLine.refreshInterval) {
+        refreshNote = ` (refresh every ${settings.statusLine.refreshInterval}s preserved)`;
+      } else {
+        refreshNote = '';
+      }
+      success(`Status line configured with "${format}" format${refreshNote}.`);
       console.log(`${colors.dim}Restart Claude Code to see changes.${colors.reset}`);
     }
     process.exit(0);
   }
 
+  // Standalone --refresh-interval (no --format) — update only the interval
+  if (cliRefreshInterval !== undefined) {
+    const settings = loadClaudeSettings();
+    if (!settings.statusLine || !settings.statusLine.format) {
+      errorMsg('No status line is configured yet. Run with --format <name> first, or use interactive setup.');
+      process.exit(1);
+    }
+    settings.statusLine = buildStatusLine(settings.statusLine, {
+      refreshInterval: cliRefreshInterval
+    });
+    if (saveClaudeSettings(settings)) {
+      success(
+        cliRefreshInterval === 0
+          ? 'Status line auto-refresh disabled.'
+          : `Status line refresh interval set to ${cliRefreshInterval}s.`
+      );
+      console.log(`${colors.dim}Requires Claude Code 2.1.97+. Restart Claude Code to see changes.${colors.reset}`);
+    }
+    process.exit(0);
+  }
+
   // Default: interactive mode
   await interactiveSetup();
 }

package/scripts/hooks/core/task-completed.js

@@ -311,6 +311,83 @@ async function handleTaskCompleted(input) {
     // Workspace notifications are handled by the Stop hook (via HTTP to manager port).
     // Removed duplicate file-based notification here to prevent double messages (finding-004).
 
+    // Compound from success — capture positive patterns (fire-and-forget)
+    if (result.completed) {
+      try {
+        const config = getConfig();
+        if (config.skillLearning?.enabled) {
+          const { writeToFeedbackPatterns } = require('../../flow-learning-orchestrator');
+          const taskType = completedTask.type || 'unknown';
+          const changedFiles = input.changedFiles || [];
+          const criteriaCount = input.scenarioCount || completedTask.criteria || 0;
+          const firstPass = input.firstAttemptPass !== false;
+
+          // Only record success patterns for non-trivial tasks that passed on first attempt
+          if (firstPass && changedFiles.length >= 2 && criteriaCount >= 2) {
+            const today = new Date().toISOString().split('T')[0];
+            const filesSummary = changedFiles.slice(0, 5).map(f => path.basename(f)).join(', ');
+            const entryText = `success-pattern: ${taskType} task (${criteriaCount} criteria, ${changedFiles.length} files) completed first-pass. Files: ${filesSummary}`;
+            const tableRow = `| ${today} | ${entryText} | 1 | - | #success |`;
+
+            writeToFeedbackPatterns({
+              content: tableRow,
+              entryText,
+              caller: 'task-completed-success',
+            }).catch(() => {
+              // Non-critical
+            });
+          }
+        }
+      } catch (_err) {
+        // Non-critical — success pattern capture may not be available
+      }
+    }
+
+    // Skill learning extraction (fire-and-forget)
+    if (result.completed) {
+      try {
+        const { isLearningEnabled, extractLearningContext, matchFilesToSkills, appendLearning, discoverSkills, ensureKnowledgeDir, formatSemanticChanges } = require('../../flow-skill-learn');
+        const config = getConfig();
+        if (isLearningEnabled(config, 'task')) {
+          const changedFiles = input.changedFiles || [];
+          if (changedFiles.length > 0) {
+            const skills = discoverSkills();
+            const { matches: skillMap } = matchFilesToSkills(changedFiles, skills);
+            const context = extractLearningContext(changedFiles, 'task');
+
+            // Enrich context with task info
+            context.summary = `Task ${completedTask.id}: ${completedTask.title || ''}`;
+            context.taskType = completedTask.type || 'unknown';
+
+            for (const [skillName, matchedFiles] of skillMap) {
+              if (matchedFiles.length > 0) {
+                const skill = skills.find(s => s.name === skillName);
+                const skillDir = skill?.path;
+                if (skillDir) {
+                  ensureKnowledgeDir(skillDir);
+                  const entry = [
+                    `### ${context.summary}`,
+                    `**Type**: ${context.type} | **Trigger**: task-complete`,
+                    `**Files**: ${matchedFiles.join(', ')}`,
+                  ];
+                  if (context.semanticChanges.length > 0) {
+                    entry.push(`**Changes**: ${formatSemanticChanges(context.semanticChanges).slice(0, 200)}`);
+                  }
+                  entry.push('');
+                  appendLearning(skillDir, entry.join('\n'));
+                }
+              }
+            }
+          }
+        }
+      } catch (_err) {
+        // Non-critical — skill learning may not be available
+        if (process.env.DEBUG) {
+          console.error(`[Task Completed] Skill learning failed: ${_err.message}`);
+        }
+      }
+    }
+
     // Check pending queue — notify user if items are waiting
     try {
       const { getPendingCount } = require('../../flow-pending');

package/scripts/hooks/entry/claude-code/session-start.js

@@ -8,7 +8,7 @@
  */
 
 const { gatherSessionContext } = require('../../core/session-context');
-const { setCliSessionId, clearStaleCurrentTaskAsync } = require('../../../flow-session-state');
+const { setCliSessionId, clearStaleCurrentTaskAsync, resetSessionTaskCounter } = require('../../../flow-session-state');
 const { checkAndResetStalePhase } = require('../../core/phase-gate');
 const { setRoutingPending } = require('../../core/routing-gate');
 const { getConfig } = require('../../../flow-utils');
@@ -97,6 +97,13 @@ runHook('SessionStart', async ({ parsedInput }) => {
     }
   }
 
+  // Reset session task counter so first task uses full prompt
+  try {
+    resetSessionTaskCounter();
+  } catch (_err) {
+    // Non-blocking
+  }
+
   try {
     const routingResult = setRoutingPending();
     if (process.env.DEBUG) {