wogiflow 2.9.0 → 2.9.1

package/.claude/commands/wogi-learn.md

@@ -105,7 +105,10 @@ Use `AskUserQuestion` to let user select.
    - What was the root cause?
    - What should have been done differently?
 
-4. Propose a rule:
+4. **Auto-route via knowledge router** (NEW):
+   Run `node -e "const kr = require('wogiflow/scripts/flow-knowledge-router'); const routes = kr.detectKnowledgeRoute('[correction text]', { currentModel: process.env.CLAUDE_MODEL }); console.log(JSON.stringify(routes))"` to get routing suggestions. Use the highest-confidence route as the default option.
+
+5. Propose a rule with routing recommendation:
 
 ```
 Based on recent work, here's what I found:
@@ -114,19 +117,23 @@ Incident: [description from request-log/corrections]
 Root Cause: [analysis]
 Proposed Rule: "[rule statement]"
 
+Knowledge Router suggests: [route type] (confidence: XX%)
+
 What should we do with this learning?
 1. Create a project rule (routes to /wogi-decide flow)
 2. Fix WogiFlow product behavior (edit command/script/template)
-3. Add to feedback-patterns for monitoring first
-4. Skip — not a recurring issue
+3. Store as skill learning (auto-routes to matching skill)
+4. Add to feedback-patterns for monitoring first
+5. Skip — not a recurring issue
 ```
 
 Use `AskUserQuestion` to present options.
 
 If option 1: Invoke `/wogi-decide --from-pattern` with the proposed rule (uses streamlined path, writes to project `decisions.md`). If user cancels within the /wogi-decide sub-flow, return to wogi-learn and display "Rule creation cancelled. Pattern not promoted."
 If option 2: Apply the product-level fix directly — edit the relevant command `.md` file, script, or template. If the fix needs investigation, add to `.workflow/state/product-feedback.md`. Do NOT write to `decisions.md` (product fixes don't belong in per-project state).
-If option 3: Add to `feedback-patterns.md` Pending Patterns section with count 1.
-If option 4: No action taken.
+If option 3: Route via knowledge router: `node -e "const kr = require('wogiflow/scripts/flow-knowledge-router'); kr.storeByRoute(correction, route, context)"` — stores to the matching skill's `knowledge/learnings.md`.
+If option 4: Add to `feedback-patterns.md` Pending Patterns section with count 1.
+If option 5: No action taken.
 
 ### Mode C: Bulk Promotion
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wogiflow",
-  "version": "2.9.0",
+  "version": "2.9.1",
   "description": "AI-powered development workflow management system with multi-model support",
   "main": "lib/index.js",
   "bin": {

package/scripts/flow-health.js

@@ -714,6 +714,186 @@ function main() {
     }
   }
 
+  // Knowledge linting
+  console.log('');
+  printSection('Knowledge linting...');
+
+  // 1. Check section-index freshness
+  if (fileExists(PATHS.sectionIndex)) {
+    try {
+      const indexStat = fs.statSync(PATHS.sectionIndex);
+      const indexAge = Date.now() - indexStat.mtimeMs;
+      const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
+      if (indexAge > maxAge) {
+        const days = Math.round(indexAge / (24 * 60 * 60 * 1000));
+        warn(`section-index.json is ${days} days old — may be stale`);
+        console.log(`    ${color('dim', "→ Run 'node scripts/flow-section-index.js --force' to regenerate")}`);
+        warnings++;
+      } else {
+        success(`section-index.json is fresh`);
+      }
+    } catch (_err) {
+      warn(`Could not check section-index.json age`);
+      warnings++;
+    }
+  } else {
+    warn(`section-index.json not found — knowledge navigation unavailable`);
+    console.log(`    ${color('dim', "→ Run 'node scripts/flow-section-index.js --force' to generate")}`);
+    warnings++;
+  }
+
+  // 2. Check feedback-patterns.md for stale/duplicate entries
+  if (fileExists(PATHS.feedbackPatterns)) {
+    try {
+      const fpContent = fs.readFileSync(PATHS.feedbackPatterns, 'utf-8');
+      const fpLines = fpContent.split('\n').filter(l => l.startsWith('|') && !l.includes('---') && !l.includes('Date'));
+      const totalPatterns = fpLines.length;
+      const needsSkill = fpLines.filter(l => l.includes('#needs-skill')).length;
+      const promoted = fpLines.filter(l => l.includes('Fixed') || l.includes('Promoted')).length;
+      const stale = fpLines.filter(l => {
+        const dateMatch = l.match(/\d{4}-\d{2}-\d{2}/);
+        if (!dateMatch) return false;
+        const entryDate = new Date(dateMatch[0]);
+        const age = Date.now() - entryDate.getTime();
+        return age > 90 * 24 * 60 * 60 * 1000; // older than 90 days
+      }).length;
+
+      if (totalPatterns > 0) {
+        success(`feedback-patterns.md: ${totalPatterns} entries`);
+        if (needsSkill > totalPatterns * 0.7) {
+          warn(`${needsSkill}/${totalPatterns} entries are #needs-skill — skill gap detected`);
+          console.log(`    ${color('dim', '→ Consider creating skills for common file patterns')}`);
+          warnings++;
+        }
+        if (stale > 0) {
+          warn(`${stale} entries older than 90 days — consider archiving`);
+          warnings++;
+        }
+        if (promoted > 0) {
+          console.log(`  ${color('dim', 'ℹ')} ${promoted} patterns promoted/fixed`);
+        }
+      }
+    } catch (_err) {
+      warn(`Could not parse feedback-patterns.md`);
+      warnings++;
+    }
+  }
+
+  // 3. Check decisions.md references are still valid
+  if (fileExists(PATHS.decisions)) {
+    try {
+      const decContent = fs.readFileSync(PATHS.decisions, 'utf-8');
+      const fileRefs = decContent.match(/`[^`]*\.(js|ts|md|json)`/g) || [];
+      let orphanedRefs = 0;
+      const checkedRefs = new Set();
+
+      for (const ref of fileRefs) {
+        const filePath = ref.replace(/`/g, '');
+        if (checkedRefs.has(filePath)) continue;
+        checkedRefs.add(filePath);
+
+        // Resolve relative to project root, trying common prefixes
+        const candidates = [
+          path.join(PROJECT_ROOT, filePath),
+          path.join(PROJECT_ROOT, '.workflow', filePath),
+          path.join(PROJECT_ROOT, '.claude', filePath),
+        ];
+
+        const exists = candidates.some(c => fileExists(c));
+        if (!exists && !filePath.includes('*') && !filePath.includes('{')) {
+          orphanedRefs++;
+        }
+      }
+
+      if (orphanedRefs > 0) {
+        warn(`decisions.md has ${orphanedRefs} reference(s) to files that may no longer exist`);
+        warnings++;
+      } else if (fileRefs.length > 0) {
+        success(`decisions.md file references verified (${checkedRefs.size} checked)`);
+      }
+    } catch (_err) {
+      warn(`Could not lint decisions.md references`);
+      warnings++;
+    }
+  }
+
+  // 4. Check skill feedback loop — verify skills with learnings get loaded
+  try {
+    const skillsDir = path.join(PROJECT_ROOT, '.claude', 'skills');
+    if (dirExists(skillsDir)) {
+      const skillDirs = fs.readdirSync(skillsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && d.name !== '_template' && d.name !== 'README.md');
+
+      let skillsWithLearnings = 0;
+      for (const dir of skillDirs) {
+        const learningsPath = path.join(skillsDir, dir.name, 'knowledge', 'learnings.md');
+        if (fileExists(learningsPath)) {
+          try {
+            const content = fs.readFileSync(learningsPath, 'utf-8').trim();
+            if (content.length > 50) { // Non-empty learnings
+              skillsWithLearnings++;
+            }
+          } catch (_err) {}
+        }
+      }
+
+      const config = getConfig();
+      const loadLearnings = config.skills?.loadLearnings !== false;
+
+      if (skillsWithLearnings > 0 && !loadLearnings) {
+        warn(`${skillsWithLearnings} skill(s) have learnings but skills.loadLearnings is disabled`);
+        console.log(`    ${color('dim', '→ Set skills.loadLearnings: true in config.json to use accumulated learnings')}`);
+        warnings++;
+      } else if (skillsWithLearnings > 0) {
+        success(`${skillsWithLearnings} skill(s) with learnings — feedback loop active`);
+      } else if (skillDirs.length > 0) {
+        console.log(`  ${color('dim', 'ℹ')} ${skillDirs.length} skill(s) installed — no learnings yet`);
+      }
+    }
+  } catch (_err) {
+    // Skills directory check is non-critical
+  }
+
+  // 5. Check registry maps for orphaned file references
+  try {
+    const { getActiveRegistries, STATE_DIR: stateDir } = require('./flow-utils');
+    const registries = getActiveRegistries();
+    let totalOrphans = 0;
+    let totalChecked = 0;
+
+    for (const reg of registries) {
+      const mapPath = path.join(stateDir, reg.mapFile);
+      if (!fileExists(mapPath)) continue;
+
+      try {
+        const mapContent = fs.readFileSync(mapPath, 'utf-8');
+        // Extract file paths from markdown table rows (typically in a "File" or "Path" column)
+        const pathRefs = mapContent.match(/(?:src|lib|scripts|components|pages|app)\/[\w/.-]+\.\w+/g) || [];
+        const unique = [...new Set(pathRefs)];
+
+        for (const ref of unique) {
+          totalChecked++;
+          const fullPath = path.join(PROJECT_ROOT, ref);
+          if (!fileExists(fullPath)) {
+            totalOrphans++;
+          }
+        }
+      } catch (_err) {
+        // Skip unreadable maps
+      }
+    }
+
+    if (totalOrphans > 0) {
+      warn(`Registry maps have ${totalOrphans} orphaned file reference(s) (${totalChecked} checked)`);
+      console.log(`    ${color('dim', "→ Run 'flow registry-manager scan' to update maps")}`);
+      warnings++;
+    } else if (totalChecked > 0) {
+      success(`Registry map file references verified (${totalChecked} checked)`);
+    }
+  } catch (_err) {
+    // Registry system unavailable — skip silently
+  }
+
   // Check agents
   console.log('');
   printSection('Checking agents...');

package/scripts/flow-log-manager.js

@@ -658,12 +658,14 @@ Commands:
   archive             Force archive old entries
   search <query>      Search entries (current + archives)
   list-archives       List archive files
+  rebuild-fts         Rebuild FTS5 full-text search index from current log
   --help              Show this help
 
 Examples:
   node scripts/flow-log-manager.js status
   node scripts/flow-log-manager.js search "#component:Button"
   node scripts/flow-log-manager.js archive
+  node scripts/flow-log-manager.js rebuild-fts
 `);
 }
 
@@ -757,6 +759,42 @@ if (require.main === module) {
       break;
     }
 
+    case 'rebuild-fts': {
+      if (!memoryDb) {
+        error('Memory DB not available — FTS rebuild requires flow-memory-db');
+        process.exit(1);
+      }
+
+      printHeader('Rebuilding FTS Index');
+      const rebuildContent = fileExists(LOG_PATH) ? readFile(LOG_PATH, '') : '';
+      const allEntries = parseEntries(rebuildContent);
+      let indexed = 0;
+
+      (async () => {
+        for (const entry of allEntries) {
+          try {
+            await memoryDb.addRequestLogEntry({
+              id: entry.id,
+              type: entry.type || 'other',
+              tags: entry.tags ? entry.tags.split(/\s+/) : [],
+              request: entry.request || '',
+              result: entry.result || '',
+              files: entry.files ? entry.files.split(/,\s*/) : [],
+              taskId: null
+            });
+            indexed++;
+          } catch (_err) {
+            // Skip duplicates
+          }
+        }
+        success(`Indexed ${indexed}/${allEntries.length} entries into FTS`);
+      })().catch(err => {
+        error(`FTS rebuild failed: ${err.message}`);
+        process.exit(1);
+      });
+      break;
+    }
+
     case '--help':
     case '-h':
       printUsage();

package/scripts/flow-memory-db.js

@@ -137,6 +137,7 @@ function safeParseArray(json) {
 
 let SQL = null;
 let db = null;
+let ftsAvailable = false;
 let embedder = null;
 let initPromise = null;
 
@@ -294,6 +295,24 @@ async function initDatabase() {
       )
     `);
 
+    // FTS5 virtual table for full-text search over request log
+    // sql.js may not include FTS5 — silently skip if unavailable
+    try {
+      db.run(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS request_log_fts USING fts5(
+          request, result, tags, files,
+          content='request_log',
+          content_rowid='rowid'
+        )
+      `);
+      ftsAvailable = true;
+    } catch (_err) {
+      // FTS5 not available in this sql.js build — fall back to LIKE queries
+      if (process.env.DEBUG) {
+        console.error('[memory-db] FTS5 not available — using LIKE fallback for search');
+      }
+    }
+
     // v10.0: Observations table for automatic tool use capture
     db.run(`
       CREATE TABLE IF NOT EXISTS observations (
@@ -1307,6 +1326,18 @@ async function addRequestLogEntry(entry) {
     entry.taskId || null
   ]);
 
+  // Populate FTS index (skip if FTS5 not available to avoid exception overhead)
+  if (ftsAvailable) {
+    try {
+      db.run(`
+        INSERT INTO request_log_fts (rowid, request, result, tags, files)
+        SELECT rowid, request, result, tags, files FROM request_log WHERE id = ?
+      `, [id]);
+    } catch (_err) {
+      // FTS insert failure is non-critical
+    }
+  }
+
   saveDatabase();
   return { id, stored: true };
 }
@@ -1345,8 +1376,28 @@ async function searchRequestLog(options = {}) {
   }
 
   if (query) {
-    sql += ' AND (request LIKE ? OR result LIKE ?)';
-    params.push(`%${query}%`, `%${query}%`);
+    // Try FTS5 first for better ranking, fall back to LIKE
+    try {
+      const ftsCheck = db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name='request_log_fts'");
+      if (ftsCheck.length > 0 && ftsCheck[0].values.length > 0) {
+        // Escape FTS special characters for safety
+        const ftsQuery = query.replace(/['"]/g, '').replace(/[^\w\s#:-]/g, '').trim();
+        if (ftsQuery) {
+          sql += ' AND rowid IN (SELECT rowid FROM request_log_fts WHERE request_log_fts MATCH ?)';
+          params.push(ftsQuery);
+        } else {
+          // Sanitized query is empty — fall back to LIKE
+          sql += ' AND (request LIKE ? OR result LIKE ?)';
+          params.push(`%${query}%`, `%${query}%`);
+        }
+      } else {
+        sql += ' AND (request LIKE ? OR result LIKE ?)';
+        params.push(`%${query}%`, `%${query}%`);
+      }
+    } catch (_err) {
+      sql += ' AND (request LIKE ? OR result LIKE ?)';
+      params.push(`%${query}%`, `%${query}%`);
+    }
   }
 
   sql += ' ORDER BY timestamp DESC LIMIT ?';

package/scripts/flow-section-resolver.js

@@ -428,6 +428,51 @@ async function main() {
       console.log(JSON.stringify(stats, null, 2));
       break;
 
+    case 'browse': {
+      // Human-readable knowledge index — outputs a browsable catalog of all indexed sections
+      await ensureIndex();
+
+      const indexData = readIndex();
+      if (!indexData) {
+        console.log('No section index found. Run: node scripts/flow-section-index.js --force');
+        break;
+      }
+
+      // Index stores sections per source: { sources: { "file.md": { sections: [...] } } }
+      const bySource = {};
+      let totalSections = 0;
+      const sources = indexData.sources || {};
+      for (const [sourceName, sourceData] of Object.entries(sources)) {
+        const sects = sourceData.sections || [];
+        if (sects.length > 0) {
+          bySource[sourceName] = sects;
+          totalSections += sects.length;
+        }
+      }
+
+      console.log('╔══════════════════════════════════════════════════╗');
+      console.log('║         KNOWLEDGE INDEX (browsable)             ║');
+      console.log('╚══════════════════════════════════════════════════╝');
+      console.log(`  ${totalSections} sections indexed from ${Object.keys(bySource).length} sources\n`);
+
+      for (const [source, sects] of Object.entries(bySource)) {
+        const shortSource = source.replace(/.*\/state\//, '').replace(/.*\/specs\//, 'specs/');
+        console.log(`  ── ${shortSource} (${sects.length} sections) ──`);
+        for (const s of sects.slice(0, 20)) {
+          const pins = (s.pins || []).slice(0, 3).join(', ');
+          const title = s.title || s.id || '(untitled)';
+          console.log(`    • ${title}${pins ? ` [${pins}]` : ''}`);
+        }
+        if (sects.length > 20) {
+          console.log(`    ... and ${sects.length - 20} more`);
+        }
+        console.log('');
+      }
+
+      console.log(`Use 'find <pin>' to drill into a specific topic.`);
+      break;
+    }
+
     default:
       console.log(`
 Usage: node scripts/flow-section-resolver.js <command> [args]
@@ -437,12 +482,14 @@ Commands:
   get <section-id>     Get a section by ID
   find <pins...>       Find sections matching pins
   task "<description>" Find sections relevant to a task
+  browse               Human-readable knowledge index catalog
   stats                Show section statistics
 
 Examples:
   node scripts/flow-section-resolver.js get coding-standards:security-patterns-2026-01-11
   node scripts/flow-section-resolver.js find security error-handling
   node scripts/flow-section-resolver.js task "Add user authentication"
+  node scripts/flow-section-resolver.js browse
 `);
   }
 }

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');