dual-brain 0.2.0 → 0.2.1

package/src/doctor.mjs

@@ -20,7 +20,7 @@
  *   verify, verifyAll, getVerificationCache, getStaleAssumptions, formatVerifications
  */
 
-import { existsSync, readFileSync, writeFileSync, renameSync, appendFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, appendFileSync, mkdirSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { readdir, readFile } from 'fs/promises';
 import { exec, execSync } from 'child_process';
@@ -1264,6 +1264,321 @@ export function formatDiscovery(result) {
   return lines.join('\n');
 }
 
+// ─── EVENT LEDGER ─────────────────────────────────────────────────────────────
+// Append-only event log at .dualbrain/doctor/events.jsonl
+// Event types: check_result, gate_failure, contradiction_caught, agent_drift,
+//              manual_fix, incident, check_proposed, check_promoted, check_demoted, check_sentineled
+
+function doctorDir(cwd) {
+  return join(cwd || process.cwd(), '.dualbrain', 'doctor');
+}
+
+function eventsPath(cwd) {
+  return join(doctorDir(cwd), 'events.jsonl');
+}
+
+function checksDir(cwd) {
+  return join(doctorDir(cwd), 'checks');
+}
+
+function ensureDoctorDir(cwd) {
+  try { mkdirSync(checksDir(cwd), { recursive: true }); } catch { /* ignore */ }
+}
+
+/**
+ * recordEvent(event, cwd) — append an event to the doctor event ledger.
+ * Event schema: { ts, type, source, checkId, severity, outcome, evidence, sessionId, release }
+ */
+export function recordEvent(event, cwd = process.cwd()) {
+  try {
+    ensureDoctorDir(cwd);
+    const entry = {
+      ts: new Date().toISOString(),
+      type: event.type || 'unknown',
+      source: event.source || 'pipeline',
+      checkId: event.checkId || null,
+      severity: event.severity || null,
+      outcome: event.outcome || null,
+      evidence: event.evidence || null,
+      sessionId: event.sessionId || null,
+      release: event.release || null,
+      ...event,  // allow extra fields
+    };
+    appendFileSync(eventsPath(cwd), JSON.stringify(entry) + '\n', 'utf8');
+    return entry;
+  } catch { return null; }
+}
+
+/**
+ * getRecentEvents(cwd, days) — read events from the last N days.
+ */
+export function getRecentEvents(cwd = process.cwd(), days = 7) {
+  const p = eventsPath(cwd);
+  if (!existsSync(p)) return [];
+  const cutoff = new Date(Date.now() - days * 86400000).toISOString();
+  try {
+    return readFileSync(p, 'utf8').trim().split('\n').filter(Boolean)
+      .flatMap(line => { try { return [JSON.parse(line)]; } catch { return []; } })
+      .filter(e => e.ts >= cutoff);
+  } catch { return []; }
+}
+
+/**
+ * getEventsForCheck(checkId, cwd) — filter ledger events by checkId.
+ */
+export function getEventsForCheck(checkId, cwd = process.cwd()) {
+  const p = eventsPath(cwd);
+  if (!existsSync(p)) return [];
+  try {
+    return readFileSync(p, 'utf8').trim().split('\n').filter(Boolean)
+      .flatMap(line => { try { return [JSON.parse(line)]; } catch { return []; } })
+      .filter(e => e.checkId === checkId);
+  } catch { return []; }
+}
+
+// ─── CHECK REGISTRY ───────────────────────────────────────────────────────────
+// Each check spec is stored as a JSON file in .dualbrain/doctor/checks/<id>.json
+
+const STATIC_CHECK_SEEDS = [
+  { id: 'package-name',     kind: 'package-json-field',  severity: 'fail' },
+  { id: 'version-scheme',   kind: 'package-json-field',  severity: 'fail' },
+  { id: 'bin-target',       kind: 'export-target',       severity: 'fail' },
+  { id: 'exports',          kind: 'export-target',       severity: 'fail' },
+  { id: 'required-files',   kind: 'file-exists',         severity: 'fail' },
+  { id: 'branding-check',   kind: 'forbidden-string',    severity: 'fail' },
+  { id: 'readme-commands',  kind: 'readme-contract',     severity: 'warn' },
+  { id: 'dead-exports',     kind: 'export-target',       severity: 'warn' },
+  { id: 'files-array',      kind: 'file-exists',         severity: 'warn' },
+  { id: 'cli-smoke-test',   kind: 'command-exit',        severity: 'fail' },
+  { id: 'npm-pack-dry-run', kind: 'command-exit',        severity: 'fail' },
+];
+
+function checkSpecPath(checkId, cwd) {
+  return join(checksDir(cwd), `${checkId}.json`);
+}
+
+function defaultSpec(seed) {
+  return {
+    id: seed.id,
+    kind: seed.kind,
+    severity: seed.severity,
+    source: seed.source || 'static',
+    status: seed.status || 'active',
+    sentinel: seed.sentinel || false,
+    createdAt: seed.createdAt || new Date().toISOString().slice(0, 10),
+    createdFrom: seed.createdFrom || null,
+    signal: {
+      hits: 0,
+      falsePositives: 0,
+      truePositives: 0,
+      lastSeen: null,
+      lastFailed: null,
+    },
+  };
+}
+
+/**
+ * getCheckRegistry(cwd) — load all check specs from the registry directory.
+ * Seeds static checks if they don't exist yet.
+ */
+export function getCheckRegistry(cwd = process.cwd()) {
+  try {
+    ensureDoctorDir(cwd);
+    // Seed static checks on first call
+    for (const seed of STATIC_CHECK_SEEDS) {
+      const p = checkSpecPath(seed.id, cwd);
+      if (!existsSync(p)) {
+        try {
+          writeFileSync(p, JSON.stringify(defaultSpec(seed), null, 2) + '\n', 'utf8');
+        } catch { /* ignore */ }
+      }
+    }
+    // Load all check specs
+    let entries;
+    try { entries = readdirSync(checksDir(cwd)).filter(f => f.endsWith('.json')); }
+    catch { return []; }
+    return entries.flatMap(fname => {
+      try { return [JSON.parse(readFileSync(join(checksDir(cwd), fname), 'utf8'))]; }
+      catch { return []; }
+    });
+  } catch { return []; }
+}
+
+/**
+ * registerCheck(spec, cwd) — add or update a check spec in the registry.
+ */
+export function registerCheck(spec, cwd = process.cwd()) {
+  if (!spec || !spec.id) throw new Error('registerCheck: spec.id is required');
+  try {
+    ensureDoctorDir(cwd);
+    const p = checkSpecPath(spec.id, cwd);
+    const existing = existsSync(p)
+      ? (() => { try { return JSON.parse(readFileSync(p, 'utf8')); } catch { return null; } })()
+      : null;
+    const merged = existing ? { ...existing, ...spec } : { ...defaultSpec(spec), ...spec };
+    writeFileSync(p, JSON.stringify(merged, null, 2) + '\n', 'utf8');
+    return merged;
+  } catch (e) { throw new Error(`registerCheck failed: ${e.message}`); }
+}
+
+/**
+ * updateCheckStats(checkId, outcome, cwd) — increment signal stats for a check.
+ * outcome: 'pass' | 'fail' | 'warn' | 'false_positive'
+ */
+export function updateCheckStats(checkId, outcome, cwd = process.cwd()) {
+  try {
+    ensureDoctorDir(cwd);
+    const p = checkSpecPath(checkId, cwd);
+    if (!existsSync(p)) return; // not registered — skip silently
+    let spec; try { spec = JSON.parse(readFileSync(p, 'utf8')); } catch { return; }
+    const signal = spec.signal || { hits: 0, falsePositives: 0, truePositives: 0, lastSeen: null, lastFailed: null };
+    const now = new Date().toISOString();
+    if (outcome === 'fail' || outcome === 'warn') {
+      signal.hits = (signal.hits || 0) + 1;
+      signal.truePositives = (signal.truePositives || 0) + 1;
+      signal.lastSeen = now;
+      signal.lastFailed = now;
+    } else if (outcome === 'false_positive') {
+      signal.hits = (signal.hits || 0) + 1;
+      signal.falsePositives = (signal.falsePositives || 0) + 1;
+      signal.lastSeen = now;
+    } else if (outcome === 'pass') {
+      signal.lastSeen = now;
+    }
+    spec.signal = signal;
+    writeFileSync(p, JSON.stringify(spec, null, 2) + '\n', 'utf8');
+  } catch { /* graceful degradation */ }
+}
+
+/**
+ * getCheckHealth(cwd) — summary of all checks with signal stats.
+ */
+export function getCheckHealth(cwd = process.cwd()) {
+  const registry = getCheckRegistry(cwd);
+  return registry.map(spec => {
+    const sig = spec.signal || {};
+    const hits = sig.hits || 0;
+    const fp = sig.falsePositives || 0;
+    const fpRate = hits >= 5 ? fp / hits : null;
+    return {
+      id: spec.id,
+      kind: spec.kind,
+      status: spec.status,
+      sentinel: spec.sentinel,
+      hits,
+      falsePositives: fp,
+      truePositives: sig.truePositives || 0,
+      fpRate,
+      lastSeen: sig.lastSeen,
+      lastFailed: sig.lastFailed,
+    };
+  });
+}
+
+// ─── RECONCILE ────────────────────────────────────────────────────────────────
+// Core invariant checks that should become sentinel candidates
+const SENTINEL_INVARIANTS = new Set(['version-scheme', 'package-name', 'bin-target']);
+
+const VALID_PRIMITIVES = new Set([
+  'file-exists', 'forbidden-string', 'command-exit', 'command-output',
+  'package-json-field', 'readme-contract', 'export-target',
+]);
+
+/**
+ * reconcile(cwd) — analyze events and check signal to surface improvement proposals.
+ * Returns { proposals, demotions, sentinels } — never auto-applies changes.
+ */
+export function reconcile(cwd = process.cwd()) {
+  const proposals = [];
+  const demotions = [];
+  const sentinels = [];
+
+  try {
+    const recentEvents = getRecentEvents(cwd, 7);
+    const registry = getCheckRegistry(cwd);
+    const checkMap = Object.fromEntries(registry.map(c => [c.id, c]));
+
+    // ── 1. Find incidents/gate_failures with no matching check_result failure ──
+    const incidents = recentEvents.filter(e =>
+      e.type === 'incident' || e.type === 'gate_failure'
+    );
+
+    for (const incident of incidents) {
+      const sessionId = incident.sessionId;
+      // Look for any check_result with outcome=fail in the same session
+      const caughtByCheck = recentEvents.some(e =>
+        e.type === 'check_result' &&
+        e.outcome === 'fail' &&
+        sessionId && e.sessionId === sessionId
+      );
+
+      if (!caughtByCheck && incident.evidence) {
+        // Propose a candidate check for this uncaught failure
+        const primitive = _inferPrimitive(incident.evidence);
+        if (primitive) {
+          proposals.push({
+            type: 'check_proposed',
+            candidateId: `auto-${Date.now()}-${proposals.length}`,
+            kind: primitive,
+            severity: 'warn',
+            source: 'reconcile',
+            status: 'quarantine',
+            createdFrom: incident.type,
+            evidence: incident.evidence,
+            rationale: `Uncaught ${incident.type}: ${String(incident.evidence).slice(0, 120)}`,
+          });
+        }
+      }
+    }
+
+    // ── 2. Checks with high false positive rate → recommend demotion ──────────
+    const health = getCheckHealth(cwd);
+    for (const h of health) {
+      if (h.status !== 'active') continue;
+      if (h.hits >= 5 && h.fpRate !== null && h.fpRate > 0.3) {
+        demotions.push({
+          checkId: h.id,
+          reason: `${Math.round(h.fpRate * 100)}% false positive rate over ${h.hits} runs`,
+          fpRate: h.fpRate,
+          hits: h.hits,
+        });
+      }
+    }
+
+    // ── 3. Checks that never fail in 20+ runs AND guard core invariants ────────
+    for (const h of health) {
+      if (h.status !== 'active') continue;
+      if (h.sentinel) continue; // already sentinel
+      const spec = checkMap[h.id];
+      if (!spec) continue;
+      const guardsInvariant = SENTINEL_INVARIANTS.has(h.id);
+      // Check hasn't fired but is tracking
+      const neverFailed = h.truePositives === 0 && h.hits >= 20;
+      if (guardsInvariant && neverFailed) {
+        sentinels.push({
+          checkId: h.id,
+          reason: `${h.hits} runs without failure — stable invariant guard`,
+          hits: h.hits,
+        });
+      }
+    }
+  } catch { /* graceful degradation — return empty results */ }
+
+  return { proposals, demotions, sentinels };
+}
+
+function _inferPrimitive(evidence) {
+  const s = String(evidence).toLowerCase();
+  if (s.includes('file') || s.includes('missing') || s.includes('not found')) return 'file-exists';
+  if (s.includes('string') || s.includes('branding') || s.includes('forbidden')) return 'forbidden-string';
+  if (s.includes('exit') || s.includes('failed') || s.includes('command')) return 'command-exit';
+  if (s.includes('package') || s.includes('version') || s.includes('name')) return 'package-json-field';
+  if (s.includes('readme') || s.includes('doc') || s.includes('contract')) return 'readme-contract';
+  if (s.includes('export')) return 'export-target';
+  if (s.includes('output')) return 'command-output';
+  return null; // can't infer — don't propose
+}
+
 // ─── Health Baseline Comparison ───────────────────────────────────────────────
 export async function compareHealth(cwd = process.cwd()) {
   const bpath = join(cwd, '.dualbrain', 'health-baseline.json');

package/src/health.mjs

@@ -12,6 +12,88 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 
+// ─── Auth status (delegates to replit-tools when available) ──────────────────
+
+/**
+ * Get Claude auth status, preferring replit-tools as the authoritative source.
+ *
+ * Returns:
+ *   { ok: boolean, detail: string, source: 'replit-tools' | 'direct' | 'unknown' }
+ *
+ * @param {string} [cwd]
+ */
+export async function getAuthHealthStatus(cwd) {
+  const root = cwd ?? process.cwd();
+
+  // Try replit-tools first (dynamic import — never breaks if absent)
+  try {
+    const { getAuthStatus } = await import('./replit.mjs');
+    const status = getAuthStatus(root);
+    if (status.available) {
+      const tokenOk = status.tokenStatus === 'valid' || status.tokenStatus === 'unknown';
+      const detail = status.tokenStatus === 'valid'
+        ? `Auth: OK (via replit-tools${status.expiresAt ? ', expires ' + status.expiresAt : ''})`
+        : status.tokenStatus === 'expired'
+          ? 'Auth: expired (via replit-tools)'
+          : status.tokenStatus === 'expiring'
+            ? 'Auth: expiring soon (via replit-tools)'
+            : 'Auth: status unknown (via replit-tools)';
+      return { ok: tokenOk, detail, source: 'replit-tools' };
+    }
+  } catch {
+    // replit-tools unavailable — fall through to direct check
+  }
+
+  // Fall back: check for .credentials.json directly
+  const home = process.env.HOME || '/root';
+  const credPaths = [
+    join(home, '.claude', '.credentials.json'),
+    join(root, '.replit-tools', '.claude-persistent', '.credentials.json'),
+    join(root, '.claude-persistent', '.credentials.json'),
+  ];
+
+  for (const p of credPaths) {
+    if (!existsSync(p)) continue;
+    try {
+      const creds = JSON.parse(readFileSync(p, 'utf8'));
+      const oauth = creds?.claudeAiOauth;
+      if (oauth?.accessToken) {
+        const remainingMs = oauth.expiresAt ? oauth.expiresAt - Date.now() : Infinity;
+        const remainingHours = Math.floor(remainingMs / 1000 / 60 / 60);
+        if (remainingMs <= 0) {
+          return { ok: false, detail: 'Auth: token expired (direct check)', source: 'direct' };
+        }
+        return {
+          ok: true,
+          detail: `Auth: OK (direct check, ${remainingHours}h remaining)`,
+          source: 'direct',
+        };
+      }
+    } catch {
+      // continue to next path
+    }
+  }
+
+  // .claude.json oauthAccount check
+  const claudeJsonPaths = [
+    join(root, '.replit-tools', '.claude-persistent', '.claude.json'),
+    join(home, '.claude', '.claude.json'),
+  ];
+  for (const p of claudeJsonPaths) {
+    if (!existsSync(p)) continue;
+    try {
+      const data = JSON.parse(readFileSync(p, 'utf8'));
+      if (data?.oauthAccount || data?.apiKey) {
+        return { ok: true, detail: 'Auth: OK (direct check via .claude.json)', source: 'direct' };
+      }
+    } catch {
+      // continue
+    }
+  }
+
+  return { ok: false, detail: 'Auth: no credentials found (direct check)', source: 'unknown' };
+}
+
 const HEALTH_FILE = '.dualbrain/health.json';
 
 // Cooldown ladder in minutes: index = attempts - 1, capped at last entry

package/src/index.mjs

@@ -13,7 +13,7 @@ export { dispatch, buildCommand, detectRuntime, compressResult, dispatchDualBrai
 export { loadPlaybook, listPlaybooks, executePlaybook, createRunArtifact } from './playbook.mjs';
 export { getHealth, markHot, markDegraded, markHealthy, checkCooldown, getProviderScore, recordDispatch, getSessionStats, resetHealth, remainingCooldownMinutes } from './health.mjs';
 export { detectRepo, loadRepoCache, getTestCommand, getLintCommand } from './repo.mjs';
-export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror, buildSessionIndex, searchSessions, getSessionContext } from './session.mjs';
+export { loadSession, saveSession, updateSession, clearSession, formatSessionCard, importReplitSessions, renameSession, pinSession, unpinSession, categorizeSession, getSessionMeta, autoLabel, enrichSessions, ensurePersistence, syncSessionMirror, buildSessionIndex, searchSessions, getSessionContext, extractSessionMeta, getRoutingContext } from './session.mjs';
 export { decompose, isSimpleTask, taskGraphToWaves } from './decompose.mjs';
 export { generateBrief, compressPriorResults, listRoles } from './brief.mjs';
 export { redact, redactFiles, isSecretFile } from './redact.mjs';

package/src/intelligence.mjs

@@ -357,8 +357,11 @@ export function detectContradictions(projectBrief, taskBrief, plan = {}) {
 
 /**
  * Format a compact situational awareness summary (max 15 lines) for agent prompts.
+ * @param {object} projectBrief
+ * @param {object} taskBrief
+ * @param {object|null} [sessionContext]  Optional: { relatedSessions, riskSignals, priorAttempts, relevantFiles }
  */
-export function formatBrief(projectBrief, taskBrief) {
+export function formatBrief(projectBrief, taskBrief, sessionContext = null) {
   const lines = [];
 
   const dirtyLabel = projectBrief.dirty ? 'dirty' : 'clean';
@@ -419,5 +422,26 @@ export function formatBrief(projectBrief, taskBrief) {
     }
   }
 
+  // Session context: include 1-2 lines about prior cross-session work when available
+  if (sessionContext) {
+    const priorAttempts = Array.isArray(sessionContext.priorAttempts) ? sessionContext.priorAttempts : [];
+    const failures = priorAttempts.filter(a => a && (a.failed || a.status === 'failed'));
+    const successes = priorAttempts.filter(a => a && !a.failed && a.status !== 'failed');
+
+    if (failures.length > 0) {
+      const lastFail = failures[failures.length - 1];
+      const age = lastFail.daysAgo != null ? `${lastFail.daysAgo}d ago` : (lastFail.when ?? 'recently');
+      const reason = lastFail.error ?? lastFail.reason ?? '';
+      const reasonClip = reason ? ` (${reason.slice(0, 40)})` : '';
+      lines.push(`PRIOR: similar task failed ${age}${reasonClip}`);
+    } else if (successes.length > 0) {
+      const lastSuccess = successes[successes.length - 1];
+      const age = lastSuccess.daysAgo != null ? `${lastSuccess.daysAgo}d ago` : (lastSuccess.when ?? 'recently');
+      lines.push(`PRIOR: related work completed successfully ${age}`);
+    } else if (Array.isArray(sessionContext.relatedSessions) && sessionContext.relatedSessions.length > 0) {
+      lines.push(`PRIOR: ${sessionContext.relatedSessions.length} related session(s) found`);
+    }
+  }
+
   return lines.slice(0, 15).join('\n');
 }

package/src/pipeline.mjs

@@ -76,6 +76,14 @@ export function createPipelineRun(trigger = '', prompt = '') {
     thinkResult: null,       // from think-engine
     decisionPreflight: null, // from lookupDecision
 
+    // Session history context (populated in Phase 0 from session.mjs)
+    sessionContext: null,    // { relatedSessions, riskSignals, priorAttempts, relevantFiles }
+
+    // Replit context (populated in Phase 0 when running inside Replit)
+    replitEnvironment: null, // from replit.detectReplitEnvironment()
+    replitTools: null,       // from replit.inspectReplitTools()
+    replitConfig: null,      // from replit.getReplitToolsConfig()
+
     completedAt: null,
   };
 }
@@ -247,12 +255,12 @@ export function outcomeGate(run) {
  * @param {string} cwd
  * @returns {object}
  */
-async function buildContextPack(prompt, files = [], cwd = process.cwd()) {
+async function buildContextPack(prompt, files = [], cwd = process.cwd(), sessionContext = null) {
   const profile = await _loadProfileSafe(cwd);
 
   const priorFailures = _getPriorFailures(prompt, cwd);
 
-  const detection = detectTask({ prompt, files, priorFailures });
+  const detection = detectTask({ prompt, files, priorFailures, sessionContext });
 
   return {
     prompt,
@@ -261,6 +269,7 @@ async function buildContextPack(prompt, files = [], cwd = process.cwd()) {
     profile,
     priorFailures,
     cwd,
+    sessionContext,
   };
 }
 
@@ -389,7 +398,7 @@ export function buildExecutionPlan(contextPack, trigger, options = {}) {
     effort: depthToEffort[reasoningDepth] ?? detection.effort,
   };
 
-  const decision = decideRoute({ profile, detection: detectionWithDepth, cwd: contextPack.cwd, thinkResult: options.thinkResult });
+  const decision = decideRoute({ profile, detection: detectionWithDepth, cwd: contextPack.cwd, thinkResult: options.thinkResult, sessionContext: contextPack.sessionContext ?? null });
 
   // 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' };
@@ -657,11 +666,19 @@ export async function runPipeline(trigger, prompt, options = {}) {
   try {
     // ── Phase 0: Situational awareness ───────────────────────────────────────
 
+    // Session history context — load first so Phase 0 modules (intelligence, formatBrief) can use it
+    try {
+      const session = await import('./session.mjs');
+      if (session.getRoutingContext) {
+        run.sessionContext = session.getRoutingContext(cwd, prompt);
+      }
+    } catch {} // session.mjs not available or getRoutingContext not exported — non-blocking
+
     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);
+      run.situationBrief = formatBrief(run.projectBrief, run.taskBrief, run.sessionContext);
     } catch (e) {
       // intelligence module not available — continue without it (degraded)
     }
@@ -741,6 +758,17 @@ export async function runPipeline(trigger, prompt, options = {}) {
       // awareness not available
     }
 
+    // Replit context enrichment — augment run with Replit environment data
+    try {
+      const replit = await import('./replit.mjs');
+      const replitEnv = replit.detectReplitEnvironment(cwd);
+      if (replitEnv.isReplit) {
+        run.replitEnvironment = replitEnv;
+        run.replitTools = replit.inspectReplitTools(cwd);
+        run.replitConfig = replit.getReplitToolsConfig(cwd);
+      }
+    } catch {} // replit.mjs not available — non-blocking
+
     // Knowledge preflight — check if we already know the answer
     try {
       const { lookupDecision, triageQuestion } = await import('./think-engine.mjs');
@@ -806,8 +834,8 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
     const effectivePrompt = run.enrichedPrompt || prompt;
 
-    // Build context pack
-    run.context = await buildContextPack(effectivePrompt, files, cwd);
+    // Build context pack (pass sessionContext so detect can use cross-session signals)
+    run.context = await buildContextPack(effectivePrompt, files, cwd, run.sessionContext);
 
     // Query failure history (must happen before context gate)
     try {
@@ -830,6 +858,10 @@ export async function runPipeline(trigger, prompt, options = {}) {
     // Gate 1: Context gate
     if (!runGate(run, 'context', contextGate)) {
       run.completedAt = Date.now();
+      try {
+        const { recordEvent } = await import('./doctor.mjs');
+        recordEvent({ type: 'gate_failure', checkId: 'context-gate', severity: 'fail', outcome: 'blocked', evidence: run.gates.context.reason, sessionId: run.id }, cwd);
+      } catch { /* non-blocking */ }
       return { success: false, gateFailure: 'context', reason: run.gates.context.reason, run };
     }
 
@@ -878,6 +910,10 @@ export async function runPipeline(trigger, prompt, options = {}) {
         const blockers = run.contradictions.filter(c => c.severity === 'block');
         if (blockers.length > 0) {
           run.completedAt = Date.now();
+          try {
+            const { recordEvent } = await import('./doctor.mjs');
+            recordEvent({ type: 'contradiction_caught', severity: 'fail', outcome: 'blocked', evidence: blockers.map(b => b.message).join('; ').slice(0, 200), sessionId: run.id }, cwd);
+          } catch { /* non-blocking */ }
           return {
             success: false,
             gateFailure: 'contradiction',
@@ -894,12 +930,20 @@ export async function runPipeline(trigger, prompt, options = {}) {
     // Gate 2: Planning gate
     if (!runGate(run, 'planning', planningGate)) {
       run.completedAt = Date.now();
+      try {
+        const { recordEvent } = await import('./doctor.mjs');
+        recordEvent({ type: 'gate_failure', checkId: 'planning-gate', severity: 'fail', outcome: 'blocked', evidence: run.gates.planning.reason, sessionId: run.id }, cwd);
+      } catch { /* non-blocking */ }
       return { success: false, gateFailure: 'planning', reason: run.gates.planning.reason, run };
     }
 
     // Gate 3: Principle gate
     if (!runGate(run, 'principle', principleGate)) {
       run.completedAt = Date.now();
+      try {
+        const { recordEvent } = await import('./doctor.mjs');
+        recordEvent({ type: 'gate_failure', checkId: 'principle-gate', severity: 'fail', outcome: 'blocked', evidence: run.gates.principle.reason, sessionId: run.id }, cwd);
+      } catch { /* non-blocking */ }
       return { success: false, gateFailure: 'principle', reason: run.gates.principle.reason, run };
     }
 
@@ -925,6 +969,10 @@ export async function runPipeline(trigger, prompt, options = {}) {
     // Gate 4: Execution gate (cleared to work?)
     if (!runGate(run, 'execution', executionGate)) {
       run.completedAt = Date.now();
+      try {
+        const { recordEvent } = await import('./doctor.mjs');
+        recordEvent({ type: 'gate_failure', checkId: 'execution-gate', severity: 'fail', outcome: 'blocked', evidence: run.gates.execution.reason, sessionId: run.id }, cwd);
+      } catch { /* non-blocking */ }
       return { success: false, gateFailure: 'execution', reason: run.gates.execution.reason, run };
     }
 
@@ -1038,6 +1086,22 @@ export async function runPipeline(trigger, prompt, options = {}) {
       // living-docs not available — non-blocking
     }
 
+    // Doctor: record execution outcome event (fail-silent)
+    try {
+      const { recordEvent } = await import('./doctor.mjs');
+      const successFlag = run.result && !run.result.error && run.verification?.ok;
+      recordEvent({
+        type: successFlag ? 'execution_success' : 'gate_failure',
+        checkId: 'execution',
+        severity: successFlag ? 'pass' : 'fail',
+        outcome: successFlag ? 'pass' : 'fail',
+        evidence: successFlag
+          ? `Completed ${trigger}: ${prompt.slice(0, 100)}`
+          : (run.result?.error || 'Execution failed'),
+        sessionId: run.id,
+      }, cwd);
+    } catch { /* non-blocking */ }
+
     // Doctor: record learning from this execution outcome (fail-silent)
     try {
       const { recordLearning } = await import('./doctor.mjs');

package/src/profile.mjs

@@ -602,6 +602,34 @@ async function autoSetup(cwd) {
  * @param {string} [cwd]
  */
 async function autoRefreshToken(cwd) {
+  // Delegate to replit-tools auth refresh script when available,
+  // to avoid competing token refreshes from two different code paths.
+  try {
+    const { getAuthStatus, inspectReplitTools } = await import('./replit.mjs');
+    const tools = inspectReplitTools(cwd || process.cwd());
+    if (tools.authRefresh?.available) {
+      const status = getAuthStatus(cwd || process.cwd());
+      if (status.available) {
+        // replit-tools owns the refresh cycle — report current status and exit
+        const hoursRemaining = status.expiresAt
+          ? Math.max(0, Math.floor((Date.parse(status.expiresAt) - Date.now()) / 3_600_000))
+          : null;
+        if (status.tokenStatus === 'valid') {
+          return { status: 'valid', hoursRemaining: hoursRemaining ?? 999, delegatedTo: 'replit-tools' };
+        }
+        if (status.tokenStatus === 'expired') {
+          // replit-tools will handle the actual refresh on its own schedule;
+          // we note the state but do not attempt our own refresh.
+          return { status: 'expiring_no_refresh', hoursRemaining: 0, delegatedTo: 'replit-tools' };
+        }
+        // expiring or unknown — note delegation and skip our own refresh attempt
+        return { status: 'valid', hoursRemaining: hoursRemaining ?? 1, delegatedTo: 'replit-tools' };
+      }
+    }
+  } catch {
+    // replit.mjs unavailable — fall through to direct refresh
+  }
+
   const home = process.env.HOME || '/root';
   const credPaths = [
     join(home, '.claude', '.credentials.json'),