wogiflow 2.8.0 → 2.9.1

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

@@ -21,6 +21,7 @@ const fs = require('node:fs');
 const { getConfig, PATHS, safeJsonParse, writeJson, withLock, validateTaskId, archiveCompletedTasksToLog } = require('../../flow-utils');
 const { resetPhase, isPhaseGateEnabled } = require('./phase-gate');
 const { clearOnTaskComplete } = require('../../flow-hook-status');
+const { checkGateLatch, clearGateLatch } = require('../../flow-gate-latch');
 
 /**
  * Check if task completed handling is enabled
@@ -90,6 +91,22 @@ async function handleTaskCompleted(input) {
       }
       result.taskId = completedTask.id;
 
+      // Gate latch check — verify quality gates have passed before allowing completion.
+      // Without this, agents can call TaskUpdate and bypass all quality gates.
+      // The latch is written by flow-done.js after gates pass.
+      const config = getConfig();
+      const requireGateLatch = config.enforcement?.requireGateLatch !== false;
+      if (requireGateLatch) {
+        const latchResult = checkGateLatch(completedTask.id);
+        if (!latchResult.valid) {
+          result.message = `BLOCKED: ${latchResult.reason} ` +
+            'Quality gates must pass before a task can be completed. ' +
+            'Run the full /wogi-start pipeline (Step 4: Quality Gates) or `flow done` first.';
+          result.gateBlocked = true;
+          return;
+        }
+      }
+
       // Move task to recentlyCompleted
       completedTask.status = 'completed';
       completedTask.completedAt = new Date().toISOString();
@@ -158,6 +175,15 @@ async function handleTaskCompleted(input) {
       }
     }
 
+    // Clear gate latch after successful completion
+    if (result.completed) {
+      try {
+        clearGateLatch();
+      } catch (_err) {
+        // Non-critical
+      }
+    }
+
     // Clear progress tracker state on task completion
     if (result.completed) {
       try {
@@ -285,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/postinstall.js

@@ -928,6 +928,26 @@ function main() {
   // so the correct hooks are already in place when stale ones are removed.
   migrateStaleLocalHooks();
 
+  // Migrate config.json defaults when they change between versions.
+  // Without this, existing users keep stale defaults forever because
+  // deepMerge(defaults, userConfig) lets user values win.
+  // Only upgrades keys that still match the OLD default — user-customized values are preserved.
+  try {
+    const configPath = path.join(WORKFLOW_DIR, 'config.json');
+    if (fs.existsSync(configPath)) {
+      const { migrateConfigFile } = require('./flow-config-migrate');
+      const migrationResult = migrateConfigFile(configPath);
+      if (migrationResult.migrated && !shouldBeSilent()) {
+        process.stderr.write(`\x1b[36mWogiFlow:\x1b[0m Migrated config (v${migrationResult.fromVersion} → v${migrationResult.toVersion}): ${migrationResult.applied.length} change(s).\n`);
+      }
+    }
+  } catch (err) {
+    // Non-fatal — config migration should never fail installation
+    if (process.env.DEBUG) {
+      console.error(`[postinstall] Config migration failed: ${err.message}`);
+    }
+  }
+
   // NOTE: Scripts and .workflow/ managed dirs (bridges, templates, agents, lib) are
   // NO LONGER copied to the project. They live exclusively in the wogiflow package
   // under node_modules/wogiflow/. This keeps user projects clean.