@bitkyc08/opencodex 2.65.0-preview.20260925 → 2.66.0-preview.20260925

package/src/protocols/shadow.ts

@@ -0,0 +1,62 @@
+/**
+ * Shadow-plan comparison (PF-12, `protocols.rollout.shadowPlan`): does the dispatch-basis plan
+ * for a request agree with what the request actually did?
+ *
+ * LEAF MODULE (see `contract.ts`) and PURE. It compares two finished records and nothing else:
+ * no second request, no config read, no state. The caller (`trace.ts`) contains any throw.
+ *
+ * What is compared, and why only that:
+ *
+ * - The candidate is the one the request settled on (provider and model of the final route),
+ *   falling back to the plan's first eligible candidate. A combo that failed over is compared
+ *   against the target that answered, not against the first one the plan lists.
+ * - Mode, upstream wire and request path. The response path is not compared: with
+ *   `directEncoders` on, the client side leaves the internal Responses hop while the request
+ *   side keeps it, and the planner does not model the encoder switch.
+ * - A Messages request forwarded with the caller's own Anthropic credential is native by the
+ *   caller's choice; the plan says so with `caller-credential-required` and never predicts it.
+ * - A blocked trace agrees with a blocked plan. A compatibility reject is Claude-integration
+ *   policy the planner does not model, so it is not compared.
+ */
+import type { ProtocolHop } from "./contract";
+import type { ProtocolPlanCandidateV1, ProtocolPlanV1, ProtocolTraceV1 } from "./dto";
+
+/** The route the request settled on, as the request log context records it. */
+export interface ShadowSettledRoute {
+  provider?: string;
+  model?: string;
+}
+
+function samePath(a: readonly ProtocolHop[], b: readonly ProtocolHop[]): boolean {
+  return a.length === b.length && a.every((hop, index) => hop === b[index]);
+}
+
+function settledCandidate(plan: ProtocolPlanV1, settled: ShadowSettledRoute): ProtocolPlanCandidateV1 | undefined {
+  const exact = settled.provider && settled.model
+    ? plan.candidates.find(candidate => candidate.provider === settled.provider && candidate.model === settled.model)
+    : undefined;
+  return exact ?? plan.candidates.find(candidate => candidate.eligible);
+}
+
+/** True when the plan and the observed trace disagree about the path the request took. */
+export function shadowPlanMismatch(
+  plan: ProtocolPlanV1,
+  trace: ProtocolTraceV1,
+  settled: ShadowSettledRoute = {},
+): boolean {
+  if (plan.inbound !== trace.inbound) return true;
+  if (trace.mode === "blocked") {
+    if (trace.reasonCodes.includes("compatibility-reject")) return false;
+    return plan.mode !== "blocked";
+  }
+  if (trace.inbound === "messages" && trace.mode === "native"
+    && plan.reasonCodes.includes("caller-credential-required")
+    && samePath(trace.requestPath, ["messages", "messages"])) {
+    return false;
+  }
+  const candidate = settledCandidate(plan, settled);
+  if (!candidate || candidate.mode === "blocked") return true;
+  return candidate.mode !== trace.mode
+    || candidate.upstream !== trace.upstream
+    || !samePath(candidate.requestPath, trace.requestPath);
+}

package/src/protocols/trace.ts

@@ -0,0 +1,335 @@
+/**
+ * Observed protocol path for one request (PF-02).
+ *
+ * SERVER SIDE: the dashboard never imports this file; it reads the finished `ProtocolTraceV1`
+ * through `dto.ts`. Marks live in WeakMaps keyed by the request log context and by the live
+ * attempt objects, so neither `RequestLogContext` nor the persisted attempt row grows a field,
+ * and a context that is never finalized takes its marks with it.
+ *
+ * Every function here is side-effect free apart from its own WeakMap and never throws into the
+ * request path: a trace is diagnostics, and a request must not fail because its trace could not
+ * be recorded. Nothing conversation-derived is kept — only fixed vocabulary.
+ *
+ * Shadow plan (PF-12): when `protocols.rollout.shadowPlan` is on, the ingress records the
+ * dispatch-basis plan input for the request (`src/protocols/shadow-plan.ts`); at finalize the
+ * plan is computed with the pure planner and compared with the observed trace, and a
+ * disagreement sets `planMismatch`. Nothing is recorded with the switch off, so the trace is
+ * unchanged, and a failed comparison leaves the trace as observed.
+ */
+import {
+  PROTOCOL_CONTRACT_VERSION,
+  isProtocolReasonCode,
+  upstreamWireForAdapter,
+  type DeliveryMode,
+  type Protocol,
+  type ProtocolHop,
+  type ProtocolReasonCode,
+  type UpstreamWire,
+} from "./contract";
+import { PROTOCOL_DTO_LIMITS, PROTOCOL_TRACE_SCHEMA_VERSION, type ProtocolAttemptTraceV1, type ProtocolTraceV1 } from "./dto";
+import { featureEffectsForPath, isProtocolFeature, type ProtocolFeature } from "./features";
+import { deliveryModeForLane, requestPathForLane, responsePathForLane, type ProtocolLane } from "./path";
+import { planProtocol, type ProtocolPlanInput } from "./plan";
+import { shadowPlanMismatch } from "./shadow";
+
+/** Features are computed inside the mark, so a thrown feature scan is contained there too. */
+export type ProtocolFeatureSource = Iterable<ProtocolFeature> | (() => Iterable<ProtocolFeature>);
+
+interface EntryMark {
+  kind: "entry";
+  inbound: Protocol;
+  lane: ProtocolLane;
+  reasonCodes: ProtocolReasonCode[];
+  features: ProtocolFeature[];
+}
+
+interface BlockedMark {
+  kind: "blocked";
+  inbound: Protocol;
+  reasonCodes: ProtocolReasonCode[];
+  features: ProtocolFeature[];
+}
+
+interface AttemptMark {
+  mode: Exclude<DeliveryMode, "blocked">;
+  requestPath: ProtocolHop[];
+  responsePath?: ProtocolHop[];
+}
+
+/** The attempt fields the trace reads. `PersistedUsageAttempt` satisfies it. */
+export interface ProtocolTraceAttempt {
+  ordinal: number;
+  adapter: string;
+}
+
+const requestMarks = new WeakMap<object, EntryMark | BlockedMark>();
+const attemptMarks = new WeakMap<object, AttemptMark>();
+const shadowInputs = new WeakMap<object, ProtocolPlanInput>();
+
+function boundedReasons(codes: Iterable<ProtocolReasonCode>): ProtocolReasonCode[] {
+  const out: ProtocolReasonCode[] = [];
+  for (const code of codes) {
+    if (!isProtocolReasonCode(code) || out.includes(code)) continue;
+    out.push(code);
+    if (out.length >= PROTOCOL_DTO_LIMITS.reasonCodes) break;
+  }
+  return out;
+}
+
+function collectFeatures(source: ProtocolFeatureSource | undefined): ProtocolFeature[] {
+  if (source === undefined) return [];
+  const iterable = typeof source === "function" ? source() : source;
+  const out: ProtocolFeature[] = [];
+  for (const feature of iterable) {
+    if (isProtocolFeature(feature) && !out.includes(feature)) out.push(feature);
+    if (out.length >= PROTOCOL_DTO_LIMITS.featureEffects) break;
+  }
+  return out;
+}
+
+/**
+ * Record which lane a Chat or Messages ingress chose. A later mark replaces an earlier one:
+ * the last decision before the send is the one that describes it.
+ */
+export function markProtocolEntry(
+  logCtx: object,
+  mark: { inbound: Protocol; lane: ProtocolLane; reasonCodes?: Iterable<ProtocolReasonCode>; features?: ProtocolFeatureSource },
+): void {
+  try {
+    requestMarks.set(logCtx, {
+      kind: "entry",
+      inbound: mark.inbound,
+      lane: mark.lane,
+      reasonCodes: boundedReasons(mark.reasonCodes ?? []),
+      features: collectFeatures(mark.features),
+    });
+  } catch {
+    /* a trace must never fail the request it describes */
+  }
+}
+
+/** Features the request's entry or blocked mark recorded, for the shadow plan input. */
+export function protocolMarkFeatures(logCtx: object): readonly ProtocolFeature[] | undefined {
+  try {
+    const mark = requestMarks.get(logCtx);
+    return mark ? [...mark.features] : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Record the dispatch-basis plan input the shadow comparison runs at finalize. The input holds
+ * fixed vocabulary and the provider and model names the server already exposes, nothing else.
+ */
+export function markProtocolShadowPlanInput(logCtx: object, input: ProtocolPlanInput): void {
+  try {
+    shadowInputs.set(logCtx, input);
+  } catch {
+    /* a trace must never fail the request it describes */
+  }
+}
+
+/** Record a refusal made before any upstream send. */
+export function markProtocolBlocked(
+  logCtx: object,
+  mark: { inbound: Protocol; reasonCodes: Iterable<ProtocolReasonCode>; features?: ProtocolFeatureSource },
+): void {
+  try {
+    requestMarks.set(logCtx, {
+      kind: "blocked",
+      inbound: mark.inbound,
+      reasonCodes: boundedReasons(mark.reasonCodes),
+      features: collectFeatures(mark.features),
+    });
+  } catch {
+    /* a trace must never fail the request it describes */
+  }
+}
+
+/**
+ * Add a reason to the request's entry mark: a combo candidate skipped before any send (PF-07).
+ * No-op without an entry mark, and a blocked mark is never reopened.
+ */
+export function addProtocolEntryReason(logCtx: object, code: ProtocolReasonCode): void {
+  try {
+    const mark = requestMarks.get(logCtx);
+    if (mark?.kind !== "entry") return;
+    mark.reasonCodes = boundedReasons([...mark.reasonCodes, code]);
+  } catch {
+    /* a trace must never fail the request it describes */
+  }
+}
+
+/**
+ * Record the path one physical attempt actually took, overriding the lane-derived one. For a
+ * send site that knows its path better than the ingress lane does.
+ */
+export function markAttemptProtocolPath(
+  attempt: object,
+  mark: { mode: Exclude<DeliveryMode, "blocked">; requestPath: readonly ProtocolHop[]; responsePath?: readonly ProtocolHop[] },
+): void {
+  try {
+    if (mark.requestPath.length === 0 || mark.requestPath.length > PROTOCOL_DTO_LIMITS.pathHops) return;
+    const responsePath = mark.responsePath && mark.responsePath.length > 0
+      && mark.responsePath.length <= PROTOCOL_DTO_LIMITS.pathHops
+      ? [...mark.responsePath]
+      : undefined;
+    attemptMarks.set(attempt, {
+      mode: mark.mode,
+      requestPath: [...mark.requestPath],
+      ...(responsePath ? { responsePath } : {}),
+    });
+  } catch {
+    /* a trace must never fail the request it describes */
+  }
+}
+
+function isReverse(a: readonly ProtocolHop[], b: readonly ProtocolHop[]): boolean {
+  return a.length === b.length && a.every((hop, index) => hop === b[b.length - 1 - index]);
+}
+
+interface ResolvedPath {
+  upstream: UpstreamWire;
+  mode: Exclude<DeliveryMode, "blocked">;
+  requestPath: ProtocolHop[];
+  responsePath: ProtocolHop[];
+}
+
+function pathFor(inbound: Protocol, lane: ProtocolLane, upstream: UpstreamWire): ResolvedPath {
+  return {
+    upstream,
+    mode: deliveryModeForLane(inbound, lane, upstream),
+    requestPath: requestPathForLane(inbound, lane, upstream),
+    responsePath: responsePathForLane(inbound, lane, upstream),
+  };
+}
+
+function attemptPath(inbound: Protocol, lane: ProtocolLane, attempt: ProtocolTraceAttempt): ResolvedPath {
+  // A native Chat or Messages lane sends the ingress wire itself, whatever the adapter id says;
+  // Responses has no lane and follows its adapter.
+  const upstream = lane === "native" && inbound !== "responses" ? inbound : upstreamWireForAdapter(attempt.adapter);
+  const derived = pathFor(inbound, lane, upstream);
+  const mark = attemptMarks.get(attempt);
+  if (!mark) return derived;
+  return {
+    upstream,
+    mode: mark.mode,
+    requestPath: [...mark.requestPath],
+    responsePath: mark.responsePath ? [...mark.responsePath] : [...mark.requestPath].reverse(),
+  };
+}
+
+/** A reason code the path itself implies, so a trace is never reason-less. */
+function pathReason(path: ResolvedPath): ProtocolReasonCode {
+  if (path.upstream === "other") return "upstream-other";
+  if (path.mode === "native") return "same-wire-native";
+  if (path.mode === "legacy-bridge") return "not-migrated";
+  return path.requestPath.includes("ir") ? "cross-wire-ir" : "cross-wire-codec";
+}
+
+/** The context fields the trace reads at finalize. */
+export type ProtocolTraceContext = object & { inboundProtocol?: Protocol; provider?: string; model?: string };
+
+/**
+ * Derive the observed trace at finalize. `attempts` are the live attempt objects (the ones
+ * `markAttemptProtocolPath` was keyed by), not detached copies.
+ *
+ * - blocked mark: `blocked`, empty paths.
+ * - Responses inbound without a mark: the final adapter's wire decides the path.
+ * - Chat or Messages: the entry lane decides, through `path.ts`.
+ * - no attempt and no native or blocked mark: `undefined`; nothing is guessed.
+ *
+ * With a shadow plan input recorded, a disagreeing plan adds `planMismatch: true`.
+ */
+export function protocolTraceForRequest(
+  logCtx: ProtocolTraceContext,
+  attempts: readonly ProtocolTraceAttempt[] | undefined,
+): ProtocolTraceV1 | undefined {
+  const trace = observedTrace(logCtx, attempts);
+  return trace ? withShadowPlan(logCtx, trace) : undefined;
+}
+
+/**
+ * Compare the recorded dispatch plan with the observed trace. Pure and local: the planner reads
+ * only the recorded input. Any throw leaves the observed trace as it was.
+ */
+function withShadowPlan(logCtx: ProtocolTraceContext, trace: ProtocolTraceV1): ProtocolTraceV1 {
+  try {
+    const input = shadowInputs.get(logCtx);
+    if (!input) return trace;
+    const settled = {
+      ...(typeof logCtx.provider === "string" ? { provider: logCtx.provider } : {}),
+      ...(typeof logCtx.model === "string" ? { model: logCtx.model } : {}),
+    };
+    return shadowPlanMismatch(planProtocol(input), trace, settled) ? { ...trace, planMismatch: true } : trace;
+  } catch {
+    return trace;
+  }
+}
+
+function observedTrace(
+  logCtx: ProtocolTraceContext,
+  attempts: readonly ProtocolTraceAttempt[] | undefined,
+): ProtocolTraceV1 | undefined {
+  try {
+    const mark = requestMarks.get(logCtx);
+    if (mark?.kind === "blocked") {
+      return {
+        v: PROTOCOL_TRACE_SCHEMA_VERSION,
+        inbound: mark.inbound,
+        mode: "blocked",
+        requestPath: [],
+        responsePath: [],
+        reasonCodes: mark.reasonCodes,
+        contractVersion: PROTOCOL_CONTRACT_VERSION,
+      };
+    }
+    let inbound: Protocol;
+    let lane: ProtocolLane;
+    if (mark) {
+      inbound = mark.inbound;
+      lane = mark.lane;
+    } else if (logCtx.inboundProtocol === "responses") {
+      inbound = "responses";
+      lane = "native";
+    } else {
+      return undefined;
+    }
+    const live = (attempts ?? []).filter(attempt => Number.isInteger(attempt.ordinal) && attempt.ordinal > 0);
+    const kept = live.slice(-PROTOCOL_DTO_LIMITS.attempts);
+    const attemptPaths = kept.map(attempt => ({ attempt, path: attemptPath(inbound, lane, attempt) }));
+    let final: ResolvedPath;
+    const last = attemptPaths.at(-1);
+    if (last) final = last.path;
+    else if (mark && lane === "native") final = pathFor(inbound, lane, inbound);
+    else return undefined;
+
+    const reasonCodes = boundedReasons([...(mark?.reasonCodes ?? []), pathReason(final)]);
+    const features = mark?.features ?? [];
+    const effects = features.length > 0
+      ? featureEffectsForPath(inbound, final.requestPath, features).effects.slice(0, PROTOCOL_DTO_LIMITS.featureEffects)
+      : [];
+    const attemptTraces: ProtocolAttemptTraceV1[] = attemptPaths.map(({ attempt, path }) => ({
+      ordinal: attempt.ordinal,
+      upstream: path.upstream,
+      mode: path.mode,
+      requestPath: path.requestPath,
+      ...(isReverse(path.requestPath, path.responsePath) ? {} : { responsePath: path.responsePath }),
+    }));
+    return {
+      v: PROTOCOL_TRACE_SCHEMA_VERSION,
+      inbound,
+      mode: final.mode,
+      upstream: final.upstream,
+      requestPath: final.requestPath,
+      responsePath: final.responsePath,
+      reasonCodes,
+      ...(effects.length > 0 ? { featureEffects: effects.map(effect => ({ ...effect })) } : {}),
+      ...(attemptTraces.length > 0 ? { attempts: attemptTraces } : {}),
+      contractVersion: PROTOCOL_CONTRACT_VERSION,
+    };
+  } catch {
+    return undefined;
+  }
+}

package/src/providers/model-rename-migration.ts

@@ -18,7 +18,7 @@
 // with nothing left to carry forward (see `isRegistryResidue`, issue #5066).
 // Everything else in the row is left alone.
 
-import { PROVIDER_REGISTRY } from "./registry";
+import { PROVIDER_REGISTRY, normalizedProviderEndpoint } from "./registry";
 import { MODEL_KEYED_RECORDS, MODEL_ID_LISTS, MODEL_ID_SCALARS, MODEL_NESTED_RECORDS } from "./model-rename-fields";
 import { providerConfigSeed } from "./derive";
 import type { OcxConfig, OcxProviderConfig } from "../types";
@@ -256,8 +256,8 @@ function providerStillMatchesRegistry(name: string, prov: OcxProviderConfig): bo
   const choices = entry.baseUrlChoices?.map(choice => choice.baseUrl) ?? [];
   const known = [entry.baseUrl, ...choices]
     .filter((url): url is string => typeof url === "string")
-    .map(url => url.replace(/\/+$/, ""));
-  return known.includes(prov.baseUrl.replace(/\/+$/, ""));
+    .map(normalizedProviderEndpoint);
+  return known.includes(normalizedProviderEndpoint(prov.baseUrl));
 }
 
 /** Guard against a stale rename: only apply when the registry actually seeds `to`. */

package/src/providers/registry/entries-core.ts

@@ -1263,7 +1263,12 @@ export const PROVIDER_REGISTRY_CORE: readonly ProviderRegistryEntry[] = [
     modelReasoningEfforts: Object.fromEntries(DEEPSEEK_NATIVE_THINKING_MODELS.map(id => [id, deepseekThinkingEffortsFor(id)])),
     modelReasoningEffortMap: Object.fromEntries(DEEPSEEK_NATIVE_THINKING_MODELS.map(id => [id, deepseekReasoningMapFor(id)])),
     modelSupportsReasoningSummaries: Object.fromEntries(DEEPSEEK_NATIVE_THINKING_MODELS.map(id => [id, true])),
-    preserveReasoningContentModels: DEEPSEEK_NATIVE_THINKING_MODELS,
+    // deepseek-v4-pro is absent from the live sets on purpose (retired upstream, requests
+    // route to V4.1-Flash — see model-seeds.ts), but it stays SELECTABLE in configs that
+    // already carry it, and what serves it is a thinking-mode model. A saved config with
+    // the alias selected would otherwise serialize a bare continuation the upstream 400s
+    // on (#5421). The preserve list governs replay, not advertisement.
+    preserveReasoningContentModels: [...DEEPSEEK_NATIVE_THINKING_MODELS, "deepseek-v4-pro"],
     // #4436: first-party deepseek-flash accepts native images on Chat and Responses.
     // Keep unprobed compatibility aliases on the #88 sidecar path. This must be fixed
     // here: router enrichment unions this list with saved config, so config cannot remove it.

package/src/providers/registry/entries-extended.ts

@@ -117,6 +117,21 @@ import {
 } from "./model-seeds";
 
 export const PROVIDER_REGISTRY_EXTENDED: readonly ProviderRegistryEntry[] = [
+  {
+    // Verified 2026-09-21: docs.typesafe.ai/introduction/quickstart and /api document the fixed
+    // endpoint, Bearer auth, jev-latest, and TYPESAFE_API_KEY; typesafe.ai/legal/mca permits API integration.
+    id: "jev",
+    label: "TypeSafe JEV",
+    baseUrl: "https://api.typesafe.ai/v1/systemone",
+    adapter: "jev-decision",
+    authKind: "key",
+    credentialOnly: true,
+    dashboardUrl: "https://console.typesafe.ai",
+    liveModels: false,
+    apiKeyValidation: "unknown",
+    preserveCustomDestination: true,
+    note: "TypeSafe JEV decision service for the optional JEV Combo strategy. This credential-only preset does not publish a directly routable model.",
+  },
   {
     id: "baseten",
     label: "Baseten Model APIs",

package/src/providers/registry/model-ids.ts

@@ -46,6 +46,7 @@ export const REGISTRY_FIELD_MODEL_ID_ROLES = {
   apiKeyTransport: NONE,
   alias: NONE,
   authKind: NONE,
+  credentialOnly: NONE,
   codexAccountMode: NONE,
   allowKeyAuthOverride: NONE,
   allowPrivateNetworkByDefault: NONE,

package/src/providers/registry/types.ts

@@ -112,6 +112,12 @@ export interface ProviderRegistryEntry {
   apiKeyTransport?: OcxProviderConfig["apiKeyTransport"];
   alias?: string;
   authKind: ProviderAuthKind;
+  /**
+   * Credential preset for an auxiliary service rather than a model transport.
+   * Its adapter is an identity marker and is intentionally absent from the
+   * routable adapter registry.
+   */
+  credentialOnly?: boolean;
   codexAccountMode?: CodexAccountMode;
   /** OAuth preset may explicitly honor a persisted API-key billing mode. */
   allowKeyAuthOverride?: boolean;

package/src/providers/registry.ts

@@ -81,7 +81,7 @@ export function registryModelServiceTierCapabilityApplies(
   return guard === undefined || guard(provider.baseUrl);
 }
 
-function normalizedProviderEndpoint(value: string): string {
+export function normalizedProviderEndpoint(value: string): string {
   const trimmed = value.trim();
   try {
     const parsed = new URL(trimmed);

package/src/remote-control/workspace-hub.ts

@@ -478,13 +478,14 @@ export class RemoteWorkspaceHub {
   }
 
   revokeDevice(deviceId: string): boolean {
-    const before = this.state.devices.length;
-    this.state = { ...this.state, devices: this.state.devices.filter(device => device.id !== deviceId) };
-    if (this.state.devices.length === before) return false;
+    const next = { ...this.state, devices: this.state.devices.filter(device => device.id !== deviceId) };
+    if (next.devices.length === this.state.devices.length) return false;
+    // Publish only after durable removal: a failed save must remain visible and retryable.
+    this.store.save(next);
+    this.state = next;
     const connection = this.connections.get(deviceId);
     this.connections.delete(deviceId);
     connection?.close("remote workspace device was revoked");
-    this.store.save(this.state);
     return true;
   }
 

package/src/responses/apply-patch-envelope.ts

@@ -28,6 +28,11 @@ const FREEFORM_FALLBACK_KEYS: Readonly<Record<string, readonly string[]>> = {
   apply_patch: ["patch", "content"],
 };
 
+/** The field names a tool's freeform wrapper may unwrap through, besides canonical `input`. */
+export function freeformFallbackKeys(toolName: string): readonly string[] {
+  return FREEFORM_FALLBACK_KEYS[toolName] ?? [];
+}
+
 function stripMarkdownCodeFence(text: string, toolName: string): string {
   if (toolName !== "exec" && toolName !== "apply_patch") return text;
   const match = OUTER_MARKDOWN_CODE_FENCE.exec(text.trim());
@@ -46,7 +51,7 @@ export function unwrapFreeformToolInput(argumentsText: unknown, toolName = ""):
           ? stripMarkdownCodeFence(record.input, toolName)
           : argumentsText;
       }
-      const fallbackKeys = FREEFORM_FALLBACK_KEYS[toolName] ?? [];
+      const fallbackKeys = freeformFallbackKeys(toolName);
       const candidates = fallbackKeys.filter(key => typeof record[key] === "string");
       if (candidates.length === 1) {
         return stripMarkdownCodeFence(record[candidates[0]] as string, toolName);

package/src/responses/code-mode-shell-input.ts

@@ -40,8 +40,10 @@ export function mayBecomeCodeModeShellInput(argumentsText: string, input: string
   const head = input.trimStart();
   if (head === "" || head.startsWith("{")) return true;
   // Canonical JavaScript streams progressively; avoid reparsing its growing wrapper on every
-  // delta. The shared prefix scanner is bounded independently of the command's size.
-  if (input === argumentsText || scanFreeformWrapper(argumentsText).kind === "input") return false;
+  // delta. The shared prefix scanner is bounded independently of the command's size. No fallback
+  // keys here: a fallback value is a shell command, not JavaScript, so only canonical `input`
+  // may short-circuit the parse below.
+  if (input === argumentsText || scanFreeformWrapper(argumentsText, []).kind === "input") return false;
   try {
     const args = JSON.parse(argumentsText);
     // A fallback cmd value becomes visible only when the outer object closes. Do not emit