@orion-agents/orion-code 0.1.6 → 0.1.8

package/dist/runtime/agent-runtime-controller.js

@@ -21,6 +21,8 @@ const session_storage_1 = require("../services/session-storage");
 const external_assertion_1 = require("../framework/external-assertion");
 const global_config_1 = require("../services/global-config");
 const tool_allowlist_1 = require("../services/tool-allowlist");
+const agent_mode_1 = require("../framework/agent-mode");
+const lifecycle_1 = require("./goals/lifecycle");
 function isExitInput(input) {
     const parsed = (0, parser_1.parseInput)(input.trim());
     return parsed.isCommand && ['exit', 'quit', 'q'].includes(parsed.name);
@@ -98,6 +100,9 @@ class AgentRuntimeController {
         this.goalProviderReservedTokens = 0;
         this.nextPermissionRequestId = 1;
         this.queuedCommands = [];
+        this.followupQueue = [];
+        this.followupQueueLimit = 16;
+        this.nextFollowupId = 1;
         /** v0.2.24: optional goal coordinator for /target mode. */
         this.goalCoordinator = null;
         this.goalCoordinatorSessionId = null;
@@ -111,18 +116,31 @@ class AgentRuntimeController {
                 this.captureGoalEvidence(event);
                 const result = downstream.emit(event);
                 if (event.type === 'session_restored') {
+                    if (this.followupQueue.length > 0) {
+                        this.followupQueue.splice(0);
+                        this.emitFollowupQueue();
+                    }
                     this.restoreGoalForSession(event.event.sessionId, event.event.projectPath);
                 }
                 return result;
             },
         };
+        this.agentModeLifecycle =
+            options.agentModeLifecycle ?? new agent_mode_1.AgentModeLifecycleController(options.runtime.store);
+        this.agentModeLifecycle.subscribe(snapshot => {
+            this.eventSink.emit({ type: 'agent_mode_changed', snapshot });
+        });
         const events = (0, agent_runtime_protocol_1.createUiEventSinkFromAgentRuntimeEvents)(this.eventSink);
         this.runner =
             options.runner ?? new chat_controller_1.AgentChatController(options.runtime, events, this.createChatOptions());
+        this.emitAgentModeSnapshot();
     }
     hasActiveTurn() {
         return this.turnController.hasActiveTurn();
     }
+    getFollowupQueue() {
+        return this.followupQueue;
+    }
     /** v0.1.1: shared /target command handling for all renderers. */
     handleTargetInput(rawInput) {
         if (/^\/target(?:\s|$)/iu.test(rawInput.trim())) {
@@ -243,7 +261,11 @@ class AgentRuntimeController {
                             this.abortGoalOwnedExecution();
                             executionRevoked = true;
                         }
-                        success = coord.clear();
+                        success = (0, lifecycle_1.clearGoalLifecycle)(coord) !== null;
+                        if (success && this.followupQueue.length > 0) {
+                            this.followupQueue.splice(0);
+                            this.emitFollowupQueue();
+                        }
                         if (hadGoal && !success) {
                             error = this.failClosedGoalMutation(coord, input.action, new Error('Target clear did not remove the active Goal.'), executionRevoked, previousGoalId);
                         }
@@ -281,23 +303,21 @@ class AgentRuntimeController {
                 }
             }
         }
-        if (success) {
+        if (success && input.action !== 'clear') {
             const { updateSessionGoalBinding } = require('../services/session-storage');
             updateSessionGoalBinding(coord.boundSessionId, coord.goal);
-            if (input.action === 'clear' && previousGoalId) {
-                this.emitGoalEvent({ type: 'goal_cleared', goalId: previousGoalId, reason: 'user_clear' });
-            }
-            else {
-                const snapshot = coord.snapshot();
-                if (snapshot) {
-                    this.emitGoalEvent({
-                        type: 'goal_updated',
-                        goal: snapshot,
-                        reason: `target_${input.action}`,
-                    });
-                }
+            const snapshot = coord.snapshot();
+            if (snapshot) {
+                this.emitGoalEvent({
+                    type: 'goal_updated',
+                    goal: snapshot,
+                    reason: `target_${input.action}`,
+                });
             }
         }
+        if (success && input.action === 'clear' && previousGoalId) {
+            this.emitGoalEvent({ type: 'goal_cleared', goalId: previousGoalId, reason: 'user_clear' });
+        }
         const statusText = this.formatTargetStatus(coord);
         this.emitAppend({ role: 'system', title: 'target', content: statusText });
         if (success &&
@@ -346,6 +366,10 @@ class AgentRuntimeController {
         switch (input.type) {
             case 'submit':
                 return this.submit(input.text);
+            case 'queue_followup':
+                return this.queueFollowup(input.text);
+            case 'manage_followup_queue':
+                return this.manageFollowupQueue(input.action, input.itemId);
             case 'select_session':
                 return this.submit(resumeSessionInput(input.sessionId, input.allProjects));
             case 'permission_decision':
@@ -359,8 +383,47 @@ class AgentRuntimeController {
                 return this.handleGoalControl(input);
             case 'permission_mode_change':
                 return this.applyPermissionModeChange(input.value);
+            case 'cycle_agent_mode':
+                return this.cycleAgentMode();
         }
     }
+    queueFollowup(input) {
+        const text = input.trim();
+        if (!text)
+            return { type: 'empty' };
+        if (!this.turnController.hasActiveTurn()) {
+            this.emitStatus('Nothing is running; press Enter to submit this message now.');
+            return { type: 'command_ignored' };
+        }
+        if (this.followupQueue.length >= this.followupQueueLimit) {
+            this.emitStatus(`Follow-up queue is full (${this.followupQueueLimit}).`);
+            return { type: 'followup_queue_full' };
+        }
+        const item = {
+            id: `followup-${this.nextFollowupId++}`,
+            text,
+            queuedAt: Date.now(),
+        };
+        this.followupQueue.push(item);
+        this.emitFollowupQueue();
+        this.emitStatus(`Queued follow-up ${this.followupQueue.length}/${this.followupQueueLimit}.`);
+        return { type: 'followup_queued', itemId: item.id };
+    }
+    manageFollowupQueue(action, itemId) {
+        if (action === 'clear') {
+            this.followupQueue.splice(0);
+        }
+        else if (itemId) {
+            const index = this.followupQueue.findIndex(item => item.id === itemId);
+            if (index >= 0)
+                this.followupQueue.splice(index, 1);
+        }
+        this.emitFollowupQueue();
+        this.emitStatus(this.followupQueue.length > 0
+            ? `${this.followupQueue.length} follow-up(s) queued.`
+            : 'Follow-up queue is empty.');
+        return { type: 'followup_queue_changed' };
+    }
     submit(input) {
         const submitted = input.trim();
         if (!submitted)
@@ -372,6 +435,22 @@ class AgentRuntimeController {
         if ((0, target_command_1.isTargetCommand)(submitted)) {
             return this.handleTargetInput(submitted).runtimeResult;
         }
+        const activeSession = this.options.runtime.getSession();
+        const activeGoalCoordinator = this.ensureGoalCoordinator(false);
+        if (activeSession && activeGoalCoordinator?.goal) {
+            const abandonment = (0, tools_1.authorizeGoalAbandonment)({
+                inputKind: 'user',
+                text: submitted,
+                sessionId: activeSession.id,
+                persistAsUserMessage: true,
+                echoToTranscript: true,
+                generation: activeGoalCoordinator.generation,
+            });
+            if (abandonment.authorized) {
+                this.emitAppend(submittedEntry(submitted));
+                return this.handleTargetInput('/goal exit').runtimeResult;
+            }
+        }
         const parsedInput = (0, parser_1.parseInput)(submitted);
         if (parsedInput.isCommand && parsedInput.name === 'clear') {
             this.emitClearView();
@@ -783,7 +862,52 @@ class AgentRuntimeController {
             this.emitGoalEvent({ type: 'goal_updated', goal: snapshot, reason: 'turn_finalized' });
             if (terminalEvent)
                 this.emitGoalEvent(terminalEvent);
+            if (terminalEvent?.type === 'goal_completed') {
+                this.autoExitCompletedGoal(coord, snapshot.goalId, 'completion_auto_exit');
+            }
+        }
+    }
+    /**
+     * Leave Goal mode after a passed completion audit while retaining the
+     * terminal sidecar as the durable completion receipt. The conditional
+     * session mutation prevents a stale completion from clearing a newer Goal.
+     */
+    autoExitCompletedGoal(coord, goalId, reason) {
+        if (coord.goal?.goalId !== goalId ||
+            coord.goal.status !== 'complete' ||
+            coord.goal.completionAudit?.passed !== true) {
+            return false;
+        }
+        try {
+            const { clearSessionGoalBinding } = require('../services/session-storage');
+            const session = clearSessionGoalBinding(coord.boundSessionId, goalId);
+            if (!session) {
+                throw new Error(`Session ${coord.boundSessionId} was not found while clearing Goal mode.`);
+            }
+            if (!coord.detachCompletedReceipt(goalId)) {
+                throw new Error(`Completed Goal ${goalId} could not be detached from the live runtime.`);
+            }
+        }
+        catch (cause) {
+            const detail = (0, redaction_1.redactTraceText)(cause instanceof Error ? cause.message : String(cause)).slice(0, 600);
+            const message = `Goal completed, but automatic Goal-mode exit could not clear the session binding. The completed Goal remains terminal and will be reconciled on restore. ${detail}`;
+            this.emitAppend({
+                role: 'error',
+                title: 'goal auto-exit',
+                content: message,
+                errorLayer: 'session',
+            });
+            this.emitStatus(message);
+            return false;
+        }
+        this.continuationScheduleEpoch += 1;
+        this.rejectPendingPermissions();
+        if (this.followupQueue.length > 0) {
+            this.followupQueue.splice(0);
+            this.emitFollowupQueue();
         }
+        this.emitGoalEvent({ type: 'goal_cleared', goalId, reason });
+        return true;
     }
     failClosedGoalPersistence(coord, goalId, error, operation) {
         const message = this.failClosedGoalMutation(coord, operation, error, false, goalId);
@@ -932,6 +1056,7 @@ class AgentRuntimeController {
             if (!this.requestIsCurrent(nextRequest))
                 break;
             const request = nextRequest;
+            const planCompletionBeforeRequest = this.agentModeLifecycle.completionRevision();
             const nextInput = request.text?.trim() ||
                 'Continue pursuing the active goal from its persisted plan and evidence.';
             if ((this.options.echoSubmittedInput ?? true) &&
@@ -993,6 +1118,13 @@ class AgentRuntimeController {
                 preserveTerminalGoalStatus = Boolean(finalizedGoal?.completionAudit ||
                     (toolContext?.pendingTerminalRequest?.requestedStatus === 'blocked' &&
                         finalizedGoal?.status !== 'blocked'));
+                const completedPlan = this.agentModeLifecycle.completedPlanSince(planCompletionBeforeRequest) ?? undefined;
+                // A shortcut pressed during the turn affects the next logical request,
+                // never the permissions or tools of the request that just completed.
+                // exit_plan_mode consumes a pending next mode while saving the plan;
+                // every other request applies it here at the same boundary.
+                if (!completedPlan)
+                    this.agentModeLifecycle.applyPending();
                 if (revision?.trim()) {
                     const currentCoord = this.ensureGoalCoordinator(false);
                     const currentGoal = currentCoord?.goal?.status === 'active' ? currentCoord.goal : undefined;
@@ -1021,12 +1153,36 @@ class AgentRuntimeController {
                         };
                     }
                 }
+                else if (completedPlan) {
+                    const currentCoord = this.ensureGoalCoordinator(false);
+                    const currentGoal = currentCoord?.goal?.status === 'active' ? currentCoord.goal : undefined;
+                    nextRequest = {
+                        inputKind: 'plan_execution',
+                        text: `Execute the saved plan now. Continue autonomously from the plan and verify the result.\n\n${completedPlan}`,
+                        sessionId: this.options.runtime.getSession()?.id ?? request.sessionId,
+                        goal: currentGoal
+                            ? {
+                                goalId: currentGoal.goalId,
+                                revision: currentGoal.revision,
+                                continuationIndex: currentGoal.continuationCount,
+                            }
+                            : undefined,
+                        persistAsUserMessage: false,
+                        echoToTranscript: false,
+                        generation: currentCoord?.generation ?? 0,
+                    };
+                    this.emitStatus('Plan saved · starting execution in the selected mode.');
+                }
                 else {
                     const queuedCommand = this.queuedCommands.shift();
-                    nextRequest = queuedCommand
+                    const queuedFollowup = queuedCommand ? undefined : this.followupQueue.shift();
+                    if (queuedFollowup)
+                        this.emitFollowupQueue();
+                    const queuedInput = queuedCommand ?? queuedFollowup?.text;
+                    nextRequest = queuedInput
                         ? {
                             inputKind: 'user',
-                            text: queuedCommand,
+                            text: queuedInput,
                             sessionId: this.options.runtime.getSession()?.id ?? request.sessionId,
                             persistAsUserMessage: true,
                             echoToTranscript: false,
@@ -1081,6 +1237,27 @@ class AgentRuntimeController {
     emitProcessing(processing) {
         this.eventSink.emit({ type: 'processing_changed', processing });
     }
+    emitFollowupQueue() {
+        this.eventSink.emit({
+            type: 'followup_queue_changed',
+            snapshot: { items: [...this.followupQueue], limit: this.followupQueueLimit },
+        });
+    }
+    emitAgentModeSnapshot() {
+        this.eventSink.emit({
+            type: 'agent_mode_changed',
+            snapshot: this.agentModeLifecycle.snapshot(),
+        });
+    }
+    cycleAgentMode() {
+        const deferred = this.turnController.hasActiveTurn();
+        const snapshot = this.agentModeLifecycle.cycle({ defer: deferred });
+        return {
+            type: 'agent_mode_changed',
+            snapshot,
+            appliesFrom: deferred ? 'next-logical-request' : 'immediate',
+        };
+    }
     emitGoalEvent(event) {
         this.eventSink.emit({ type: 'goal_event', event });
     }
@@ -1166,6 +1343,11 @@ class AgentRuntimeController {
                 .filter(Boolean)
                 .join(' ')
             : undefined;
+        const goalRuntimeSubject = (0, evidence_1.describeGoalRuntimeEvidence)({
+            name: event.event.name,
+            success: event.event.success,
+            error: event.event.error,
+        });
         const record = {
             id: `evidence:${(0, crypto_1.randomUUID)()}`,
             goalId: goal.goalId,
@@ -1173,7 +1355,11 @@ class AgentRuntimeController {
             objectiveRevision: goal.contract?.objectiveRevision ?? 0,
             turnId: context.turnId,
             kind,
-            subject: (0, redaction_1.redactTraceText)(assertionSubject || event.event.summary || event.event.error || event.event.name).slice(0, 512),
+            subject: (0, redaction_1.redactTraceText)(assertionSubject ||
+                goalRuntimeSubject ||
+                event.event.summary ||
+                event.event.error ||
+                event.event.name).slice(0, 512),
             result,
             sourceRef: `tool:${event.event.callId}:${event.event.name}`,
             capturedAt,
@@ -1201,10 +1387,25 @@ class AgentRuntimeController {
         this.continuationScheduleEpoch += 1;
         this.goalCoordinator = null;
         this.goalCoordinatorSessionId = null;
-        const coord = this.bindGoalCoordinator(sessionId, true, projectPath);
+        const coord = this.bindGoalCoordinator(sessionId, true, projectPath, true);
         const snapshot = coord?.snapshot();
-        if (snapshot)
+        if (!snapshot)
+            return;
+        if (snapshot.status === 'complete' && coord.goal?.completionAudit?.passed === true) {
+            // A completed sidecar with no active binding is a historical receipt,
+            // not an active Goal to restore. Only replay the completion lifecycle
+            // when recovering the crash window between the terminal write and the
+            // conditional binding clear.
             this.emitGoalEvent({ type: 'goal_restored', goal: snapshot });
+            this.emitGoalEvent({
+                type: 'goal_completed',
+                goal: snapshot,
+                audit: coord.goal.completionAudit,
+            });
+            this.autoExitCompletedGoal(coord, snapshot.goalId, 'completion_recovery_auto_exit');
+            return;
+        }
+        this.emitGoalEvent({ type: 'goal_restored', goal: snapshot });
     }
     async requestToolPermission(request) {
         if (request.abortSignal?.aborted || this.stopping)
@@ -1281,7 +1482,7 @@ class AgentRuntimeController {
                     if (input.payload?.confirmed && coord.goal !== null) {
                         this.abortGoalOwnedExecution();
                         executionRevoked = true;
-                        if (!coord.clear()) {
+                        if (!(0, lifecycle_1.clearGoalLifecycle)(coord)) {
                             const message = this.failClosedGoalMutation(coord, input.action, new Error('Target clear did not remove the active Goal.'), executionRevoked, goalIdBeforeMutation);
                             this.emitGoalMutationError(message);
                         }
@@ -1319,10 +1520,37 @@ class AgentRuntimeController {
         }
         return this.bindGoalCoordinator(sessionId, true, session.projectPath || this.options.runtime.cwd);
     }
-    bindGoalCoordinator(sessionId, recoverActive, projectPath) {
+    bindGoalCoordinator(sessionId, recoverActive, projectPath, restoreMissingBinding = false) {
         const { GoalCoordinator } = require('./goals/coordinator');
         const coord = new GoalCoordinator(projectPath, sessionId);
         coord.load(recoverActive);
+        if (coord.goal) {
+            const { loadSessionMeta, restoreSessionGoalBinding } = require('../services/session-storage');
+            const session = loadSessionMeta(sessionId);
+            if (coord.goal.status === 'complete' &&
+                coord.goal.completionAudit?.passed === true &&
+                session?.activeGoalId !== coord.goal.goalId) {
+                coord.detachCompletedReceipt(coord.goal.goalId);
+            }
+            else if (restoreMissingBinding && !session?.activeGoalId) {
+                try {
+                    const restored = session
+                        ? restoreSessionGoalBinding(sessionId, coord.goal, session.updatedAt ?? session.startTime)
+                        : null;
+                    if (!restored) {
+                        throw new Error(`Session ${sessionId} was not found while restoring its Goal binding.`);
+                    }
+                }
+                catch (cause) {
+                    this.emitAppend({
+                        role: 'error',
+                        title: 'target recovery',
+                        content: `Goal sidecar ${coord.goal.goalId} remains paused, but its session binding could not be restored safely. ${(0, redaction_1.redactTraceText)(cause instanceof Error ? cause.message : String(cause))}`,
+                        errorLayer: 'session',
+                    });
+                }
+            }
+        }
         if (coord.lastLoadIssue) {
             this.emitAppend({
                 role: 'error',
@@ -1438,6 +1666,7 @@ class AgentRuntimeController {
         const chatOptions = {
             uiCapabilities,
             uiRenderer: resolvedRenderer,
+            agentModeLifecycle: this.agentModeLifecycle,
             onVerificationStateChange: state => this.turnController.setVerificationState(state),
             ...(this.options.chatOptions ?? {}),
         };