@calliopelabs/cli 2.2.0 → 2.5.0

package/dist/ui/commands.js

@@ -21,6 +21,7 @@ import { getAgentStatusReport, swarmManager, councilManager, COUNCIL_TEMPLATES,
 import { smartRoute, getDefaultSmartRoutingConfig, detectTaskType } from '../smart-router.js';
 import { getCurrentSkin, getCurrentPalette, applySkin, applyPalette, listSkins, listPalettes } from '../hud/api.js';
 import { getCurrentCompanion, applyCompanion, listCompanions, getMoodText } from '../companions.js';
+import { scuttlebotClient } from '../scuttlebot/index.js';
 import { createJob, runJob, cancelJob, getJob, formatJob, formatJobsList, clearFinishedJobs } from '../background-jobs.js';
 import { listRecordings, loadRecording, formatRecording, deleteRecording } from '../terminal-recording.js';
 import { startApiServer, stopApiServer, isApiServerRunning } from '../api-server.js';
@@ -28,6 +29,74 @@ import { getTerminalImageInfo, getImageModeLabel, renderSkinBanner, renderTransi
 import { applyThemePack, listThemePacks, getCurrentPack, getCompanionMode, setCompanionMode, getThemePack } from '../hud/theme-packs/api.js';
 import { getModelContextLimit } from '../model-detection.js';
 import { resetContextWarnings } from './context.js';
+import * as memory from '../memory.js';
+import { resolveIterationLimit, formatIterationLimit, isFiniteIterationLimit, } from '../iteration-limit.js';
+// Builds the full system prompt including memory context (project + global).
+// dir should be the project directory for the active/resumed session.
+function buildFullSystemPrompt(persona, dir) {
+    const base = getSystemPrompt(persona);
+    const mem = memory.buildMemoryContext(dir);
+    return mem.trim() ? base + '\n\n--- Project Context ---\n' + mem : base;
+}
+function getActiveProjectDir(ctx) {
+    return ctx.sessionRef.current?.projectPath ?? process.cwd();
+}
+function formatLedgerDuration(durationMs) {
+    if (durationMs < 1000)
+        return `${durationMs}ms`;
+    if (durationMs < 60_000)
+        return `${(durationMs / 1000).toFixed(1)}s`;
+    return `${(durationMs / 60_000).toFixed(1)}m`;
+}
+function formatSessionLogLimit(limit) {
+    return limit > 0 ? String(limit) : 'unlimited';
+}
+function formatLedgerRun(run) {
+    const iterationCount = Math.max(0, (run.entryCountAtEnd ?? run.entryCountAtStart) - run.entryCountAtStart);
+    const parts = [`${run.kind}`, `[${run.status}]`];
+    if (iterationCount > 0) {
+        parts.push(`${iterationCount} iteration${iterationCount === 1 ? '' : 's'}`);
+    }
+    if (run.maxIterations != null && Number.isFinite(run.maxIterations)) {
+        parts.push(`max ${run.maxIterations}`);
+    }
+    else if (run.maxIterations === null) {
+        parts.push('unlimited');
+    }
+    const prompt = run.prompt.length > 90 ? `${run.prompt.slice(0, 90)}...` : run.prompt;
+    let line = `${parts.join(' ')} — ${prompt}`;
+    if (run.errorSummary) {
+        line += ` (${run.errorSummary})`;
+    }
+    return line;
+}
+function watchAsyncLedgerRun(ledger, kind, prompt, getStatus) {
+    if (!ledger)
+        return;
+    const runId = ledger.startRun(kind, prompt);
+    void (async () => {
+        for (;;) {
+            const current = getStatus();
+            if (!current) {
+                ledger.finishRun(runId, 'failed', { errorSummary: 'Run state no longer available' });
+                return;
+            }
+            if (current.status === 'completed') {
+                ledger.finishRun(runId, 'completed');
+                return;
+            }
+            if (current.status === 'failed') {
+                ledger.finishRun(runId, 'failed', { errorSummary: current.error });
+                return;
+            }
+            if (current.status === 'cancelled') {
+                ledger.finishRun(runId, 'cancelled', { errorSummary: current.error || 'Cancelled' });
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, 500));
+        }
+    })();
+}
 // ============================================================================
 // handleCommand
 // ============================================================================
@@ -45,7 +114,7 @@ export async function handleCommand(cmd, ctx) {
   /persona [name]            - Switch personality
   /route [on|off]            - Auto model routing (/autoroute)
   /smart [on|off|cost|test]  - Cross-provider smart routing
-  /breaker [status|resume]   - Circuit breaker control (/cb)
+  /breaker [status|adjust]   - Circuit breaker control (/cb)
 
 --- Conversation ---
   /edit                      - Edit and resend last message
@@ -57,6 +126,7 @@ export async function handleCommand(cmd, ctx) {
 
 --- Session & State ---
   /session [list|info|fork|save] - Session management (/sessions)
+  /log [summary|tail|failures|reset] - Iteration/run log
   /resume [sessionId]        - Resume session (restores full context)
   /checkpoint [list|clear]   - File checkpoints (/cp)
   /restore <path> [index]    - Restore file from checkpoint
@@ -103,8 +173,8 @@ export async function handleCommand(cmd, ctx) {
 --- Multi-Agent ---
   /agents                    - Sub-agent status (--agents mode)
   /swarm [start|coord|status] - Agent swarms & coordination
-  /loop [prompt] [n]         - Iterative agent loop
-  /cancel-loop               - Stop running loop (/stop)
+  /loop [prompt]             - Iterative agent loop (default: unlimited)
+  /cancel-loop               - Stop running loop (/stop, /breakloop)
 
 --- System ---
   /status                    - Show status (/s)
@@ -125,9 +195,17 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/providers':
         case '/p':
             if (parts[1]) {
-                const p = parts[1].toLowerCase();
-                ctx.setProvider(p);
-                ctx.addMessage('system', `Provider: ${selectProvider(p)}`);
+                const requested = parts[1].toLowerCase();
+                const available = getAvailableProviders();
+                if (!available.includes(requested)) {
+                    ctx.addMessage('error', `Provider "${requested}" is not configured. Run /provider (no args) for an interactive picker with setup.`);
+                    break;
+                }
+                ctx.setProvider(requested);
+                ctx.addMessage('system', `Provider: ${selectProvider(requested)}`);
+            }
+            else if (ctx.openProviderPicker) {
+                ctx.openProviderPicker();
             }
             else {
                 ctx.addMessage('system', `Provider: ${ctx.actualProvider} | Available: ${getAvailableProviders().join(', ')}`);
@@ -157,7 +235,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             else {
                 ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
                 try {
-                    const models = await getAvailableModels(ctx.actualProvider);
+                    const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
                     if (models.length > 0) {
                         ctx.setAvailableModels(models);
                         ctx.setModalMode('model');
@@ -174,7 +252,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/models':
             ctx.addMessage('system', `Fetching models for ${ctx.actualProvider}...`);
             try {
-                const models = await getAvailableModels(ctx.actualProvider);
+                const models = await getAvailableModels(ctx.actualProvider, { throwOnError: true });
                 if (models.length > 0) {
                     ctx.setAvailableModels(models);
                     ctx.setModalMode('model');
@@ -202,7 +280,7 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
             if (parts[1] && ['calliope', 'muse', 'minimal'].includes(parts[1])) {
                 const p = parts[1];
                 ctx.setPersona(p);
-                ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(p) }];
+                ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(p, getActiveProjectDir(ctx)) }];
                 ctx.addMessage('system', `Persona: ${p}`);
             }
             else {
@@ -212,7 +290,8 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/clear':
         case '/c':
             ctx.setMessages([]);
-            ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(ctx.persona) }];
+            ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
+            ctx.ledger?.reset();
             ctx.setStats({ inputTokens: 0, outputTokens: 0, cost: 0, messageCount: 0 });
             resetContextWarnings(); // Reset context warning state
             break;
@@ -340,11 +419,95 @@ Modes: Plan | Hybrid | Work | Auto-route: ${ctx.autoRoute ? 'ON' : 'OFF'}${ctx.a
         case '/status':
         case '/s': {
             const imgInfo = getTerminalImageInfo();
-            ctx.addMessage('system', `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`);
+            let statusMsg = `${ctx.actualProvider}:${ctx.actualModel} | ${ctx.stats.messageCount} msgs | ${ctx.stats.inputTokens + ctx.stats.outputTokens} tokens | terminal: ${getImageModeLabel(imgInfo.mode)}${imgInfo.truecolor ? ' (truecolor)' : ''} ${imgInfo.width}cols`;
+            // Add scuttlebot status if enabled
+            if (scuttlebotClient.isEnabled()) {
+                const sbStatus = scuttlebotClient.getStatus();
+                statusMsg += `\nScuttlebot: enabled (${sbStatus.nick}) | irc:${sbStatus.config?.ircAddr} | #${sbStatus.config?.channel}`;
+            }
+            ctx.addMessage('system', statusMsg);
+            break;
+        }
+        case '/scuttlebot': {
+            const subCmd = parts[1];
+            const sbStatus = scuttlebotClient.getStatus();
+            // /scuttlebot enable - enable mid-session
+            if (subCmd === 'enable') {
+                if (sbStatus.enabled) {
+                    ctx.addMessage('system', 'Scuttlebot is already enabled.');
+                    break;
+                }
+                // Initialize scuttlebot — config is loaded from ~/.config/scuttlebot-relay.env,
+                // process.env, and .scuttlebot.yaml inside initialize()
+                const sessionId = ctx.sessionRef.current?.id || 'default';
+                const cwd = getActiveProjectDir(ctx);
+                scuttlebotClient.initialize(sessionId, cwd).then(async (enabled) => {
+                    if (enabled) {
+                        const status = scuttlebotClient.getStatus();
+                        let msg = '✓ Scuttlebot enabled!\n';
+                        msg += `  Nick:      ${status.nick}\n`;
+                        msg += `  IRC:       ${status.config?.ircAddr}\n`;
+                        msg += `  Channel:   #${status.config?.channel}`;
+                        if (status.config?.channels && status.config.channels.length > 1) {
+                            msg += `\n  Channels:  ${status.config.channels.map((c) => '#' + c).join(', ')}`;
+                        }
+                        ctx.addMessage('system', msg);
+                        // Post online status and start routing IRC instructions
+                        await scuttlebotClient.postOnline();
+                        ctx.startScuttlebotPolling();
+                    }
+                    else {
+                        ctx.addMessage('system', 'Failed to enable scuttlebot');
+                    }
+                }).catch((err) => {
+                    ctx.addMessage('system', `Failed to enable scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                break;
+            }
+            // /scuttlebot disable - disable mid-session
+            if (subCmd === 'disable') {
+                if (!sbStatus.enabled) {
+                    ctx.addMessage('system', 'Scuttlebot is not enabled.');
+                    break;
+                }
+                scuttlebotClient.postOffline().then(() => {
+                    return scuttlebotClient.disconnect();
+                }).then(() => {
+                    ctx.addMessage('system', 'Scuttlebot disabled');
+                }).catch((err) => {
+                    ctx.addMessage('system', `Error disabling scuttlebot: ${err instanceof Error ? err.message : String(err)}`);
+                });
+                break;
+            }
+            // Show status
+            if (!sbStatus.enabled) {
+                ctx.addMessage('system', 'Scuttlebot not enabled.\n\nRun: /scuttlebot enable\n\nConfig is loaded automatically from ~/.config/scuttlebot-relay.env\nChannel is read from .scuttlebot.yaml');
+                break;
+            }
+            let statusText = 'Scuttlebot Status\n────────────────────────────────────────\n';
+            statusText += `Enabled:     yes\n`;
+            statusText += `Nick:        ${sbStatus.nick}\n`;
+            statusText += `IRC:         ${sbStatus.config?.ircAddr}\n`;
+            statusText += `Channel:     #${sbStatus.config?.channel}\n`;
+            statusText += `Connected:   ${sbStatus.connected ? 'yes' : 'no'}`;
+            if (sbStatus.config?.channels && sbStatus.config.channels.length > 1) {
+                statusText += `\nChannels:    ${sbStatus.config.channels.map((c) => '#' + c).join(', ')}`;
+            }
+            statusText += '\n\nCommands:\n  /scuttlebot <message>  Post a message\n  /scuttlebot disable    Disable integration';
+            ctx.addMessage('system', statusText);
+            // Allow manual message posting
+            if (subCmd && subCmd !== 'enable' && subCmd !== 'disable') {
+                const message = parts.slice(1).join(' ');
+                scuttlebotClient.postMessage(message).then(() => {
+                    ctx.addMessage('system', 'Message posted to scuttlebot.');
+                }).catch((err) => {
+                    ctx.addMessage('system', `Failed to post message: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
             break;
         }
         case '/config':
-            ctx.addMessage('system', `Config: ${config.getConfigPath()}\nProviders: ${config.getConfiguredProviders().join(', ') || 'none'}\nmaxIterations: ${config.get('maxIterations')}`);
+            ctx.addMessage('system', `Config: ${config.getConfigPath()}\nProviders: ${config.getConfiguredProviders().join(', ') || 'none'}\nmaxIterations: ${config.get('maxIterations')}\nsessionLogLimit: ${formatSessionLogLimit(config.get('sessionLogLimit'))} (set > 0 to cap)`);
             break;
         case '/agents': {
             if (!ctx.agtermEnabled) {
@@ -797,6 +960,7 @@ Edit the YAML to customize members, strategy, and coordination settings.`);
                 ctx.addMessage('system', `Usage: /set <key> <value>
 Available keys:
   maxIterations <number>  - Max agent iterations (current: ${config.get('maxIterations')})
+  sessionLogLimit <number> - Cap retained session log items (current: ${formatSessionLogLimit(config.get('sessionLogLimit'))}, 0 = unlimited)
   persona <name>          - calliope, muse, minimal
   fancyOutput <bool>      - true/false`);
                 break;
@@ -804,12 +968,22 @@ Available keys:
             try {
                 if (key === 'maxIterations') {
                     const num = parseInt(value, 10);
-                    if (isNaN(num) || num < 1 || num > 10000) {
-                        ctx.addMessage('error', 'maxIterations must be 1-10000');
+                    if (isNaN(num) || num < 0 || num > 1000000) {
+                        ctx.addMessage('error', 'maxIterations must be 0-1000000 (0 = unlimited)');
                         break;
                     }
                     config.set('maxIterations', num);
-                    ctx.addMessage('system', `\u2713 maxIterations set to ${num}`);
+                    ctx.addMessage('system', `\u2713 maxIterations set to ${formatIterationLimit(resolveIterationLimit(num))}`);
+                }
+                else if (key === 'sessionLogLimit') {
+                    const num = parseInt(value, 10);
+                    if (isNaN(num) || num < 0 || num > 100000) {
+                        ctx.addMessage('error', 'sessionLogLimit must be 0-100000 (0 = unlimited)');
+                        break;
+                    }
+                    config.set('sessionLogLimit', num);
+                    ctx.ledger?.setRetentionLimit(num);
+                    ctx.addMessage('system', `\u2713 sessionLogLimit set to ${num === 0 ? 'unlimited (set > 0 to cap)' : num}`);
                 }
                 else if (key === 'persona') {
                     if (!['calliope', 'muse', 'minimal'].includes(value)) {
@@ -947,6 +1121,10 @@ Usage:
         }
         case '/loop': {
             // Parse /loop "<prompt>" [--max-iterations N] [--completion-promise "text"]
+            if (ctx.loopActive) {
+                ctx.addMessage('system', 'Loop already running. Use /breakloop to stop it first.');
+                break;
+            }
             const loopArgs = parts.slice(1).join(' ');
             const maxIterMatch = loopArgs.match(/--max-iterations\s+(\d+)/);
             const completionMatch = loopArgs.match(/--completion-promise\s+"([^"]+)"/);
@@ -963,23 +1141,28 @@ Usage:
 Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE"`);
                 break;
             }
+            const defaultMaxIterations = resolveIterationLimit(config.get('maxIterations'));
+            const loopMaxIterations = maxIterMatch
+                ? resolveIterationLimit(parseInt(maxIterMatch[1], 10))
+                : defaultMaxIterations;
             // Start the loop
             ctx.setLoopActive(true);
             ctx.setLoopPrompt(prompt);
-            ctx.setLoopMaxIterations(maxIterMatch ? parseInt(maxIterMatch[1], 10) : 100);
+            ctx.setLoopMaxIterations(loopMaxIterations);
             ctx.setLoopCompletionPromise(completionMatch ? completionMatch[1] : undefined);
             ctx.setLoopIteration(0);
             ctx.loopCancelledRef.current = false;
             ctx.addMessage('system', `\u{1F504} Agent Loop Started
   Prompt: "${prompt.substring(0, 50)}${prompt.length > 50 ? '...' : ''}"
-  Max iterations: ${maxIterMatch ? maxIterMatch[1] : '100'}
-  ${completionMatch ? `Completion promise: "${completionMatch[1]}"` : 'No completion promise (runs until max iterations)'}
-  Use /cancel-loop to stop`);
+  Max iterations: ${formatIterationLimit(loopMaxIterations)}
+  ${completionMatch ? `Completion promise: "${completionMatch[1]}"` : isFiniteIterationLimit(loopMaxIterations) ? 'No completion promise (runs until max iterations)' : 'No completion promise (runs until stopped)'}
+  Use /breakloop to stop`);
             // Start the loop execution (non-blocking)
-            ctx.runLoop(prompt, maxIterMatch ? parseInt(maxIterMatch[1], 10) : 100, completionMatch?.[1]);
+            ctx.runLoop(prompt, loopMaxIterations, completionMatch?.[1]);
             break;
         }
         case '/cancel-loop':
+        case '/breakloop':
         case '/stop':
             if (ctx.loopActive) {
                 ctx.loopCancelledRef.current = true;
@@ -1272,7 +1455,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
         case '/branch': {
             const branching = await import('../branching.js');
             const subCmd = parts[1];
-            const sessionId = ctx.sessionRef.current?.id || `session_${Date.now()}`;
+            const sessionId = ctx.sessionRef.current?.id || storage.createSessionId();
             if (subCmd === 'list' || !subCmd) {
                 const tree = branching.getBranchTree(sessionId);
                 ctx.addMessage('system', `Branches:\n${tree}`);
@@ -1399,7 +1582,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 const newComp = getCurrentCompanion();
                 if (newComp.name === subCmd) {
                     config.set('activeCompanion', subCmd);
-                    ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(ctx.persona) }];
+                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
                     ctx.addMessage('system', `Companion set to: ${subCmd} \u2014 "${newComp.greeting}"`);
                 }
                 else {
@@ -1480,7 +1663,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                         : pack.companions.immersive;
                     config.set('activeCompanion', companion.name);
                     // Reset LLM system prompt to use the companion's persona
-                    ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(ctx.persona) }];
+                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
                     ctx.addMessage('system', `Theme pack: ${subCmd}\n` +
                         `  Skin: ${pack.skin.name}, Palette: ${pack.palette.name}, Companion: ${companion.name}\n` +
                         `  "${companion.greeting}"`);
@@ -1499,7 +1682,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                     const pack = getCurrentPack();
                     config.set('companionIntensity', 'professional');
                     config.set('activeCompanion', pack.companions.professional.name);
-                    ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(ctx.persona) }];
+                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
                     ctx.addMessage('system', `Switched to professional mode — ${pack.companions.professional.description}`);
                 }
                 else {
@@ -1512,7 +1695,7 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                     const pack = getCurrentPack();
                     config.set('companionIntensity', 'immersive');
                     config.set('activeCompanion', pack.companions.immersive.name);
-                    ctx.llmMessages.current = [{ role: 'system', content: getSystemPrompt(ctx.persona) }];
+                    ctx.llmMessages.current = [{ role: 'system', content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)) }];
                     ctx.addMessage('system', `Switched to immersive mode — ${pack.companions.immersive.description}`);
                 }
                 else {
@@ -1768,7 +1951,22 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 if (session) {
                     const savedMessages = storage.loadMessageHistory();
                     const savedCount = savedMessages ? savedMessages.length : 0;
-                    ctx.addMessage('system', `Session: ${session.projectName}\nID: ${session.id}\nCreated: ${new Date(session.createdAt).toLocaleString()}\nMessages: ${session.messageCount}\nSaved LLM messages: ${savedCount}`);
+                    const ledgerTotals = ctx.ledger?.getTotals();
+                    const latestRun = ctx.ledger?.getLatestRun();
+                    const lines = [
+                        `Session: ${session.projectName}`,
+                        `ID: ${session.id}`,
+                        `Created: ${new Date(session.createdAt).toLocaleString()}`,
+                        `Messages: ${session.messageCount}`,
+                        `Saved LLM messages: ${savedCount}`,
+                    ];
+                    if (ledgerTotals) {
+                        lines.push(`Iterations logged: ${ledgerTotals.iterations}`, `Failed approaches: ${ctx.ledger?.getFailedApproachCount() ?? 0}`);
+                    }
+                    if (latestRun) {
+                        lines.push(`Latest run: ${formatLedgerRun(latestRun)}`);
+                    }
+                    ctx.addMessage('system', lines.join('\n'));
                 }
                 else {
                     ctx.addMessage('system', 'No active session.');
@@ -1782,6 +1980,9 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
                 else {
                     // Save current messages before forking
                     storage.saveMessageHistory(ctx.llmMessages.current);
+                    if (ctx.ledger) {
+                        storage.saveIterationLedger(ctx.ledger);
+                    }
                     const forked = storage.forkSession(session.projectPath);
                     if (forked) {
                         ctx.sessionRef.current = forked;
@@ -1794,12 +1995,89 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else if (parts[1] === 'save') {
                 storage.saveMessageHistory(ctx.llmMessages.current);
-                ctx.addMessage('system', `Saved ${ctx.llmMessages.current.length} LLM messages to session.`);
+                if (ctx.ledger) {
+                    storage.saveIterationLedger(ctx.ledger);
+                }
+                ctx.addMessage('system', `Saved ${ctx.llmMessages.current.length} LLM messages and current log state to session.`);
             }
             else {
                 ctx.addMessage('system', 'Usage: /session [list|info|fork|save] or just /sessions');
             }
             break;
+        case '/log': {
+            if (!ctx.ledger) {
+                ctx.addMessage('system', 'No session log available.');
+                break;
+            }
+            const subCmd = parts[1] || 'summary';
+            if (subCmd === 'summary') {
+                const totals = ctx.ledger.getTotals();
+                const runs = ctx.ledger.getRuns(5);
+                const allFailures = ctx.ledger.getFailedApproaches();
+                const failures = allFailures.slice(-5);
+                const lines = [
+                    'Session Log',
+                    `Iterations: ${totals.iterations}`,
+                    `Failed approaches: ${ctx.ledger.getFailedApproachCount()}`,
+                    `Tokens: ${totals.totalTokens}`,
+                    `Cost: $${totals.totalCost.toFixed(4)}`,
+                    `Duration: ${formatLedgerDuration(totals.totalDurationMs)}`,
+                ];
+                if (runs.length > 0) {
+                    lines.push('', 'Recent runs:');
+                    for (const run of runs) {
+                        lines.push(`  - ${formatLedgerRun(run)}`);
+                    }
+                }
+                if (failures.length > 0) {
+                    lines.push('', 'Recent failures:');
+                    for (const failure of failures) {
+                        lines.push(`  - #${failure.iteration} ${failure.description} — ${failure.reason}`);
+                    }
+                }
+                ctx.addMessage('system', lines.join('\n'));
+            }
+            else if (subCmd === 'tail') {
+                const limit = parts[2] ? parseInt(parts[2], 10) : 10;
+                if (isNaN(limit) || limit <= 0 || limit > 100) {
+                    ctx.addMessage('error', 'Usage: /log tail [1-100]');
+                    break;
+                }
+                const entries = ctx.ledger.getEntries().slice(-limit);
+                if (entries.length === 0) {
+                    ctx.addMessage('system', 'No logged iterations yet.');
+                    break;
+                }
+                const lines = ['Recent iterations:'];
+                for (const entry of entries) {
+                    const actions = entry.actions.length > 0
+                        ? entry.actions.map(action => `${action.tool}(${action.args})${action.result === 'error' ? ' FAILED' : action.result === 'blocked' ? ' BLOCKED' : ''}`).join(', ')
+                        : 'no tool actions';
+                    lines.push(`  #${entry.iteration} [${entry.outcome}] ${formatLedgerDuration(entry.durationMs)} — ${actions}`);
+                }
+                ctx.addMessage('system', lines.join('\n'));
+            }
+            else if (subCmd === 'failures') {
+                const failures = ctx.ledger.getFailedApproaches();
+                if (failures.length === 0) {
+                    ctx.addMessage('system', 'No failed approaches recorded.');
+                    break;
+                }
+                const lines = ['Failed approaches:'];
+                for (const failure of failures.slice(-10)) {
+                    lines.push(`  - #${failure.iteration} ${failure.description} — ${failure.reason}`);
+                }
+                ctx.addMessage('system', lines.join('\n'));
+            }
+            else if (subCmd === 'reset') {
+                ctx.ledger.reset();
+                ctx.addMessage('system', 'Session log reset.');
+            }
+            else {
+                ctx.addMessage('system', 'Usage: /log [summary|tail [N]|failures|reset]');
+            }
+            break;
+        }
         case '/todo': {
             const subCommand = parts[1];
             if (subCommand === 'add' && parts.length > 2) {
@@ -2371,6 +2649,20 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             // Resume a session by loading saved LLM message history
             // Usage: /resume [sessionId] - resume a specific session, or current session if no ID
             const targetSessionId = parts[1];
+            if (targetSessionId) {
+                const resumedSession = storage.setCurrentSessionById(targetSessionId);
+                if (!resumedSession) {
+                    ctx.addMessage('system', `Session not found: ${targetSessionId}`);
+                    break;
+                }
+                ctx.sessionRef.current = resumedSession;
+            }
+            if (ctx.ledger) {
+                ctx.ledger.loadSnapshot(storage.loadIterationLedger(targetSessionId || ctx.sessionRef.current?.id));
+                if (ctx.sessionRef.current?.id) {
+                    storage.saveIterationLedger(ctx.ledger, ctx.sessionRef.current.id);
+                }
+            }
             // Try loading full message history first (preferred - preserves tool calls etc.)
             const savedMessages = storage.loadMessageHistory(targetSessionId);
             if (savedMessages && savedMessages.length > 0) {
@@ -2384,11 +2676,16 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else {
                 // Fall back to chat.log history (legacy format, user/assistant only)
-                const history = storage.getChatHistory(20);
+                const history = storage.getChatHistory(20, targetSessionId);
                 if (history.length === 0) {
                     ctx.addMessage('system', 'No previous messages to resume. Start a conversation first, messages are auto-saved.');
                 }
                 else {
+                    ctx.llmMessages.current.length = 0;
+                    ctx.llmMessages.current.push({
+                        role: 'system',
+                        content: buildFullSystemPrompt(ctx.persona, getActiveProjectDir(ctx)),
+                    });
                     for (const msg of history) {
                         if (msg.role === 'user' || msg.role === 'assistant') {
                             ctx.llmMessages.current.push({
@@ -2442,19 +2739,234 @@ Example: /loop "Build a REST API" --max-iterations 50 --completion-promise "DONE
             }
             else if (subCmd === 'off') {
                 config.set('circuitBreakersEnabled', false);
-                ctx.addMessage('system', '\u2713 Circuit breakers disabled (will take effect on next agent run)');
+                // Also disable the current circuit breaker instance if it exists
+                if (ctx.circuitBreaker) {
+                    ctx.circuitBreaker = undefined;
+                    ctx.setBreakerHealth?.('ok');
+                }
+                ctx.addMessage('system', '\u2713 Circuit breakers disabled');
             }
             else if (subCmd === 'on') {
                 config.set('circuitBreakersEnabled', true);
                 ctx.addMessage('system', '\u2713 Circuit breakers enabled');
             }
+            else if (subCmd === 'adjust') {
+                const breakerTypeString = parts[2];
+                const param = parts[3];
+                const rawValue = parts[4];
+                // Handle special 'list' command to show detailed parameter info
+                if (breakerTypeString === 'list') {
+                    ctx.addMessage('system', `Circuit Breaker Configuration Reference:
+
+📊 REPEATED-FAILURE (Consecutive Errors)
+  • maxConsecutiveErrors: Number of consecutive errors before tripping (default: 3)
+  Example: /breaker adjust repeated-failure maxConsecutiveErrors 5
+
+💰 COST-RUNAWAY (Spending Control)
+  • maxSessionCost: Maximum total cost per session in USD (default: $5.0)
+  • maxCostPerMinute: Maximum spending rate per minute in USD (default: $1.0)
+  • windowSizeMs: Sliding window size for rate calculation in milliseconds (default: 60000)
+  Examples:
+    /breaker adjust cost-runaway maxSessionCost 10.0
+    /breaker adjust cost-runaway maxCostPerMinute 2.0
+
+🔄 INFINITE-LOOP (Repetitive Behavior)
+  • maxIdenticalInWindow: Max identical tool calls in window before tripping (default: 3)
+  • windowSize: Number of recent tool calls to analyze (default: 6)
+  • detectOscillation: Detect A-B-A-B oscillation patterns (default: true)
+  Examples:
+    /breaker adjust infinite-loop maxIdenticalInWindow 5
+    /breaker adjust infinite-loop detectOscillation false
+
+🔥 TOKEN-BURN (Token Usage Limits)
+  • maxTokensPerIteration: Max tokens per single iteration (default: 200,000)
+  • maxTotalTokens: Max total tokens per session (default: 5,000,000)
+  Examples:
+    /breaker adjust token-burn maxTokensPerIteration 100000
+    /breaker adjust token-burn maxTotalTokens 1000000
+
+⏸️  STALL (Progress Detection)
+  • maxIdleIterations: Max iterations with no tool calls/content (default: 5)
+  Example: /breaker adjust stall maxIdleIterations 3
+
+⏰ WALL-CLOCK (Time Limits)
+  • maxSessionDurationMs: Max session duration in milliseconds (0 = unlimited, default: 0)
+  • maxIterationDurationMs: Max single iteration duration in milliseconds (default: 600000 = 10 min)
+  Examples:
+    /breaker adjust wall-clock maxSessionDurationMs 3600000  # 1 hour
+    /breaker adjust wall-clock maxIterationDurationMs 300000  # 5 minutes
+
+Quick Commands:
+  /breaker adjust <type>              - Show current settings for that type
+  /breaker adjust                     - Show types overview
+  /breaker status                     - Show current breaker states`);
+                    break;
+                }
+                // Show basic types overview if no type specified
+                if (!breakerTypeString) {
+                    ctx.addMessage('system', `Circuit Breaker Types Available for Configuration:
+
+  repeated-failure  - Consecutive errors before tripping
+  cost-runaway      - Spending rate and total cost limits  
+  infinite-loop     - Identical tool calls and oscillation detection
+  token-burn        - Token usage per iteration and total limits
+  stall             - Idle iterations without progress
+  wall-clock        - Time-based session and iteration limits
+
+Usage: /breaker adjust <type> [param] [value]
+       /breaker adjust list                   - Show detailed parameter reference
+
+Examples:
+  /breaker adjust repeated-failure          - Show current settings
+  /breaker adjust cost-runaway maxSessionCost 10.0
+  /breaker adjust infinite-loop detectOscillation true`);
+                    break;
+                }
+                // Cast to BreakerType and validate
+                const breakerType = breakerTypeString;
+                const validTypes = ['repeated-failure', 'cost-runaway', 'infinite-loop', 'token-burn', 'stall', 'wall-clock'];
+                if (!validTypes.includes(breakerType)) {
+                    ctx.addMessage('error', `Invalid breaker type "${breakerType}". Valid types: ${validTypes.join(', ')}`);
+                    break;
+                }
+                const currentConfig = ctx.circuitBreaker.getConfig();
+                const breakerConfig = currentConfig.breakers[breakerType];
+                // Show current configuration if no param specified
+                if (!param) {
+                    let configDisplay = `${breakerType} Circuit Breaker Settings:\n`;
+                    switch (breakerType) {
+                        case 'repeated-failure':
+                            configDisplay += `  maxConsecutiveErrors: ${breakerConfig.maxConsecutiveErrors} errors\n\nUsage: /breaker adjust repeated-failure <param> <value>\n  /breaker adjust repeated-failure maxConsecutiveErrors <number>`;
+                            break;
+                        case 'cost-runaway':
+                            configDisplay += `  maxSessionCost: ${breakerConfig.maxSessionCost} per session\n  maxCostPerMinute: ${breakerConfig.maxCostPerMinute} per minute\n  windowSizeMs: ${breakerConfig.windowSizeMs}ms\n\nUsage: /breaker adjust cost-runaway <param> <value>\n  /breaker adjust cost-runaway maxSessionCost <dollars>\n  /breaker adjust cost-runaway maxCostPerMinute <dollars>\n  /breaker adjust cost-runaway windowSizeMs <milliseconds>`;
+                            break;
+                        case 'infinite-loop':
+                            configDisplay += `  maxIdenticalInWindow: ${breakerConfig.maxIdenticalInWindow} calls\n  windowSize: ${breakerConfig.windowSize} recent calls\n  detectOscillation: ${breakerConfig.detectOscillation}\n\nUsage: /breaker adjust infinite-loop <param> <value>\n  /breaker adjust infinite-loop maxIdenticalInWindow <number>\n  /breaker adjust infinite-loop windowSize <number>\n  /breaker adjust infinite-loop detectOscillation <true|false>`;
+                            break;
+                        case 'token-burn':
+                            configDisplay += `  maxTokensPerIteration: ${breakerConfig.maxTokensPerIteration.toLocaleString()} tokens\n  maxTotalTokens: ${breakerConfig.maxTotalTokens.toLocaleString()} tokens\n\nUsage: /breaker adjust token-burn <param> <value>\n  /breaker adjust token-burn maxTokensPerIteration <number>\n  /breaker adjust token-burn maxTotalTokens <number>`;
+                            break;
+                        case 'stall':
+                            configDisplay += `  maxIdleIterations: ${breakerConfig.maxIdleIterations} iterations\n\nUsage: /breaker adjust stall <param> <value>\n  /breaker adjust stall maxIdleIterations <number>`;
+                            break;
+                        case 'wall-clock':
+                            const sessionDuration = breakerConfig.maxSessionDurationMs;
+                            const iterationDuration = breakerConfig.maxIterationDurationMs;
+                            configDisplay += `  maxSessionDurationMs: ${sessionDuration === 0 ? 'unlimited' : sessionDuration + 'ms'}\n  maxIterationDurationMs: ${iterationDuration}ms (${Math.round(iterationDuration / 60000)} minutes)\n\nUsage: /breaker adjust wall-clock <param> <value>\n  /breaker adjust wall-clock maxSessionDurationMs <milliseconds>\n  /breaker adjust wall-clock maxIterationDurationMs <milliseconds>`;
+                            break;
+                    }
+                    ctx.addMessage('system', configDisplay);
+                    break;
+                }
+                // Parse and validate the value
+                let parsedValue;
+                // Handle boolean parameters
+                if (param === 'detectOscillation') {
+                    if (rawValue === 'true')
+                        parsedValue = true;
+                    else if (rawValue === 'false')
+                        parsedValue = false;
+                    else {
+                        ctx.addMessage('error', 'detectOscillation must be "true" or "false"');
+                        break;
+                    }
+                }
+                else {
+                    // Handle numeric parameters
+                    parsedValue = parseFloat(rawValue);
+                    if (isNaN(parsedValue) || parsedValue < 0) {
+                        ctx.addMessage('error', 'Value must be a non-negative number');
+                        break;
+                    }
+                }
+                // Validate parameter names for each breaker type
+                const paramValidations = {
+                    'repeated-failure': {
+                        params: ['maxConsecutiveErrors'],
+                        validate: (param, value) => value <= 0 ? 'maxConsecutiveErrors must be > 0' : null
+                    },
+                    'cost-runaway': {
+                        params: ['maxSessionCost', 'maxCostPerMinute', 'windowSizeMs'],
+                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
+                    },
+                    'infinite-loop': {
+                        params: ['maxIdenticalInWindow', 'windowSize', 'detectOscillation'],
+                        validate: (param, value) => {
+                            if (param === 'detectOscillation')
+                                return null; // boolean is already validated above
+                            return value <= 0 ? `${param} must be > 0` : null;
+                        }
+                    },
+                    'token-burn': {
+                        params: ['maxTokensPerIteration', 'maxTotalTokens'],
+                        validate: (param, value) => value <= 0 ? `${param} must be > 0` : null
+                    },
+                    'stall': {
+                        params: ['maxIdleIterations'],
+                        validate: (param, value) => value <= 0 ? 'maxIdleIterations must be > 0' : null
+                    },
+                    'wall-clock': {
+                        params: ['maxSessionDurationMs', 'maxIterationDurationMs'],
+                        validate: (param, value) => {
+                            if (param === 'maxSessionDurationMs' && value === 0)
+                                return null; // 0 = unlimited is valid
+                            return value < 0 ? `${param} cannot be negative` : null;
+                        }
+                    }
+                };
+                const validation = paramValidations[breakerType];
+                if (!validation.params.includes(param)) {
+                    ctx.addMessage('error', `Invalid parameter "${param}" for ${breakerType}. Valid parameters: ${validation.params.join(', ')}`);
+                    break;
+                }
+                // Run custom validation if provided
+                if (validation.validate) {
+                    const error = validation.validate(param, parsedValue);
+                    if (error) {
+                        ctx.addMessage('error', error);
+                        break;
+                    }
+                }
+                // Update the configuration
+                const oldValue = breakerConfig[param];
+                ctx.circuitBreaker.adjust(breakerType, { [param]: parsedValue });
+                // Format the success message based on parameter type
+                let formattedOld, formattedNew;
+                if (param === 'detectOscillation') {
+                    formattedOld = String(oldValue);
+                    formattedNew = String(parsedValue);
+                }
+                else if (param.includes('Cost')) {
+                    formattedOld = `${oldValue}`;
+                    formattedNew = `${parsedValue}`;
+                }
+                else if (param.includes('Ms')) {
+                    formattedOld = oldValue === 0 ? 'unlimited' : `${oldValue}ms`;
+                    formattedNew = parsedValue === 0 ? 'unlimited' : `${parsedValue}ms`;
+                }
+                else if (param.includes('Tokens')) {
+                    formattedOld = oldValue.toLocaleString();
+                    formattedNew = parsedValue.toLocaleString();
+                }
+                else {
+                    formattedOld = String(oldValue);
+                    formattedNew = String(parsedValue);
+                }
+                ctx.addMessage('system', `✅ ${breakerType} ${param}: ${formattedOld} → ${formattedNew}`);
+            }
             else {
-                ctx.addMessage('system', `Usage: /breaker [status|resume|reset|on|off]
+                ctx.addMessage('system', `Usage: /breaker [status|resume|reset|adjust|on|off]
   /breaker resume [type]  - Resume tripped breaker (half-open)
   /breaker reset [type]   - Reset breaker to closed
+  /breaker adjust [type] [param] [value] - Configure breaker thresholds
   /breaker on|off         - Enable/disable circuit breakers
 
-Breaker types: repeated-failure, cost-runaway, infinite-loop, token-burn, stall`);
+Breaker types: repeated-failure, cost-runaway, infinite-loop, token-burn, stall, wall-clock
+
+Quick help:
+  /breaker adjust         - Show types overview
+  /breaker adjust list    - Show detailed parameter reference`);
             }
             break;
         }
@@ -2523,6 +3035,7 @@ Usage: /smart [on|off|cost <0-1>|test <message>]
         case '/swarm':
         case '/council': {
             const subCmd = parts[1];
+            const swarmCwd = ctx.sessionRef.current?.projectPath ?? process.cwd();
             if (!ctx.agtermEnabled) {
                 ctx.addMessage('system', 'Agents mode not enabled. Start with --agents flag to use agent swarms.');
                 break;
@@ -2603,7 +3116,7 @@ Usage: /smart [on|off|cost <0-1>|test <message>]
                     try {
                         let session;
                         if (template) {
-                            session = await councilManager.startFromTemplate(template, cleanPrompt);
+                            session = await councilManager.startFromTemplate(template, cleanPrompt, swarmCwd);
                         }
                         else {
                             const { randomUUID } = await import('crypto');
@@ -2612,8 +3125,9 @@ Usage: /smart [on|off|cost <0-1>|test <message>]
                                 { id: randomUUID(), name: 'Agent B', agent: 'claude', weight: 1.0 },
                                 { id: randomUUID(), name: 'Agent C', agent: 'claude', weight: 1.0 },
                             ];
-                            session = await councilManager.startCouncil(cleanPrompt, { mode, members });
+                            session = await councilManager.startCouncil(cleanPrompt, { mode, members }, swarmCwd);
                         }
+                        watchAsyncLedgerRun(ctx.ledger, 'council', cleanPrompt, () => councilManager.getSession(session.id));
                         ctx.addMessage('system', `\u2713 Swarm coordination started: ${session.id.slice(0, 8)}\nMode: ${session.config.mode}\nAgents: ${session.config.members.map(m => m.name).join(', ')}\n\nUse /swarm coord status ${session.id.slice(0, 8)} to check progress.`);
                     }
                     catch (err) {
@@ -2674,7 +3188,8 @@ Options:
                     cleanPrompt = cleanPrompt.replace(aggMatch[0], '').trim();
                 }
                 try {
-                    const session = await swarmManager.startSwarm(cleanPrompt, { decomposition: strategy, aggregation });
+                    const session = await swarmManager.startSwarm(cleanPrompt, { decomposition: strategy, aggregation }, swarmCwd);
+                    watchAsyncLedgerRun(ctx.ledger, 'swarm', cleanPrompt, () => swarmManager.getSession(session.id));
                     ctx.addMessage('system', `\u2713 Swarm started: ${session.id.slice(0, 8)}\nStrategy: ${strategy} \u2192 ${aggregation}\nStatus: ${session.status}\n\nUse /swarm status ${session.id.slice(0, 8)} to check progress.`);
                 }
                 catch (err) {
@@ -2858,14 +3373,16 @@ Requires --agents flag.`);
             runJob(bgJob.id, async (prompt, signal) => {
                 const { chat } = await import('../providers/index.js');
                 const { TOOLS } = await import('../tools.js');
-                const { getSystemPrompt: getSysPrompt } = await import('../types.js');
+                const { executeTool: execTool } = await import('../tools.js');
+                const cwd = ctx.sessionRef.current?.projectPath || process.cwd();
+                const maxIterations = resolveIterationLimit(config.get('maxIterations'));
                 const bgMessages = [
-                    { role: 'system', content: getSysPrompt(ctx.persona) },
+                    { role: 'system', content: buildFullSystemPrompt(ctx.persona, cwd) },
                     { role: 'user', content: prompt },
                 ];
                 let iterations = 0;
                 let lastContent = '';
-                while (iterations < 20 && !signal.aborted) {
+                while (!signal.aborted && iterations < maxIterations) {
                     iterations++;
                     const response = await chat(ctx.provider, bgMessages, TOOLS, ctx.model);
                     if (!response.toolCalls?.length) {
@@ -2873,12 +3390,18 @@ Requires --agents flag.`);
                         break;
                     }
                     bgMessages.push({ role: 'assistant', content: response.content, toolCalls: response.toolCalls });
-                    const { executeTool: execTool } = await import('../tools.js');
                     for (const tc of response.toolCalls) {
-                        const result = await execTool(tc, process.cwd());
+                        const result = await execTool(tc, cwd);
                         bgMessages.push({ role: 'tool', content: result.result, toolCallId: tc.id });
+                        if (signal.aborted)
+                            break;
                     }
                 }
+                if (signal.aborted) {
+                    const error = new Error('Background job cancelled');
+                    error.name = 'AbortError';
+                    throw error;
+                }
                 return { result: lastContent, iterations };
             }).then(completed => {
                 ctx.addMessage('system', `Background job ${completed.id} ${completed.status}: ${completed.result?.slice(0, 200) || completed.error || 'done'}`);