mindforge-cc 11.0.0 → 11.2.1

package/bin/browser/regression-writer.js

@@ -10,12 +10,54 @@ function write(bug, phaseNum) {
   const dir = path.join(process.cwd(), 'tests', 'regression');
   fs.mkdirSync(dir, { recursive: true });
   const name = `phase${phaseNum}-${bug.surface.replace(/\//g, '-').slice(1) || 'home'}.test.ts`;
+
+  // Embed the bug's surface and failure signal as safely-escaped JS string
+  // literals. JSON.stringify escapes quotes, backticks and ${...} so a
+  // freeform bug.error cannot break out of the generated source.
+  const surfaceLit = JSON.stringify(bug.surface);
+  const errorLit   = JSON.stringify(bug.error);
+
+  // The generated test reproduces the original failure conditions and asserts
+  // the page no longer exhibits THIS bug's signal — it is NOT a body-visibility
+  // tautology that passes for any page.
   const content = `
 import { test, expect } from '@playwright/test';
 
-test('Regression: ${bug.surface} [${bug.error}]', async ({ page }) => {
-  await page.goto('${bug.surface}');
-  // TODO: Add more specific assertions based on the bug
+// Regression guard for the bug originally observed on ${bug.surface}:
+//   ${String(bug.error).replace(/[\r\n]+/g, ' ')}
+// This test fails again if that failure signal re-appears (console error,
+// page text, or a >=400 HTTP status on the affected surface).
+const SURFACE = ${surfaceLit};
+const BUG_SIGNAL = ${errorLit};
+
+test('Regression: ' + SURFACE + ' [' + BUG_SIGNAL + ']', async ({ page }) => {
+  const consoleErrors: string[] = [];
+  page.on('console', (msg) => {
+    if (msg.type() === 'error') consoleErrors.push(msg.text());
+  });
+  page.on('pageerror', (err) => consoleErrors.push(String(err)));
+
+  const response = await page.goto(SURFACE);
+
+  // 1. The affected surface must load without the original HTTP failure.
+  if (response) {
+    expect(response.status(), 'surface re-returned a failing HTTP status').toBeLessThan(400);
+  }
+
+  // 2. The specific failure signal must not re-appear in the console.
+  expect(
+    consoleErrors.some((line) => line.includes(BUG_SIGNAL)),
+    'console re-emitted the original error: ' + BUG_SIGNAL
+  ).toBeFalsy();
+
+  // 3. ...nor be surfaced in the rendered page text.
+  const bodyText = await page.textContent('body');
+  expect(
+    (bodyText || '').includes(BUG_SIGNAL),
+    'page re-rendered the original error: ' + BUG_SIGNAL
+  ).toBeFalsy();
+
+  // 4. Smoke check: the page actually rendered something.
   expect(await page.isVisible('body')).toBeTruthy();
 });
 `;

package/bin/browser/session-manager.js

@@ -7,7 +7,6 @@
 
 const fs   = require('fs');
 const path = require('path');
-const os   = require('os');
 
 const SESSIONS_DIR = path.join(process.cwd(), '.mindforge', 'browser', 'sessions');
 const ensureDir = () => fs.mkdirSync(SESSIONS_DIR, { recursive: true });
@@ -71,23 +70,28 @@ async function loadSession(name, context) {
   return { cookiesLoaded };
 }
 
+/**
+ * Import cookies/sessions directly from a native browser profile.
+ *
+ * NOT IMPLEMENTED: native browser cookie DB import was removed together with
+ * the `better-sqlite3` dependency (the project now uses sql.js / WASM). Browser
+ * cookie stores are SQLite databases, and decoding them required that native
+ * backend. Rather than silently returning an empty array — which would lie about
+ * capability and let callers mistake "no cookies imported" for success — this
+ * method throws so the missing capability is explicit.
+ *
+ * To populate a session, capture cookies live via a browser context and use
+ * `saveSession` / `loadSession` instead.
+ *
+ * @param {string} source - Browser identifier (chrome, arc, brave, edge).
+ * @throws {Error} Always — native browser cookie import is not implemented.
+ */
 function importFromBrowser(source) {
-  const home = os.homedir();
-  const paths = {
-    chrome: `${home}/Library/Application Support/Google/Chrome/Default/Cookies`,
-    arc: `${home}/Library/Application Support/Arc/User Data/Default/Cookies`,
-    brave: `${home}/Library/Application Support/BraveSoftware/Brave-Browser/Default/Cookies`,
-    edge: `${home}/Library/Application Support/Microsoft Edge/Default/Cookies`,
-  };
-
-  const p = paths[source.toLowerCase()];
-  if (!p || !fs.existsSync(p)) {
-    throw new Error(`Cookie file for ${source} not found at ${p}`);
-  }
-
-  // Real SQLite parsing would happen here via better-sqlite3 if installed.
-  // This is a placeholder for the logic specified in the roadmap.
-  return [];
+  throw new Error(
+    `importFromBrowser not implemented for "${source}": the native browser ` +
+    'cookie-DB backend (better-sqlite3) was removed project-wide. ' +
+    'Capture cookies live via a browser context and use saveSession/loadSession instead.'
+  );
 }
 
 module.exports = { saveSession, loadSession, importFromBrowser };

package/bin/council-cli.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * MindForge — Council CLI (UC-22)
+ *
+ * Thin CLI wrapper around council-runtime.runCouncil. Provides the injectable
+ * model function via ModelClient and formats structured output for the
+ * /mindforge:council command.
+ *
+ * Usage:
+ *   node bin/council-cli.js "Should we adopt event sourcing for the payments domain?"
+ *   node bin/council-cli.js --id payment-es "Should we adopt event sourcing?"
+ *
+ * Exit codes:
+ *   0 — PROCEED
+ *   1 — REVISE
+ *   2 — NO_CONSENSUS
+ *   3 — Runtime error
+ */
+const { runCouncil } = require('./engine/council-runtime');
+const ModelClient = require('./models/model-client');
+
+const VOICE_SYSTEM_PROMPTS = {
+  architect: 'You are the Architect voice in a decision council. You focus on system design, scalability, maintainability, and long-term architectural integrity. Evaluate the decision from a structural perspective.',
+  skeptic: 'You are the Skeptic voice in a decision council. You challenge assumptions, identify risks, hidden costs, and failure modes. Your job is to stress-test the proposal.',
+  pragmatist: 'You are the Pragmatist voice in a decision council. You focus on delivery timelines, team capacity, incremental value, and practical trade-offs. Favor what ships reliably.',
+  critic: 'You are the Critic voice in a decision council. You evaluate quality, correctness, edge cases, and whether the solution meets its stated goals without over-engineering.',
+};
+
+const POSITION_INSTRUCTION = `
+Respond with ONLY a JSON object (no markdown fences, no prose) in this exact shape:
+{
+  "recommendation": "PROCEED" or "REVISE",
+  "confidence": <number between 0 and 1>,
+  "rationale": "<1-3 sentence explanation>"
+}
+Do NOT include any text outside the JSON object.`;
+
+/**
+ * Injectable model function for runCouncil — calls ModelClient.complete per voice.
+ */
+async function councilModel({ voice, question }) {
+  const systemPrompt = (VOICE_SYSTEM_PROMPTS[voice] || VOICE_SYSTEM_PROMPTS.architect) +
+    '\n' + POSITION_INSTRUCTION;
+
+  const result = await ModelClient.complete({
+    persona: 'council',
+    tier: 2,
+    systemPrompt,
+    userMessage: `Decision under review:\n${question}`,
+    maxTokens: 300,
+    temperature: 0.4,
+    taskName: `council-${voice}`,
+  });
+
+  // Parse the JSON response from the model
+  const content = (result.content || '').trim();
+  let parsed;
+  try {
+    // Strip markdown fences if model adds them despite instructions
+    const cleaned = content.replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/i, '');
+    parsed = JSON.parse(cleaned);
+  } catch {
+    throw new Error(`Council voice "${voice}" returned unparseable response: ${content.slice(0, 200)}`);
+  }
+
+  return {
+    recommendation: parsed.recommendation,
+    confidence: parsed.confidence,
+    rationale: parsed.rationale,
+  };
+}
+
+// --- CLI argument parsing ---
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const opts = { question: null, decisionId: null };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--id' && args[i + 1]) {
+      opts.decisionId = args[++i];
+    } else if (!args[i].startsWith('-')) {
+      opts.question = opts.question ? `${opts.question} ${args[i]}` : args[i];
+    }
+  }
+  return opts;
+}
+
+// --- Formatted output ---
+function formatOutput(result) {
+  const lines = [];
+  lines.push('');
+  lines.push('=== COUNCIL VERDICT ===');
+  lines.push('');
+  lines.push(`Question: ${result.question}`);
+  lines.push('');
+  lines.push('--- Positions ---');
+  for (const pos of result.positions) {
+    const icon = pos.recommendation === 'PROCEED' ? '[+]' : '[-]';
+    lines.push(`  ${icon} ${pos.voice.toUpperCase()} (${pos.recommendation}, confidence: ${pos.confidence.toFixed(2)})`);
+    lines.push(`      ${pos.rationale}`);
+  }
+  lines.push('');
+  lines.push(`--- Consensus: ${(result.consensus * 100).toFixed(1)}% ---`);
+  lines.push('');
+  lines.push(`VERDICT: ${result.verdict}`);
+
+  if (result.verdict === 'NO_CONSENSUS' && result.dissent.length > 0) {
+    lines.push('');
+    lines.push('--- Dissent (full split) ---');
+    for (const d of result.dissent) {
+      lines.push(`  * ${d.voice.toUpperCase()} (${d.recommendation}): ${d.rationale}`);
+    }
+  } else if (result.dissent.length > 0) {
+    lines.push('');
+    lines.push('--- Dissent ---');
+    for (const d of result.dissent) {
+      lines.push(`  * ${d.voice.toUpperCase()}: ${d.rationale}`);
+    }
+  }
+
+  lines.push('');
+  lines.push('Council is advisory -- you have final say.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+// --- Main ---
+async function main() {
+  const { question, decisionId } = parseArgs(process.argv);
+
+  if (!question) {
+    process.stderr.write('Usage: node bin/council-cli.js [--id <decision-id>] "<question>"\n');
+    process.exit(3);
+  }
+
+  try {
+    const result = await runCouncil(question, {
+      model: councilModel,
+      writeDecision: true,
+      decisionId: decisionId || undefined,
+    });
+
+    // Output structured JSON to stdout for programmatic consumption
+    console.log(JSON.stringify(result, null, 2));
+
+    // Output formatted human-readable summary to stderr
+    process.stderr.write(formatOutput(result));
+
+    // Exit code reflects verdict
+    const exitCode = result.verdict === 'PROCEED' ? 0
+      : result.verdict === 'REVISE' ? 1
+      : 2;
+    process.exit(exitCode);
+  } catch (err) {
+    process.stderr.write(`[council-cli] ERROR: ${err.message}\n`);
+    process.exit(3);
+  }
+}
+
+main();

package/bin/dashboard/approval-handler.js

@@ -115,7 +115,9 @@ function writeAuditEntry(entry) {
   try {
     const paths = getPaths();
     if (!fs.existsSync(path.dirname(paths.audit))) return;
-    fs.appendFileSync(paths.audit, JSON.stringify(entry) + '\n');
+    // UC-04b: unified, hash-chained, durable append into the single verifiable chain.
+    const { appendAuditEntrySync } = require('../autonomous/audit-writer');
+    appendAuditEntrySync(paths.audit, entry);
   } catch { /* ignore AUDIT write failures */ }
 }
 

package/bin/dashboard/server.js

@@ -161,7 +161,7 @@ app.use((req, res, next) => {
   res.setHeader('X-Content-Type-Options', 'nosniff');
   res.setHeader('X-Frame-Options', 'DENY');
   res.setHeader('Cache-Control', 'no-store'); // Never cache dashboard responses
-  res.setHeader('Content-Security-Policy', "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; connect-src 'self'");
+  res.setHeader('Content-Security-Policy', 'default-src \'self\'; script-src \'self\'; style-src \'self\' \'unsafe-inline\'; connect-src \'self\'');
   res.setHeader('X-XSS-Protection', '1; mode=block');
   res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
   next();

package/bin/dashboard/sse-bridge.js

@@ -21,7 +21,6 @@ const APPROVAL_DIR    = path.join(process.cwd(), '.planning', 'approvals');
 const clients = new Set(); // Connected SSE response objects
 
 let _lastAuditSize  = 0;
-let _auditInode     = 0; // Track file inode for rotation detection
 let _lastAutoState  = '';
 let _lastApprovals  = '';
 
@@ -78,14 +77,16 @@ function pollAuditLog() {
   try {
     const stat     = fs.statSync(AUDIT_PATH);
     const newSize  = stat.size;
-    const newIno   = stat.ino;
 
-    // File rotation detected: inode changed or file shrunk (truncated after archival)
-    if ((newIno !== _auditInode && _auditInode !== 0) || (newSize < _lastAuditSize)) {
-      process.stderr.write(`[sse-bridge] AUDIT.jsonl rotation detected (size: ${_lastAuditSize} -> ${newSize}, ino: ${_auditInode} -> ${newIno})\n`);
+    // Truncation / recreation recovery (NOT rotation — audit rotation was retired in
+    // UC-04b because it broke the hash chain; AUDIT.jsonl grows unbounded). If the
+    // file ever SHRINKS (manually truncated, .planning wiped, or replaced), reset the
+    // read offset to 0 so the live tail keeps working instead of stalling forever on
+    // the `newSize <= _lastAuditSize` early-return below or reading at a stale offset.
+    if (newSize < _lastAuditSize) {
+      process.stderr.write(`[sse-bridge] AUDIT.jsonl shrank (size: ${_lastAuditSize} -> ${newSize}) — re-tailing from start\n`);
       _lastAuditSize = 0;
     }
-    _auditInode = newIno;
 
     if (newSize <= _lastAuditSize) return;
 
@@ -169,9 +170,7 @@ function startPolling() {
 
   // Initialize AUDIT position on first start
   if (!_initialized && fs.existsSync(AUDIT_PATH)) {
-    const stat = fs.statSync(AUDIT_PATH);
-    _lastAuditSize = stat.size;
-    _auditInode    = stat.ino;
+    _lastAuditSize = fs.statSync(AUDIT_PATH).size;
     _initialized   = true;
   }
 
@@ -207,9 +206,7 @@ function stopPolling() {
 function start() {
   // Pre-initialize AUDIT position so first client gets instant data
   if (!_initialized && fs.existsSync(AUDIT_PATH)) {
-    const stat = fs.statSync(AUDIT_PATH);
-    _lastAuditSize = stat.size;
-    _auditInode    = stat.ino;
+    _lastAuditSize = fs.statSync(AUDIT_PATH).size;
     _initialized   = true;
   }
   // Polling starts lazily when addClient() is called

package/bin/engine/council-runtime.js

@@ -0,0 +1,124 @@
+'use strict';
+/**
+ * MindForge — Council Runtime (UC-10). Thin multi-voice decision harness (ADS).
+ *
+ * Activates the Adversarial Decision Loop (ADS) mandated by CLAUDE.md: instead of
+ * a multi-round debate simulator, this is a THIN runtime — parallel position
+ * collection (one per voice) + consensus scoring + dissent capture.
+ *
+ * The model is INJECTABLE (no hard LLM dependency) so callers/tests can supply a
+ * mock. The Semaphore from wave-executor is reused to bound concurrent voice calls.
+ *
+ * Design decision — NO challenge round (kept thin per adversarial review + YAGNI):
+ * A second model call per dissenter that folds a revised confidence back into the
+ * consensus adds ordering/weighting complexity and extra failure modes without
+ * changing the activation goal. Position-collection + consensus fully satisfies the
+ * ADS loop and the verdict contract. Add a challenge round only if a concrete need
+ * arises (an explicit `opts.challengeRound` flag would be the clean extension point).
+ *
+ * Filenames use opts.decisionId (NOT Date.now(), which is unavailable in some
+ * MindForge execution contexts); falls back to "council-latest.json".
+ */
+const fs = require('fs');
+const path = require('path');
+const { Semaphore } = require('../autonomous/wave-executor');
+
+const DEFAULT_VOICES = ['architect', 'skeptic', 'pragmatist', 'critic'];
+const VALID_RECOMMENDATIONS = ['PROCEED', 'REVISE'];
+
+/**
+ * Validates a single voice's position payload. Throws a clear, voice-named error
+ * on a malformed payload rather than letting it degrade into NaN consensus.
+ * @param {string} voice — The voice that produced the position (for the error message).
+ * @param {object} position — The raw position returned by the model.
+ */
+function validatePosition(voice, position) {
+  if (!position || typeof position !== 'object') {
+    throw new Error(`Council voice "${voice}" returned an invalid position: expected an object, got ${position === null ? 'null' : typeof position}`);
+  }
+  if (!VALID_RECOMMENDATIONS.includes(position.recommendation)) {
+    throw new Error(`Council voice "${voice}" returned an invalid position: recommendation must be one of ${VALID_RECOMMENDATIONS.join('/')}, got ${JSON.stringify(position.recommendation)}`);
+  }
+  if (typeof position.confidence !== 'number' || !Number.isFinite(position.confidence) || position.confidence < 0 || position.confidence > 1) {
+    throw new Error(`Council voice "${voice}" returned an invalid position: confidence must be a number in [0,1], got ${position.confidence}`);
+  }
+}
+
+/**
+ * Runs a thin adversarial council over a question.
+ * @param {string} question — The decision/question put to the council.
+ * @param {object} [opts]
+ * @param {string[]} [opts.voices] — Voice personas to consult (default: 4 ADS voices).
+ * @param {number} [opts.consensusThreshold=0.75] — Threshold for PROCEED/REVISE.
+ * @param {function} opts.model — REQUIRED. async ({voice, question}) =>
+ *   { recommendation: 'PROCEED'|'REVISE', confidence: number(0..1), rationale: string }
+ * @param {number} [opts.maxConcurrency] — Bound on parallel voice calls (default: #voices).
+ * @param {boolean} [opts.writeDecision=true] — Persist a decision record to disk.
+ * @param {string} [opts.outputPath] — Directory for the record (default: .planning/decisions).
+ * @param {string} [opts.decisionId] — Stable id used in the filename (no Date.now()).
+ * @returns {Promise<{question,positions,consensus,verdict,dissent}>}
+ */
+async function runCouncil(question, opts = {}) {
+  const voices = Array.isArray(opts.voices) && opts.voices.length > 0
+    ? opts.voices
+    : DEFAULT_VOICES;
+  const consensusThreshold = opts.consensusThreshold ?? 0.75;
+  const model = opts.model;
+  if (typeof model !== 'function') {
+    throw new Error('runCouncil requires an injectable model function (opts.model)');
+  }
+  const maxConcurrency = opts.maxConcurrency || voices.length;
+
+  // Parallel position collection — bounded by the reused Semaphore.
+  const sem = new Semaphore(maxConcurrency);
+  const positions = await Promise.all(voices.map(async (voice) => {
+    await sem.acquire();
+    try {
+      const position = await model({ voice, question });
+      // Validate the payload immediately — never silently swallow a malformed
+      // position into NaN consensus (which would collapse to NO_CONSENSUS and
+      // write NaN to the decision record).
+      validatePosition(voice, position);
+      return { voice, ...position };
+    } finally {
+      sem.release();
+    }
+  }));
+
+  // Consensus = mean approval signal across voices.
+  // A PROCEED contributes its confidence; a REVISE contributes its inverse
+  // (so a high-confidence REVISE pulls consensus down hard).
+  const consensus = positions.reduce((sum, p) => {
+    const approval = p.recommendation === 'PROCEED' ? p.confidence : (1 - p.confidence);
+    return sum + approval;
+  }, 0) / positions.length;
+
+  const verdict = consensus >= consensusThreshold ? 'PROCEED'
+    : consensus <= (1 - consensusThreshold) ? 'REVISE'
+    : 'NO_CONSENSUS';
+
+  // Dissent capture:
+  // - For a decisive verdict (PROCEED/REVISE): the voices opposing that direction.
+  // - For NO_CONSENSUS (the deadlock ADS most needs documented): the FULL split —
+  //   every voice's {voice, recommendation, rationale} — so the decision record
+  //   preserves both camps rather than recording an empty dissent list.
+  const dissent = verdict === 'NO_CONSENSUS'
+    ? positions.map((p) => ({ voice: p.voice, recommendation: p.recommendation, rationale: p.rationale }))
+    : positions.filter((p) =>
+        (verdict === 'PROCEED' && p.recommendation !== 'PROCEED') ||
+        (verdict === 'REVISE' && p.recommendation === 'PROCEED'))
+      .map((d) => ({ voice: d.voice, rationale: d.rationale }));
+
+  const result = { question, positions, consensus, verdict, dissent };
+
+  if (opts.writeDecision !== false) {
+    const dir = opts.outputPath || path.join(process.cwd(), '.planning', 'decisions');
+    fs.mkdirSync(dir, { recursive: true });
+    const name = opts.decisionId ? `council-${opts.decisionId}.json` : 'council-latest.json';
+    fs.writeFileSync(path.join(dir, name), JSON.stringify(result, null, 2));
+  }
+
+  return result;
+}
+
+module.exports = { runCouncil };

package/bin/engine/logic-drift-detector.js

@@ -1,9 +1,15 @@
 /**
- * MindForge v6.1.0-alpha — Neural Drift Remediation (NDR)
- * Component: Logic Drift Detector (Pillar X)
- * 
- * Analyzes reasoning traces for "Semantic Decay" (repeated failure patterns, 
- * hallucination-like markers, or mission drift).
+ * MindForge v6.1.0-alpha — Logic Drift Detector (Pillar X)
+ *
+ * HEURISTIC drift detector. Despite the "Pillar X" product naming, this
+ * component does NOT use a neural network, embeddings, or any learned model.
+ * It scores reasoning traces using pure keyword/ratio heuristics:
+ *   - unique-word-to-total ratio (proxy for "rambling")
+ *   - max word-repetition count (proxy for circular reasoning)
+ *   - presence of a small hardcoded list of contradiction phrases
+ *
+ * Flags "Semantic Decay" (repeated failure patterns, contradiction markers,
+ * or mission drift) heuristically. No model inference is performed.
  */
 'use strict';
 
@@ -48,7 +54,9 @@ class LogicDriftDetector {
   }
 
   /**
-   * Internal Heuristic: Detects low semantic density (rambling).
+   * Internal Heuristic: approximates "rambling" via a unique-keyword-to-word
+   * ratio. NOTE: this is NOT a semantic/embedding measure — "density" here is
+   * a plain lexical ratio, not model-derived semantic similarity.
    */
   _calculateSemanticDensity(thought) {
     const words = thought.split(/\s+/).length;