ai-runtime-engine 2.7.0 → 2.9.0

package/dist/cli/interactive/session.js

@@ -13,13 +13,17 @@ import { actionCapabilityRows, renderActionCapabilities, renderCapabilityGaps }
 import { renderMcpList, renderMcpDetail } from '../commands/mcp.js';
 import { candidatesFrom, deriveCapabilitiesOffline } from '../../runtime/planning/deriveCapabilities.js';
 import { displaySafe } from '../render.js';
+import { AGENT_TERMINAL } from '../../agents/task.js';
+import { TERMINAL as EXEC_TERMINAL } from '../../executions/execution.js';
 /** Top-level slash commands, for REPL tab-completion (Phase 21b). Kept in sync with the `handle` dispatch. */
 export const SLASH_COMMANDS = [
     'help', 'status', 'info', 'doctor', 'cleanup', 'mode', 'compare', 'models', 'config', 'providers', 'tools', 'capabilities', 'mcp',
-    'skills', 'memory', 'conversations', 'executions', 'resume', 'resume-execution', 'pause', 'cancel', 'approve',
+    'skills', 'memory', 'conversations', 'executions', 'agents', 'resume', 'resume-execution', 'pause', 'cancel', 'approve',
     'deny', 'learning', 'feedback', 'permissions', 'budget', 'stream', 'dry-run', 'clear', 'exit', 'quit',
 ];
-const HELP = [
+/** Exported so a test can prove every reachable command is documented — the three touch points below
+ *  are synced by hand, and `/agents` shipped tab-completable but absent from this list. */
+export const HELP = [
     'Commands:',
     '  /help                       show this help',
     '  /status                     workspace, mode, provider count',
@@ -49,6 +53,8 @@ const HELP = [
     '  /conversations              list recent conversations',
     '  /resume <id>                resume a conversation',
     '  /executions                 list persisted executions',
+    '  /agents                     list agent tasks (state, progress, spend, findings)',
+    '  /agents stop <id>           stop one agent task',
     '  /resume-execution <id>      resume an execution',
     '  /approve <id>               approve an execution waiting for approval, then continue',
     '  /deny <id>                  deny an execution waiting for approval (cancels it)',
@@ -59,7 +65,7 @@ const HELP = [
     '  /stream                     toggle token-by-token streaming of answers',
     '  /budget                     show the call/cost budget (AI_MAX_CALLS / AI_MAX_COST_USD)',
     '  /clear                      clear the screen',
-    '  /exit                       leave the session',
+    '  /exit, /quit                leave the session',
     '',
     'Anything else is sent to the runtime as a request.',
 ];
@@ -209,6 +215,8 @@ export class ReplSession {
                 return this.resume(args[0]);
             case 'executions':
                 return this.executionsList();
+            case 'agents':
+                return args[0] === 'stop' ? this.agentStop(args[1]) : this.agentsList();
             case 'resume-execution':
                 return this.resumeExecution(args[0]);
             case 'approve':
@@ -327,6 +335,32 @@ export class ReplSession {
             return { lines: ['no conversations yet.'] };
         return { lines: ['Recent conversations:', ...list.map((c, i) => `  ${i + 1}. ${c.id}  ${c.title} (${c.turns} turns)`)] };
     }
+    /** Agent tasks across this project's executions, newest first. */
+    agentsList() {
+        if (!this.runtime.executionStore.enabled)
+            return { lines: ['agent tasks are not persisted (stateless mode).'] };
+        const tasks = this.runtime.agentTasks().slice(0, 12);
+        if (!tasks.length)
+            return { lines: ['no agent tasks yet.', '(agents run when `runtime.agents.enabled` is set and a plan delegates to one)'] };
+        // A waiting task's question goes on its own line: it is the one thing the user must read to act.
+        const lines = tasks.flatMap((t) => {
+            const steps = `${t.innerSteps.succeeded}/${t.innerSteps.total}`;
+            const spend = `${t.callsUsed}/${t.callsReserved} call(s), ${t.toolCallsUsed} tool call(s)`;
+            const why = t.interruption ? `  (${t.interruption.kind})` : '';
+            // `stepId` is planner-authored and `question` is model-authored: both go through displaySafe,
+            // like every other untrusted string this file renders.
+            const row = `  ${t.agentTaskId}  [${t.state}]  ${t.agentId} @ ${displaySafe(t.stepId, 40)}  ${steps} inner step(s), ${spend}, ${t.findings} finding(s)${why}`;
+            return t.question ? [row, `      ? ${displaySafe(t.question, 200)}`] : [row];
+        });
+        return { lines: ['Agent tasks:', ...lines, '', 'stop one with /agents stop <agent-task-id>'] };
+    }
+    /** Stop one agent task. Every outcome is reported — a stop that looks like nothing happened is a bug. */
+    agentStop(id) {
+        if (!id)
+            return { lines: ['usage: /agents stop <agent-task-id>'] };
+        const r = this.runtime.stopAgentTask(id);
+        return { lines: [`${r.ok ? 'stopped' : 'not stopped'} ${id}: ${r.reason}${r.state ? ` (state: ${r.state})` : ''}`] };
+    }
     executionsList() {
         if (!this.runtime.executionStore.enabled)
             return { lines: ['executions are disabled (stateless mode).'] };
@@ -362,13 +396,31 @@ export class ReplSession {
     status() {
         const ws = this.runtime.workspaceInfo();
         const providers = this.runtime.ai.providers();
-        return {
-            lines: [
-                `workspace: ${ws?.name ?? '(none)'}${ws?.git.branch ? ` @ ${ws.git.branch}` : ''}`,
-                `mode:      ${this.mode}`,
-                `providers: ${providers.length} configured (${providers.filter((p) => p.enabled).length} enabled)`,
-            ],
-        };
+        const lines = [
+            `workspace: ${ws?.name ?? '(none)'}${ws?.git.branch ? ` @ ${ws.git.branch}` : ''}`,
+            `mode:      ${this.mode}`,
+            `providers: ${providers.length} configured (${providers.filter((p) => p.enabled).length} enabled)`,
+        ];
+        // Phase 3.6: agent work is the one thing that can be UNFINISHED and invisible — a task left waiting
+        // or interrupted holds its execution up, so /status names it rather than leaving the user to think
+        // to run /agents. Absent entirely when nothing has ever delegated, so the flag-off output is
+        // unchanged.
+        // Only executions that are themselves still going: a non-terminal task on a finished execution is
+        // stale bookkeeping, and reporting it as "unfinished work" forever would train the user to ignore
+        // this line — which is the one line that has to be trusted when something IS waiting.
+        const live = this.runtime.executionStore.enabled ? this.runtime.executions().filter((e) => !EXEC_TERMINAL.has(e.status)) : [];
+        const tasks = live.flatMap((e) => this.runtime.agentTasks(e.id));
+        if (tasks.length) {
+            const unfinished = tasks.filter((t) => !AGENT_TERMINAL.has(t.state));
+            const waiting = unfinished.filter((t) => t.state === 'waiting_for_clarification' || t.state === 'waiting_for_input');
+            lines.push(`agents:    ${tasks.length} task(s), ${unfinished.length} unfinished${waiting.length ? `, ${waiting.length} waiting for an answer` : ''}`);
+            for (const t of unfinished.slice(0, 3)) {
+                lines.push(`             ${t.agentTaskId} [${t.state}] ${displaySafe(t.agentId, 24)} @ ${displaySafe(t.stepId, 16)}  ${t.innerSteps.succeeded}/${t.innerSteps.total} step(s)`);
+            }
+            if (unfinished.length > 3)
+                lines.push(`             … ${unfinished.length - 3} more (/agents)`);
+        }
+        return { lines };
     }
     setOrShowMode(next) {
         if (!next)