wogiflow 2.26.2 → 2.29.1

package/scripts/flow-session-end.js

@@ -25,7 +25,7 @@ const {
   isGitRepo,
   getGitStatus,
   safeJsonParse,
-  getTodayDate
+  _getTodayDate
 } = require('./flow-utils')
 const { color, printSection, success, warn, error } = require('./flow-output');;
 
@@ -774,6 +774,64 @@ function showContextHealthSummary() {
   }
 }
 
+// B7 (wf-c3b5afab): Surface gate missRate telemetry at session-end so users
+// see rubber-stamping risk without running /wogi-gate-stats. Pulls from the
+// existing getGateStats() API — no duplicated computation or thresholds.
+const MISS_RATE_THRESHOLD = 0.10;
+const MISS_WATCH_WINDOW = '7d';
+const MISS_WATCH_TOP_N = 3;
+
+function loadGateStats() {
+  let getGateStats;
+  try {
+    ({ getGateStats } = require('./flow-gate-telemetry'));
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] Gate telemetry: ${err.message}`);
+    return null;
+  }
+  try {
+    return getGateStats({ since: MISS_WATCH_WINDOW });
+  } catch (err) {
+    if (process.env.DEBUG) console.error(`[DEBUG] Gate telemetry stats: ${err.message}`);
+    return null;
+  }
+}
+
+function printGateTelemetryWatch(stats = loadGateStats()) {
+  console.log('');
+  console.log(color('yellow', 'Gate Telemetry — Miss Rate Watch (7d):'));
+
+  const perGate = stats && stats.perGate ? stats.perGate : null;
+  const gates = perGate ? Object.keys(perGate) : [];
+  if (!perGate || gates.length === 0) {
+    console.log(`  ${color('dim', 'No telemetry yet (baseline)')}`);
+    return;
+  }
+
+  const ranked = gates
+    .map(id => ({ id, ...perGate[id] }))
+    .filter(g => g.verdicts && g.verdicts.PASS > 0)
+    .sort((a, b) => b.missRate - a.missRate)
+    .slice(0, MISS_WATCH_TOP_N);
+
+  if (ranked.length === 0) {
+    console.log(`  ${color('dim', 'No PASS events yet — miss rate unmeasurable')}`);
+    return;
+  }
+
+  for (const g of ranked) {
+    const pct = (g.missRate * 100).toFixed(1);
+    const flagged = g.missRate >= MISS_RATE_THRESHOLD;
+    const line = `  ${g.id}: miss ${pct}% (${g.missedAfterPass}/${g.verdicts.PASS} PASS events)`;
+    if (flagged) {
+      console.log(color('red', `${line}  ← rubber-stamping risk`));
+    } else {
+      console.log(line);
+    }
+  }
+  console.log(`  ${color('dim', 'Threshold: miss rate ≥ 10% flags a gate as rubber-stamping. See /wogi-gate-stats for full table.')}`);
+}
+
 /**
  * v1.8.0: Automatic memory management
  * Part of automatic memory management for teams
@@ -1346,6 +1404,9 @@ async function main() {
   // v1.7.0: Show context health
   showContextHealthSummary();
 
+  // B7 (wf-c3b5afab): Surface gate miss-rate watch — rubber-stamping visibility
+  printGateTelemetryWatch();
+
   // v1.8.0: Automatic memory management
   await automaticMemoryManagement();
 
@@ -1376,7 +1437,15 @@ async function main() {
   showSummary();
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+if (require.main === module) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  printGateTelemetryWatch,
+  MISS_RATE_THRESHOLD,
+  MISS_WATCH_TOP_N,
+};

package/scripts/flow-session-state.js

@@ -94,7 +94,11 @@ function getDefaultState() {
       count: 0,           // Number of bypasses in this session
       attempts: [],       // Array of bypass attempt details
       autoCreatedTasks: [] // Tasks that were auto-created (bypasses)
-    }
+    },
+    // Autonomous walk-away mode (Story C / wf-d712002e)
+    // active=true means the AI commits to running the queue without interrupting
+    // until it drains, the user sends "stop"/"pause", or the staleness threshold trips.
+    autonomousMode: null
   };
 }
 
@@ -915,6 +919,93 @@ if (require.main === module) {
   }
 }
 
+// ============================================================
+// Autonomous Mode (Story C / wf-d712002e)
+// ============================================================
+//
+// Disk is canonical (survives SIGTERM at task-boundary-reset); cache is read-hot.
+// Hot-path hooks (PreToolUse) MUST use the cache; never re-read the disk file.
+
+const DEFAULT_AUTONOMOUS_STALENESS_MS = 60 * 60 * 1000;
+
+let autonomousModeCache = undefined;
+
+function getAutonomousConfig() {
+  const cfg = getConfig().autonomousMode || {};
+  return {
+    stalenessThresholdMs: cfg.stalenessThresholdMs ?? DEFAULT_AUTONOMOUS_STALENESS_MS,
+    maxAdversaryInvocations: cfg.maxAdversaryInvocations ?? 30,
+    maxQueueSize: cfg.maxQueueSize ?? 100
+  };
+}
+
+function activateAutonomousMode({ trigger } = {}) {
+  const runId = `auto-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+  const record = {
+    active: true,
+    activatedAt: new Date().toISOString(),
+    trigger: trigger || 'unspecified',
+    runId,
+    adversaryInvocations: { used: 0, breakdown: { autonomousLowConfidence: 0, igrArchitect: 0, manual: 0 } }
+  };
+  saveSessionState({ autonomousMode: record });
+  autonomousModeCache = record;
+  return record;
+}
+
+function deactivateAutonomousMode() {
+  saveSessionState({ autonomousMode: null });
+  autonomousModeCache = null;
+}
+
+function getAutonomousMode() {
+  if (autonomousModeCache !== undefined) return autonomousModeCache;
+  const state = loadSessionState();
+  autonomousModeCache = state.autonomousMode || null;
+  return autonomousModeCache;
+}
+
+function isAutonomousActive() {
+  const mode = getAutonomousMode();
+  return Boolean(mode && mode.active);
+}
+
+function isAutonomousStale(mode = getAutonomousMode()) {
+  if (!mode || !mode.activatedAt) return false;
+  const ageMs = Date.now() - new Date(mode.activatedAt).getTime();
+  return ageMs > getAutonomousConfig().stalenessThresholdMs;
+}
+
+function rehydrateAutonomousFromDisk() {
+  autonomousModeCache = undefined;
+  const mode = getAutonomousMode();
+  if (mode && mode.active && isAutonomousStale(mode)) {
+    deactivateAutonomousMode();
+    return { hydrated: false, reason: 'stale', staleMode: mode };
+  }
+  return { hydrated: Boolean(mode && mode.active), mode };
+}
+
+function incrementAdversaryInvocation(source = 'manual') {
+  const mode = getAutonomousMode();
+  if (!mode || !mode.active) return { allowed: true, used: 0, cap: 0 };
+  const cap = getAutonomousConfig().maxAdversaryInvocations;
+  const used = (mode.adversaryInvocations?.used ?? 0) + 1;
+  const breakdown = { ...(mode.adversaryInvocations?.breakdown || {}) };
+  const key = source === 'igr' ? 'igrArchitect'
+    : source === 'lowConfidence' ? 'autonomousLowConfidence'
+    : 'manual';
+  breakdown[key] = (breakdown[key] || 0) + 1;
+  const updated = { ...mode, adversaryInvocations: { used, breakdown } };
+  saveSessionState({ autonomousMode: updated });
+  autonomousModeCache = updated;
+  return { allowed: used <= cap, used, cap };
+}
+
+function _resetAutonomousCacheForTests() {
+  autonomousModeCache = undefined;
+}
+
 // ============================================================
 // Exports
 // ============================================================
@@ -979,6 +1070,17 @@ module.exports = {
   getBypassSummary,
   clearBypassTracking,
 
+  // Autonomous mode (Story C / wf-d712002e)
+  activateAutonomousMode,
+  deactivateAutonomousMode,
+  getAutonomousMode,
+  isAutonomousActive,
+  isAutonomousStale,
+  rehydrateAutonomousFromDisk,
+  incrementAdversaryInvocation,
+  getAutonomousConfig,
+  _resetAutonomousCacheForTests,
+
   // Path
   SESSION_PATH
 };

package/scripts/flow-setup-hooks.js

@@ -18,7 +18,7 @@ const path = require('node:path');
 const {
   getProjectRoot: _getProjectRoot,
   getConfig, PATHS,
-  getTodayDate
+  _getTodayDate
 } = require('./flow-utils')
 const { color, success, warn, error } = require('./flow-output');;
 

package/scripts/flow-skeptical-evaluator.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Skeptical Evaluator (wf-15175dbc / B5).
+ *
+ * Validating-phase agent that reads the spec + delivery, then forces the AI
+ * through a field-by-field enumeration before letting a "done" claim stand.
+ *
+ * The evaluator composes a prompt with three enumeration passes:
+ *   1. UI-field enumeration  — for every modified UI surface, list every
+ *      input/select/textarea/custom field. Reuses the B3 template schema.
+ *   2. API-parameter enumeration — for every touched endpoint, list every
+ *      request/response field.
+ *   3. State-key enumeration — for every touched state file or config key,
+ *      list every entry.
+ *
+ * For each enumerated item, the evaluator demands a Tier classification
+ * (reuse flow-completion-truth-gate EVIDENCE_TIERS) and a confidencePct
+ * per the 95/85/75 rubric (wf-f14dcfeb / A4).
+ *
+ * Composition flow (orchestrator calls this, then invokes Agent tool with the prompt):
+ *   const { buildSkepticalPrompt, parseSkepticalOutput } = require('./flow-skeptical-evaluator');
+ *   const prompt = buildSkepticalPrompt({ specMarkdown, diffText, changedFiles, taskId });
+ *   // ... orchestrator invokes Agent tool with prompt ...
+ *   const result = parseSkepticalOutput(agentResponse, { taskId });
+ *
+ * Story: wf-15175dbc (B5)
+ * Epic: wf-34290000
+ */
+
+const path = require('node:path');
+
+const { PATHS } = require('./flow-paths');
+const { getConfig } = require('./flow-config-loader');
+const {
+  parseBELItems,
+  extractSpecStrings,
+  verifyBELAgainstDelivery,
+  verifySpecBundleCoverage,
+} = require('./flow-completion-truth-gate');
+
+const TEMPLATE_PATH = path.join(PATHS.workflow, 'templates', 'tier3-dom-field-inventory.md');
+
+function _isDisabled() {
+  const cfg = getConfig();
+  const igr = cfg.intentGroundedReasoning || {};
+  if (igr.enabled === false) return { disabled: true, reason: 'igr-disabled' };
+  const se = igr.skepticalEvaluator || {};
+  if (se.enabled === false) return { disabled: true, reason: 'skeptical-evaluator-disabled' };
+  return { disabled: false };
+}
+
+/**
+ * Build the system + user prompt for the skeptical evaluator sub-agent.
+ *
+ * @param {object} opts
+ * @param {string} opts.specMarkdown - spec file content
+ * @param {string} opts.diffText - git diff
+ * @param {string[]} [opts.changedFiles]
+ * @param {string} [opts.commitMessage]
+ * @param {string} [opts.taskId]
+ * @param {string} [opts.bundleText] - built-bundle text if available
+ * @returns {{ systemPrompt: string, userPrompt: string, preChecks: object, metadata: object }}
+ */
+function buildSkepticalPrompt(opts) {
+  if (!opts || typeof opts !== 'object') throw new TypeError('buildSkepticalPrompt: opts required');
+  if (typeof opts.specMarkdown !== 'string') throw new TypeError('buildSkepticalPrompt: specMarkdown required');
+
+  const dis = _isDisabled();
+  if (dis.disabled) {
+    return { systemPrompt: '', userPrompt: '', preChecks: {}, metadata: { skipped: true, reason: dis.reason, taskId: opts.taskId || null } };
+  }
+
+  const { specMarkdown, diffText = '', changedFiles = [], commitMessage = '', taskId = '', bundleText = '' } = opts;
+
+  // Run the mechanical pre-checks so the evaluator is grounded in data, not vibes.
+  const bel = verifyBELAgainstDelivery({ specMarkdown, diffText, changedFiles, commitMessage });
+  const bundle = verifySpecBundleCoverage({ specMarkdown, diffText, changedFiles, bundleText });
+  const belItems = parseBELItems(specMarkdown);
+  const specStrings = extractSpecStrings(specMarkdown);
+
+  const systemPrompt = [
+    '# Skeptical Evaluator',
+    '',
+    'You are the Skeptical Evaluator for WogiFlow\'s validating phase. Your job is to force field-by-field enumeration before a task can be marked "done". Your baseline stance: the claim is unverified until you see every field enumerated and classified.',
+    '',
+    '## Inputs you receive',
+    '',
+    '- The task spec (markdown)',
+    '- The unified diff',
+    '- Changed file paths',
+    '- Commit message (if any)',
+    '- Mechanical pre-check results from `flow-completion-truth-gate` (BEL grep, spec-bundle grep)',
+    '',
+    '## Mandatory enumeration passes',
+    '',
+    '### Pass 1 — UI-field enumeration',
+    'For every modified UI surface (form, filter, wizard, settings panel):',
+    '- List every `<input>`, `<select>`, `<textarea>`, or custom input component by its `name` / `data-testid`.',
+    '- For each: label, type, default, required, validation, visibility condition.',
+    '- Compare to the spec\'s AC. Flag vanished / modified / added fields.',
+    '',
+    'If no UI surfaces touched, state explicitly: "UI-field pass: N/A — no UI files modified."',
+    'Reference template: `' + path.relative(process.cwd(), TEMPLATE_PATH) + '`.',
+    '',
+    '### Pass 2 — API-parameter enumeration',
+    'For every touched API endpoint (request handler, route, or client call):',
+    '- List every request parameter (query, path, body field).',
+    '- List every response field.',
+    '- Compare to the spec\'s AC. Flag additions / removals / type changes.',
+    '',
+    'If no API work touched, state explicitly: "API-parameter pass: N/A."',
+    '',
+    '### Pass 3 — State-key enumeration',
+    'For every touched state file (JSON, YAML, TOML, .env) or config key:',
+    '- List every top-level key and each nested key the change introduces / removes.',
+    '- Compare to the spec\'s AC.',
+    '',
+    'If no state-file work touched, state explicitly: "State-key pass: N/A."',
+    '',
+    '## Evidence tier + confidence tier on every claim',
+    '',
+    'For every enumerated item you classify as preserved/modified/added/vanished, attach:',
+    '- `evidenceTier`: 0–4 per `scripts/flow-runtime-verification.js` EVIDENCE_TIERS',
+    '- `confidencePct`: exactly 95, 85, or 75 per `.workflow/rubrics/confidence-tiers.md`',
+    '- `evidenceNote`: one-line citation (file:line, grep result, or observation)',
+    '',
+    'Confidence 75 automatically flags the claim `UNVERIFIED`. Do not upgrade without evidence.',
+    '',
+    '## Output contract',
+    '',
+    'Return ONE JSON object with shape:',
+    '```json',
+    '{',
+    '  "taskId": "<id>",',
+    '  "uiFieldPass": { "ran": true|false, "reason": "...", "findings": [...] },',
+    '  "apiParameterPass": { ... },',
+    '  "stateKeyPass": { ... },',
+    '  "overallVerdict": "PASS" | "CONCERN" | "FAIL",',
+    '  "blockers": ["one string per blocking issue"],',
+    '  "unverifiedClaims": ["one string per claim at confidence 75"]',
+    '}',
+    '```',
+    '',
+    'No prose. No markdown fences around the JSON. Just the object.',
+  ].join('\n');
+
+  const userPrompt = [
+    '# Inputs',
+    '',
+    `- Task ID: ${taskId || '<unknown>'}`,
+    `- Changed files (${changedFiles.length}): ${changedFiles.slice(0, 20).join(', ')}${changedFiles.length > 20 ? ', ...' : ''}`,
+    '',
+    '## Spec',
+    '```markdown',
+    _truncate(specMarkdown, 12000),
+    '```',
+    '',
+    '## Unified diff',
+    '```',
+    _truncate(diffText, 12000),
+    '```',
+    '',
+    '## Commit message',
+    '```',
+    _truncate(commitMessage, 2000),
+    '```',
+    '',
+    '## Mechanical pre-checks (from flow-completion-truth-gate)',
+    '',
+    '### BEL grep',
+    `- items parsed: ${belItems.length}`,
+    `- ok: ${bel.ok}`,
+    `- uncovered: ${bel.uncoveredItems.length}`,
+    bel.uncoveredItems.length ? `- uncovered samples: ${bel.uncoveredItems.slice(0, 5).map((u) => u.text).join(' | ')}` : '',
+    '',
+    '### Spec-bundle coverage',
+    `- ok: ${bundle.ok}`,
+    ..._bundleSummaryLines(bundle),
+    '',
+    '## Extracted spec strings (reference)',
+    `- backtickIds (${specStrings.backtickIds.length}): ${specStrings.backtickIds.slice(0, 8).join(', ')}`,
+    `- filePaths (${specStrings.filePaths.length}): ${specStrings.filePaths.slice(0, 8).join(', ')}`,
+    `- constants (${specStrings.constants.length}): ${specStrings.constants.slice(0, 8).join(', ')}`,
+    `- routes (${specStrings.routes.length}): ${specStrings.routes.slice(0, 8).join(', ')}`,
+    '',
+    '## Your task',
+    '',
+    'Run the three enumeration passes described in the system prompt. Return the JSON object. Be skeptical — force a verdict on every field.',
+  ].filter(Boolean).join('\n');
+
+  return {
+    systemPrompt,
+    userPrompt,
+    preChecks: { bel, bundle, belItems, specStrings },
+    metadata: { taskId: taskId || null, changedFileCount: changedFiles.length },
+  };
+}
+
+function _truncate(text, cap) {
+  const s = String(text || '');
+  return s.length > cap ? s.slice(0, cap) + `\n\n[... truncated at ${cap} chars]` : s;
+}
+
+function _bundleSummaryLines(bundle) {
+  const out = [];
+  for (const [cat, v] of Object.entries(bundle.coverage || {})) {
+    if (v.total === 0) continue;
+    out.push(`  - ${cat}: ${v.hit}/${v.total} (need ${v.threshold.toFixed(2)})`);
+    if (v.missing && v.missing.length > 0) out.push(`      missing: ${v.missing.slice(0, 4).join(', ')}`);
+  }
+  return out;
+}
+
+/**
+ * Parse the sub-agent's JSON response.
+ * @param {string} response
+ * @param {object} [ctx]
+ * @returns {object}
+ */
+function parseSkepticalOutput(response, ctx = {}) {
+  if (typeof response !== 'string' || response.trim().length === 0) {
+    return { ok: false, reason: 'empty response', overallVerdict: 'FAIL' };
+  }
+  let parsed;
+  try {
+    // Try raw
+    parsed = JSON.parse(response);
+  } catch (_err) {
+    // Try extracting JSON object
+    const m = response.match(/\{[\s\S]*\}/);
+    if (!m) return { ok: false, reason: 'no JSON object found', overallVerdict: 'FAIL' };
+    try {
+      parsed = JSON.parse(m[0]);
+    } catch (err) {
+      return { ok: false, reason: `JSON parse failed: ${err.message}`, overallVerdict: 'FAIL' };
+    }
+  }
+  if (!parsed || typeof parsed !== 'object') {
+    return { ok: false, reason: 'response is not an object', overallVerdict: 'FAIL' };
+  }
+  const verdict = parsed.overallVerdict || 'FAIL';
+  return {
+    ok: verdict === 'PASS',
+    overallVerdict: verdict,
+    uiFieldPass: parsed.uiFieldPass || { ran: false },
+    apiParameterPass: parsed.apiParameterPass || { ran: false },
+    stateKeyPass: parsed.stateKeyPass || { ran: false },
+    blockers: Array.isArray(parsed.blockers) ? parsed.blockers : [],
+    unverifiedClaims: Array.isArray(parsed.unverifiedClaims) ? parsed.unverifiedClaims : [],
+    taskId: parsed.taskId || ctx.taskId || null,
+  };
+}
+
+module.exports = {
+  buildSkepticalPrompt,
+  parseSkepticalOutput,
+  TEMPLATE_PATH,
+};
+
+if (require.main === module) {
+  const cmd = process.argv[2];
+  if (cmd === 'prompt') {
+    const specFile = process.argv[3];
+    if (!specFile) { console.error('usage: flow-skeptical-evaluator prompt <spec.md>'); process.exit(2); }
+    const fs = require('node:fs');
+    const specMarkdown = fs.readFileSync(specFile, 'utf8');
+    const built = buildSkepticalPrompt({ specMarkdown, diffText: '', changedFiles: [], taskId: 'cli' });
+    console.log('--- SYSTEM ---\n' + built.systemPrompt + '\n--- USER ---\n' + built.userPrompt);
+  } else {
+    console.error('usage: flow-skeptical-evaluator prompt <spec.md>');
+    process.exit(2);
+  }
+}

package/scripts/flow-skill-generator.js

@@ -229,7 +229,7 @@ async function fetchDocsViaContext7(technology) {
 // SKILL FILE GENERATION
 // ============================================
 
-function generateSkillMd(tech, docs) {
+function _generateSkillMd(tech, docs) {
   const date = getTodayDate();
 
   return `---
@@ -595,7 +595,7 @@ This skill is loaded on-demand when:
  * v2.0 format includes: type, ecosystem, loadWith, tokenCost
  */
 function generateSkillsIndex(technologies, selections) {
-  const { getSkillType, getParentFramework, ECOSYSTEMS } = getTechOptions();
+  const { getSkillType, getParentFramework, _ECOSYSTEMS } = getTechOptions();
   const skills = {};
 
   // First pass: identify all technologies and their types
@@ -759,7 +759,7 @@ function migrateOldSkills(projectRoot) {
  * @param {Object} skillContext - Additional context { type, parentFramework, ecosystemSkills }
  */
 async function writeSkillFiles(tech, docs, projectRoot, skillContext = {}) {
-  const { getSkillType, getParentFramework } = getTechOptions();
+  const { getSkillType, _getParentFramework } = getTechOptions();
 
   const skillId = tech.value.toLowerCase().replace(/[^a-z0-9]/g, '-');
   const skillDir = path.join(projectRoot, '.claude', 'skills', skillId);

package/scripts/flow-skill-learn.js

@@ -29,9 +29,6 @@ function log(color, ...args) {
   console.log(colors[color] + args.join(' ') + colors.reset);
 }
 
-// Alias getConfig as loadConfig for minimal code changes
-const loadConfig = getConfig;
-
 function isLearningEnabled(config, trigger) {
   if (!config?.skillLearning?.enabled) return false;
   if (!config?.skillLearning?.autoExtract) return false;
@@ -81,7 +78,7 @@ function getChangedFiles(staged = false) {
   }
 }
 
-function getRecentCommitFiles(count = 1) {
+function _getRecentCommitFiles(count = 1) {
   try {
     const cmd = `git diff HEAD~${count} --name-only`;
     const output = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
@@ -387,7 +384,7 @@ function formatSemanticChanges(semanticChanges) {
 
   const lines = [];
 
-  for (const { file, changes } of semanticChanges) {
+  for (const { _file, changes } of semanticChanges) {
     if (changes.length === 0) continue;
 
     for (const change of changes) {
@@ -714,7 +711,7 @@ async function main() {
     process.exit(0);
   }
 
-  const config = loadConfig();
+  const config = getConfig();
 
   if (!isLearningEnabled(config, options.trigger)) {
     if (options.verbose) {