@open-agent-toolkit/cli 0.2.50 → 0.2.52

package/dist/providers/identity/claude-runtime-observation.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Claude runtime metadata parsing.
+ *
+ * Field paths here are taken from real on-disk transcripts under
+ * `~/.claude/projects/`, not from assumption. Every corpus figure in this file
+ * is an operator-environment observation as of 2026-09-02 on the capturing
+ * operator's machine, not a provider guarantee: a later mismatch means the
+ * corpus moved, not that the claim was wrong.
+ *
+ * An earlier revision read only `system`/`init` and `result` records; a scan of
+ * all 2,725 local transcripts found `"subtype":"init"` in zero of them, so that parser returned
+ * `not-reported` against every real transcript while its hand-written fixtures
+ * agreed with it. The on-disk `assistant` entry is now the primary shape.
+ *
+ * Reading an `assistant` entry does not mean reading a conversation. The parser
+ * takes allowlisted entry-level metadata plus exactly two explicit key paths
+ * inside `message` — `message.model` and `message.usage.service_tier`.
+ * `message` is never spread, enumerated, or filtered after the fact, so
+ * `message.content` is not merely dropped later; it is never reached. The
+ * content-trap test pins this: a `message` whose `content` throws on access
+ * still parses cleanly.
+ *
+ * Everything this module produces is per-run, non-authoritative corroboration.
+ * A failed or partial parse yields `not-reported` and never falls back to the
+ * configured invocation.
+ */
+/**
+ * The complete entry-level read surface for an `assistant` entry. `message` is
+ * handled separately by explicit path and is deliberately absent from this
+ * list, so this plus `message.model` and `message.usage.service_tier` is
+ * everything the parser touches. Exported so a test can pin it: a future widening
+ * has to change this list, in view, rather than slip in at a call site.
+ *
+ * `attributionAgent` is the role identifier and is the same class of signal
+ * Codex carries as `agent_role`: a bounded enum-like name, not conversation
+ * content. Across 2,725 captured transcripts it took 8 distinct values, all
+ * of which pass the shared identifier validator, with a longest value of 21
+ * characters against the 256 bound. It appears on subagent turns only, so a
+ * main session reports no role rather than a synthesized one.
+ */
+export declare const CLAUDE_ASSISTANT_KEYS: readonly ['type', 'isSidechain', 'effort', 'attributionAgent', 'sessionId', 'session_id', 'requestId'];
+/**
+ * Stream-json entry keys, for `claude -p --output-format stream-json`.
+ *
+ * UNVERIFIED: no captured artifact of that format was available, and zero of
+ * the 2,725 observed local transcripts contained a `system`/`init` record. This path is
+ * retained as a secondary shape and must not be presented as equally grounded
+ * with the on-disk shape above.
+ */
+export declare const CLAUDE_INIT_KEYS: readonly ['type', 'subtype', 'model', 'service_tier', 'serviceTier', 'agent', 'subagent_type', 'reasoning_effort', 'effort', 'request_id'];
+export declare const CLAUDE_OBSERVATION_SOURCE = "claude-session-metadata";
+export interface ClaudeRuntimeMetadata {
+    /**
+     * `root` for a main session, `depth-unknown` for a subagent turn.
+     *
+     * `isSidechain` is the only lineage signal Claude emits and it is binary. No
+     * depth, nesting, level, or ancestry key appeared on any of the 141,078
+     * observed assistant entries, and `parentUuid` never crosses an `agentId`
+     * boundary, so it chains messages within one agent rather than agents to
+     * each other. A depth number is therefore not derivable and is not invented.
+     */
+    childLineage: string | null;
+    /** Observed role, from `attributionAgent`; `null` when the run reports none. */
+    role: string | null;
+    model: string | null;
+    effort: string | null;
+    serviceTier: string | null;
+    /**
+     * OAT request correlation declared by the provider, for parity with the Codex
+     * parser. Claude declares none, so this is `null` on a real transcript.
+     * Claude's own `requestId` is a per-turn API identifier and its `sessionId` a
+     * transcript identifier; neither is an OAT dispatch request id, so neither is
+     * equality-checked against one.
+     */
+    requestId: string | null;
+    /** Provider session identifier, used to prove the envelope is one session. */
+    sessionId: string | null;
+}
+/**
+ * Extract the child's metadata from Claude transcript entries.
+ *
+ * The applicable turn is the last one: it is the most recent state the session
+ * reported. Earlier turns fill only the fields the last one left unreported.
+ * Returns `null` when no Claude metadata is present, or when the entries mix
+ * sessions — every captured transcript carries exactly one `sessionId`, so more
+ * than one means no single applicable child exists.
+ */
+export declare function extractClaudeRuntimeMetadata(entries: readonly unknown[]): ClaudeRuntimeMetadata | null;
+/**
+ * Neutral observation facts for the cross-provider projection.
+ *
+ * The single-session guarantee runs in-process inside
+ * {@link extractClaudeRuntimeMetadata}, so `sessionId` never needs to survive
+ * into the projected output — which matters, because `sessionId` classifies
+ * sensitive and previously made every real transcript unrecordable.
+ */
+export declare function observeClaudeRuntimeFacts(entries: readonly unknown[]): {
+    lineage: string | null;
+    role: string | null;
+    model: string | null;
+    effort: string | null;
+    serviceTier: string | null;
+    correlation: string | null;
+} | null;
+//# sourceMappingURL=claude-runtime-observation.d.ts.map

package/dist/providers/identity/claude-runtime-observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-runtime-observation.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/claude-runtime-observation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,YAChC,MAAM,EACN,aAAa,EACb,QAAQ,EACR,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,WAAW,CACH,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,YAC3B,MAAM,EACN,SAAS,EACT,OAAO,EACP,cAAc,EACd,aAAa,EACb,OAAO,EACP,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,YAAY,CACJ,CAAC;AAEX,eAAO,MAAM,yBAAyB,4BAA4B,CAAC;AAEnE,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,gFAAgF;IAChF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,8EAA8E;IAC9E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AA+FD;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,SAAS,OAAO,EAAE,GAC1B,qBAAqB,GAAG,IAAI,CAmD9B;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG;IACtE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,IAAI,CAWP"}

package/dist/providers/identity/claude-runtime-observation.fixtures.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Captured Claude transcript metadata, sanitized.
+ *
+ * Derived from real on-disk transcripts under `~/.claude/projects/`, which is
+ * the format Claude actually writes. Corpus counts below are
+ * operator-environment observations (as of 2026-09-02, on the capturing operator's machine). They replaced hand-written fixtures built
+ * around `system`/`init` and `result` records: a scan of all 2,725 local
+ * transcripts found `"subtype":"init"` in zero of them, so the previous parser
+ * returned `not-reported` against every real transcript while its own fixtures
+ * agreed with it.
+ *
+ * Sanitization is allowlist-based. Retained: the entry-level metadata keys the
+ * parser reads plus a few it does not (`version`, `userType`, `uuid`), so the
+ * fixtures still demonstrate that unread keys are dropped. `message` is reduced
+ * to the two explicit key paths the parser reaches — `message.model` and
+ * `message.usage.service_tier`. Dropped outright: `message.content` (the
+ * conversation), `cwd`, `gitBranch`, `slug`, `agentId`, and the remaining
+ * `attribution*` fields.
+ *
+ * Structural facts these fixtures preserve, each load-bearing:
+ * - `effort` is a real top-level field on an assistant entry. Claude does
+ *   expose a selectable effort axis, so reporting `not-exposed` for it was
+ *   wrong; observed values across 124,804 entries are `high`, `xhigh`,
+ *   `medium`, and `max`.
+ * - `attributionAgent` is the role identifier, and it is exactly the signal
+ *   Codex carries as `agent_role`. It appears on subagent turns only: present
+ *   on 114,600 of 114,657 sidechain entries and on none of the 26,497
+ *   main-session entries. `SIDECHAIN_TRANSCRIPT` therefore carries it and
+ *   `MAIN_SESSION_TRANSCRIPT` does not, which is the real distinction rather
+ *   than a constructed one.
+ * - `isSidechain` distinguishes a main session from a subagent turn. It is the
+ *   only lineage signal present, and it is binary. Role names are not a depth
+ *   signal and are never read as one.
+ * - `sessionId` is constant within a transcript; every one of the 2,655 local
+ *   transcripts that carries one carries exactly one.
+ * - Model and service tier live only under `message`, never at the top level.
+ */
+export declare const MAIN_SESSION_TRANSCRIPT: readonly unknown[];
+export declare const SIDECHAIN_TRANSCRIPT: readonly unknown[];
+//# sourceMappingURL=claude-runtime-observation.fixtures.d.ts.map

package/dist/providers/identity/claude-runtime-observation.fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-runtime-observation.fixtures.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/claude-runtime-observation.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,eAAO,MAAM,uBAAuB,EAAE,SAAS,OAAO,EAoDrD,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,SAAS,OAAO,EAuDlD,CAAC"}

package/dist/providers/identity/claude-runtime-observation.fixtures.js

@@ -0,0 +1,146 @@
+/**
+ * Captured Claude transcript metadata, sanitized.
+ *
+ * Derived from real on-disk transcripts under `~/.claude/projects/`, which is
+ * the format Claude actually writes. Corpus counts below are
+ * operator-environment observations (as of 2026-09-02, on the capturing operator's machine). They replaced hand-written fixtures built
+ * around `system`/`init` and `result` records: a scan of all 2,725 local
+ * transcripts found `"subtype":"init"` in zero of them, so the previous parser
+ * returned `not-reported` against every real transcript while its own fixtures
+ * agreed with it.
+ *
+ * Sanitization is allowlist-based. Retained: the entry-level metadata keys the
+ * parser reads plus a few it does not (`version`, `userType`, `uuid`), so the
+ * fixtures still demonstrate that unread keys are dropped. `message` is reduced
+ * to the two explicit key paths the parser reaches — `message.model` and
+ * `message.usage.service_tier`. Dropped outright: `message.content` (the
+ * conversation), `cwd`, `gitBranch`, `slug`, `agentId`, and the remaining
+ * `attribution*` fields.
+ *
+ * Structural facts these fixtures preserve, each load-bearing:
+ * - `effort` is a real top-level field on an assistant entry. Claude does
+ *   expose a selectable effort axis, so reporting `not-exposed` for it was
+ *   wrong; observed values across 124,804 entries are `high`, `xhigh`,
+ *   `medium`, and `max`.
+ * - `attributionAgent` is the role identifier, and it is exactly the signal
+ *   Codex carries as `agent_role`. It appears on subagent turns only: present
+ *   on 114,600 of 114,657 sidechain entries and on none of the 26,497
+ *   main-session entries. `SIDECHAIN_TRANSCRIPT` therefore carries it and
+ *   `MAIN_SESSION_TRANSCRIPT` does not, which is the real distinction rather
+ *   than a constructed one.
+ * - `isSidechain` distinguishes a main session from a subagent turn. It is the
+ *   only lineage signal present, and it is binary. Role names are not a depth
+ *   signal and are never read as one.
+ * - `sessionId` is constant within a transcript; every one of the 2,655 local
+ *   transcripts that carries one carries exactly one.
+ * - Model and service tier live only under `message`, never at the top level.
+ */
+export const MAIN_SESSION_TRANSCRIPT = [
+    {
+        type: 'assistant',
+        isSidechain: false,
+        effort: 'high',
+        sessionId: '7f9d5ab4-3b08-4a21-adb5-405c04af2d89',
+        requestId: 'req_011Ce9GB4DvzreK2hzChvmgy',
+        uuid: '14c99a81-02ff-4153-8104-3e4d238451f9',
+        parentUuid: '66d090ee-2e16-4b8d-bc67-bcb1027220cb',
+        version: '2.1.234',
+        userType: 'external',
+        message: {
+            model: 'claude-fable-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+    {
+        type: 'assistant',
+        isSidechain: false,
+        effort: 'high',
+        sessionId: '7f9d5ab4-3b08-4a21-adb5-405c04af2d89',
+        requestId: 'req_011Ce9GB4DvzreK2hzChvmgy',
+        uuid: '50ef9865-24e6-4a77-9831-a01258db757f',
+        parentUuid: '14c99a81-02ff-4153-8104-3e4d238451f9',
+        version: '2.1.234',
+        userType: 'external',
+        message: {
+            model: 'claude-fable-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+    {
+        type: 'assistant',
+        isSidechain: false,
+        effort: 'high',
+        sessionId: '7f9d5ab4-3b08-4a21-adb5-405c04af2d89',
+        requestId: 'req_011Ce9GB4DvzreK2hzChvmgy',
+        uuid: '15864101-70c5-48fb-939f-679a458ba679',
+        parentUuid: '50ef9865-24e6-4a77-9831-a01258db757f',
+        version: '2.1.234',
+        userType: 'external',
+        message: {
+            model: 'claude-fable-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+];
+export const SIDECHAIN_TRANSCRIPT = [
+    {
+        type: 'assistant',
+        isSidechain: true,
+        effort: 'high',
+        attributionAgent: 'general-purpose',
+        sessionId: '19c78382-cceb-45ab-bf24-bb8aa284d96b',
+        requestId: 'req_011CdSgeEdPwRsUpVTCihKmV',
+        uuid: '0f106449-eeb9-475c-8186-d70b9d14a82c',
+        parentUuid: '95017f46-0284-49e3-9a7c-597ad4364042',
+        version: '2.1.220',
+        userType: 'external',
+        message: {
+            model: 'claude-opus-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+    {
+        type: 'assistant',
+        isSidechain: true,
+        effort: 'high',
+        attributionAgent: 'general-purpose',
+        sessionId: '19c78382-cceb-45ab-bf24-bb8aa284d96b',
+        requestId: 'req_011CdSgeEdPwRsUpVTCihKmV',
+        uuid: '24c36d1b-c532-447f-9981-8f2b0d0988f8',
+        parentUuid: '0f106449-eeb9-475c-8186-d70b9d14a82c',
+        version: '2.1.220',
+        userType: 'external',
+        message: {
+            model: 'claude-opus-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+    {
+        type: 'assistant',
+        isSidechain: true,
+        effort: 'high',
+        attributionAgent: 'general-purpose',
+        sessionId: '19c78382-cceb-45ab-bf24-bb8aa284d96b',
+        requestId: 'req_011CdSgeEdPwRsUpVTCihKmV',
+        uuid: 'd3453335-a00b-4716-95bf-6a7574903336',
+        parentUuid: 'c0d14665-a467-46e5-abcd-85c3e15ba30e',
+        version: '2.1.220',
+        userType: 'external',
+        message: {
+            model: 'claude-opus-5',
+            usage: {
+                service_tier: 'standard',
+            },
+        },
+    },
+];

package/dist/providers/identity/claude-runtime-observation.js

@@ -0,0 +1,229 @@
+import { observationIdentifier as observedValue } from './oat-dispatch-record.js';
+/**
+ * Claude runtime metadata parsing.
+ *
+ * Field paths here are taken from real on-disk transcripts under
+ * `~/.claude/projects/`, not from assumption. Every corpus figure in this file
+ * is an operator-environment observation as of 2026-09-02 on the capturing
+ * operator's machine, not a provider guarantee: a later mismatch means the
+ * corpus moved, not that the claim was wrong.
+ *
+ * An earlier revision read only `system`/`init` and `result` records; a scan of
+ * all 2,725 local transcripts found `"subtype":"init"` in zero of them, so that parser returned
+ * `not-reported` against every real transcript while its hand-written fixtures
+ * agreed with it. The on-disk `assistant` entry is now the primary shape.
+ *
+ * Reading an `assistant` entry does not mean reading a conversation. The parser
+ * takes allowlisted entry-level metadata plus exactly two explicit key paths
+ * inside `message` — `message.model` and `message.usage.service_tier`.
+ * `message` is never spread, enumerated, or filtered after the fact, so
+ * `message.content` is not merely dropped later; it is never reached. The
+ * content-trap test pins this: a `message` whose `content` throws on access
+ * still parses cleanly.
+ *
+ * Everything this module produces is per-run, non-authoritative corroboration.
+ * A failed or partial parse yields `not-reported` and never falls back to the
+ * configured invocation.
+ */
+/**
+ * The complete entry-level read surface for an `assistant` entry. `message` is
+ * handled separately by explicit path and is deliberately absent from this
+ * list, so this plus `message.model` and `message.usage.service_tier` is
+ * everything the parser touches. Exported so a test can pin it: a future widening
+ * has to change this list, in view, rather than slip in at a call site.
+ *
+ * `attributionAgent` is the role identifier and is the same class of signal
+ * Codex carries as `agent_role`: a bounded enum-like name, not conversation
+ * content. Across 2,725 captured transcripts it took 8 distinct values, all
+ * of which pass the shared identifier validator, with a longest value of 21
+ * characters against the 256 bound. It appears on subagent turns only, so a
+ * main session reports no role rather than a synthesized one.
+ */
+export const CLAUDE_ASSISTANT_KEYS = [
+    'type',
+    'isSidechain',
+    'effort',
+    'attributionAgent',
+    'sessionId',
+    'session_id',
+    'requestId',
+];
+/**
+ * Stream-json entry keys, for `claude -p --output-format stream-json`.
+ *
+ * UNVERIFIED: no captured artifact of that format was available, and zero of
+ * the 2,725 observed local transcripts contained a `system`/`init` record. This path is
+ * retained as a secondary shape and must not be presented as equally grounded
+ * with the on-disk shape above.
+ */
+export const CLAUDE_INIT_KEYS = [
+    'type',
+    'subtype',
+    'model',
+    'service_tier',
+    'serviceTier',
+    'agent',
+    'subagent_type',
+    'reasoning_effort',
+    'effort',
+    'request_id',
+];
+export const CLAUDE_OBSERVATION_SOURCE = 'claude-session-metadata';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * The two explicit key paths inside `message`. Reaching them by path is what
+ * makes the projection narrow; a spread or key-filter would touch
+ * `message.content` on the way.
+ */
+function messageMetadata(entry) {
+    const message = entry.message;
+    if (!isRecord(message))
+        return { model: undefined, serviceTier: undefined };
+    const usage = message.usage;
+    return {
+        model: message.model,
+        serviceTier: isRecord(usage) ? usage.service_tier : undefined,
+    };
+}
+function firstModelUsage(entry) {
+    const usage = entry.modelUsage;
+    if (!isRecord(usage))
+        return null;
+    const [name, detail] = Object.entries(usage)[0] ?? [];
+    if (name === undefined)
+        return null;
+    return {
+        model: observedValue(name),
+        serviceTier: isRecord(detail)
+            ? observedValue(detail.serviceTier ?? detail.service_tier)
+            : null,
+    };
+}
+function assistantTurn(entry) {
+    const { model, serviceTier } = messageMetadata(entry);
+    return {
+        isSidechain: typeof entry.isSidechain === 'boolean' ? entry.isSidechain : null,
+        effort: observedValue(entry.effort),
+        sessionId: observedValue(entry.sessionId ?? entry.session_id),
+        model: observedValue(model),
+        serviceTier: observedValue(serviceTier),
+        requestId: null,
+        // Role only. It never contributes to lineage: `isSidechain` is the sole
+        // lineage signal, and inferring depth from a role name would be exactly
+        // the invention this parser was rewritten to remove.
+        role: observedValue(entry.attributionAgent),
+    };
+}
+/** Secondary, unverified stream-json shape; see CLAUDE_INIT_KEYS. */
+function streamJsonTurn(entry) {
+    if (entry.type === 'system' && entry.subtype === 'init') {
+        return {
+            isSidechain: null,
+            effort: observedValue(entry.reasoning_effort ?? entry.effort),
+            sessionId: null,
+            model: observedValue(entry.model),
+            serviceTier: observedValue(entry.service_tier ?? entry.serviceTier),
+            requestId: observedValue(entry.request_id),
+            role: observedValue(entry.agent ?? entry.subagent_type),
+        };
+    }
+    if (entry.type === 'result') {
+        const usage = firstModelUsage(entry);
+        if (usage === null)
+            return null;
+        return {
+            isSidechain: null,
+            effort: null,
+            sessionId: null,
+            model: usage.model,
+            serviceTier: usage.serviceTier,
+            requestId: null,
+            role: null,
+        };
+    }
+    return null;
+}
+/**
+ * Extract the child's metadata from Claude transcript entries.
+ *
+ * The applicable turn is the last one: it is the most recent state the session
+ * reported. Earlier turns fill only the fields the last one left unreported.
+ * Returns `null` when no Claude metadata is present, or when the entries mix
+ * sessions — every captured transcript carries exactly one `sessionId`, so more
+ * than one means no single applicable child exists.
+ */
+export function extractClaudeRuntimeMetadata(entries) {
+    if (!Array.isArray(entries))
+        return null;
+    const turns = [];
+    for (const entry of entries) {
+        if (!isRecord(entry))
+            continue;
+        // Classification is by discriminator alone.
+        if (entry.type === 'assistant') {
+            turns.push(assistantTurn(entry));
+            continue;
+        }
+        const fallback = streamJsonTurn(entry);
+        if (fallback !== null)
+            turns.push(fallback);
+    }
+    if (turns.length === 0)
+        return null;
+    const sessions = new Set(turns
+        .map((turn) => turn.sessionId)
+        .filter((value) => value !== null));
+    if (sessions.size > 1)
+        return null;
+    const applicable = turns.at(-1);
+    if (!applicable)
+        return null;
+    let model = null;
+    let effort = null;
+    let serviceTier = null;
+    let requestId = null;
+    let role = null;
+    for (const turn of turns) {
+        model = turn.model ?? model;
+        effort = turn.effort ?? effort;
+        serviceTier = turn.serviceTier ?? serviceTier;
+        requestId = turn.requestId ?? requestId;
+        role = turn.role ?? role;
+    }
+    return {
+        childLineage: applicable.isSidechain === null
+            ? null
+            : applicable.isSidechain
+                ? 'depth-unknown'
+                : 'root',
+        role,
+        model,
+        effort,
+        serviceTier,
+        requestId,
+        sessionId: [...sessions][0] ?? null,
+    };
+}
+/**
+ * Neutral observation facts for the cross-provider projection.
+ *
+ * The single-session guarantee runs in-process inside
+ * {@link extractClaudeRuntimeMetadata}, so `sessionId` never needs to survive
+ * into the projected output — which matters, because `sessionId` classifies
+ * sensitive and previously made every real transcript unrecordable.
+ */
+export function observeClaudeRuntimeFacts(entries) {
+    const metadata = extractClaudeRuntimeMetadata(entries);
+    if (metadata === null)
+        return null;
+    return {
+        lineage: metadata.childLineage,
+        role: metadata.role,
+        model: metadata.model,
+        effort: metadata.effort,
+        serviceTier: metadata.serviceTier,
+        correlation: metadata.requestId,
+    };
+}

package/dist/providers/identity/codex-runtime-observation.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Codex rollout metadata parsing.
+ *
+ * Field paths here are taken from captured Codex 0.152.1 rollouts, not from
+ * assumption; see `codex-runtime-observation.fixtures.ts` for the sanitized
+ * captures the tests run against.
+ *
+ * Four accepted paths are UNVERIFIED against any captured rollout and appear
+ * zero times in the operator's local corpus (1,596 rollouts spanning cli_version
+ * 0.142.4-0.152.x, as of 2026-09-02, on the capturing operator's machine): `turn_context.service_tier`,
+ * `turn_context.serviceTier`, `turn_context.reasoning_effort`, and
+ * `session_meta.request_id`. They are retained as forward-compatible readers
+ * and all fail closed to `null`, so no Codex rollout observed to date reports a
+ * service tier, and Codex request correlation is caller-asserted in practice.
+ * They are labelled here for the same reason `CLAUDE_INIT_KEYS` is labelled:
+ * an unverified path must not read as a captured one. An earlier revision of this parser read
+ * `payload.parent_id` and `payload.role`, which Codex does not emit, so every
+ * subagent was misreported as a root with no role while hand-written fixtures
+ * agreed with the parser instead of with the world.
+ *
+ * The parser reads session and turn metadata only. Entries are classified by
+ * their `type` discriminator alone, and the payload of any entry outside
+ * {@link CODEX_METADATA_ENTRY_TYPES} is never touched, so conversation content,
+ * instructions, and tool output cannot be reached from here. Every extracted
+ * value is a short provider identifier validated against a closed shape before
+ * it can become durable evidence.
+ *
+ * Everything this module produces is per-run, non-authoritative corroboration.
+ * A failed or partial parse yields `not-reported`; it never falls back to the
+ * configured invocation, so a requested value cannot masquerade as an
+ * observation.
+ */
+/** Entry types whose payloads are metadata rather than conversation content. */
+export declare const CODEX_METADATA_ENTRY_TYPES: readonly ['session_meta', 'turn_context'];
+export declare const CODEX_OBSERVATION_SOURCE = "codex-rollout-metadata";
+export interface CodexRuntimeMetadata {
+    childLineage: string;
+    role: string | null;
+    model: string | null;
+    effort: string | null;
+    serviceTier: string | null;
+    /** Request correlation declared by the session itself, when present. */
+    requestId: string | null;
+    /** Raw `thread_source`; `user` for a root session, `subagent` for a child. */
+    threadSource: string | null;
+    /**
+     * Raw `forked_from_id`. Recorded without interpretation: a subagent commonly
+     * carries it alongside `parent_thread_id`, so it does not by itself identify
+     * a user fork. See the module tests for what could and could not be
+     * established about fork shapes.
+     */
+    forkedFromId: string | null;
+}
+/**
+ * Extract the applicable child's metadata from Codex rollout entries.
+ *
+ * The applicable session is the *first* `session_meta`: a rollout's own header
+ * is written at ordinal 0, and any embedded parent history follows it.
+ */
+export declare function extractCodexRuntimeMetadata(entries: readonly unknown[]): CodexRuntimeMetadata | null;
+/**
+ * Neutral observation facts for the cross-provider projection.
+ *
+ * Nothing of the rollout's own shape escapes this module: the caller receives
+ * only the closed fact set owned by `runtime-observation.ts`.
+ */
+export declare function observeCodexRuntimeFacts(entries: readonly unknown[]): {
+    lineage: string | null;
+    role: string | null;
+    model: string | null;
+    effort: string | null;
+    serviceTier: string | null;
+    correlation: string | null;
+} | null;
+//# sourceMappingURL=codex-runtime-observation.d.ts.map

package/dist/providers/identity/codex-runtime-observation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-runtime-observation.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/codex-runtime-observation.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,gFAAgF;AAChF,eAAO,MAAM,0BAA0B,YACrC,cAAc,EACd,cAAc,CACN,CAAC;AAIX,eAAO,MAAM,wBAAwB,2BAA2B,CAAC;AAKjE,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,wEAAwE;IACxE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,8EAA8E;IAC9E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B;;;;;OAKG;IACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAkLD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,SAAS,OAAO,EAAE,GAC1B,oBAAoB,GAAG,IAAI,CAyD7B;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,GAAG;IACrE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B,GAAG,IAAI,CAWP"}

package/dist/providers/identity/codex-runtime-observation.fixtures.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Captured Codex rollout metadata, sanitized.
+ *
+ * These fixtures are derived from three real Codex 0.152.1 rollouts produced by
+ * one live nested dispatch on the capturing operator's machine, 2026-09-02: a root `exec` session, a depth-1
+ * subagent, and a depth-2 subagent. They replaced hand-written fixtures that
+ * had been constructed from assumption — those fixtures passed while the parser
+ * did not work against any real rollout, which is exactly the failure mode
+ * captured evidence prevents.
+ *
+ * Sanitization is allowlist-based, so a new upstream field cannot silently
+ * appear here. Only `session_meta` and `turn_context` payloads are retained,
+ * restricted to lineage, identity, and selection keys. Every non-metadata entry
+ * keeps its `type` and `ordinal` and carries no payload at all. Dropped
+ * outright: `base_instructions`, `git`, `cwd`, `workspace_roots`,
+ * `sandbox_policy`, `permission_profile`, and `collaboration_mode` — that is,
+ * every instruction, conversation, absolute-path, and repository-identifying
+ * field.
+ *
+ * Structural facts these fixtures preserve, each load-bearing for the parser:
+ * - A root declares `thread_source: "user"`, a plain string `source`, and no
+ *   `parent_thread_id`.
+ * - A subagent declares `thread_source: "subagent"`, a tagged
+ *   `source.subagent.thread_spawn` object with an authoritative `depth`, and a
+ *   `parent_thread_id` at both the top level and inside `thread_spawn`.
+ * - On a subagent, `session_id` is the *root's* id, not its own. Only `id`
+ *   identifies the session itself.
+ * - The depth-1 rollout embeds its parent's history: its own `session_meta` is
+ *   first at ordinal 0, the parent's `session_meta` follows, and the parent's
+ *   `turn_context` (`gpt-5.6-sol`) precedes its own (`gpt-5.6-terra`).
+ *   `subagent_history_start_ordinal` marks where its own records begin.
+ * - No real `turn_context` carries a service tier.
+ */
+export declare const ROOT_ROLLOUT: readonly unknown[];
+export declare const DEPTH_1_ROLLOUT: readonly unknown[];
+export declare const DEPTH_2_ROLLOUT: readonly unknown[];
+//# sourceMappingURL=codex-runtime-observation.fixtures.d.ts.map

package/dist/providers/identity/codex-runtime-observation.fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-runtime-observation.fixtures.d.ts","sourceRoot":"","sources":["../../../src/providers/identity/codex-runtime-observation.fixtures.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,eAAO,MAAM,YAAY,EAAE,SAAS,OAAO,EA2K1C,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAsO7C,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAsG7C,CAAC"}