@dungle-scrubs/harness-cli-normalizer 0.1.2 → 0.3.0

package/src/interpretation/turn-options.ts

@@ -0,0 +1,424 @@
+/**
+ * turn-options: rendering and validation of per-call turn options into argv.
+ *
+ * This lives separately from argv.ts because argv.ts owns argv *assembly and
+ * ordering* (where the prompt goes, that tools is last, that resume never
+ * inherits launch flags). Turn-option *rendering and validation* - which
+ * flag spells a dimension, how its value is validated and quoted, and when
+ * it must refuse - is a distinct responsibility with its own vocabulary.
+ * Folding it into argv.ts would make the largest interpretation file the
+ * place two unrelated questions are answered.
+ */
+import type { HarnessDescriptor, OptionRender, SpecBase } from "../knowledge/descriptor.js";
+import { DISCOVERY_FACETS, resolveRender, TURN_OPTION_KEYS } from "../knowledge/descriptor.js";
+import type { DiscoveryOptions, TurnOptions } from "./argv.js";
+import { ArgvRefusalError } from "./refusal.js";
+import { CLEAN_SELECTOR, resolveModel, validateEffort } from "./vocabulary.js";
+
+// TOML-quoted value for config-kv: JSON.stringify is sufficient for the
+// closed vocabularies that may use it (enum, effort) - no value contains a
+// quote that would need escaping beyond JSON's.
+const tomlQuote = (value: string): string => JSON.stringify(value);
+
+const isPlainObject = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** Render turn options for a given phase, in TURN_OPTION_KEYS order and with
+ * discovery facets in DISCOVERY_FACETS order, de-duplicating by exact token
+ * sequence (first wins) so claude's two facets sharing one flag emit once. */
+export const renderTurnOptions = (
+  h: HarnessDescriptor,
+  opts: TurnOptions,
+  phase: "launch" | "resume",
+): string[] => {
+  const sequences: string[][] = [];
+
+  for (const key of TURN_OPTION_KEYS) {
+    const spec = h.turnOptions[key];
+    const raw = (opts as unknown as Record<string, unknown>)[key];
+
+    // Discovery is a table of facets, handled separately.
+    if (key === "discovery") {
+      const discovery = raw as DiscoveryOptions | undefined;
+      // omitted, null, or {} => no-op
+      if (discovery === undefined || discovery === null) continue;
+      if (!isPlainObject(discovery as unknown)) {
+        throw new ArgvRefusalError({
+          issue: "invalid-option-value",
+          harness: h.name,
+          option: "discovery",
+          supported: ["discovery must be an object"],
+          detail: String(raw),
+        });
+      }
+      const discObj = discovery as Record<string, unknown>;
+      // If spec absent, any facet set to false must refuse.
+      if (spec === undefined) {
+        const requested = DISCOVERY_FACETS.filter((f) => discObj[f] === false);
+        if (requested.length === 0) continue;
+        throw new ArgvRefusalError({
+          issue: "unsupported-option",
+          harness: h.name,
+          option: "discovery",
+          supported: Object.keys(h.turnOptions).length ? Object.keys(h.turnOptions) : ["(none)"],
+          detail: String(requested[0]),
+        });
+      }
+      if (spec.kind !== "discovery") {
+        throw new ArgvRefusalError({
+          issue: "invalid-option-value",
+          harness: h.name,
+          option: "discovery",
+          supported: ["discovery spec malformed"],
+        });
+      }
+      // Validate each facet value is boolean if present
+      for (const facet of DISCOVERY_FACETS) {
+        if (!(facet in discObj)) continue;
+        const v = discObj[facet];
+        if (v !== undefined && typeof v !== "boolean") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: "discovery",
+            facet,
+            supported: ["true or false"],
+            detail: String(v),
+          });
+        }
+      }
+      // Render facets in DISCOVERY_FACETS order
+      for (const facet of DISCOVERY_FACETS) {
+        const val = discObj[facet];
+        if (val === undefined) continue;
+        // Polarity handling: disables emits on false, enables emits on true
+        const facetSpec = spec.facets[facet];
+        if (facetSpec === undefined) {
+          // If caller asked to disable (false for disables, true for enables) but facet not declared, refuse
+          // But if caller passed true for a disables facet, it's a no-op, not a refusal
+          // So only refuse when the caller's value would have emitted
+          // For all current descriptors polarity is disables, so false would emit -> refuse
+          // For safety, check wouldEmit logic
+          // If val would not emit anyway, skip
+          // Determine wouldEmit: if facetSpec undefined, we cannot know polarity, so treat false as intended disable -> refuse
+          if (val === false) {
+            const supportedFacets = Object.keys(spec.facets);
+            throw new ArgvRefusalError({
+              issue: "unsupported-option-facet",
+              harness: h.name,
+              option: "discovery",
+              facet,
+              supported: supportedFacets.length ? supportedFacets : ["(none)"],
+            });
+          }
+          continue;
+        }
+        // Determine if this value should emit
+        let shouldEmit = false;
+        if (facetSpec.polarity === "disables" && val === false) shouldEmit = true;
+        else if (facetSpec.polarity === "enables" && val === true) shouldEmit = true;
+        else {
+          // true for disables or false for enables => no-op
+          continue;
+        }
+        if (!shouldEmit) continue;
+        // Check resumeRender refusal
+        const effective = resolveRender(facetSpec, phase);
+        if (effective === null) {
+          const resumeSupported = Object.entries(spec.facets)
+            .filter(
+              ([, v]) =>
+                resolveRender(
+                  v as unknown as import("../knowledge/descriptor.js").SpecBase,
+                  "resume",
+                ) !== null,
+            )
+            .map(([k]) => k);
+          throw new ArgvRefusalError({
+            issue: "unsupported-on-resume",
+            harness: h.name,
+            option: "discovery",
+            facet,
+            supported: resumeSupported.length ? resumeSupported : ["(none resume)"],
+          });
+        }
+        // Reject config-kv for discovery (only closed vocab, discovery is not)
+        if ((effective as OptionRender).kind === "config-kv") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: "discovery",
+            facet,
+            supported: ["flag-list only for discovery"],
+          });
+        }
+        let seq: string[];
+        if ((effective as OptionRender).kind === "flag-list")
+          seq = [...(effective as Extract<OptionRender, { kind: "flag-list" }>).flags];
+        else if ((effective as OptionRender).kind === "flag-value")
+          seq = [(effective as Extract<OptionRender, { kind: "flag-value" }>).flag, ""];
+        else seq = [];
+        sequences.push(seq);
+      }
+      continue;
+    }
+
+    // Non-discovery keys
+    // Handle enum default on launch
+    if (raw === undefined) {
+      if (
+        spec !== undefined &&
+        spec.kind === "enum" &&
+        spec.default !== undefined &&
+        phase === "launch"
+      ) {
+        const effective = resolveRender(spec as unknown as SpecBase, phase);
+        if (effective === null) continue; // should not happen for launch
+        // config-kv is allowed for enum (closed vocab) - no rejection needed here
+        let seq: string[];
+        if ((effective as OptionRender).kind === "flag-value")
+          seq = [(effective as Extract<OptionRender, { kind: "flag-value" }>).flag, spec.default];
+        else if ((effective as OptionRender).kind === "config-kv")
+          seq = [
+            (effective as Extract<OptionRender, { kind: "config-kv" }>).flag,
+            `${(effective as Extract<OptionRender, { kind: "config-kv" }>).key}=${tomlQuote(spec.default)}`,
+          ];
+        else if ((effective as OptionRender).kind === "flag-list")
+          seq = [...(effective as Extract<OptionRender, { kind: "flag-list" }>).flags];
+        else seq = [];
+        sequences.push(seq);
+      }
+      continue;
+    }
+
+    // Raw is defined but spec is absent => unsupported-option
+    if (spec === undefined) {
+      throw new ArgvRefusalError({
+        issue: "unsupported-option",
+        harness: h.name,
+        option: key,
+        supported: Object.keys(h.turnOptions).length ? Object.keys(h.turnOptions) : ["(none)"],
+        detail: String(raw),
+      });
+    }
+
+    // Check resumeRender null => unsupported-on-resume
+    // For discovery we handled per-facet; for others check spec
+    if ((spec as { kind: string }).kind !== "discovery") {
+      const effective = resolveRender(spec as unknown as SpecBase, phase);
+      if (effective === null) {
+        const resumeSupported = TURN_OPTION_KEYS.filter((k) => {
+          const s = h.turnOptions[k];
+          if (!s) return false;
+          if ((s as { kind: string }).kind === "discovery") {
+            const facets = (s as unknown as { facets: Record<string, unknown> }).facets;
+            return Object.keys(facets).length > 0;
+          }
+          return resolveRender(s as unknown as SpecBase, "resume") !== null;
+        }) as string[];
+        throw new ArgvRefusalError({
+          issue: "unsupported-on-resume",
+          harness: h.name,
+          option: key,
+          supported: resumeSupported.length ? resumeSupported : ["(none)"],
+        });
+      }
+      // Reject config-kv for non-closed vocabulary
+      if (
+        (spec as unknown as SpecBase).render.kind === "config-kv" &&
+        (spec as { kind: string }).kind !== "enum" &&
+        (spec as { kind: string }).kind !== "effort"
+      ) {
+        throw new ArgvRefusalError({
+          issue: "invalid-option-value",
+          harness: h.name,
+          option: key,
+          supported: ["config-kv only for enum and effort (closed vocabularies)"],
+        });
+      }
+    }
+
+    // Per-kind validation and token generation
+    const effectiveRender =
+      (spec as { kind: string }).kind === "discovery"
+        ? null
+        : resolveRender(spec as unknown as SpecBase, phase);
+    // effectiveRender already checked for null
+
+    switch (spec.kind) {
+      case "effort": {
+        if (typeof raw !== "string") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: [...h.vocabulary.efforts],
+            detail: String(raw),
+          });
+        }
+        const validated = validateEffort(
+          h,
+          raw,
+          (opts as unknown as Record<string, unknown>).model as string | undefined,
+        );
+        if (!validated.ok) {
+          let ladder = h.vocabulary.efforts;
+          const model = (opts as unknown as Record<string, unknown>).model as string | undefined;
+          if (model !== undefined && h.vocabulary.effortsByModel !== undefined) {
+            const { id } = resolveModel(h, model);
+            const perModel = Object.hasOwn(h.vocabulary.effortsByModel, id)
+              ? h.vocabulary.effortsByModel[id]
+              : undefined;
+            if (perModel !== undefined) ladder = perModel;
+          }
+          throw new ArgvRefusalError({
+            issue: "unknown-effort",
+            harness: h.name,
+            option: key,
+            supported: [...ladder],
+            detail: raw,
+          });
+        }
+        const r = effectiveRender!;
+        let seq: string[];
+        if (r.kind === "flag-value") seq = [r.flag, raw];
+        else if (r.kind === "config-kv") seq = [r.flag, `${r.key}=${tomlQuote(raw)}`];
+        else if (r.kind === "flag-list") seq = [...r.flags];
+        else seq = [];
+        sequences.push(seq);
+        break;
+      }
+      case "enum": {
+        if (typeof raw !== "string") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: [...spec.values],
+            detail: String(raw),
+          });
+        }
+        if (!spec.values.includes(raw)) {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: [...spec.values],
+            detail: raw,
+          });
+        }
+        const r = effectiveRender!;
+        let seq: string[];
+        if (r.kind === "flag-value") seq = [r.flag, raw];
+        else if (r.kind === "config-kv") seq = [r.flag, `${r.key}=${tomlQuote(raw)}`];
+        else if (r.kind === "flag-list") seq = [...r.flags];
+        else seq = [];
+        sequences.push(seq);
+        break;
+      }
+      case "selector": {
+        if (typeof raw !== "string") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: ["CLEAN_SELECTOR"],
+            detail: String(raw),
+          });
+        }
+        if (!CLEAN_SELECTOR.test(raw)) {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: ["must match CLEAN_SELECTOR /^[A-Za-z0-9][A-Za-z0-9._:/@-]{0,127}$/"],
+            detail: raw,
+          });
+        }
+        const r = effectiveRender!;
+        let seq: string[];
+        if (r.kind === "flag-value") seq = [r.flag, raw];
+        else if (r.kind === "config-kv") seq = [r.flag, `${r.key}=${tomlQuote(raw)}`];
+        else if (r.kind === "flag-list") seq = [...r.flags];
+        else seq = [];
+        sequences.push(seq);
+        break;
+      }
+      case "toggle": {
+        if (typeof raw !== "boolean") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: ["true or false"],
+            detail: String(raw),
+          });
+        }
+        let shouldEmit = false;
+        if (spec.polarity === "disables" && raw === false) shouldEmit = true;
+        else if (spec.polarity === "enables" && raw === true) shouldEmit = true;
+        if (!shouldEmit) break;
+        const r = effectiveRender!;
+        let seq: string[];
+        if (r.kind === "flag-list") seq = [...r.flags];
+        else if (r.kind === "flag-value") seq = [r.flag, String(raw)];
+        else if (r.kind === "config-kv") seq = [r.flag, `${r.key}=${tomlQuote(String(raw))}`];
+        else seq = [];
+        sequences.push(seq);
+        break;
+      }
+      case "integer": {
+        if (typeof raw !== "number") {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: [`[${spec.min}, ${spec.max}] integer`],
+            detail: String(raw),
+          });
+        }
+        if (!Number.isFinite(raw) || !Number.isInteger(raw) || raw < spec.min || raw > spec.max) {
+          throw new ArgvRefusalError({
+            issue: "invalid-option-value",
+            harness: h.name,
+            option: key,
+            supported: [`[${spec.min}, ${spec.max}] integer`],
+            detail: String(raw),
+          });
+        }
+        const r = effectiveRender!;
+        let seq: string[];
+        if (r.kind === "flag-value") seq = [r.flag, String(raw)];
+        else if (r.kind === "config-kv") seq = [r.flag, `${r.key}=${tomlQuote(String(raw))}`];
+        else if (r.kind === "flag-list") seq = [...r.flags];
+        else seq = [];
+        sequences.push(seq);
+        break;
+      }
+      case "discovery":
+        // already handled
+        break;
+      default: {
+        const _exhaustive: never = spec as never;
+        throw new ArgvRefusalError({
+          issue: "invalid-option-value",
+          harness: h.name,
+          option: key,
+          supported: [],
+          detail: String(_exhaustive),
+        });
+      }
+    }
+  }
+
+  // De-duplication by exact token sequence, first occurrence winning
+  const seen = new Set<string>();
+  const deduped: string[][] = [];
+  for (const seq of sequences) {
+    const k = seq.join("\0");
+    if (seen.has(k)) continue;
+    seen.add(k);
+    deduped.push(seq);
+  }
+  return deduped.flat();
+};

package/src/interpretation/vocabulary.ts

@@ -18,7 +18,7 @@ export interface ValidationRefusal {
  * models as provider/id[:thinking], so word characters plus the few real
  * separators - never whitespace, shell metacharacters, or control/format
  * characters, and bounded like session ids. */
-const CLEAN_SELECTOR = /^[A-Za-z0-9][A-Za-z0-9._:/@-]{0,127}$/;
+export const CLEAN_SELECTOR = /^[A-Za-z0-9][A-Za-z0-9._:/@-]{0,127}$/;
 
 export interface ResolvedModel {
   readonly id: string;

package/src/knowledge/claude-code.ts

@@ -1,7 +1,19 @@
 /**
  * The claude-code descriptor: facts about the `claude` CLI as data, verified
- * against claude 2.1.227 and the 00-chat-substrate spike evidence (A-001,
+ * against claude 2.1.229 and the 00-chat-substrate spike evidence (A-001,
  * A-002, A-005). No process logic lives here.
+ *
+ * Discovery: claude 2.1.229 has no isolated instruction-file toggle.
+ * `--bare` would stop `CLAUDE.md` discovery, but it also skips hooks, LSP,
+ * plugin sync, auto-memory and keychain reads, and forces auth to
+ * `ANTHROPIC_API_KEY` / `apiKeyHelper` (OAuth never read) - so a caller
+ * authenticated via OAuth would break. The descriptor therefore offers no
+ * `instructionFiles` facet and a call passing it must refuse. Likewise
+ * `tools` has no discovery flag on claude and refuses.
+ *
+ * Effort: A-002 showed `--effort bogus` warns on stderr and runs at DEFAULT
+ * effort, exit 0, with nothing echoed in the stream. The library-side
+ * `validateEffort` refusal is therefore load-bearing, not cosmetic.
  */
 import { deepFreeze, type HarnessDescriptor, UUID_SHAPE } from "./descriptor.js";
 import { SHARED_AUTH_MATCHERS, SHARED_LIMIT_MATCHERS } from "./matchers.js";
@@ -9,7 +21,7 @@ import { SHARED_AUTH_MATCHERS, SHARED_LIMIT_MATCHERS } from "./matchers.js";
 export const claudeCode: HarnessDescriptor = deepFreeze({
   name: "claude",
   bin: "claude",
-  verifiedAgainst: "2.1.227",
+  verifiedAgainst: "2.1.229",
   versionSource: { kind: "npm", package: "@anthropic-ai/claude-code" },
   launch: {
     baseFlags: ["-p"],
@@ -69,17 +81,17 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
   limitMatchers: [
     // Observed phrasings from the live CLI (ported from lucid v1's limits.ts):
     // "You've hit your session limit · resets 6:30pm"
-    [/you'?ve hit your session limit/i, "session-limit"],
+    { pattern: "you'?ve hit your session limit", flags: "i", code: "session-limit" },
     // "You've hit your weekly limit · resets 2am (Asia/Bangkok)"
-    [/you'?ve hit your weekly limit/i, "weekly-limit"],
+    { pattern: "you'?ve hit your weekly limit", flags: "i", code: "weekly-limit" },
     ...SHARED_LIMIT_MATCHERS,
   ],
   authMatchers: [
     // A detached process cannot read Keychain creds, and misreading that as
     // "not logged in" sends the human to redo a login that was never broken.
-    [/oauth session expired|could not be refreshed/i, "expired"],
-    [/failed to authenticate/i, "expired"],
-    [/not logged in|please run \/login/i, "not-logged-in"],
+    { pattern: "oauth session expired|could not be refreshed", flags: "i", kind: "expired" },
+    { pattern: "failed to authenticate", flags: "i", kind: "expired" },
+    { pattern: "not logged in|please run \\/login", flags: "i", kind: "not-logged-in" },
     ...SHARED_AUTH_MATCHERS,
   ],
   autonomy: { flag: "--dangerously-skip-permissions" },
@@ -93,8 +105,6 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
       haiku: "claude-haiku-4-5-20251001",
     },
     efforts: ["low", "medium", "high", "xhigh", "max"],
-    // Effort is an in-session command for claude, not a launch flag.
-    effortFlag: null,
     extensible: false,
   },
   store: {
@@ -111,11 +121,7 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
     usedPctField: "used_percentage",
   },
   resumeLast: null,
-  provider: null,
   stdin: "inherit",
-  // D-025: project-only setting sources is claude's discovery-isolation
-  // spelling; the child loads no user-level hooks or skills.
-  discoveryDisableFlags: ["--setting-sources", "project"],
   presence: {
     headlessMarkers: ["-p", "--print"],
   },
@@ -129,4 +135,20 @@ export const claudeCode: HarnessDescriptor = deepFreeze({
     },
     session: true,
   },
+  turnOptions: {
+    effort: { kind: "effort", render: { kind: "flag-value", flag: "--effort" } },
+    discovery: {
+      kind: "discovery",
+      facets: {
+        extensions: {
+          polarity: "disables",
+          render: { kind: "flag-list", flags: ["--setting-sources", "project"] },
+        },
+        skills: {
+          polarity: "disables",
+          render: { kind: "flag-list", flags: ["--setting-sources", "project"] },
+        },
+      },
+    },
+  },
 });

package/src/knowledge/codex.ts

@@ -14,13 +14,13 @@ export const codexCli: HarnessDescriptor = deepFreeze({
   versionSource: { kind: "npm", package: "@openai/codex" },
   launch: {
     // exec --json emits structured item events; without --json, identity
-    // discovery is blind (v1: requiredArgument "--json"). The sandbox grant
-    // is v1's proven spawn shape - codex's built-in default is read-only,
-    // under which a non-autonomy turn cannot write files.
+    // discovery is blind (v1: requiredArgument "--json").
     // --skip-git-repo-check: codex exec refuses to run outside a trusted
     // git dir without it (verified 0.147.0). cwd targeting is the spawner's
     // job (spawn opts.cwd), not descriptor data.
-    baseFlags: ["exec", "--json", "--sandbox", "workspace-write", "--skip-git-repo-check"],
+    // Sandbox is now per-call via turnOptions.sandbox with default
+    // workspace-write, not a hardcoded base flag.
+    baseFlags: ["exec", "--json", "--skip-git-repo-check"],
     subcommands: ["exec"],
     promptStyle: "positional",
     toolsFlag: null,
@@ -54,24 +54,24 @@ export const codexCli: HarnessDescriptor = deepFreeze({
     announce: { match: { type: "thread.started" }, idField: "thread_id" },
   },
   limitMatchers: [...SHARED_LIMIT_MATCHERS],
-  authMatchers: [[/run codex login/i, "not-logged-in"], ...SHARED_AUTH_MATCHERS],
+  authMatchers: [
+    { pattern: "run codex login", flags: "i", kind: "not-logged-in" },
+    ...SHARED_AUTH_MATCHERS,
+  ],
   // Accepted by codex 0.147.0 as a hidden alias (not in --help).
   autonomy: { flag: "--yolo" },
   vocabulary: {
     modelFlag: "--model",
     models: ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"],
     aliases: {},
-    efforts: ["minimal", "low", "medium", "high", "xhigh", "max", "ultra"],
+    efforts: ["minimal", "low", "medium", "high", "xhigh", "max"],
     // Codex constrains ladders per model generation (v1 registry).
     effortsByModel: {
       "gpt-5.5": ["minimal", "low", "medium", "high"],
-      "gpt-5.6-sol": ["medium", "high", "xhigh", "max", "ultra"],
-      "gpt-5.6-terra": ["medium", "high", "xhigh", "max", "ultra"],
-      "gpt-5.6-luna": ["medium", "high", "xhigh", "max", "ultra"],
+      "gpt-5.6-sol": ["medium", "high", "xhigh", "max"],
+      "gpt-5.6-terra": ["medium", "high", "xhigh", "max"],
+      "gpt-5.6-luna": ["medium", "high", "xhigh", "max"],
     },
-    // Reasoning effort is a config key (-c model_reasoning_effort=...), not
-    // a plain flag; argv-level insertion has no spelling to use.
-    effortFlag: null,
     extensible: false,
   },
   store: {
@@ -84,12 +84,10 @@ export const codexCli: HarnessDescriptor = deepFreeze({
   contextHook: null,
   // Valid only in the `exec resume` context: `codex exec resume --last`.
   resumeLast: { flag: "--last" },
-  provider: null,
   // codex exec appends piped stdin as a <stdin> block and can block on an
   // open stdin - close it (verified 0.147.0: "Reading additional input
   // from stdin...").
   stdin: "close-required",
-  discoveryDisableFlags: [],
   presence: {
     headlessMarkers: ["exec"],
   },
@@ -103,4 +101,17 @@ export const codexCli: HarnessDescriptor = deepFreeze({
     },
     session: false,
   },
+  turnOptions: {
+    effort: {
+      kind: "effort",
+      render: { kind: "config-kv", flag: "-c", key: "model_reasoning_effort" },
+    },
+    sandbox: {
+      kind: "enum",
+      values: ["read-only", "workspace-write", "danger-full-access"],
+      default: "workspace-write",
+      render: { kind: "flag-value", flag: "--sandbox" },
+      resumeRender: null,
+    },
+  },
 });