elanous 0.2.31 → 0.2.32

package/src/index.ts

@@ -6,6 +6,7 @@ import { accessSync, constants as fsConstants, existsSync, lstatSync, readFileSy
 import type { SelfDevRunParticipant, SelfDevRunState } from './self-dev/run-store.js';
 import { applyConfigDirFlagFromArgv } from './cli/config-dir-flag.js';
 import { LOGS_SINCE_OPTION, registerLogsCommands } from './cli/logs-cli.js';
+import { registerSimCommands } from './cli/sim-cli.js';
 import { registerDocsCommands } from './cli/docs-cli.js';
 import { registerBenchCommands } from './cli/bench-cli.js';
 import { registerRetroCommands } from './cli/retro-cli.js';
@@ -4370,7 +4371,7 @@ selfCmd
       }
     };
     try {
-      const { dispatchHeavyCheck } = await import('./self-implement/gate-remote.js');
+      const { dispatchHeavyCheck, remoteSelfGateArgv } = await import('./self-implement/gate-remote.js');
       const { runGitCommand } = await import('./git-fs/runner.js');
       const topLevel = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
       if (topLevel.status !== 0) throw new Error(`git rev-parse --show-toplevel failed: ${topLevel.stderr.trim() || `rc=${topLevel.status}`}`);
@@ -4389,13 +4390,13 @@ selfCmd
         const { remoteCommitSupportsArtifactDir, newRemoteArtifactDir } = await import('./self-implement/gate-artifacts.js');
         remoteArtifacts = remoteCommitSupportsArtifactDir(repo) ? { dir: newRemoteArtifactDir() } : { unsupported: true };
       }
-      const remoteArtifactArgs = remoteArtifacts && 'dir' in remoteArtifacts ? ['--artifact-dir', remoteArtifacts.dir] : [];
       // origin/main is pinned to this machine's origin/main on the host; any other base is passed as its resolved sha.
-      const remoteArgv = (sha: (ref: string) => string) => ['bun', 'bin/elanous.mjs', 'self', 'gate', '--local', ...(opts.changed ? ['--changed'] : []),
-        ...(opts.base ? ['--base', opts.base === 'origin/main' ? opts.base : sha(opts.base)] : []), ...(shards !== undefined ? ['--shards', String(shards)] : []),
+      const remoteArgv = (sha: (ref: string) => string) => remoteSelfGateArgv({
+        changed: opts.changed, base: opts.base, shards, fixedShardDistribution: opts.fixedShardDistribution,
+        includeImporters: opts.includeImporters,
         // A measured commit without this option rejects it (exit ≠ 0) — read as not passed, never as a silent measured run.
-        ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []),
-        ...(opts.includeImporters ? ['--include-importers'] : []), ...remoteArtifactArgs];
+        artifactDir: remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.dir : undefined,
+      }, sha);
       const { gateHostReservationRoot } = await import('./release-loop/gate-host-reservation.js');
       process.exitCode = await dispatchHeavyCheck({
         tool: 'self-gate', repo, installPwa: true, remoteArgv, refs: opts.base ? [opts.base] : [], reservationRoot: gateHostReservationRoot(),
@@ -6175,6 +6176,7 @@ async function loadJevAccessOrExit(): Promise<import('./decide/jev.js').JevAcces
 registerIntakeCommands(program);
 
 registerLogsCommands(program);
+registerSimCommands(program);
 
 // ── ad (marketing-ad pipeline entrance) ──
 /** ⛔ 「있다」와 「읽을 수 있는 파일이다」는 다른 값 — 디렉토리·권한 없는 파일을 실사로 읽지 않는다. */

package/src/input/external-input-queue.ts

@@ -15,6 +15,11 @@
 //    - ⏹ 정확히 `/stop`·`/esc` 인 글(TUI-STOP-INPUT-BYPASS · #68): 대기열을 «건너뛰고» 지금 턴의 ESC 중단 경로
 //      (`requestStop` → 대시보드 escGate)를 바로 부른다. 대기 중인 일반 항목은 그대로·순서대로 남는다.
 //      턴이 없으면 아무것도 안 하고 `tui-stop-no-active-turn`(멈출 길이 없으면 `tui-stop-undelivered`)으로 던져 바깥 호출자(rc≠0)에게 알린다.
+//    - ⏹ 원시 pty 길(TUI-STOP-RAW-PTY): `pty text pty_<id> /stop --enter`·tmux 처럼 TUI 를 띄운 «PTY 자체»에 쓰면
+//      이 라우터를 안 지나 stdin 으로 들어오고, 턴 중 typeahead 가 «대기(응답 뒤)»에 쌓았다(10-17 재점검).
+//      ⇒ 턴 중 스트리밍 리스너가 stdin «한 청크»가 정확히 `/stop⏎`·`/esc⏎` 이면 `routeRawPtyStop` 으로 같은 `routeStop` 을 부른다.
+//      키보드는 한 키씩 오고 붙여넣기는 봉투에 싸이므로, 한 청크에 온 «글 한 줄 ⊕ Enter» 는 바깥 주입이다.
+//      턴 밖·Enter 없음·그 밖의 글은 종전대로 키로 흐른다(관측 `path: 'raw-pty'` · 제어 IPC 는 `'control-ipc'`).
 //
 // ⚠️ herdr/tmux 처럼 «터미널 자체»에 쓰는 길은 키보드와 구별할 수 없다 — 이 라우터는
 //    elanous 제어 IPC(`pty text`) 경로만 가른다.
@@ -40,11 +45,13 @@ export interface ExternalInputHost {
   requestStop?(): boolean;
   /** 외부 stop 의 결과 표지(채팅 로그 한 줄). */
   onExternalStop?(result: 'stopped' | 'no-turn' | 'failed'): void;
-  /** 대기열이 바뀌었다 — 화면 표지를 다시 그린다. */
-  onQueueChange?(pending: readonly ExternalInputItem[], event: 'queued' | 'delivered'): void;
+  /** 대기열의 현재 상태가 바뀌었다 — 화면 표지를 다시 그린다. */
+  onQueueChange?(pending: readonly ExternalInputItem[]): void;
 }
 
 export type ExternalInputRoute = 'passthrough' | 'submitted' | 'queued' | 'stopped';
+/** 외부 stop 이 들어온 길 — 제어 IPC(`tui:<pid>` · 이 라우터) / 원시 pty(stdin 한 청크). */
+export type ExternalStopPath = 'control-ipc' | 'raw-pty';
 export type ExternalInputDecision = 'passthrough' | 'submit-now' | 'queue' | 'reject';
 
 const EXTERNAL_INPUT_SOURCE: InputSourceRef = { kind: 'terminal', provider: 'pty' };
@@ -133,8 +140,8 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
   // 경고는 머리 항목 «하나»에 한 번 — 머리가 실제로 바뀔 때만 다시 경고할 수 있다(제출 실패로 남은 같은 머리는 유지).
   let staleTurnWarnedHead: ExternalInputItem | null = null;
 
-  const notify = (event: 'queued' | 'delivered'): void => {
-    try { host?.onQueueChange?.(pending, event); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
+  const notify = (): void => {
+    try { host?.onQueueChange?.(pending); } catch { /* fail-soft — 표지 실패가 입력을 막지 않는다 */ }
   };
   const ensurePump = (): void => {
     if (pending.length > 0 && !stopPump) stopPump = schedule(pump, PUMP_MS);
@@ -163,20 +170,20 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
     if (!ok) { log('deliver-failed', { length: head.text.length, pending: pending.length }); return false; }
     pending = pending.slice(1);
     log('delivered', { length: head.text.length, waitedMs: now() - head.at, pending: pending.length });
-    notify('delivered');
+    notify();
     ensurePump();
     return true;
   }
 
   /** ⏹ 외부 stop — 대기열을 건너뛰고 지금 턴의 escGate 로. 대기열은 건드리지 않는다. */
-  function routeStop(h: ExternalInputHost, text: string): ExternalInputRoute {
+  function routeStop(h: ExternalInputHost, text: string, path: ExternalStopPath): ExternalInputRoute {
     let turnActive = false;
     try { turnActive = h.isTurnActive(); } catch { turnActive = false; }
     let stopped = false;
     if (turnActive && h.requestStop) {
       try { stopped = h.requestStop(); } catch { stopped = false; }
     }
-    logInput('external-stop', { hadTurn: turnActive, stopped, command: text, pending: pending.length });
+    logInput('external-stop', { hadTurn: turnActive, stopped, command: text, pending: pending.length, path });
     const result = stopped ? 'stopped' : turnActive ? 'failed' : 'no-turn';
     try { h.onExternalStop?.(result); } catch { /* fail-soft */ }
     if (result === 'no-turn') throw new Error('tui-stop-no-active-turn');
@@ -189,6 +196,7 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       host = next;
       log('host-registered', { pending: pending.length });
       ensurePump();
+      if (pending.length > 0) notify();
       return () => {
         if (host !== next) return;
         host = null;
@@ -200,7 +208,7 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       // `pty key`(input-key)는 «키»다 — 공백·`j` 처럼 출력 가능한 키도 종전대로 넣는다.
       if (keyCommandDepth > 0) return 'passthrough';
       const line = parseExternalTextLine(chars);
-      if (line && host && isExternalStopCommand(line.text)) return routeStop(host, line.text);
+      if (line && host && isExternalStopCommand(line.text)) return routeStop(host, line.text, 'control-ipc');
       let turnActive = false; let composer: string | undefined; let pendingKeys = false;
       if (host && line) {
         try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
@@ -229,10 +237,26 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
       }
       pending = [...pending, { text: line!.text, at: now() }];
       log('route', { ...base, route: 'queued', pending: pending.length });
-      notify('queued');
+      notify();
       ensurePump();
       return 'queued';
     },
+    /**
+     * ⏹ 원시 pty 길 — 턴 중 stdin «한 청크»가 정확히 `/stop⏎`·`/esc⏎` 이면 `routeStop` 으로 보내고 true(키로 흘리지 않는다).
+     * 턴 밖·호스트 없음·Enter 없음·그 밖의 글은 false — 호출측이 종전대로 키를 넣는다.
+     */
+    routeRawStop(chunk: string): boolean {
+      const h = host;
+      if (!h) return false;
+      const line = parseExternalTextLine(chunk);
+      if (!line?.submit || !isExternalStopCommand(line.text)) return false;
+      let turnActive = false;
+      try { turnActive = h.isTurnActive(); } catch { turnActive = false; }
+      if (!turnActive) return false;
+      // 'failed'(중단 경로 없음)도 소비한다 — 표지(Esc 로 멈춰 주세요)는 routeStop 이 이미 남겼다.
+      try { routeStop(h, line.text, 'raw-pty'); } catch { /* 결과는 이벤트·표지로 남았다 */ }
+      return true;
+    },
     pump,
     pending: (): readonly ExternalInputItem[] => pending,
   };
@@ -249,3 +273,4 @@ const shared = createExternalInputQueue();
 
 export function registerExternalInputHost(host: ExternalInputHost): () => void { return shared.register(host); }
 export function routeExternalInput(chars: string): ExternalInputRoute { return shared.route(chars); }
+export function routeRawPtyStop(chunk: string): boolean { return shared.routeRawStop(chunk); }

package/src/llm/route-decision.ts

@@ -40,12 +40,48 @@ const lastBySurface = new Map<string, RouteDecision>();
 
 export function recordCurrentRouteDecision(surface: string, decision: RouteDecision): void {
   lastBySurface.set(surface, decision);
+  // 새 턴의 결정이 서면 지난 턴의 «실제 실행»은 더는 이 턴의 것이 아니다.
+  executionBySurface.delete(surface);
 }
 
 export function currentRouteDecision(surface: string): RouteDecision | null {
   return lastBySurface.get(surface) ?? null;
 }
 
+/** 이번 턴에 «실제로» 응답한 공급자·모델(TUI-MODEL-BADGE-ACTUAL · 10-16).
+ *  결정(`RouteDecision`)은 턴 «시작»에 고른 값이고, 폴백 체인이 다른 공급자로 넘기면 실제는 달라진다.
+ *  ACP 사용량 봉투(`routeProvider`·`model`)로 들어온다 — 이 표면이 결정을 세운 in-process 세션만 적는다.
+ *  ⚠️ 지금 읽는 곳은 완료 배지뿐이다. 상태줄·`/model` «지금:» 의 원천 통일은 후속 칸 TUI-MODEL-BADGE-SOURCE. */
+export interface RouteExecution {
+  provider?: string;
+  model: string;
+}
+
+const executionBySurface = new Map<string, RouteExecution>();
+
+export function recordRouteExecution(surface: string, execution: RouteExecution): void {
+  executionBySurface.set(surface, execution);
+}
+
+export function currentRouteExecution(surface: string): RouteExecution | null {
+  return executionBySurface.get(surface) ?? null;
+}
+
+/** 표면의 결정·실행을 비운다(세션 핀은 사람의 선택이라 남긴다) — 짝이 안 맞는 턴(원격 등)에서 지난 «A → B» 가
+ *  다시 보이지 않게 한다(r5 리뷰). */
+export function clearSurfaceRouteDecision(surface: string): void {
+  lastBySurface.delete(surface);
+  executionBySurface.delete(surface);
+}
+
+/** 턴이 고른 모델과 실제로 응답한 모델이 다르면 «처음 → 실제», 아니면 null(꾸미지 않는다). */
+export function routeFallbackLabel(surface: string): string | null {
+  const decision = lastBySurface.get(surface);
+  const execution = executionBySurface.get(surface);
+  if (!decision?.model || !execution?.model || execution.model === decision.model) return null;
+  return `${decision.model} → ${execution.model}`;
+}
+
 /** A `/model` choice scoped to this process's surface (TUI-MODEL-SESSION-SCOPE · 10-14).
  * It reaches the turn as `explicitModel`, so it wins over the Codex tier policy —
  * a config-only `llm.model` change is ignored by that policy (10-14 OPT: `/model luna`

package/src/llm/tool-loop-steered-rejection.ts

@@ -18,6 +18,12 @@ export const REPAIR_PHASE_READ_ONLY_OPS_TOOLS = ['MsgList', 'ChecklistList'] as
  *    rejects the steer target loops forever (#62 repair · #67 verify — MsgPost).
  *  - Agent is allowed in every action phase, so its result (AgentOutput/AgentList) must be
  *    too, or a delegated result is dropped and the parent redoes the work (#41).
+ *  - Read-only observation of the run itself (TUI-OPS-TURN-GUARD gap ②, old-build samples where
+ *    repair/verify rejected these mid-ops-turn): `logs_query` (logs.db READ-ONLY) and
+ *    `PtyShellPoll` (drains output of a PTY the turn already started — no input, no spawn).
+ *    Deliberately NOT here: `schedule_manage` (create/update/delete mutate crontab) and
+ *    `se_build` (`stop` SIGTERMs a mission) — the allow list is by name, so a tool with any
+ *    write action stays phase-governed.
  *  Source edits stay governed by each phase's own Edit/Write entries — nothing here edits files. */
 export const ACTION_PHASE_OPS_TOOLS = [
   'MsgList',
@@ -30,4 +36,6 @@ export const ACTION_PHASE_OPS_TOOLS = [
   'ChecklistMove',
   'AgentOutput',
   'AgentList',
+  'logs_query',
+  'PtyShellPoll',
 ] as const;

package/src/llm-request-shape.ts

@@ -0,0 +1,209 @@
+// ── Codex(Responses API) 요청 «모양» 요약 — 4xx 거절 관측용 (TUI-OBS-400-SHAPE · 결함 #69) ──
+//
+// 왜: Codex 백엔드는 400 을 `{"detail":"Bad Request"}` 한 줄로만 돌려준다. 그래서 «요청이 너무 컸나 ·
+// 메시지가 몇 개였나 · tool_call ↔ tool_result 짝이 깨졌나 · 첨부가 섞였나» 를 로그로 가를 수 없었다
+// (10-16 OPT 실측: 같은 문면이 «합쳤을 때만» 400 — 원인 추정 불가).
+//
+// 무엇을 싣나: 수·바이트·종류·짝 깨짐 수 «만». ⛔ 본문·프롬프트·도구 인자·도구 출력·사용자 텍스트·키는
+// 싣지 않는다. 짝 깨진 call_id 는 sha256 앞 8자로만(상한 5개) — 같은 id 가 다음 런에도 보이는지 대조용.
+// 순수 함수 — 호출부(streamCodexResponsesEvents)가 실제 전송 객체와 전송 문자열을 넘긴다.
+
+import { createHash } from 'node:crypto';
+
+const HASH_SAMPLE_CAP = 5;
+
+// ⛔ 카운트 «키» 도 요청에서 온 문자열이다 — 알려진 종류만 키로 쓰고 나머지는 `unknown` 으로 접는다
+//    (잘못된 type/role 문자열에 내용이 들어 있어도 이벤트에 새지 않게 · 리뷰 r1).
+const KNOWN_ROLES = new Set(['user', 'assistant', 'system', 'developer', 'tool']);
+const KNOWN_ITEM_TYPES = new Set([
+  'message', 'function_call', 'function_call_output', 'reasoning', 'custom_tool_call', 'custom_tool_call_output',
+  'local_shell_call', 'local_shell_call_output', 'web_search_call', 'image_generation_call', 'item_reference',
+]);
+const KNOWN_CONTENT_TYPES = new Set([
+  'input_text', 'output_text', 'input_image', 'input_file', 'input_audio', 'refusal', 'summary_text', 'reasoning_text', 'string',
+]);
+const KNOWN_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+const KNOWN_SUMMARIES = new Set(['auto', 'concise', 'detailed', 'none']);
+const KNOWN_TOOL_CHOICES = new Set(['auto', 'required', 'none', 'function', 'allowed_tools', 'custom']);
+const MODEL_ID_RE = /^[A-Za-z0-9._:/@+-]{1,80}$/;
+
+function known(set: Set<string>, value: unknown): string {
+  return typeof value === 'string' && set.has(value) ? value : 'unknown';
+}
+
+function hash8(id: string): string {
+  return createHash('sha256').update(id).digest('hex').slice(0, 8);
+}
+
+function byteLen(value: unknown): number {
+  try {
+    const text = typeof value === 'string' ? value : JSON.stringify(value ?? null);
+    return Buffer.byteLength(text ?? '', 'utf8');
+  } catch {
+    return -1;
+  }
+}
+
+function bump(counts: Record<string, number>, key: string): void {
+  counts[key] = (counts[key] ?? 0) + 1;
+}
+
+function countContentBlocks(content: unknown, counts: Record<string, number>, empty: { n: number }): void {
+  if (typeof content === 'string') {
+    bump(counts, 'string');
+    if (content.length === 0) empty.n += 1;
+    return;
+  }
+  if (!Array.isArray(content)) return;
+  for (const block of content) {
+    if (!block || typeof block !== 'object') { bump(counts, 'unknown'); continue; }
+    const b = block as Record<string, unknown>;
+    const type = typeof b.type === 'string' ? b.type : '';
+    bump(counts, known(KNOWN_CONTENT_TYPES, type));
+    if ((type === 'input_text' || type === 'output_text') && typeof b.text === 'string' && b.text.length === 0) empty.n += 1;
+  }
+}
+
+export interface CodexRequestShape {
+  status: number;
+  /** UTF-8 bytes of the exact JSON string sent on the wire. */
+  bytes: number;
+  instructionsBytes: number;
+  inputBytes: number;
+  toolsBytes: number;
+  /** Largest single input item, bytes — one huge tool output vs. many small items. */
+  maxInputItemBytes: number;
+  inputItemCount: number;
+  /** Items carrying a `role` (user/assistant/system/developer messages). */
+  messageCount: number;
+  roleCounts: Record<string, number>;
+  /** Top-level item kinds: message / function_call / function_call_output / reasoning / … */
+  itemTypeCounts: Record<string, number>;
+  /** Content block kinds across messages and array-form tool outputs (input_text / input_image / …). */
+  contentTypeCounts: Record<string, number>;
+  emptyTextBlockCount: number;
+  toolCallCount: number;
+  toolResultCount: number;
+  /** function_call «items» whose call_id has no function_call_output anywhere (counted per item, duplicates included). */
+  unpairedToolCallCount: number;
+  /** function_call_output «items» whose call_id has no function_call anywhere (counted per item). */
+  orphanToolResultCount: number;
+  /** function_call_output items whose call_id has a function_call only «after» them. */
+  toolResultBeforeCallCount: number;
+  /** function_call items beyond the first for the same call_id. */
+  duplicateToolCallIdCount: number;
+  missingCallIdCount: number;
+  unpairedToolCallIdHashes: string[];
+  orphanToolResultIdHashes: string[];
+  toolDefinitionCount: number;
+  model?: string;
+  reasoningEffort?: string;
+  reasoningSummary?: string;
+  store: boolean;
+  hasPreviousResponseId: boolean;
+  toolChoice?: string;
+  hasPromptCacheKey: boolean;
+  /** Size of the provider's error body — the body itself is not recorded. */
+  errorBodyBytes?: number;
+}
+
+/** Summarise a Codex Responses request body for a rejected (4xx) call. Never copies text content. */
+export function summarizeCodexRequestShape(
+  wireBody: Record<string, unknown>,
+  wireJson: string,
+  status: number,
+  errorBodyText?: string,
+): CodexRequestShape {
+  const input = Array.isArray(wireBody.input) ? wireBody.input : [];
+  const roleCounts: Record<string, number> = {};
+  const itemTypeCounts: Record<string, number> = {};
+  const contentTypeCounts: Record<string, number> = {};
+  const empty = { n: 0 };
+  // 항목별로 센다(리뷰 r2) — 같은 call_id 가 여러 번 나와도 짝 깨짐 수는 «항목 수» 다.
+  const calls: Array<{ id: string; index: number }> = [];
+  const results: Array<{ id: string; index: number }> = [];
+  let toolCallCount = 0;
+  let toolResultCount = 0;
+  let missingCallIdCount = 0;
+  let maxInputItemBytes = 0;
+
+  input.forEach((raw, index) => {
+    maxInputItemBytes = Math.max(maxInputItemBytes, byteLen(raw));
+    if (!raw || typeof raw !== 'object') { bump(itemTypeCounts, 'unknown'); return; }
+    const item = raw as Record<string, unknown>;
+    const type = typeof item.type === 'string' ? item.type : (typeof item.role === 'string' ? 'message' : 'unknown');
+    bump(itemTypeCounts, known(KNOWN_ITEM_TYPES, type));
+    if (typeof item.role === 'string') {
+      bump(roleCounts, known(KNOWN_ROLES, item.role));
+      countContentBlocks(item.content, contentTypeCounts, empty);
+    }
+    if (type === 'function_call') {
+      toolCallCount += 1;
+      const id = typeof item.call_id === 'string' && item.call_id ? item.call_id : '';
+      if (!id) { missingCallIdCount += 1; return; }
+      calls.push({ id, index });
+    } else if (type === 'function_call_output') {
+      toolResultCount += 1;
+      countContentBlocks(item.output, contentTypeCounts, empty);
+      const id = typeof item.call_id === 'string' && item.call_id ? item.call_id : '';
+      if (!id) { missingCallIdCount += 1; return; }
+      results.push({ id, index });
+    }
+  });
+
+  const firstCallAt = new Map<string, number>();
+  for (const c of calls) if (!firstCallAt.has(c.id)) firstCallAt.set(c.id, c.index);
+  const resultIds = new Set(results.map((r) => r.id));
+  const unpairedItems = calls.filter((c) => !resultIds.has(c.id));
+  const orphanItems = results.filter((r) => !firstCallAt.has(r.id));
+  const resultBeforeCall = results.filter((r) => firstCallAt.has(r.id) && r.index < (firstCallAt.get(r.id) as number)).length;
+  const duplicateToolCallIdCount = calls.length - firstCallAt.size;
+  const unpaired = [...new Set(unpairedItems.map((c) => c.id))];
+  const orphan = [...new Set(orphanItems.map((r) => r.id))];
+
+  const reasoning = wireBody.reasoning && typeof wireBody.reasoning === 'object'
+    ? wireBody.reasoning as Record<string, unknown> : undefined;
+  const toolChoiceRaw = wireBody.tool_choice;
+  const toolChoice = toolChoiceRaw === undefined || toolChoiceRaw === null
+    ? undefined
+    : known(KNOWN_TOOL_CHOICES, typeof toolChoiceRaw === 'object' ? (toolChoiceRaw as Record<string, unknown>).type : toolChoiceRaw);
+  const tools = Array.isArray(wireBody.tools) ? wireBody.tools : [];
+
+  return {
+    status,
+    bytes: Buffer.byteLength(wireJson, 'utf8'),
+    instructionsBytes: typeof wireBody.instructions === 'string' ? Buffer.byteLength(wireBody.instructions, 'utf8') : 0,
+    inputBytes: byteLen(input),
+    toolsBytes: byteLen(tools),
+    maxInputItemBytes,
+    inputItemCount: input.length,
+    messageCount: Object.values(roleCounts).reduce((a, b) => a + b, 0),
+    roleCounts,
+    itemTypeCounts,
+    contentTypeCounts,
+    emptyTextBlockCount: empty.n,
+    toolCallCount,
+    toolResultCount,
+    unpairedToolCallCount: unpairedItems.length,
+    orphanToolResultCount: orphanItems.length,
+    toolResultBeforeCallCount: resultBeforeCall,
+    duplicateToolCallIdCount,
+    missingCallIdCount,
+    unpairedToolCallIdHashes: unpaired.slice(0, HASH_SAMPLE_CAP).map(hash8),
+    orphanToolResultIdHashes: orphan.slice(0, HASH_SAMPLE_CAP).map(hash8),
+    toolDefinitionCount: tools.length,
+    ...(typeof wireBody.model === 'string' ? { model: MODEL_ID_RE.test(wireBody.model) ? wireBody.model : 'unknown' } : {}),
+    ...(reasoning?.effort !== undefined ? { reasoningEffort: known(KNOWN_EFFORTS, reasoning.effort) } : {}),
+    ...(reasoning?.summary !== undefined ? { reasoningSummary: known(KNOWN_SUMMARIES, reasoning.summary) } : {}),
+    store: wireBody.store === true,
+    hasPreviousResponseId: typeof wireBody.previous_response_id === 'string' && wireBody.previous_response_id.length > 0,
+    ...(toolChoice ? { toolChoice } : {}),
+    hasPromptCacheKey: typeof wireBody.prompt_cache_key === 'string',
+    ...(typeof errorBodyText === 'string' ? { errorBodyBytes: Buffer.byteLength(errorBodyText, 'utf8') } : {}),
+  };
+}
+
+/** 4xx rejections whose cause can be the request shape. Auth (401/403) and quota (429) are not shape problems. */
+export function isShapeRelevantRejection(status: number): boolean {
+  return status >= 400 && status < 500 && status !== 401 && status !== 403 && status !== 429;
+}