@trenchwork/erosolar 1.1.62 → 1.1.63

package/dist/headless/interactiveShell.js

@@ -13,9 +13,8 @@
  * - Ctrl+C to interrupt
  */
 import { stdin, stdout, exit } from 'node:process';
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
-import { resolve, dirname, join, relative } from 'node:path';
-import { homedir } from 'node:os';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { exec as childExec } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -32,7 +31,9 @@ import { resolveProfileConfig } from '../config.js';
 import { createAgentController } from '../runtime/agentController.js';
 import { expandFileMentions, listWorkspaceFiles } from '../core/fileMentions.js';
 import { resolveWorkspaceCaptureOptions, buildWorkspaceContext } from '../workspace.js';
-import { loadAllSecrets, listSecretDefinitions, setSecretValue, getSecretValue } from '../core/secretStore.js';
+import { loadAllSecrets, listSecretDefinitions, setSecretValue, getSecretValue, getSecretDefinition, classifyKeyEntry } from '../core/secretStore.js';
+import { resolveKeyMode, keyModeLine, setPreferOwnKeys, clearHostedSession } from '../core/hostedAuth.js';
+import { appendMemoryNote } from '../tools/memoryTools.js';
 import { listSessions, loadSessionById, saveSessionSnapshot } from '../core/sessionStore.js';
 import { relativeTime } from '../core/relativeTime.js';
 import { getModelContextInfo } from '../core/contextWindow.js';
@@ -48,6 +49,10 @@ import { setDebugMode, debugSnippet } from '../utils/debugLogger.js';
 const exec = promisify(childExec);
 import { ensureNextSteps } from '../core/finalResponseFormatter.js';
 import { getTaskCompletionDetector, detectFailingTestOrBuild } from '../core/taskCompletionDetector.js';
+import { TurnGovernor, pendingTodos, nextTodoPrompt } from '../core/turnGovernor.js';
+import { FailureRegistry } from '../core/failureRegistry.js';
+import { buildAdversarialCorrectionPrompt, MAX_ADVERSARIAL_CORRECTIONS } from '../core/adversarialCorrection.js';
+import { getCurrentTodos } from '../tools/todoTools.js';
 import { checkForUpdates, performBackgroundUpdate } from '../core/updateChecker.js';
 import { startNewRun } from '../tools/fileChangeTracker.js';
 import { onSudoPasswordNeeded, offSudoPasswordNeeded, provideSudoPassword } from '../core/sudoPasswordManager.js';
@@ -144,12 +149,18 @@ function getVersion() {
 /** Inner content of the welcome box (plain, no border/colour). */
 function welcomeBodyLines(input) {
     const body = ['✻ Welcome to Erosolar Coder', ''];
-    if (!input.hasApiKey) {
-        body.push('⚠ No API key configured', '', 'Get your key: https://platform.deepseek.com/', 'Set your key: /key YOUR_API_KEY');
+    const mode = input.keyMode ?? (input.hasApiKey ? 'own' : 'none');
+    if (mode === 'hosted') {
+        // Signed in — running on hosted keys. The mode line names the account so
+        // it's unmistakable this is NOT the user's own key.
+        body.push(input.keyModeLine ?? 'Signed in · using hosted keys');
     }
-    else {
+    else if (mode === 'own') {
         body.push(`${input.model} · ${input.provider}`, `Key: ${input.maskedKey} · /help for commands`);
     }
+    else {
+        body.push('⚠ No DeepSeek API key configured', '', 'Bring your own keys:', '  /key sk-…    DeepSeek (required) · platform.deepseek.com', '  /key tvly-…  Tavily web search (optional) · tavily.com');
+    }
     if (input.cwd)
         body.push(`cwd: ${input.cwd}`);
     return body;
@@ -275,6 +286,17 @@ class InteractiveShell {
     // Store original prompt for auto-continuation
     originalPromptForAutoContinue = null;
     // (Pinned prompt removed per request — field intentionally absent.)
+    // Bounds + stall-detects the auto-continue loop per user request, and drives
+    // continuation from the live TODO plan (see src/core/turnGovernor.ts). Reset
+    // when a fresh user prompt arrives.
+    autoGovernor = new TurnGovernor();
+    // Remembers recurring error signatures across auto-continue turns so the
+    // agent stops re-trying the same dead end (see src/core/failureRegistry.ts).
+    failureRegistry = new FailureRegistry();
+    // Adversarial auto-correction: how many bounded re-fixes the reviewer has
+    // triggered for the CURRENT user request (capped). Reset on a fresh prompt;
+    // the findings themselves are a per-turn local in processPrompt.
+    adversarialCorrectionCount = 0;
     constructor(controller, profile, profileConfig, workingDir) {
         this.controller = controller;
         this.profile = profile;
@@ -345,6 +367,7 @@ class InteractiveShell {
             // Esc interrupts a running turn (handleInterrupt no-ops when idle), so
             // the spinner's "esc to interrupt" is real. Ctrl+C still works too.
             onEscape: () => this.handleInterrupt(),
+            onShowShortcuts: () => this.showKeyboardShortcuts(),
         });
         // Register cleanup callback for graceful shutdown
         onShutdown(() => {
@@ -492,12 +515,15 @@ class InteractiveShell {
         // WHICH lines appear; here we draw the same box with brand colour.
         const flare = chalk.hex('#ff6a1f');
         const wire = chalk.hex('#3a362e');
+        const keyStatus = resolveKeyMode();
         const body = welcomeBodyLines({
             hasApiKey,
             maskedKey: hasApiKey ? maskApiKey(apiKey) : '',
             model: this.profileConfig.model,
             provider: this.profileConfig.provider,
             cwd: this.workingDir,
+            keyMode: keyStatus.mode,
+            keyModeLine: keyModeLine(keyStatus),
         });
         const boxed = roundedBox(body, (cell) => cell.replace('✻', flare('✻')), (s) => wire(s));
         const welcomeContent = ['', ...updateLines, ...boxed, ''].join('\n');
@@ -791,26 +817,19 @@ class InteractiveShell {
         const lower = trimmed.toLowerCase();
         // /model and /secrets were removed: Erosolar is locked to deepseek-v4-pro
         // on max thought (no model switching), and /key is the one key you set.
-        // Handle /key - shortcut to set DEEPSEEK_API_KEY
+        // Handle /key — set your own DeepSeek OR Tavily API key. Routed by prefix:
+        // `sk-…` → DeepSeek (the model), `tvly-…` → Tavily (web search). Explicit
+        // `/key tavily <k>` / `/key deepseek <k>` also work. Bring-your-own-key is
+        // the model; both are stored in the OS-permission secret store.
         if (lower === '/key' || lower.startsWith('/key ')) {
-            const parts = trimmed.split(/\s+/);
-            const keyValue = parts[1];
             const renderer = this.promptController?.getRenderer();
-            if (keyValue) {
-                // Direct file write - most reliable method
+            const arg = trimmed.slice('/key'.length).trim();
+            const entry = classifyKeyEntry(arg);
+            if (entry) {
                 try {
-                    const secretDir = join(homedir(), '.erosolar');
-                    const secretFile = join(secretDir, 'secrets.json');
-                    mkdirSync(secretDir, { recursive: true });
-                    const existing = existsSync(secretFile)
-                        ? JSON.parse(readFileSync(secretFile, 'utf-8'))
-                        : {};
-                    existing['DEEPSEEK_API_KEY'] = keyValue;
-                    writeFileSync(secretFile, JSON.stringify(existing, null, 2) + '\n');
-                    // Also set in process.env for immediate use
-                    process.env['DEEPSEEK_API_KEY'] = keyValue;
-                    // Show confirmation via renderer
-                    renderer?.addEvent('system', chalk.green('✓ DEEPSEEK_API_KEY saved'));
+                    setSecretValue(entry.id, entry.value);
+                    const label = getSecretDefinition(entry.id)?.label ?? entry.id;
+                    renderer?.addEvent('system', chalk.green(`✓ ${label} saved`));
                 }
                 catch (error) {
                     const msg = error instanceof Error ? error.message : String(error);
@@ -818,11 +837,33 @@ class InteractiveShell {
                 }
             }
             else {
-                // Show usage hint
-                renderer?.addEvent('system', chalk.yellow('Usage: /key YOUR_API_KEY'));
+                renderer?.addEvent('system', chalk.yellow('Usage: /key sk-… (DeepSeek) or /key tvly-… (Tavily web search)'));
             }
             return true;
         }
+        // /account — show the active key source (hosted vs your own) and switch
+        // between them. `/account own` forces your own keys even while signed in;
+        // `/account hosted` returns to hosted. Hosted keys come from sign-in
+        // (server-side, never baked into this client) — see core/hostedAuth.ts.
+        if (lower === '/account' || lower.startsWith('/account ')) {
+            const r = this.promptController?.getRenderer();
+            const arg = trimmed.slice('/account'.length).trim().toLowerCase();
+            if (arg === 'own')
+                setPreferOwnKeys(true);
+            else if (arg === 'hosted')
+                setPreferOwnKeys(false);
+            if (arg === 'own' || arg === 'hosted')
+                void this.showWelcome(); // banner reflects the switch
+            r?.addEvent('system', this.accountStatusText(resolveKeyMode()));
+            return true;
+        }
+        // /logout — drop the hosted session (back to your own keys, or none).
+        if (lower === '/logout' || lower === '/signout') {
+            clearHostedSession();
+            this.promptController?.getRenderer()?.addEvent('system', chalk.green('✓ Signed out — using your own keys.'));
+            void this.showWelcome();
+            return true;
+        }
         // /update — check npm for a newer version and upgrade in-shell.
         if (lower === '/update' || lower === '/upgrade') {
             void this.handleUpdateCommand();
@@ -1489,6 +1530,19 @@ class InteractiveShell {
         revertAllChanges(this.workingDir); // restores/deletes on disk + clears tracking
         renderer?.addEvent('system', chalk.green('✓ ' + rewindResultLine(restored, deleted)));
     }
+    /** One-line summary of the active key source for /account. */
+    accountStatusText(s) {
+        if (s.mode === 'hosted') {
+            return chalk.green(`Hosted keys · signed in as ${s.email}.`) +
+                chalk.dim(` /account own to use your own · /logout to sign out.`);
+        }
+        if (s.mode === 'own') {
+            return chalk.green(`Your own keys · DeepSeek${s.ownTavily ? ' + Tavily' : ''}.`) +
+                chalk.dim(s.signedIn ? ` /account hosted to use hosted keys.` : ` Sign-in for hosted keys is coming.`);
+        }
+        return chalk.yellow('No keys configured.') +
+            chalk.dim(' Set your own: /key sk-… (and /key tvly-…). Hosted sign-in is coming.');
+    }
     showHelp() {
         if (!this.promptController?.supportsInlinePanel()) {
             this.promptController?.setStatusMessage('Help: /key sk-… (everything else is automatic)');
@@ -1503,13 +1557,17 @@ class InteractiveShell {
         const lines = [
             chalk.bold.hex('#ece6da')('Erosolar Coder') + dim('  (press any key to dismiss)'),
             '',
-            cmd('/key sk-…') + dim('   Set your DeepSeek API key'),
+            cmd('/key sk-…') + dim('     Set your DeepSeek API key (required)'),
+            cmd('/key tvly-…') + dim('   Set your Tavily key for web search (optional)'),
+            cmd('/account') + dim('      Show / switch key source (hosted vs your own)'),
             cmd('/update') + dim('      Check npm and upgrade to the latest version'),
             cmd('/resume') + dim('      Restore a previous conversation'),
             cmd('/context') + dim('     Show context-window usage'),
             cmd('/diff') + dim('        Review changes made this run'),
             cmd('/rewind') + dim('      Undo this run\'s file changes'),
             '',
+            dim('Prefixes: ') + cmd('@file') + dim(' attach · ') + cmd('!cmd') + dim(' run shell · ') + cmd('#note') + dim(' save to memory'),
+            '',
             dim('Everything else runs automatically for max performance —'),
             dim('deepseek-v4-pro · max thought · ultracode · adversarial verifier, all on.'),
             dim('Shift+Tab cycles permission mode · Ctrl+D exits · ? for shortcuts'),
@@ -1609,6 +1667,19 @@ class InteractiveShell {
             void this.runLocalCommand(trimmed.slice(1).trim());
             return;
         }
+        // `#note` — quick-capture a note to persistent project memory (Claude Code
+        // parity), no model round-trip. Lands in .erosolar/memory/ where the agent
+        // reads it on later sessions.
+        if (trimmed.startsWith('#')) {
+            this.dismissInlinePanel();
+            const note = trimmed.slice(1).trim();
+            const r = this.promptController?.getRenderer();
+            if (appendMemoryNote(this.workingDir, note))
+                r?.addEvent('system', chalk.green('✓ Saved to memory'));
+            else
+                r?.addEvent('system', chalk.yellow('Usage: #<note to remember>'));
+            return;
+        }
         // Dismiss inline panel for regular user prompts
         this.dismissInlinePanel();
         // Live follow-up queue (Claude Code parity): a prompt typed while the agent
@@ -1645,6 +1716,10 @@ class InteractiveShell {
             // A fresh user prompt clears any prior interrupt state — this is new
             // work the user actually wants done.
             this.userInterruptedRun = false;
+            // Fresh user request → start a new auto-continue turn budget + failure log.
+            this.autoGovernor.reset();
+            this.failureRegistry.reset();
+            this.adversarialCorrectionCount = 0;
             // Pinned-prompt persistence removed per request — no longer
             // displayed above the chat box.
         }
@@ -1657,6 +1732,12 @@ class InteractiveShell {
         let episodeSuccess = false;
         const toolsUsed = [];
         const filesModified = [];
+        // Tail of this turn's tool outputs (where TS/test/build errors land), so the
+        // failure registry + governor see real error text, not just the narration.
+        let turnToolOutput = '';
+        // Reviewer findings from THIS turn (set by the adversarial.findings event),
+        // used in the finally to drive a bounded auto-correction.
+        let turnAdversarialFindings = null;
         // Track reasoning content for fallback when response is empty
         let reasoningBuffer = '';
         // Track reasoning-only time to prevent models from reasoning forever without action
@@ -1820,6 +1901,11 @@ class InteractiveShell {
                         if (isHitlToolName(event.toolName)) {
                             hitlDepth = Math.max(0, hitlDepth - 1);
                         }
+                        // Keep the tail of tool output for the failure registry / governor
+                        // (errors land here, not in the assistant narration).
+                        if (typeof event.result === 'string' && event.result) {
+                            turnToolOutput = (turnToolOutput + '\n' + event.result).slice(-16000);
+                        }
                         // Clear the activity label; the agent is thinking again.
                         this.promptController?.setStatusMessage('Thinking…');
                         // Reset reasoning timer after tool completes
@@ -1883,6 +1969,11 @@ class InteractiveShell {
                             elapsedMs: event.elapsedMs,
                         })));
                         break;
+                    case 'adversarial.findings':
+                        // The reviewer refuted this turn's draft — remember it so the
+                        // auto-continue loop can run a bounded re-fix (handled in finally).
+                        turnAdversarialFindings = event.findings;
+                        break;
                     case 'context.compacted': {
                         // The conversation was auto-compacted to stay within the window —
                         // surface it as a dim note (Claude Code parity) instead of silently.
@@ -2028,6 +2119,10 @@ class InteractiveShell {
             r?.setQueuedPrompts([]);
             // Note: pendingPrompts may still have items if a drain just started
             // a new processPrompt; the new run will manage the list.
+            // Snapshot this turn's full output (tool results + narration) BEFORE the
+            // buffer is cleared — the auto-continue governor + failure registry need
+            // the real error text, which the reset below would otherwise wipe.
+            const combinedTurnOutput = (turnToolOutput + '\n' + this.currentResponseBuffer).slice(-16000);
             this.currentResponseBuffer = '';
             // Autosave the conversation so /resume has something to restore. Each
             // turn updates the same snapshot in place (keyed by this.sessionId).
@@ -2060,19 +2155,54 @@ class InteractiveShell {
                     // Check if original user prompt is fully completed
                     const detector = getTaskCompletionDetector();
                     const analysis = detector.analyzeCompletion(this.currentResponseBuffer, toolsUsed);
-                    // Continue until task is complete
-                    if (!analysis.isComplete) {
+                    // Record this turn with the governor (bounds the loop + detects a
+                    // stall: the same tools/files/failure repeating with no new progress)
+                    // and the failure registry (catches the same error recurring across
+                    // NON-consecutive turns — a thrash the stall check would miss).
+                    this.autoGovernor.recordTurn({
+                        toolsUsed,
+                        filesModified,
+                        failingSignal: detectFailingTestOrBuild(combinedTurnOutput),
+                    });
+                    this.failureRegistry.trackTurn(combinedTurnOutput);
+                    const gov = this.autoGovernor.check();
+                    const failureNudge = this.failureRegistry.nudge();
+                    const todos = getCurrentTodos();
+                    const pending = pendingTodos(todos);
+                    if (gov.stop) {
+                        // Yield to the user WITH state instead of thrashing forever.
+                        const note = gov.reason === 'limit'
+                            ? `Paused after ${gov.turn} auto-continue turns (turn limit).${pending.length ? ` ${pending.length} task${pending.length === 1 ? '' : 's'} still pending` : ''} — say "continue" to keep going.`
+                            : `Paused: no new progress over the last few turns (same actions repeating).${pending.length ? ` ${pending.length} task${pending.length === 1 ? '' : 's'} pending` : ''} — tell me how to proceed.`;
+                        this.promptController?.getRenderer()?.addEvent('system', chalk.dim(note));
+                        this.promptController?.setStatusMessage(null);
+                        this.originalPromptForAutoContinue = null;
+                    }
+                    else if (turnAdversarialFindings && this.adversarialCorrectionCount < MAX_ADVERSARIAL_CORRECTIONS) {
+                        // The reviewer refuted this turn's draft — re-run the FULL tool loop
+                        // to actually fix the findings (not just show the caveat), bounded
+                        // by the governor + this per-request cap.
+                        this.adversarialCorrectionCount += 1;
+                        this.promptController?.setStatusMessage('Addressing reviewer findings…');
+                        await new Promise(resolve => setTimeout(resolve, 300));
+                        await this.processPrompt(buildAdversarialCorrectionPrompt(turnAdversarialFindings));
+                    }
+                    else if (!analysis.isComplete || pending.length > 0) {
+                        // Continue — but only stop when the LIVE PLAN is also clear: pending
+                        // todos force a continue even if the response sounded "done".
                         this.promptController?.setStatusMessage('Continuing...');
                         await new Promise(resolve => setTimeout(resolve, 500));
-                        // Generate auto-continue prompt using stored original prompt
-                        const autoPrompt = this.generateAutoContinuePrompt(this.originalPromptForAutoContinue || '', this.currentResponseBuffer, toolsUsed);
-                        if (autoPrompt) {
-                            await this.processPrompt(autoPrompt);
-                        }
-                        else {
-                            // Default continue if no specific auto-prompt generated
-                            await this.processPrompt('continue');
-                        }
+                        // Prefer the plan's next task; fall back to the response heuristic.
+                        const base = nextTodoPrompt(todos)
+                            ?? this.generateAutoContinuePrompt(this.originalPromptForAutoContinue || '', combinedTurnOutput, toolsUsed)
+                            ?? 'continue';
+                        // When a failure keeps recurring, lead with the change-approach nudge.
+                        // Keep an IMPORTANT: prefix so this counts as an auto-continue (not a
+                        // fresh user prompt, which would reset the governor).
+                        const autoPrompt = failureNudge
+                            ? `IMPORTANT: ${failureNudge}\n\n${base.replace(/^IMPORTANT:\s*/, '')}`
+                            : base;
+                        await this.processPrompt(autoPrompt);
                     }
                     else {
                         this.promptController?.setStatusMessage('Task complete');