wogiflow 2.29.2 → 2.29.3

package/scripts/flow-source-fidelity.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Source Fidelity Verifier (P11.5 mechanical check)
+ *
+ * Verifies that a spec file complies with the Source Fidelity Rule
+ * (methodology-rules.hbs / Logic Constitution v2 sub-principle 11.5):
+ *
+ *   T1 — Verbatim source preserved (`## Original Request (verbatim)`)
+ *   T2 — Item manifest reconciles every source item
+ *   T3 — Per-item: each source item has either a matching AC or a
+ *        defer-with-reason line (heuristic — full coverage check is
+ *        adversary's job; this CLI is the Tier-2 evidence the
+ *        adversary may invoke)
+ *
+ * Lossy spec-authoring is the documented root cause of the wogi-hub
+ * 2026-04-27 incident (5 of 12 user-named features survived from
+ * prompt → spec → build because the manager compressed the prompt
+ * into a 5-bullet contract). This verifier runs at spec_review and at
+ * the spec-write gate.
+ *
+ * Usage:
+ *   node scripts/flow-source-fidelity.js check <spec-file>
+ *   node scripts/flow-source-fidelity.js check <spec-file> --json
+ *   node scripts/flow-source-fidelity.js check <spec-file> --strict
+ *
+ * Exit codes:
+ *   0 — spec passes (verbatim block present + item manifest present
+ *       OR source is short enough to skip the rule)
+ *   1 — spec fails (T1 or T2 violated; details printed to stderr)
+ *   2 — couldn't read spec / not a spec file
+ *
+ * Programmatic:
+ *   const { checkSourceFidelity } = require('./flow-source-fidelity');
+ *   const result = checkSourceFidelity(specPath, { strict: false });
+ *   // result: { ok, source, items, missing, warnings, exempt }
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const VERBATIM_HEADER_REGEX = /^##\s+Original Request \(verbatim\)\s*$/m;
+const MANIFEST_HEADER_REGEX = /^##\s+Item Manifest\s*$/m;
+// Triggers the rule when the verbatim source is "long" — same threshold
+// as the long-input gate (40 lines OR ≥5 discrete items).
+const LONG_LINE_THRESHOLD = 40;
+const LONG_ITEM_THRESHOLD = 5;
+
+function detectDiscreteItems(text) {
+  if (typeof text !== 'string') return 0;
+  const lines = text.split('\n');
+  let count = 0;
+  for (const line of lines) {
+    if (/^\s*[-*]\s+/.test(line)) count++;          // bullet
+    else if (/^\s*\d+[.)]\s+/.test(line)) count++;  // numbered
+    else if (/;.*;/.test(line)) count++;            // semicolon-list
+  }
+  return count;
+}
+
+function extractBlock(content, headerRegex) {
+  const match = headerRegex.exec(content);
+  if (!match) return null;
+  const startIdx = match.index + match[0].length;
+  // Block ends at next ## heading at the same level
+  const rest = content.slice(startIdx);
+  const nextHeader = /^##\s+\S/m.exec(rest);
+  const blockEnd = nextHeader ? startIdx + nextHeader.index : content.length;
+  return content.slice(startIdx, blockEnd).trim();
+}
+
+/**
+ * Parse the verbatim source block and count its discrete items.
+ * Returns the body text + item count.
+ */
+function parseVerbatim(content) {
+  const block = extractBlock(content, VERBATIM_HEADER_REGEX);
+  if (block === null) return null;
+  return {
+    text: block,
+    lineCount: block.split('\n').filter(l => l.trim()).length,
+    itemCount: detectDiscreteItems(block)
+  };
+}
+
+/**
+ * Parse the item manifest. Each line of the form
+ *   - <item> → AC<n>
+ *   - <item> → defer-with-reason: <reason>
+ * Lines without "→" or with empty mappings are flagged.
+ */
+function parseManifest(content) {
+  const block = extractBlock(content, MANIFEST_HEADER_REGEX);
+  if (block === null) return null;
+  const entries = [];
+  for (const rawLine of block.split('\n')) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (!/^[-*]\s+/.test(line)) continue;
+    const body = line.replace(/^[-*]\s+/, '');
+    const arrowIdx = body.indexOf('→');
+    if (arrowIdx === -1) {
+      entries.push({ item: body, mapping: null, raw: rawLine });
+      continue;
+    }
+    const item = body.slice(0, arrowIdx).trim();
+    const mapping = body.slice(arrowIdx + 1).trim();
+    entries.push({ item, mapping, raw: rawLine });
+  }
+  return { entries, raw: block };
+}
+
+/**
+ * Decide whether the rule applies to this spec by checking either the
+ * verbatim block (if present) or the spec body itself for the
+ * long-prompt threshold.
+ */
+function ruleApplies(content, verbatim) {
+  // If verbatim exists AND has content, it's the canonical signal of
+  // long-form-ness. Otherwise fall back to inspecting the spec body —
+  // an empty verbatim block doesn't exempt the spec from the rule.
+  if (verbatim && (verbatim.lineCount > LONG_LINE_THRESHOLD || verbatim.itemCount >= LONG_ITEM_THRESHOLD)) {
+    return true;
+  }
+  // Body inspection: catches both "no verbatim block at all" AND
+  // "verbatim block present but empty" — both mean the rule should fire
+  // if the surrounding spec content qualifies as long-form.
+  const bodyLines = content.split('\n').filter(l => l.trim()).length;
+  const bodyItems = detectDiscreteItems(content);
+  return bodyLines > LONG_LINE_THRESHOLD || bodyItems >= LONG_ITEM_THRESHOLD;
+}
+
+/**
+ * Main verification entry point.
+ * @param {string} specPath
+ * @param {object} [options]
+ * @param {boolean} [options.strict] — if true, T2 (manifest) is mandatory
+ * @returns {{ok, exempt, missing, warnings, verbatim, manifest, specPath}}
+ */
+function checkSourceFidelity(specPath, options = {}) {
+  if (!specPath || !fs.existsSync(specPath)) {
+    return { ok: false, missing: ['spec-file-not-found'], warnings: [], exempt: false, specPath };
+  }
+  const content = fs.readFileSync(specPath, 'utf-8');
+  const verbatim = parseVerbatim(content);
+  const manifest = parseManifest(content);
+  const applies = ruleApplies(content, verbatim);
+
+  if (!applies) {
+    return {
+      ok: true,
+      exempt: true,
+      reason: 'spec-below-long-input-threshold',
+      verbatim, manifest, missing: [], warnings: [], specPath
+    };
+  }
+
+  const missing = [];
+  const warnings = [];
+
+  if (!verbatim) {
+    missing.push('T1: missing `## Original Request (verbatim)` block (rule applies — source is long-form)');
+  } else if (verbatim.lineCount === 0) {
+    missing.push('T1: `## Original Request (verbatim)` block is empty');
+  }
+
+  if (!manifest) {
+    if (options.strict) {
+      missing.push('T2: missing `## Item Manifest` block (--strict required)');
+    } else {
+      warnings.push('T2: no `## Item Manifest` block — recommended for full P11.5 compliance');
+    }
+  } else {
+    for (const entry of manifest.entries) {
+      if (!entry.mapping) {
+        warnings.push(`T2: manifest entry "${entry.item}" has no mapping (expected "→ AC<n>" or "→ defer-with-reason: <reason>")`);
+      }
+    }
+  }
+
+  return {
+    ok: missing.length === 0,
+    exempt: false,
+    missing,
+    warnings,
+    verbatim,
+    manifest,
+    specPath
+  };
+}
+
+function formatResult(result, opts = {}) {
+  if (opts.json) {
+    const slim = {
+      ok: result.ok,
+      exempt: result.exempt || false,
+      reason: result.reason || null,
+      missing: result.missing,
+      warnings: result.warnings,
+      verbatim: result.verbatim ? {
+        lineCount: result.verbatim.lineCount,
+        itemCount: result.verbatim.itemCount
+      } : null,
+      manifestEntries: result.manifest ? result.manifest.entries.length : 0,
+      specPath: result.specPath
+    };
+    return JSON.stringify(slim, null, 2);
+  }
+  const lines = [];
+  lines.push(`Source Fidelity Check — ${result.specPath}`);
+  lines.push('━'.repeat(58));
+  if (result.exempt) {
+    lines.push(`⏭  EXEMPT — ${result.reason || 'rule does not apply'}`);
+    return lines.join('\n');
+  }
+  if (result.ok) {
+    lines.push('✓ PASS');
+  } else {
+    lines.push('✗ FAIL');
+  }
+  if (result.verbatim) {
+    lines.push(`  Verbatim block:  ${result.verbatim.lineCount} non-empty lines, ${result.verbatim.itemCount} discrete items`);
+  } else {
+    lines.push('  Verbatim block:  ABSENT');
+  }
+  if (result.manifest) {
+    lines.push(`  Item manifest:   ${result.manifest.entries.length} entries`);
+  } else {
+    lines.push('  Item manifest:   ABSENT');
+  }
+  if (result.missing.length) {
+    lines.push('');
+    lines.push('Missing (BLOCKING):');
+    for (const m of result.missing) lines.push(`  - ${m}`);
+  }
+  if (result.warnings.length) {
+    lines.push('');
+    lines.push('Warnings:');
+    for (const w of result.warnings) lines.push(`  - ${w}`);
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  checkSourceFidelity,
+  parseVerbatim,
+  parseManifest,
+  ruleApplies,
+  detectDiscreteItems,
+  LONG_LINE_THRESHOLD,
+  LONG_ITEM_THRESHOLD
+};
+
+if (require.main === module) {
+  const [,, cmd, ...rest] = process.argv;
+  if (cmd === 'check') {
+    const target = rest.find(a => !a.startsWith('--'));
+    const json = rest.includes('--json');
+    const strict = rest.includes('--strict');
+    if (!target) {
+      process.stderr.write('Usage: flow-source-fidelity check <spec-file> [--json] [--strict]\n');
+      process.exit(2);
+    }
+    const result = checkSourceFidelity(target, { strict });
+    const formatted = formatResult(result, { json });
+    if (result.ok || result.exempt) {
+      process.stdout.write(formatted + '\n');
+      process.exit(0);
+    } else {
+      process.stderr.write(formatted + '\n');
+      process.exit(1);
+    }
+  } else {
+    process.stderr.write('Usage: flow-source-fidelity check <spec-file> [--json] [--strict]\n');
+    process.exit(2);
+  }
+}

package/scripts/flow-time-format.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Wogi Flow — Shared time-formatting helpers.
+ *
+ * Extracted from flow-completion-summary.js + flow-workspace-summary.js
+ * (CL-006 / 2026-04-26 review-fix). Both files implemented identical
+ * `formatDuration(startedAt, endedAt)` with already-creeping stylistic
+ * divergence. Single source of truth here.
+ */
+
+function pad2(n) {
+  return String(n).padStart(2, '0');
+}
+
+/**
+ * Format the wall-clock duration between two ISO timestamps as "m:ss" (or
+ * "h:mm:ss" if ≥1 hour). Returns "0:00" for missing inputs or negative
+ * durations (clock skew).
+ *
+ * @param {string} startedAt
+ * @param {string} endedAt
+ * @returns {string}
+ */
+function formatDuration(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return '0:00';
+  const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return '0:00';
+  const sec = Math.floor(ms / 1000);
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  if (m >= 60) {
+    const h = Math.floor(m / 60);
+    return `${h}:${pad2(m % 60)}:${pad2(s)}`;
+  }
+  return `${m}:${pad2(s)}`;
+}
+
+module.exports = {
+  pad2,
+  formatDuration
+};

package/scripts/flow-utils.js

@@ -129,6 +129,7 @@ const {
   generatePlanId,
   validateTaskId,
   isLegacyTaskId,
+  isValidWogiId,
 } = require('./flow-id');
 
 // ============================================================
@@ -254,22 +255,8 @@ function invalidateReadyDataCache() {
  * @param {string} id - ID to check
  * @returns {boolean}
  */
-function isValidWogiId(id) {
-  if (!id || typeof id !== 'string') return false;
-  // Standard task, sub-task, review fix (wf-cr-), review finding (wf-rv-)
-  if (/^wf-[a-f0-9]{8}(-\d{2})?$/i.test(id)) return true;
-  if (/^wf-cr-[a-f0-9]{6}$/i.test(id)) return true;
-  if (/^wf-rv-[a-f0-9]{8}$/i.test(id)) return true;
-  // Epic, feature, plan IDs
-  if (/^(ep|ft|pl)-[a-f0-9]{8}$/i.test(id)) return true;
-  // Slug format: wf-<alphanum>[<alphanum or hyphen>]*<alphanum>, 5-64 chars.
-  // For manager-dispatched descriptive IDs. Path-safe (no dots/separators).
-  // Keep this in sync with validateTaskId() 'slug' branch in flow-id.js.
-  if (/^wf-[a-z0-9][a-z0-9-]{0,60}[a-z0-9]$/i.test(id)) return true;
-  // Legacy format
-  if (/^(TASK|BUG)-\d{3,}$/i.test(id)) return true;
-  return false;
-}
+// isValidWogiId — extracted to flow-id.js (audit Story 12 partial — pattern
+// validator). Re-exported below for backwards compat with 302 importers.
 
 /**
  * Validate all task IDs in a ready.json data object before writing.

package/scripts/flow-worker-mcp-strip.js

@@ -38,6 +38,10 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+// arch-004 (2026-04-26): use canonical safeJsonParse — no raw JSON.parse in
+// scripts/. The .mcp.json file is user-controllable on disk; recursive
+// proto-pollution scrub is the right default.
+const { safeJsonParse } = require('./flow-io');
 
 const CHANNEL_SERVER_NAME = 'wogi-workspace-channel';
 
@@ -48,17 +52,14 @@ const CHANNEL_SERVER_NAME = 'wogi-workspace-channel';
 function extractChannelOnlyConfig(sourcePath) {
   const empty = { mcpServers: {} };
   if (!sourcePath || typeof sourcePath !== 'string') return empty;
-  try {
-    if (!fs.existsSync(sourcePath)) return empty;
-    const raw = fs.readFileSync(sourcePath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object' || !parsed.mcpServers) return empty;
-    const entry = parsed.mcpServers[CHANNEL_SERVER_NAME];
-    if (!entry || typeof entry !== 'object') return empty;
-    return { mcpServers: { [CHANNEL_SERVER_NAME]: entry } };
-  } catch (_err) {
-    return empty;
-  }
+  // safeJsonParse: returns the empty fallback on missing file, malformed
+  // JSON, or prototype-pollution attempt. Replaces the previous fs.readFileSync
+  // + JSON.parse + try/catch trio.
+  const parsed = safeJsonParse(sourcePath, null);
+  if (!parsed || typeof parsed !== 'object' || !parsed.mcpServers) return empty;
+  const entry = parsed.mcpServers[CHANNEL_SERVER_NAME];
+  if (!entry || typeof entry !== 'object') return empty;
+  return { mcpServers: { [CHANNEL_SERVER_NAME]: entry } };
 }
 
 /**

package/scripts/flow-workspace-summary.js

@@ -40,14 +40,28 @@ function encodeBase64(payload) {
   return Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64');
 }
 
+// SEC-005 + arch-006 fix (2026-04-26): decode through the canonical
+// safeJsonParseStringStrip helper instead of raw JSON.parse. Channel-dispatch
+// bytes are attacker-influenceable (any process that can POST to the manager
+// port can inject a forged ## COMPLETION-SUMMARY: line). Stripping
+// __proto__/constructor/prototype recursively defangs prototype-pollution
+// before validatePayload runs.
+const { safeJsonParseStringStrip } = require('./flow-io');
+
 function decodeBase64(s) {
+  let text;
   try {
-    const buf = Buffer.from(s, 'base64');
-    const text = buf.toString('utf-8');
-    return JSON.parse(text);
+    text = Buffer.from(s, 'base64').toString('utf-8');
   } catch (err) {
-    throw new Error(`base64-JSON decode failed: ${err.message}`);
+    throw new Error(`base64 decode failed: ${err.message}`);
+  }
+  // Sentinel — distinct object identity so callers can detect parse failure.
+  const FAIL = decodeBase64.__failSentinel || (decodeBase64.__failSentinel = Symbol('decode-fail'));
+  const parsed = safeJsonParseStringStrip(text, FAIL);
+  if (parsed === FAIL) {
+    throw new Error('base64-JSON decode failed: invalid JSON or unsafe payload');
   }
+  return parsed;
 }
 
 /**
@@ -100,6 +114,11 @@ function parseChunked(lines) {
     return { ok: false, error: 'lines must be a non-empty array' };
   }
   const fragments = [];
+  // CL-004 fix (2026-04-26): track seen indices to reject duplicate chunks.
+  // Without this, a replay or attacker-injected duplicate fragment silently
+  // overwrites fragments[n-1]; the missing-chunks check still passes (slot
+  // is non-undefined); the reassembled payload is corrupted/tampered.
+  const seen = new Set();
   let total = null;
   for (const line of lines) {
     const m = CHUNK_PREFIX_REGEX.exec(line);
@@ -111,10 +130,17 @@ function parseChunked(lines) {
     if (!Number.isInteger(n) || n < 1 || n > total) {
       return { ok: false, error: `invalid chunk index: ${m[1]}` };
     }
+    if (seen.has(n)) {
+      return { ok: false, error: `duplicate chunk index: ${n}` };
+    }
+    seen.add(n);
     fragments[n - 1] = line.replace(CHUNK_PREFIX_REGEX, '');
   }
+  // CL-004: use !==undefined instead of filter(Boolean) so empty-string
+  // fragments (legitimate edge case for short tail chunks) aren't miscounted.
   if (fragments.length !== total || fragments.some(f => f === undefined)) {
-    return { ok: false, error: `missing chunks (have ${fragments.filter(Boolean).length} of ${total})` };
+    const have = fragments.filter(f => f !== undefined).length;
+    return { ok: false, error: `missing chunks (have ${have} of ${total})` };
   }
   try {
     const payload = decodeBase64(fragments.join(''));
@@ -216,19 +242,8 @@ function renderMultiWorker(summaries) {
   return lines.join('\n');
 }
 
-function formatDuration(startedAt, endedAt) {
-  if (!startedAt || !endedAt) return '0:00';
-  const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
-  if (!Number.isFinite(ms) || ms < 0) return '0:00';
-  const sec = Math.floor(ms / 1000);
-  const m = Math.floor(sec / 60);
-  const s = sec % 60;
-  if (m >= 60) {
-    const h = Math.floor(m / 60);
-    return `${h}:${String(m % 60).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
-  }
-  return `${m}:${String(s).padStart(2, '0')}`;
-}
+// CL-006 (2026-04-26): consolidated formatDuration to flow-time-format.
+const { formatDuration } = require('./flow-time-format');
 
 module.exports = {
   SINGLE_LINE_PREFIX,
@@ -245,7 +260,11 @@ module.exports = {
 if (require.main === module) {
   const [,, cmd, ...rest] = process.argv;
   if (cmd === 'encode') {
-    const payload = JSON.parse(rest.join(' '));
+    const payload = safeJsonParseStringStrip(rest.join(' '), null);
+    if (!payload) {
+      process.stderr.write('encode: invalid JSON or unsafe payload\n');
+      process.exit(1);
+    }
     console.log(encodeMessage(payload).join('\n'));
   } else if (cmd === 'parse') {
     const r = parseMessage(rest.join(' '));

package/scripts/hooks/adapters/claude-code.js

@@ -421,11 +421,14 @@ Run: /wogi-start ${coreResult.nextTaskId}`;
       };
     }
 
-    // Compose additionalContext from up to four pieces:
-    //   1. systemReminder (research protocol) OR message (warning)
-    //   2. phasePrompt (phase-specific context)
-    //   3. overduePrompt (wf-d3e67abe — silent-halt surfacing, manager-only)
+    // Compose additionalContext from up to five pieces:
+    //   1. longInputEnforcement (P11.5 — placed FIRST so AI sees the
+    //      forcing instruction before anything else)
+    //   2. systemReminder (research protocol) OR message (warning)
+    //   3. phasePrompt (phase-specific context)
+    //   4. overduePrompt (wf-d3e67abe — silent-halt surfacing, manager-only)
     const pieces = [];
+    if (coreResult.longInputEnforcement) pieces.push(coreResult.longInputEnforcement);
     if (coreResult.systemReminder) pieces.push(coreResult.systemReminder);
     else if (coreResult.message) pieces.push(coreResult.message);
     if (coreResult.phasePrompt) pieces.push(coreResult.phasePrompt);