@orion-agents/orion-code 0.1.0 → 0.1.2

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRuntimeController = void 0;
+exports.goalProviderError = goalProviderError;
+exports.goalTurnMadeProgress = goalTurnMadeProgress;
 const parser_1 = require("../commands/parser");
 const target_command_1 = require("../commands/target-command");
 const agent_runtime_protocol_1 = require("./agent-runtime-protocol");
@@ -8,10 +10,46 @@ const agent_status_1 = require("./agent-status");
 const chat_controller_1 = require("./chat-controller");
 const ui_events_1 = require("./ui-events");
 const turn_controller_1 = require("./turn-controller");
+const tools_1 = require("./goals/tools");
+const accounting_1 = require("./goals/accounting");
+const crypto_1 = require("crypto");
+const workspace_state_1 = require("../services/workspace-state");
+const redaction_1 = require("../services/redaction");
+const evidence_1 = require("./goals/evidence");
+const session_storage_1 = require("../services/session-storage");
+const external_assertion_1 = require("../framework/external-assertion");
 function isExitInput(input) {
     const parsed = (0, parser_1.parseInput)(input.trim());
     return parsed.isCommand && ['exit', 'quit', 'q'].includes(parsed.name);
 }
+function goalProviderError(finishReason, errorType) {
+    if (finishReason !== 'failed' || !errorType)
+        return undefined;
+    switch (errorType) {
+        case 'quota_or_credit_exhausted':
+            return { kind: 'usage_limit', retryable: false };
+        case 'rate_limit':
+            return { kind: 'rate_limit', retryable: true };
+        case 'provider_busy':
+            return { kind: 'provider_busy', retryable: true };
+        case 'auth_failed':
+            return { kind: 'auth', retryable: false };
+        case 'connect_timeout':
+        case 'read_timeout':
+        case 'connection_reset':
+        case 'network_error':
+            return { kind: 'network', retryable: true };
+        default:
+            return { kind: 'unknown', retryable: false };
+    }
+}
+function goalTurnMadeProgress(input) {
+    const passedEvidence = input.evidenceRecords?.some(record => record.result === 'passed') ?? false;
+    const workspaceChanged = Boolean(input.workspaceFingerprintBefore &&
+        input.workspaceFingerprintAfter &&
+        input.workspaceFingerprintBefore !== input.workspaceFingerprintAfter);
+    return passedEvidence || workspaceChanged;
+}
 function submittedEntry(input) {
     const parsed = (0, parser_1.parseInput)(input.trim());
     return {
@@ -41,9 +79,7 @@ class AgentRuntimeController {
     /** v0.2.24: set the goal coordinator for /target mode. */
     setGoalCoordinator(coord) {
         this.goalCoordinator = coord;
-        // Wire goal tools to the coordinator so model can call get_goal/create_goal/update_goal.
-        const { setGoalToolCoordinator } = require('./goals/tools');
-        setGoalToolCoordinator(coord);
+        this.goalCoordinatorSessionId = coord.boundSessionId;
         // Wire goal prompt injection into the chat controller.
         if ('setGoalCoordinator' in this.runner) {
             this.runner.setGoalCoordinator(coord);
@@ -54,20 +90,228 @@ class AgentRuntimeController {
         this.pendingPermissions = new Map();
         this.activeRun = null;
         this.stopping = false;
+        this.continuationScheduleEpoch = 0;
+        /** Conservative reservations for every provider attempt in the current root turn. */
+        this.goalProviderReservedTokens = 0;
         this.nextPermissionRequestId = 1;
         /** v0.2.24: optional goal coordinator for /target mode. */
         this.goalCoordinator = null;
+        this.goalCoordinatorSessionId = null;
         if (!options.events && !options.eventSink) {
             throw new Error('AgentRuntimeController requires either events or eventSink');
         }
         this.turnController = new turn_controller_1.TurnController(options);
-        this.eventSink = options.eventSink ?? (0, agent_runtime_protocol_1.createAgentRuntimeEventSinkFromUiEvents)(options.events);
-        const events = options.events ?? (0, agent_runtime_protocol_1.createUiEventSinkFromAgentRuntimeEvents)(this.eventSink);
-        this.runner = options.runner ?? new chat_controller_1.AgentChatController(options.runtime, events, this.createChatOptions());
+        const downstream = options.eventSink ?? (0, agent_runtime_protocol_1.createAgentRuntimeEventSinkFromUiEvents)(options.events);
+        this.eventSink = {
+            emit: event => {
+                this.captureGoalEvidence(event);
+                const result = downstream.emit(event);
+                if (event.type === 'session_restored') {
+                    this.restoreGoalForSession(event.event.sessionId, event.event.projectPath);
+                }
+                return result;
+            },
+        };
+        const events = (0, agent_runtime_protocol_1.createUiEventSinkFromAgentRuntimeEvents)(this.eventSink);
+        this.runner =
+            options.runner ?? new chat_controller_1.AgentChatController(options.runtime, events, this.createChatOptions());
     }
     hasActiveTurn() {
         return this.turnController.hasActiveTurn();
     }
+    /** v0.1.1: shared /target command handling for all renderers. */
+    handleTargetInput(rawInput) {
+        const parsed = (0, target_command_1.parseTargetCommand)(rawInput);
+        if (!parsed.ok) {
+            this.emitAppend({
+                role: 'error',
+                title: 'target',
+                content: parsed.error,
+                errorLayer: 'runtime',
+            });
+            return {
+                handled: true,
+                statusText: parsed.error,
+                runtimeResult: { type: 'command_handled' },
+            };
+        }
+        const input = parsed.input;
+        const coord = this.ensureGoalCoordinator(input.action !== 'show');
+        if (!coord) {
+            const statusText = 'Target unavailable: no active session.';
+            this.emitAppend({
+                role: 'error',
+                title: 'target',
+                content: statusText,
+                errorLayer: 'session',
+            });
+            return { handled: true, statusText, runtimeResult: { type: 'command_handled' } };
+        }
+        if (this.turnController.hasActiveTurn() && !['pause', 'show', 'clear'].includes(input.action)) {
+            const statusText = 'Target command ignored while the agent is running. Use /target pause or interrupt first.';
+            this.emitStatus(statusText);
+            return { handled: true, statusText, runtimeResult: { type: 'command_ignored' } };
+        }
+        let success = true;
+        let error;
+        let executionRevoked = false;
+        const previousGoalId = coord.goal?.goalId;
+        try {
+            switch (input.action) {
+                case 'show':
+                    break;
+                case 'create': {
+                    const result = coord.create(input.payload?.objective ?? '');
+                    success = result.ok;
+                    if (!result.ok)
+                        error = result.error;
+                    break;
+                }
+                case 'pause':
+                    if (coord.isActive) {
+                        this.abortGoalOwnedExecution();
+                        executionRevoked = true;
+                    }
+                    success = coord.pause();
+                    if (!success)
+                        error = 'Target is not active.';
+                    break;
+                case 'resume':
+                    success = coord.resume({
+                        confirmBoundary: true,
+                        expectedGoalId: coord.goal?.goalId,
+                        expectedRevision: coord.goal?.revision,
+                    });
+                    if (!success)
+                        error = 'Target cannot be resumed from its current state.';
+                    break;
+                case 'confirm':
+                    success = coord.confirmCriterion(input.payload?.criterionId ?? '');
+                    if (!success) {
+                        error = 'Criterion cannot be confirmed. It must exist and require user evidence.';
+                    }
+                    break;
+                case 'edit':
+                    success = coord.edit(input.payload?.objective ?? '');
+                    if (!success)
+                        error = 'Target objective could not be updated.';
+                    break;
+                case 'replace':
+                    success = coord.replace(input.payload?.objective ?? '');
+                    if (!success) {
+                        error = 'Target could not be replaced.';
+                        if (input.payload?.objective?.trim()) {
+                            error = this.failClosedGoalMutation(coord, input.action, new Error(error), executionRevoked, previousGoalId);
+                            executionRevoked = true;
+                        }
+                    }
+                    break;
+                case 'set_budget':
+                    success = coord.setBudget(input.payload?.tokenBudget ?? null);
+                    if (!success)
+                        error = 'Create or resume a target before setting a budget.';
+                    break;
+                case 'clear':
+                    if (!input.payload?.confirmed) {
+                        success = false;
+                        error = 'Clearing a target requires confirmation: /target clear --yes';
+                    }
+                    else {
+                        const hadGoal = coord.goal !== null;
+                        if (hadGoal) {
+                            this.abortGoalOwnedExecution();
+                            executionRevoked = true;
+                        }
+                        success = coord.clear();
+                        if (hadGoal && !success) {
+                            error = this.failClosedGoalMutation(coord, input.action, new Error('Target clear did not remove the active Goal.'), executionRevoked, previousGoalId);
+                        }
+                        if (!success && !hadGoal)
+                            error = 'No target exists to clear.';
+                    }
+                    break;
+            }
+        }
+        catch (cause) {
+            success = false;
+            error =
+                input.action === 'show'
+                    ? cause instanceof Error
+                        ? cause.message
+                        : String(cause)
+                    : this.failClosedGoalMutation(coord, input.action, cause, executionRevoked, previousGoalId);
+        }
+        if (!success && error) {
+            this.emitAppend({ role: 'error', title: 'target', content: error, errorLayer: 'runtime' });
+        }
+        if (success &&
+            input.action === 'resume' &&
+            coord.goal?.status === 'active' &&
+            coord.goal.tokenBudget !== undefined) {
+            const resumedBudget = (0, accounting_1.budgetPreflight)(coord.goal.tokensUsed, coord.goal.tokenBudget, 0);
+            if (!resumedBudget.available) {
+                try {
+                    coord.limitBudget(resumedBudget.reason ?? 'Token budget unavailable after resuming the target.');
+                }
+                catch (cause) {
+                    success = false;
+                    error = this.failClosedGoalMutation(coord, 'resume_budget_stop', cause, executionRevoked, previousGoalId);
+                    this.emitGoalMutationError(error);
+                }
+            }
+        }
+        if (success) {
+            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 statusText = this.formatTargetStatus(coord);
+        this.emitAppend({ role: 'system', title: 'target', content: statusText });
+        if (success &&
+            (input.action === 'create' || input.action === 'resume' || input.action === 'replace') &&
+            coord.isActive) {
+            const req = coord.buildContinuationRequest();
+            if (req) {
+                const runtimeResult = this.submitGoalContinuation(req, `target_${input.action}`, true);
+                return { handled: true, statusText, runtimeResult };
+            }
+        }
+        return { handled: true, statusText, runtimeResult: { type: 'command_handled' } };
+    }
+    /** v0.1.1: shared /target intercept check for all renderers. */
+    canInterceptTargetCommand(input, duringActiveTurn) {
+        if (!(0, target_command_1.isTargetCommand)(input))
+            return false;
+        const parsed = (0, target_command_1.parseTargetCommand)(input);
+        if (!parsed.ok)
+            return true; // intercept to show error
+        // During active turn, only allow non-mutating actions.
+        if (duringActiveTurn) {
+            return ['pause', 'show', 'clear'].includes(parsed.input.action);
+        }
+        return true;
+    }
+    /** v0.1.1: emit clear_view event through the renderer protocol. */
+    emitClearView() {
+        this.eventSink.emit({ type: 'clear_view' });
+    }
+    /** v0.1.1: emit shutdown_requested event through the renderer protocol. */
+    emitShutdownRequested(reason) {
+        this.deferGoalContinuation(reason ?? 'shutdown requested', true);
+        this.eventSink.emit({ type: 'shutdown_requested', reason });
+    }
     setVerificationState(state) {
         this.turnController.setVerificationState(state);
     }
@@ -99,27 +343,76 @@ class AgentRuntimeController {
         if (!submitted)
             return { type: 'empty' };
         if (isExitInput(submitted)) {
+            this.emitShutdownRequested('user request');
             return { type: 'exit_requested' };
         }
+        if ((0, target_command_1.isTargetCommand)(submitted)) {
+            return this.handleTargetInput(submitted).runtimeResult;
+        }
+        const parsedInput = (0, parser_1.parseInput)(submitted);
+        if (parsedInput.isCommand && parsedInput.name === 'clear') {
+            this.emitClearView();
+            this.emitStatus('View cleared. Conversation context is preserved.');
+            return { type: 'command_handled' };
+        }
         if (this.turnController.hasActiveTurn()) {
             const parsed = (0, parser_1.parseInput)(submitted);
             if (parsed.isCommand) {
-                this.emitStatus(this.options.commandWhileRunningStatus ?? 'Command ignored while agent is running. Press Ctrl+C to interrupt first.');
+                this.emitStatus(this.options.commandWhileRunningStatus ??
+                    'Command ignored while agent is running. Press Ctrl+C to interrupt first.');
                 return { type: 'command_ignored' };
             }
             // v0.2.26: user steering input during active goal — update constraints
             // without replacing the root objective.
             const gc = this.goalCoordinator;
             if (gc?.goal && !(0, target_command_1.isTargetCommand)(submitted)) {
-                // Record the steering as a constraint update without changing objective.
-                gc.edit(gc.goal.objective); // no-op edit to bump revision, steering is via prompt
+                const steeringGoalId = gc.goal.goalId;
+                try {
+                    gc.addConstraint(submitted);
+                }
+                catch (cause) {
+                    const message = this.failClosedGoalMutation(gc, 'steering', cause, false, steeringGoalId);
+                    this.emitAppend({
+                        role: 'error',
+                        title: 'target steering',
+                        content: message,
+                        errorLayer: 'runtime',
+                    });
+                    this.emitStatus(message);
+                    return { type: 'command_ignored' };
+                }
             }
             this.turnController.clearExitIntent();
             this.turnController.requestRevision(submitted);
             this.emitStatus(this.options.revisionStatus ?? 'Revision received. Interrupting current response...');
             return { type: 'revision_requested' };
         }
-        this.activeRun = this.runTurn(submitted)
+        const session = this.options.runtime.getSession() ?? this.options.runtime.ensureSession();
+        const coord = this.ensureGoalCoordinator(false);
+        const goal = coord?.goal?.status === 'active' ? coord.goal : undefined;
+        const request = {
+            inputKind: 'user',
+            text: submitted,
+            sessionId: session?.id ?? 'pending-session',
+            goal: goal
+                ? {
+                    goalId: goal.goalId,
+                    revision: goal.revision,
+                    continuationIndex: goal.continuationCount,
+                }
+                : undefined,
+            persistAsUserMessage: true,
+            echoToTranscript: true,
+            generation: coord?.generation ?? 0,
+        };
+        return this.submitTurnRequest(request);
+    }
+    submitTurnRequest(request) {
+        if (this.turnController.hasActiveTurn())
+            return { type: 'command_ignored' };
+        if (!this.requestIsCurrent(request))
+            return { type: 'command_ignored' };
+        this.activeRun = this.runTurn(request)
             .catch(error => {
             this.handleRunLoopError(error);
         })
@@ -130,58 +423,326 @@ class AgentRuntimeController {
         });
         return { type: 'started' };
     }
+    submitGoalContinuation(request, reason, emitScheduled) {
+        const goalId = request.goal?.goalId;
+        if (emitScheduled && goalId) {
+            this.emitGoalEvent({ type: 'goal_continuation', goalId, phase: 'scheduled', reason });
+        }
+        const result = this.submitTurnRequest(request);
+        if (goalId) {
+            this.emitGoalEvent({
+                type: 'goal_continuation',
+                goalId,
+                phase: result.type === 'started' ? 'started' : 'deferred',
+                reason: result.type === 'started' ? reason : `request rejected: ${reason}`,
+            });
+        }
+        return result;
+    }
     // --- v0.2.26: goal continuation scheduling ---
     scheduleGoalContinuation() {
         const coord = this.goalCoordinator;
         if (!coord || !coord.isActive || coord.goal?.status !== 'active')
             return;
-        if (!coord.canContinue)
-            return; // don't continue if deferred, budget exceeded, etc.
+        if (!coord.canContinue) {
+            this.emitGoalEvent({
+                type: 'goal_continuation',
+                goalId: coord.goal.goalId,
+                phase: 'deferred',
+                reason: 'coordinator is not eligible to continue',
+            });
+            return;
+        }
+        const scheduleEpoch = ++this.continuationScheduleEpoch;
+        const scheduledGoalId = coord.goal.goalId;
         // Defer to next tick to let the current turn's events settle.
         setImmediate(() => {
-            if (this.stopping || this.turnController.hasActiveTurn())
+            if (scheduleEpoch !== this.continuationScheduleEpoch) {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: scheduledGoalId,
+                    phase: 'deferred',
+                    reason: 'scheduled continuation was invalidated',
+                });
+                return;
+            }
+            if (this.stopping ||
+                this.turnController.hasActiveTurn() ||
+                this.pendingPermissions.size > 0) {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: scheduledGoalId,
+                    phase: 'deferred',
+                    reason: this.stopping
+                        ? 'runtime is stopping'
+                        : this.pendingPermissions.size > 0
+                            ? 'tool permission is pending'
+                            : 'another turn is active',
+                });
                 return;
-            if (!coord.isActive || coord.goal?.status !== 'active')
-                return; // re-check after tick
+            }
+            if (!coord.isActive || coord.goal?.status !== 'active') {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: scheduledGoalId,
+                    phase: 'deferred',
+                    reason: 'goal is no longer active',
+                });
+                return;
+            }
             const req = coord.buildContinuationRequest();
             if (req) {
-                this.handle({
-                    type: 'submit',
-                    text: `[goal continuation #${coord.goal.continuationCount + 1}]`,
-                    source: 'programmatic',
+                const projected = coord.goal?.lastTurn?.totalTokens ?? 0;
+                const preflight = (0, accounting_1.budgetPreflight)(coord.goal?.tokensUsed ?? 0, coord.goal?.tokenBudget, projected);
+                if (!preflight.available) {
+                    try {
+                        coord.limitBudget(preflight.reason ?? 'Token budget unavailable for another turn.');
+                    }
+                    catch (cause) {
+                        const message = this.failClosedGoalMutation(coord, 'budget_stop', cause, false, scheduledGoalId);
+                        this.emitGoalMutationError(message);
+                        return;
+                    }
+                    this.emitGoalEvent({
+                        type: 'goal_continuation',
+                        goalId: coord.goal.goalId,
+                        phase: 'stopped',
+                        reason: preflight.reason ?? 'budget preflight failed',
+                    });
+                    return;
+                }
+                this.submitGoalContinuation(req, `continuation ${req.goal.continuationIndex}`, true);
+            }
+            else {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: scheduledGoalId,
+                    phase: 'deferred',
+                    reason: 'coordinator did not produce a continuation request',
                 });
             }
         });
     }
     /** v0.2.26: finalize goal turn with usage data from the last loop. */
-    finalizeGoalTurn(turnId) {
+    finalizeGoalTurn(turnId, request, toolContext, startedAt, workspaceFingerprintBefore, turnAborted) {
         const coord = this.goalCoordinator;
-        if (!coord?.goal || coord.goal.status !== 'active')
+        const requestGoal = request.goal;
+        const currentSessionId = this.options.runtime.getSession()?.id;
+        if (!coord?.goal ||
+            !requestGoal ||
+            currentSessionId !== request.sessionId ||
+            coord.boundSessionId !== request.sessionId ||
+            coord.generation !== request.generation ||
+            coord.goal.goalId !== requestGoal.goalId) {
+            if (request.inputKind === 'goal_continuation' && requestGoal) {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: requestGoal.goalId,
+                    phase: 'deferred',
+                    reason: 'turn outcome rejected because its session, goal, revision, or generation is stale',
+                });
+            }
             return;
+        }
         const usage = this.options.runtime.store.getSnapshot().tokenUsage;
         const loopStats = this.options.runtime.store.getSnapshot().lastLoopStats;
+        const subagentPromptTokens = loopStats?.subagentPromptTokens ?? 0;
+        const subagentCompletionTokens = loopStats?.subagentCompletionTokens ?? 0;
+        const subagentTokens = loopStats?.subagentTotalTokens ?? 0;
+        const workspaceFingerprintAfter = (0, workspace_state_1.captureWorkspaceFingerprint)(this.activeProjectPath());
+        const workspaceChanged = Boolean(workspaceFingerprintBefore &&
+            workspaceFingerprintAfter &&
+            workspaceFingerprintBefore !== workspaceFingerprintAfter);
+        const usageAccountingComplete = loopStats
+            ?.usageAccountingComplete !== false;
         const outcome = {
             turnId: String(turnId),
-            sessionId: this.options.runtime.getSession()?.id ?? '',
-            goalId: coord.goal.goalId,
-            goalRevision: coord.goal.revision,
-            startedAt: coord.goal.updatedAt,
+            sessionId: request.sessionId,
+            goalId: requestGoal.goalId,
+            goalRevision: requestGoal.revision,
+            goalGeneration: request.generation,
+            startedAt,
             endedAt: Date.now(),
             finishReason: loopStats?.finishReason ?? 'unknown',
             usage: {
-                promptTokens: usage?.promptTokens ?? 0,
-                completionTokens: usage?.completionTokens ?? 0,
-                subagentTokens: 0,
-                totalTokens: (usage?.promptTokens ?? 0) + (usage?.completionTokens ?? 0),
+                promptTokens: Math.max(0, (usage?.promptTokens ?? 0) - subagentPromptTokens),
+                completionTokens: Math.max(0, (usage?.completionTokens ?? 0) - subagentCompletionTokens),
+                subagentTokens,
+                totalTokens: usage !== null
+                    ? (usage?.promptTokens ?? 0) + (usage?.completionTokens ?? 0)
+                    : subagentTokens,
             },
-            madeProgress: loopStats ? loopStats.toolCalls > 0 : true,
+            madeProgress: goalTurnMadeProgress({
+                evidenceRecords: toolContext?.evidenceRecords,
+                pendingPlanUpdate: toolContext?.pendingPlanUpdate,
+                workspaceFingerprintBefore,
+                workspaceFingerprintAfter,
+            }),
+            workspaceChanged,
+            providerError: goalProviderError(loopStats?.finishReason, loopStats?.providerLastRetryErrorType),
+            blocker: toolContext?.pendingBlocker,
+            pendingTerminalRequest: toolContext?.pendingTerminalRequest,
+            pendingPlanUpdate: toolContext?.pendingPlanUpdate,
+            evidenceRecords: toolContext?.evidenceRecords,
+            workspaceFingerprint: workspaceFingerprintAfter,
+            evidenceRefs: toolContext?.evidenceRecords.map(record => record.id),
+            verificationSummary: this.verificationSummary(loopStats),
+            usageComplete: usageAccountingComplete &&
+                usage !== null &&
+                loopStats?.finishReason !== 'failed' &&
+                (loopStats?.providerRetryCount ?? 0) === 0 &&
+                (loopStats?.providerFallbackCount ?? 0) === 0,
         };
-        coord.finalizeTurn(outcome);
+        const semanticOutcomeIsCurrent = coord.goal.status === 'active' &&
+            !turnAborted &&
+            coord.goal.revision === requestGoal.revision;
+        if (!semanticOutcomeIsCurrent) {
+            const accountingOnlyEligible = turnAborted || coord.goal.status === 'paused' || coord.goal.revision > requestGoal.revision;
+            if (!accountingOnlyEligible) {
+                if (request.inputKind === 'goal_continuation') {
+                    this.emitGoalEvent({
+                        type: 'goal_continuation',
+                        goalId: requestGoal.goalId,
+                        phase: 'deferred',
+                        reason: 'turn outcome rejected because the Goal lifecycle no longer accepts this turn',
+                    });
+                }
+                return;
+            }
+            // accountStaleTurn is the coordinator's accounting-only, idempotent
+            // entry point. An interrupt can leave the Goal revision unchanged, so
+            // freeze this outcome immediately before the current revision without
+            // admitting any semantic payload from the cancelled turn.
+            const accountingOutcome = {
+                ...outcome,
+                goalRevision: Math.min(outcome.goalRevision ?? requestGoal.revision, coord.goal.revision - 1),
+            };
+            let accounted = false;
+            try {
+                const alreadyAccounted = coord.goal.lastTurn?.turnId === String(turnId);
+                accounted = alreadyAccounted ? false : coord.accountStaleTurn(accountingOutcome);
+                // Missing/partial provider usage is fail-closed. Known lower-bound
+                // tokens have already been retained by accountStaleTurn.
+                if (outcome.usageComplete === false && coord.goal?.status === 'active') {
+                    coord.pause();
+                }
+            }
+            catch (error) {
+                this.failClosedGoalPersistence(coord, requestGoal.goalId, error, 'stale_accounting');
+                return;
+            }
+            const snapshot = coord.snapshot();
+            if (accounted && snapshot) {
+                this.emitGoalEvent({
+                    type: 'goal_updated',
+                    goal: snapshot,
+                    reason: 'interrupted or stale turn usage accounted without semantic finalization',
+                });
+                this.recordGoalTraceState(turnId, request, snapshot);
+            }
+            if (request.inputKind === 'goal_continuation') {
+                this.emitGoalEvent({
+                    type: 'goal_continuation',
+                    goalId: requestGoal.goalId,
+                    phase: 'deferred',
+                    reason: 'turn semantic outcome rejected; incurred usage was accounted without continuation',
+                });
+            }
+            return;
+        }
+        // Live steering intentionally bumps the Goal revision before the aborted
+        // provider turn settles. The semantic payload is stale, but the provider
+        // usage and elapsed time were still incurred and must be counted once.
+        const planRevisionBefore = coord.goal.contract?.planSnapshot?.revision;
+        try {
+            coord.finalizeTurn(outcome);
+        }
+        catch (error) {
+            this.failClosedGoalPersistence(coord, requestGoal.goalId, error, 'turn_finalize');
+            return;
+        }
+        const snapshot = coord.snapshot();
+        if (snapshot) {
+            this.recordGoalTraceState(turnId, request, snapshot);
+            if (coord.goal?.contract?.planSnapshot &&
+                coord.goal.contract.planSnapshot.revision !== planRevisionBefore) {
+                const plan = coord.goal.contract.planSnapshot;
+                this.emitGoalEvent({
+                    type: 'goal_plan_updated',
+                    goalId: snapshot.goalId,
+                    planRevision: plan.revision,
+                    phase: plan.phase,
+                    nextAction: plan.nextAction,
+                });
+            }
+            let terminalEvent;
+            if (snapshot.status === 'complete' && coord.goal?.completionAudit) {
+                terminalEvent = {
+                    type: 'goal_completed',
+                    goal: snapshot,
+                    audit: coord.goal.completionAudit,
+                };
+            }
+            else if (coord.goal?.completionAudit && !coord.goal.completionAudit.passed) {
+                terminalEvent = {
+                    type: 'goal_audit_failed',
+                    goalId: snapshot.goalId,
+                    audit: 'completion',
+                    summary: coord.goal.completionAudit.remainingRequirements.join(' '),
+                };
+            }
+            else if (toolContext?.pendingTerminalRequest?.requestedStatus === 'blocked' &&
+                snapshot.status !== 'blocked') {
+                const blocker = coord.goal?.blocker;
+                terminalEvent = {
+                    type: 'goal_audit_failed',
+                    goalId: snapshot.goalId,
+                    audit: 'blocked',
+                    summary: blocker
+                        ? `Blocker is not terminal: ${blocker.consecutiveTurns}/3 consecutive turns; no-progress ${coord.goal?.noProgressCount ?? 0}/3.`
+                        : 'Blocked request did not include a valid non-retryable user, permission, or external-state blocker.',
+                };
+            }
+            // Project the fresh snapshot first, then the specific audit/completion
+            // event. This keeps renderer state current without a generic update
+            // overwriting the user-facing terminal result.
+            this.emitGoalEvent({ type: 'goal_updated', goal: snapshot, reason: 'turn_finalized' });
+            if (terminalEvent)
+                this.emitGoalEvent(terminalEvent);
+        }
+    }
+    failClosedGoalPersistence(coord, goalId, error, operation) {
+        const message = this.failClosedGoalMutation(coord, operation, error, false, goalId);
+        this.emitAppend({
+            role: 'error',
+            title: 'goal persistence',
+            content: message,
+            errorLayer: 'session',
+        });
+        this.emitStatus(message);
+    }
+    recordGoalTraceState(turnId, request, snapshot) {
+        if (!request.goal)
+            return;
+        const trace = (0, session_storage_1.appendSessionTraceEvent)(request.sessionId, {
+            turnId: String(turnId),
+            type: 'goal_state',
+            goalId: request.goal.goalId,
+            goalRevision: request.goal.revision,
+            goalInputKind: request.inputKind,
+            goalStopReason: snapshot.stopReason ?? (snapshot.status === 'complete' ? 'completed' : 'continue'),
+            note: `status=${snapshot.status}; snapshotRevision=${snapshot.revision}`,
+        });
+        if (trace)
+            this.eventSink.emit({ type: 'trace_event_recorded', event: trace });
     }
     interrupt() {
-        const shouldExit = this.turnController.registerExitIntent();
         // v0.2.26: pause active goal on interrupt to prevent immediate restart.
-        this.goalCoordinator?.deferContinuation();
+        this.deferGoalContinuation('user interrupt', true);
+        // Register after any synchronous persistence recovery. A lock wait can be
+        // longer than the confirmation window, but must not consume the user's
+        // first Ctrl+C before this call even returns.
+        const shouldExit = this.turnController.registerExitIntent();
         if (this.turnController.hasActiveTurn()) {
             this.turnController.interruptActiveTurn();
             if (shouldExit)
@@ -196,6 +757,7 @@ class AgentRuntimeController {
     }
     async stopActiveTurn() {
         this.stopping = true;
+        this.deferGoalContinuation('runtime stopping');
         this.turnController.interruptActiveTurn();
         this.rejectPendingPermissions();
         if (this.activeRun) {
@@ -204,24 +766,136 @@ class AgentRuntimeController {
         // Reset stopping flag so subsequent turns can execute.
         this.stopping = false;
     }
+    deferGoalContinuation(reason, preserveExitIntent = false) {
+        this.continuationScheduleEpoch += 1;
+        const coord = this.goalCoordinator;
+        const goalId = coord?.goal?.status === 'active' ? coord.goal.goalId : undefined;
+        if (!coord || !goalId)
+            return;
+        try {
+            coord.deferContinuation();
+        }
+        catch (cause) {
+            const message = this.failClosedGoalMutation(coord, 'pause', cause, false, goalId, preserveExitIntent);
+            this.emitGoalMutationError(message);
+            return;
+        }
+        this.emitGoalEvent({
+            type: 'goal_continuation',
+            goalId,
+            phase: 'deferred',
+            reason,
+        });
+    }
+    /** Revoke all Goal-owned execution before mutating a lifecycle boundary. */
+    abortGoalOwnedExecution(preserveExitIntent = false) {
+        this.continuationScheduleEpoch += 1;
+        if (!preserveExitIntent)
+            this.turnController.clearExitIntent();
+        this.turnController.interruptActiveTurn();
+        this.rejectPendingPermissions();
+    }
+    /**
+     * Contain a failed Goal mutation without writing the restored disk state back.
+     * The coordinator advances its generation so every in-flight request becomes
+     * stale, then preserves complete or deleted disk authority as-is.
+     */
+    failClosedGoalMutation(coord, operation, cause, executionAlreadyRevoked = false, goalIdBeforeMutation, preserveExitIntent = false) {
+        if (!executionAlreadyRevoked)
+            this.abortGoalOwnedExecution(preserveExitIntent);
+        const detail = (0, redaction_1.redactTraceText)(cause instanceof Error ? cause.message : String(cause)).slice(0, 600);
+        const operationSubject = operation === 'steering'
+            ? 'Steering'
+            : operation === 'turn_finalize'
+                ? 'Goal turn finalization'
+                : operation === 'stale_accounting'
+                    ? 'Stale Goal accounting'
+                    : `Target ${operation}`;
+        const goalIdBeforeRecovery = coord.goal?.goalId ?? goalIdBeforeMutation;
+        const failureReason = `${operationSubject} was not saved; Goal-owned execution was revoked fail-closed. ${detail}`;
+        coord.failClosedAfterPersistenceError(failureReason);
+        const snapshot = coord.snapshot();
+        const message = !snapshot
+            ? `${operationSubject} was not saved; disk authority reports that the Goal was deleted. No continuation was started. ${detail}`
+            : coord.goal?.status === 'complete'
+                ? `${operationSubject} was not saved; the restored completed Goal remains terminal. No continuation was started. ${detail}`
+                : `${operationSubject} was not saved; execution was paused fail-closed. Resolve the storage error, then use /target resume. ${detail}`;
+        if (snapshot) {
+            this.emitGoalEvent({
+                type: 'goal_updated',
+                goal: snapshot,
+                reason: coord.goal?.status === 'complete'
+                    ? `target_${operation} persistence failed; completed disk authority preserved`
+                    : `target_${operation} persistence failed; continuation paused fail-closed`,
+            });
+        }
+        else if (goalIdBeforeRecovery) {
+            this.emitGoalEvent({
+                type: 'goal_cleared',
+                goalId: goalIdBeforeRecovery,
+                reason: `target_${operation} failed after the Goal was deleted`,
+            });
+        }
+        const deferredGoalId = snapshot?.goalId ?? goalIdBeforeRecovery;
+        if (deferredGoalId) {
+            this.emitGoalEvent({
+                type: 'goal_continuation',
+                goalId: deferredGoalId,
+                phase: 'deferred',
+                reason: `target_${operation} persistence failed`,
+            });
+        }
+        return message;
+    }
     waitForIdle() {
         return this.activeRun ?? Promise.resolve();
     }
-    async runTurn(firstInput) {
-        let nextInput = firstInput;
-        while (nextInput?.trim() && !this.stopping) {
-            if (this.options.echoSubmittedInput ?? true) {
+    async runTurn(firstRequest) {
+        let nextRequest = firstRequest;
+        while (nextRequest && !this.stopping) {
+            this.goalProviderReservedTokens = 0;
+            if (!this.requestIsCurrent(nextRequest))
+                break;
+            const request = nextRequest;
+            const nextInput = request.text?.trim() ||
+                'Continue pursuing the active goal from its persisted plan and evidence.';
+            if ((this.options.echoSubmittedInput ?? true) && request.echoToTranscript) {
                 this.emitAppend(submittedEntry(nextInput));
             }
             this.options.beforeTurn?.(nextInput);
             const turn = this.turnController.beginTurn(nextInput);
+            const startedAt = Date.now();
+            const workspaceFingerprintBefore = (0, workspace_state_1.captureWorkspaceFingerprint)(this.activeProjectPath());
+            const coord = this.ensureGoalCoordinator(false);
+            const toolContext = coord
+                ? { coordinator: coord, request, turnId: String(turn.id), evidenceRecords: [] }
+                : undefined;
             this.options.runtime.store.setProcessing(true);
             this.emitProcessing(true);
             const runningStatus = statusText(this.options.runningStatus, nextInput);
             if (runningStatus)
                 this.emitStatus(runningStatus);
             try {
-                await this.runner.runInput(nextInput, { abortSignal: turn.abortSignal, turnId: turn.id });
+                const execute = () => {
+                    if (this.runner.runRequest) {
+                        return this.runner.runRequest(request, {
+                            abortSignal: turn.abortSignal,
+                            turnId: turn.id,
+                        });
+                    }
+                    return this.runner.runInput(nextInput, {
+                        abortSignal: turn.abortSignal,
+                        turnId: turn.id,
+                        persistAsUserMessage: request.persistAsUserMessage,
+                        inputKind: request.inputKind,
+                    });
+                };
+                if (toolContext) {
+                    await (0, tools_1.runWithGoalToolContext)(toolContext, execute);
+                }
+                else {
+                    await execute();
+                }
             }
             catch (error) {
                 if (!turn.abortSignal.aborted) {
@@ -237,13 +911,35 @@ class AgentRuntimeController {
             finally {
                 const revision = this.turnController.finishTurn(turn.id);
                 // v0.2.26: finalize goal turn with usage data.
-                this.finalizeGoalTurn(turn.id);
+                this.finalizeGoalTurn(turn.id, request, toolContext, startedAt, workspaceFingerprintBefore, turn.abortSignal.aborted);
                 if (revision?.trim()) {
-                    this.emitStatus(this.options.restartingStatus ?? 'Restarting with latest instruction...');
-                    nextInput = revision;
+                    const currentCoord = this.ensureGoalCoordinator(false);
+                    const currentGoal = currentCoord?.goal?.status === 'active' ? currentCoord.goal : undefined;
+                    if (request.goal && currentCoord?.goal && !currentGoal) {
+                        this.emitStatus('Latest instruction was saved, but the Goal is paused because usage accounting is incomplete. Use /target resume after reviewing the budget.');
+                        nextRequest = undefined;
+                    }
+                    else {
+                        this.emitStatus(this.options.restartingStatus ?? 'Restarting with latest instruction...');
+                        nextRequest = {
+                            inputKind: 'revision',
+                            text: revision,
+                            sessionId: this.options.runtime.getSession()?.id ?? request.sessionId,
+                            goal: currentGoal
+                                ? {
+                                    goalId: currentGoal.goalId,
+                                    revision: currentGoal.revision,
+                                    continuationIndex: currentGoal.continuationCount,
+                                }
+                                : undefined,
+                            persistAsUserMessage: true,
+                            echoToTranscript: true,
+                            generation: currentCoord?.generation ?? 0,
+                        };
+                    }
                 }
                 else {
-                    nextInput = undefined;
+                    nextRequest = undefined;
                 }
             }
         }
@@ -264,7 +960,11 @@ class AgentRuntimeController {
         }
         else {
             const message = error instanceof Error ? error.message : String(error);
-            this.emitAppend({ role: 'error', content: `[RUNTIME] Error: ${message}`, errorLayer: 'runtime' });
+            this.emitAppend({
+                role: 'error',
+                content: `[RUNTIME] Error: ${message}`,
+                errorLayer: 'runtime',
+            });
         }
         this.options.runtime.store.setProcessing(false);
         this.emitProcessing(false);
@@ -284,6 +984,131 @@ class AgentRuntimeController {
     emitProcessing(processing) {
         this.eventSink.emit({ type: 'processing_changed', processing });
     }
+    emitGoalEvent(event) {
+        this.eventSink.emit({ type: 'goal_event', event });
+    }
+    requestIsCurrent(request) {
+        const activeSessionId = this.options.runtime.getSession()?.id;
+        if (activeSessionId && request.sessionId !== activeSessionId)
+            return false;
+        if (!request.goal)
+            return true;
+        const coord = this.goalCoordinator;
+        const goal = coord?.goal;
+        return Boolean(coord &&
+            goal &&
+            coord.boundSessionId === request.sessionId &&
+            coord.generation === request.generation &&
+            goal.goalId === request.goal.goalId &&
+            goal.revision === request.goal.revision &&
+            goal.status === 'active');
+    }
+    verificationSummary(loopStats) {
+        if (!loopStats)
+            return 'No loop statistics were recorded.';
+        const passed = loopStats.verificationPassedCommands ?? [];
+        const failed = loopStats.verificationFailedCommands ?? [];
+        const missing = loopStats.verificationMissingCommands ?? [];
+        return [
+            `finish=${loopStats.finishReason}`,
+            passed.length ? `passed=${passed.join(', ')}` : '',
+            failed.length ? `failed=${failed.join(', ')}` : '',
+            missing.length ? `missing=${missing.join(', ')}` : '',
+        ]
+            .filter(Boolean)
+            .join('; ');
+    }
+    captureGoalEvidence(event) {
+        if (event.type !== 'tool_finished')
+            return;
+        const context = (0, tools_1.currentGoalToolContext)();
+        const goal = context?.coordinator.goal;
+        if (!context || !goal || goal.status !== 'active')
+            return;
+        const capturedAt = Date.now();
+        const claimedAssertion = event.event.externalAssertion;
+        const assertion = claimedAssertion &&
+            (0, external_assertion_1.externalAssertionMatchesInvocation)({
+                assertion: claimedAssertion,
+                name: event.event.name,
+                args: event.event.args,
+                success: event.event.success,
+                skipped: event.event.skipped,
+                now: capturedAt,
+            })
+            ? claimedAssertion
+            : undefined;
+        const kind = claimedAssertion
+            ? 'external'
+            : (0, evidence_1.classifyGoalEvidenceKind)(event.event.name, event.event.args);
+        if (!kind)
+            return;
+        const classifiedResult = (0, evidence_1.classifyGoalEvidenceResult)({
+            kind,
+            success: event.event.success,
+            skipped: event.event.skipped,
+            summary: event.event.summary,
+            error: event.event.error,
+        });
+        // A successful transport plus display text is never sufficient proof of
+        // an external mutation/state. Only runtime-derived typed assertions may
+        // promote successful external tool output to passed evidence. Explicit
+        // tool failures remain failed so the ledger still records negative proof.
+        const result = assertion
+            ? assertion.status
+            : kind === 'external' && classifiedResult === 'passed'
+                ? 'inconclusive'
+                : classifiedResult;
+        const assertionSubject = assertion
+            ? [
+                `external ${assertion.action} ${assertion.status}`,
+                `provider=${assertion.provider}`,
+                `target=${assertion.target}`,
+                assertion.observedValue ? `observed=${assertion.observedValue}` : '',
+            ]
+                .filter(Boolean)
+                .join(' ')
+            : undefined;
+        const record = {
+            id: `evidence:${(0, crypto_1.randomUUID)()}`,
+            goalId: goal.goalId,
+            goalRevision: goal.revision,
+            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),
+            result,
+            sourceRef: `tool:${event.event.callId}:${event.event.name}`,
+            capturedAt,
+            workspaceFingerprint: (0, workspace_state_1.captureWorkspaceFingerprint)(this.activeProjectPath()),
+            expiresAt: kind === 'external' ? capturedAt + 5 * 60000 : undefined,
+            ...(assertion ? { externalAssertion: assertion } : {}),
+            redacted: true,
+        };
+        context.evidenceRecords.push(record);
+        this.emitGoalEvent({
+            type: 'goal_evidence_recorded',
+            goalId: goal.goalId,
+            evidence: {
+                id: record.id,
+                kind: record.kind,
+                result: record.result,
+                subject: record.subject,
+            },
+        });
+    }
+    restoreGoalForSession(sessionId, projectPath) {
+        // A continuation queued by the previously active session must not survive a
+        // session switch. It captured the old coordinator and would otherwise be
+        // able to start after /resume has rebound the runtime.
+        this.continuationScheduleEpoch += 1;
+        this.goalCoordinator = null;
+        this.goalCoordinatorSessionId = null;
+        const coord = this.bindGoalCoordinator(sessionId, true, projectPath);
+        const snapshot = coord?.snapshot();
+        if (snapshot)
+            this.emitGoalEvent({ type: 'goal_restored', goal: snapshot });
+    }
     async requestToolPermission(request) {
         if (request.abortSignal?.aborted || this.stopping)
             return false;
@@ -313,46 +1138,146 @@ class AgentRuntimeController {
         const coord = this.goalCoordinator;
         if (!coord)
             return { type: 'empty' };
-        switch (input.action) {
-            case 'show':
-                // Just shows status — already handled by the renderer format function.
-                return { type: 'empty' };
-            case 'create': {
-                const obj = input.payload?.objective;
-                if (!obj)
+        let executionRevoked = false;
+        const goalIdBeforeMutation = coord.goal?.goalId;
+        try {
+            switch (input.action) {
+                case 'show':
+                    // Just shows status — already handled by the renderer format function.
                     return { type: 'empty' };
-                const result = coord.create(obj);
-                return { type: result.ok ? 'interrupted' : 'empty' };
-            }
-            case 'pause':
-                coord.pause();
-                return { type: 'interrupted' };
-            case 'resume':
-                coord.resume();
-                return { type: 'interrupted' };
-            case 'edit': {
-                const obj = input.payload?.objective;
-                if (obj)
-                    coord.edit(obj);
-                return { type: 'interrupted' };
-            }
-            case 'replace': {
-                const obj = input.payload?.objective;
-                if (obj)
-                    coord.replace(obj);
-                return { type: 'interrupted' };
-            }
-            case 'set_budget':
-                coord.setBudget(input.payload?.tokenBudget ?? null);
-                return { type: 'interrupted' };
-            case 'clear':
-                if (input.payload?.confirmed) {
-                    coord.clear();
+                case 'create': {
+                    const obj = input.payload?.objective;
+                    if (!obj)
+                        return { type: 'empty' };
+                    const result = coord.create(obj);
+                    return { type: result.ok ? 'interrupted' : 'empty' };
+                }
+                case 'pause':
+                    if (coord.isActive) {
+                        this.abortGoalOwnedExecution();
+                        executionRevoked = true;
+                    }
+                    return { type: coord.pause() ? 'interrupted' : 'empty' };
+                case 'resume':
+                    return { type: coord.resume() ? 'interrupted' : 'empty' };
+                case 'confirm':
+                    coord.confirmCriterion(input.payload?.criterionId ?? '');
+                    return { type: 'interrupted' };
+                case 'edit': {
+                    const obj = input.payload?.objective;
+                    if (obj)
+                        coord.edit(obj);
+                    return { type: 'interrupted' };
                 }
-                return { type: 'interrupted' };
-            default:
-                return { type: 'empty' };
+                case 'replace': {
+                    const obj = input.payload?.objective;
+                    if (obj && !coord.replace(obj)) {
+                        const message = this.failClosedGoalMutation(coord, input.action, new Error('Target could not be replaced.'), executionRevoked, goalIdBeforeMutation);
+                        this.emitGoalMutationError(message);
+                    }
+                    return { type: 'interrupted' };
+                }
+                case 'set_budget':
+                    coord.setBudget(input.payload?.tokenBudget ?? null);
+                    return { type: 'interrupted' };
+                case 'clear':
+                    if (input.payload?.confirmed && coord.goal !== null) {
+                        this.abortGoalOwnedExecution();
+                        executionRevoked = true;
+                        if (!coord.clear()) {
+                            const message = this.failClosedGoalMutation(coord, input.action, new Error('Target clear did not remove the active Goal.'), executionRevoked, goalIdBeforeMutation);
+                            this.emitGoalMutationError(message);
+                        }
+                    }
+                    return { type: 'interrupted' };
+                default:
+                    return { type: 'empty' };
+            }
         }
+        catch (cause) {
+            const message = this.failClosedGoalMutation(coord, input.action, cause, executionRevoked, goalIdBeforeMutation);
+            this.emitGoalMutationError(message);
+            return { type: 'interrupted' };
+        }
+    }
+    emitGoalMutationError(message) {
+        this.emitAppend({
+            role: 'error',
+            title: 'target',
+            content: message,
+            errorLayer: 'runtime',
+        });
+        this.emitStatus(message);
+    }
+    ensureGoalCoordinator(ensureSession) {
+        if (ensureSession) {
+            this.options.runtime.ensureSession();
+        }
+        const session = this.options.runtime.getSession();
+        const sessionId = session?.id;
+        if (!sessionId)
+            return this.goalCoordinator;
+        if (this.goalCoordinator && this.goalCoordinatorSessionId === sessionId) {
+            return this.goalCoordinator;
+        }
+        return this.bindGoalCoordinator(sessionId, true, session.projectPath || this.options.runtime.cwd);
+    }
+    bindGoalCoordinator(sessionId, recoverActive, projectPath) {
+        const { GoalCoordinator } = require('./goals/coordinator');
+        const coord = new GoalCoordinator(projectPath, sessionId);
+        coord.load(recoverActive);
+        if (coord.lastLoadIssue) {
+            this.emitAppend({
+                role: 'error',
+                title: 'target recovery',
+                content: `${coord.lastLoadIssue.code}: ${coord.lastLoadIssue.message}. Run orion doctor for recovery guidance.`,
+                errorLayer: 'runtime',
+            });
+        }
+        this.goalCoordinator = coord;
+        this.goalCoordinatorSessionId = sessionId;
+        if ('setGoalCoordinator' in this.runner) {
+            this.runner.setGoalCoordinator(coord);
+        }
+        return coord;
+    }
+    activeProjectPath() {
+        return this.options.runtime.getSession()?.projectPath || this.options.runtime.cwd;
+    }
+    formatTargetStatus(coord) {
+        const goal = coord.goal;
+        if (!goal) {
+            return 'Target: no active goal. Use /target <objective> to create one.';
+        }
+        const objective = goal.objective.length > 60 ? `${goal.objective.slice(0, 57)}...` : goal.objective;
+        const tokens = goal.tokensUsed >= 1000 ? `${(goal.tokensUsed / 1000).toFixed(1)}K` : String(goal.tokensUsed);
+        const lines = [
+            `Target: [${goal.status}] ${objective} | ${goal.continuationCount} turns | ${tokens} tokens${goal.tokenBudget ? ` | budget ${tokens}/${goal.tokenBudget}` : ''}`,
+        ];
+        const contract = goal.contract;
+        const plan = contract?.planSnapshot;
+        if (plan) {
+            lines.push(`Plan: r${plan.revision} ${plan.phase}${plan.nextAction ? ` | next: ${plan.nextAction}` : ''}`);
+        }
+        if (contract?.successCriteria.length) {
+            const passed = contract.successCriteria.filter(criterion => criterion.status === 'passed').length;
+            const failed = contract.successCriteria.filter(criterion => criterion.status === 'failed').length;
+            const stale = contract.successCriteria.filter(criterion => criterion.status === 'stale').length;
+            const pending = contract.successCriteria.length - passed - failed - stale;
+            lines.push(`Criteria: ${pending} pending | ${passed}/${contract.successCriteria.length} passed | ${failed} failed | ${stale} stale`);
+        }
+        if (goal.completionAudit?.remainingRequirements.length) {
+            lines.push(`Audit: ${goal.completionAudit.remainingRequirements.slice(0, 3).join(' | ')}`);
+        }
+        if (goal.stopReason)
+            lines.push(`Resume: ${goal.stopReason.message}`);
+        const recentEvidence = (goal.evidenceLedger ?? []).slice(-3);
+        if (recentEvidence.length > 0) {
+            lines.push(`Evidence: ${recentEvidence
+                .map(item => `${item.id} ${item.kind}/${item.result} ${item.subject}`)
+                .join(' | ')}`);
+        }
+        return lines.join('\n');
     }
     recordPermissionDecision(requestId, approved) {
         const resolve = this.pendingPermissions.get(requestId);
@@ -383,7 +1308,9 @@ class AgentRuntimeController {
         };
         chatOptions.uiCapabilities = uiCapabilities;
         chatOptions.uiRenderer = chatOptions.uiRenderer ?? resolvedRenderer;
-        chatOptions.onVerificationStateChange = chatOptions.onVerificationStateChange ?? (state => this.turnController.setVerificationState(state));
+        chatOptions.onVerificationStateChange =
+            chatOptions.onVerificationStateChange ??
+                (state => this.turnController.setVerificationState(state));
         if (this.options.useRuntimeToolPermissions && !chatOptions.confirmToolUse) {
             chatOptions.confirmToolUse = request => this.requestToolPermission(request);
         }
@@ -410,6 +1337,46 @@ class AgentRuntimeController {
                 });
             };
         }
+        const configuredPreflight = chatOptions.beforeProviderRequest;
+        chatOptions.beforeProviderRequest = async (context) => {
+            if (configuredPreflight) {
+                const configuredDecision = await configuredPreflight(context);
+                if (!configuredDecision.available)
+                    return configuredDecision;
+            }
+            const coord = this.goalCoordinator;
+            const goal = coord?.goal;
+            if (!coord || !goal || goal.status !== 'active' || !goal.tokenBudget) {
+                return { available: true };
+            }
+            const projectedTokens = Math.max(1, context.estimatedPromptTokens, goal.lastTurn?.totalTokens ?? 0);
+            const decision = (0, accounting_1.budgetPreflight)(goal.tokensUsed + this.goalProviderReservedTokens, goal.tokenBudget, projectedTokens);
+            if (!decision.available) {
+                try {
+                    coord.limitBudget(decision.reason ?? 'Token budget unavailable for provider request.');
+                }
+                catch (cause) {
+                    const message = this.failClosedGoalMutation(coord, 'provider_budget_stop', cause, false, goal.goalId);
+                    this.emitGoalMutationError(message);
+                    return { available: false, reason: message };
+                }
+                const snapshot = coord.snapshot();
+                if (snapshot) {
+                    this.emitGoalEvent({
+                        type: 'goal_updated',
+                        goal: snapshot,
+                        reason: `provider request ${context.operation} attempt ${context.attempt} rejected by token budget`,
+                    });
+                }
+                return decision;
+            }
+            // Reserve the projected cost before the network call. Failed retries and
+            // fallbacks keep their reservation because providers may charge attempts
+            // that fail before returning usage. Actual successful usage is persisted
+            // at turn finalization; reservations reset only when the next root turn starts.
+            this.goalProviderReservedTokens += projectedTokens;
+            return decision;
+        };
         return Object.keys(chatOptions).length > 0 ? chatOptions : undefined;
     }
 }