elanous 0.2.31 → 0.2.34

package/src/knowhow/pack.ts

@@ -0,0 +1,199 @@
+/** Shared, deterministic retrieval contract for TUI and task-agent knowhow. */
+
+export const KNOWHOW_PACK_DEFAULT_K = 8;
+export const KNOWHOW_PACK_DEFAULT_CHAR_BUDGET = 32_000;
+
+export type KnowhowSourceKind = 'KNOWHOW.md' | 'PLAYBOOK' | 'know-candidates' | 'autopsy';
+export type KnowhowKind = 'fact' | 'warning' | 'heuristic' | 'playbook' | 'case';
+
+export const KNOWHOW_HALF_LIFE_DAYS: Readonly<Record<KnowhowKind, number>> = {
+  fact: 14,
+  warning: 30,
+  heuristic: 90,
+  playbook: 60,
+  case: Number.POSITIVE_INFINITY,
+};
+
+export interface KnowhowTarget {
+  surface: string;
+  scope: string;
+  tool?: string;
+  commandClass?: string;
+}
+
+/** Values are normalized by the consumer; the shared core compares them exactly. */
+export interface KnowhowFailureSignature {
+  kind: string;
+  stableCode: string;
+  normalizedArgsHash: string;
+}
+
+export interface KnowhowFragment {
+  id: string;
+  target: KnowhowTarget;
+  signature: KnowhowFailureSignature;
+  text: string;
+  kind: KnowhowKind;
+  source: { kind: KnowhowSourceKind; path: string; ref: string };
+  status: 'verified' | 'candidate' | 'challenged' | 'rejected';
+  confidence: number;
+  verifiedAt: string;
+  expiresAt: string;
+}
+
+export interface KnowhowPackRequest {
+  target: KnowhowTarget;
+  signature: KnowhowFailureSignature;
+  now?: number;
+  maxItems?: number;
+  maxChars?: number;
+}
+
+export interface KnowhowPack {
+  snippets: Array<Pick<KnowhowFragment, 'id' | 'text' | 'source' | 'status' | 'confidence' | 'verifiedAt'>>;
+  omittedCount: number;
+  diagnostics: string[];
+}
+
+function sameTarget(a: KnowhowTarget, b: KnowhowTarget): boolean {
+  return a.surface === b.surface
+    && a.scope === b.scope
+    && a.tool === b.tool
+    && a.commandClass === b.commandClass;
+}
+
+function sameSignature(a: KnowhowFailureSignature, b: KnowhowFailureSignature): boolean {
+  return a.kind === b.kind
+    && a.stableCode === b.stableCode
+    && a.normalizedArgsHash === b.normalizedArgsHash;
+}
+
+function timestamp(value: string): number | null {
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function compareText(a: string, b: string): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function validTarget(value: unknown): value is KnowhowTarget {
+  if (!isRecord(value)) return false;
+  return typeof value.surface === 'string' && value.surface.trim().length > 0
+    && typeof value.scope === 'string' && value.scope.trim().length > 0
+    && (value.tool === undefined || typeof value.tool === 'string')
+    && (value.commandClass === undefined || typeof value.commandClass === 'string');
+}
+
+function validSignature(value: unknown): value is KnowhowFailureSignature {
+  return isRecord(value)
+    && typeof value.kind === 'string' && value.kind.trim().length > 0
+    && typeof value.stableCode === 'string' && value.stableCode.trim().length > 0
+    && typeof value.normalizedArgsHash === 'string' && value.normalizedArgsHash.trim().length > 0;
+}
+
+function validFragment(fragment: KnowhowFragment, request: KnowhowPackRequest, now: number): boolean {
+  const verifiedAt = timestamp(fragment.verifiedAt);
+  const expiresAt = timestamp(fragment.expiresAt);
+  return fragment.status === 'verified'
+    && Object.hasOwn(KNOWHOW_HALF_LIFE_DAYS, fragment.kind)
+    && Number.isFinite(fragment.confidence)
+    && fragment.confidence >= 0 && fragment.confidence <= 1
+    && ['KNOWHOW.md', 'PLAYBOOK', 'know-candidates', 'autopsy'].includes(fragment.source.kind)
+    && fragment.id.trim().length > 0
+    && fragment.text.trim().length > 0
+    && fragment.source.path.trim().length > 0
+    && fragment.source.ref.trim().length > 0
+    && verifiedAt !== null && verifiedAt <= now
+    && expiresAt !== null && expiresAt > now
+    && expiresAt >= verifiedAt
+    && (now - verifiedAt <= KNOWHOW_HALF_LIFE_DAYS[fragment.kind]
+      * 24 * 60 * 60 * 1000)
+    && sameTarget(fragment.target, request.target)
+    && sameSignature(fragment.signature, request.signature);
+}
+
+/**
+ * Select only verified, unexpired fragments for an exact target and failure
+ * signature. Whole snippets are admitted or omitted; this function never
+ * truncates evidence-bearing text. Invalid limits and malformed input fail
+ * open as an empty pack, leaving the caller's existing path usable.
+ */
+export function buildKnowhowPack(
+  fragments: readonly KnowhowFragment[],
+  request: KnowhowPackRequest,
+): KnowhowPack {
+  try {
+    const inputCount = Array.isArray(fragments) ? fragments.length : 0;
+    if (!isRecord(request) || !validTarget(request.target) || !validSignature(request.signature)) {
+      return { snippets: [], omittedCount: inputCount, diagnostics: ['invalid-request'] };
+    }
+    if (!Array.isArray(fragments)) {
+      return { snippets: [], omittedCount: 0, diagnostics: ['invalid-fragments'] };
+    }
+    const maxItems = request.maxItems ?? KNOWHOW_PACK_DEFAULT_K;
+    const maxChars = request.maxChars ?? KNOWHOW_PACK_DEFAULT_CHAR_BUDGET;
+    const now = request.now ?? Date.now();
+    if (!Number.isFinite(now) || !Number.isInteger(maxItems) || maxItems < 0
+      || !Number.isInteger(maxChars) || maxChars < 0) {
+      return { snippets: [], omittedCount: inputCount, diagnostics: ['invalid-request'] };
+    }
+
+    const sorted = [...fragments].filter((fragment) => validFragment(fragment, request, now)).sort((a, b) => {
+      // Most recently verified wins; the id is the stable tie breaker.
+      return timestamp(b.verifiedAt)! - timestamp(a.verifiedAt)!
+        || compareText(a.id, b.id)
+        || compareText(a.verifiedAt, b.verifiedAt)
+        || b.confidence - a.confidence
+        || compareText(a.expiresAt, b.expiresAt)
+        || compareText(a.source.kind, b.source.kind)
+        || compareText(a.source.path, b.source.path)
+        || compareText(a.source.ref, b.source.ref)
+        || compareText(a.text, b.text);
+    });
+    const seen = new Set<string>();
+    const eligible = sorted.filter((fragment) => {
+      if (seen.has(fragment.id)) return false;
+      seen.add(fragment.id);
+      return true;
+    });
+
+    const snippets: KnowhowPack['snippets'] = [];
+    let chars = 0;
+    for (const fragment of eligible) {
+      if (snippets.length >= maxItems) break;
+      const snippet: KnowhowPack['snippets'][number] = {
+        id: fragment.id,
+        text: fragment.text,
+        source: {
+          kind: fragment.source.kind,
+          path: fragment.source.path,
+          ref: fragment.source.ref,
+        },
+        status: fragment.status,
+        confidence: fragment.confidence,
+        verifiedAt: fragment.verifiedAt,
+      };
+      // Budget the complete serialized snippet, including provenance metadata.
+      const snippetChars = JSON.stringify(snippet).length;
+      if (chars + snippetChars > maxChars) continue;
+      snippets.push(snippet);
+      chars += snippetChars;
+    }
+    return {
+      snippets,
+      omittedCount: fragments.length - snippets.length,
+      diagnostics: [],
+    };
+  } catch {
+    return {
+      snippets: [],
+      omittedCount: Array.isArray(fragments) ? fragments.length : 0,
+      diagnostics: ['fragment-validation-failed'],
+    };
+  }
+}

package/src/light-cli.ts

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import { applyConfigDirFlagFromArgv } from './cli/config-dir-flag.js';
+import { applyTestStateDirFlagFromArgv } from './cli/test-state-dir-flag.js';
+import { applyTestFlagFromArgv } from './cli/test-flag.js';
+import type { LightCliRoute } from './cli/light-entry-route.js';
+
+/** Dispatch a small read-only command without loading the full command registry. */
+export async function runLightCli(route: LightCliRoute): Promise<void> {
+  // Keep the same pre-import isolation order as src/index.ts. In particular,
+  // config-touching command modules must not load before these flags apply.
+  applyTestStateDirFlagFromArgv();
+  applyTestFlagFromArgv();
+  applyConfigDirFlagFromArgv();
+
+  const program = new Command().name('elanous').enablePositionalOptions();
+  switch (route) {
+    case 'msg': {
+      const { registerMsgCommands } = await import('./cli/msg-cli.js');
+      registerMsgCommands(program);
+      break;
+    }
+    case 'release': {
+      const { registerReleaseCommands } = await import('./cli/release-cli.js');
+      registerReleaseCommands(program);
+      break;
+    }
+    case 'tasks': {
+      const { registerTasksCommands } = await import('./cli/tasks-cli.js');
+      registerTasksCommands(program);
+      break;
+    }
+    case 'pty': {
+      const { registerPtyTakeoverCommands } = await import('./cli/pty-takeover-cli.js');
+      registerPtyTakeoverCommands(program);
+      break;
+    }
+    case 'logs': {
+      const { registerLogsCommands } = await import('./cli/logs-cli.js');
+      registerLogsCommands(program);
+      break;
+    }
+    case 'config': {
+      const { getUserConfig } = await import('./user-config.js');
+      const { redactSecrets, redactSecretText } = await import('./debug/log.js');
+      const { resolveCurrentInstance } = await import('./instance/current.js');
+      const redactDisplay = (value: unknown): unknown => {
+        if (Array.isArray(value)) return value.map(redactDisplay);
+        if (value !== null && typeof value === 'object') {
+          return Object.fromEntries(Object.entries(value as Record<string, unknown>).map(([key, child]) => [
+            redactSecretText(key), redactDisplay(child),
+          ]));
+        }
+        return typeof value === 'string' ? redactSecretText(value) : value;
+      };
+      const config = program.command('config').description('Inspect and edit ~/.config/elanous/config.json');
+      config.command('get [path]')
+        .description('Print all config or one dotted path, e.g. llm.provider (secrets redacted by default)')
+        .option('--reveal', 'Print unredacted output and record the reveal')
+        .action(async (path: string | undefined) => {
+          if (resolveCurrentInstance().kind === 'test' && String(resolveCurrentInstance().layer) === 'tree-derived') {
+            console.error('⚠️ test 우주의 config를 읽습니다 — 운영 값은 --config-dir ~/.elanous');
+          }
+          const config = getUserConfig() as unknown as Record<string, unknown>;
+          const lookup = (root: unknown): unknown => {
+            let value = root;
+            for (const part of path?.split('.').filter(Boolean) ?? []) {
+              if (value === null || typeof value !== 'object') return undefined;
+              value = (value as Record<string, unknown>)[part];
+            }
+            return value;
+          };
+          const selected = path ? (lookup(config) ?? lookup(config.raw)) : config;
+          if (selected === undefined) {
+            const { error } = await import('./ui.js');
+            error(`config path not found: ${path}`);
+            process.exitCode = 1;
+            return;
+          }
+          const displayKey = path?.split('.').filter(Boolean).at(-1);
+          const display = displayKey
+            ? redactDisplay(redactSecrets({ [displayKey]: selected })[displayKey])
+            : redactDisplay(redactSecrets(selected));
+          console.log(typeof display === 'string' ? display : JSON.stringify(display, null, 2));
+        });
+      break;
+    }
+  }
+
+  try {
+    await program.parseAsync(['node', 'elanous', ...process.argv.slice(2)]);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

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;
+}