wogiflow 2.9.0 → 2.10.0

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-hypothesis-generator.js

@@ -551,6 +551,64 @@ function formatHypothesisTree(tree) {
   return lines.join('\n');
 }
 
+// ============================================================
+// Hypothesis Verification Gate (v2.10)
+// ============================================================
+
+const VERIFICATION_STATE_PATH = path.join(PATHS.state, 'hypothesis-verification.json');
+
+/**
+ * Record a hypothesis verification attempt.
+ * Called by the AI during bug investigation to track the
+ * hypothesis → verify → confirm cycle.
+ *
+ * @param {object} params
+ * @param {string} params.taskId - Bug task ID
+ * @param {string} params.hypothesis - The root cause claim
+ * @param {string} params.method - Verification method: 'code-trace' | 'test' | 'data-query' | 'reproduction'
+ * @param {string} params.result - 'confirmed' | 'refuted' | 'inconclusive'
+ * @param {string} params.evidence - What was observed
+ */
+function recordHypothesisVerification({ taskId, hypothesis, method, result, evidence }) {
+  const state = readJson(VERIFICATION_STATE_PATH, { verifications: [] });
+  state.verifications.push({
+    taskId,
+    hypothesis,
+    method,
+    result,
+    evidence,
+    timestamp: new Date().toISOString()
+  });
+  writeJson(VERIFICATION_STATE_PATH, state);
+  if (result === 'confirmed') {
+    success(`Hypothesis verified (${method}): ${hypothesis}`);
+  } else if (result === 'refuted') {
+    warn(`Hypothesis refuted (${method}): ${hypothesis}`);
+  } else {
+    info(`Hypothesis inconclusive (${method}): ${hypothesis}`);
+  }
+  return state;
+}
+
+/**
+ * Check whether a hypothesis has been verified for a given task.
+ * Used by the gate to determine if "fixed" claims are allowed.
+ *
+ * @param {string} taskId
+ * @returns {{ verified: boolean, hypothesis: string|null, evidence: string|null }}
+ */
+function isHypothesisVerified(taskId) {
+  const state = readJson(VERIFICATION_STATE_PATH, { verifications: [] });
+  const confirmed = state.verifications.find(
+    v => v.taskId === taskId && v.result === 'confirmed'
+  );
+  return {
+    verified: !!confirmed,
+    hypothesis: confirmed?.hypothesis ?? null,
+    evidence: confirmed?.evidence ?? null
+  };
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -574,6 +632,11 @@ module.exports = {
   saveHypothesisTree,
   loadHypothesisTree,
 
+  // Hypothesis verification gate (v2.10)
+  VERIFICATION_STATE_PATH,
+  recordHypothesisVerification,
+  isHypothesisVerified,
+
   // Formatting
   formatHypotheses,
   formatHypothesisTree

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/flow-session-state.js

@@ -85,7 +85,8 @@ function getDefaultState() {
       tasksCompleted: 0,
       filesModified: 0,
       errorsEncountered: 0,
-      sessionCount: 0
+      sessionCount: 0,
+      sessionTasksStarted: 0  // Tasks started in THIS session (resets on new session)
     },
     lastSessionSummary: null,
     // Bypass tracking for enforcement
@@ -106,10 +107,7 @@ function getDefaultState() {
  * Returns default state if file doesn't exist or is invalid
  */
 function loadSessionState() {
-  if (!fileExists(SESSION_PATH)) {
-    return getDefaultState();
-  }
-
+  // Use try-catch only, no fileExists (prevents TOCTOU race condition)
   try {
     const state = readJson(SESSION_PATH, null);
     if (!state) return getDefaultState();
@@ -245,13 +243,44 @@ function getCliSessionId() {
  * Track task start
  */
 function trackTaskStart(taskId, taskTitle, metadata = {}) {
-  // saveSessionState already loads current state and merges
+  const current = loadSessionState();
+  const metrics = current.metrics || {};
   return saveSessionState({
     currentTask: {
       id: taskId,
       title: taskTitle,
       startedAt: new Date().toISOString(),
       ...metadata
+    },
+    metrics: {
+      ...metrics,
+      sessionTasksStarted: (metrics.sessionTasksStarted || 0) + 1
+    }
+  });
+}
+
+/**
+ * Check if this is a continuation task (2nd+ in session)
+ * Used by /wogi-start to select compressed vs full prompt.
+ * MUST be called BEFORE trackTaskStart() for the current task.
+ * @returns {boolean}
+ */
+function isContinuationTask() {
+  const state = loadSessionState();
+  return (state.metrics?.sessionTasksStarted ?? 0) >= 1;
+}
+
+/**
+ * Reset session task counter. Called by SessionStart hook
+ * to ensure the first task of a new session uses the full prompt.
+ */
+function resetSessionTaskCounter() {
+  const current = loadSessionState();
+  const metrics = current.metrics || {};
+  return saveSessionState({
+    metrics: {
+      ...metrics,
+      sessionTasksStarted: 0
     }
   });
 }
@@ -912,6 +941,8 @@ module.exports = {
 
   // Task tracking
   trackTaskStart,
+  isContinuationTask,
+  resetSessionTaskCounter,
   trackTaskComplete,
   trackTaskCompleteAsync,
   getCurrentTask,