dual-brain 0.2.30 → 0.3.0

package/src/governance.mjs

@@ -1,279 +0,0 @@
-// governance.mjs — Model tier enforcement + multi-model collaboration
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-// ─── Tier Definitions ────────────────────────────────────────────────────────
-
-export const MODEL_TIERS = Object.freeze({
-  1: {
-    label: 'lightweight',
-    models: ['claude-haiku-4-5-20251001', 'haiku', 'gpt-4o-mini', 'o4-mini'],
-    autoApprove: true,
-  },
-  2: {
-    label: 'standard',
-    models: ['claude-sonnet-4-6', 'sonnet', 'gpt-4o', 'gpt-4.1'],
-    autoApprove: true,
-  },
-  3: {
-    label: 'heavy',
-    models: ['claude-opus-4-6', 'claude-opus-4-7', 'opus', 'o3'],
-    autoApprove: false, // requires consent check per profile
-  },
-});
-
-// Reverse lookup: model ID → tier number
-export function getModelTier(modelId) {
-  if (!modelId) return 2; // default to standard
-  const normalized = String(modelId).toLowerCase();
-  for (const [tier, def] of Object.entries(MODEL_TIERS)) {
-    if (def.models.some(m => normalized.includes(m))) return Number(tier);
-  }
-  return 2; // unknown models default to standard
-}
-
-// ─── Task Scoring ────────────────────────────────────────────────────────────
-
-export function scoreTask(detection) {
-  // detection comes from detect.mjs — has intent, risk, scope, files, etc.
-  const scores = {
-    complexity: 0,  // 0-3
-    risk: 0,        // 0-3
-    creativity: 0,  // 0-2
-    precision: 0,   // 0-2
-    contextVolume: 0, // 0-3
-  };
-
-  // Complexity from file count / scope
-  const fileCount = detection?.files?.length || detection?.scope?.fileCount || 0;
-  if (fileCount >= 6) scores.complexity = 3;
-  else if (fileCount >= 3) scores.complexity = 2;
-  else if (fileCount >= 1) scores.complexity = 1;
-
-  // Risk from explicit risk field or keywords
-  const risk = detection?.risk || detection?.riskLevel || 'low';
-  const riskMap = { low: 0, medium: 1, high: 2, critical: 3 };
-  scores.risk = riskMap[risk] ?? 0;
-
-  // Boost risk for security/auth/billing keywords
-  const text = (detection?.objective || detection?.intent || '').toLowerCase();
-  if (/\b(auth|security|credential|secret|billing|payment|migration|delete|drop)\b/.test(text)) {
-    scores.risk = Math.max(scores.risk, 2);
-  }
-
-  // Creativity from intent type
-  const intent = (detection?.intent || detection?.type || '').toLowerCase();
-  if (/\b(architect|design|brainstorm|explore|research)\b/.test(intent)) scores.creativity = 2;
-  else if (/\b(refactor|plan|decide)\b/.test(intent)) scores.creativity = 1;
-
-  // Precision — one-shot tasks need higher precision
-  if (/\b(security|deploy|publish|migration)\b/.test(text)) scores.precision = 2;
-  else if (/\b(implement|build|create)\b/.test(text)) scores.precision = 1;
-
-  // Context volume
-  const contextSize = detection?.contextTokens || detection?.estimatedContext || 0;
-  if (contextSize > 200000) scores.contextVolume = 3;
-  else if (contextSize > 50000) scores.contextVolume = 2;
-  else if (contextSize > 10000) scores.contextVolume = 1;
-
-  return scores;
-}
-
-export function computeRequiredTier(scores) {
-  const total = Object.values(scores).reduce((a, b) => a + b, 0);
-  if (total <= 2) return 1;
-  if (total <= 6) return 2;
-  return 3;
-}
-
-// ─── Governance Assessment ───────────────────────────────────────────────────
-
-// Profile governance defaults
-const GOVERNANCE_PERMISSIONS = {
-  'auto':          { 1: 'auto', 2: 'auto', 3: 'ask' },
-  'balanced':      { 1: 'auto', 2: 'auto', 3: 'ask' },
-  'cost-saver':    { 1: 'auto', 2: 'auto', 3: 'deny' },
-  'quality-first': { 1: 'auto', 2: 'auto', 3: 'auto' },
-};
-
-// Pricing per million tokens (input/output) for cost estimation
-const MODEL_PRICING = {
-  'haiku':  { input: 1.00, output: 5.00 },
-  'sonnet': { input: 3.00, output: 15.00 },
-  'opus':   { input: 5.00, output: 25.00 },
-  'gpt-4o-mini': { input: 0.15, output: 0.60 },
-  'gpt-4o': { input: 2.50, output: 10.00 },
-  'gpt-4.1': { input: 2.00, output: 8.00 },
-  'o3': { input: 2.00, output: 8.00 },
-  'o4-mini': { input: 1.10, output: 4.40 },
-};
-
-function estimateCost(modelId, estimatedTokens = 8000) {
-  const normalized = String(modelId).toLowerCase();
-  let pricing = MODEL_PRICING['sonnet']; // default
-  for (const [key, p] of Object.entries(MODEL_PRICING)) {
-    if (normalized.includes(key)) { pricing = p; break; }
-  }
-  // Assume 20% input, 80% output for agent tasks
-  const inputTokens = estimatedTokens * 0.2;
-  const outputTokens = estimatedTokens * 0.8;
-  return (inputTokens * pricing.input + outputTokens * pricing.output) / 1_000_000;
-}
-
-export function assessGovernance(model, detection, profile) {
-  const tier = getModelTier(model);
-  const scores = scoreTask(detection);
-  const requiredTier = computeRequiredTier(scores);
-  const workStyle = profile?.workStyle || profile?.name || 'auto';
-  const permissions = GOVERNANCE_PERMISSIONS[workStyle] || GOVERNANCE_PERMISSIONS['auto'];
-  const permission = permissions[tier] || 'ask';
-  const estimatedCost = estimateCost(model);
-
-  return {
-    requestedTier: tier,
-    requiredTier,
-    overProvisioned: tier > requiredTier,
-    underProvisioned: tier < requiredTier,
-    permission, // 'auto' | 'ask' | 'deny'
-    estimatedCost,
-    scores,
-    justification: buildJustification(scores, tier, requiredTier),
-  };
-}
-
-function buildJustification(scores, requestedTier, requiredTier) {
-  const parts = [];
-  if (scores.risk >= 2) parts.push('high-risk');
-  if (scores.complexity >= 2) parts.push('complex');
-  if (scores.creativity >= 2) parts.push('creative/architectural');
-  if (scores.contextVolume >= 2) parts.push('large-context');
-  if (requestedTier > requiredTier) parts.push('over-provisioned');
-  if (requestedTier < requiredTier) parts.push('under-provisioned');
-  return parts.join(', ') || 'standard task';
-}
-
-// ─── Collaboration Assessment ────────────────────────────────────────────────
-
-export function shouldCollaborate(detection, governance, profile) {
-  // Never collaborate on tier-1 tasks
-  if (governance.requiredTier <= 1) return { collaborate: false };
-
-  // Never collaborate in cost-saver mode unless explicitly requested
-  const workStyle = profile?.workStyle || profile?.name || 'auto';
-  if (workStyle === 'cost-saver') return { collaborate: false };
-
-  // Check collaboration triggers (need ANY two)
-  const triggers = [];
-  const text = (detection?.objective || detection?.intent || '').toLowerCase();
-
-  if (/\b(auth|security|credential|billing|migration)\b/.test(text)) triggers.push('irreversibility');
-  if (detection?.ambiguity === 'high' || /\b(should we|how to|best approach|tradeoff)\b/.test(text)) triggers.push('ambiguity');
-  if (detection?.novelty === 'high' || /\b(new|first time|never done|greenfield)\b/.test(text)) triggers.push('novelty');
-  if ((detection?.files?.length || 0) >= 4 && /\b(security|performance|ux)\b/.test(text)) triggers.push('cross-domain');
-  if (governance.requestedTier >= 3 && detection?.confidence && detection.confidence < 0.8) triggers.push('low-confidence');
-
-  const shouldDo = triggers.length >= 2;
-
-  return {
-    collaborate: shouldDo,
-    triggers,
-    pattern: shouldDo ? selectPattern(triggers, detection) : null,
-    estimatedOverhead: shouldDo ? estimateCost('gpt-4.1') : 0, // secondary model cost
-  };
-}
-
-function selectPattern(triggers, detection) {
-  const text = (detection?.objective || detection?.intent || '').toLowerCase();
-
-  // Security → adversarial review
-  if (triggers.includes('irreversibility') && /\b(auth|security|credential)\b/.test(text)) {
-    return 'adversarial-review';
-  }
-
-  // Architecture/greenfield → second opinion (perspective rotation reserved for Phase 4)
-  if (triggers.includes('novelty') || triggers.includes('ambiguity')) {
-    return 'second-opinion';
-  }
-
-  // Default
-  return 'second-opinion';
-}
-
-// ─── Governance State (Session Budget Tracking) ──────────────────────────────
-
-const STATE_FILE = '.dualbrain/governance-state.json';
-const SESSION_GAP_MS = 30 * 60 * 1000; // 30 min gap = new session
-
-export function loadGovernanceState(cwd) {
-  const statePath = join(cwd, STATE_FILE);
-  try {
-    const raw = JSON.parse(readFileSync(statePath, 'utf8'));
-    // Check if session is stale
-    const lastDispatch = raw.dispatches?.[raw.dispatches.length - 1];
-    if (lastDispatch && (Date.now() - Date.parse(lastDispatch.ts)) > SESSION_GAP_MS) {
-      // Stale session — reset
-      return freshState();
-    }
-    return raw;
-  } catch {
-    return freshState();
-  }
-}
-
-function freshState() {
-  return {
-    sessionStartedAt: new Date().toISOString(),
-    dispatches: [],
-    totalEstimatedCost: 0,
-    tierCounts: { 1: 0, 2: 0, 3: 0 },
-  };
-}
-
-export function recordDispatch(cwd, tier, model, estimatedCost, approved = true) {
-  const state = loadGovernanceState(cwd);
-  state.dispatches.push({
-    tier,
-    model: String(model),
-    estimatedCost,
-    approved,
-    ts: new Date().toISOString(),
-  });
-  state.totalEstimatedCost += estimatedCost;
-  state.tierCounts[tier] = (state.tierCounts[tier] || 0) + 1;
-
-  const dir = join(cwd, '.dualbrain');
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(join(cwd, STATE_FILE), JSON.stringify(state, null, 2) + '\n');
-  return state;
-}
-
-export function checkBudget(cwd, orchestratorConfig) {
-  const state = loadGovernanceState(cwd);
-  const sessionLimit = orchestratorConfig?.budgets?.session_limit_usd || 10;
-  const remaining = sessionLimit - state.totalEstimatedCost;
-
-  return {
-    spent: state.totalEstimatedCost,
-    remaining,
-    limit: sessionLimit,
-    warning: remaining < sessionLimit * 0.2, // <20% remaining
-    blocked: remaining <= 0,
-    tierCounts: state.tierCounts,
-  };
-}
-
-// ─── Format for User Display ─────────────────────────────────────────────────
-
-export function formatGovernancePrompt(governance, collaboration) {
-  const tierLabel = MODEL_TIERS[governance.requestedTier]?.label || 'unknown';
-  const lines = [];
-
-  lines.push(`[governance] Task requires ${tierLabel} model (tier ${governance.requestedTier}, ~$${governance.estimatedCost.toFixed(2)})`);
-  if (governance.justification) lines.push(`  Reason: ${governance.justification}`);
-  if (collaboration?.collaborate) {
-    lines.push(`  + ${collaboration.pattern} with secondary model (+$${collaboration.estimatedOverhead.toFixed(2)})`);
-  }
-
-  return lines.join('\n');
-}

package/src/handoff.mjs

@@ -1,87 +0,0 @@
-// handoff.mjs — Typed handoffs between pipeline stages
-import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-
-export const HANDOFF_TYPES = {
-  'think-to-work':  { required: ['objective', 'files', 'criteria'], optional: ['context', 'confidence'] },
-  'work-to-review': { required: ['filesChanged', 'objective'],      optional: ['diff', 'criteria', 'testsRun'] },
-  'review-to-head': { required: ['pass'],                           optional: ['findings', 'recommendation', 'severity'] },
-};
-
-const hDir  = (cwd) => join(cwd || process.cwd(), '.dualbrain', 'handoffs');
-const hPath = (id, f, t, cwd) => join(hDir(cwd), `${id}_${f}_${t}.json`);
-
-function validate(from, to, data) {
-  const schema = HANDOFF_TYPES[`${from}-to-${to}`];
-  if (!schema) return;
-  for (const f of schema.required) {
-    if (!(f in data)) process.stderr.write(`[handoff] warn: missing required field '${f}' in ${from}-to-${to}\n`);
-  }
-}
-
-export function createHandoff(fromStage, toStage, data, runId, cwd) {
-  try {
-    validate(fromStage, toStage, data);
-    const safeRunId = String(runId).replace(/[^a-z0-9_-]/gi, '_').slice(0, 50);
-    const dir = hDir(cwd);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    const record = { fromStage, toStage, runId: safeRunId, createdAt: new Date().toISOString(), data };
-    const dest = hPath(safeRunId, fromStage, toStage, cwd); const tmp = dest + '.tmp';
-    writeFileSync(tmp, JSON.stringify(record, null, 2), 'utf8');
-    try { renameSync(tmp, dest); } catch { writeFileSync(dest, JSON.stringify(record, null, 2), 'utf8'); }
-    return record;
-  } catch { return null; }
-}
-
-export function consumeHandoff(runId, fromStage, toStage, cwd) {
-  try {
-    const safeRunId = String(runId).replace(/[^a-z0-9_-]/gi, '_').slice(0, 50);
-    const p = hPath(safeRunId, fromStage, toStage, cwd);
-    if (!existsSync(p)) return null;
-    const record = JSON.parse(readFileSync(p, 'utf8'));
-    try { unlinkSync(p); } catch { /* best-effort */ }
-    return record;
-  } catch { return null; }
-}
-
-export function buildHandoffContext(handoff, targetRole) {
-  if (!handoff?.data) return '';
-  const d = handoff.data;
-  const lines = (...parts) => parts.filter(Boolean).join('\n');
-  const list  = (v) => Array.isArray(v) ? v.join(', ') : (v ?? '');
-  const items = (v) => Array.isArray(v) ? v.map(x => `  - ${x}`).join('\n') : (v ?? '');
-
-  if (targetRole === 'worker' && handoff.fromStage === 'thinker') return lines(
-    '## Handoff from Think Stage',
-    `**Objective:** ${d.objective ?? '(none)'}`,
-    `**Files in scope:** ${list(d.files) || 'unspecified'}`,
-    d.criteria  ? `**Acceptance criteria:**\n${items(d.criteria)}` : '',
-    d.context   ? `**Context:** ${d.context}` : '',
-    d.confidence != null ? `**Thinker confidence:** ${d.confidence}` : '',
-  );
-  if (targetRole === 'reviewer' && handoff.fromStage === 'worker') return lines(
-    '## Handoff from Work Stage',
-    `**Objective:** ${d.objective ?? '(none)'}`,
-    `**Files changed:** ${list(d.filesChanged) || 'unknown'}`,
-    d.criteria ? `**Original criteria:** ${Array.isArray(d.criteria) ? d.criteria.join('; ') : d.criteria}` : '',
-    d.testsRun ? `**Tests run:** ${d.testsRun}` : '',
-    d.diff     ? `**Diff summary:**\n\`\`\`\n${d.diff.slice(0, 1200)}\n\`\`\`` : '',
-  );
-  if (targetRole === 'head' && handoff.fromStage === 'reviewer') return lines(
-    `## Review Result: ${d.pass ? 'PASS' : 'FAIL'}`,
-    d.findings       ? `**Findings:**\n${items(d.findings)}` : '',
-    d.recommendation ? `**Recommendation:** ${d.recommendation}` : '',
-    d.severity       ? `**Severity:** ${d.severity}` : '',
-  );
-  return JSON.stringify(handoff.data, null, 2);
-}
-
-export function cleanupHandoffs(runId, cwd) {
-  try {
-    const dir = hDir(cwd);
-    if (!existsSync(dir)) return;
-    for (const name of readdirSync(dir)) {
-      if (name.startsWith(`${runId}_`)) try { unlinkSync(join(dir, name)); } catch { /* best-effort */ }
-    }
-  } catch { /* non-throwing */ }
-}

package/src/head-protocol.mjs

@@ -1,128 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { processTurn, loadState } from './head.mjs';
-
-const DUALBRAIN = join(process.cwd(), '.dualbrain');
-const DELIBERATION_FILE = join(DUALBRAIN, 'deliberation.json');
-
-/**
- * Write the deliberation artifact after running HEAD's cognitive pipeline.
- * This is the contract between HEAD's thinking and the deliberation-gate hook.
- *
- * @param {string} userMessage - The user's message to deliberate on
- * @param {object} context - Optional context (files, priorFailures, patterns, etc.)
- * @returns {object} The full deliberation result from processTurn
- */
-export function writeDeliberation(userMessage, context = {}) {
-  const state = loadState();
-  const result = processTurn(state, userMessage, context);
-
-  // Determine if there are multiple independent sub-tasks that could be parallelized
-  const dispatchPlan = _deriveDispatchPlan(result, context);
-
-  // Build the artifact
-  const artifact = {
-    timestamp: Date.now(),
-    createdAt: Date.now(),
-    message: userMessage.slice(0, 500),
-
-    // Core deliberation fields
-    action: result.action,
-    result: result.result,
-    shouldAskUser: result.shouldAskUser,
-    confidence: result.result?.confidence || null,
-
-    // Obligations and noticings
-    obligations: result.obligations || [],
-    surfaceNoticings: result.result?.surfaceNoticings || [],
-
-    // Dispatch plan (parallel-wave support)
-    dispatchPlan,
-
-    // Metadata
-    depth: result.depth,
-    rationale: result.rationale,
-    situation: {
-      taskShape: result.situation?.taskShape || null,
-      urgency: result.situation?.urgency || null,
-      scope: result.situation?.taskShape?.scope || null,
-    },
-  };
-
-  // Write atomically
-  mkdirSync(DUALBRAIN, { recursive: true });
-  const tmpFile = DELIBERATION_FILE + '.tmp.' + process.pid;
-  writeFileSync(tmpFile, JSON.stringify(artifact, null, 2));
-  renameSync(tmpFile, DELIBERATION_FILE);
-
-  return result;
-}
-
-/**
- * Read the current deliberation artifact.
- * @returns {object|null} The deliberation artifact, or null if not found/unreadable.
- */
-export function readDeliberation() {
-  try {
-    if (!existsSync(DELIBERATION_FILE)) return null;
-    return JSON.parse(readFileSync(DELIBERATION_FILE, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Check if the current deliberation is fresh (within maxAgeMs).
- * @param {number} maxAgeMs - Maximum age in milliseconds (default 60000)
- * @returns {boolean} True if deliberation exists and is fresh.
- */
-export function isDeliberationFresh(maxAgeMs = 60_000) {
-  const delib = readDeliberation();
-  if (!delib) return false;
-  const timestamp = delib.timestamp || delib.createdAt || 0;
-  return (Date.now() - timestamp) <= maxAgeMs;
-}
-
-// ── Internal helpers ─────────────────────────────────────────────────────────
-
-/**
- * Derive a dispatch plan when the situation has multiple independent sub-tasks.
- * Returns null if parallel dispatch is not applicable.
- */
-function _deriveDispatchPlan(result, context) {
-  const situation = result.situation;
-  if (!situation) return null;
-
-  // Only generate a parallel plan for multi-file, non-trivial work
-  const scope = situation.taskShape?.scope;
-  const actionType = result.action?.type;
-
-  if (scope !== 'large' && scope !== 'medium') return null;
-  if (actionType !== 'dispatch' && actionType !== 'proceed') return null;
-
-  // Check for independent sub-tasks from context
-  const subtasks = context.subtasks || [];
-  if (subtasks.length < 2) {
-    // Heuristic: large scope with multiple files could be parallel
-    const fileCount = situation.material?.touchedFiles?.length || 0;
-    if (fileCount < 3) return null;
-
-    return {
-      strategy: 'parallel-wave',
-      id: Date.now().toString(36),
-      expectedParallel: Math.min(fileCount, 5),
-      waveSize: Math.min(fileCount, 5),
-      reason: `${fileCount} independent files detected`,
-    };
-  }
-
-  return {
-    strategy: 'parallel-wave',
-    id: Date.now().toString(36),
-    expectedParallel: subtasks.length,
-    waveSize: subtasks.length,
-    subtasks: subtasks.map(t => typeof t === 'string' ? t : t.name || t.description),
-    reason: `${subtasks.length} independent sub-tasks identified`,
-  };
-}
-