dual-brain 0.2.0 → 0.2.1

package/bin/dual-brain.mjs

@@ -902,6 +902,27 @@ async function cmdStatus(args = []) {
     console.log('  unknown (could not read .claude/settings.json)');
   }
 
+  // Replit section
+  try {
+    const replit = await import('../src/replit.mjs');
+    const env = replit.detectReplitEnvironment(cwd);
+    if (env.isReplit) {
+      console.log('\nReplit:');
+      const tools = replit.inspectReplitTools(cwd);
+      const verStr = tools.version ? `v${tools.version}` : 'unknown';
+      const capsCount = Array.isArray(tools.capabilities) ? tools.capabilities.length : 0;
+      console.log(`  replit-tools  : ${tools.installed ? `${verStr} (${capsCount} capabilities)` : 'not installed'}`);
+      const authStatus = replit.getAuthStatus(cwd);
+      console.log(`  auth          : ${authStatus.authenticated ? 'authenticated' : 'not authenticated'}${authStatus.method ? ` (${authStatus.method})` : ''}`);
+      const archive = replit.getSessionArchive(cwd);
+      const archiveCount = Array.isArray(archive) ? archive.length : (archive?.count ?? 0);
+      console.log(`  session archive: ${archiveCount} session${archiveCount !== 1 ? 's' : ''}`);
+      const openaiPresent  = replit.hasSecret('OPENAI_API_KEY');
+      const anthropicPresent = replit.hasSecret('ANTHROPIC_API_KEY');
+      console.log(`  secrets       : OPENAI_API_KEY=${openaiPresent ? 'set' : 'unset'}  ANTHROPIC_API_KEY=${anthropicPresent ? 'set' : 'unset'}`);
+    }
+  } catch { /* replit.mjs not available or not in Replit — skip silently */ }
+
   // Update check
   try {
     const localVer  = readVersion();
@@ -1957,10 +1978,30 @@ async function mainScreen(rl, ask) {
     }
   } catch { /* non-fatal */ }
 
+  // Replit awareness rows (shown only when running in Replit, max 2-3 lines)
+  const replitAwarenessRows = [];
+  try {
+    const replitMod = await import('../src/replit.mjs');
+    const replitEnv = replitMod.detectReplitEnvironment(cwd);
+    if (replitEnv.isReplit) {
+      const rtInfo    = replitMod.inspectReplitTools(cwd);
+      const authInfo  = replitMod.getAuthStatus(cwd);
+      const archive   = replitMod.getSessionArchive(cwd);
+      const archCount = Array.isArray(archive) ? archive.length : (archive?.count ?? 0);
+      const secretNames = replitMod.listSecretNames();
+      const secretCount = Array.isArray(secretNames) ? secretNames.length : 0;
+      const verStr = rtInfo.version ? `v${rtInfo.version}` : (rtInfo.installed ? 'installed' : 'not installed');
+      const authStr = authInfo.authenticated ? '\x1b[32m✓\x1b[0m auth' : '\x1b[2mno auth\x1b[0m';
+      replitAwarenessRows.push(row(`\x1b[2m🔧\x1b[0m Replit  replit-tools ${verStr}  ${authStr}`));
+      replitAwarenessRows.push(row(`\x1b[2m   \x1b[0m ${archCount} archived session${archCount !== 1 ? 's' : ''}  ${secretCount} secret${secretCount !== 1 ? 's' : ''}`));
+    }
+  } catch { /* replit.mjs not available — skip */ }
+
   const awarenessRows = [
     row(awarenessLine1),
     row(awarenessLine2),
     row(awarenessLine3),
+    ...replitAwarenessRows,
   ];
 
   // ── Sessions section ──────────────────────────────────────────────────────
@@ -5001,6 +5042,21 @@ async function main() {
   }
 
   if (cmd === 'init') {
+    // init --replit: run Replit-specific integration setup
+    if (args.includes('--replit')) {
+      const cwd = process.cwd();
+      const dryRun = args.includes('--dry-run');
+      try {
+        const replit = await import('../src/replit.mjs');
+        const report = await replit.initReplitIntegration({ dryRun, cwd });
+        console.log(replit.formatReplitReport(report));
+      } catch (e) {
+        console.error('replit.mjs not available yet — skipping Replit init');
+        if (process.env.DEBUG) console.error(e.message);
+      }
+      return;
+    }
+
     if (isInteractive) {
       // Run onboarding wizard then main screen
       const cwd = process.cwd();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dual-brain",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "AI orchestration across Claude + OpenAI subscriptions — smart routing, budget awareness, and dual-brain collaboration",
   "type": "module",
   "bin": {
@@ -22,7 +22,8 @@
     "./redact": "./src/redact.mjs",
     "./calibration": "./src/calibration.mjs",
     "./models": "./src/models.mjs",
-    "./prompt-intel": "./src/prompt-intel.mjs"
+    "./prompt-intel": "./src/prompt-intel.mjs",
+    "./replit": "./src/replit.mjs"
   },
   "keywords": [
     "claude-code",
@@ -83,6 +84,7 @@
     "src/install-hooks.mjs",
     "src/update-check.mjs",
     "src/prompt-intel.mjs",
+    "src/replit.mjs",
     "src/fx.mjs",
     "bin/*.mjs",
     "hooks/enforce-tier.mjs",

package/src/awareness.mjs

@@ -110,6 +110,23 @@ function scanReplitTools() {
   return { installed: true, version, sessionArchivePath, capabilities };
 }
 
+/**
+ * Basic Replit environment scan used for the awareness report.
+ *
+ * NOTE: Detailed Replit integration (auth status, replit-tools capabilities,
+ * session archive, secrets listing, config planning, init flow) lives in
+ * src/replit.mjs. When that module is available, prefer its
+ * detectReplitEnvironment() over duplicating detection logic here.
+ *
+ * Usage (fail-safe):
+ *   try {
+ *     const { detectReplitEnvironment } = await import('./replit.mjs');
+ *     const rich = detectReplitEnvironment(cwd);
+ *     // rich has .isReplit, .replId, .version, .authStatus, .capabilities …
+ *   } catch {
+ *     // fall back to this scanReplit() result from scanEnvironment()
+ *   }
+ */
 function scanReplit(cwd) {
   const env = process.env;
   const isReplit = Boolean(env.REPL_ID || env.REPL_SLUG);

package/src/decide.mjs

@@ -682,10 +682,10 @@ function applyCriticalRiskFloor(model, provider, available, risk) {
 
 /**
  * Main routing decision function.
- * @param {{ profile: object, detection: object, cwd?: string, thinkResult?: object }} input
+ * @param {{ profile: object, detection: object, cwd?: string, thinkResult?: object, sessionContext?: object }} input
  * @returns {object} Routing decision
  */
-export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult } = {}) {
+export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult, sessionContext = null } = {}) {
   const available = getAvailableModels(profile);
 
   // Resolve active work style
@@ -831,6 +831,50 @@ export function decideRoute({ profile = {}, detection = {}, cwd, thinkResult } =
     // 'standard', 'deep', 'ultra' — leave model unchanged; existing routing already picked correctly
   }
 
+  // Session context: escalate or prefer model based on cross-session history
+  if (sessionContext) {
+    const sessionAttempts = Array.isArray(sessionContext.priorAttempts) ? sessionContext.priorAttempts : [];
+    const sessionFailures = sessionAttempts.filter(a => a && (a.failed || a.status === 'failed'));
+    const sessionSuccesses = sessionAttempts.filter(a => a && !a.failed && a.status !== 'failed');
+
+    // Prior failures on similar work → escalate from sonnet to opus (Claude) or gpt-4o to o3 (OpenAI)
+    if (sessionFailures.length >= 2 && !isHighStakes) {
+      if (provider === 'claude') {
+        const claudeRank = ['haiku', 'sonnet', 'opus'];
+        const currentIdx = claudeRank.indexOf(toShortName(model, 'claude'));
+        if (currentIdx !== -1 && currentIdx < claudeRank.length - 1) {
+          const escalated = claudeRank[currentIdx + 1];
+          if (available.claude.includes(escalated)) model = escalated;
+        }
+      } else {
+        const oaiRank = ['gpt-4o-mini', 'gpt-4.1-mini', 'gpt-4.1', 'gpt-4o', 'o4-mini', 'o3'];
+        const currentIdx = oaiRank.indexOf(model);
+        if (currentIdx !== -1 && currentIdx < oaiRank.length - 1) {
+          const escalated = oaiRank[currentIdx + 1];
+          if (available.openai.includes(escalated)) model = escalated;
+        }
+      }
+    }
+
+    // Prior successful approach → prefer same provider/model that worked before
+    if (sessionSuccesses.length > 0) {
+      const lastSuccess = sessionSuccesses[sessionSuccesses.length - 1];
+      if (lastSuccess.provider && lastSuccess.model && !isHighStakes) {
+        const successProvider = lastSuccess.provider;
+        const successModel = lastSuccess.model;
+        const providerEnabled = profile?.providers?.[successProvider]?.enabled;
+        const providerHealthy = (healthScores[successProvider] ?? 0) > 0;
+        if (providerEnabled && providerHealthy) {
+          const shortSuccess = toShortName(successModel, successProvider);
+          if (available[successProvider]?.includes(shortSuccess)) {
+            provider = successProvider;
+            model = shortSuccess;
+          }
+        }
+      }
+    }
+  }
+
   // Safety floor: critical-risk tasks must never use haiku/gpt-4.1-mini even in cost-saver mode
   model = applyCriticalRiskFloor(model, provider, available[provider], detection.risk);
 

package/src/detect.mjs

@@ -280,9 +280,112 @@ function classifyReasoningDepth(prompt, files = [], priorOutcomes = []) {
   return { depth: 'low', signals: lowSignals.length > 0 ? lowSignals : ['no elevated signals detected'] };
 }
 
-/** Main detection function. Input: { prompt, files?, priorFailures? } */
+// ─── Plugin-aware detection helpers ───────────────────────────────────────────
+
+/**
+ * Known plugin service keywords → plugin IDs.
+ * Maps common service names and their aliases to Codex plugin directory names.
+ * Static map so detect.mjs stays self-contained (no I/O at classify time).
+ */
+const PLUGIN_KEYWORD_MAP = {
+  // Payments
+  stripe: 'stripe',
+  payment: 'stripe',
+  checkout: 'stripe',
+  subscription: 'stripe',
+  webhook: 'stripe',
+  // Collaboration / messaging
+  slack: 'slack',
+  teams: 'teams',
+  // Data / backend
+  supabase: 'supabase',
+  neondb: 'neon-postgres',
+  // Dev tools
+  github: 'github',
+  'pull request': 'github',
+  linear: 'linear',
+  jira: 'atlassian-rovo',
+  atlassian: 'atlassian-rovo',
+  // Comms / productivity
+  gmail: 'gmail',
+  outlook: 'outlook-email',
+  notion: 'notion',
+  'google calendar': 'google-calendar',
+  'google drive': 'google-drive',
+  // Monitoring / infra
+  sentry: 'sentry',
+  vercel: 'vercel',
+  netlify: 'netlify',
+  cloudflare: 'cloudflare',
+  // Analytics
+  amplitude: 'amplitude',
+  // Design
+  figma: 'figma',
+  canva: 'canva',
+  // CRM / sales
+  hubspot: 'hubspot',
+  pipedrive: 'pipedrive',
+  // Communication
+  sendgrid: 'sendgrid',
+  twilio: 'twilio-developer-kit',
+  // Storage
+  sharepoint: 'sharepoint',
+  box: 'box',
+  // AI / ML
+  openai: 'openai-developers',
+  'hugging face': 'hugging-face',
+  // Other
+  razorpay: 'razorpay',
+  render: 'render',
+  monday: 'monday-com',
+  asana: 'asana',
+  clickup: 'clickup',
+};
+
+/**
+ * Detect Codex plugin IDs that match keywords in the prompt.
+ * Returns an array of matched plugin IDs (deduplicated, max 5).
+ * @param {string} prompt
+ * @returns {string[]}
+ */
+function detectSuggestedPlugins(prompt) {
+  if (!prompt) return [];
+  const lower = prompt.toLowerCase();
+  const matched = new Set();
+
+  // Check multi-word phrases first (longer matches take priority)
+  const sortedEntries = Object.entries(PLUGIN_KEYWORD_MAP).sort((a, b) => b[0].length - a[0].length);
+  for (const [keyword, pluginId] of sortedEntries) {
+    if (lower.includes(keyword)) {
+      matched.add(pluginId);
+      if (matched.size >= 5) break;
+    }
+  }
+
+  return [...matched];
+}
+
+/** Main detection function. Input: { prompt, files?, priorFailures?, sessionContext? } */
 function detectTask(input) {
-  const { prompt = '', files = [], priorFailures = 0 } = input;
+  const { prompt = '', files = [], sessionContext = null } = input;
+  let { priorFailures = 0 } = input;
+
+  // Session context: bump priorFailures if session history shows failures on similar tasks
+  let repeatedFailure = false;
+  if (sessionContext) {
+    const sessionFailures = Array.isArray(sessionContext.priorAttempts)
+      ? sessionContext.priorAttempts.filter(a => a && (a.failed || a.status === 'failed')).length
+      : 0;
+    if (sessionFailures > 0) {
+      priorFailures = Math.max(priorFailures, sessionFailures);
+    }
+    // Flag repeated_failure if riskSignals contains failure indicators
+    const riskSignals = sessionContext.riskSignals ?? [];
+    if (riskSignals.some(s => s && (s.type === 'failure' || s.failed || /fail/i.test(String(s))))) {
+      repeatedFailure = true;
+    }
+    if (sessionFailures >= 2) repeatedFailure = true;
+  }
 
   // 1. Intent
   const intent = classifyIntent(prompt);
@@ -299,7 +402,14 @@ function detectTask(input) {
     if (regex.test(prompt)) { keywordRisk = level; break; }
   }
 
-  const risk = higherRisk(pathRiskLevel, keywordRisk);
+  let risk = higherRisk(pathRiskLevel, keywordRisk);
+
+  // Session context: bump risk one level if prior session attempts failed on similar tasks
+  if (repeatedFailure && LEVEL_ORDER[risk] < LEVEL_ORDER['high']) {
+    const riskLevels = ['low', 'medium', 'high', 'critical'];
+    const currentIdx = riskLevels.indexOf(risk);
+    risk = riskLevels[Math.min(currentIdx + 1, riskLevels.length - 1)];
+  }
   const fileCount = files.length;
 
   // 4. Complexity
@@ -342,6 +452,9 @@ function detectTask(input) {
     : [];
   const { depth: reasoningDepth, signals: reasoningSignals } = classifyReasoningDepth(prompt, files, priorOutcomes);
 
+  // 10. Suggested Codex plugins (keyword-based, static map — no I/O)
+  const suggestedPlugins = detectSuggestedPlugins(prompt);
+
   return {
     intent,
     risk,
@@ -356,6 +469,8 @@ function detectTask(input) {
     specialist: specialistResult,
     reasoningDepth,
     reasoningSignals,
+    suggestedPlugins,
+    ...(repeatedFailure && { repeatedFailure: true }),
   };
 }
 
@@ -474,4 +589,4 @@ if (process.argv[1] && new URL(import.meta.url).pathname === process.argv[1]) {
   console.log(JSON.stringify(result, null, 2));
 }
 
-export { detectTask, classifyIntent, classifyRisk, estimateComplexity, inferTier, extractPaths, classifySpecialist, classifyReasoningDepth };
+export { detectTask, classifyIntent, classifyRisk, estimateComplexity, inferTier, extractPaths, classifySpecialist, classifyReasoningDepth, detectSuggestedPlugins };

package/src/dispatch.mjs

@@ -737,6 +737,25 @@ async function dispatch(input = {}) {
   }
   // ── End specialist injection ─────────────────────────────────────────────────
 
+  // ── Plugin hint injection (Codex path) ──────────────────────────────────────
+  // When dispatching to OpenAI/Codex, check if any Codex plugins match the task
+  // and append an advisory hint so the agent can choose to use them.
+  // Uses dynamic import so failure is always non-fatal.
+  const targetProvider = decision.provider ?? 'claude';
+  if (targetProvider === 'openai') {
+    try {
+      const { matchPluginsForTask } = await import('./replit.mjs');
+      const matched = matchPluginsForTask(prompt, undefined, cwd);
+      if (matched.length > 0) {
+        const pluginNames = matched.slice(0, 3).map(m => m.plugin.id).join(', ');
+        const hint = `\n\n[Available Codex plugins for this task: ${pluginNames}. Consider using the matching plugin for direct API access.]`;
+        prompt = prompt + hint;
+        if (verbose) process.stderr.write(`[dual-brain] plugin hint injected: ${pluginNames}\n`);
+      }
+    } catch { /* non-fatal — never block dispatch */ }
+  }
+  // ── End plugin hint injection ────────────────────────────────────────────────
+
   const tier     = decision.tier ?? 'execute';
   const timeoutMs = TIER_TIMEOUT_MS[tier] ?? 120_000;