@orion-agents/orion-code 0.3.2 → 0.3.4

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

@@ -1,7 +1,15 @@
 import type { Message } from '../services/llm';
 import type { RuntimeEventEnvelopeV1 } from './protocol/runtime-protocol-v1';
 import type { ThreadLogIdentityV1 } from './thread-event-store';
-import type { ItemProjectionV1, ThreadProjectionV1 } from './thread-projection';
+import type { ItemProjectionV1, PlanReviewProjectionV1, ThreadProjectionV1, TurnProjectionStatusV1 } from './thread-projection';
+export interface ThreadSessionIndexPerformanceCountersV1 {
+    readonly indexBuilds: number;
+    readonly manifestReads: number;
+    readonly pageReads: number;
+    readonly bytesRead: number;
+}
+/** Process-local monotonic derived-index counters for Web performance evidence. */
+export declare function threadSessionIndexPerformanceCountersV1(): ThreadSessionIndexPerformanceCountersV1;
 export interface ThreadSessionTranscriptMessageV1 {
     readonly role: Message['role'];
     readonly content: string;
@@ -15,6 +23,12 @@ export interface ThreadSessionTurnCommitV1 {
     readonly seq: number;
     readonly receipt: string;
 }
+export interface ThreadSessionLatestTurnV1 {
+    readonly turnId: string;
+    readonly status: TurnProjectionStatusV1;
+    readonly startedSeq: number;
+    readonly terminalSeq?: number;
+}
 export interface ThreadSessionIndexHeadV1 {
     readonly cursor: number;
     readonly projectionDigest: string;
@@ -41,8 +55,10 @@ export interface ThreadSessionIndexManifestV1 {
     readonly updatedAt: number;
     readonly messageCount: number;
     readonly pages: readonly StoredTranscriptPagePointerV1[];
+    readonly latestTurn?: ThreadSessionLatestTurnV1;
     readonly latestTurnCommit?: ThreadSessionTurnCommitV1;
     readonly latestPlanTurnCommit?: ThreadSessionTurnCommitV1;
+    readonly planReview?: PlanReviewProjectionV1;
     readonly digest: string;
 }
 export interface ThreadSessionIndexedPageV1 {

package/dist/runtime/thread-session-index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThreadSessionIndexError = void 0;
+exports.threadSessionIndexPerformanceCountersV1 = threadSessionIndexPerformanceCountersV1;
 exports.buildThreadSessionIndexV1 = buildThreadSessionIndexV1;
 exports.advanceThreadSessionIndexV1 = advanceThreadSessionIndexV1;
 exports.loadThreadSessionIndexManifestV1 = loadThreadSessionIndexManifestV1;
@@ -12,6 +13,16 @@ const atomic_write_1 = require("../services/atomic-write");
 const canonical_1 = require("./protocol/canonical");
 const TRANSCRIPT_PAGE_ITEMS = 100;
 const MAX_MANIFEST_PAGES = 100000;
+const threadSessionIndexPerformance = {
+    indexBuilds: 0,
+    manifestReads: 0,
+    pageReads: 0,
+    bytesRead: 0,
+};
+/** Process-local monotonic derived-index counters for Web performance evidence. */
+function threadSessionIndexPerformanceCountersV1() {
+    return Object.freeze({ ...threadSessionIndexPerformance });
+}
 class ThreadSessionIndexError extends Error {
     constructor(code, message) {
         super(message);
@@ -21,6 +32,7 @@ class ThreadSessionIndexError extends Error {
 }
 exports.ThreadSessionIndexError = ThreadSessionIndexError;
 function buildThreadSessionIndexV1(input) {
+    threadSessionIndexPerformance.indexBuilds += 1;
     const previous = readManifest(manifestPath(input.rootDir, input.threadId), input.threadId);
     const messages = projectTranscriptMessages(input.projection.items, input.events);
     const pages = [];
@@ -36,6 +48,7 @@ function buildThreadSessionIndexV1(input) {
         updatedAt: input.events.at(-1)?.timestamp ?? 0,
         messageCount: messages.length,
         pages,
+        ...(input.projection.planReview ? { planReview: input.projection.planReview } : {}),
         ...commits,
     });
     writeManifest(input.rootDir, manifest);
@@ -63,7 +76,22 @@ function advanceThreadSessionIndexV1(input) {
     }
     const pages = [...current.pages];
     let messageCount = current.messageCount;
-    for (let start = 0; start < messages.length; start += TRANSCRIPT_PAGE_ITEMS) {
+    let messageOffset = 0;
+    const partialTail = pages.at(-1);
+    if (partialTail &&
+        partialTail.end === messageCount &&
+        partialTail.end - partialTail.start < TRANSCRIPT_PAGE_ITEMS &&
+        messages.length > 0) {
+        const existing = readPage(input.rootDir, input.threadId, partialTail);
+        const appended = messages.slice(0, Math.min(messages.length, TRANSCRIPT_PAGE_ITEMS - existing.items.length));
+        pages[pages.length - 1] = writeImmutablePage(input.rootDir, input.threadId, partialTail.start, [
+            ...existing.items,
+            ...appended,
+        ]);
+        messageOffset = appended.length;
+        messageCount += appended.length;
+    }
+    for (let start = messageOffset; start < messages.length; start += TRANSCRIPT_PAGE_ITEMS) {
         const chunk = messages.slice(start, start + TRANSCRIPT_PAGE_ITEMS);
         pages.push(writeImmutablePage(input.rootDir, input.threadId, messageCount, chunk));
         messageCount += chunk.length;
@@ -77,8 +105,10 @@ function advanceThreadSessionIndexV1(input) {
         updatedAt: input.nextHead.lastEventTimestamp,
         messageCount,
         pages,
+        ...(nextCommits.latestTurn ? { latestTurn: nextCommits.latestTurn } : {}),
         latestTurnCommit: nextCommits.latestTurnCommit ?? current.latestTurnCommit,
         latestPlanTurnCommit: nextCommits.latestPlanTurnCommit ?? current.latestPlanTurnCommit,
+        ...(input.projection.planReview ? { planReview: input.projection.planReview } : {}),
     });
     writeManifest(input.rootDir, manifest);
     return true;
@@ -155,10 +185,12 @@ function createManifest(input) {
         updatedAt: input.updatedAt,
         messageCount: input.messageCount,
         pages: input.pages.map(page => ({ ...page })),
+        ...(input.latestTurn ? { latestTurn: { ...input.latestTurn } } : {}),
         ...(input.latestTurnCommit ? { latestTurnCommit: { ...input.latestTurnCommit } } : {}),
         ...(input.latestPlanTurnCommit
             ? { latestPlanTurnCommit: { ...input.latestPlanTurnCommit } }
             : {}),
+        ...(input.planReview ? { planReview: { ...input.planReview } } : {}),
     };
     return deepFreeze({ ...content, digest: (0, canonical_1.digestRuntimeValue)(content) });
 }
@@ -168,7 +200,9 @@ function latestAuthorityCommits(projection, events) {
             .filter(event => event.payload.type === 'turn.committed' && event.turnId)
             .map(event => event.turnId))
         : undefined;
-    const commits = Object.values(projection.turns)
+    const orderedTurns = Object.values(projection.turns).sort((left, right) => left.startedSeq - right.startedSeq);
+    const latestTurnProjection = orderedTurns.at(-1);
+    const commits = orderedTurns
         .filter(turn => !committedTurns || committedTurns.has(turn.turnId))
         .flatMap(turn => (turn.commit ? [{ seq: turn.commit.seq, receipt: turn.commit.receipt }] : []))
         .sort((left, right) => left.seq - right.seq);
@@ -177,6 +211,18 @@ function latestAuthorityCommits(projection, events) {
         .reverse()
         .find(commit => turnCommitContainsPlan(commit.receipt));
     return {
+        ...(latestTurnProjection
+            ? {
+                latestTurn: {
+                    turnId: latestTurnProjection.turnId,
+                    status: latestTurnProjection.status,
+                    startedSeq: latestTurnProjection.startedSeq,
+                    ...(latestTurnProjection.terminalSeq !== undefined
+                        ? { terminalSeq: latestTurnProjection.terminalSeq }
+                        : {}),
+                },
+            }
+            : {}),
         ...(latestTurnCommit ? { latestTurnCommit } : {}),
         ...(latestPlanTurnCommit ? { latestPlanTurnCommit } : {}),
     };
@@ -208,7 +254,7 @@ function writeManifest(rootDir, manifest) {
     fsyncDirectory(rootDir);
 }
 function readManifest(path, threadId) {
-    const value = readRegularJson(path);
+    const value = readRegularJson(path, 'manifest');
     if (!isRecord(value))
         return null;
     const { digest: _digest, ...content } = value;
@@ -238,13 +284,44 @@ function readManifest(path, threadId) {
     }
     if (nextStart !== value.messageCount)
         return null;
+    if (value.latestTurn !== undefined && !isLatestTurn(value.latestTurn))
+        return null;
     if (value.latestTurnCommit !== undefined && !isTurnCommit(value.latestTurnCommit))
         return null;
     if (value.latestPlanTurnCommit !== undefined && !isTurnCommit(value.latestPlanTurnCommit)) {
         return null;
     }
+    if (value.planReview !== undefined && !isPlanReview(value.planReview))
+        return null;
     return deepFreeze(value);
 }
+function isPlanReview(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.reviewId === 'string' &&
+        value.reviewId.length > 0 &&
+        typeof value.revision === 'string' &&
+        value.revision.length > 0 &&
+        isSha256(value.planDigest) &&
+        isSha256(value.planReceiptDigest) &&
+        ['awaiting_review', 'approved', 'continued', 'cancelled'].includes(String(value.status)) &&
+        nonNegativeSafeInteger(value.createdAt) &&
+        typeof value.createdModel === 'string' &&
+        value.createdModel.length > 0 &&
+        ['build', 'auto'].includes(String(value.returnMode)) &&
+        positiveSafeInteger(value.requestedSeq) &&
+        (value.resolvedAt === undefined || nonNegativeSafeInteger(value.resolvedAt)) &&
+        (value.resolvedSeq === undefined || positiveSafeInteger(value.resolvedSeq)) &&
+        (value.feedback === undefined || typeof value.feedback === 'string') &&
+        (value.feedbackDigest === undefined || isSha256(value.feedbackDigest)));
+}
+function isLatestTurn(value) {
+    return (isRecord(value) &&
+        typeof value.turnId === 'string' &&
+        ['active', 'completed', 'failed', 'interrupted'].includes(String(value.status)) &&
+        positiveSafeInteger(value.startedSeq) &&
+        (value.terminalSeq === undefined || positiveSafeInteger(value.terminalSeq)));
+}
 function readPage(rootDir, threadId, pointer) {
     if ((0, path_1.basename)(pointer.file) !== pointer.file)
         throw indexCorrupt('Transcript page path escaped.');
@@ -258,7 +335,7 @@ function readPage(rootDir, threadId, pointer) {
     return page;
 }
 function readStoredPage(path, threadId) {
-    const value = readRegularJson(path);
+    const value = readRegularJson(path, 'page');
     if (!isRecord(value))
         return null;
     const { digest: _digest, ...content } = value;
@@ -435,13 +512,19 @@ function isItemTerminalEvent(event) {
 function isMessageRole(value) {
     return value === 'system' || value === 'user' || value === 'assistant' || value === 'tool';
 }
-function readRegularJson(path) {
+function readRegularJson(path, kind) {
     let fd;
     try {
         fd = (0, fs_1.openSync)(path, fs_1.constants.O_RDONLY | (typeof fs_1.constants.O_NOFOLLOW === 'number' ? fs_1.constants.O_NOFOLLOW : 0));
         if (!(0, fs_1.fstatSync)(fd).isFile())
             return undefined;
-        return JSON.parse((0, fs_1.readFileSync)(fd, 'utf8'));
+        const bytes = (0, fs_1.readFileSync)(fd);
+        threadSessionIndexPerformance.bytesRead += bytes.byteLength;
+        if (kind === 'manifest')
+            threadSessionIndexPerformance.manifestReads += 1;
+        else
+            threadSessionIndexPerformance.pageReads += 1;
+        return JSON.parse(bytes.toString('utf8'));
     }
     catch {
         return undefined;

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

@@ -1,7 +1,8 @@
 import type { Message } from '../services/llm';
 import { type SessionHistoryRecoveryDiagnosticV1, type SessionHistoryResolvedSourceV1 } from './session-history-recovery';
 import { ThreadEventStore, type ThreadReadModelHeadV1 } from './thread-event-store';
-import { type ThreadSessionTranscriptMessageV1, type ThreadSessionTurnCommitV1 } from './thread-session-index';
+import { type ThreadSessionLatestTurnV1, type ThreadSessionTranscriptMessageV1, type ThreadSessionTurnCommitV1 } from './thread-session-index';
+import type { PlanReviewProjectionV1 } from './thread-projection';
 export type { ThreadSessionTranscriptMessageV1, ThreadSessionTurnCommitV1, } from './thread-session-index';
 /** Metadata/transcript projection that never needs to decode model history. */
 export interface ThreadSessionSummaryV1 {
@@ -72,8 +73,10 @@ export interface ThreadSessionSnapshotPageV1 {
         readonly lastRecordHash: string | null;
         readonly log: ThreadReadModelHeadV1['log'];
     };
+    readonly latestTurn?: ThreadSessionLatestTurnV1;
     readonly latestTurnCommit?: ThreadSessionTurnCommitV1;
     readonly latestPlanTurnCommit?: ThreadSessionTurnCommitV1;
+    readonly planReview?: PlanReviewProjectionV1;
 }
 export declare class ThreadSessionViewError extends Error {
     readonly code = "ORION_THREAD_SESSION_VIEW_INVALID";

package/dist/runtime/thread-session-view.js

@@ -119,7 +119,8 @@ function loadThreadSessionSnapshotPageV1(projectPath, sessionId, cursor, pageSiz
             }
         }
         catch (error) {
-            if (!(error instanceof thread_session_index_1.ThreadSessionIndexError) || error.code !== 'ORION_THREAD_SESSION_INDEX_CORRUPT') {
+            if (!(error instanceof thread_session_index_1.ThreadSessionIndexError) ||
+                error.code !== 'ORION_THREAD_SESSION_INDEX_CORRUPT') {
                 throw error;
             }
         }
@@ -268,10 +269,12 @@ function snapshotPageFromIndex(sessionId, cutoverGeneration, page) {
             lastRecordHash: manifest.lastRecordHash,
             log: manifest.log,
         },
+        ...(manifest.latestTurn ? { latestTurn: manifest.latestTurn } : {}),
         ...(manifest.latestTurnCommit ? { latestTurnCommit: manifest.latestTurnCommit } : {}),
         ...(manifest.latestPlanTurnCommit
             ? { latestPlanTurnCommit: manifest.latestPlanTurnCommit }
             : {}),
+        ...(manifest.planReview ? { planReview: manifest.planReview } : {}),
     });
 }
 function captureStableThreadView(store, minimumCursor, minimumProjectionDigest, includeDurableHistory) {
@@ -301,7 +304,7 @@ function replayAll(store, cursor) {
     const events = [];
     let nextCursor = 0;
     while (nextCursor < cursor) {
-        const replay = store.replay(nextCursor);
+        const replay = store.replay(nextCursor, undefined, 'thread_session_view');
         const page = replay.events.filter(event => event.seq <= cursor);
         if (page.length === 0) {
             throw new ThreadSessionViewError(`Thread ${store.threadId} replay stopped at ${nextCursor}/${cursor}.`);

package/dist/runtime/thread-ui-adapter.js

@@ -141,7 +141,7 @@ class ThreadUiAdapterV1 {
     }
     replayInitialHistory() {
         while (this.cursorValue < this.initialReplayTarget) {
-            const replay = this.runtime.replay(this.cursorValue);
+            const replay = this.runtime.replay(this.cursorValue, undefined, 'ui_initial_history');
             const events = replay.events.filter(event => event.seq <= this.initialReplayTarget);
             if (events.length === 0) {
                 throw new ThreadUiAdapterError(`Thread replay stalled at cursor ${this.cursorValue} before ${this.initialReplayTarget}.`);
@@ -157,7 +157,7 @@ class ThreadUiAdapterV1 {
             throw new ThreadUiAdapterError(`Replay cursor ${fromCursor} differs from projected cursor ${this.cursorValue}.`);
         }
         while (true) {
-            const replay = this.runtime.replay(this.cursorValue);
+            const replay = this.runtime.replay(this.cursorValue, undefined, 'ui_gap_recovery');
             for (const event of replay.events) {
                 this.project(event);
                 this.cursorValue = event.seq;
@@ -380,7 +380,14 @@ class ThreadUiAdapterV1 {
         if (isToolItem(presentation.kind)) {
             const durableReceiptFact = this.toolReceiptFacts.get(presentation.itemId);
             let receipt;
-            if (terminal.receipt && durableReceiptFact) {
+            const hasTerminalReceipt = terminal.receipt !== undefined;
+            const hasDurableReceiptFact = durableReceiptFact !== undefined;
+            if (hasTerminalReceipt !== hasDurableReceiptFact) {
+                throw new ThreadUiAdapterError(hasTerminalReceipt
+                    ? `Tool item ${presentation.itemId} has a canonical receipt without its durable receipt fact.`
+                    : `Tool item ${presentation.itemId} has a durable receipt fact without its canonical terminal receipt.`);
+            }
+            if (hasTerminalReceipt && durableReceiptFact) {
                 try {
                     receipt = (0, tool_receipt_validator_1.validateDurableToolInvocationReceiptV1)({
                         terminalEvent: event,

package/dist/runtime/tool-gateway.js

@@ -142,6 +142,7 @@ class ToolGateway {
                         }),
                     })
                     : await this.services.execution.run({
+                        invocationId: invocation.invocationId,
                         snapshot: invocation.snapshot,
                         toolName: invocation.toolName,
                         args: structuredClone(invocation.args),

package/dist/runtime/turn-commit.js

@@ -43,7 +43,7 @@ class ThreadTurnCommitJournalV1 {
         const receiptEvents = [];
         let cursor = 0;
         while (true) {
-            const page = this.store.replay(cursor);
+            const page = this.store.replay(cursor, undefined, 'turn_commit_journal');
             receiptEvents.push(...page.events.filter(event => event.turnId === input.turnId));
             if (!page.hasMore)
                 break;

package/dist/runtime/ui-events.d.ts

@@ -16,6 +16,7 @@ import type { EffortLevel, EffortPreference, EffortScope } from '../services/eff
 import type { AgentRuntimeRunnerV1 } from './agent-runtime-runner';
 import type { FirstPartyApprovalHandlerV1 } from './first-party-tool-services';
 import type { OrionRuntimeDiagnosticsV1 } from './orion-runtime-v1';
+import type { WorkspaceRuntimeKernelV1 } from './workspace-runtime-kernel';
 import type { SettingsCoordinatorV1, SettingsDocumentViewV1, SettingsOperationV1, SettingsUpdateResultV1 } from '../services/settings-coordinator';
 /** Re-export so the runtime event protocol can reference subtask events. */
 export type { RuntimeSubtaskEvent } from './subagents/types';
@@ -281,6 +282,8 @@ export interface OrionCodeUiRuntime extends RuntimeSessionAccessors {
     modelCoordinator?: ModelCoordinator;
     /** Sole Session-scoped mode/model/effort/permission control authority. */
     sessionComposerControls?: SessionComposerControlServiceV1;
+    /** Workspace-scoped services shared by Web Session actors. */
+    workspaceRuntimeKernel?: WorkspaceRuntimeKernelV1;
     /** Creates the sole product runner after a renderer-neutral event sink exists. */
     createAgentRunner?: (events: UiEventSink, options: {
         readonly approvalHandler: FirstPartyApprovalHandlerV1;

package/dist/runtime/workspace-runtime-kernel.d.ts

@@ -0,0 +1,67 @@
+import type { OrionCodeCLIConfig } from '../services/config';
+import { ProviderRequestGate, ProviderResilienceCoordinator } from '../services/provider-resilience';
+import { SettingsCoordinatorV1, type SettingsInvalidationV1, type SettingsUpdateContextV1 } from '../services/settings-coordinator';
+import type { ProductionFirstPartyToolUniverseV1 } from './first-party-tool-universe';
+import type { FirstPartyMcpAdapterV1 } from './mcp';
+import type { FilesystemSkillProviderV1 } from './skills';
+export interface WorkspaceSettingsRuntimeParticipantV1 {
+    readonly runtimeIdle: () => boolean;
+    readonly runtimePrepare: (context: Omit<SettingsUpdateContextV1, 'document'>) => void | Promise<void>;
+    /**
+     * Apply one committed Settings document and return an exact in-memory
+     * compensation. The kernel invokes compensations in reverse order when a
+     * later participant rejects, before the coordinator restores durable bytes.
+     */
+    readonly runtimeApply: (context: SettingsUpdateContextV1) => void | (() => void | Promise<void>) | Promise<void | (() => void | Promise<void>)>;
+}
+export interface WorkspaceRuntimeKernelOptionsV1 {
+    readonly cwd: string;
+    readonly config: OrionCodeCLIConfig;
+    readonly toolUniverse: ProductionFirstPartyToolUniverseV1;
+    readonly skillProvider: FilesystemSkillProviderV1;
+    readonly mcpAdapter: FirstPartyMcpAdapterV1;
+    readonly onSettingsInvalidated?: (event: SettingsInvalidationV1) => void;
+    readonly providerRequestGate?: ProviderRequestGate;
+    readonly providerResilience?: ProviderResilienceCoordinator;
+}
+export interface WorkspaceRuntimeKernelDiagnosticsV1 {
+    readonly participantCount: number;
+    readonly ownerReleased: boolean;
+    readonly closed: boolean;
+    readonly providerGate: ReturnType<ProviderRequestGate['snapshot']>;
+}
+/**
+ * Workspace-owned services shared by every Web Session actor.
+ *
+ * Session runtimes still own mutable Store/LLM/Thread/controller state. This
+ * kernel owns only workspace-scoped, concurrency-safe resources: the parsed
+ * model/client configuration, static Tool and MCP descriptors, the filesystem
+ * Skill provider, one Settings coordinator/watcher, and one provider request
+ * gate/cooldown domain.
+ */
+export declare class WorkspaceRuntimeKernelV1 {
+    readonly version: 1;
+    readonly cwd: string;
+    readonly toolUniverse: ProductionFirstPartyToolUniverseV1;
+    readonly skillProvider: FilesystemSkillProviderV1;
+    readonly mcpAdapter: FirstPartyMcpAdapterV1;
+    readonly providerRequestGate: ProviderRequestGate;
+    readonly providerResilience: ProviderResilienceCoordinator;
+    readonly settingsCoordinator: SettingsCoordinatorV1;
+    private readonly configSnapshot;
+    private readonly participants;
+    private ownerReleasedValue;
+    private closedValue;
+    constructor(options: WorkspaceRuntimeKernelOptionsV1);
+    createRuntimeConfig(): OrionCodeCLIConfig;
+    registerSettingsRuntime(participant: WorkspaceSettingsRuntimeParticipantV1): () => void;
+    runtimeIdle(): boolean;
+    diagnostics(): WorkspaceRuntimeKernelDiagnosticsV1;
+    /** Release the sole workspace owner; final close waits for actor teardown. */
+    releaseOwner(): void;
+    private prepareParticipants;
+    private applyParticipants;
+    private closeWhenUnowned;
+    private assertOpen;
+}
+//# sourceMappingURL=workspace-runtime-kernel.d.ts.map

package/dist/runtime/workspace-runtime-kernel.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceRuntimeKernelV1 = void 0;
+const path_1 = require("path");
+const provider_resilience_1 = require("../services/provider-resilience");
+const settings_coordinator_1 = require("../services/settings-coordinator");
+/**
+ * Workspace-owned services shared by every Web Session actor.
+ *
+ * Session runtimes still own mutable Store/LLM/Thread/controller state. This
+ * kernel owns only workspace-scoped, concurrency-safe resources: the parsed
+ * model/client configuration, static Tool and MCP descriptors, the filesystem
+ * Skill provider, one Settings coordinator/watcher, and one provider request
+ * gate/cooldown domain.
+ */
+class WorkspaceRuntimeKernelV1 {
+    constructor(options) {
+        this.version = 1;
+        this.participants = new Set();
+        this.ownerReleasedValue = false;
+        this.closedValue = false;
+        // The composition root owns canonical workspace identity. Resolving
+        // lexical segments here is safe; realpath re-keying (/var -> /private/var
+        // on macOS) would diverge from the durable project Settings key.
+        this.cwd = (0, path_1.resolve)(options.cwd);
+        this.configSnapshot = cloneRuntimeConfig(options.config);
+        this.toolUniverse = options.toolUniverse;
+        this.skillProvider = options.skillProvider;
+        this.mcpAdapter = options.mcpAdapter;
+        this.providerRequestGate = options.providerRequestGate ?? new provider_resilience_1.ProviderRequestGate();
+        this.providerResilience =
+            options.providerResilience ??
+                new provider_resilience_1.ProviderResilienceCoordinator(undefined, this.providerRequestGate);
+        this.settingsCoordinator = settings_coordinator_1.SettingsCoordinatorV1.create({
+            workspace: this.cwd,
+            onInvalidated: options.onSettingsInvalidated,
+            models: options.config.modelRegistry?.enabledProfiles.map(profile => ({
+                id: profile.id,
+                label: profile.displayName ?? profile.id,
+                provider: profile.provider,
+            })),
+            internalDefaultModel: 'gpt-4o',
+            modelDefaultEffort: 'auto',
+            internalToolConfirmation: 'allow',
+            runtimeIdle: () => this.runtimeIdle(),
+            runtimePrepare: context => this.prepareParticipants(context),
+            runtimeApply: context => this.applyParticipants(context),
+        });
+    }
+    createRuntimeConfig() {
+        this.assertOpen();
+        return cloneRuntimeConfig(this.configSnapshot);
+    }
+    registerSettingsRuntime(participant) {
+        this.assertOpen();
+        if (this.ownerReleasedValue) {
+            throw new Error('Workspace Runtime kernel owner has already been released.');
+        }
+        this.participants.add(participant);
+        let disposed = false;
+        return () => {
+            if (disposed)
+                return;
+            disposed = true;
+            this.participants.delete(participant);
+            this.closeWhenUnowned();
+        };
+    }
+    runtimeIdle() {
+        for (const participant of this.participants) {
+            if (!participant.runtimeIdle())
+                return false;
+        }
+        return true;
+    }
+    diagnostics() {
+        return Object.freeze({
+            participantCount: this.participants.size,
+            ownerReleased: this.ownerReleasedValue,
+            closed: this.closedValue,
+            providerGate: Object.freeze({ ...this.providerRequestGate.snapshot() }),
+        });
+    }
+    /** Release the sole workspace owner; final close waits for actor teardown. */
+    releaseOwner() {
+        if (this.ownerReleasedValue)
+            return;
+        this.ownerReleasedValue = true;
+        this.closeWhenUnowned();
+    }
+    async prepareParticipants(context) {
+        for (const participant of [...this.participants]) {
+            await participant.runtimePrepare(context);
+        }
+    }
+    async applyParticipants(context) {
+        const compensations = [];
+        try {
+            for (const participant of [...this.participants]) {
+                const compensate = await participant.runtimeApply(context);
+                if (typeof compensate === 'function')
+                    compensations.push(compensate);
+            }
+        }
+        catch (error) {
+            let compensationFailed = false;
+            for (const compensate of compensations.reverse()) {
+                try {
+                    await compensate();
+                }
+                catch {
+                    compensationFailed = true;
+                }
+            }
+            if (compensationFailed) {
+                throw new settings_coordinator_1.SettingsCoordinatorError(503, 'settings_recovery_required', 'One or more Session runtimes could not restore their previous Settings state.');
+            }
+            throw error;
+        }
+    }
+    closeWhenUnowned() {
+        if (this.closedValue || !this.ownerReleasedValue || this.participants.size > 0) {
+            return;
+        }
+        this.closedValue = true;
+        this.settingsCoordinator.close();
+    }
+    assertOpen() {
+        if (this.closedValue)
+            throw new Error('Workspace Runtime kernel is closed.');
+    }
+}
+exports.WorkspaceRuntimeKernelV1 = WorkspaceRuntimeKernelV1;
+function cloneRuntimeConfig(config) {
+    return {
+        ...config,
+        ...(config.ui ? { ui: { ...config.ui } } : {}),
+        ...(config.skills
+            ? {
+                skills: {
+                    ...config.skills,
+                    ...(config.skills.paths ? { paths: [...config.skills.paths] } : {}),
+                },
+            }
+            : {}),
+    };
+}
+//# sourceMappingURL=workspace-runtime-kernel.js.map

package/dist/services/global-config.d.ts

@@ -33,7 +33,9 @@ export interface ProjectConfig {
 /** How to handle tool permission checks that request interactive confirmation. */
 export type ToolConfirmationPolicy = 'ask' | 'allow' | 'deny';
 /** Browser appearance preferences persisted in the canonical global document. */
+export type WebUiStylePreferenceV1 = 'classic' | 'orion-blocksmith';
 export interface WebAppearanceConfigV1 {
+    style?: WebUiStylePreferenceV1;
     theme?: 'system' | 'light' | 'dark';
     motion?: 'system' | 'reduced';
 }

package/dist/services/global-config.js

@@ -165,7 +165,10 @@ function validateGlobalConfigDocumentStrict(value) {
         if (value.web.appearance !== undefined) {
             if (!isRecord(value.web.appearance))
                 invalidField('web.appearance');
-            const { theme, motion } = value.web.appearance;
+            const { style, theme, motion } = value.web.appearance;
+            if (style !== undefined && style !== 'classic' && style !== 'orion-blocksmith') {
+                invalidField('web.appearance.style');
+            }
             if (theme !== undefined && theme !== 'system' && theme !== 'light' && theme !== 'dark') {
                 invalidField('web.appearance.theme');
             }
@@ -442,6 +445,9 @@ function sanitizeWebConfig(value) {
     const sanitized = { ...raw };
     if (raw.appearance && typeof raw.appearance === 'object' && !Array.isArray(raw.appearance)) {
         const appearance = { ...raw.appearance };
+        if (appearance.style !== 'classic' && appearance.style !== 'orion-blocksmith') {
+            delete appearance.style;
+        }
         if (appearance.theme !== 'system' &&
             appearance.theme !== 'light' &&
             appearance.theme !== 'dark') {

package/dist/services/provider-resilience/coordinator.d.ts

@@ -6,9 +6,11 @@
  * through this coordinator.
  */
 import type { ProviderRequestContext, ProviderRequestDiagnosticsV2, ProviderResilienceConfig, ProviderAttemptReporter } from './types';
+import type { ProviderRequestGate } from './request-gate';
 export declare class ProviderResilienceCoordinator {
+    private readonly requestGate?;
     private readonly config;
-    constructor(config?: Partial<ProviderResilienceConfig>);
+    constructor(config?: Partial<ProviderResilienceConfig>, requestGate?: ProviderRequestGate | undefined);
     /** Execute a logical request with full retry/fallback/recovery logic. */
     execute<T>(ctx: ProviderRequestContext, transport: (attempt: number, signal?: AbortSignal, model?: string, reporter?: ProviderAttemptReporter) => Promise<{
         response: T;