@orion-agents/orion-code 0.3.1 → 0.3.4

package/dist/commands/workflow-command-handlers.js

@@ -8,8 +8,47 @@ exports.continueAsSlashChat = continueAsSlashChat;
 const workspace_diff_1 = require("../services/workspace-diff");
 const commit_plan_1 = require("../services/commit-plan");
 const agent_mode_1 = require("../framework/agent-mode");
-function handlePlan(ctx, args) {
+async function handlePlan(ctx, args) {
     const task = args.trim();
+    const [subcommand = '', ...tail] = task.split(/\s+/);
+    if (['status', 'approve', 'continue', 'cancel'].includes(subcommand)) {
+        if (!ctx.getPlanReviewState || !ctx.reviewPlan) {
+            return { success: false, error: 'Durable Plan review is unavailable in this Runtime.' };
+        }
+        const state = await ctx.getPlanReviewState();
+        if (!state)
+            return { success: false, error: 'No durable Plan review exists for this Session.' };
+        if (subcommand === 'status') {
+            return {
+                success: true,
+                output: `Plan ${state.planDigest.slice(0, 12)} · ${state.status} · revision ${state.revision}`,
+            };
+        }
+        if (state.status !== 'awaiting_review') {
+            return { success: false, error: `Plan review is already ${state.status}.` };
+        }
+        const feedback = tail.join(' ').trim();
+        if (subcommand === 'continue' && !feedback) {
+            return { success: false, error: 'Usage: /plan continue <feedback>' };
+        }
+        const action = subcommand === 'approve' ? 'approve' : subcommand === 'continue' ? 'continue' : 'cancel';
+        const receipt = await ctx.reviewPlan({
+            planDigest: state.planDigest,
+            action,
+            ...(feedback ? { feedback } : {}),
+        });
+        const nextMode = action === 'approve' ? 'interactive' : action === 'continue' ? 'plan' : null;
+        if (nextMode) {
+            if (ctx.agentModeLifecycle)
+                ctx.agentModeLifecycle.setMode(nextMode);
+            else
+                (0, agent_mode_1.setAgentMode)(ctx.store, nextMode);
+        }
+        return {
+            success: true,
+            output: `Plan review ${receipt.state.status}; follow-on ${receipt.admission.status}.`,
+        };
+    }
     const snapshot = ctx.store.getSnapshot();
     if (!snapshot.planMode || snapshot.agentMode !== 'plan') {
         if (ctx.agentModeLifecycle)
@@ -20,12 +59,12 @@ function handlePlan(ctx, args) {
     if (!task) {
         return {
             success: true,
-            output: 'Plan mode started with the current tool permission policy. Send the task; Orion will save the plan, exit Plan, and execute it in the next logical request.',
+            output: 'Plan mode started with the current tool permission policy. Send the task; Orion will save the plan and wait for explicit review.',
         };
     }
     return {
         success: true,
-        output: 'Plan mode started with full tool availability under the current permission policy. Orion will save the plan, then execute it in a separate request.',
+        output: 'Plan mode started with full tool availability under the current permission policy. Orion will save the plan, then wait for approve, continue, or cancel.',
         continueAsChat: true,
         chatInput: task,
     };

package/dist/commands/workflow-commands.js

@@ -21,8 +21,8 @@ exports.WORKFLOW_COMMANDS = [
     },
     {
         name: 'plan',
-        description: 'Plan with normal tool access, save a decision-complete plan, then exit automatically',
-        argumentHint: '[task description]',
+        description: 'Plan with normal tool access, then review the durable result before execution',
+        argumentHint: '[task | status | approve | continue <feedback> | cancel]',
         category: 'workflow',
         priority: 4,
         type: 'builtin',

package/dist/runtime/agent-runtime-controller.d.ts

@@ -1,10 +1,10 @@
 import type { AgentMode } from '../commands/types';
 import type { AgentRuntimeEventSink, AgentRuntimeInput, AgentRuntimeInputResult, AgentRuntimeInterruptResult, AgentRuntimeSubmitResult } from './agent-runtime-protocol';
 import type { AgentRuntimeRunnerV1, AgentRuntimeRunInputOptionsV1 } from './agent-runtime-runner';
-import type { OrionCodeUiRuntime, FollowupQueueItem, UiEventSink, UiRendererCapabilities } from './ui-events';
+import type { OrionCodeUiRuntime, FollowupQueueItem, FollowupQueueSnapshot, UiEventSink, UiRendererCapabilities } from './ui-events';
 import type { CommandUiRenderer } from '../commands/types';
 import { type TurnControllerOptions } from './turn-controller';
-import { AgentModeLifecycleController } from '../framework/agent-mode';
+import { AgentModeLifecycleController, type AgentModeSnapshot } from '../framework/agent-mode';
 export type { AgentRuntimeInput, AgentRuntimeInputResult, AgentRuntimeInterruptResult, AgentRuntimeSubmitResult, } from './agent-runtime-protocol';
 export type AgentRuntimeRunner = AgentRuntimeRunnerV1;
 export type RunInputOptions = AgentRuntimeRunInputOptionsV1;
@@ -21,6 +21,11 @@ export interface AgentRuntimePendingPermissionSnapshot {
     readonly reason?: string;
     readonly args: Readonly<Record<string, unknown>>;
 }
+/** Item-local queue CAS failure used by Web and renderer adapters. */
+export declare class FollowupQueueConflictError extends Error {
+    readonly code = "queue_item_conflict";
+    constructor(message: string);
+}
 /** Exact agent-mode input used by renderers with a three-state selector. */
 export interface AgentRuntimeSetAgentModeInput {
     readonly type: 'set_agent_mode';
@@ -83,6 +88,11 @@ export declare class AgentRuntimeController {
     constructor(options: AgentRuntimeControllerOptions);
     hasActiveTurn(): boolean;
     getFollowupQueue(): readonly FollowupQueueItem[];
+    getAgentModeSnapshot(): AgentModeSnapshot;
+    getFollowupQueueSnapshot(): FollowupQueueSnapshot;
+    editFollowupQueueItem(itemId: string, expectedRevision: number, text: string): AgentRuntimeInputResult;
+    moveFollowupQueueItem(itemId: string, expectedRevision: number, targetIndex: number): AgentRuntimeInputResult;
+    removeFollowupQueueItem(itemId: string, expectedRevision: number): AgentRuntimeInputResult;
     /**
      * Return a detached read model for browser refresh/reconnect recovery.
      * AbortSignal and resolver ownership remain private to the controller.
@@ -116,8 +126,13 @@ export declare class AgentRuntimeController {
     interrupt(): AgentRuntimeInterruptResult;
     stopActiveTurn(): Promise<void>;
     waitForIdle(): Promise<void>;
+    compactContext(): Promise<import('./agent-runtime-runner').AgentRuntimeCompactResultV1>;
+    canCompactContext(): boolean;
+    planReviewState(): Promise<import('./thread-projection').PlanReviewProjectionV1 | undefined>;
+    reviewPlan(input: Parameters<NonNullable<import('./agent-runtime-runner').AgentRuntimeRunnerV1['reviewPlan']>>[0]): Promise<import('./plan-review').PlanReviewResolutionReceiptV1>;
     private runTurn;
     private handleRunLoopError;
+    private handleCommandError;
     private synchronizeSettingsAtLogicalBoundary;
     private emitAppend;
     private emitStatus;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRuntimeController = void 0;
+exports.AgentRuntimeController = exports.FollowupQueueConflictError = void 0;
+const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
 const commands_1 = require("../commands");
 const parser_1 = require("../commands/parser");
@@ -13,6 +14,15 @@ const tool_allowlist_1 = require("../services/tool-allowlist");
 const agent_mode_1 = require("../framework/agent-mode");
 const redaction_1 = require("../services/redaction");
 const style_1 = require("../tui-core/style");
+/** Item-local queue CAS failure used by Web and renderer adapters. */
+class FollowupQueueConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'queue_item_conflict';
+        this.name = 'FollowupQueueConflictError';
+    }
+}
+exports.FollowupQueueConflictError = FollowupQueueConflictError;
 function isExitInput(input) {
     const parsed = (0, parser_1.parseInput)(input.trim());
     return parsed.isCommand && ['exit', 'quit', 'q'].includes(parsed.name);
@@ -102,7 +112,56 @@ class AgentRuntimeController {
         return this.turnController.hasActiveTurn();
     }
     getFollowupQueue() {
-        return this.followupQueue;
+        return Object.freeze(this.followupQueue.map(item => projectFollowupQueueItem(item)));
+    }
+    getAgentModeSnapshot() {
+        return this.agentModeSnapshot();
+    }
+    getFollowupQueueSnapshot() {
+        return Object.freeze({
+            items: Object.freeze(this.followupQueue.map(item => projectFollowupQueueItem(item))),
+            limit: this.followupQueueLimit,
+        });
+    }
+    editFollowupQueueItem(itemId, expectedRevision, text) {
+        const next = text.trim();
+        if (!next)
+            return { type: 'empty' };
+        const index = this.followupQueue.findIndex(item => item.id === itemId);
+        if (index < 0 || this.followupQueue[index].revision !== expectedRevision) {
+            throw new FollowupQueueConflictError('The queued message changed before it was edited.');
+        }
+        const current = this.followupQueue[index];
+        this.followupQueue[index] = {
+            ...current,
+            text: next,
+            resolvedText: `${next}${current.contextSuffix}`,
+            revision: current.revision + 1,
+        };
+        this.emitFollowupQueue();
+        return { type: 'followup_queue_changed' };
+    }
+    moveFollowupQueueItem(itemId, expectedRevision, targetIndex) {
+        const index = this.followupQueue.findIndex(item => item.id === itemId);
+        if (index < 0 ||
+            this.followupQueue[index].revision !== expectedRevision ||
+            !Number.isSafeInteger(targetIndex)) {
+            throw new FollowupQueueConflictError('The queued message changed before it was moved.');
+        }
+        const bounded = Math.max(0, Math.min(this.followupQueue.length - 1, targetIndex));
+        const [item] = this.followupQueue.splice(index, 1);
+        this.followupQueue.splice(bounded, 0, { ...item, revision: item.revision + 1 });
+        this.emitFollowupQueue();
+        return { type: 'followup_queue_changed' };
+    }
+    removeFollowupQueueItem(itemId, expectedRevision) {
+        const index = this.followupQueue.findIndex(item => item.id === itemId);
+        if (index < 0 || this.followupQueue[index].revision !== expectedRevision) {
+            throw new FollowupQueueConflictError('The queued message changed before it was removed.');
+        }
+        this.followupQueue.splice(index, 1);
+        this.emitFollowupQueue();
+        return { type: 'followup_queue_changed' };
     }
     /**
      * Return a detached read model for browser refresh/reconnect recovery.
@@ -165,7 +224,7 @@ class AgentRuntimeController {
             case 'submit':
                 return this.submit(input.text);
             case 'queue_followup':
-                return this.queueFollowup(input.text);
+                return this.queueFollowup(input.text, input.resolvedText);
             case 'manage_followup_queue':
                 return this.manageFollowupQueue(input.action, input.itemId);
             case 'select_session':
@@ -208,7 +267,7 @@ class AgentRuntimeController {
             appliesFrom: 'next-logical-request',
         };
     }
-    queueFollowup(input) {
+    queueFollowup(input, resolvedInput) {
         const text = input.trim();
         if (!text)
             return { type: 'empty' };
@@ -220,10 +279,15 @@ class AgentRuntimeController {
             this.emitStatus(`Follow-up queue is full (${this.followupQueueLimit}).`);
             return { type: 'followup_queue_full' };
         }
+        const resolvedText = resolvedInput?.trim() || text;
+        const contextSuffix = resolvedText.startsWith(text) ? resolvedText.slice(text.length) : '';
         const item = {
             id: `followup-${this.nextFollowupId++}`,
             text,
+            resolvedText,
+            contextSuffix,
             queuedAt: Date.now(),
+            revision: 1,
         };
         this.followupQueue.push(item);
         this.emitFollowupQueue();
@@ -270,21 +334,7 @@ class AgentRuntimeController {
         }
         if (parsedInput.isCommand) {
             const command = (0, commands_1.findCommand)(parsedInput.name);
-            this.activeRun = this.runCommand(command, parsedInput.args)
-                .catch(error => this.handleRunLoopError(error))
-                .finally(() => {
-                this.activeRun = null;
-            });
-            return { type: 'command_handled' };
-        }
-        if (this.turnController.hasActiveTurn()) {
-            const parsed = (0, parser_1.parseInput)(submitted);
-            if (parsed.isCommand) {
-                const command = (0, commands_1.findCommand)(parsed.name);
-                if (!command) {
-                    this.emitStatus(`Unknown command /${parsed.name}; active turn continues.`);
-                    return { type: 'command_ignored' };
-                }
+            if (this.turnController.hasActiveTurn()) {
                 if (command.busyPolicy === 'reject-busy') {
                     this.emitStatus(`/${command.name} rejected: an agent turn is active.`);
                     return { type: 'command_rejected_busy', commandId: command.id };
@@ -302,6 +352,16 @@ class AgentRuntimeController {
                 this.emitStatus(`Queued /${command.name}; it will apply after the active logical request.`);
                 return { type: 'command_queued', commandId: command.id };
             }
+            const run = this.runCommand(command, parsedInput.args)
+                .catch(error => this.handleCommandError(command, error))
+                .finally(() => {
+                if (this.activeRun === run)
+                    this.activeRun = null;
+            });
+            this.activeRun = run;
+            return { type: 'command_handled' };
+        }
+        if (this.turnController.hasActiveTurn()) {
             this.turnController.clearExitIntent();
             this.turnController.requestRevision(submitted);
             // v0.1.3 (G1): echo the incremental input to the transcript immediately,
@@ -429,6 +489,7 @@ class AgentRuntimeController {
             llm: this.options.runtime.llm,
             compactCoordinator: this.options.runtime.compactCoordinator,
             modelCoordinator: this.options.runtime.modelCoordinator,
+            sessionComposerControls: this.options.runtime.sessionComposerControls,
             sessionId: this.options.runtime.getSession()?.id,
             ensureSession: this.options.runtime.ensureSession,
             setSession: session => this.options.runtime.setSession(session),
@@ -458,6 +519,10 @@ class AgentRuntimeController {
             describeSettings: this.options.runtime.describeSettings,
             updateSettings: this.options.runtime.updateSettings,
             compact: this.runner.compact ? input => this.runner.compact(input) : undefined,
+            reviewPlan: this.runner.reviewPlan ? input => this.runner.reviewPlan(input) : undefined,
+            getPlanReviewState: this.runner.planReviewState
+                ? () => this.runner.planReviewState()
+                : undefined,
         };
     }
     submitTurnRequest(request) {
@@ -501,6 +566,23 @@ class AgentRuntimeController {
     async waitForIdle() {
         await Promise.all([this.activeRun ?? Promise.resolve(), ...this.goalControlRuns]);
     }
+    async compactContext() {
+        if (this.turnController.hasActiveTurn() || !this.runner.compact) {
+            return { status: 'rejected', reason: 'runtime_busy' };
+        }
+        return this.runner.compact({});
+    }
+    canCompactContext() {
+        return Boolean(this.runner.compact);
+    }
+    async planReviewState() {
+        return this.runner.planReviewState?.();
+    }
+    async reviewPlan(input) {
+        if (!this.runner.reviewPlan)
+            throw new Error('Plan review is unavailable for this Runtime.');
+        return this.runner.reviewPlan(input);
+    }
     async runTurn(firstRequest) {
         let nextRequest = firstRequest;
         while (nextRequest && !this.stopping) {
@@ -558,6 +640,19 @@ class AgentRuntimeController {
                     ? undefined
                     : (this.agentModeLifecycle.completedPlanSince(planCompletionBeforeRequest) ?? undefined);
                 this.applyPendingAgentMode(Boolean(completedPlan));
+                try {
+                    await this.options.runtime.sessionComposerControls?.applyPendingAtLogicalBoundary();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.emitAppend({
+                        role: 'error',
+                        title: 'composer controls',
+                        content: `Deferred Composer control failed: ${message}`,
+                        errorLayer: 'runtime',
+                    });
+                    this.emitStatus(`Composer control rollback: ${message}`);
+                }
                 if (revision?.trim()) {
                     this.emitStatus(this.options.restartingStatus ?? '根据补充调整方向中…');
                     nextRequest = {
@@ -586,7 +681,7 @@ class AgentRuntimeController {
                     const queuedFollowup = queuedCommand ? undefined : this.followupQueue.shift();
                     if (queuedFollowup)
                         this.emitFollowupQueue();
-                    const queuedInput = queuedCommand ?? queuedFollowup?.text;
+                    const queuedInput = queuedCommand ?? queuedFollowup?.resolvedText;
                     nextRequest = queuedInput
                         ? {
                             inputKind: 'user',
@@ -633,6 +728,17 @@ class AgentRuntimeController {
             this.emitStatus(readyStatus);
         this.options.afterTurnLoop?.();
     }
+    handleCommandError(command, error) {
+        const message = (0, style_1.sanitizeTerminalText)((0, redaction_1.redactTraceText)(error instanceof Error ? error.message : String(error)));
+        this.emitAppend({
+            role: 'error',
+            title: `/${command.name}`,
+            content: message,
+            errorLayer: 'runtime',
+            command: commandIdentity(command, false),
+        });
+        this.emitStatus(`/${command.name} failed; the active turn state was not changed.`);
+    }
     async synchronizeSettingsAtLogicalBoundary() {
         const synchronize = this.options.runtime.synchronizeSettings;
         if (!synchronize)
@@ -657,7 +763,10 @@ class AgentRuntimeController {
     emitFollowupQueue() {
         this.eventSink.emit({
             type: 'followup_queue_changed',
-            snapshot: { items: [...this.followupQueue], limit: this.followupQueueLimit },
+            snapshot: {
+                items: this.followupQueue.map(item => projectFollowupQueueItem(item)),
+                limit: this.followupQueueLimit,
+            },
         });
     }
     agentModeSnapshot() {
@@ -975,36 +1084,87 @@ function commandIdentity(command, success) {
     };
 }
 async function captureCommandOutput(execute) {
-    const lines = [];
-    const originalLog = console.log;
-    const originalError = console.error;
-    const originalWarn = console.warn;
-    const capture = (...values) => {
-        const line = values
-            .map(value => {
-            if (typeof value === 'string')
-                return value;
-            try {
-                return JSON.stringify(value);
-            }
-            catch {
-                return String(value);
-            }
-        })
-            .join(' ');
-        lines.push((0, style_1.sanitizeTerminalText)(line));
-    };
-    console.log = capture;
-    console.error = capture;
-    console.warn = capture;
+    const capture = { active: true, lines: [] };
+    acquireCommandConsoleBridge();
     try {
-        return { result: await execute(), output: lines.join('\n').trim() };
+        const result = await commandOutputCaptureStorage.run(capture, execute);
+        return { result, output: capture.lines.join('\n').trim() };
     }
     finally {
-        console.log = originalLog;
-        console.error = originalError;
-        console.warn = originalWarn;
+        capture.active = false;
+        releaseCommandConsoleBridge();
+    }
+}
+const commandOutputCaptureStorage = new async_hooks_1.AsyncLocalStorage();
+let commandConsoleBridgeReferences = 0;
+let commandConsoleOriginalMethods;
+const commandConsoleBridge = {
+    log: (...values) => routeCommandConsole('log', values),
+    error: (...values) => routeCommandConsole('error', values),
+    warn: (...values) => routeCommandConsole('warn', values),
+};
+function acquireCommandConsoleBridge() {
+    if (commandConsoleBridgeReferences === 0) {
+        commandConsoleOriginalMethods = {
+            log: originalConsoleMethod('log'),
+            error: originalConsoleMethod('error'),
+            warn: originalConsoleMethod('warn'),
+        };
+        console.log = commandConsoleBridge.log;
+        console.error = commandConsoleBridge.error;
+        console.warn = commandConsoleBridge.warn;
+    }
+    commandConsoleBridgeReferences += 1;
+}
+function releaseCommandConsoleBridge() {
+    commandConsoleBridgeReferences = Math.max(0, commandConsoleBridgeReferences - 1);
+    if (commandConsoleBridgeReferences !== 0 || !commandConsoleOriginalMethods)
+        return;
+    if (console.log === commandConsoleBridge.log)
+        console.log = commandConsoleOriginalMethods.log;
+    if (console.error === commandConsoleBridge.error)
+        console.error = commandConsoleOriginalMethods.error;
+    if (console.warn === commandConsoleBridge.warn)
+        console.warn = commandConsoleOriginalMethods.warn;
+}
+function originalConsoleMethod(method) {
+    const current = console[method];
+    if (current !== commandConsoleBridge[method] || !commandConsoleOriginalMethods)
+        return current;
+    return commandConsoleOriginalMethods[method];
+}
+function routeCommandConsole(method, values) {
+    const capture = commandOutputCaptureStorage.getStore();
+    if (capture?.active) {
+        capture.lines.push((0, style_1.sanitizeTerminalText)((0, redaction_1.redactTraceText)(formatConsoleValues(values))));
+        return;
     }
+    const original = commandConsoleOriginalMethods?.[method];
+    if (original && original !== commandConsoleBridge[method]) {
+        Reflect.apply(original, console, values);
+    }
+}
+function formatConsoleValues(values) {
+    return values
+        .map(value => {
+        if (typeof value === 'string')
+            return value;
+        try {
+            return JSON.stringify(value) ?? String(value);
+        }
+        catch {
+            return String(value);
+        }
+    })
+        .join(' ');
+}
+function projectFollowupQueueItem(item) {
+    return Object.freeze({
+        id: item.id,
+        text: item.text,
+        queuedAt: item.queuedAt,
+        revision: item.revision,
+    });
 }
 function createUnavailableRunner() {
     return {

package/dist/runtime/agent-runtime-protocol.d.ts

@@ -11,7 +11,10 @@ export type AgentRuntimeInput = {
     metadata?: Record<string, unknown>;
 } | {
     type: 'queue_followup';
+    /** User-visible text retained by queue editors and renderer snapshots. */
     text: string;
+    /** Optional Host-resolved execution text; never projected back to renderers. */
+    resolvedText?: string;
     source?: 'composer' | 'programmatic';
 } | {
     type: 'manage_followup_queue';

package/dist/runtime/agent-runtime-runner.d.ts

@@ -1,6 +1,8 @@
 import type { AgentInputKind, AgentTurnRequest } from './goals/types';
 import type { GoalRuntimeControlResultV2, GoalRuntimeControlV2 } from './goal-runtime-coordinator';
 import type { ThreadSessionRuntimeActivationV1 } from './thread-session-view';
+import type { PlanReviewActionV1, PlanReviewResolutionReceiptV1 } from './plan-review';
+import type { PlanReviewProjectionV1 } from './thread-projection';
 /** Renderer-neutral options for one admitted runtime request. */
 export interface AgentRuntimeRunInputOptionsV1 {
     readonly abortSignal?: AbortSignal;
@@ -31,6 +33,12 @@ export interface AgentRuntimeRunnerV1 {
     restoreSession?(activation?: ThreadSessionRuntimeActivationV1): Promise<void>;
     controlGoal?(control: GoalRuntimeControlV2): Promise<GoalRuntimeControlResultV2>;
     compact?(input?: AgentRuntimeCompactInputV1): Promise<AgentRuntimeCompactResultV1>;
+    planReviewState?(): Promise<PlanReviewProjectionV1 | undefined>;
+    reviewPlan?(input: {
+        readonly planDigest: string;
+        readonly action: PlanReviewActionV1;
+        readonly feedback?: string;
+    }): Promise<PlanReviewResolutionReceiptV1>;
     interrupt?(reason?: string): void;
     close?(reason?: string): void | Promise<void>;
 }

package/dist/runtime/capability-receipt-journal.js

@@ -223,7 +223,7 @@ function replayAll(store) {
     const events = [];
     let cursor = 0;
     while (true) {
-        const page = store.replay(cursor);
+        const page = store.replay(cursor, undefined, 'capability_receipt_journal');
         events.push(...page.events);
         if (!page.hasMore)
             return events;

package/dist/runtime/durable-tool-receipt-reader.js

@@ -72,7 +72,7 @@ function readItemReceipt(sessionId, store, item) {
     if (!terminalSeq || terminalSeq < 2 || !toolName || !item.receipt) {
         throw new tool_receipt_validator_1.DurableToolReceiptValidationError('Terminal tool projection is missing its canonical receipt identity.');
     }
-    const pair = store.replay(terminalSeq - 2, 2).events;
+    const pair = store.replay(terminalSeq - 2, 2, 'durable_tool_receipt').events;
     const factEvent = pair.find(event => event.seq === terminalSeq - 1);
     const terminalEvent = pair.find(event => event.seq === terminalSeq);
     if (!factEvent || !terminalEvent || terminalEvent.itemId !== item.itemId) {

package/dist/runtime/legacy-thread-materializer.js

@@ -477,7 +477,7 @@ function materializeFacts(threadsDir, plan) {
     if (cursor > plan.events.length) {
         throw diverged(`Existing Thread has ${cursor} events, expected ${plan.events.length}`);
     }
-    const existing = cursor === 0 ? [] : store.replay(0, cursor).events;
+    const existing = cursor === 0 ? [] : store.replay(0, cursor, 'legacy_materializer').events;
     for (let index = 0; index < existing.length; index += 1) {
         if ((0, canonical_1.canonicalRuntimeJson)(existing[index]) !== (0, canonical_1.canonicalRuntimeJson)(plan.events[index])) {
             throw diverged(`Existing Thread diverges from import plan at seq ${index + 1}`);
@@ -490,7 +490,7 @@ function materializeFacts(threadsDir, plan) {
     return store;
 }
 function verifyMaterializedStore(store, plan) {
-    const replay = store.replay(0, Math.max(1, plan.events.length));
+    const replay = store.replay(0, Math.max(1, plan.events.length), 'legacy_materializer');
     if (replay.hasMore ||
         replay.events.length !== plan.events.length ||
         (0, canonical_1.digestRuntimeValue)(replay.events) !== plan.eventDigest) {

package/dist/runtime/orion-runtime-v1.d.ts

@@ -14,7 +14,7 @@ import { PromptRegistryV1 } from './prompts';
 import { ResourceScope, type ResourceScopeCloseReport } from './resource-scope';
 import { type RuntimeContributorSlots, type RuntimeContributors, type RuntimeServicePort, type RuntimeServices, type RuntimeServiceSlots } from './runtime-services';
 import { LazySkillRuntime, type LazySkillRuntimeOptions, type LazySkillRuntimeStatsV1 } from './skills';
-import { ExecutionService, type AuthoritySnapshotV1, type ToolBindingV1 } from './step-snapshot';
+import { ExecutionService, type AuthoritySnapshotV1, type ToolBindingV1, type WorkspaceMutationCoordinatorV1 } from './step-snapshot';
 import { ThreadCompactMaintenanceRunnerV1, ThreadCompactTransactionPersistenceV1, type ThreadCompactMaintenanceRunnerOptionsV1 } from './thread-compact-persistence';
 import { type TaskContextService, type TaskContextServiceOptions } from './task-context-service';
 import { ThreadEventStore, type ThreadEventStoreOptionsV1 } from './thread-event-store';
@@ -116,6 +116,7 @@ export interface OrionRuntimeV1Options {
     readonly mcp: Omit<LazyMcpRuntimeOptions, 'signal'>;
     readonly resolveCapabilityConfiguration: OrionCapabilityConfigurationResolverV1;
     readonly approvalHandler?: FirstPartyApprovalHandlerV1;
+    readonly workspaceMutationCoordinator?: WorkspaceMutationCoordinatorV1;
     readonly contributors?: RuntimeContributorSlots;
     readonly subagents?: OrionSubagentCompositionV1;
     readonly thread?: Omit<ThreadRuntimeOptionsV1, 'store' | 'runner' | 'maintenanceRunner' | 'projectPath' | 'requireTurnCommit'>;

package/dist/runtime/orion-runtime-v1.js

@@ -82,22 +82,24 @@ class OrionRuntimeV1 {
         const projection = graph.thread.getProjection();
         const admission = graph.thread.getAdmissionSnapshot();
         const eventCursor = graph.eventStore.getCursor();
-        const recent = graph.eventStore.replay(Math.max(0, eventCursor - 256), 256).events;
-        const latestCapabilityEvent = [...recent]
-            .reverse()
-            .find(event => event.payload.type === 'capability.receipt');
-        const latestSnapshotEvent = [...recent]
-            .reverse()
-            .find(event => event.payload.type === 'step.snapshot');
-        const latestCommitEvent = [...recent]
-            .reverse()
-            .find(event => event.payload.type === 'turn.committed');
-        const latestCompactEvent = [...recent]
-            .reverse()
-            .find(event => event.payload.type.startsWith('compact.'));
+        const legacyRecent = projection.diagnosticEvents && projection.compactEvents
+            ? []
+            : graph.eventStore.replay(Math.max(0, eventCursor - 256), 256, 'runtime_diagnostics_legacy')
+                .events;
+        const latestCapabilityEvent = projection.diagnosticEvents?.latestCapability ??
+            [...legacyRecent].reverse().find(event => event.payload.type === 'capability.receipt');
+        const latestSnapshotEvent = projection.diagnosticEvents?.latestStepSnapshot ??
+            [...legacyRecent].reverse().find(event => event.payload.type === 'step.snapshot');
+        const latestCommitProjection = Object.values(projection.turns)
+            .map(turn => turn.commit)
+            .filter((commit) => Boolean(commit))
+            .sort((left, right) => left.seq - right.seq)
+            .at(-1);
+        const latestCompactEvent = projection.compactEvents?.at(-1) ??
+            [...legacyRecent].reverse().find(event => event.payload.type.startsWith('compact.'));
         const capability = parseCapabilityDiagnostics(latestCapabilityEvent, latestSnapshotEvent);
-        const latestCommit = latestCommitEvent?.payload.type === 'turn.committed'
-            ? (0, turn_commit_1.parseTurnCommitV1)(latestCommitEvent.payload.data.receipt)
+        const latestCommit = latestCommitProjection
+            ? (0, turn_commit_1.parseTurnCommitV1)(latestCommitProjection.receipt)
             : undefined;
         const task = graph.taskContext.snapshot();
         const activeTurn = projection.activeTurnId
@@ -354,7 +356,7 @@ class OrionRuntimeV1 {
             });
             const approval = new first_party_tool_services_1.FirstPartyToolApprovalServiceV1(this.options.approvalHandler);
             const sandbox = new first_party_tool_services_1.FirstPartySandboxServiceV1();
-            const execution = new step_snapshot_1.ExecutionService();
+            const execution = new step_snapshot_1.ExecutionService(this.options.workspaceMutationCoordinator);
             const toolJournal = new thread_tool_journal_1.ThreadToolInvocationJournalV1(eventStore);
             const gateway = new tool_gateway_1.ToolGateway({
                 policy,