dual-brain 0.1.22 → 0.2.0

package/src/pipeline.mjs

@@ -28,6 +28,12 @@ export function createPipelineRun(trigger = '', prompt = '') {
     trigger,
     prompt,
 
+    // Phase 0: Intelligence
+    projectBrief: null,    // from deriveProjectState
+    taskBrief: null,       // from deriveTaskContext
+    contradictions: [],    // from detectContradictions
+    situationBrief: null,  // formatted string from formatBrief
+
     // Phase 1: Context
     context: null,
     failureHistory: null,   // result of checkFailureHistory — even empty counts as "queried"
@@ -54,6 +60,22 @@ export function createPipelineRun(trigger = '', prompt = '') {
     // Phase 5: Outcome
     outcome: null,
 
+    // Ledger + calibration
+    taskId: null,           // ledger task ID for this run
+    openTasks: [],          // pending tasks from ledger
+    calibration: null,      // user calibration state
+    adaptation: null,       // behavior adaptation from calibration
+
+    // Prompt intelligence + environment
+    promptAnalysis: null,   // from analyzePrompt
+    enrichedPrompt: null,   // from enrichPrompt
+    environment: null,      // from scanEnvironment
+    modelSuggestion: null,  // from suggestModel
+
+    // Think-engine fields
+    thinkResult: null,       // from think-engine
+    decisionPreflight: null, // from lookupDecision
+
     completedAt: null,
   };
 }
@@ -367,7 +389,7 @@ export function buildExecutionPlan(contextPack, trigger, options = {}) {
     effort: depthToEffort[reasoningDepth] ?? detection.effort,
   };
 
-  const decision = decideRoute({ profile, detection: detectionWithDepth, cwd: contextPack.cwd });
+  const decision = decideRoute({ profile, detection: detectionWithDepth, cwd: contextPack.cwd, thinkResult: options.thinkResult });
 
   // Resolve full model ID for display (mirrors dispatch.mjs CLAUDE_MODEL_IDS)
   const CLAUDE_MODEL_IDS = { opus: 'claude-opus-4-6', sonnet: 'claude-sonnet-4-6', haiku: 'claude-haiku-4-5-20251001' };
@@ -633,15 +655,164 @@ export async function runPipeline(trigger, prompt, options = {}) {
   const run = createPipelineRun(trigger, prompt);
 
   try {
+    // ── Phase 0: Situational awareness ───────────────────────────────────────
+
+    try {
+      const { deriveProjectState, deriveTaskContext, detectContradictions, formatBrief } = await import('./intelligence.mjs');
+      run.projectBrief = await deriveProjectState(options.cwd || process.cwd());
+      run.taskBrief = deriveTaskContext(prompt, options.recentEvents || []);
+      run.situationBrief = formatBrief(run.projectBrief, run.taskBrief);
+    } catch (e) {
+      // intelligence module not available — continue without it (degraded)
+    }
+
+    // Doctor: discover capabilities (cached per process via discovery log)
+    try {
+      const { discover, verifyAll } = await import('./doctor.mjs');
+      const doctorCwd = options.cwd || process.cwd();
+      discover(doctorCwd);    // writes to .dual-brain/discoveries.jsonl (idempotent)
+      verifyAll(doctorCwd);   // writes to .dual-brain/verifications.jsonl
+    } catch (e) {
+      // doctor not available — non-blocking
+    }
+
+    // Ledger: check open tasks + create task for this run
+    try {
+      const { getOpenTasks, createTask, reconcile } = await import('./ledger.mjs');
+      const cwd = options.cwd || process.cwd();
+
+      // Check for stale tasks on session start
+      run.openTasks = getOpenTasks(cwd);
+      const staleTasks = reconcile(cwd);
+
+      // Create a ledger task for this pipeline run
+      const task = createTask({
+        intent: prompt,
+        owner: 'head',
+        priority: run.projectBrief?.recentFailures?.length > 0 ? 'high' : 'medium',
+        files: options.files || []
+      }, cwd);
+      run.taskId = task.id;
+    } catch (e) {
+      // ledger not available — continue degraded
+    }
+
+    // Append open tasks to situation brief if any exist
+    if (run.openTasks.length > 0) {
+      const preview = run.openTasks.slice(0, 3).map(t => t.intent).join(', ');
+      const pendingLine = `PENDING TASKS: ${run.openTasks.length} open (${preview})`;
+      run.situationBrief = run.situationBrief
+        ? `${run.situationBrief}\n${pendingLine}`
+        : pendingLine;
+    }
+
+    // Calibration: analyze user input and adapt
+    try {
+      const { analyzeInput, getAdaptation, detectCorrection, updateCalibration } = await import('./calibration.mjs');
+      const { getProjectState, updateProject } = await import('./living-docs.mjs');
+      const cwd = options.cwd || process.cwd();
+
+      const projectState = getProjectState(cwd);
+      const currentCal = projectState?.project?.userCalibration || { specificity: 3, corrections: 3, autonomy: 3, interactions: 0 };
+      const isCorrection = detectCorrection(prompt);
+
+      run.calibration = updateCalibration(currentCal, prompt, isCorrection);
+      run.adaptation = getAdaptation(run.calibration);
+
+      // Persist updated calibration
+      updateProject({ userCalibration: run.calibration }, cwd);
+    } catch (e) {
+      // calibration not available — continue degraded
+    }
+
+    // Environment awareness
+    try {
+      const { scanEnvironment, getCapabilitySummary } = await import('./awareness.mjs');
+      run.environment = scanEnvironment(cwd);
+
+      // Add capabilities to situation brief
+      if (run.situationBrief && run.environment) {
+        const caps = getCapabilitySummary(run.environment);
+        if (caps.length > 0) {
+          run.situationBrief += '\nCAPABILITIES: ' + caps.join(', ');
+        }
+      }
+    } catch (e) {
+      // awareness not available
+    }
+
+    // Knowledge preflight — check if we already know the answer
+    try {
+      const { lookupDecision, triageQuestion } = await import('./think-engine.mjs');
+      const cwd = options.cwd || process.cwd();
+
+      run.decisionPreflight = lookupDecision(prompt, options.tags || [], cwd);
+
+      // If exact reuse found, we can short-circuit
+      if (run.decisionPreflight.recommendation === 'reuse' && run.decisionPreflight.candidates[0]) {
+        // Add cached decision info to situation brief
+        if (run.situationBrief) {
+          run.situationBrief += '\nCACHED DECISION: Found prior decision with ' +
+            Math.round(run.decisionPreflight.candidates[0].relevance * 100) + '% relevance';
+        }
+      }
+
+      // Triage to determine thinking tier
+      const triage = triageQuestion(prompt, run.projectBrief, run.decisionPreflight);
+      run.thinkResult = { tier: triage.recommendedTier, estimatedTokens: triage.estimatedTokens, triage };
+
+      // Add to situation brief
+      if (run.situationBrief) {
+        run.situationBrief += '\nTHINK TIER: ' + triage.recommendedTier + ' (' + triage.estimatedTokens + ' tokens est.)';
+      }
+    } catch (e) {
+      // think-engine not available
+    }
+
+    // Prompt intelligence
+    try {
+      const { analyzePrompt, enrichPrompt, shouldBlock, getBlockReason } = await import('./prompt-intel.mjs');
+
+      run.promptAnalysis = analyzePrompt(prompt, run.projectBrief, run.calibration);
+
+      // Hard block on dangerous intent
+      if (shouldBlock(run.promptAnalysis)) {
+        const reason = getBlockReason(run.promptAnalysis);
+        if (run.taskId) {
+          try {
+            const { failTask } = await import('./ledger.mjs');
+            failTask(run.taskId, 'Blocked by risk detection: ' + reason, cwd);
+          } catch (e) {}
+        }
+        run.completedAt = Date.now();
+        return {
+          success: false,
+          gateFailure: 'risk',
+          reason: 'Prompt blocked: ' + reason,
+          promptAnalysis: run.promptAnalysis,
+          run
+        };
+      }
+
+      // Enrich prompt if intervention says so
+      if (run.promptAnalysis.intervention === 'silent_enrich' || run.promptAnalysis.intervention === 'confirm_rewrite') {
+        run.enrichedPrompt = enrichPrompt(prompt, run.projectBrief, run.promptAnalysis);
+      }
+    } catch (e) {
+      // prompt-intel not available
+    }
+
     // ── Phase 1: Context ──────────────────────────────────────────────────────
 
+    const effectivePrompt = run.enrichedPrompt || prompt;
+
     // Build context pack
-    run.context = await buildContextPack(prompt, files, cwd);
+    run.context = await buildContextPack(effectivePrompt, files, cwd);
 
     // Query failure history (must happen before context gate)
     try {
       const { checkFailureHistory } = await import('./failure-memory.mjs');
-      run.failureHistory = await checkFailureHistory(prompt, files, cwd);
+      run.failureHistory = await checkFailureHistory(effectivePrompt, files, cwd);
     } catch {
       // failure-memory.mjs unavailable — set to empty result so gate still passes
       run.failureHistory = { hasPriorFailures: false, failureCount: 0, lastFailure: null, escalation: { recommended: false } };
@@ -650,7 +821,7 @@ export async function runPipeline(trigger, prompt, options = {}) {
     // Query relevant outcomes (must happen before context gate)
     try {
       const { getRelevantOutcomes } = await import('./outcome.mjs');
-      run.priorOutcomes = await getRelevantOutcomes(prompt, files, cwd);
+      run.priorOutcomes = await getRelevantOutcomes(effectivePrompt, files, cwd);
     } catch {
       // outcome.mjs unavailable — set to empty array so gate still passes
       run.priorOutcomes = [];
@@ -664,12 +835,62 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
     // ── Phase 2: Plan ─────────────────────────────────────────────────────────
 
-    run.plan = buildExecutionPlan(run.context, trigger, { forceDepth, forceChallenger });
+    run.plan = buildExecutionPlan(run.context, trigger, { forceDepth, forceChallenger, thinkResult: run.thinkResult });
+
+    // Model intelligence
+    try {
+      const { suggestModel, getRegistryAge } = await import('./models.mjs');
+      const availableProviders = [];
+      if (run.environment?.secrets?.ANTHROPIC_API_KEY || run.environment?.claudeCode?.isInsideClaude) availableProviders.push('anthropic');
+      if (run.environment?.secrets?.OPENAI_API_KEY) availableProviders.push('openai');
+
+      const intent = run.promptAnalysis?.intent?.type || 'execute';
+      const risk = run.plan?.risk || 'medium';
+      const complexity = run.plan?.complexity || 'medium';
+
+      run.modelSuggestion = suggestModel(intent, risk, complexity, availableProviders);
+
+      // Warn if model registry is stale
+      const age = getRegistryAge();
+      if (age > 30 && run.situationBrief) {
+        run.situationBrief += '\nWARNING: Model registry is ' + age + ' days old';
+      }
+    } catch (e) {
+      // models not available
+    }
 
     if (verbose || dryRun) {
       log(formatExecutionPlan(run.plan));
     }
 
+    // Contradiction detection
+    if (run.projectBrief && run.plan) {
+      try {
+        const { detectContradictions } = await import('./intelligence.mjs');
+        const planForCheck = {
+          description: run.plan.description || prompt,
+          targetFiles: run.plan.targetFiles || run.plan.files || [],
+          assumptions: run.plan.assumptions || {}
+        };
+        run.contradictions = detectContradictions(run.projectBrief, run.taskBrief, planForCheck);
+
+        // Any blocking contradiction fails the pipeline
+        const blockers = run.contradictions.filter(c => c.severity === 'block');
+        if (blockers.length > 0) {
+          run.completedAt = Date.now();
+          return {
+            success: false,
+            gateFailure: 'contradiction',
+            reason: blockers.map(b => b.message).join('; '),
+            contradictions: blockers,
+            run
+          };
+        }
+      } catch (e) {
+        // contradiction detection failed — continue (degraded)
+      }
+    }
+
     // Gate 2: Planning gate
     if (!runGate(run, 'planning', planningGate)) {
       run.completedAt = Date.now();
@@ -684,8 +905,21 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
     if (dryRun) {
       run.completedAt = Date.now();
-      // Return legacy-compatible shape for dry-run callers
-      return { plan: run.plan, result: null, verification: null, run };
+      // Return legacy-compatible shape plus intelligence fields for dry-run callers
+      return {
+        plan: run.plan,
+        result: null,
+        verification: null,
+        run,
+        // Intelligence fields (mirrors full execution return)
+        projectBrief:     run.projectBrief,
+        contradictions:   run.contradictions,
+        promptAnalysis:   run.promptAnalysis,
+        environment:      run.environment,
+        modelSuggestion:  run.modelSuggestion,
+        thinkResult:      run.thinkResult,
+        decisionPreflight: run.decisionPreflight,
+      };
     }
 
     // Gate 4: Execution gate (cleared to work?)
@@ -705,14 +939,58 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
     run.result = await dispatch({
       decision,
-      prompt,
+      prompt: effectivePrompt,
       files,
       cwd,
       dryRun: false,
       verbose,
       profile: run.context.profile,
+      situationBrief: run.situationBrief,
+      adaptation: run.adaptation,
+      modelSuggestion: run.modelSuggestion,
     });
 
+    // Update ledger task with result
+    if (run.taskId) {
+      const { updateTask, failTask } = await import('./ledger.mjs');
+      const ledgerCwd = options.cwd || process.cwd();
+
+      if (run.result && !run.result.error) {
+        // updateTask throws if proof/result is missing — let that propagate so
+        // the outcome gate catches it rather than silently succeeding.
+        updateTask(run.taskId, {
+          status: 'done',
+          result: typeof run.result === 'string' ? run.result : JSON.stringify(run.result).slice(0, 500),
+          proof: run.verification ? 'Pipeline verification passed' : 'Execution completed',
+          files: run.result.filesChanged || run.plan?.targetFiles || []
+        }, ledgerCwd);
+      } else {
+        try {
+          failTask(run.taskId, run.result?.error || 'Pipeline execution failed', ledgerCwd);
+        } catch (e) {
+          // failTask failure is non-blocking
+        }
+      }
+    }
+
+    // Record action in living docs
+    try {
+      const { appendAction } = await import('./living-docs.mjs');
+      const cwd = options.cwd || process.cwd();
+
+      appendAction({
+        type: trigger || 'task',
+        intent: prompt,
+        status: (run.result && !run.result.error) ? 'done' : 'failed',
+        owner: 'head',
+        files: run.result?.filesChanged || run.plan?.targetFiles || [],
+        proof: run.verification ? JSON.stringify(run.verification).slice(0, 200) : null,
+        result: typeof run.result === 'string' ? run.result.slice(0, 300) : null
+      }, cwd);
+    } catch (e) {
+      // living docs not available — non-blocking
+    }
+
     // ── Phase 4: Verification ─────────────────────────────────────────────────
 
     run.verification = await verify(run.result, run.plan, cwd);
@@ -726,6 +1004,62 @@ export async function runPipeline(trigger, prompt, options = {}) {
       _incrementFailureCache(prompt);
     }
 
+    // Track cost after verification (fail-silent — advisory only)
+    try {
+      const { trackCost } = await import('./cost-tracker.mjs');
+      const tokensEstimated =
+        (run.result?.usage?.inputTokens ?? run.result?.tokensUsed?.input ?? 0) +
+        (run.result?.usage?.outputTokens ?? run.result?.tokensUsed?.output ?? 0);
+      trackCost({
+        action: trigger || 'execute',
+        model:  run.result?.model ?? run.plan?._decision?.model ?? 'default',
+        tier:   run.plan?.tier ?? 'standard',
+        tokensEstimated,
+        wasCacheHit: false,
+        tokensSaved: 0,
+      }, cwd);
+    } catch (e) {
+      // cost-tracker not available — non-blocking
+    }
+
+    // Living docs: update state after significant execution (fail-silent — advisory only)
+    try {
+      const { updateState } = await import('./living-docs.mjs');
+      const docsCwd = options.cwd || process.cwd();
+      const successFlag = run.result && !run.result.error && run.verification.ok;
+      const stateEntry =
+        `# Current State\n\nLast run: ${new Date().toISOString()}\n` +
+        `Task: ${prompt.slice(0, 120)}\n` +
+        `Status: ${successFlag ? 'completed' : 'failed'}\n` +
+        `Tier: ${run.plan?.tier ?? 'unknown'}\n` +
+        `Model: ${run.plan?.primaryModel ?? 'unknown'}\n`;
+      updateState(stateEntry, docsCwd);
+    } catch (e) {
+      // living-docs not available — non-blocking
+    }
+
+    // Doctor: record learning from this execution outcome (fail-silent)
+    try {
+      const { recordLearning } = await import('./doctor.mjs');
+      const doctorCwd = options.cwd || process.cwd();
+      const successFlag = run.result && !run.result.error && run.verification.ok;
+      recordLearning({
+        taskType:      run.context?.detection?.intent ?? 'unknown',
+        prompt,
+        model:         run.result?.model ?? run.plan?._decision?.model ?? '',
+        provider:      run.result?.provider ?? run.plan?.primaryProvider ?? '',
+        tier:          run.plan?.tier ?? '',
+        reasoningDepth: run.plan?.reasoningDepth ?? 'low',
+        wasEnriched:   !!run.enrichedPrompt,
+        wasDualBrain:  !!(run.plan?.useChallenger && run.plan?.challengerModel),
+        success:       successFlag,
+        duration:      run.completedAt ? (Date.now() - run.startedAt) : 0,
+        filesChanged:  (run.result?.filesChanged ?? []).length,
+      }, doctorCwd);
+    } catch (e) {
+      // doctor not available — non-blocking
+    }
+
     // ── Phase 5: Outcome ──────────────────────────────────────────────────────
 
     await recordOutcomeSafe(run);
@@ -736,6 +1070,23 @@ export async function runPipeline(trigger, prompt, options = {}) {
       return { success: false, gateFailure: 'outcome', reason: run.gates.outcome.reason, run };
     }
 
+    // Persist decision for future recall
+    if (run.result && !run.result?.error) {
+      try {
+        const { persistDecision } = await import('./think-engine.mjs');
+        const cwd = options.cwd || process.cwd();
+        persistDecision(
+          prompt,
+          typeof run.result === 'string' ? run.result : JSON.stringify(run.result).slice(0, 1000),
+          run.thinkResult?.tier || 'standard',
+          { tags: options.tags || [], projectBrief: run.projectBrief },
+          cwd
+        );
+      } catch (e) {
+        // persist failed — non-blocking
+      }
+    }
+
   } catch (err) {
     log(`[pipeline] error in pipeline step: ${err.message}`);
     run.result = { status: 'error', error: err.message };
@@ -751,6 +1102,14 @@ export async function runPipeline(trigger, prompt, options = {}) {
   return {
     success: true,
     run,
+    // Intelligence fields for callers to inspect
+    projectBrief: run.projectBrief,
+    contradictions: run.contradictions,
+    promptAnalysis: run.promptAnalysis,
+    environment: run.environment,
+    modelSuggestion: run.modelSuggestion,
+    thinkResult: run.thinkResult,
+    decisionPreflight: run.decisionPreflight,
     // Legacy compatibility
     plan: run.plan,
     result: run.result,