wogiflow 2.1.3 → 2.3.0

package/scripts/hooks/core/post-compact.js

@@ -8,13 +8,21 @@
  *
  * Purpose: Restore critical state that may have been lost during compaction.
  * - Re-inject durable session context (current task, completed steps, remaining work)
- * - Re-inject active decisions and routing state
+ * - Re-inject acceptance criteria with completion status
+ * - Re-inject changed files and last request-log entry
  * - Ensure routing-pending flag is set (compaction = new context, needs re-routing)
  *
  * This hook is non-blocking (fail-open). Compaction should never be prevented
  * by a state restoration failure.
+ *
+ * v2.0: Hoisted shared requires, added criteria/files/log restoration,
+ *       fixed criteria done status to read from scenarios.completed[]
  */
 
+const path = require('node:path');
+const fs = require('node:fs');
+const { PATHS, safeJsonParse, getReadyData } = require('../../flow-utils');
+
 /**
  * Sanitize a string value before injecting into AI context.
  * Strips markdown heading markers and truncates to prevent prompt manipulation.
@@ -65,7 +73,6 @@ function handlePostCompact() {
 
   // 2. Check for active task in ready.json (fallback if no durable session)
   try {
-    const { getReadyData } = require('../../flow-utils');
     const readyData = getReadyData();
     if (Array.isArray(readyData.inProgress) && readyData.inProgress.length > 0) {
       const task = readyData.inProgress[0];
@@ -82,6 +89,77 @@ function handlePostCompact() {
     }
   }
 
+  // 2b. Load acceptance criteria and changed files from task checkpoint
+  try {
+    const checkpointPath = path.join(PATHS.state, 'task-checkpoint.json');
+    const checkpoint = safeJsonParse(checkpointPath, null);
+    if (checkpoint && checkpoint.taskId) {
+      // Inject acceptance criteria with completion status
+      // Derive done status from scenarios.completed[] (the authoritative source)
+      // rather than criteria[].done (which is never updated after initialization)
+      const completedIndices = new Set(
+        (checkpoint.scenarios?.completed || []).map(s => s.index)
+      );
+
+      if (Array.isArray(checkpoint.criteria) && checkpoint.criteria.length > 0) {
+        const criteriaLines = checkpoint.criteria.slice(0, 15).map((c, i) => {
+          const isDone = completedIndices.has(i);
+          const status = isDone ? '✓' : '○';
+          return `  ${status} ${sanitize(c.text || c.description || c.id, 120)}`;
+        });
+        const done = checkpoint.criteria.filter((_, i) => completedIndices.has(i)).length;
+        contextParts.push(`**Acceptance Criteria** (${done}/${checkpoint.criteria.length} done):\n${criteriaLines.join('\n')}`);
+      }
+
+      // Inject changed files list
+      if (Array.isArray(checkpoint.changedFiles) && checkpoint.changedFiles.length > 0) {
+        const files = checkpoint.changedFiles.slice(0, 20).map(f => `  - ${sanitize(f, 100)}`);
+        contextParts.push(`**Changed files this session** (${checkpoint.changedFiles.length}):\n${files.join('\n')}`);
+      }
+    }
+
+    // Fallback: get changed files from git if checkpoint doesn't have them
+    if (!checkpoint || !checkpoint.changedFiles || checkpoint.changedFiles.length === 0) {
+      try {
+        const { execFileSync } = require('node:child_process');
+        const gitFiles = execFileSync('git', ['diff', '--name-only', 'HEAD'], {
+          encoding: 'utf-8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        if (gitFiles) {
+          const files = gitFiles.split('\n').filter(Boolean).slice(0, 20);
+          contextParts.push(`**Uncommitted changes** (${files.length} files):\n${files.map(f => `  - ${f}`).join('\n')}`);
+        }
+      } catch (_err) {
+        // git not available or no changes — skip silently
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[post-compact] Criteria/files restore failed: ${err.message}`);
+    }
+  }
+
+  // 2c. Load last request-log entry number
+  try {
+    const logPath = path.join(PATHS.state, 'request-log.md');
+    if (fs.existsSync(logPath)) {
+      const content = fs.readFileSync(logPath, 'utf-8');
+      // Find the last R-NNN entry
+      const matches = content.match(/^### R-(\d+)/gm);
+      if (matches && matches.length > 0) {
+        const lastEntry = matches[0]; // First match = most recent (file is reverse-chronological)
+        const num = lastEntry.match(/R-(\d+)/)?.[1];
+        if (num) {
+          contextParts.push(`**Last request-log entry**: R-${num} (next entry should be R-${parseInt(num, 10) + 1})`);
+        }
+      }
+    }
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(`[post-compact] Request-log read failed: ${err.message}`);
+    }
+  }
+
   // 3. Re-set routing-pending flag
   // After compaction, the AI has fresh context and may try to act without routing.
   // Setting routing-pending ensures the next tool use goes through routing checks.
@@ -99,8 +177,6 @@ function handlePostCompact() {
 
   // 4. Load current workflow phase
   try {
-    const { PATHS, safeJsonParse } = require('../../flow-utils');
-    const path = require('node:path');
     const phasePath = path.join(PATHS.state, 'workflow-phase.json');
     const phaseData = safeJsonParse(phasePath, {});
     if (phaseData.phase && phaseData.phase !== 'idle') {
@@ -116,9 +192,6 @@ function handlePostCompact() {
   // Claude Code stops auto-compaction after 3 consecutive failures.
   // If we detect repeated compactions in quick succession, warn about potential issues.
   try {
-    const path = require('node:path');
-    const fs = require('node:fs');
-    const { PATHS, safeJsonParse } = require('../../flow-utils');
     const compactStatePath = path.join(PATHS.state, '.compact-tracker.json');
     const tracker = safeJsonParse(compactStatePath, { count: 0, lastAt: null });
     const now = Date.now();
@@ -136,7 +209,7 @@ function handlePostCompact() {
     fs.writeFileSync(compactStatePath, JSON.stringify(tracker, null, 2));
 
     if (tracker.count >= 3) {
-      contextParts.push('**WARNING**: Multiple compactions detected in quick succession. Claude Code 2.1.76+ stops auto-compaction after 3 consecutive failures. If context keeps growing, consider starting a new session or committing progress and using `/wogi-pre-compact`.');
+      contextParts.push('**WARNING**: Multiple compactions detected in quick succession. Claude Code 2.1.76+ stops auto-compaction after 3 consecutive failures. If context keeps growing, consider starting a new session.');
     }
   } catch (err) {
     if (process.env.DEBUG) {

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

@@ -93,6 +93,12 @@ async function handleTaskCompleted(input) {
       completedTask.status = 'completed';
       completedTask.completedAt = new Date().toISOString();
 
+      // Strip progress prefix from title (e.g., "[3/5] Title" → "Title")
+      // Done inside the lock to avoid race conditions with progress tracker
+      if (completedTask.title) {
+        completedTask.title = completedTask.title.replace(/^\[\d+\/\d+\]\s*/, '');
+      }
+
       // Remove from inProgress
       ready.inProgress = ready.inProgress.filter(t =>
         (typeof t === 'string' ? t : t.id) !== completedTask.id
@@ -140,6 +146,19 @@ async function handleTaskCompleted(input) {
       }
     }
 
+    // Clear progress tracker state on task completion
+    if (result.completed) {
+      try {
+        const { clearProgress } = require('../../flow-progress-tracker');
+        clearProgress();
+      } catch (err) {
+        // Non-fatal — progress tracker may not exist in older installs
+        if (process.env.DEBUG) {
+          console.error(`[Task Completed] Progress clear failed: ${err.message}`);
+        }
+      }
+    }
+
     // Update durable history if it exists (under lock to prevent concurrent corruption)
     if (result.completed) {
       try {

package/scripts/hooks/entry/claude-code/post-tool-use.js

@@ -113,6 +113,26 @@ async function main() {
               if (process.env.DEBUG) console.error(`[post-tool-use] setCurrentTask: ${err.message}`);
             }
 
+            // v7.0: Initialize task checkpoint with criteria for PostCompact recovery
+            try {
+              const { saveCheckpoint } = require('../../../flow-task-checkpoint');
+              const criteriaList = (task.acceptanceCriteria || task.scenarios || [])
+                .map((c, i) => ({
+                  id: `ac-${i + 1}`,
+                  text: typeof c === 'string' ? c : (c.description || c.title || `Criterion ${i + 1}`),
+                  done: false
+                }));
+              await saveCheckpoint({
+                taskId,
+                taskTitle,
+                currentPhase: 'coding',
+                criteria: criteriaList,
+                changedFiles: []
+              });
+            } catch (err) {
+              if (process.env.DEBUG) console.error(`[post-tool-use] Checkpoint init: ${err.message}`);
+            }
+
             if (process.env.DEBUG) {
               console.error(`[post-tool-use] Initialized durable session for ${taskId} (prompt-path bridge)`);
             }
@@ -126,6 +146,31 @@ async function main() {
       }
     }
 
+    // Auto registry scan after successful git commit (fire-and-forget)
+    // v7.0: Mechanical enforcement — AI no longer needs to remember to run registry scan.
+    // Runs after every commit, regardless of task level (L3 included).
+    if (toolName === 'Bash' && toolInput.command && !toolFailed) {
+      const { isGitCommit } = require('../../core/commit-log-gate');
+      if (isGitCommit(toolInput.command)) {
+        try {
+          const { RegistryManager } = require('../../../flow-registry-manager');
+          const manager = new RegistryManager();
+          manager.loadPlugins();
+          manager.activatePlugins();
+          manager.scanAll().catch((err) => {
+            if (process.env.DEBUG) {
+              console.error(`[post-tool-use] Auto registry scan failed: ${err.message}`);
+            }
+          });
+        } catch (err) {
+          // Non-blocking — registry manager may not be available
+          if (process.env.DEBUG) {
+            console.error(`[post-tool-use] Registry manager load error: ${err.message}`);
+          }
+        }
+      }
+    }
+
     // Only run validation for Edit/Write
     if (toolName !== 'Edit' && toolName !== 'Write') {
       console.log(JSON.stringify({ continue: true }));
@@ -140,6 +185,21 @@ async function main() {
       return;
     }
 
+    // v7.0: Track changed files in task checkpoint (continuous state persistence)
+    // This ensures the PostCompact hook can restore the changed files list
+    // after auto-compaction, making /wogi-pre-compact redundant for file tracking.
+    if (filePath && !filePath.includes('.workflow/') && !filePath.includes('.claude/')) {
+      try {
+        const { trackChangedFile } = require('../../../flow-task-checkpoint');
+        trackChangedFile(filePath);
+      } catch (err) {
+        // Non-blocking — checkpoint may not exist yet (no active task)
+        if (process.env.DEBUG) {
+          console.error(`[post-tool-use] File tracking: ${err.message}`);
+        }
+      }
+    }
+
     // Run validation
     const coreResult = await runValidation({
       filePath,

package/scripts/hooks/entry/claude-code/pre-tool-use.js

@@ -17,6 +17,7 @@ const { checkComponentReuse } = require('../../core/component-check');
 const { checkTodoWriteGate } = require('../../core/todowrite-gate');
 const { checkRoutingGate, clearRoutingPending, hasActiveTask } = require('../../core/routing-gate');
 const { checkPhaseGate } = require('../../core/phase-gate');
+const { checkCommitLogGate } = require('../../core/commit-log-gate');
 const { claudeCodeAdapter } = require('../../adapters/claude-code');
 const { markSkillPending } = require('../../../flow-durable-session');
 const { getConfig } = require('../../../flow-utils');
@@ -242,6 +243,32 @@ async function main() {
       }
     }
 
+    // Commit log gate check (for Bash git commit commands)
+    // v9.0: Block git commit when active task has no request-log entry staged.
+    // Same mechanical enforcement pattern as routing gate.
+    if (toolName === 'Bash' && toolInput.command) {
+      try {
+        const commitLogResult = checkCommitLogGate(toolInput.command, config);
+        if (commitLogResult.blocked) {
+          coreResult = {
+            allowed: false,
+            blocked: true,
+            reason: `Commit log gate: ${commitLogResult.reason}`,
+            message: commitLogResult.message
+          };
+          const output = claudeCodeAdapter.transformResult('PreToolUse', coreResult);
+          console.log(JSON.stringify(output));
+          process.exit(0);
+          return;
+        }
+      } catch (err) {
+        // Fail-open for commit log gate — don't block work if gate has issues
+        if (process.env.DEBUG) {
+          console.error(`[Hook] Commit log gate error (fail-open): ${err.message}`);
+        }
+      }
+    }
+
     // Strict adherence check (for Bash commands)
     // v5.0: Block AI from using wrong package manager or port
     if (toolName === 'Bash') {

package/scripts/registries/component-registry.js

@@ -290,10 +290,147 @@ class ComponentScanner extends BaseScanner {
   }
 
   generateMap() {
-    // Component registry generates component-index.json only.
-    // It does NOT overwrite app-map.md — that remains human-curated.
-    // The index is complementary: auto-generated for machine use.
-    success(`Component index available at ${path.relative(PROJECT_ROOT, INDEX_PATH)}`);
+    const MAP_PATH = path.join(STATE_DIR, 'app-map.md');
+
+    // Check if app-map.md exists and has content
+    let existing = '';
+    try {
+      existing = fs.readFileSync(MAP_PATH, 'utf-8');
+    } catch (_err) {
+      // File doesn't exist — will create
+    }
+
+    // Use marker to distinguish auto-generated from human-curated
+    const AUTO_MARKER = '<!-- AUTO-GENERATED BY COMPONENT SCANNER -->';
+    const isAutoGenerated = existing.includes(AUTO_MARKER);
+    const hasContent = existing.split('\n').filter(l => l.startsWith('|')).length > 5;
+
+    if (hasContent && !isAutoGenerated) {
+      // Human-curated content — merge without overwriting
+      this._mergeIntoAppMap(MAP_PATH, existing);
+      return;
+    }
+
+    // Generate fresh app-map.md from scan results
+    const lines = [
+      '# App Map',
+      '',
+      AUTO_MARKER,
+      '',
+      'Component and page registry. **Check before creating anything new.**',
+      '',
+      '> Auto-generated by component scanner. Edit to add context.',
+      '',
+      '---',
+      ''
+    ];
+
+    // Group components by category
+    const categories = {};
+    for (const comp of this.registry.components) {
+      const cat = comp.category || 'uncategorized';
+      if (!categories[cat]) categories[cat] = [];
+      categories[cat].push(comp);
+    }
+
+    // Components section
+    if (this.registry.components.length > 0) {
+      lines.push('## Components', '');
+
+      for (const cat of Object.keys(categories).sort()) {
+        const catName = cat.charAt(0).toUpperCase() + cat.slice(1);
+        lines.push(`### ${catName}`, '');
+        lines.push('| Component | File | Description |');
+        lines.push('|-----------|------|-------------|');
+
+        for (const comp of categories[cat].sort((a, b) => a.name.localeCompare(b.name))) {
+          const desc = comp.description || '-';
+          lines.push(`| \`${comp.name}\` | \`${comp.file}\` | ${desc} |`);
+        }
+        lines.push('');
+      }
+    }
+
+    // Hooks section
+    if (this.registry.hooks.length > 0) {
+      lines.push('## Hooks', '');
+      lines.push('| Hook | File | Description |');
+      lines.push('|------|------|-------------|');
+
+      for (const hook of this.registry.hooks.sort((a, b) => a.name.localeCompare(b.name))) {
+        const desc = hook.description || '-';
+        lines.push(`| \`${hook.name}\` | \`${hook.file}\` | ${desc} |`);
+      }
+      lines.push('');
+    }
+
+    lines.push('---', '');
+    lines.push('## Rules', '');
+    lines.push('1. **Before creating** → Search this file');
+    lines.push('2. **If similar exists** → Add variant, don\'t create new');
+    lines.push('3. **After creating** → Run `flow registry-manager scan` to update');
+    lines.push('');
+
+    fs.writeFileSync(MAP_PATH, lines.join('\n'));
+    success(`Generated ${path.relative(PROJECT_ROOT, MAP_PATH)} (${this.registry.components.length} components, ${this.registry.hooks.length} hooks)`);
+  }
+
+  /**
+   * Merge scanner results into existing app-map.md without overwriting curated content.
+   * Adds only components not already present.
+   */
+  _mergeIntoAppMap(mapPath, existing) {
+    // Path containment check (defense-in-depth)
+    if (!mapPath.startsWith(STATE_DIR)) {
+      warn('Write target outside state directory — skipping merge');
+      return;
+    }
+
+    // Extract names already in app-map (with or without backticks)
+    const existingNames = new Set();
+    const nameRegex = /\|\s*`?(\w+)`?\s*\|/g;
+    let m;
+    while ((m = nameRegex.exec(existing)) !== null) {
+      existingNames.add(m[1]);
+    }
+
+    // Find new components not in app-map
+    const newComponents = this.registry.components.filter(c => !existingNames.has(c.name));
+    const newHooks = this.registry.hooks.filter(h => !existingNames.has(h.name));
+
+    if (newComponents.length === 0 && newHooks.length === 0) {
+      info(`app-map.md is up to date (${existingNames.size} entries)`);
+      return;
+    }
+
+    // Remove existing "## Auto-Discovered" section if present (prevent duplicates)
+    const autoDiscoveredIdx = existing.indexOf('\n## Auto-Discovered');
+    const base = autoDiscoveredIdx !== -1 ? existing.substring(0, autoDiscoveredIdx) : existing;
+
+    const additions = ['\n## Auto-Discovered (new entries)', ''];
+
+    if (newComponents.length > 0) {
+      additions.push('### Components', '');
+      additions.push('| Component | File | Description |');
+      additions.push('|-----------|------|-------------|');
+      for (const comp of newComponents.sort((a, b) => a.name.localeCompare(b.name))) {
+        additions.push(`| \`${comp.name}\` | \`${comp.file}\` | ${comp.description || '-'} |`);
+      }
+      additions.push('');
+    }
+
+    if (newHooks.length > 0) {
+      additions.push('### Hooks', '');
+      additions.push('| Hook | File | Description |');
+      additions.push('|------|------|-------------|');
+      for (const hook of newHooks.sort((a, b) => a.name.localeCompare(b.name))) {
+        additions.push(`| \`${hook.name}\` | \`${hook.file}\` | ${hook.description || '-'} |`);
+      }
+      additions.push('');
+    }
+
+    fs.writeFileSync(mapPath, base + additions.join('\n'));
+    success(`Merged ${newComponents.length} components + ${newHooks.length} hooks into app-map.md`);
   }
 }