dual-brain 0.2.23 → 0.2.24

package/hooks/enforce-tier.mjs

@@ -290,7 +290,19 @@ const THINK_WORDS = /\b(plan|design|architect|review|audit|security|code[-\s]?re
 const WRITE_INTENT_WORDS = /\b(edit|fix|change|update|create|write|modify|implement|refactor|add|remove|delete|build|install|configure|patch|apply|move|rename|migrate|replace|rewrite|generate|scaffold|init(?:ialize)?|setup|deploy|run\s+tests?|commit|push|install|uninstall)\b/i;
 
 // Dispatch marker prefix stamped by src/dispatch.mjs for all legitimate dispatches.
-const DISPATCH_MARKER_RE = /<!--\s*dual-brain-dispatch:\s*[a-z0-9]+\s*-->/i;
+const DISPATCH_MARKER_RE = /<!--\s*dual-brain-dispatch:[a-z0-9|:.\-]+\s*-->/i;
+
+function parseDispatchMarker(prompt) {
+  const match = prompt?.match(/<!-- dual-brain-dispatch:([^>]+) -->/);
+  if (!match) return null;
+  const parts = match[1].split('|');
+  const fields = { runId: parts[0] };
+  for (const part of parts.slice(1)) {
+    const [key, val] = part.split(':');
+    if (key && val) fields[key] = val;
+  }
+  return fields;
+}
 
 /**
  * Determine whether a prompt is purely read-only (no write keywords at all).
@@ -357,6 +369,22 @@ try {
     // Non-blocking governance warning — will be included in final output
   }
 
+  // ── Over-provisioning check via enriched dispatch marker ───────────────────
+  // If the marker carries governance scores, validate that the model tier isn't
+  // higher than the task actually requires (closes the brainstorm-opus loophole).
+  const markerFields = parseDispatchMarker(rawPrompt);
+  if (markerFields?.req && markerFields?.model) {
+    const reqTier = parseInt(markerFields.req, 10);
+    const modelTier = getGovernanceTier(markerFields.model);
+    if (!isNaN(reqTier) && modelTier > reqTier && reqTier <= 2) {
+      process.stdout.write(JSON.stringify({
+        systemMessage: `[governance] Over-provisioned: task requires tier ${reqTier} but using tier ${modelTier} model (${markerFields.model}). Consider downgrading.`,
+      }));
+      process.exit(0);
+    }
+  }
+  // ── End over-provisioning check ────────────────────────────────────────────
+
   // Compute prompt hash early for duplicate detection and logging
   const promptHash = computePromptHash(ti);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {

package/src/dispatch.mjs

@@ -18,6 +18,7 @@ import { getFailoverOrder } from './decide.mjs';
 import { getTemplate, renderPrompt, quickRender } from './templates.mjs';
 import { compilePacket, shapeForRole } from './context-intel.mjs';
 import { buildContextPack } from './context.mjs';
+import { scoreTask, computeRequiredTier } from './governance.mjs';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const USAGE_DIR = join(__dirname, '..', '.dualbrain', 'usage');
@@ -706,8 +707,8 @@ function _renderTemplatedPrompt(prompt, decision, context = {}) {
 // Prepend a marker to every prompt that goes through the official dispatch pipeline.
 // The enforce-tier hook checks for this marker to distinguish legitimate dispatches
 // from raw Agent calls made by the HEAD that bypass the dual-brain pipeline.
-// Format: <!-- dual-brain-dispatch: <runId> -->
-// runId is a short timestamp-based ID that ties back to this dispatch session.
+// Format: <!-- dual-brain-dispatch:<runId>|tier:<tier>|model:<model>|risk:<risk>|req:<requiredTier> -->
+// runId is a short timestamp-based ID; governance fields enable over-provisioning validation.
 
 let _dispatchRunId = null;
 
@@ -719,9 +720,14 @@ function _getDispatchRunId() {
   return _dispatchRunId;
 }
 
-function _prependDispatchMarker(prompt) {
+function _prependDispatchMarker(prompt, decision = {}) {
   const runId = _getDispatchRunId();
-  return `<!-- dual-brain-dispatch: ${runId} -->\n${prompt}`;
+  const tier = decision.tier || 'execute';
+  const model = decision.model || 'sonnet';
+  const risk = decision.risk || 'medium';
+  const requiredTier = decision._requiredTier || '';
+  const marker = `<!-- dual-brain-dispatch:${runId}|tier:${tier}|model:${model}|risk:${risk}|req:${requiredTier} -->`;
+  return `${marker}\n${prompt}`;
 }
 
 // ─── Related session age label ────────────────────────────────────────────────
@@ -845,7 +851,12 @@ async function dispatch(input = {}) {
 
   // Stamp the prompt with the dispatch marker so enforce-tier.mjs can recognise
   // that this agent call came through the official pipeline.
-  prompt = _prependDispatchMarker(prompt);
+  // Compute required tier for governance validation
+  try {
+    const scores = scoreTask({ intent: decision.tier, risk: decision.risk, files, objective: prompt.slice(0, 200) });
+    decision = { ...decision, _requiredTier: computeRequiredTier(scores) };
+  } catch { /* non-blocking */ }
+  prompt = _prependDispatchMarker(prompt, decision);
 
   // ── Situation brief injection ────────────────────────────────────────────────
   // Prepend a compact project-state summary when provided by the pipeline.
@@ -1149,7 +1160,7 @@ async function dispatch(input = {}) {
     }
     // ── End auto-review annotation ────────────────────────────────────────────
 
-    return {
+    const nativeResult = {
       status:        success ? 'completed' : 'failed',
       type:          'native-agent',
       provider:      currentProvider,
@@ -1166,6 +1177,11 @@ async function dispatch(input = {}) {
       authVerified:  true,
       error: success ? null : errorText.slice(0, 200),
     };
+    try {
+      const { recordDispatchOutcome } = await import('./outcome.mjs');
+      recordDispatchOutcome(input, nativeResult);
+    } catch { /* never block */ }
+    return nativeResult;
   }
 
   const command = buildCommand(effectiveDecision, prompt, files, cwd);
@@ -1268,7 +1284,7 @@ async function dispatch(input = {}) {
   }
   // ── End auto-review annotation ──────────────────────────────────────────────
 
-  return {
+  const subResult = {
     status:      success ? 'completed' : 'failed',
     provider:    subProvider,
     model:       subModel,
@@ -1283,6 +1299,11 @@ async function dispatch(input = {}) {
     authVerified: true,
     error: success ? null : errorText.slice(0, 200),
   };
+  try {
+    const { recordDispatchOutcome } = await import('./outcome.mjs');
+    recordDispatchOutcome(input, subResult);
+  } catch { /* never block */ }
+  return subResult;
 }
 
 // ─── Dual-brain dispatch (parallel) ───────────────────────────────────────────
@@ -1295,7 +1316,12 @@ async function dispatchDualBrain(input = {}) {
   prompt = redact(prompt);
 
   // Stamp with dispatch marker so enforce-tier.mjs allows this Agent call
-  prompt = _prependDispatchMarker(prompt);
+  // Compute required tier for governance validation
+  try {
+    const scores = scoreTask({ intent: decision.tier, risk: decision.risk, files, objective: prompt.slice(0, 200) });
+    decision = { ...decision, _requiredTier: computeRequiredTier(scores) };
+  } catch { /* non-blocking */ }
+  prompt = _prependDispatchMarker(prompt, decision);
 
   // ── Situation brief injection ────────────────────────────────────────────────
   const _dualBrainBrief = typeof input.situationBrief === 'string' && input.situationBrief.trim()

package/src/outcome.mjs

@@ -1,4 +1,4 @@
-import { mkdirSync, appendFileSync, readFileSync, existsSync } from 'fs';
+import { mkdirSync, appendFileSync, writeFileSync, readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { randomUUID } from 'crypto';
 
@@ -44,6 +44,36 @@ function last7DaysFiles(cwd) {
   return files;
 }
 
+export function recordDispatchOutcome(dispatchInput, result) {
+  try {
+    const cwd = dispatchInput.cwd ?? process.cwd();
+    const decision = dispatchInput.decision ?? {};
+    ensureDir(cwd);
+
+    const id = `out_${Date.now().toString(36)}`;
+    const record = {
+      id,
+      timestamp: new Date().toISOString(),
+      prompt: (dispatchInput.prompt ?? '').slice(0, 200),
+      tier: decision.tier ?? result.tier ?? 'execute',
+      model: decision.model ?? result.model ?? 'unknown',
+      provider: decision.provider ?? result.provider ?? 'unknown',
+      success: result.status === 'success' || result.status === 'completed',
+      status: result.status ?? 'unknown',
+      durationMs: result.durationMs ?? 0,
+      filesChanged: result.filesChanged?.length ?? 0,
+      errors: (result.errors ?? (result.error ? [result.error] : [])).slice(0, 3),
+      lesson: '',
+    };
+
+    const filePath = join(outcomesDir(cwd), `outcome_${id}.json`);
+    writeFileSync(filePath, JSON.stringify(record, null, 2), 'utf8');
+    return record;
+  } catch {
+    return null;
+  }
+}
+
 export function computeRoutingScore(plan, result, verification) {
   let score = 3;
   if (result.success && result.duration < 60_000) score += 1;

package/src/pipeline.mjs

@@ -12,6 +12,8 @@ import { dispatch } from './dispatch.mjs';
 import { loadProfile } from './profile.mjs';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { buildContextPack as buildContextPackIntel } from './context.mjs';
+import { compilePacket } from './context-intel.mjs';
 
 // Lazy-load collaboration module
 let _collab = null;
@@ -648,6 +650,143 @@ function runGate(run, gateName, gateFn) {
   return result.passed;
 }
 
+// ─── Pre-dispatch think (Position 1: context intelligence) ───────────────────
+
+/**
+ * Optionally spawn a cheap think agent to produce a refined work spec before
+ * the real dispatch. Non-blocking on any failure.
+ *
+ * @param {string}   prompt
+ * @param {string[]} files
+ * @param {object}   decision   — from plan._decision
+ * @param {string}   cwd
+ * @param {object}   profile
+ * @param {object}   [opts]
+ * @param {boolean}  [opts._skipPreDispatchThink]  — set true on recursive calls
+ * @param {object}   [opts.log]                    — logging function
+ * @returns {Promise<{ refined: boolean, prompt?, files?, decision? }>}
+ */
+async function preDispatchThink(prompt, files, decision, cwd, profile, opts = {}) {
+  const log = opts.log ?? (() => {});
+
+  // Guard: never recurse
+  if (opts._skipPreDispatchThink) {
+    log('[dual-brain] pre-dispatch think: skipped (recursive call)');
+    return { refined: false };
+  }
+
+  // Guard: only execute/think tiers
+  const tier = decision?.tier ?? 'execute';
+  if (tier === 'search') {
+    log('[dual-brain] pre-dispatch think: skipped (search tier)');
+    return { refined: false };
+  }
+
+  // Guard: governance tier >= 2 (map tier names to numeric levels)
+  const TIER_LEVEL = { search: 1, execute: 2, think: 3 };
+  const tierLevel = TIER_LEVEL[tier] ?? 2;
+  if (tierLevel < 2) {
+    log('[dual-brain] pre-dispatch think: skipped (tier < 2)');
+    return { refined: false };
+  }
+
+  // Guard: decision confidence must be < 0.9
+  const confidence = decision?.confidence ?? 0.5;
+  if (confidence >= 0.9) {
+    log('[dual-brain] pre-dispatch think: skipped (confidence >= 0.9)');
+    return { refined: false };
+  }
+
+  // Guard: not cost-saver work style
+  try {
+    const style = getWorkStyle(profile);
+    if (style.key === 'cost-saver') {
+      log('[dual-brain] pre-dispatch think: skipped (cost-saver profile)');
+      return { refined: false };
+    }
+  } catch {
+    // profile unavailable — proceed
+  }
+
+  try {
+    log('[dual-brain] pre-dispatch think: refining work spec...');
+
+    // Build the thinker context pack
+    const pack = await buildContextPackIntel(prompt, files, cwd);
+
+    // Compile to a thinker-shaped prompt (sonnet, 3000 token budget)
+    const thinkerPrompt = compilePacket(pack, 'thinker', 'sonnet', 3000);
+
+    // Dispatch to a think agent — use sonnet, tier=think, skip all extras
+    const thinkDecision = {
+      provider: 'claude',
+      model: 'sonnet',
+      tier: 'think',
+      confidence: 1,   // internal call — fully confident
+    };
+
+    const thinkResult = await dispatch({
+      decision: thinkDecision,
+      prompt: thinkerPrompt,
+      files: [],
+      cwd,
+      dryRun: false,
+      verbose: false,
+      profile,
+      _skipPreDispatchThink: true,
+      _skipRelatedContext: true,
+    });
+
+    // Parse the think result — expect JSON with { decision, confidence, workSpec }
+    let parsed = null;
+    try {
+      const raw = typeof thinkResult === 'string'
+        ? thinkResult
+        : (thinkResult?.output ?? thinkResult?.result ?? thinkResult?.text ?? JSON.stringify(thinkResult));
+
+      // Extract JSON from possible prose wrapping
+      const jsonMatch = raw.match(/\{[\s\S]*\}/);
+      if (jsonMatch) {
+        parsed = JSON.parse(jsonMatch[0]);
+      }
+    } catch {
+      // JSON parse failed — proceed unchanged
+    }
+
+    if (!parsed || typeof parsed.confidence !== 'number' || parsed.confidence <= 0.7) {
+      const reason = !parsed ? 'unparseable response' : `confidence ${parsed.confidence} <= 0.7`;
+      log(`[dual-brain] pre-dispatch think: skipped (${reason})`);
+      return { refined: false };
+    }
+
+    const ws = parsed.workSpec;
+    if (!ws || !ws.objective) {
+      log('[dual-brain] pre-dispatch think: skipped (no workSpec.objective)');
+      return { refined: false };
+    }
+
+    // Apply refinements
+    const newObjective = ws.objective;
+    const newFiles     = [...new Set([...files, ...(ws.files ?? [])])];
+    const newDecision  = ws.criteria?.length
+      ? { ...decision, acceptanceCriteria: [...(decision.acceptanceCriteria ?? []), ...ws.criteria] }
+      : decision;
+
+    log(`[dual-brain] think refined: "${newObjective.slice(0, 60)}..." (confidence: ${parsed.confidence})`);
+
+    return {
+      refined:  true,
+      prompt:   newObjective,
+      files:    newFiles,
+      decision: newDecision,
+    };
+  } catch (err) {
+    // Non-blocking on any failure
+    log(`[dual-brain] pre-dispatch think: skipped (error: ${err.message})`);
+    return { refined: false };
+  }
+}
+
 // ─── Main entry point ─────────────────────────────────────────────────────────
 
 /**
@@ -1070,7 +1209,33 @@ export async function runPipeline(trigger, prompt, options = {}) {
       }
     }
 
-    const decision = { ...run.plan._decision };
+    let decision = { ...run.plan._decision };
+
+    // ── Pre-dispatch think (Position 1: context intelligence) ────────────────
+    // For tier-2+ non-trivial tasks with decision confidence < 0.9, spawn a
+    // cheap sonnet think agent to produce a refined work spec before the real
+    // dispatch. Non-blocking — if it fails or confidence is low, proceed as-is.
+    {
+      const thinkRefinement = await preDispatchThink(
+        effectivePrompt,
+        files,
+        decision,
+        cwd,
+        run.context?.profile ?? {},
+        { log, _skipPreDispatchThink: options._skipPreDispatchThink }
+      );
+      if (thinkRefinement.refined) {
+        // Mutate locals so both collab and direct paths use the refined inputs
+        // (effectivePrompt is const — store refinement in a mutable local)
+        run._thinkRefinedPrompt  = thinkRefinement.prompt;
+        run._thinkRefinedFiles   = thinkRefinement.files;
+        decision                 = thinkRefinement.decision;
+      }
+    }
+
+    // Resolve the (possibly refined) prompt and file list for dispatch
+    const dispatchPrompt = run._thinkRefinedPrompt ?? effectivePrompt;
+    const dispatchFiles  = run._thinkRefinedFiles  ?? files;
 
     // ── HEAD judgment injection into agent prompts ─────────────────────────────
     // HEAD's obligations, noticings, and uncertainties flow to the work agent
@@ -1130,13 +1295,13 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
       // Inject collaboration context + HEAD judgment into prompt
       const collabContext = collab.buildAgentContext(session, primaryId);
-      const promptParts = [collabContext, headJudgmentBlock, effectivePrompt].filter(Boolean);
+      const promptParts = [collabContext, headJudgmentBlock, dispatchPrompt].filter(Boolean);
       const collabPrompt = promptParts.join('\n\n');
 
       run.result = await dispatch({
         decision,
         prompt: collabPrompt,
-        files,
+        files: dispatchFiles,
         cwd,
         dryRun: false,
         verbose,
@@ -1192,13 +1357,13 @@ export async function runPipeline(trigger, prompt, options = {}) {
       try { collab.persistEvents(session, cwd); } catch {}
     } else {
       const directPrompt = headJudgmentBlock
-        ? `${headJudgmentBlock}\n\n${effectivePrompt}`
-        : effectivePrompt;
+        ? `${headJudgmentBlock}\n\n${dispatchPrompt}`
+        : dispatchPrompt;
 
       run.result = await dispatch({
         decision,
         prompt: directPrompt,
-        files,
+        files: dispatchFiles,
         cwd,
         dryRun: false,
         verbose,