@orion-agents/orion-code 0.3.1 → 0.3.4

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

@@ -3,6 +3,7 @@ import type { LoopContinuationAction, LoopStats } from '../framework/query';
 import type { LLMService } from '../services/llm';
 import type { CompactCoordinator } from '../services/compact';
 import type { ModelCoordinator } from './model-coordinator';
+import type { SessionComposerControlServiceV1 } from './session-composer-control';
 import type { OrionCodeCLIConfig } from '../services/config';
 import type { SessionMeta, SessionTraceEvent } from '../services/session-storage';
 import type { RuntimeSubtaskEvent } from './subagents/types';
@@ -15,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';
@@ -232,9 +234,11 @@ export interface FollowupQueueItem {
     id: string;
     text: string;
     queuedAt: number;
+    /** Monotonic item-local CAS token for edit, move, and remove mutations. */
+    revision: number;
 }
 export interface FollowupQueueSnapshot {
-    items: FollowupQueueItem[];
+    items: readonly FollowupQueueItem[];
     limit: number;
 }
 export type RuntimeLoopStats = LoopStats;
@@ -276,6 +280,10 @@ export interface OrionCodeUiRuntime extends RuntimeSessionAccessors {
     llm: LLMService | null;
     compactCoordinator?: CompactCoordinator;
     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;

package/dist/services/provider-resilience/coordinator.js

@@ -14,7 +14,8 @@ const types_1 = require("./types");
 const error_classifier_1 = require("./error-classifier");
 const observability_1 = require("../../utils/observability");
 class ProviderResilienceCoordinator {
-    constructor(config) {
+    constructor(config, requestGate) {
+        this.requestGate = requestGate;
         this.config = { ...types_1.DEFAULT_PROVIDER_RESILIENCE_CONFIG, ...config };
     }
     /** Execute a logical request with full retry/fallback/recovery logic. */
@@ -51,7 +52,13 @@ class ProviderResilienceCoordinator {
             }
             const attemptRecord = this.startAttempt(ctx, attempt, diagnostics, currentModel);
             diagnostics.attempts.push(attemptRecord);
+            let gateLease;
             try {
+                gateLease = await this.requestGate?.acquire({
+                    priority: 0,
+                    providerKey: ctx.providerKey,
+                    ...(ctx.abortSignal ? { abortSignal: ctx.abortSignal } : {}),
+                });
                 const result = await transport(attempt, ctx.abortSignal, currentModel, this.createAttemptReporter(attemptRecord));
                 attemptRecord.outcome = 'succeeded';
                 attemptRecord.endedAt = Date.now();
@@ -73,6 +80,18 @@ class ProviderResilienceCoordinator {
                 attemptRecord.endedAt = Date.now();
                 attemptRecord.outcome = 'failed';
                 const classification = (0, error_classifier_1.classifyProviderError)(error, attemptRecord.semanticDeltaSeen);
+                if (classification.kind === 'aborted') {
+                    attemptRecord.outcome = 'aborted';
+                    attemptRecord.failureKind = 'aborted';
+                    attemptRecord.retryDisposition = 'fail_fast';
+                    diagnostics.finalState = 'aborted';
+                    (0, observability_1.incrementDiagnosticMetric)('provider.failure.aborted');
+                    (0, observability_1.incrementDiagnosticMetric)('provider.request.aborted');
+                    throw new ProviderRetryExhaustedError(diagnostics, 'aborted by signal', error);
+                }
+                if (classification.kind === 'rate_limit' && classification.retryAfterMs) {
+                    this.requestGate?.enterCooldown(ctx.providerKey, Date.now() + classification.retryAfterMs, `Provider rate limit; retry-after ${classification.retryAfterMs}ms`);
+                }
                 attemptRecord.failureKind = classification.kind;
                 if (attemptRecord.semanticDeltaSeen && !attemptRecord.usage) {
                     diagnostics.unknownBilledAttemptCount++;
@@ -138,6 +157,9 @@ class ProviderResilienceCoordinator {
                         throw new ProviderRetryExhaustedError(diagnostics, 'provider cooldown active', error);
                 }
             }
+            finally {
+                gateLease?.release();
+            }
         }
         diagnostics.finalState = 'retry_exhausted';
         throw new ProviderRetryExhaustedError(diagnostics, `max attempts exhausted: ${String(lastError)}`, lastError);

package/dist/services/provider-resilience/request-gate.js

@@ -8,6 +8,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderRequestGate = void 0;
+function createGateAbortError() {
+    const error = new Error('Provider request gate acquisition aborted.');
+    error.name = 'AbortError';
+    return error;
+}
 class ProviderRequestGate {
     constructor(options = {}) {
         this.activeCount = 0;
@@ -26,7 +31,7 @@ class ProviderRequestGate {
      */
     acquire(request) {
         if (request.abortSignal?.aborted) {
-            return Promise.reject(new Error('aborted'));
+            return Promise.reject(createGateAbortError());
         }
         return new Promise((resolve, reject) => {
             const waiter = { request, resolve, reject };
@@ -35,7 +40,7 @@ class ProviderRequestGate {
                     const idx = this.waiters.indexOf(waiter);
                     if (idx >= 0) {
                         this.waiters.splice(idx, 1);
-                        reject(new Error('aborted'));
+                        reject(createGateAbortError());
                         this.tryDispatch();
                     }
                     request.abortSignal?.removeEventListener('abort', onAbort);

package/dist/services/redaction.js

@@ -13,6 +13,10 @@ exports.redactTraceText = redactTraceText;
  * table-driven test is what stops the next format from silently leaking.
  */
 const SECRET_PATTERNS = [
+    // Redact URL userinfo before generic `token:` / `secret:` rules can consume
+    // only the password tail and make the complete credential boundary
+    // unrecognizable (issue #234).
+    [/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1[REDACTED_CREDENTIAL]@'],
     [
         /\b((?:GH_TOKEN|GITHUB_TOKEN|AWS_ACCESS_KEY_ID|AWS_SECRET_ACCESS_KEY|AWS_SESSION_TOKEN)\s*=\s*)(["']?)[^\s"',;]+/gi,
         '$1$2[REDACTED_SECRET]',
@@ -46,7 +50,6 @@ const SECRET_PATTERNS = [
         /(["'](?:token|client[_-]?secret|private[_-]?key|secret[_-]?key|signing[_-]?key|encryption[_-]?key|session[_-]?key|db[_-]?password|credential[_-]?value|account[_-]?key|connection[_-]?string|database[_-]?url|dsn|pwd|auth)["']\s*:\s*)(["'])(?:[^"']+)(["'])/gi,
         '$1$2[REDACTED_SECRET]$3',
     ],
-    [/\b([a-z][a-z0-9+.-]*:\/\/)[^\s/:@]+:[^\s/@]+@/gi, '$1[REDACTED_CREDENTIAL]@'],
     [
         /\b((?:OPENAI_API_KEY|DASHSCOPE_API_KEY|ANTHROPIC_API_KEY|XAI_API_KEY)\s*=\s*)(["']?)[^\s"',;]+/g,
         '$1$2[REDACTED_SECRET]',
@@ -121,6 +124,20 @@ function isSensitiveFilePath(path) {
     });
 }
 function redactTraceText(text) {
-    return SECRET_PATTERNS.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), text);
+    const labelRedacted = SECRET_PATTERNS.reduce((current, [pattern, replacement]) => current.replace(pattern, replacement), text);
+    return redactStructuredSecretFields(labelRedacted);
+}
+function redactStructuredSecretFields(text) {
+    const doubleQuoted = text.replace(/("((?:\\.|[^"\\])*)"\s*:\s*)"(?:\\.|[^"\\])*"/gu, (match, prefix, encodedKey) => {
+        let key = encodedKey;
+        try {
+            key = JSON.parse(`"${encodedKey}"`);
+        }
+        catch {
+            // Keep the literal key for JSON-like diagnostic output.
+        }
+        return isSensitiveFieldName(key) ? `${prefix}"[REDACTED_SECRET]"` : match;
+    });
+    return doubleQuoted.replace(/('((?:\\.|[^'\\])*)'\s*:\s*)'(?:\\.|[^'\\])*'/gu, (match, prefix, key) => isSensitiveFieldName(key) ? `${prefix}'[REDACTED_SECRET]'` : match);
 }
 //# sourceMappingURL=redaction.js.map

package/dist/services/session-storage.d.ts

@@ -9,6 +9,7 @@ import type { StopDecision } from '../framework/stop-decision';
 import type { Message } from './llm';
 import type { ContextUsageSnapshot } from './model-context';
 import type { EffortPreference } from './effort';
+import type { ToolConfirmationPolicy } from './global-config';
 import { type ThreadSessionRuntimeActivationV1 } from '../runtime/thread-session-view';
 import type { SessionHistoryRecoveryDiagnosticV1, SessionHistoryResolvedSourceV1 } from '../runtime/session-history-recovery';
 import { type ContextCapsule, type HarnessState, type PromptSectionManifestEntry } from '../harness';
@@ -94,6 +95,8 @@ export interface SessionMeta {
     activeGoalObjective?: string;
     /** Session-level reasoning effort preference; absent means inherit project/global/model. */
     effortPreference?: EffortPreference;
+    /** Session-level tool confirmation override; absent means inherit the Project default. */
+    toolConfirmationOverride?: ToolConfirmationPolicy;
 }
 export interface CompactCheckpointV1 {
     version: 1;
@@ -422,6 +425,33 @@ export declare function createSession(projectPath: string, model: string): Sessi
  */
 export declare function saveSessionMeta(session: SessionMeta): void;
 export declare function updateSessionEffort(sessionId: string, effortPreference: EffortPreference | undefined): SessionMeta | null;
+export interface SessionComposerPreferencesV1 {
+    readonly model: string;
+    readonly effortPreference?: EffortPreference;
+    readonly toolConfirmationOverride?: ToolConfirmationPolicy;
+}
+export interface SessionComposerPreferencesPatchV1 {
+    readonly expected?: SessionComposerPreferencesV1;
+    readonly model?: string;
+    readonly effort?: {
+        readonly value: EffortPreference | undefined;
+    };
+    readonly permission?: {
+        readonly value: ToolConfirmationPolicy | undefined;
+    };
+}
+export declare class SessionComposerPreferencesConflictError extends Error {
+    readonly code = "ORION_SESSION_COMPOSER_CONFLICT";
+    constructor(message?: string);
+}
+/**
+ * Atomically update all Session-scoped Composer preferences under the metadata lock.
+ *
+ * The optional expected projection prevents Web and slash-command writers from
+ * replacing a newer model, effort, or permission override with a stale snapshot.
+ */
+export declare function updateSessionComposerPreferences(sessionId: string, patch: SessionComposerPreferencesPatchV1): SessionMeta | null;
+export declare function projectSessionComposerPreferences(session: SessionMeta): SessionComposerPreferencesV1;
 /** Persist the model selected for one Session without replacing unrelated metadata. */
 export declare function updateSessionModel(sessionId: string, model: string): SessionMeta | null;
 export interface SessionThreadReadModelV1 {
@@ -579,6 +609,12 @@ export declare function loadSessionRestoreBundle(sessionId: string): SessionRest
  * 列出所有会话
  */
 export declare function listSessions(limit?: number): SessionMeta[];
+/**
+ * Count catalogued Sessions by their canonical project identity without
+ * sorting or touching every project directory. This is the lightweight read
+ * model used by project pickers and other collection summaries.
+ */
+export declare function countSessionsByProject(): ReadonlyMap<string, number>;
 /**
  * List sessions for a single canonical project.
  */