@orion-agents/orion-code 0.3.2 → 0.3.4

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

@@ -2,12 +2,14 @@ import type { Store } from '../framework/store';
 import type { OrionCodeCLIConfig } from '../services/config';
 import type { CompactCoordinator } from '../services/compact/coordinator';
 import { LLMService } from '../services/llm';
+import type { ProviderRequestGate } from '../services/provider-resilience/request-gate';
 import { type BuiltinToolCatalogV1 } from './builtin-tool-provider';
 import type { McpConnectorV1, McpServerDescriptorInputV1 } from './mcp';
 import { type OrionRuntimeV1 } from './orion-runtime-v1';
 import type { SkillProviderV1 } from './skills';
 import type { FirstPartyApprovalHandlerV1 } from './first-party-tool-services';
 import type { ThreadSessionRuntimeActivationV1 } from './thread-session-view';
+import { type WorkspaceMutationCoordinatorV1 } from './step-snapshot';
 import type { SubagentThreadReceiptV1 } from './subagent-thread-runtime';
 import { type SubagentRole } from './subagents/types';
 export interface ProductOrionRuntimeOptionsV1 {
@@ -22,6 +24,9 @@ export interface ProductOrionRuntimeOptionsV1 {
     readonly mcpDescriptors?: readonly McpServerDescriptorInputV1[];
     readonly mcpConnector?: McpConnectorV1;
     readonly approvalHandler?: FirstPartyApprovalHandlerV1;
+    readonly workspaceMutationCoordinator?: WorkspaceMutationCoordinatorV1;
+    /** Workspace-scoped provider concurrency/cooldown authority shared by root and child calls. */
+    readonly providerRequestGate?: ProviderRequestGate;
     /** Must create a distinct mutable provider client for every child request. */
     readonly createSubagentModelExecutor?: (input: {
         readonly role: SubagentRole;

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

@@ -103,6 +103,7 @@ function createProductOrionRuntimeV1(options, sessionId, activation) {
             connector: options.mcpConnector ?? INERT_MCP_CONNECTOR,
         },
         approvalHandler: options.approvalHandler,
+        workspaceMutationCoordinator: options.workspaceMutationCoordinator,
         ...(subagents ? { subagents } : {}),
         resolveCapabilityConfiguration: async (input, context) => {
             if (!promptState || promptState.turnId !== input.turnId) {
@@ -365,6 +366,7 @@ function createProductSubagentCompositionV1(options, model) {
                     modelLabel: model.modelId,
                     rootObjectiveSummary: input.input,
                     abortSignal: input.abortSignal,
+                    sharedGate: options.providerRequestGate,
                 });
                 if (!bundle) {
                     productionRuntime.close('subagent_turn_unavailable');

package/dist/runtime/release-receipts.d.ts

@@ -6,11 +6,15 @@ export declare const SUPPORTED_RELEASE_VERSION_LINE_V1: "0.3.x";
 export declare const WEB_E2E_LEGACY_SCENARIOS_V1: readonly ["E2E-P0-01", "E2E-P0-02", "E2E-P0-03", "E2E-P0-04", "E2E-P0-05", "E2E-P0-06", "E2E-P0-07", "E2E-P0-08", "SET-P0-01", "SET-P0-02", "SET-P0-03", "SET-P0-04", "SET-P0-05", "SET-P0-06", "SET-P0-07", "SET-P0-08", "SET-P0-09", "SET-P0-10", "SET-P0-11", "SET-P0-12", "SET-P0-13", "SET-P0-14"];
 export declare const WEB_E2E_WEB31_SCENARIOS_V1: readonly ["WEB31-P0-01", "WEB31-P0-02", "WEB31-P0-03", "WEB31-P0-04", "WEB31-P0-05", "WEB31-P0-06", "WEB31-P0-07", "WEB31-P0-08", "WEB31-P0-09", "WEB31-P0-10", "WEB31-P0-11", "WEB31-P0-12"];
 export declare const WEB_E2E_WEB32_SCENARIOS_V1: readonly ["WEB32-P0-01", "WEB32-P0-02", "WEB32-P0-03", "WEB32-P0-04", "WEB32-P0-05", "WEB32-P0-06", "WEB32-P0-07", "WEB32-P0-08", "WEB32-P0-09", "WEB32-P0-10", "WEB32-P0-11", "WEB32-P0-12"];
-export declare const WEB_E2E_FULL_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12")[];
-export declare const WEB_E2E_SETTINGS_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12")[];
+export declare const WEB_E2E_WEB33_THEME_SCENARIOS_V1: readonly ["WEB33-P0-01", "WEB33-P0-02", "WEB33-P0-03", "WEB33-P0-04", "WEB33-P0-05", "WEB33-P0-06", "WEB33-P0-07", "WEB33-P0-08", "WEB33-P0-09", "WEB33-P0-10", "WEB33-P0-11", "WEB33-P0-12"];
+export declare const WEB_E2E_WEB33_SESSION_SCENARIOS_V1: readonly ["WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-19", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-22", "WEB33-P0-23", "WEB33-P0-24"];
+export declare const WEB_E2E_WEB33_SCENARIOS_V1: readonly ("WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24")[];
+export declare const WEB_E2E_FULL_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12" | "WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24")[];
+export declare const WEB_E2E_SETTINGS_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12" | "WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24")[];
 export declare const WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1: readonly ["WEB31-P0-01", "WEB31-P0-02", "WEB31-P0-08", "WEB31-P0-09", "WEB31-P0-10", "WEB31-P0-12"];
 export declare const WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1: readonly ["WEB32-P0-01", "WEB32-P0-04", "WEB32-P0-05", "WEB32-P0-06", "WEB32-P0-09", "WEB32-P0-11", "WEB32-P0-12"];
-export declare const WEB_E2E_CRITICAL_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12")[];
+export declare const WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1: readonly ["WEB33-P0-01", "WEB33-P0-03", "WEB33-P0-08", "WEB33-P0-10", "WEB33-P0-12", "WEB33-P0-16", "WEB33-P0-17", "WEB33-P0-18", "WEB33-P0-20", "WEB33-P0-21", "WEB33-P0-23", "WEB33-P0-24"];
+export declare const WEB_E2E_CRITICAL_SCENARIOS_V1: readonly ("E2E-P0-01" | "E2E-P0-02" | "E2E-P0-03" | "E2E-P0-04" | "E2E-P0-05" | "E2E-P0-06" | "E2E-P0-07" | "E2E-P0-08" | "SET-P0-01" | "SET-P0-02" | "SET-P0-03" | "SET-P0-04" | "SET-P0-05" | "SET-P0-06" | "SET-P0-07" | "SET-P0-08" | "SET-P0-09" | "SET-P0-10" | "SET-P0-11" | "SET-P0-12" | "SET-P0-13" | "SET-P0-14" | "WEB31-P0-01" | "WEB31-P0-02" | "WEB31-P0-03" | "WEB31-P0-04" | "WEB31-P0-05" | "WEB31-P0-06" | "WEB31-P0-07" | "WEB31-P0-08" | "WEB31-P0-09" | "WEB31-P0-10" | "WEB31-P0-11" | "WEB31-P0-12" | "WEB32-P0-01" | "WEB32-P0-02" | "WEB32-P0-03" | "WEB32-P0-04" | "WEB32-P0-05" | "WEB32-P0-06" | "WEB32-P0-07" | "WEB32-P0-08" | "WEB32-P0-09" | "WEB32-P0-10" | "WEB32-P0-11" | "WEB32-P0-12" | "WEB33-P0-01" | "WEB33-P0-02" | "WEB33-P0-03" | "WEB33-P0-04" | "WEB33-P0-05" | "WEB33-P0-06" | "WEB33-P0-07" | "WEB33-P0-08" | "WEB33-P0-09" | "WEB33-P0-10" | "WEB33-P0-11" | "WEB33-P0-12" | "WEB33-P0-16" | "WEB33-P0-17" | "WEB33-P0-18" | "WEB33-P0-19" | "WEB33-P0-20" | "WEB33-P0-21" | "WEB33-P0-22" | "WEB33-P0-23" | "WEB33-P0-24")[];
 export type ReleaseGateDecisionV1 = 'GO' | 'NO_GO';
 export interface TarballArtifactReceiptV1 {
     readonly version: typeof RELEASE_RECEIPT_VERSION_V1;

package/dist/runtime/release-receipts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WEB_E2E_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_SETTINGS_SCENARIOS_V1 = exports.WEB_E2E_FULL_SCENARIOS_V1 = exports.WEB_E2E_WEB32_SCENARIOS_V1 = exports.WEB_E2E_WEB31_SCENARIOS_V1 = exports.WEB_E2E_LEGACY_SCENARIOS_V1 = exports.SUPPORTED_RELEASE_VERSION_LINE_V1 = exports.SUPPORTED_RELEASE_NODE_FLOORS_V1 = exports.SUPPORTED_RELEASE_NODE_MAJORS_V1 = exports.RELEASE_RECEIPT_VERSION_V1 = void 0;
+exports.WEB_E2E_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1 = exports.WEB_E2E_SETTINGS_SCENARIOS_V1 = exports.WEB_E2E_FULL_SCENARIOS_V1 = exports.WEB_E2E_WEB33_SCENARIOS_V1 = exports.WEB_E2E_WEB33_SESSION_SCENARIOS_V1 = exports.WEB_E2E_WEB33_THEME_SCENARIOS_V1 = exports.WEB_E2E_WEB32_SCENARIOS_V1 = exports.WEB_E2E_WEB31_SCENARIOS_V1 = exports.WEB_E2E_LEGACY_SCENARIOS_V1 = exports.SUPPORTED_RELEASE_VERSION_LINE_V1 = exports.SUPPORTED_RELEASE_NODE_FLOORS_V1 = exports.SUPPORTED_RELEASE_NODE_MAJORS_V1 = exports.RELEASE_RECEIPT_VERSION_V1 = void 0;
 exports.createTarballArtifactReceiptV1 = createTarballArtifactReceiptV1;
 exports.verifyTarballArtifactReceiptV1 = verifyTarballArtifactReceiptV1;
 exports.createRuntimeMatrixReceiptV1 = createRuntimeMatrixReceiptV1;
@@ -72,10 +72,40 @@ exports.WEB_E2E_WEB32_SCENARIOS_V1 = Object.freeze([
     'WEB32-P0-11',
     'WEB32-P0-12',
 ]);
+exports.WEB_E2E_WEB33_THEME_SCENARIOS_V1 = Object.freeze([
+    'WEB33-P0-01',
+    'WEB33-P0-02',
+    'WEB33-P0-03',
+    'WEB33-P0-04',
+    'WEB33-P0-05',
+    'WEB33-P0-06',
+    'WEB33-P0-07',
+    'WEB33-P0-08',
+    'WEB33-P0-09',
+    'WEB33-P0-10',
+    'WEB33-P0-11',
+    'WEB33-P0-12',
+]);
+exports.WEB_E2E_WEB33_SESSION_SCENARIOS_V1 = Object.freeze([
+    'WEB33-P0-16',
+    'WEB33-P0-17',
+    'WEB33-P0-18',
+    'WEB33-P0-19',
+    'WEB33-P0-20',
+    'WEB33-P0-21',
+    'WEB33-P0-22',
+    'WEB33-P0-23',
+    'WEB33-P0-24',
+]);
+exports.WEB_E2E_WEB33_SCENARIOS_V1 = Object.freeze([
+    ...exports.WEB_E2E_WEB33_THEME_SCENARIOS_V1,
+    ...exports.WEB_E2E_WEB33_SESSION_SCENARIOS_V1,
+]);
 exports.WEB_E2E_FULL_SCENARIOS_V1 = Object.freeze([
     ...exports.WEB_E2E_LEGACY_SCENARIOS_V1,
     ...exports.WEB_E2E_WEB31_SCENARIOS_V1,
     ...exports.WEB_E2E_WEB32_SCENARIOS_V1,
+    ...exports.WEB_E2E_WEB33_SCENARIOS_V1,
 ]);
 exports.WEB_E2E_SETTINGS_SCENARIOS_V1 = Object.freeze(exports.WEB_E2E_FULL_SCENARIOS_V1.filter(id => id.startsWith('SET-P0-')));
 exports.WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1 = Object.freeze([
@@ -95,11 +125,26 @@ exports.WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1 = Object.freeze([
     'WEB32-P0-11',
     'WEB32-P0-12',
 ]);
+exports.WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1 = Object.freeze([
+    'WEB33-P0-01',
+    'WEB33-P0-03',
+    'WEB33-P0-08',
+    'WEB33-P0-10',
+    'WEB33-P0-12',
+    'WEB33-P0-16',
+    'WEB33-P0-17',
+    'WEB33-P0-18',
+    'WEB33-P0-20',
+    'WEB33-P0-21',
+    'WEB33-P0-23',
+    'WEB33-P0-24',
+]);
 exports.WEB_E2E_CRITICAL_SCENARIOS_V1 = Object.freeze([
     ...exports.WEB_E2E_LEGACY_SCENARIOS_V1.slice(0, 4),
     ...exports.WEB_E2E_SETTINGS_SCENARIOS_V1,
     ...exports.WEB_E2E_WEB31_CRITICAL_SCENARIOS_V1,
     ...exports.WEB_E2E_WEB32_CRITICAL_SCENARIOS_V1,
+    ...exports.WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1,
 ]);
 function createTarballArtifactReceiptV1(input) {
     assertIsoTimestamp(input.createdAt, 'artifact createdAt');
@@ -246,6 +291,8 @@ function createWebE2EReleaseReceiptV1(input) {
             `consecutive=${primaryTimelineIsConsecutive}`,
     });
     const runtimeMajors = runtimeRuns.map(run => run.environment.nodeMajor);
+    const runtimeRunIds = new Set(runtimeRuns.map(run => run.runId));
+    const runtimeManifestDigests = new Set(runtimeRuns.map(run => run.manifestDigest));
     checks.push({
         id: 'node_matrix_complete',
         status: runtimeRuns.length === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length &&
@@ -254,6 +301,21 @@ function createWebE2EReleaseReceiptV1(input) {
             : 'fail',
         detail: `expected=${exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.join(',')} observed=${runtimeMajors.join(',') || 'none'}`,
     });
+    checks.push({
+        id: 'node_matrix_runs_unique',
+        status: runtimeRuns.length === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length &&
+            runtimeRunIds.size === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length &&
+            runtimeManifestDigests.size === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length
+            ? 'pass'
+            : 'fail',
+        detail: `runs=${runtimeRuns.length} uniqueRunIds=${runtimeRunIds.size} ` +
+            `uniqueManifests=${runtimeManifestDigests.size}`,
+    });
+    checks.push({
+        id: 'live_canary',
+        status: input.liveCanary === 'FAIL' ? 'fail' : 'pass',
+        detail: `observed=${input.liveCanary}`,
+    });
     const primaryCoverage = primaryRuns.length === 3 &&
         primaryRuns.every(run => run.role === 'primary' && sameOrderedValues(run.scenarioIds, exports.WEB_E2E_FULL_SCENARIOS_V1));
     const runtimeCoverage = runtimeRuns.length === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length &&
@@ -351,6 +413,22 @@ function createWebE2EReleaseReceiptV1(input) {
             ? `all WEB32 journeys passed in three primary runs; critical Composer/Layout journeys passed on Node ${runtimeMajors.join(',')} using one tgz`
             : 'WEB32 full or critical exact-tarball coverage is missing, skipped, failed, or dirty',
     });
+    const web33PrimaryComplete = primaryRuns.length === 3 &&
+        primaryRuns.every(run => run.decision === 'GO' &&
+            run.cleanEvidence &&
+            exports.WEB_E2E_WEB33_SCENARIOS_V1.every(id => run.scenarioIds.includes(id)));
+    const web33MatrixComplete = runtimeRuns.length === exports.SUPPORTED_RELEASE_NODE_MAJORS_V1.length &&
+        runtimeRuns.every(run => run.decision === 'GO' &&
+            run.cleanEvidence &&
+            run.tarballSha256 === input.tarballSha256 &&
+            exports.WEB_E2E_WEB33_CRITICAL_SCENARIOS_V1.every(id => run.scenarioIds.includes(id)));
+    checks.push({
+        id: 'WEB33-P0-24',
+        status: web33PrimaryComplete && web33MatrixComplete ? 'pass' : 'fail',
+        detail: web33PrimaryComplete && web33MatrixComplete
+            ? `all WEB33 journeys passed in three primary runs; critical theme/session journeys passed on Node ${runtimeMajors.join(',')} using one tgz`
+            : 'WEB33 full or critical exact-tarball coverage is missing, skipped, failed, or dirty',
+    });
     const decision = checks.every(check => check.status === 'pass')
         ? 'GO'
         : 'NO_GO';

package/dist/runtime/step-snapshot.d.ts

@@ -133,6 +133,7 @@ export declare class ToolRouterSnapshotV1 {
     assertIntegrity(): void;
 }
 export interface BoundToolExecutionRequestV1 {
+    readonly invocationId: string;
     readonly snapshot: StepSnapshotV1;
     readonly toolName: string;
     readonly args: Record<string, unknown>;
@@ -140,6 +141,15 @@ export interface BoundToolExecutionRequestV1 {
     readonly enforcement: 'full' | 'partial' | 'none';
     readonly abortSignal?: AbortSignal;
 }
+export interface WorkspaceMutationCoordinatorV1 {
+    runWorkspaceMutation<T>(input: {
+        readonly workspaceId: string;
+        readonly invocationId: string;
+        readonly toolName: string;
+        readonly args: Readonly<Record<string, unknown>>;
+        readonly abortSignal?: AbortSignal;
+    }, operation: () => T | Promise<T>): Promise<T>;
+}
 export interface BoundToolExecutionResultV1 {
     readonly terminal: 'completed' | 'failed' | 'interrupted' | 'indeterminate';
     readonly result: ToolResult;
@@ -147,6 +157,8 @@ export interface BoundToolExecutionResultV1 {
 }
 /** The only runtime primitive allowed to call a frozen concrete tool executor. */
 export declare class ExecutionService {
+    private readonly workspaceMutations?;
+    constructor(workspaceMutations?: WorkspaceMutationCoordinatorV1 | undefined);
     run(request: BoundToolExecutionRequestV1): Promise<BoundToolExecutionResultV1>;
 }
 export interface StepSnapshotV1 {

package/dist/runtime/step-snapshot.js

@@ -105,6 +105,9 @@ class ToolRouterSnapshotV1 {
 exports.ToolRouterSnapshotV1 = ToolRouterSnapshotV1;
 /** The only runtime primitive allowed to call a frozen concrete tool executor. */
 class ExecutionService {
+    constructor(workspaceMutations) {
+        this.workspaceMutations = workspaceMutations;
+    }
     async run(request) {
         const startedAt = Date.now();
         request.snapshot.toolRouter.assertIntegrity();
@@ -132,7 +135,17 @@ class ExecutionService {
         const timeout = setTimeout(() => timeoutController.abort(new Error('Tool invocation timed out')), request.snapshot.executionPolicy.timeoutMs);
         timeout.unref?.();
         try {
-            const result = await request.snapshot.toolRouter.executeBound(EXECUTION_SERVICE_TOKEN, request.toolName, structuredClone(request.args), { ...request.context, abortSignal: timeoutController.signal });
+            const execute = () => request.snapshot.toolRouter.executeBound(EXECUTION_SERVICE_TOKEN, request.toolName, structuredClone(request.args), { ...request.context, abortSignal: timeoutController.signal });
+            const descriptor = request.snapshot.toolRouter.resolveDescriptor(request.toolName);
+            const result = descriptor?.risk.effect === 'workspace_write' && this.workspaceMutations
+                ? await this.workspaceMutations.runWorkspaceMutation({
+                    workspaceId: request.snapshot.authority.projectRoot,
+                    invocationId: request.invocationId,
+                    toolName: request.toolName,
+                    args: request.args,
+                    abortSignal: timeoutController.signal,
+                }, execute)
+                : await execute();
             const presented = persistLargeToolOutput(request.context.cwd, request.toolName, result);
             return {
                 terminal: timeoutController.signal.aborted

package/dist/runtime/subagent-thread-runtime.js

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

package/dist/runtime/thread-event-store.d.ts

@@ -14,6 +14,7 @@ export interface ThreadEventReplayV1 {
     readonly nextCursor: number;
     readonly hasMore: boolean;
 }
+export type ThreadEventReplayReasonV1 = 'direct' | 'capability_receipt_journal' | 'durable_tool_receipt' | 'legacy_materializer' | 'runtime_diagnostics_legacy' | 'subagent_receipt_journal' | 'thread_session_view' | 'turn_commit_journal' | 'ui_gap_recovery' | 'ui_initial_history';
 export interface ThreadEventCommitV1 {
     readonly events: readonly RuntimeEventEnvelopeV1[];
     readonly projection: ThreadProjectionV1;
@@ -84,11 +85,19 @@ export interface ThreadEventStoreOptionsV1 {
         readonly events: number;
     }) => void;
 }
+export interface ThreadEventStorePerformanceCountersV1 {
+    readonly logScans: number;
+    readonly bytesScanned: number;
+    readonly eventsScanned: number;
+    readonly scanReasons: Readonly<Record<string, number>>;
+}
 export declare class ThreadEventStoreError extends Error {
     readonly code: 'ORION_THREAD_EVENT_CORRUPT' | 'ORION_THREAD_EVENT_LIMIT' | 'ORION_THREAD_EVENT_CURSOR' | 'ORION_THREAD_EVENT_IDENTITY' | 'ORION_THREAD_COMPACT_INVALID' | 'ORION_THREAD_COMPACT_CONFLICT';
     readonly offset?: number | undefined;
     constructor(code: 'ORION_THREAD_EVENT_CORRUPT' | 'ORION_THREAD_EVENT_LIMIT' | 'ORION_THREAD_EVENT_CURSOR' | 'ORION_THREAD_EVENT_IDENTITY' | 'ORION_THREAD_COMPACT_INVALID' | 'ORION_THREAD_COMPACT_CONFLICT', message: string, offset?: number | undefined);
 }
+/** Process-local monotonic read counters for diagnostics and switch budgets. */
+export declare function threadEventStorePerformanceCountersV1(): ThreadEventStorePerformanceCountersV1;
 /**
  * Append-only durable fact store for a single Thread.
  *
@@ -120,7 +129,7 @@ export declare class ThreadEventStore {
     createEphemeral<T extends Extract<RuntimeEventV1, {
         type: 'item.delta';
     }>>(input: AppendRuntimeEventV1<T>): RuntimeEventEnvelopeV1<T>;
-    replay(cursor?: number, limit?: number): ThreadEventReplayV1;
+    replay(cursor?: number, limit?: number, reason?: ThreadEventReplayReasonV1): ThreadEventReplayV1;
     /**
      * Verify and seal an immutable imported prefix. The first call may scan the
      * authoritative log; later processes reuse the prefix receipt while the

package/dist/runtime/thread-event-store.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadEventStore = exports.ThreadEventStoreError = void 0;
+exports.threadEventStorePerformanceCountersV1 = threadEventStorePerformanceCountersV1;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const atomic_write_1 = require("../services/atomic-write");
@@ -21,6 +22,19 @@ exports.ThreadEventStoreError = ThreadEventStoreError;
 const DEFAULT_MAX_LOG_BYTES = 128 * 1024 * 1024;
 const DEFAULT_MAX_REPLAY_EVENTS = 10000;
 const DEFAULT_LOCK_WAIT_MS = 10000;
+const threadEventStorePerformance = {
+    logScans: 0,
+    bytesScanned: 0,
+    eventsScanned: 0,
+    scanReasons: {},
+};
+/** Process-local monotonic read counters for diagnostics and switch budgets. */
+function threadEventStorePerformanceCountersV1() {
+    return Object.freeze({
+        ...threadEventStorePerformance,
+        scanReasons: Object.freeze({ ...threadEventStorePerformance.scanReasons }),
+    });
+}
 /**
  * Append-only durable fact store for a single Thread.
  *
@@ -172,7 +186,7 @@ class ThreadEventStore {
         (0, runtime_protocol_v1_1.assertRuntimeEventEnvelopeV1)(event);
         return deepFreeze(event);
     }
-    replay(cursor = 0, limit = this.maxReplayEvents) {
+    replay(cursor = 0, limit = this.maxReplayEvents, reason = 'direct') {
         if (!Number.isSafeInteger(cursor) || cursor < 0) {
             throw new ThreadEventStoreError('ORION_THREAD_EVENT_CURSOR', 'Replay cursor must be a non-negative safe integer');
         }
@@ -181,7 +195,7 @@ class ThreadEventStore {
             throw new ThreadEventStoreError('ORION_THREAD_EVENT_LIMIT', `Replay limit ${safeLimit} exceeds ${this.maxReplayEvents}`);
         }
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const scan = requireVerifiedScan(this.loadVerifiedHead(true, `replay:${reason}`));
             const lastSeq = scan.events.length;
             if (cursor > lastSeq) {
                 throw new ThreadEventStoreError('ORION_THREAD_EVENT_CURSOR', `Replay cursor ${cursor} is ahead of durable cursor ${lastSeq}`);
@@ -216,7 +230,7 @@ class ThreadEventStore {
             const expected = { cursor, eventDigest, projectionDigest };
             if (head.verifiedPrefixes.some(prefix => sameVerifiedPrefix(prefix, expected)))
                 return true;
-            head = this.loadVerifiedHead(true);
+            head = this.loadVerifiedHead(true, 'verify_durable_prefix');
             const scan = requireVerifiedScan(head);
             const events = scan.events.slice(0, cursor);
             if (events.length !== cursor ||
@@ -333,14 +347,14 @@ class ThreadEventStore {
      */
     loadAuthoritativeModelHistory() {
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const head = this.loadVerifiedHead();
             const state = readCompactState(this.compactStatePath, this.threadId);
             if (state)
                 this.assertCompactCheckpoint(state);
-            const turnState = readLatestDurableTurnState(scan.events, this.threadId);
+            const turnState = readLatestDurableTurnStateFromProjection(head.projection);
             if (!state && !turnState)
                 return undefined;
-            return resolveCompactAuthority(scan.events, state, this.threadId).history;
+            return resolveCompactAuthorityState(turnState, state).history;
         });
     }
     /**
@@ -350,7 +364,7 @@ class ThreadEventStore {
     captureCompactSource(turnId) {
         return this.withLogLock(() => {
             ensurePrivateDirectory(this.rootDir);
-            const head = this.loadVerifiedHead(true);
+            const head = this.loadVerifiedHead(true, 'capture_compact_source');
             const scan = requireVerifiedScan(head);
             const { projection } = head;
             assertActiveMaintenanceTurn(projection, turnId);
@@ -387,7 +401,7 @@ class ThreadEventStore {
             ensurePrivateDirectory(this.compactCheckpointsDir);
             validateCompactCommitInput(input, this.threadId);
             input.onBoundary('before_cas_recheck');
-            const head = this.loadVerifiedHead(true);
+            const head = this.loadVerifiedHead(true, 'compact_cas');
             const scan = requireVerifiedScan(head);
             const { projection } = head;
             const eventsAfterAnchor = scan.events.slice(input.expectedEventAnchor.cursor);
@@ -454,7 +468,10 @@ class ThreadEventStore {
     }
     listCompactEvents() {
         return this.withLogLock(() => {
-            const scan = requireVerifiedScan(this.loadVerifiedHead(true));
+            const projection = this.loadVerifiedHead().projection;
+            if (projection.compactEvents)
+                return projection.compactEvents;
+            const scan = requireVerifiedScan(this.loadVerifiedHead(true, 'legacy_compact_projection'));
             return deepFreeze(scan.events.filter((event) => event.payload.type === 'compact.started' ||
                 event.payload.type === 'compact.completed' ||
                 event.payload.type === 'compact.failed'));
@@ -511,7 +528,7 @@ class ThreadEventStore {
      * projection still match. Callers that need historical events explicitly
      * request a scan; cursor/projection/append paths stay O(head + projection).
      */
-    loadVerifiedHead(requireScan = false) {
+    loadVerifiedHead(requireScan = false, scanReason = 'unspecified') {
         ensurePrivateDirectory(this.rootDir);
         const logIdentity = readFileIdentity(this.logPath);
         if (this.cachedHead?.logFingerprint === logIdentity.fingerprint &&
@@ -528,6 +545,11 @@ class ThreadEventStore {
             }
         }
         const scan = scanThreadEventLog(this.logPath, this.threadId, this.maxLogBytes);
+        threadEventStorePerformance.logScans += 1;
+        threadEventStorePerformance.bytesScanned += scan.safeByteLength + scan.discardedTailBytes;
+        threadEventStorePerformance.eventsScanned += scan.events.length;
+        threadEventStorePerformance.scanReasons[scanReason] =
+            (threadEventStorePerformance.scanReasons[scanReason] ?? 0) + 1;
         this.onLogScan?.({
             threadId: this.threadId,
             bytes: scan.safeByteLength + scan.discardedTailBytes,
@@ -961,6 +983,9 @@ function assertActiveMaintenanceTurn(projection, turnId) {
 }
 function resolveCompactAuthority(events, compactState, threadId) {
     const turnState = readLatestDurableTurnState(events, threadId);
+    return resolveCompactAuthorityState(turnState, compactState);
+}
+function resolveCompactAuthorityState(turnState, compactState) {
     if (!turnState && !compactState) {
         throw new ThreadEventStoreError('ORION_THREAD_COMPACT_INVALID', 'Compact requires a durable TurnCommitV1 source');
     }
@@ -981,15 +1006,26 @@ function resolveCompactAuthority(events, compactState, threadId) {
         taskContextRevision: taskContextOwner.taskContextRevision,
     });
 }
+function readLatestDurableTurnStateFromProjection(projection) {
+    const commit = Object.values(projection.turns)
+        .map(turn => turn.commit)
+        .filter((value) => Boolean(value))
+        .sort((left, right) => left.seq - right.seq)
+        .at(-1);
+    return commit ? parseDurableTurnState(commit.receipt, commit.seq, projection.threadId) : null;
+}
 function readLatestDurableTurnState(events, threadId) {
     const event = [...events]
         .reverse()
         .find(candidate => candidate.payload.type === 'turn.committed');
     if (!event || event.payload.type !== 'turn.committed')
         return null;
+    return parseDurableTurnState(event.payload.data.receipt, event.seq, threadId);
+}
+function parseDurableTurnState(serializedReceipt, eventSeq, threadId) {
     let receipt;
     try {
-        receipt = JSON.parse(event.payload.data.receipt);
+        receipt = JSON.parse(serializedReceipt);
     }
     catch {
         throw compactCorrupt('TurnCommitV1 receipt is not valid JSON');
@@ -1022,7 +1058,7 @@ function readLatestDurableTurnState(events, threadId) {
         throw compactCorrupt('TurnCommitV1 history or TaskContext digest changed');
     }
     return deepFreeze({
-        eventSeq: event.seq,
+        eventSeq,
         history: structuredClone(history),
         historyDigest: receipt.historyDigest,
         taskContext: structuredClone(taskContext),

package/dist/runtime/thread-projection.d.ts

@@ -1,4 +1,5 @@
 import type { RuntimeEventEnvelopeV1, RuntimeEventTypeV1 } from './protocol/runtime-protocol-v1';
+import type { CompactRuntimeEventV1 } from './compact-transaction';
 export type ThreadProjectionStatusV1 = 'new' | 'active' | 'idle';
 export type TurnProjectionStatusV1 = 'active' | 'completed' | 'failed' | 'interrupted';
 export type ItemProjectionStatusV1 = 'started' | 'completed' | 'failed' | 'interrupted' | 'indeterminate';
@@ -66,6 +67,10 @@ export interface PlanReviewProjectionV1 {
     readonly feedback?: string;
     readonly feedbackDigest?: string;
 }
+export interface ThreadDiagnosticEventsV1 {
+    readonly latestCapability?: RuntimeEventEnvelopeV1;
+    readonly latestStepSnapshot?: RuntimeEventEnvelopeV1;
+}
 export interface ThreadProjectionV1 {
     readonly version: 1;
     readonly threadId: string;
@@ -76,6 +81,15 @@ export interface ThreadProjectionV1 {
     readonly items: Readonly<Record<string, ItemProjectionV1>>;
     readonly queue: readonly QueuedTurnProjectionV1[];
     readonly planReview?: PlanReviewProjectionV1;
+    /** Missing only on projections written before diagnostics became head-only. */
+    readonly diagnosticEvents?: ThreadDiagnosticEventsV1;
+    /**
+     * Compact lifecycle facts retained by new projections so fresh-process
+     * orphan recovery does not have to replay the full authoritative JSONL.
+     * Missing means a projection written by an older Orion version and forces
+     * the store to take the verified scan fallback.
+     */
+    readonly compactEvents?: readonly RuntimeEventEnvelopeV1<CompactRuntimeEventV1>[];
     readonly stepSnapshotDigests: readonly string[];
     readonly capabilityReceiptDigests: readonly string[];
     readonly toolInvocationIds: readonly string[];
@@ -91,6 +105,11 @@ interface MutableThreadProjectionV1 {
     items: Record<string, ItemProjectionV1>;
     queue: QueuedTurnProjectionV1[];
     planReview?: PlanReviewProjectionV1;
+    diagnosticEvents: {
+        latestCapability?: RuntimeEventEnvelopeV1;
+        latestStepSnapshot?: RuntimeEventEnvelopeV1;
+    };
+    compactEvents: RuntimeEventEnvelopeV1<CompactRuntimeEventV1>[];
     stepSnapshotDigests: string[];
     capabilityReceiptDigests: string[];
     toolInvocationIds: string[];

package/dist/runtime/thread-projection.js

@@ -25,6 +25,8 @@ function projectThreadEvents(threadId, events) {
         turns: {},
         items: {},
         queue: [],
+        diagnosticEvents: {},
+        compactEvents: [],
         stepSnapshotDigests: [],
         capabilityReceiptDigests: [],
         toolInvocationIds: [],
@@ -65,6 +67,10 @@ function advanceThreadProjection(projection, events) {
         items: Object.fromEntries(Object.entries(projection.items).map(([id, item]) => [id, { ...item }])),
         queue: projection.queue.map(item => ({ ...item })),
         ...(projection.planReview ? { planReview: { ...projection.planReview } } : {}),
+        diagnosticEvents: projection.diagnosticEvents
+            ? structuredClone(projection.diagnosticEvents)
+            : {},
+        compactEvents: (projection.compactEvents ?? []).map(event => structuredClone(event)),
         stepSnapshotDigests: [...projection.stepSnapshotDigests],
         capabilityReceiptDigests: [...projection.capabilityReceiptDigests],
         toolInvocationIds: [...projection.toolInvocationIds],
@@ -148,6 +154,7 @@ function applyThreadEvent(state, event) {
                 throw invariant('step snapshot already exists', event);
             }
             state.stepSnapshotDigests.push(event.payload.data.digest);
+            state.diagnosticEvents.latestStepSnapshot = structuredClone(event);
             break;
         case 'capability.receipt':
             validateCapabilityReceipt(event);
@@ -155,6 +162,7 @@ function applyThreadEvent(state, event) {
                 throw invariant('capability receipt already exists', event);
             }
             state.capabilityReceiptDigests.push(event.payload.data.digest);
+            state.diagnosticEvents.latestCapability = structuredClone(event);
             break;
         case 'tool.receipt':
             if (state.toolInvocationIds.includes(event.payload.data.invocationId)) {
@@ -165,6 +173,8 @@ function applyThreadEvent(state, event) {
         case 'compact.started':
         case 'compact.completed':
         case 'compact.failed':
+            state.compactEvents.push(structuredClone(event));
+            break;
         case 'approval.requested':
             break;
         case 'item.delta':
@@ -517,6 +527,8 @@ function freezeProjection(state) {
         ])),
         items: Object.fromEntries(Object.entries(state.items).map(([id, item]) => [id, { ...item }])),
         queue: state.queue.map(item => ({ ...item })),
+        diagnosticEvents: structuredClone(state.diagnosticEvents),
+        compactEvents: state.compactEvents.map(event => structuredClone(event)),
         stepSnapshotDigests: [...state.stepSnapshotDigests],
         capabilityReceiptDigests: [...state.capabilityReceiptDigests],
         toolInvocationIds: [...state.toolInvocationIds],

package/dist/runtime/thread-runtime.d.ts

@@ -1,6 +1,6 @@
 import { RuntimeEventBufferV1, type RuntimeEventBufferOptionsV1 } from './runtime-event-buffer';
 import { type ThreadAdmissionOptionsV1, type ThreadCommandAdmissionV1, type ThreadTurnRequestV1 } from './thread-admission';
-import { ThreadEventStore } from './thread-event-store';
+import { ThreadEventStore, type ThreadEventReplayReasonV1 } from './thread-event-store';
 import { type AgentRuntimeCommandV1, type RuntimeEventEnvelopeV1 } from './protocol/runtime-protocol-v1';
 import type { CompactPrepareSourceReceiptV1 } from './compact-transaction';
 export interface ThreadCompactCandidateDraftV1 {
@@ -143,7 +143,7 @@ export declare class ThreadRuntimeV1 {
     unsubscribe(consumerId: string): void;
     /** Observe committed durable facts without acquiring ownership of the Thread lifecycle. */
     observeCommittedEvents(listener: (events: readonly RuntimeEventEnvelopeV1[]) => void): () => void;
-    replay(cursor?: number, limit?: number): import("./thread-event-store").ThreadEventReplayV1;
+    replay(cursor?: number, limit?: number, reason?: ThreadEventReplayReasonV1): import("./thread-event-store").ThreadEventReplayV1;
     getProjection(): import("./thread-projection").ThreadProjectionV1;
     getAdmissionSnapshot(): import("./thread-admission").ThreadAdmissionSnapshotV1;
     waitForIdle(): Promise<void>;

package/dist/runtime/thread-runtime.js

@@ -252,8 +252,8 @@ class ThreadRuntimeV1 {
             throw new Error('Closed Thread runtime cannot be observed');
         return this.store.subscribeCommitted(listener);
     }
-    replay(cursor = 0, limit) {
-        return this.store.replay(cursor, limit);
+    replay(cursor = 0, limit, reason) {
+        return this.store.replay(cursor, limit, reason);
     }
     getProjection() {
         return this.store.loadProjection();