@orion-agents/orion-code 0.3.2 → 0.3.4

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/settings-coordinator.d.ts

@@ -9,6 +9,7 @@ export type SettingsAppliesV1 = 'live' | 'next-logical-request' | 'new-session'
 export type SettingsStateV1 = 'ready' | 'invalid' | 'read-only' | 'unavailable';
 export type SettingsThemeV1 = 'system' | 'light' | 'dark';
 export type SettingsMotionV1 = 'system' | 'reduced';
+export type SettingsUiStyleV1 = 'classic' | 'orion-blocksmith';
 export interface SettingsFieldViewV1<T> {
     readonly effectiveValue: T;
     readonly explicitValue?: T;
@@ -38,7 +39,7 @@ export interface SettingsCurrentSessionV1 {
 }
 /** Secret-free settings description suitable for direct Web protocol projection. */
 export interface SettingsDocumentViewV1 {
-    readonly schemaVersion: 1;
+    readonly schemaVersion: 2;
     readonly revision: string;
     readonly state: SettingsStateV1;
     readonly writable: boolean;
@@ -46,6 +47,7 @@ export interface SettingsDocumentViewV1 {
     readonly workspace: string;
     readonly sections: {
         readonly appearance: {
+            readonly style: SettingsFieldViewV1<SettingsUiStyleV1>;
             readonly theme: SettingsFieldViewV1<SettingsThemeV1>;
             readonly motion: SettingsFieldViewV1<SettingsMotionV1>;
         };

package/dist/services/settings-coordinator.js

@@ -51,6 +51,9 @@ function controlledState(snapshot, workspace) {
     const appearance = getRecord(getRecord(document, 'web'), 'appearance');
     const project = getRecord(getRecord(document, 'projects'), workspace);
     return Object.freeze({
+        ...(getString(appearance, 'style')
+            ? { style: getString(appearance, 'style') }
+            : {}),
         ...(getString(appearance, 'theme')
             ? { theme: getString(appearance, 'theme') }
             : {}),
@@ -75,6 +78,11 @@ function controlledState(snapshot, workspace) {
 }
 function controlledDiff(before, after) {
     const operations = [];
+    if (before.style !== after.style) {
+        operations.push(after.style
+            ? { op: 'set', key: 'appearance.style', value: after.style }
+            : { op: 'unset', key: 'appearance.style' });
+    }
     if (before.theme !== after.theme) {
         operations.push(after.theme
             ? { op: 'set', key: 'appearance.theme', value: after.theme }
@@ -270,6 +278,7 @@ class SettingsCoordinatorV1 {
         const appearance = getRecord(web, 'appearance');
         const projects = getRecord(document, 'projects');
         const project = getRecord(projects, this.workspace);
+        const explicitStyle = getString(appearance, 'style');
         const explicitTheme = getString(appearance, 'theme');
         const explicitMotion = getString(appearance, 'motion');
         const explicitModel = getString(document, 'defaultModel');
@@ -306,7 +315,7 @@ class SettingsCoordinatorV1 {
             })
             : snapshot.diagnostic;
         return deepFreeze({
-            schemaVersion: 1,
+            schemaVersion: 2,
             revision: snapshot.revision,
             state,
             writable: storageWritable,
@@ -314,6 +323,18 @@ class SettingsCoordinatorV1 {
             workspace: this.workspace,
             sections: {
                 appearance: {
+                    style: {
+                        effectiveValue: explicitStyle ?? 'orion-blocksmith',
+                        ...(explicitStyle
+                            ? { explicitValue: explicitStyle }
+                            : { inheritedValue: 'orion-blocksmith' }),
+                        source: explicitStyle ? 'global' : 'internal',
+                        scope: 'global',
+                        applies: 'live',
+                        overridden: false,
+                        writable: storageWritable,
+                        ...(generalBlocked ? { blockedReason: generalBlocked } : {}),
+                    },
                     theme: {
                         effectiveValue: explicitTheme ?? 'system',
                         ...(explicitTheme
@@ -532,19 +553,30 @@ class SettingsCoordinatorV1 {
                 const apply = input.runtimeApply ?? this.runtimeApply;
                 await apply?.({ before, document, operations: input.operations });
             }
-            catch {
+            catch (applyError) {
+                let restored;
                 try {
-                    const restored = this.repository.rollback(persisted.rollbackToken);
-                    this.emitInvalidation({
-                        revision: restored.revision,
-                        reason: 'local-write',
-                        state: 'ready',
-                    });
+                    restored = this.repository.rollback(persisted.rollbackToken);
                 }
                 catch {
                     this.recoveryRequired = true;
                     throw new SettingsCoordinatorError(503, 'settings_recovery_required', 'The durable settings write could not be reconciled with the runtime.');
                 }
+                if (applyError instanceof SettingsCoordinatorError &&
+                    applyError.code === 'settings_recovery_required') {
+                    this.recoveryRequired = true;
+                    this.emitInvalidation({
+                        revision: restored.revision,
+                        reason: 'local-write',
+                        state: 'invalid',
+                    });
+                    throw applyError;
+                }
+                this.emitInvalidation({
+                    revision: restored.revision,
+                    reason: 'local-write',
+                    state: 'ready',
+                });
                 throw new SettingsCoordinatorError(422, 'settings_rejected', 'The runtime rejected the settings update; the document was restored.');
             }
             this.lastAppliedSnapshot = persisted.snapshot;

package/dist/services/settings-document-repository.d.ts

@@ -8,8 +8,15 @@ import { type GlobalConfigDocument } from './global-config';
 import { type EffortPreference } from './effort';
 export declare const SETTINGS_REVISION_KEY_FILE = ".orion-settings-revision.key";
 export declare const SETTINGS_REVISION_PREFIX = "hmac-sha256:";
-export type SettingsKeyV1 = 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'defaults.globalEffort' | 'permissions.toolConfirmation';
+export type SettingsKeyV1 = 'appearance.style' | 'appearance.theme' | 'appearance.motion' | 'defaults.model' | 'defaults.effort' | 'defaults.globalEffort' | 'permissions.toolConfirmation';
 export type SettingsOperationV1 = {
+    readonly op: 'set';
+    readonly key: 'appearance.style';
+    readonly value: 'classic' | 'orion-blocksmith';
+} | {
+    readonly op: 'unset';
+    readonly key: 'appearance.style';
+} | {
     readonly op: 'set';
     readonly key: 'appearance.theme';
     readonly value: 'system' | 'light' | 'dark';

package/dist/services/settings-document-repository.js

@@ -82,7 +82,8 @@ function validateSettingsOperationsV1(operations) {
         if (!isRecord(operation) || (operation.op !== 'set' && operation.op !== 'unset')) {
             invalidOperation();
         }
-        if (operation.key !== 'appearance.theme' &&
+        if (operation.key !== 'appearance.style' &&
+            operation.key !== 'appearance.theme' &&
             operation.key !== 'appearance.motion' &&
             operation.key !== 'defaults.model' &&
             operation.key !== 'defaults.effort' &&
@@ -99,6 +100,11 @@ function validateSettingsOperationsV1(operations) {
             continue;
         }
         switch (operation.key) {
+            case 'appearance.style':
+                if (operation.value !== 'classic' && operation.value !== 'orion-blocksmith') {
+                    invalidOperation();
+                }
+                break;
             case 'appearance.theme':
                 if (operation.value !== 'system' &&
                     operation.value !== 'light' &&
@@ -139,6 +145,21 @@ function applyOperations(source, workspace, operations) {
     const candidate = cloneDocument(source);
     for (const operation of operations) {
         switch (operation.key) {
+            case 'appearance.style': {
+                if (operation.op === 'set') {
+                    const web = isRecord(candidate.web) ? candidate.web : {};
+                    const appearance = isRecord(web.appearance) ? web.appearance : {};
+                    appearance.style = operation.value;
+                    web.appearance = appearance;
+                    candidate.web = web;
+                }
+                else if (isRecord(candidate.web) && isRecord(candidate.web.appearance)) {
+                    delete candidate.web.appearance.style;
+                    pruneEmptyObject(candidate.web, 'appearance');
+                    pruneEmptyObject(candidate, 'web');
+                }
+                break;
+            }
             case 'appearance.theme': {
                 if (operation.op === 'set') {
                     const web = isRecord(candidate.web) ? candidate.web : {};

package/dist/tui-ui/transcript-inspector-layout.js

@@ -15,7 +15,9 @@ function renderTranscriptInspectorFrame(view, options) {
     const width = frame.width;
     const height = frame.height;
     (0, frame_1.writeFrameText)(frame, 0, 0, ' Orion Code Tool Inspector', theme.heading);
-    const search = view.searchQuery ? `search: ${view.searchQuery}` : `${view.entries.length} tools`;
+    const search = view.searchQuery
+        ? `search: ${sanitizeInlineIdentifier(view.searchQuery)}`
+        : `${view.entries.length} tools`;
     (0, frame_1.writeFrameText)(frame, 1, 1, search, theme.toolMeta);
     if (width < 60) {
         const listRows = Math.max(2, Math.min(6, Math.floor((height - 4) / 3)));
@@ -43,10 +45,12 @@ function renderList(frame, view, top, maxRows, width, theme) {
         const entry = view.entries[index];
         const selected = index === view.selectedIndex;
         const marker = entry.state === 'success' ? '✓' : entry.state === 'error' ? '✗' : '-';
-        const text = `${selected ? '›' : ' '} ${marker} #${entry.sequence} ${entry.toolName}`;
+        const text = `${selected ? '›' : ' '} ${marker} #${entry.sequence} ${sanitizeInlineIdentifier(entry.toolName)}`;
         (0, frame_1.writeFrameText)(frame, top + row, 0, truncateWidth(text, Math.max(1, width - 1)), selected
             ? { ...theme.toolName, inverse: true }
-            : entry.state === 'error' ? theme.toolError : theme.toolMeta);
+            : entry.state === 'error'
+                ? theme.toolError
+                : theme.toolMeta);
     }
 }
 function renderDetail(frame, view, top, maxRows, left, width, theme) {
@@ -55,17 +59,17 @@ function renderDetail(frame, view, top, maxRows, left, width, theme) {
     const entry = view.selected;
     if (!entry)
         return;
-    const heading = ` ${entry.toolName} · ${formatBytes(entry.outputBytes)}${entry.artifactId ? '' : ' · legacy'}`;
+    const heading = ` ${sanitizeInlineIdentifier(entry.toolName)} · ${formatBytes(entry.outputBytes)}${entry.artifactId ? '' : ' · legacy'}`;
     (0, frame_1.writeFrameText)(frame, top, left, heading, theme.toolName);
     const expanded = view.expandedCallIds.includes(entry.callId);
     const detail = view.detail;
     const body = !expanded
-        ? entry.summary ?? 'Press Enter to expand detail.'
+        ? (entry.summary ?? 'Press Enter to expand detail.')
         : detail?.loading
             ? 'Loading detail...'
             : detail?.error
                 ? `Detail error: ${detail.error}`
-                : detail?.content ?? entry.summary ?? 'Press Enter to load detail.';
+                : (detail?.content ?? entry.summary ?? 'Press Enter to load detail.');
     const lines = (0, style_1.sanitizeTerminalText)(body).split('\n');
     const detailOffset = expanded ? Math.max(0, view.detailOffset) : 0;
     for (let index = 0; index < maxRows - 1 && detailOffset + index < lines.length; index += 1) {
@@ -82,6 +86,9 @@ function formatBytes(bytes) {
         return `${(bytes / 1024).toFixed(1)} KB`;
     return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
+function sanitizeInlineIdentifier(value) {
+    return (0, style_1.sanitizeTerminalText)(value, 2).replace(/\s+/gu, ' ').trim();
+}
 function truncateWidth(value, maxWidth) {
     let output = '';
     let width = 0;

package/dist/web/event-hub.d.ts

@@ -18,6 +18,7 @@ export declare class WebEventHub {
     private nextCursor;
     private retainedBytes;
     private discardedDurableThrough;
+    private replayResetCount;
     constructor(options?: WebEventHubOptions);
     emitRuntime(event: AgentRuntimeEvent, context?: {
         readonly sessionId?: string;
@@ -35,6 +36,7 @@ export declare class WebEventHub {
         readonly earliest: number;
         readonly latest: number;
         readonly retained: number;
+        readonly replayResets: number;
     };
     private trim;
     private compactRuntimeEvent;

package/dist/web/event-hub.js

@@ -31,12 +31,16 @@ class WebEventHub {
         this.nextCursor = 1;
         this.retainedBytes = 0;
         this.discardedDurableThrough = 0;
+        this.replayResetCount = 0;
         this.maxEvents = positiveInteger(options.maxEvents ?? DEFAULT_MAX_EVENTS, 'maxEvents');
         this.maxBytes = positiveInteger(options.maxBytes ?? DEFAULT_MAX_BYTES, 'maxBytes');
         this.now = options.now ?? Date.now;
     }
     emitRuntime(event, context = {}) {
-        return this.emit({ type: 'runtime_event', value: this.compactRuntimeEvent(sanitizeRuntimeEvent(event)) }, isDurableRuntimeEvent(event), context);
+        return this.emit({
+            type: 'runtime_event',
+            value: this.compactRuntimeEvent(sanitizeRuntimeEvent(event), context.sessionId),
+        }, isDurableRuntimeEvent(event), context);
     }
     emitThread(event, sessionId) {
         return this.emit({ type: 'thread_event', value: sanitizeThreadEvent(event) }, true, {
@@ -73,6 +77,7 @@ class WebEventHub {
     attach(response, cursor) {
         const latest = this.nextCursor - 1;
         if (cursor > latest || cursor < this.discardedDurableThrough) {
+            this.replayResetCount += 1;
             const reset = {
                 apiVersion: protocol_1.WEB_API_VERSION,
                 eventId: (0, crypto_1.randomUUID)(),
@@ -117,6 +122,7 @@ class WebEventHub {
             earliest: this.retained[0]?.envelope.cursor ?? this.nextCursor,
             latest: this.nextCursor - 1,
             retained: this.retained.length,
+            replayResets: this.replayResetCount,
         });
     }
     trim() {
@@ -128,11 +134,12 @@ class WebEventHub {
             this.discardedDurableThrough = Math.max(this.discardedDurableThrough, removed.envelope.cursor);
         }
     }
-    compactRuntimeEvent(event) {
+    compactRuntimeEvent(event, sessionId) {
         if (event.type === 'transcript_update' && typeof event.patch.content === 'string') {
             const content = event.patch.content;
-            const previous = this.transcriptContents.get(event.id);
-            this.rememberTranscriptContent(event.id, content);
+            const key = transcriptContentKey(sessionId, event.id);
+            const previous = this.transcriptContents.get(key);
+            this.rememberTranscriptContent(key, content);
             if (previous !== undefined && content.startsWith(previous)) {
                 const patch = { ...event.patch };
                 delete patch.content;
@@ -146,10 +153,14 @@ class WebEventHub {
             return event;
         }
         if (event.type === 'transcript_finalize' || event.type === 'transcript_remove') {
-            this.transcriptContents.delete(event.id);
+            this.transcriptContents.delete(transcriptContentKey(sessionId, event.id));
         }
         else if (event.type === 'transcript_clear' || event.type === 'transcript_replace') {
-            this.transcriptContents.clear();
+            const prefix = transcriptSessionPrefix(sessionId);
+            for (const key of this.transcriptContents.keys()) {
+                if (key.startsWith(prefix))
+                    this.transcriptContents.delete(key);
+            }
         }
         return event;
     }
@@ -165,6 +176,12 @@ class WebEventHub {
     }
 }
 exports.WebEventHub = WebEventHub;
+function transcriptSessionPrefix(sessionId) {
+    return `${sessionId ?? '<surface>'}\u0000`;
+}
+function transcriptContentKey(sessionId, id) {
+    return `${transcriptSessionPrefix(sessionId)}${id}`;
+}
 function toEnvelope(base, event) {
     switch (event.type) {
         case 'runtime_event':
@@ -232,6 +249,26 @@ function toEnvelope(base, event) {
                 type: event.type,
                 payload: { state: event.state },
             };
+        case 'session_runtime_changed':
+            if (!base.sessionId)
+                throw new Error('Session Runtime events require Session identity');
+            return {
+                ...base,
+                sessionId: base.sessionId,
+                durable: true,
+                type: event.type,
+                payload: { runtime: event.runtime },
+            };
+        case 'workspace_mutation_changed':
+            if (!base.sessionId)
+                throw new Error('Workspace mutation events require Session identity');
+            return {
+                ...base,
+                sessionId: base.sessionId,
+                durable: false,
+                type: event.type,
+                payload: { state: event.state },
+            };
         case 'replay_reset':
             return {
                 ...base,

package/dist/web/file-read-service.d.ts

@@ -5,6 +5,8 @@ export interface WebFileNodeV1 {
     /** Sanitized Workspace-relative display path. Requests must continue to use the opaque id. */
     readonly displayPath: string;
     readonly kind: WebFileKindV1;
+    /** Effective target kind for a readable symbolic link. */
+    readonly targetKind?: 'file' | 'directory';
     readonly sizeBytes?: number;
     readonly modifiedAt: string;
     readonly sensitive: boolean;

package/dist/web/file-read-service.js

@@ -114,7 +114,7 @@ class FileReadServiceV1 {
         if (!node.stat.isFile()) {
             throw new errors_1.WebWorkbenchError(409, 'File node is not a regular file.', 'file_not_regular');
         }
-        const sensitive = (0, redaction_1.isSensitiveFilePath)(node.relativePath);
+        const sensitive = isSensitiveResolvedPath(this.root, node.relativePath, node.canonicalPath);
         if (sensitive) {
             throw new errors_1.WebWorkbenchError(403, 'Sensitive file content is not available in the Web Workbench.', 'sensitive_file_blocked');
         }
@@ -152,6 +152,19 @@ class FileReadServiceV1 {
             const remaining = Math.max(0, Number(before.size) - offset);
             const page = readLineSafePage(descriptor, offset, remaining, limitBytes);
             this.performance.bytesRead += page.bytesRead;
+            if (isBinary(page.content)) {
+                return Object.freeze({
+                    fileId: input.fileId,
+                    name: (0, path_1.basename)(node.relativePath),
+                    revision,
+                    sizeBytes: Number(before.size),
+                    binary: true,
+                    sensitive: false,
+                    mediaType: 'application/octet-stream',
+                    offsetBytes: offset,
+                    nextCursor: null,
+                });
+            }
             const contentBuffer = validUtf8Prefix(page.content);
             if (page.consumedBytes > 0 && contentBuffer.length === 0) {
                 throw new errors_1.WebWorkbenchError(415, 'File is not valid UTF-8 text.', 'file_binary');
@@ -192,25 +205,32 @@ class FileReadServiceV1 {
         const symlink = lexicalStat.isSymbolicLink();
         let readable = true;
         let effectiveStat = lexicalStat;
-        if (symlink) {
-            try {
-                const canonicalPath = (0, fs_1.realpathSync)(lexicalPath);
-                readable = isWithinRoot(canonicalPath, this.root);
-                if (readable)
-                    effectiveStat = (0, fs_1.statSync)(canonicalPath, { bigint: true });
-            }
-            catch {
-                readable = false;
-            }
+        let canonicalPath;
+        try {
+            canonicalPath = (0, fs_1.realpathSync)(lexicalPath);
+            readable = isWithinRoot(canonicalPath, this.root);
+            if (readable)
+                effectiveStat = (0, fs_1.statSync)(canonicalPath, { bigint: true });
         }
+        catch {
+            readable = false;
+        }
+        const targetKind = readable
+            ? effectiveStat.isDirectory()
+                ? 'directory'
+                : effectiveStat.isFile()
+                    ? 'file'
+                    : undefined
+            : undefined;
         return Object.freeze({
             id: this.remember(relativePath),
             name: (0, path_1.basename)(relativePath),
             displayPath: normalizeRelativePath(relativePath),
             kind: symlink ? 'symlink' : effectiveStat.isDirectory() ? 'directory' : 'file',
+            ...(symlink && targetKind ? { targetKind } : {}),
             ...(effectiveStat.isFile() ? { sizeBytes: Number(effectiveStat.size) } : {}),
             modifiedAt: new Date(Number(effectiveStat.mtimeMs)).toISOString(),
-            sensitive: (0, redaction_1.isSensitiveFilePath)(relativePath),
+            sensitive: isSensitiveResolvedPath(this.root, relativePath, canonicalPath),
             readable,
         });
     }
@@ -360,6 +380,13 @@ function isWithinRoot(candidate, root) {
     const rel = (0, path_1.relative)(root, candidate);
     return rel === '' || (!rel.startsWith(`..${path_1.sep}`) && rel !== '..' && !(0, path_1.isAbsolute)(rel));
 }
+function isSensitiveResolvedPath(root, aliasRelativePath, canonicalPath) {
+    if ((0, redaction_1.isSensitiveFilePath)(aliasRelativePath))
+        return true;
+    if (!canonicalPath || !isWithinRoot(canonicalPath, root))
+        return false;
+    return (0, redaction_1.isSensitiveFilePath)((0, path_1.relative)(root, canonicalPath));
+}
 function fingerprintStat(stat) {
     return (0, crypto_1.createHash)('sha256')
         .update([stat.dev, stat.ino, stat.mode, stat.size, stat.mtimeNs, stat.ctimeNs]

package/dist/web/git-read-model-service.js

@@ -122,6 +122,9 @@ class GitReadModelServiceV1 {
         if (!record) {
             throw new errors_1.WebWorkbenchError(409, 'Git file changed before diff.', 'git_revision_conflict');
         }
+        if (isSensitiveGitRecord(record)) {
+            throw new errors_1.WebWorkbenchError(403, 'Sensitive file content is not available in the Web Workbench.', 'sensitive_file_blocked');
+        }
         const lineLimit = boundedInteger(input.lineLimit ?? DEFAULT_DIFF_LINES, 1, MAX_DIFF_LINES, 'lineLimit');
         const byteLimit = boundedInteger(input.byteLimit ?? DEFAULT_DIFF_BYTES, 1024, MAX_DIFF_BYTES, 'byteLimit');
         const offset = input.cursor
@@ -440,6 +443,10 @@ function isConflictRecord(record) {
         `${record.indexStatus}${record.worktreeStatus}` === 'AA' ||
         `${record.indexStatus}${record.worktreeStatus}` === 'DD');
 }
+function isSensitiveGitRecord(record) {
+    return ((0, redaction_1.isSensitiveFilePath)(record.path) ||
+        (record.renamedFrom !== undefined && (0, redaction_1.isSensitiveFilePath)(record.renamedFrom)));
+}
 async function streamDiffPage(input) {
     const lines = [];
     let virtualLine = 0;