@claudexor/harness-claude 3.0.4 → 3.1.1

package/dist/effort-probe.js

@@ -0,0 +1,339 @@
+import { EffortHint } from "@claudexor/schema";
+import { normalizeEffort, resolveEffort, runCapture } from "@claudexor/core";
+import { nowIso, redactSecrets } from "@claudexor/util";
+export const BIN = process.env.CLAUDEXOR_CLAUDE_BIN || "claude";
+/**
+ * Recorded fallback, captured from `claude --help` on the CLI version stamped
+ * below. Used ONLY when the live parse cannot answer.
+ */
+export const CLAUDE_EFFORT_SNAPSHOT = [
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Vendor CLI version `CLAUDE_EFFORT_SNAPSHOT` was captured from. */
+export const CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST = "2.1.165";
+/**
+ * Whether the recorded snapshot may be TRUSTED for arg emission against the
+ * installed binary (INV-105). The snapshot is another `--help`'s recorded
+ * answer, so it is only that binary's truth on the exact CLI version it was
+ * captured from: 2.1.165 advertises `xhigh`, 2.1.89 rejects it, and a 2.1.89
+ * install whose live parse failed used to be handed the 2.1.165 ladder anyway
+ * — `--effort xhigh` then went to a CLI that refuses the flag.
+ *
+ * The installed version string is whatever `claude --version` printed
+ * (e.g. `2.1.165 (Claude Code)`), 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 claudeSnapshotTrustedForVersion(installedVersion) {
+    if (installedVersion === null)
+        return false;
+    const token = installedVersion.match(/\d+(?:\.\d+)+/);
+    return token !== null && token[0] === CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST;
+}
+/**
+ * The effort ladder the RUN may resolve `--effort` against, version-gating
+ * snapshot trust (INV-105):
+ *
+ * - a LIVE parse is the installed binary's own answer — trusted on any version;
+ * - the snapshot FALLBACK is trusted only when the installed version equals
+ *   `CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST` (same binary, same ladder);
+ * - a fallback on ANY OTHER version (mismatch, unknown, unparseable) yields an
+ *   EMPTY ladder: the normalizer then sends no `--effort` flag at all, and the
+ *   existing drop seam (`claudeEffortIgnoredEvent`) 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 claudeAdvertisedEffortsForRun(efforts, installedVersion) {
+    if (efforts.live)
+        return efforts.levels;
+    return claudeSnapshotTrustedForVersion(installedVersion) ? efforts.levels : [];
+}
+/**
+ * The RUN's whole INV-105 effort seam in one place: probe the installed
+ * binary's ladder, version-gate snapshot-fallback trust
+ * (`claudeAdvertisedEffortsForRun`), and derive the DROP/CLAMP disclosure on
+ * the SAME advertised list 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 (fallback ladder AND an effort actually
+ * requested); a live parse or a hint-less run never pays for it.
+ */
+export async function claudeRunEffortResolution(spec, deps, abortSignal) {
+    const efforts = await deps.probeEffortLevels(abortSignal);
+    const advertised = efforts.live || !spec.effort_hint
+        ? efforts.levels
+        : claudeAdvertisedEffortsForRun(efforts, await deps.detectVersion(abortSignal));
+    return { advertised, disclosure: claudeEffortDisclosureEvent(spec, advertised) };
+}
+/**
+ * How many lines of a wrapped `--effort` block the parse will read. Generous
+ * next to the widest observed wrap (four lines at 40 columns) and still a hard
+ * stop, so an `--effort` line that documents nothing cannot reach into a later
+ * option's parentheses.
+ */
+const EFFORT_HELP_BLOCK_MAX_LINES = 8;
+/**
+ * Pull the advertised levels out of `claude --help` text, or null when the
+ * `--effort` line is absent or documents no values.
+ *
+ * Pure and separately testable: the spawn lives in the adapter's runtime deps so
+ * a test can feed recorded help text for any CLI version.
+ */
+export function parseClaudeEffortHelp(help) {
+    const lines = help.split(/\r?\n/);
+    // Match the flag TOKEN, not a substring: `line.includes("--effort")` also
+    // matched `--effort-budget`, anchoring the parse on the wrong flag's block.
+    const start = lines.findIndex((line) => line.split(/[\s,]+/).some((token) => token === "--effort"));
+    if (start < 0)
+        return null;
+    // The value list wraps at the rendering width, and a narrower terminal pushes
+    // the closing paren further down (2.1.165 at 40 columns needs four lines), so
+    // a fixed line count silently loses the list. Read this flag's OWN block
+    // instead: everything up to the next documented flag or the blank line that
+    // ends the section, bounded so a paren from unrelated prose can never be
+    // mistaken for the effort list.
+    let end = start + 1;
+    for (; end < lines.length && end - start < EFFORT_HELP_BLOCK_MAX_LINES; end += 1) {
+        const next = lines[end] ?? "";
+        // ANY new option line ends the block, SHORT alias included. Matching only a
+        // leading `--` let a layout that renders aliases (`  -m, --model <model>`)
+        // run straight past the next flag; the block then reached far enough that the
+        // LAST parenthesized group came from THAT flag instead — and a group like
+        // `(opus, sonnet, haiku)` is comma-separated lowercase slugs, so it passes as
+        // a value list and publishes model names as the effort ladder.
+        if (next.trim() === "" || /^\s*--?[A-Za-z0-9]/.test(next))
+            break;
+    }
+    const window = lines.slice(start, end).join(" ");
+    // The FIRST paren in the block is not necessarily the value list: a vendor
+    // annotation can precede it ("Effort level (beta) (low, medium, high, max)"),
+    // and `beta` is itself a well-formed slug, so anchoring on the first group
+    // published a bogus one-level ladder instead of falling back to the snapshot.
+    // Take the LAST group that actually looks like a value list — which also
+    // survives an annotation placed AFTER the list.
+    let levels = null;
+    for (const group of window.matchAll(/\(([^()]*)\)/g)) {
+        const parsed = readEffortGroup(group[1] ?? "");
+        // Same policy as the codex probe: ONE malformed token inside a value list
+        // fails the WHOLE parse (snapshot fallback). Skipping the token instead
+        // would publish a silently NARROWED ladder stamped as live — a real level
+        // would clamp away or refuse against a list the vendor never printed.
+        if (parsed === MALFORMED)
+            return null;
+        levels = parsed ?? levels;
+    }
+    return levels;
+}
+/**
+ * A parenthesized group that ENUMERATES like a value list but carries a token
+ * that is not an `EffortHint`. Distinct from `null` (not a value list at all —
+ * an annotation like `(beta)`, which is skipped): this poisons the whole parse.
+ */
+const MALFORMED = Symbol("malformed-effort-group");
+/**
+ * The levels one parenthesized group advertises, or null when the group is not a
+ * value list at all.
+ *
+ * A group qualifies only if it ENUMERATES (a comma or pipe): with no rank
+ * table, a lone `(high)` is indistinguishable from an annotation like
+ * `(beta)`, and the vendor's real value list has always enumerated. A help
+ * text that ever documents a genuine one-level ladder falls back to the
+ * recorded snapshot instead of guessing.
+ *
+ * STRICT inside an enumerating group, matching the codex probe's reviewed
+ * policy: a token that fails the `EffortHint` contract (prose, an over-long
+ * slug, invalid characters) is MALFORMED and fails the whole parse, because
+ * skipping it would publish a silently narrowed ladder as live — and the
+ * snapshot fallback is a real, usable ladder, so strictness costs freshness,
+ * never capability.
+ */
+function readEffortGroup(body) {
+    if (!/[,|]/.test(body))
+        return null;
+    const levels = [];
+    for (const raw of body.split(/[,|]/)) {
+        const parsed = EffortHint.safeParse(raw.trim());
+        if (!parsed.success)
+            return MALFORMED;
+        if (!levels.includes(parsed.data))
+            levels.push(parsed.data);
+    }
+    return levels.length > 0 ? levels : null;
+}
+/**
+ * Wall clock the shared capture is bounded by. It replaces the caller abort
+ * signal that used to bound it, so the spawn still cannot hang forever without
+ * belonging to any one caller.
+ */
+const HELP_PROBE_TIMEOUT_MS = 10_000;
+let helpProbePromise = null;
+/** What an abandoned caller reads, without the shared capture ever seeing it. */
+function abandonedProbe() {
+    return { ok: false, error: "claude --help probe abandoned: the caller was cancelled" };
+}
+/**
+ * The ONE `claude --help` capture, owned by the module rather than by whichever
+ * caller happened to ask for it first. The readonly-flag probe and the effort
+ * ladder both ask the same installed binary the same question, so they share a
+ * single spawn rather than growing a second discovery mechanism.
+ *
+ * Two properties keep the sharing honest, and the first cache had neither:
+ *
+ * 1. NO CALLER'S ABORT SIGNAL REACHES THE SPAWN. Threading the first caller's
+ *    signal in here made a process-wide resource the private property of one
+ *    run: cancelling that run killed the capture, and the memo then handed the
+ *    corpse to every later run. Its own wall clock bounds it instead.
+ * 2. ONLY AN ANSWER IS KEPT. A `--help` that never ran (spawn error) or that the
+ *    timeout killed (`code === null`, no exit status of its own) says nothing
+ *    about the installed binary, so keeping it turns one bad moment into a
+ *    permanent one; those outcomes drop the memo and the next caller re-probes.
+ *    A real exit is a fact about this binary — non-zero included — and stays.
+ *
+ * The stakes are higher than staleness. The ladder falls back to a snapshot
+ * recorded from CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST, so a poisoned memo on a
+ * machine running an older CLI does not merely lose freshness: it advertises and
+ * forwards `xhigh` to a binary that rejects it, for the life of the daemon.
+ */
+function sharedHelpCapture() {
+    if (helpProbePromise)
+        return helpProbePromise;
+    const pending = (async () => {
+        try {
+            const result = await runCapture(BIN, ["--help"], {
+                timeoutMs: HELP_PROBE_TIMEOUT_MS,
+                cancelSignal: "SIGTERM",
+                cancelKillDelayMs: 0,
+            });
+            return { ok: true, help: `${result.stdout}\n${result.stderr}`, code: result.code };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                error: redactSecrets(error instanceof Error ? error.message : String(error)),
+            };
+        }
+    })();
+    helpProbePromise = pending;
+    // Identity-guarded so a late settle can only ever clear its OWN memo, never a
+    // re-probe another caller has already started.
+    const forget = () => {
+        if (helpProbePromise === pending)
+            helpProbePromise = null;
+    };
+    void pending.then((probe) => {
+        if (!probe.ok || probe.code === null)
+            forget();
+    }, forget);
+    return pending;
+}
+/**
+ * The shared capture, with the caller's cancellation bounding only the CALLER'S
+ * OWN wait. An abandoned caller reads a probe failure — its run is going away
+ * anyway, and the ladder falls back to the snapshot for that one run — while the
+ * capture keeps running for everybody else.
+ */
+export function probeClaudeHelp(abortSignal) {
+    const shared = sharedHelpCapture();
+    if (!abortSignal)
+        return shared;
+    if (abortSignal.aborted)
+        return Promise.resolve(abandonedProbe());
+    return new Promise((resolve) => {
+        const abandon = () => resolve(abandonedProbe());
+        abortSignal.addEventListener("abort", abandon, { once: true });
+        void shared.then((probe) => {
+            abortSignal.removeEventListener("abort", abandon);
+            resolve(probe);
+        });
+    });
+}
+/**
+ * The effort ladder the INSTALLED claude binary advertises, falling back to the
+ * recorded snapshot when `--help` cannot be read or no longer documents the
+ * values. A probe failure costs freshness, never the run.
+ */
+export async function probeClaudeEffortLevels(abortSignal) {
+    const probe = await probeClaudeHelp(abortSignal);
+    const parsed = probe.ok ? parseClaudeEffortHelp(probe.help) : null;
+    return parsed ? { levels: parsed, live: true } : { levels: CLAUDE_EFFORT_SNAPSHOT, live: false };
+}
+/**
+ * The INV-105 disclosure for an effort the RUN itself could not honor, or null
+ * when nothing was dropped. Preflight validates against the manifest ladder,
+ * but the arg builder resolves against what the INSTALLED binary advertises at
+ * run time (an older CLI's `--help` can be narrower than the discovered
+ * manifest), and its normalizer answers "send no flag" — which without this
+ * event was a silent vendor-default run. The payload rides the same
+ * `ignored_settings` channel governance uses (QA-070 timeline warning).
+ */
+export function claudeEffortIgnoredEvent(spec, advertised) {
+    if (!spec.effort_hint)
+        return null;
+    if (normalizeEffort(spec.effort_hint, advertised) !== null)
+        return null;
+    // An EMPTY advertised list is the version-gated snapshot distrust case
+    // (`claudeAdvertisedEffortsForRun`): the installed binary's ladder could not
+    // be read and the recorded snapshot belongs to a different CLI version, so
+    // the honest statement is "unverifiable", not "not accepted".
+    const detail = advertised.length > 0
+        ? `effort=${spec.effort_hint} (not accepted by the installed claude CLI; ` +
+            `it advertises: ${advertised.join(", ")}; the run used the vendor default)`
+        : `effort=${spec.effort_hint} (could not be verified against the installed claude CLI: ` +
+            "its effort ladder could not be read from --help, and the recorded snapshot was " +
+            `captured from CLI ${CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST}, a different version, ` +
+            "so no effort flag was sent; the run used the vendor default)";
+    return {
+        type: "message",
+        session_id: spec.session_id,
+        ts: nowIso(),
+        text: `[effort] ignored: ${detail}`,
+        payload: { ignored_settings: [detail] },
+    };
+}
+/**
+ * The INV-105 disclosure for an effort the resolution CLAMPED, or null when the
+ * level rode through verbatim (or was dropped — `claudeEffortIgnoredEvent`'s
+ * shape; the two are mutually exclusive: a drop sends no flag, a clamp sends a
+ * different one). Mirrors the codex clamp seam so a moved level is disclosed
+ * the same way on both adapters, and takes the SAME (advertised, ladder)
+ * inputs the arg builder's normalizer takes so the disclosure can never
+ * disagree with the flag actually sent.
+ *
+ * Reachability today: the arg builder resolves with the installed binary's own
+ * list as both advertised set and rank ladder (`normalizeEffort`'s two-arg
+ * form), and against one's own ladder every miss is a DROP, never a clamp —
+ * so with current call sites this event only fires if a rank ladder broader
+ * than the binary's list is ever threaded through (the codex-shaped future,
+ * e.g. `ultra` ranking above a max-capped binary and clamping onto `max`).
+ * The seam exists precisely so that future cannot be silent.
+ */
+/**
+ * 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 function claudeEffortDisclosureEvent(spec, advertised) {
+    return claudeEffortIgnoredEvent(spec, advertised) ?? claudeEffortClampedEvent(spec, advertised);
+}
+export function claudeEffortClampedEvent(spec, advertised, ladder = advertised) {
+    if (!spec.effort_hint)
+        return null;
+    const check = resolveEffort(spec.effort_hint, advertised, ladder);
+    if (check.status !== "ok" || !check.clamped || check.effort === null)
+        return null;
+    const detail = `effort=${spec.effort_hint} (clamped to ${check.effort}: the requested level is not ` +
+        `advertised by the installed claude CLI (it advertises: ${advertised.join(", ")}), ` +
+        `so the run sent ${check.effort}, the nearest level it advertises)`;
+    return {
+        type: "message",
+        session_id: spec.session_id,
+        ts: nowIso(),
+        text: `[effort] clamped: ${detail}`,
+        payload: { ignored_settings: [detail] },
+    };
+}
+//# sourceMappingURL=effort-probe.js.map

package/dist/effort-probe.js.map

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

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-import type { AuthSourceReadiness, HarnessRunSpec } from "@claudexor/schema";
+import type { AuthSourceReadiness, EffortHint, HarnessRunSpec } from "@claudexor/schema";
 import type { HarnessAdapter } from "@claudexor/core";
 import { runCapture, runCliHarness, selectStrictAuthRoute } from "@claudexor/core";
 export { claudeAccountIdentity, defaultNativeClaudeConfigDir } from "./native-home.js";
 export { canonicalProfileConfigDir } from "./profile.js";
 import { smokeIsolatedApiKey, smokeIsolatedOAuthToken } from "./smoke.js";
-export declare const BIN: string;
+import { probeClaudeEffortLevels } from "./effort-probe.js";
+export { BIN, CLAUDE_EFFORT_SNAPSHOT } from "./effort-probe.js";
 export declare const CLAUDE_PROVIDER_ENV_DENYLIST: string[];
 /** Exported for focused route-policy tests; runtime uses this exact selector. */
 export declare const selectClaudeRunAuthRoute: typeof selectStrictAuthRoute;
@@ -13,6 +14,14 @@ export interface ClaudeReadonlyProfileProbe {
     missingFlags: string[];
     detail: string;
 }
+/**
+ * Derived from the SHARED `--help` capture on every call instead of behind a
+ * second cache of its own. That cache had the same defect as the one under it —
+ * a probe that failed once (or that a cancelled run read) stayed failed for the
+ * process lifetime, so a long-lived daemon reported readonly enforcement
+ * unavailable forever. It bought nothing either: the spawn is already memoized,
+ * and what is left is a handful of `includes` over text we already hold.
+ */
 export declare function probeClaudeReadonlyProfile(abortSignal?: AbortSignal): Promise<ClaudeReadonlyProfileProbe>;
 declare function detectVersion(abortSignal?: AbortSignal): Promise<string | null>;
 /**
@@ -69,8 +78,13 @@ type ClaudeRuntimeDeps = {
     smokeIsolatedApiKey: typeof smokeIsolatedApiKey;
     smokeIsolatedOAuthToken: typeof smokeIsolatedOAuthToken;
     probeReadonlyProfile: typeof probeClaudeReadonlyProfile;
+    /** Effort ladder of the installed binary; falls back to the recorded snapshot. */
+    probeEffortLevels: typeof probeClaudeEffortLevels;
     runCliHarness: typeof runCliHarness;
 };
 export declare function createClaudeAdapter(deps?: Partial<ClaudeRuntimeDeps>): HarnessAdapter;
-export declare function claudeArgsForSpec(spec: HarnessRunSpec, interactive?: boolean, suppressBare?: boolean): string[];
+export declare function claudeArgsForSpec(spec: HarnessRunSpec, interactive?: boolean, suppressBare?: boolean, 
+/** What the installed CLI advertises; the recorded snapshot by default so
+ * arg-shape callers stay synchronous and the probe stays optional. */
+advertisedEfforts?: readonly EffortHint[]): string[];
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

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

package/dist/index.js

@@ -10,16 +10,11 @@ import { createClaudeParser } from "./parse.js";
 import { probeClaudeCredentialProfile, resolveClaudeProfileRoute } from "./profile.js";
 export { canonicalProfileConfigDir } from "./profile.js";
 import { smokeIsolatedApiKey, smokeIsolatedOAuthToken } from "./smoke.js";
+import { BIN, CLAUDE_EFFORT_SNAPSHOT, CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST, claudeRunEffortResolution, probeClaudeEffortLevels, probeClaudeHelp, } from "./effort-probe.js";
+export { BIN, CLAUDE_EFFORT_SNAPSHOT } from "./effort-probe.js";
 import { claudeAttachmentBlocks, handleControlRequestFrame, initialSessionFrames, isControlRequestFrame, isResultFrame, } from "./interactive.js";
-export const BIN = process.env.CLAUDEXOR_CLAUDE_BIN || "claude";
 export const CLAUDE_PROVIDER_ENV_DENYLIST = PROVIDER_SECRET_ENV.filter((k) => k !== "ANTHROPIC_API_KEY");
-/**
- * Ordered (weakest→strongest) reasoning-effort levels `claude --effort` accepts.
- * Verified against the installed CLI (`claude --help`, v2.1.165): the full
- * ladder is low|medium|high|max. SINGLE source for the manifest's
- * `effort_levels` and the run-time normalizer (which now clamps nothing away).
- */
-const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "max"];
+// The `--effort` ladder is read from the INSTALLED binary (`probeClaudeEffortLevels`).
 /** Exported for focused route-policy tests; runtime uses this exact selector. */
 export const selectClaudeRunAuthRoute = selectStrictAuthRoute;
 function permissionArgs(access) {
@@ -54,40 +49,36 @@ const CLAUDE_READONLY_REQUIRED_FLAGS = [
     "--disable-slash-commands",
     "--no-chrome",
 ];
-let readonlyProbePromise = null;
-export function probeClaudeReadonlyProfile(abortSignal) {
-    if (readonlyProbePromise)
-        return readonlyProbePromise;
-    readonlyProbePromise = (async () => {
-        try {
-            const result = await runCapture(BIN, ["--help"], {
-                timeoutMs: 10_000,
-                abortSignal,
-                cancelSignal: "SIGTERM",
-                cancelKillDelayMs: 0,
-            });
-            const help = `${result.stdout}\n${result.stderr}`;
-            const missingFlags = CLAUDE_READONLY_REQUIRED_FLAGS.filter((flag) => !help.includes(flag));
-            const hasPlanMode = help.includes('"plan"') || help.includes("plan,") || help.includes(", plan");
-            if (!hasPlanMode)
-                missingFlags.push("--permission-mode=plan");
-            return {
-                supported: result.code === 0 && missingFlags.length === 0,
-                missingFlags,
-                detail: result.code === 0 && missingFlags.length === 0
-                    ? "installed Claude CLI exposes the complete restrictive readonly flag set"
-                    : `readonly enforcement unavailable; missing ${missingFlags.join(", ") || `help exited ${result.code}`}`,
-            };
-        }
-        catch (error) {
-            return {
-                supported: false,
-                missingFlags: [...CLAUDE_READONLY_REQUIRED_FLAGS],
-                detail: `readonly enforcement probe failed: ${redactSecrets(error instanceof Error ? error.message : String(error))}`,
-            };
-        }
-    })();
-    return readonlyProbePromise;
+/**
+ * Derived from the SHARED `--help` capture on every call instead of behind a
+ * second cache of its own. That cache had the same defect as the one under it —
+ * a probe that failed once (or that a cancelled run read) stayed failed for the
+ * process lifetime, so a long-lived daemon reported readonly enforcement
+ * unavailable forever. It bought nothing either: the spawn is already memoized,
+ * and what is left is a handful of `includes` over text we already hold.
+ */
+export async function probeClaudeReadonlyProfile(abortSignal) {
+    const probe = await probeClaudeHelp(abortSignal);
+    if (!probe.ok) {
+        return {
+            supported: false,
+            missingFlags: [...CLAUDE_READONLY_REQUIRED_FLAGS],
+            detail: `readonly enforcement probe failed: ${probe.error}`,
+        };
+    }
+    const help = probe.help;
+    const missingFlags = CLAUDE_READONLY_REQUIRED_FLAGS.filter((flag) => !help.includes(flag));
+    const hasPlanMode = help.includes('"plan"') || help.includes("plan,") || help.includes(", plan");
+    if (!hasPlanMode)
+        missingFlags.push("--permission-mode=plan");
+    const supported = probe.code === 0 && missingFlags.length === 0;
+    return {
+        supported,
+        missingFlags,
+        detail: supported
+            ? "installed Claude CLI exposes the complete restrictive readonly flag set"
+            : `readonly enforcement unavailable; missing ${missingFlags.join(", ") || `help exited ${probe.code}`}`,
+    };
 }
 async function detectVersion(abortSignal) {
     try {
@@ -219,6 +210,7 @@ export function createClaudeAdapter(deps = {}) {
         smokeIsolatedApiKey,
         smokeIsolatedOAuthToken,
         probeReadonlyProfile: probeClaudeReadonlyProfile,
+        probeEffortLevels: probeClaudeEffortLevels,
         runCliHarness,
         ...deps,
     };
@@ -231,6 +223,9 @@ export function createClaudeAdapter(deps = {}) {
             }
             const apiKey = runtime.anthropicApiKey() !== null;
             const readonlyProfile = await runtime.probeReadonlyProfile();
+            // The ladder belongs to the INSTALLED CLI, so read it from that binary
+            // rather than declaring one version's list for every version.
+            const efforts = await runtime.probeEffortLevels();
             const native = await runtime.probeAuthStatus(BIN, { env: claudeNativeEnv() });
             const authed = native.authed;
             const oauthTokenAvailable = runtime.claudeOAuthToken() !== null;
@@ -257,13 +252,23 @@ export function createClaudeAdapter(deps = {}) {
                     browser_tool: true,
                     // LIVE-VERIFIED (claude 2.1.165): `--json-schema <schema>` (inline JSON).
                     json_schema_output: true,
+                    // D-16: `--json-schema` materializes a StructuredOutput TOOL, so a
+                    // WorkReport envelope rides the tool while the prose final stays
+                    // markdown (side_tool). Interactive stream-json lanes disclose
+                    // unsupported at spec build, not here.
+                    work_report_transport: "constrained",
+                    structured_output_channel: "side_tool",
                     web_policy: "tools",
                     max_turns: true,
                     tool_lists: true,
                     interactive: true,
-                    // claude --effort accepts low|medium|high|xhigh|max (verified against
-                    // the installed CLI's --help). Single source for the run-time normalizer.
-                    effort_levels: [...CLAUDE_EFFORT_LEVELS],
+                    // Whatever THIS binary's --help documents; the snapshot fills in when
+                    // the parse fails. Claude's ladder is CLI-wide, not per model, so
+                    // `model_effort_levels` stays empty and every model falls back here.
+                    effort_levels: [...efforts.levels],
+                    effort_levels_verified_against: efforts.live
+                        ? version
+                        : CLAUDE_EFFORT_SNAPSHOT_VERIFIED_AGAINST,
                     // Manifest model truth source (strict model-truth validation: an explicit model outside
                     // this list is refused, never forwarded to die as a native error).
                     // Stable aliases plus current full ids; verified against the vendor
@@ -519,7 +524,10 @@ const CLAUDE_READONLY_DENIED_TOOLS = [
     "Agent",
     "Skill",
 ];
-export function claudeArgsForSpec(spec, interactive = false, suppressBare = false) {
+export function claudeArgsForSpec(spec, interactive = false, suppressBare = false, 
+/** What the installed CLI advertises; the recorded snapshot by default so
+ * arg-shape callers stay synchronous and the probe stays optional. */
+advertisedEfforts = CLAUDE_EFFORT_SNAPSHOT) {
     // Interactive sessions deliver the prompt as a stream-json user message on
     // stdin (the control protocol's transport); one-shot runs keep the prompt arg.
     // `--permission-prompt-tool stdio` is the live-verified switch that routes
@@ -550,9 +558,11 @@ export function claudeArgsForSpec(spec, interactive = false, suppressBare = fals
     // W-C4 live deltas (engine-gated to single-candidate lanes; parser tags payload.delta).
     if (spec.stream_deltas)
         args.push("--include-partial-messages");
-    // Clamp onto claude's declared effort ladder; null = not
-    // requested OR not tunable -> pass no flag. Never sends an invalid level.
-    const eff = normalizeEffort(spec.effort_hint, CLAUDE_EFFORT_LEVELS);
+    // Resolve against what the INSTALLED CLI advertises: an advertised level goes
+    // through verbatim (so a newer binary's level needs no code change here), a
+    // rankable one clamps, and anything else sends no flag rather than a level the
+    // vendor would reject. Null = not requested OR not tunable -> pass no flag.
+    const eff = normalizeEffort(spec.effort_hint, advertisedEfforts);
     if (eff)
         args.push("--effort", eff);
     if (spec.max_turns !== null && spec.max_turns > 0)
@@ -767,7 +777,15 @@ async function* runClaude(spec, runtime) {
         }
     }
     const useSubscription = route === "subscription";
-    const args = claudeArgsForSpec(spec, interactive, useSubscription);
+    // Shared with discovery through the memoized --help probe, so a run never
+    // re-spawns the CLI just to learn its ladder.
+    // INV-105 on the RUN: probe the installed ladder, version-gate snapshot
+    // fallback trust (an installed 2.1.89 is never sent the 2.1.165 snapshot's
+    // xhigh), and disclose a DROP/CLAMP on the same inputs the args resolve with.
+    const effort = await claudeRunEffortResolution(spec, runtime, abortSignalFromSpec(spec));
+    const args = claudeArgsForSpec(spec, interactive, useSubscription, effort.advertised);
+    if (effort.disclosure)
+        yield effort.disclosure;
     // Scrub EVERY provider secret (incl. OpenAI/others — the cross-provider leak
     // fix) via the single core table, then re-add only the var this route needs.
     const env = subscriptionSource === "native_session" ? nativeEnv : { ...spec.env, ...providerScrubEnv() };