@claudexor/harness-codex 3.1.0 → 3.1.2

package/dist/effort-gate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * INV-105 version gate for the codex effort SNAPSHOT, plus the run's one
+ * effort-resolution seam. Split out of effort-probe.ts (discovery mechanics)
+ * so each file keeps a single altitude: the probe answers "what does the
+ * vendor advertise", this module answers "what may THIS run trust".
+ */
+import type { HarnessEvent, HarnessRunSpec } from "@claudexor/schema";
+import { type CodexEffortCatalog, type CodexEffortProbe } from "./effort-probe.js";
+/**
+ * Whether the recorded snapshot may be TRUSTED for arg emission against the
+ * installed binary (INV-105). The snapshot is another CLI version's recorded
+ * `model/list` answer, so it is only that binary's truth on the exact version
+ * it was captured from: 0.144.1 advertises `ultra` on gpt-5.6-sol, an older
+ * codex may not, and an install whose live probe failed used to be handed the
+ * 0.144.1 catalog anyway — `model_reasoning_effort="ultra"` then went to a CLI
+ * that refuses the value. Mirrors `claudeSnapshotTrustedForVersion`.
+ *
+ * The installed version string is whatever `codex --version` printed
+ * (e.g. `codex-cli 0.144.1`), so the comparison extracts the full dotted
+ * numeric token and requires it to EQUAL the snapshot stamp exactly. An
+ * unknown or unparseable version can never vouch for the snapshot.
+ */
+export declare function codexSnapshotTrustedForVersion(installedVersion: string | null): boolean;
+/**
+ * The effort catalog the RUN may resolve `model_reasoning_effort` against,
+ * version-gating snapshot trust (INV-105) — the codex mirror of
+ * `claudeAdvertisedEffortsForRun`:
+ *
+ * - a LIVE `model/list` answer is the installed binary's own truth for the
+ *   resolved env's account — trusted on any version;
+ * - the snapshot FALLBACK is trusted only when the installed version equals
+ *   `CODEX_EFFORT_SNAPSHOT_VERIFIED_AGAINST` (same binary, same catalog);
+ * - a fallback on ANY OTHER version (mismatch, unknown, unparseable) yields an
+ *   EMPTY catalog: the resolver then sends no effort flag at all, and the
+ *   existing drop seam (`codexEffortIgnoredEvent`) discloses it — the run
+ *   proceeds at the vendor default rather than forwarding a level another
+ *   version's snapshot advertises to a binary that may reject it.
+ */
+export declare function codexCatalogForRun(efforts: {
+    catalog: CodexEffortCatalog;
+    live: boolean;
+}, installedVersion: string | null): CodexEffortCatalog;
+/**
+ * The RUN's whole INV-105 effort seam in one place — the codex mirror of
+ * `claudeRunEffortResolution`: probe the catalog for THIS run's resolved env
+ * (profile / API-key `CODEX_HOME`s have their own accounts), version-gate
+ * snapshot-fallback trust (`codexCatalogForRun`), and derive the DROP/CLAMP
+ * disclosure on the SAME catalog the arg builder will resolve against — so the
+ * flag sent and the disclosure emitted can never disagree. The `--version`
+ * spawn happens only when it can matter (snapshot fallback AND an effort
+ * actually requested); a live probe or a hint-less run never pays for it.
+ */
+export declare function codexRunEffortResolution(spec: Pick<HarnessRunSpec, "session_id" | "model_hint" | "effort_hint">, deps: {
+    probeEfforts: CodexEffortProbe;
+    nowMs: () => number;
+    detectVersion: (abortSignal?: AbortSignal, env?: Record<string, string | null | undefined>) => Promise<string | null>;
+}, envPatch?: Record<string, string | null | undefined>, abortSignal?: AbortSignal): Promise<{
+    catalog: CodexEffortCatalog;
+    disclosure: HarnessEvent | null;
+}>;
+//# sourceMappingURL=effort-gate.d.ts.map

package/dist/effort-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effort-gate.d.ts","sourceRoot":"","sources":["../src/effort-gate.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAIvF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE;IAAE,OAAO,EAAE,kBAAkB,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,EACvD,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAC9B,kBAAkB,CAKpB;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,YAAY,GAAG,YAAY,GAAG,aAAa,CAAC,EACvE,IAAI,EAAE;IACJ,YAAY,EAAE,gBAAgB,CAAC;IAC/B,KAAK,EAAE,MAAM,MAAM,CAAC;IACpB,aAAa,EAAE,CACb,WAAW,CAAC,EAAE,WAAW,EACzB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,KAC5C,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC7B,EACD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EACpD,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC;IAAE,OAAO,EAAE,kBAAkB,CAAC;IAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAA;CAAE,CAAC,CAO3E"}

package/dist/effort-gate.js

@@ -0,0 +1,61 @@
+import { CODEX_EFFORT_SNAPSHOT_VERIFIED_AGAINST, codexEffortDisclosureEvent, codexEffortsForEnv, } from "./effort-probe.js";
+/**
+ * Whether the recorded snapshot may be TRUSTED for arg emission against the
+ * installed binary (INV-105). The snapshot is another CLI version's recorded
+ * `model/list` answer, so it is only that binary's truth on the exact version
+ * it was captured from: 0.144.1 advertises `ultra` on gpt-5.6-sol, an older
+ * codex may not, and an install whose live probe failed used to be handed the
+ * 0.144.1 catalog anyway — `model_reasoning_effort="ultra"` then went to a CLI
+ * that refuses the value. Mirrors `claudeSnapshotTrustedForVersion`.
+ *
+ * The installed version string is whatever `codex --version` printed
+ * (e.g. `codex-cli 0.144.1`), so the comparison extracts the full dotted
+ * numeric token and requires it to EQUAL the snapshot stamp exactly. An
+ * unknown or unparseable version can never vouch for the snapshot.
+ */
+export function codexSnapshotTrustedForVersion(installedVersion) {
+    if (installedVersion === null)
+        return false;
+    const token = installedVersion.match(/\d+(?:\.\d+)+/);
+    return token !== null && token[0] === CODEX_EFFORT_SNAPSHOT_VERIFIED_AGAINST;
+}
+/**
+ * The effort catalog the RUN may resolve `model_reasoning_effort` against,
+ * version-gating snapshot trust (INV-105) — the codex mirror of
+ * `claudeAdvertisedEffortsForRun`:
+ *
+ * - a LIVE `model/list` answer is the installed binary's own truth for the
+ *   resolved env's account — trusted on any version;
+ * - the snapshot FALLBACK is trusted only when the installed version equals
+ *   `CODEX_EFFORT_SNAPSHOT_VERIFIED_AGAINST` (same binary, same catalog);
+ * - a fallback on ANY OTHER version (mismatch, unknown, unparseable) yields an
+ *   EMPTY catalog: the resolver then sends no effort flag at all, and the
+ *   existing drop seam (`codexEffortIgnoredEvent`) discloses it — the run
+ *   proceeds at the vendor default rather than forwarding a level another
+ *   version's snapshot advertises to a binary that may reject it.
+ */
+export function codexCatalogForRun(efforts, installedVersion) {
+    if (efforts.live)
+        return efforts.catalog;
+    return codexSnapshotTrustedForVersion(installedVersion)
+        ? efforts.catalog
+        : { models: {}, defaultModel: null };
+}
+/**
+ * The RUN's whole INV-105 effort seam in one place — the codex mirror of
+ * `claudeRunEffortResolution`: probe the catalog for THIS run's resolved env
+ * (profile / API-key `CODEX_HOME`s have their own accounts), version-gate
+ * snapshot-fallback trust (`codexCatalogForRun`), and derive the DROP/CLAMP
+ * disclosure on the SAME catalog the arg builder will resolve against — so the
+ * flag sent and the disclosure emitted can never disagree. The `--version`
+ * spawn happens only when it can matter (snapshot fallback AND an effort
+ * actually requested); a live probe or a hint-less run never pays for it.
+ */
+export async function codexRunEffortResolution(spec, deps, envPatch, abortSignal) {
+    const efforts = await codexEffortsForEnv(deps, envPatch);
+    const catalog = efforts.live || !spec.effort_hint
+        ? efforts.catalog
+        : codexCatalogForRun(efforts, await deps.detectVersion(abortSignal, envPatch));
+    return { catalog, disclosure: codexEffortDisclosureEvent(catalog, spec) };
+}
+//# sourceMappingURL=effort-gate.js.map

package/dist/effort-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effort-gate.js","sourceRoot":"","sources":["../src/effort-gate.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,sCAAsC,EACtC,0BAA0B,EAC1B,kBAAkB,GAGnB,MAAM,mBAAmB,CAAC;AAE3B;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,8BAA8B,CAAC,gBAA+B;IAC5E,IAAI,gBAAgB,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC5C,MAAM,KAAK,GAAG,gBAAgB,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IACtD,OAAO,KAAK,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,sCAAsC,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAuD,EACvD,gBAA+B;IAE/B,IAAI,OAAO,CAAC,IAAI;QAAE,OAAO,OAAO,CAAC,OAAO,CAAC;IACzC,OAAO,8BAA8B,CAAC,gBAAgB,CAAC;QACrD,CAAC,CAAC,OAAO,CAAC,OAAO;QACjB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,CAAC;AACzC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,IAAuE,EACvE,IAOC,EACD,QAAoD,EACpD,WAAyB;IAEzB,MAAM,OAAO,GAAG,MAAM,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IACzD,MAAM,OAAO,GACX,OAAO,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,WAAW;QAC/B,CAAC,CAAC,OAAO,CAAC,OAAO;QACjB,CAAC,CAAC,kBAAkB,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IACnF,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,0BAA0B,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC;AAC5E,CAAC"}

package/dist/effort-probe.d.ts

@@ -0,0 +1,167 @@
+import type { HarnessEvent, HarnessRunSpec, ModelEffortCapability } from "@claudexor/schema";
+import { EffortHint } from "@claudexor/schema";
+export type CodexEffortCapability = Record<string, ModelEffortCapability>;
+/**
+ * One account's whole advertised effort surface: the per-model vocabularies
+ * PLUS which model codex itself runs when no `-m` is given (`model/list` marks
+ * it with `isDefault`). The default matters for effort resolution: a run with
+ * no model hint executes on the DEFAULT model, so its ladder — not the
+ * harness-wide union — is what a requested level must be held to.
+ */
+export interface CodexEffortCatalog {
+    models: CodexEffortCapability;
+    /** `model/list` entry flagged `isDefault: true`; null when the vendor marked none. */
+    defaultModel: string | null;
+}
+/**
+ * Recorded fallback, captured from a live `model/list` on the CLI version
+ * stamped below. Used ONLY when the live probe cannot answer; it is a snapshot
+ * of vendor state, never an allow-list this repo maintains by hand.
+ * (`defaultModel` is the entry that carried `isDefault: true` in that capture.)
+ */
+export declare const CODEX_EFFORT_SNAPSHOT: CodexEffortCatalog;
+/** Vendor CLI version `CODEX_EFFORT_SNAPSHOT` was captured from. */
+export declare const CODEX_EFFORT_SNAPSHOT_VERIFIED_AGAINST = "0.144.1";
+/**
+ * Harness-wide merged ladder of an advertised catalog, weakest→strongest. Kept
+ * as the coarse `effort_levels` fallback so every existing reader (settings
+ * validation, the composer's picker, INV-105 disclosure) keeps working while
+ * per-model narrowing happens through `effortLevelsForModel`.
+ *
+ * Ordering authority is the VENDOR: `model/list` returns each model's
+ * `supportedReasoningEfforts` already ordered weakest→strongest, so the
+ * harness ladder is the positional merge of those lists (`mergeEffortLadders`)
+ * — never a table this repo maintains. The Swift composer merges the manifests'
+ * already-ordered arrays the same way, so both sides of the wire agree.
+ *
+ * A level NO model orders against the rest (`unconstrained`) still belongs to
+ * the advertised set — some model really accepts it — but has no honest rank,
+ * so it trails the ranked merge here (membership/display) while staying
+ * excluded from the clamping order (`mergeEffortLadders.order`).
+ */
+export declare function unionEffortLevels(capability: CodexEffortCapability): EffortHint[];
+/**
+ * The whole `model/list` payload as a capability map, or null for a FAILED probe.
+ *
+ * STRICT on purpose (the reviewed decision): ONE malformed value discards the
+ * ENTIRE live catalog and the caller degrades to the recorded snapshot, which is
+ * exactly what this module promises. Skipping the bad entry instead would publish
+ * a silently NARROWED ladder — a model advertising `["low", "HIGH!"]` would go out
+ * as `["low"]`, stamped with the installed CLI version, so a `high` request would
+ * clamp down to `low` and the freshness gate would call the ladder fresh. And a
+ * malformed value that reached the manifest would fail `HarnessManifest.parse`,
+ * breaking discovery rather than degrading it. The snapshot is a real, usable
+ * ladder, so strictness costs freshness and never capability.
+ *
+ * `defaultModel` is the entry the vendor flagged `isDefault: true`
+ * (live-verified on 0.144.1). Only a literal boolean true counts: the flag is
+ * model identity, not part of the effort wire contract, so an absent or odd
+ * value degrades the default to null rather than poisoning the catalog.
+ */
+export declare function readModelListEfforts(data: unknown): CodexEffortCatalog | null;
+/**
+ * Ask a live `codex app-server` what each model advertises. Resolves to null on
+ * ANY failure — the caller falls back to the snapshot.
+ */
+export declare function probeCodexEfforts(bin: string, opts?: {
+    timeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}): Promise<CodexEffortCatalog | null>;
+/** Drop the cached effort probe (tests; and the doctor's `fresh` path). */
+export declare function clearCodexEffortCache(): void;
+/** Live entry count. Exported so the bound above can be asserted, not assumed. */
+export declare function codexEffortCacheSize(): number;
+/** Live per-model discovery for one binary in one resolved environment. */
+export type CodexEffortProbe = (bin: string, env?: NodeJS.ProcessEnv) => Promise<CodexEffortCatalog | null>;
+/**
+ * The per-model effort vocabulary codex currently advertises FOR THIS ENV. Live
+ * when the app-server answers, the recorded snapshot otherwise — a probe failure
+ * degrades the ladder's freshness, never the run.
+ */
+export declare function codexEffortCapability(probe: CodexEffortProbe, nowMs: () => number, bin: string, env?: NodeJS.ProcessEnv): Promise<{
+    catalog: CodexEffortCatalog;
+    live: boolean;
+}>;
+/**
+ * The catalog for the environment a codex child will ACTUALLY run in. ONE owner
+ * of that resolution: callers hand over their env PATCH (spec env + provider
+ * scrub + the resolved `CODEX_HOME`) and this resolves it exactly the way the
+ * spawn will, so the probe env and the cache identity can never disagree.
+ *
+ * An API-key route uses a fresh temporary `CODEX_HOME` per run, so it re-probes
+ * each time by construction. That is the correct trade: one bounded app-server
+ * spawn instead of a cross-account catalog served out of the cache.
+ */
+export declare function codexEffortsForEnv(deps: {
+    probeEfforts: CodexEffortProbe;
+    nowMs: () => number;
+}, envPatch?: Record<string, string | null | undefined>): Promise<{
+    catalog: CodexEffortCatalog;
+    live: boolean;
+}>;
+/**
+ * The full outcome of resolving one (model, requested) pair against a catalog:
+ * what to send, whether the merged vendor order MOVED it there, and which
+ * model's ladder decided. `codexEffortFor` keeps only the level for the arg
+ * builder; the disclosure seams need the other two facts, because a CLAMP is a
+ * changed setting the user asked for differently (INV-105) even though a flag
+ * is still sent.
+ */
+export interface CodexEffortResolution {
+    /** The level to send, or null when no flag should be sent at all. */
+    effort: EffortHint | null;
+    /** True when `effort` differs from the request — the merged vendor order clamped it. */
+    clamped: boolean;
+    /** The model whose advertised ladder decided this (the hint, or the catalog default). */
+    effectiveModel: string | null;
+}
+/**
+ * The effort value to send for one (model, requested) pair: advertised passes
+ * through verbatim, a level a SIBLING model advertises clamps inside the merged
+ * vendor order (`ultra` on gpt-5.4 → `xhigh` because the merged codex ladder
+ * places it), anything else sends no flag at all.
+ *
+ * If a future catalog ever contains two models whose advertised orders
+ * genuinely contradict each other, there is no honest merged rank — so
+ * cross-model clamping is treated as IMPOSSIBLE (the ladder collapses to the
+ * model's own list) and an unadvertised level is refused rather than clamped
+ * along an order this repo would have had to invent.
+ */
+export declare function codexEffortResolution(catalog: CodexEffortCatalog, model: string | null | undefined, requested: EffortHint | null | undefined): CodexEffortResolution;
+/**
+ * The level the arg builder should emit for one (model, requested) pair, or
+ * null when no flag should be sent. Thin projection of
+ * `codexEffortResolution`; the run-side disclosure seams read the full
+ * resolution so a clamp or a drop is never silent.
+ */
+export declare function codexEffortFor(catalog: CodexEffortCatalog, model: string | null | undefined, requested: EffortHint | null | undefined): EffortHint | null;
+/**
+ * The INV-105 disclosure for an effort the RUN itself could not honor, or null
+ * when nothing was dropped. Preflight validates against the manifest — the
+ * DEFAULT account's catalog — but the adapter resolves against the catalog for
+ * the env the child actually runs in (profile / API-key homes have their own
+ * accounts), so a level can pass preflight and still resolve to "send no flag"
+ * here. Without this event that run silently executed at the vendor default;
+ * the payload rides the same `ignored_settings` channel governance uses, so
+ * the timeline renders the same warning either way.
+ */
+export declare function codexEffortIgnoredEvent(catalog: CodexEffortCatalog, spec: Pick<HarnessRunSpec, "session_id" | "model_hint" | "effort_hint">): HarnessEvent | null;
+/**
+ * The INV-105 disclosure for an effort the run CLAMPED, or null when the
+ * requested level rode through verbatim (or was dropped — that is
+ * `codexEffortIgnoredEvent`'s shape, and the two are mutually exclusive: a
+ * drop sends no level, a clamp sends a different one). A clamp is quieter than
+ * a drop but just as much a changed setting: `--effort ultra` on gpt-5.4 runs
+ * at `xhigh`, and without this event nothing in the timeline said so. The
+ * payload rides the same `ignored_settings` channel governance and the drop
+ * seam use, so every existing reader renders the same warning.
+ */
+/**
+ * The one INV-105 seam the run yields: the DROP disclosure or the CLAMP
+ * disclosure, whichever applies (they are mutually exclusive by construction —
+ * a drop sends no flag, a clamp sends a different one), or null when the
+ * requested level rode through verbatim or nothing was requested.
+ */
+export declare function codexEffortDisclosureEvent(catalog: CodexEffortCatalog, spec: Pick<HarnessRunSpec, "session_id" | "model_hint" | "effort_hint">): HarnessEvent | null;
+export declare function codexEffortClampedEvent(catalog: CodexEffortCatalog, spec: Pick<HarnessRunSpec, "session_id" | "model_hint" | "effort_hint">): HarnessEvent | null;
+//# sourceMappingURL=effort-probe.d.ts.map

package/dist/effort-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effort-probe.d.ts","sourceRoot":"","sources":["../src/effort-probe.ts"],"names":[],"mappings":"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"}