dual-brain 7.1.25 → 7.1.27

package/bin/dual-brain.mjs

@@ -1518,12 +1518,20 @@ function detectInterruptedWork(sessions, cwd) {
  * Shows: "● Claude  ● OpenAI  ⚖️  Balanced"
  * Uses ANSI color codes for the dots — no dollar amounts or usage bars.
  */
-function buildProviderStatusLine(profile, auth) {
+function buildProviderStatusLine(profile, auth, envReport = null) {
   const GREEN = '\x1b[32m●\x1b[0m';
   const RED   = '\x1b[31m●\x1b[0m';
 
-  const claudeDot = auth.claude.found ? GREEN : RED;
-  const openaiDot = auth.openai.found ? GREEN : RED;
+  // Use envReport secrets when available; fall back to auth detection
+  const claudeAvailable = envReport
+    ? envReport.secrets.ANTHROPIC_API_KEY || auth.claude.found
+    : auth.claude.found;
+  const openaiAvailable = envReport
+    ? envReport.secrets.OPENAI_API_KEY || auth.openai.found
+    : auth.openai.found;
+
+  const claudeDot = claudeAvailable ? GREEN : RED;
+  const openaiDot = openaiAvailable ? GREEN : RED;
 
   const WORK_STYLE_LABELS = {
     'auto':          '⚡ Fast',
@@ -1703,8 +1711,15 @@ async function mainScreen(rl, ask) {
     // 's' → fall through to normal dashboard
   }
 
+  // ── Environment awareness (powers Box 1 dots + Box 3) ────────────────────
+  let envReport = null;
+  try {
+    const { scanEnvironment } = await import('../src/awareness.mjs');
+    envReport = scanEnvironment(cwd);
+  } catch { /* non-fatal */ }
+
   // ── Box 1 — Header row data ─────────────────────────────────────────────
-  const providerLine = buildProviderStatusLine(profile, auth);
+  const providerLine = buildProviderStatusLine(profile, auth, envReport);
 
   // ── Box 2 — Workspace: gather git data ───────────────────────────────────
   let gitBranch       = 'unknown';
@@ -1771,6 +1786,7 @@ async function mainScreen(rl, ask) {
   let awarenessLine2 = '\x1b[2m📋 No roadmap yet\x1b[0m';
   let awarenessLine3 = '\x1b[32m✓\x1b[0m No risk flags';
 
+  // Line 1: observer data first; fall back to envReport-derived observations
   let quickObservations = [];
   try {
     const observerMod = await import('../src/observer.mjs');
@@ -1793,7 +1809,27 @@ async function mainScreen(rl, ask) {
     }
   } catch { /* non-fatal — observer may not exist */ }
 
-  // Try roadmap file
+  // If observer produced nothing, derive from envReport
+  if (awarenessLine1 === '\x1b[2m💡\x1b[0m Ready to work' && envReport) {
+    if (envReport.replit?.hasDatabase) {
+      awarenessLine1 = '\x1b[2m💡\x1b[0m PostgreSQL available';
+    } else if (gitUncommitted > 0) {
+      awarenessLine1 = `\x1b[2m💡\x1b[0m ${gitUncommitted} file${gitUncommitted === 1 ? '' : 's'} ready to commit`;
+    } else if (envReport.dualBrain?.hasFailureMemory) {
+      // Check for recent failures
+      try {
+        const failureMem = await getFailureMem();
+        if (failureMem.getRecentFailures) {
+          const recent = failureMem.getRecentFailures(cwd, 2);
+          if (recent?.length > 0) {
+            awarenessLine1 = `\x1b[33m⚠\x1b[0m  ${recent.length} recent failure${recent.length === 1 ? '' : 's'} — check before proceeding`;
+          }
+        }
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Line 2: roadmap file, then ledger open tasks as fallback
   try {
     const roadmapPath = join(cwd, '.dual-brain', 'roadmap.md');
     if (existsSync(roadmapPath)) {
@@ -1808,6 +1844,25 @@ async function mainScreen(rl, ask) {
     }
   } catch { /* non-fatal */ }
 
+  if (awarenessLine2 === '\x1b[2m📋 No roadmap yet\x1b[0m') {
+    try {
+      const { getOpenTasks } = await import('../src/ledger.mjs');
+      const open = getOpenTasks(cwd);
+      if (open.length > 0) {
+        awarenessLine2 = '📋 Next: ' + open[0].intent.slice(0, 45);
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  // Line 3: model registry age warning
+  try {
+    const { getRegistryAge } = await import('../src/models.mjs');
+    const age = getRegistryAge();
+    if (age > 30 && awarenessLine3 === '\x1b[32m✓\x1b[0m No risk flags') {
+      awarenessLine3 = `\x1b[33m⚠\x1b[0m  Model registry ${age} days old`;
+    }
+  } catch { /* non-fatal */ }
+
   const awarenessRows = [
     row(awarenessLine1),
     row(awarenessLine2),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "7.1.25",
+  "version": "7.1.27",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -20,7 +20,9 @@
     "./decompose": "./src/decompose.mjs",
     "./brief": "./src/brief.mjs",
     "./redact": "./src/redact.mjs",
-    "./calibration": "./src/calibration.mjs"
+    "./calibration": "./src/calibration.mjs",
+    "./models": "./src/models.mjs",
+    "./prompt-intel": "./src/prompt-intel.mjs"
   },
   "keywords": [
     "claude-code",
@@ -60,6 +62,7 @@
     "src/brief.mjs",
     "src/redact.mjs",
     "src/calibration.mjs",
+    "src/models.mjs",
     "src/pipeline.mjs",
     "src/context.mjs",
     "src/outcome.mjs",
@@ -71,10 +74,12 @@
     "src/index.mjs",
     "src/ledger.mjs",
     "src/intelligence.mjs",
+    "src/awareness.mjs",
     "src/tui.mjs",
     "src/living-docs.mjs",
     "src/install-hooks.mjs",
     "src/update-check.mjs",
+    "src/prompt-intel.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",
     "hooks/cost-logger.mjs",

package/src/awareness.mjs

@@ -0,0 +1,343 @@
+/**
+ * awareness.mjs — Environment awareness layer for dual-brain.
+ * Scans runtime environment once on startup and caches results with TTL.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+let _cache = null;
+let _cacheTime = 0;
+
+function safeExec(cmd, timeoutMs = 2000) {
+  try {
+    return execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: timeoutMs,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function extractVersion(output) {
+  if (!output) return null;
+  const m = output.match(/(\d+\.\d+[\.\d]*)/);
+  return m ? m[1] : null;
+}
+
+function probeToolAvailability(name) {
+  const path = safeExec(`which ${name}`);
+  if (!path) return { available: false, version: null };
+  if (name === 'rg' || name === 'replit' || name === 'gh') {
+    return { available: true };
+  }
+  const versionOutput = safeExec(`${name} --version`);
+  return { available: true, version: extractVersion(versionOutput) };
+}
+
+function detectContainerType() {
+  const env = process.env;
+  if (env.REPL_ID || env.REPL_SLUG) return 'replit';
+  if (env.CODESPACES) return 'codespace';
+  if (env.CI || env.GITHUB_ACTIONS || env.GITLAB_CI || env.JENKINS_URL) return 'ci';
+  return 'local';
+}
+
+function scanSecrets() {
+  const keys = [
+    'OPENAI_API_KEY',
+    'ANTHROPIC_API_KEY',
+    'NPM_TOKEN',
+    'DATABASE_URL',
+    'GITHUB_TOKEN',
+    'REPLIT_DB_URL',
+  ];
+  const result = {};
+  for (const key of keys) {
+    result[key] = Boolean(process.env[key]);
+  }
+  return result;
+}
+
+function scanReplitTools() {
+  const home = homedir();
+  const candidates = [
+    join(home, '.replit-tools'),
+    join('/home/runner/workspace', '.replit-tools'),
+    join(process.cwd(), '.replit-tools'),
+  ];
+
+  let toolsDir = null;
+  for (const c of candidates) {
+    if (existsSync(c)) {
+      toolsDir = c;
+      break;
+    }
+  }
+
+  if (!toolsDir) {
+    return { installed: false, version: null, sessionArchivePath: null, capabilities: [] };
+  }
+
+  let version = null;
+  const versionFile = join(toolsDir, '.version');
+  if (existsSync(versionFile)) {
+    try { version = readFileSync(versionFile, 'utf8').trim() || null; } catch { /* skip */ }
+  }
+
+  const persistentBase = join(toolsDir, '.claude-persistent');
+  const projectDir = join(persistentBase, 'projects');
+  let sessionArchivePath = null;
+  if (existsSync(projectDir)) {
+    sessionArchivePath = projectDir;
+  } else if (existsSync(persistentBase)) {
+    sessionArchivePath = persistentBase;
+  }
+
+  const capabilities = [];
+  if (existsSync(join(toolsDir, '.claude-persistent'))) capabilities.push('sessions');
+  const hasSearch = existsSync(join(toolsDir, 'search')) || existsSync(join(toolsDir, 'search.mjs'));
+  if (hasSearch) capabilities.push('search');
+  const hasContext = existsSync(join(toolsDir, 'context')) || existsSync(join(toolsDir, 'context.mjs'));
+  if (hasContext) capabilities.push('context');
+  const hasMcp = existsSync(join(toolsDir, 'mcp-server')) || existsSync(join(toolsDir, 'mcp'));
+  if (hasMcp) capabilities.push('mcp');
+
+  return { installed: true, version, sessionArchivePath, capabilities };
+}
+
+function scanReplit(cwd) {
+  const env = process.env;
+  const isReplit = Boolean(env.REPL_ID || env.REPL_SLUG);
+
+  let hasDeployments = false;
+  const replitConfigPath = join(cwd, '.replit');
+  if (existsSync(replitConfigPath)) {
+    try {
+      const content = readFileSync(replitConfigPath, 'utf8');
+      hasDeployments = content.includes('[deployment]');
+    } catch { /* skip */ }
+  }
+
+  return {
+    isReplit,
+    replId: env.REPL_ID || null,
+    replSlug: env.REPL_SLUG || null,
+    hasDatabase: Boolean(env.DATABASE_URL),
+    hasKV: Boolean(env.REPLIT_DB_URL),
+    hasObjectStorage: Boolean(env.REPLIT_BUCKET_URL || env.OBJECT_STORAGE_URL),
+    hasAuth: existsSync(join(cwd, '.replit-auth')) || Boolean(env.REPLIT_AUTH),
+    hasDeployments,
+  };
+}
+
+function scanClaudeCode(cwd) {
+  const claudeDir = join(cwd, '.claude');
+  const homeClaudeDir = join(homedir(), '.claude');
+  const isInsideClaude = Boolean(
+    process.env.CLAUDE_CODE || process.env.CLAUDE_AGENT || process.env.ANTHROPIC_CLAUDE_CODE
+  );
+
+  let hooksDir = null;
+  const localHooks = join(claudeDir, 'hooks');
+  const rootHooks = join(cwd, 'hooks');
+  if (existsSync(localHooks)) {
+    hooksDir = localHooks;
+  } else if (existsSync(rootHooks)) {
+    hooksDir = rootHooks;
+  }
+
+  let mcpConfigured = false;
+  const mcpPaths = [
+    join(claudeDir, 'mcp.json'),
+    join(claudeDir, 'mcp_servers.json'),
+    join(homeClaudeDir, 'mcp.json'),
+  ];
+  for (const p of mcpPaths) {
+    if (existsSync(p)) { mcpConfigured = true; break; }
+  }
+
+  let settingsPath = null;
+  const settingsCandidates = [
+    join(claudeDir, 'settings.json'),
+    join(homeClaudeDir, 'settings.json'),
+  ];
+  for (const p of settingsCandidates) {
+    if (existsSync(p)) { settingsPath = p; break; }
+  }
+
+  return { isInsideClaude, hooksDir, mcpConfigured, settingsPath };
+}
+
+function scanDualBrain(cwd) {
+  let version = '0.0.0';
+  try {
+    const pkg = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+    version = pkg.version ?? '0.0.0';
+  } catch { /* skip */ }
+
+  const livingDocsDir = join(cwd, '.dual-brain');
+  const livingDocsInit = existsSync(livingDocsDir);
+
+  let sessionCount = 0;
+  const sessionDir = join(cwd, '.dualbrain', 'sessions');
+  if (existsSync(sessionDir)) {
+    try {
+      sessionCount = readdirSync(sessionDir).filter(f => f.endsWith('.jsonl')).length;
+    } catch { /* skip */ }
+  }
+
+  const hasLedger = existsSync(join(cwd, '.dualbrain', 'ledger.jsonl'));
+  const hasFailureMemory = existsSync(join(cwd, '.dualbrain', 'failures.jsonl'));
+
+  return { version, livingDocsInit, sessionCount, hasLedger, hasFailureMemory };
+}
+
+export function scanEnvironment(cwd, options = {}) {
+  const ttl = options.ttl ?? 300000;
+  if (_cache && Date.now() - _cacheTime < ttl && !options.force) return _cache;
+
+  const resolvedCwd = resolve(cwd || process.cwd());
+
+  const container = {
+    type: detectContainerType(),
+    hostname: process.env.HOSTNAME || process.env.REPL_ID || 'unknown',
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+  };
+
+  const toolNames = ['git', 'node', 'npm', 'codex', 'claude'];
+  const flagOnlyTools = ['rg', 'replit', 'gh'];
+  const tools = {};
+
+  for (const name of toolNames) {
+    tools[name] = probeToolAvailability(name);
+  }
+  for (const name of flagOnlyTools) {
+    const path = safeExec(`which ${name}`);
+    tools[name] = { available: Boolean(path) };
+  }
+
+  const secrets = scanSecrets();
+  const replitTools = scanReplitTools();
+  const replit = scanReplit(resolvedCwd);
+  const claudeCode = scanClaudeCode(resolvedCwd);
+  const dualBrain = scanDualBrain(resolvedCwd);
+
+  const report = {
+    scannedAt: Date.now(),
+    ttl,
+    container,
+    tools,
+    secrets,
+    replitTools,
+    replit,
+    claudeCode,
+    dualBrain,
+  };
+
+  _cache = report;
+  _cacheTime = Date.now();
+  return report;
+}
+
+export function formatEnvironment(report) {
+  const { container, tools, secrets, replitTools, replit, dualBrain } = report;
+
+  const nodeShort = container.nodeVersion.replace(/^v/, '').split('.')[0];
+  const containerLabel = container.type === 'replit'
+    ? 'Replit'
+    : container.type.charAt(0).toUpperCase() + container.type.slice(1);
+
+  const lines = [];
+
+  lines.push(`Environment: ${containerLabel} (node ${nodeShort}.x)`);
+
+  const toolEntries = [];
+  for (const [name, info] of Object.entries(tools)) {
+    if (info.available) toolEntries.push(`${name} ✓`);
+  }
+  if (toolEntries.length) lines.push(`Tools: ${toolEntries.join('  ')}`);
+
+  const secretMap = {
+    OPENAI_API_KEY: 'OpenAI',
+    ANTHROPIC_API_KEY: 'Anthropic',
+    NPM_TOKEN: 'npm',
+    GITHUB_TOKEN: 'GitHub',
+    DATABASE_URL: 'PostgreSQL',
+    REPLIT_DB_URL: 'KV',
+  };
+  const secretEntries = [];
+  for (const [key, label] of Object.entries(secretMap)) {
+    if (secrets[key]) secretEntries.push(`${label} ✓`);
+  }
+  if (secretEntries.length) lines.push(`Secrets: ${secretEntries.join('  ')}`);
+
+  const platformParts = [];
+  if (replit.hasDatabase) platformParts.push('PostgreSQL ✓');
+  if (replit.hasKV) platformParts.push('KV ✓');
+  if (replit.hasObjectStorage) platformParts.push('ObjectStorage ✓');
+  if (replit.hasAuth) platformParts.push('Auth ✓');
+  if (replit.hasDeployments) platformParts.push('Deployments ✓');
+  if (platformParts.length) lines.push(`Platform: ${platformParts.join('  ')}`);
+
+  if (replitTools.installed) {
+    const ver = replitTools.version ? `v${replitTools.version}` : 'installed';
+    const caps = replitTools.capabilities.join(', ');
+    lines.push(`replit-tools: ${ver}${caps ? ` (${caps})` : ''}`);
+  }
+
+  const dbFlag = dualBrain.hasLedger ? ', ledger ✓' : '';
+  const docsFlag = dualBrain.livingDocsInit ? 'living docs ✓' : 'living docs ✗';
+  lines.push(`dual-brain: v${dualBrain.version} (${docsFlag}${dbFlag})`);
+
+  return lines.join('\n');
+}
+
+export function getCapabilitySummary(report) {
+  const caps = [];
+
+  if (report.container.type !== 'unknown') {
+    caps.push(`${report.container.type}-container`);
+  }
+
+  if (report.replit.hasDatabase) caps.push('postgresql');
+  if (report.replit.hasKV) caps.push('replit-kv');
+  if (report.replit.hasObjectStorage) caps.push('object-storage');
+  if (report.replit.hasAuth) caps.push('replit-auth');
+  if (report.replit.hasDeployments) caps.push('replit-deployments');
+
+  if (report.tools.codex?.available) caps.push('codex-cli');
+  if (report.tools.claude?.available) caps.push('claude-cli');
+  if (report.tools.git?.available) caps.push('git');
+  if (report.tools.gh?.available) caps.push('github-cli');
+  if (report.tools.rg?.available) caps.push('ripgrep');
+
+  if (report.secrets.OPENAI_API_KEY) caps.push('openai-key');
+  if (report.secrets.ANTHROPIC_API_KEY) caps.push('anthropic-key');
+
+  if (report.replitTools.installed) {
+    for (const c of report.replitTools.capabilities) {
+      caps.push(`replit-tools-${c}`);
+    }
+  }
+
+  if (report.claudeCode.mcpConfigured) caps.push('mcp-configured');
+  if (report.claudeCode.hooksDir) caps.push('claude-hooks');
+
+  if (report.dualBrain.hasLedger) caps.push('dual-brain-ledger');
+  if (report.dualBrain.hasFailureMemory) caps.push('dual-brain-failure-memory');
+  if (report.dualBrain.livingDocsInit) caps.push('dual-brain-living-docs');
+
+  return caps;
+}
+
+export function invalidateCache() {
+  _cache = null;
+  _cacheTime = 0;
+}

package/src/decide.mjs

@@ -21,6 +21,34 @@ import { getProviderScore, checkCooldown } from './health.mjs';
 const __dirname  = dirname(fileURLToPath(import.meta.url));
 const WORKSPACE  = join(__dirname, '..');
 
+// ─── Model Registry (optional, lazy-loaded) ───────────────────────────────────
+
+/**
+ * Cached reference to models.mjs exports. Populated on first successful import.
+ * Remains null if models.mjs is unavailable — all callers fall back to
+ * the existing hardcoded model selection logic in that case.
+ */
+let modelRegistry = null;
+let _registryLoadAttempted = false;
+
+/**
+ * Attempt to load models.mjs once. Subsequent calls return immediately.
+ * This is intentionally fire-and-forget: decideRoute stays synchronous and
+ * reads `modelRegistry` after the Promise resolves.
+ */
+function _loadModelRegistry() {
+  if (_registryLoadAttempted) return;
+  _registryLoadAttempted = true;
+  import('./models.mjs').then(mod => {
+    modelRegistry = mod;
+  }).catch(() => {
+    // models.mjs unavailable — fall back to hardcoded logic
+  });
+}
+
+// Kick off the load immediately so it is ready before the first routing call.
+_loadModelRegistry();
+
 // ─── Work Styles ─────────────────────────────────────────────────────────────
 
 /**
@@ -362,6 +390,46 @@ function pickOpenAIModel(detection, available) {
   return available[0] ?? 'gpt-4o-mini';
 }
 
+/**
+ * Normalize a full model ID (e.g. 'claude-sonnet-4-6') to the short name used
+ * by the internal ranking arrays (e.g. 'sonnet'). Pass-through for names already
+ * in short form or OpenAI model IDs that don't need normalization.
+ * @param {string} model
+ * @param {string} provider  'claude'|'openai'
+ * @returns {string}
+ */
+function toShortName(model, provider) {
+  if (!model) return model;
+  const m = model.toLowerCase();
+  if (provider === 'claude') {
+    if (m.includes('haiku'))  return 'haiku';
+    if (m.includes('opus'))   return 'opus';
+    if (m.includes('sonnet')) return 'sonnet';
+  }
+  // OpenAI and already-short names pass through unchanged
+  return model;
+}
+
+/**
+ * Resolve a short model name back to the best full model ID from the registry.
+ * Used after the internal pipeline (health downgrade, profile bias, etc.) finalizes
+ * the short name, to restore the full ID when the registry is available.
+ * @param {string} shortName  e.g. 'sonnet', 'opus', 'haiku'
+ * @param {string} provider   'claude'|'openai'
+ * @param {string} tier       'search'|'execute'|'think'
+ * @returns {string}          Full model ID, or shortName if registry unavailable
+ */
+function toFullModelId(shortName, provider, tier) {
+  if (!modelRegistry) return shortName;
+  const registryProvider = provider === 'claude' ? 'anthropic' : 'openai';
+  // Map short name back to a taskType for the registry lookup
+  const taskType = tier === 'search' ? 'search' : tier === 'think' ? 'think' : 'execute';
+  const candidates = modelRegistry.getModelsForTask(taskType, registryProvider);
+  // Find the registry entry whose name substring matches the short name
+  const match = candidates.find(m => m.id.toLowerCase().includes(shortName.toLowerCase()));
+  return match ? match.id : shortName;
+}
+
 function applyHealthDowngrade(model, score, provider, available, isHighStakes) {
   // score=100 healthy, score=50 degraded, score=25 probing, score=0 hot
   // If score is 0 (hot) and this isn't high-stakes, downgrade one tier
@@ -665,18 +733,53 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
   // Select base model using work style worker assignments.
   // For Claude primary: use complexWorker (opus) on deep reasoning, defaultWorker (sonnet) otherwise.
   // For OpenAI primary: mirror the same logic using GPT equivalents.
-  let model;
-  if (provider === 'claude') {
+  //
+  // Hardcoded fallback models (used when model registry is unavailable):
+  const _fallbackClaude = (() => {
     const wantOpus = needsDeepReasoning && workStyle.key !== 'fast';
-    model = wantOpus && available.claude.includes('opus') ? 'opus' : 'sonnet';
-    if (!available.claude.includes(model)) model = available.claude[available.claude.length - 1] ?? 'sonnet';
-  } else {
-    // OpenAI primary — use o3 for deep reasoning in fullpower, gpt-4o otherwise
+    const fb = wantOpus && available.claude.includes('opus') ? 'opus' : 'sonnet';
+    return available.claude.includes(fb) ? fb : (available.claude[available.claude.length - 1] ?? 'sonnet');
+  })();
+  const _fallbackOpenAI = (() => {
     const wantO3 = needsDeepReasoning && workStyle.key === 'fullpower';
-    model = wantO3 && available.openai.includes('o3') ? 'o3' : 'gpt-4o';
-    if (!available.openai.includes(model)) model = available.openai[available.openai.length - 1] ?? 'gpt-4o';
+    const fb = wantO3 && available.openai.includes('o3') ? 'o3' : 'gpt-4o';
+    return available.openai.includes(fb) ? fb : (available.openai[available.openai.length - 1] ?? 'gpt-4o');
+  })();
+
+  let model;
+  if (modelRegistry) {
+    // Use registry to pick best model for the tier/provider.
+    // Map decide.mjs tier to registry taskType and constraints.
+    const registryProvider = provider === 'claude' ? 'anthropic' : 'openai';
+    const taskType = tier === 'search' ? 'search'
+      : tier === 'think'  ? 'think'
+      : 'execute';
+    const constraints = {
+      provider: registryProvider,
+      ...(tier === 'search' && { preferSpeed: true }),
+      ...(tier === 'think'  && { requireReasoning: true }),
+      ...(!needsDeepReasoning && workStyle.key === 'fast' && { maxCost: 'medium' }),
+    };
+    const registryResult = modelRegistry.getBestModel(taskType, constraints);
+    if (registryResult) {
+      // Registry returns full model IDs (e.g. 'claude-sonnet-4-6').
+      // dispatch.mjs mapToAgentModel handles both short names and full IDs.
+      model = registryResult.id;
+    } else {
+      // Registry found no match — use hardcoded fallback
+      model = provider === 'claude' ? _fallbackClaude : _fallbackOpenAI;
+    }
+  } else {
+    // Registry unavailable — use existing hardcoded selection
+    model = provider === 'claude' ? _fallbackClaude : _fallbackOpenAI;
   }
 
+  // The internal pipeline (health downgrade, profile bias, safety floor) operates on
+  // short model names ('haiku', 'sonnet', 'opus', 'gpt-4o', etc.) and the available[]
+  // arrays use the same short names. Normalize a full model ID to short name first so
+  // that rank lookups work correctly, then restore the full ID at the end.
+  model = toShortName(model, provider);
+
   // Apply health-based downgrade (only if score < 50 and not high-stakes)
   model = applyHealthDowngrade(model, healthScores[provider], provider, available[provider], isHighStakes);
 
@@ -694,6 +797,10 @@ export function decideRoute({ profile = {}, detection = {}, cwd } = {}) {
     }
   }
 
+  // Restore full model ID from registry if the pipeline kept the same short name it started with.
+  // If the pipeline changed the model (downgrade/bias/floor), resolve the new short name to a full ID.
+  model = toFullModelId(model, provider, tier);
+
   // ── Challenger / dual-brain decision ─────────────────────────────────────
   const hasBothProviders = !!(
     profile?.providers?.claude?.enabled &&