@prismatic-io/lux 0.0.2-preview.18 → 0.0.2-preview.21

package/src/cli/init.ts

@@ -13,19 +13,26 @@ import {
   STARTER_PROMPT_BODY,
 } from "./init-templates.js";
 
+const EXPLICIT_MODEL_DRIVERS = new Set(["cursor", "copilot", "antigravity"]);
+
 const InitOptionsSchema = z
   .object({
     cwd: z.string().min(1),
     force: z.boolean().default(false),
     experiment: z.boolean().default(false),
-    driver: z.enum(["subprocess", "claude-code", "codex", "cursor"]).optional(),
+    driver: z
+      .enum(["subprocess", "claude-code", "codex", "cursor", "copilot", "antigravity"])
+      .optional(),
     model: z.string().min(1).optional(),
   })
   .strict()
-  .refine((options) => options.driver !== "cursor" || options.model !== undefined, {
-    path: ["model"],
-    message: "Cursor requires an explicit --model",
-  })
+  .refine(
+    (options) => !EXPLICIT_MODEL_DRIVERS.has(options.driver ?? "") || options.model !== undefined,
+    {
+      path: ["model"],
+      message: "Cursor, Copilot, and Antigravity require an explicit --model",
+    },
+  )
   .refine((options) => !(options.experiment && options.driver === "subprocess"), {
     path: ["driver"],
     message: "The deterministic starter is for runs; choose a coding agent for experiments",

package/src/cli/program.ts

@@ -2,14 +2,16 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { lstat, mkdir, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Cli, Errors, z } from "incur";
 import { createRubricAssertion } from "../assertions/rubric/index.js";
 import {
   type Candidate,
   GraderAnnotationSchema,
+  type HarnessFocus,
   matchesAnyGlob,
+  ReasoningEffortSchema,
   valueHash,
 } from "../core/index.js";
 import {
@@ -17,7 +19,6 @@ import {
   buildRegistryFromConfig,
   compareRuns,
   compareSuiteRuns,
-  type DiscoveredCase,
   DoctorReportSchema,
   discoverCases,
   ExperimentCampaignPlanSchema,
@@ -46,8 +47,6 @@ import {
   resolveExperimentCampaignPath,
   runExperimentCampaign,
   type SuiteCaseResult,
-  type SuiteItem,
-  selectCases,
   upsertGraderAnnotation,
   verifyExperimentDecisionIntegrity,
   verifyExperimentRunIntegrity,
@@ -63,10 +62,15 @@ import { initProject } from "./init.js";
 import { CompareOutputSchema, ViewOutputSchema } from "./output-schemas.js";
 import { ConsoleReporter } from "./render/reporter.js";
 import {
+  expandLoop,
   parseAnnotationAssertion,
+  partitionFilters,
+  planSuiteItems,
   type RunOptions,
   resolveAnswererOverride,
   resolveConcurrency,
+  selectSuite,
+  suiteTitle,
 } from "./run-options.js";
 import { type ViewOptions, viewCommand, webViewCommand } from "./view.js";
 
@@ -92,7 +96,14 @@ const initOutput = z.object({
 const runOutput = z.union([
   z.object({
     caseCount: z.number().int(),
-    cases: z.array(z.object({ path: z.string(), id: z.string() })),
+    cases: z.array(
+      z.object({
+        path: z.string(),
+        id: z.string(),
+        caseId: z.string().optional(),
+        permutationId: z.string().optional(),
+      }),
+    ),
   }),
   z.object({
     caseCount: z.number().int(),
@@ -156,7 +167,7 @@ export const buildCli = () =>
         force: z.boolean().optional().describe("Overwrite existing files"),
         experiment: z.boolean().optional().describe("Also scaffold an optimization campaign"),
         driver: z
-          .enum(["subprocess", "claude-code", "codex", "cursor"])
+          .enum(["subprocess", "claude-code", "codex", "cursor", "copilot", "antigravity"])
           .optional()
           .describe("Starter driver (default: deterministic subprocess)"),
         model: nonEmptyString.optional().describe("Explicit subject model; required for Cursor"),
@@ -203,6 +214,11 @@ export const buildCli = () =>
         skipJudge: z.boolean().optional().describe("Skip rubric LLM judge assertions"),
         runsRoot: nonEmptyString.optional().describe("Run directory root"),
         profile: nonEmptyString.optional().describe("Named driver and answerer profile"),
+        driver: nonEmptyString
+          .optional()
+          .describe("Focus on one harness driver, replacing the matrix"),
+        model: nonEmptyString.optional().describe("Focus on one subject model"),
+        effort: ReasoningEffortSchema.optional().describe("Focus on one reasoning effort"),
         subjectRoot: nonEmptyString.optional().describe("Root bound into subjectPath values"),
         verbose: z.boolean().optional().describe("Include phase timings and run directories"),
       }),
@@ -217,6 +233,11 @@ export const buildCli = () =>
           options: { tag: [] },
           description: "Run matching cases",
         },
+        {
+          args: { filters: ["smoke"] },
+          options: { tag: [], driver: "codex", model: "gpt-5.6-luna", effort: "low" },
+          description: "Focus on one harness permutation",
+        },
       ],
       run: async (c) => {
         const result = await runCommand(c.args.filters, c.options as RunOptions, !c.agent);
@@ -620,8 +641,6 @@ const compareCommand = async (
   return comparison;
 };
 
-const caseIdOf = (casePath: string): string => basename(casePath, extname(casePath));
-
 const SIGINT_EXIT_CODE = 130;
 
 const physicalDestinationPath = async (path: string): Promise<string> => {
@@ -694,86 +713,6 @@ const isFailure = (outcome: { exitReason: string; casePassed: boolean | null }):
 
 const firstLine = (message: string): string => (message.split("\n")[0] ?? message).trim();
 
-const suiteTitle = (
-  patterns: string[],
-  tags: string[],
-  explicit: SuiteItem[],
-  loop: number,
-): string => {
-  const parts = [...patterns, ...explicit.map((e) => e.id), ...tags.map((t) => `#${t}`)];
-  const filter = parts.length > 0 ? ` ${parts.join(" ")}` : "";
-  const repeat = loop > 1 ? ` ×${loop}` : "";
-  return `run${filter}${repeat}`;
-};
-
-type FilterPartition = { explicit: SuiteItem[]; patterns: string[] };
-
-// A filter that names an existing `.ts` file runs that file directly — it may
-// sit outside the discovery root. Everything else is a substring pattern — but
-// a `.ts` filter that resolves to nothing is almost always a typo'd path, so
-// the silent downgrade to a pattern gets called out.
-const partitionFilters = (filters: string[], cwd: string): FilterPartition => {
-  const explicit: SuiteItem[] = [];
-  const patterns: string[] = [];
-  for (const f of filters) {
-    const abs = resolve(cwd, f);
-    if (f.endsWith(".ts") && existsSync(abs)) {
-      explicit.push({ path: abs, id: caseIdOf(f) });
-    } else {
-      if (f.endsWith(".ts")) {
-        process.stderr.write(`lux: ${abs} does not exist; treating "${f}" as a pattern\n`);
-      }
-      patterns.push(f);
-    }
-  }
-  return { explicit, patterns };
-};
-
-// The selected set — substring/tag matches plus explicitly named files — is
-// the same whether it is run, `--list`ed, or `--list-tags`ed. No filters at
-// all means "everything discovered"; any filter narrows.
-const selectSuite = (
-  cases: DiscoveredCase[],
-  { explicit, patterns }: FilterPartition,
-  tags: string[],
-): DiscoveredCase[] => {
-  const hasFilter = explicit.length > 0 || patterns.length > 0 || tags.length > 0;
-  const byPath = new Map<string, DiscoveredCase>();
-  if (!hasFilter) {
-    for (const c of cases) byPath.set(c.path, c);
-  } else {
-    if (patterns.length > 0 || tags.length > 0) {
-      for (const c of selectCases(cases, { patterns, tags })) byPath.set(c.path, c);
-    }
-    for (const e of explicit) {
-      const discovered = cases.find((c) => c.path === e.path);
-      // Discovery knows the case's declared id; the filename-derived one is
-      // only a fallback for files discovery never saw.
-      byPath.set(e.path, {
-        path: e.path,
-        id: discovered?.id ?? e.id,
-        relPath: discovered?.relPath ?? e.id,
-        tags: discovered?.tags ?? [],
-      });
-    }
-  }
-  return [...byPath.values()].sort((a, b) => a.id.localeCompare(b.id));
-};
-
-// `--loop` repeats each eval before moving to the next; each repeat gets a
-// `#n` display suffix so the reporter keeps them apart, while `caseId` keeps
-// every repeat filed under one run history.
-const expandLoop = (base: SuiteItem[], loop: number): SuiteItem[] =>
-  loop > 1
-    ? base.flatMap((b) =>
-        Array.from({ length: loop }, (_, i) => ({
-          path: b.path,
-          id: `${b.id} #${i + 1}`,
-          caseId: b.caseId ?? b.id,
-        })),
-      )
-    : base;
-
 const experimentCommand = async (
   mode: "experiment" | "optimize",
   campaignPath: string,
@@ -824,6 +763,7 @@ const experimentCommand = async (
   return { experimentDir: result.experimentDir, ...result.manifest };
 };
 
+/** A profile pins one driver, so callers pass the project matrix only without one. */
 const runCommand = async (filters: string[], options: RunOptions, human = false) => {
   if (options.interactive && options.claudeAnswerer) {
     throw new Errors.ParseError({
@@ -923,7 +863,17 @@ const runCommand = async (filters: string[], options: RunOptions, human = false)
     return result;
   }
 
-  const base: SuiteItem[] = selected.map((c) => ({ path: c.path, id: c.id }));
+  const focus: HarnessFocus = {
+    driver: options.driver,
+    model: options.model,
+    effort: options.effort,
+  };
+  const base = await planSuiteItems(selected, {
+    matrix: profile ? undefined : config.matrix,
+    defaultDriver,
+    registry,
+    focus,
+  });
 
   // Collect-only: answer "what would run?" without spawning a single agent.
   if (options.list) {
@@ -931,7 +881,15 @@ const runCommand = async (filters: string[], options: RunOptions, human = false)
       process.stdout.write(
         `${base.length} cases\n${base.map(({ id, path }) => `  ${id}  ${path}`).join("\n")}\n`,
       );
-    return { caseCount: base.length, cases: base };
+    return {
+      caseCount: base.length,
+      cases: base.map(({ path, id, caseId, permutationId }) => ({
+        path,
+        id,
+        ...(caseId !== undefined ? { caseId } : {}),
+        ...(permutationId !== undefined ? { permutationId } : {}),
+      })),
+    };
   }
 
   const loop = options.loop ?? 1;
@@ -943,7 +901,7 @@ const runCommand = async (filters: string[], options: RunOptions, human = false)
   const reporter = human ? new ConsoleReporter({ verbose: options.verbose ?? false }) : undefined;
   using controller = abortOnInterrupt();
   reporter?.begin({
-    title: suiteTitle(patterns, tags, explicit, loop),
+    title: suiteTitle(patterns, tags, explicit, loop, focus),
     caseIds: items.map((i) => i.id),
     runsRoot,
     loop,
@@ -991,4 +949,4 @@ const runCommand = async (filters: string[], options: RunOptions, human = false)
 };
 
 // Internal exports for testing
-export { expandLoop, isFailure, partitionFilters, resolveConcurrency, selectSuite };
+export { isFailure, resolveConcurrency };

package/src/cli/run-options.ts

@@ -1,4 +1,9 @@
+import { existsSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
 import { Errors } from "incur";
+import type { HarnessFocus, ReasoningEffort } from "../core/index.js";
+import { type DiscoveredCase, type SuiteItem, selectCases } from "../orchestrator/index.js";
+import { planHarnessItems } from "./harness-plan.js";
 
 export type RunOptions = {
   tag?: string[];
@@ -11,6 +16,9 @@ export type RunOptions = {
   skipJudge?: boolean;
   runsRoot?: string;
   profile?: string;
+  driver?: string;
+  model?: string;
+  effort?: ReasoningEffort;
   subjectRoot?: string;
   verbose?: boolean;
 };
@@ -64,3 +72,118 @@ export const resolveAnswererOverride = (options: RunOptions): string | undefined
   if (options.claudeAnswerer) return "claude-code";
   return undefined;
 };
+
+const caseIdOf = (casePath: string): string => basename(casePath, extname(casePath));
+
+export const suiteTitle = (
+  patterns: string[],
+  tags: string[],
+  explicit: SuiteItem[],
+  loop: number,
+  focus: HarnessFocus,
+): string => {
+  const parts = [...patterns, ...explicit.map((e) => e.id), ...tags.map((t) => `#${t}`)];
+  const filter = parts.length > 0 ? ` ${parts.join(" ")}` : "";
+  const focusParts = [focus.driver, focus.model, focus.effort].filter(
+    (part): part is string => part !== undefined,
+  );
+  const focused = focusParts.length > 0 ? ` @${focusParts.join(":")}` : "";
+  const repeat = loop > 1 ? ` ×${loop}` : "";
+  return `run${filter}${focused}${repeat}`;
+};
+
+type FilterPartition = { explicit: SuiteItem[]; patterns: string[] };
+
+// A filter that names an existing `.ts` file runs that file directly — it may
+// sit outside the discovery root. Everything else is a substring pattern — but
+// a `.ts` filter that resolves to nothing is almost always a typo'd path, so
+// the silent downgrade to a pattern gets called out.
+export const partitionFilters = (filters: string[], cwd: string): FilterPartition => {
+  const explicit: SuiteItem[] = [];
+  const patterns: string[] = [];
+  for (const f of filters) {
+    const abs = resolve(cwd, f);
+    if (f.endsWith(".ts") && existsSync(abs)) {
+      explicit.push({ path: abs, id: caseIdOf(f) });
+    } else {
+      if (f.endsWith(".ts")) {
+        process.stderr.write(`lux: ${abs} does not exist; treating "${f}" as a pattern\n`);
+      }
+      patterns.push(f);
+    }
+  }
+  return { explicit, patterns };
+};
+
+// The selected set — substring/tag matches plus explicitly named files — is
+// the same whether it is run, `--list`ed, or `--list-tags`ed. No filters at
+// all means "everything discovered"; any filter narrows.
+export const selectSuite = (
+  cases: DiscoveredCase[],
+  { explicit, patterns }: FilterPartition,
+  tags: string[],
+): DiscoveredCase[] => {
+  const hasFilter = explicit.length > 0 || patterns.length > 0 || tags.length > 0;
+  const byPath = new Map<string, DiscoveredCase>();
+  if (!hasFilter) {
+    for (const c of cases) byPath.set(c.path, c);
+  } else {
+    if (patterns.length > 0 || tags.length > 0) {
+      for (const c of selectCases(cases, { patterns, tags })) byPath.set(c.path, c);
+    }
+    for (const e of explicit) {
+      const discovered = cases.find((c) => c.path === e.path);
+      // Discovery knows the case's declared id; the filename-derived one is
+      // only a fallback for files discovery never saw.
+      byPath.set(e.path, {
+        path: e.path,
+        id: discovered?.id ?? e.id,
+        relPath: discovered?.relPath ?? e.id,
+        tags: discovered?.tags ?? [],
+      });
+    }
+  }
+  return [...byPath.values()].sort((a, b) => a.id.localeCompare(b.id));
+};
+
+// `--loop` repeats each eval before moving to the next; each repeat gets a
+// `#n` display suffix so the reporter keeps them apart, while `caseId` keeps
+// every repeat filed under one run history.
+export const expandLoop = (base: SuiteItem[], loop: number): SuiteItem[] =>
+  loop > 1
+    ? base.flatMap((b) =>
+        Array.from({ length: loop }, (_, i) => ({
+          ...b,
+          id: `${b.id} #${i + 1}`,
+          caseId: b.caseId ?? b.id,
+        })),
+      )
+    : base;
+
+export const planSuiteItems = async (
+  selected: readonly { path: string; id: string }[],
+  options: Parameters<typeof planHarnessItems>[1],
+): Promise<SuiteItem[]> => {
+  const plan = await planHarnessItems(selected, options);
+  for (const skipped of plan.unavailable) {
+    process.stderr.write(
+      `lux: skipping ${skipped.id}: harness command not found: ${skipped.commands.join(", ")}\n`,
+    );
+  }
+  if (plan.excluded.length > 0) {
+    process.stderr.write(
+      `lux: the harness focus excludes ${plan.excluded.length} pinned case${plan.excluded.length === 1 ? "" : "s"}: ${plan.excluded.join(", ")}\n`,
+    );
+  }
+  if (plan.items.length === 0) {
+    throw new Errors.IncurError({
+      code: plan.unavailable.length > 0 ? "NO_RUNNABLE_HARNESSES" : "NO_CASES_MATCHED",
+      message:
+        plan.unavailable.length > 0
+          ? "No cases remain: all selected matrix harnesses are unavailable."
+          : "No cases remain after applying the harness focus.",
+      exitCode: 1,
+    });
+  }
+  return plan.items;
+};

package/src/core/case.ts

@@ -3,6 +3,7 @@ import type { AssertionPlugin } from "./assertion.js";
 import { collectEvalCaseExtensions, setEvalCaseExtensions } from "./case-authoring-state.js";
 import { DriverCapabilitySchema } from "./driver.js";
 import { EvaluationMetadataSchema } from "./evaluation-clusters.js";
+import { HarnessMatrixSchema } from "./harness-matrix.js";
 import type { LifecycleHooksPlugin } from "./lifecycle-hooks.js";
 import { formatZodIssues } from "./zod.js";
 
@@ -46,6 +47,8 @@ const EvalCaseObjectSchema = z.object({
   prompt: z.string().min(1, "prompt is required"),
   persona: z.string().min(1).optional(),
   driver: DriverRefSchema.optional(),
+  /** Harness permutations this case runs through instead of the project matrix. */
+  matrix: HarnessMatrixSchema.optional(),
   answerer: AnswererRefSchema.optional(),
   fixtures: FixturesRefSchema.optional(),
   requires: z.array(DriverCapabilitySchema).optional(),

package/src/core/driver.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import type { EventHandler } from "./emitter.js";
 import type { Answer, Done, ErrorEvent, Interrupt, Progress, ReadyState } from "./events.js";
+import type { ReasoningEffort } from "./harness-catalog.js";
 import type { FixtureValueBinding } from "./lifecycle-hooks.js";
 
 export const ArtifactSchema = z.object({
@@ -97,6 +98,12 @@ export type DriverExperiment<Cfg> = {
   identity(config: Cfg, context: { rootDir: string }): unknown | Promise<unknown>;
 };
 
+/** Model and reasoning effort chosen by a harness matrix permutation. */
+export type HarnessSelection = {
+  model?: string | undefined;
+  effort?: ReasoningEffort | undefined;
+};
+
 export type DriverPlugin<Cfg = unknown> = {
   name: string;
   configSchema?: z.ZodTypeAny;
@@ -104,8 +111,27 @@ export type DriverPlugin<Cfg = unknown> = {
   runtime?: (config: Cfg) => DriverRuntime;
   /** Ordinary runs remain supported when controlled experiments are not declared. */
   experiment?: DriverExperiment<Cfg>;
+  /**
+   * Apply a matrix selection to raw (unvalidated) configuration. Drivers
+   * without a model concept leave this undefined and reject selection.
+   */
+  selectHarness?: (config: unknown, selection: HarnessSelection) => unknown;
 };
 
+/** Selection for drivers whose configuration uses `model` and `reasoningEffort`. */
+export const selectModelAndReasoningEffort = (
+  config: unknown,
+  selection: HarnessSelection,
+): unknown => ({
+  ...(config && typeof config === "object" && !Array.isArray(config)
+    ? (config as Record<string, unknown>)
+    : {}),
+  ...(selection.model !== undefined ? { model: selection.model } : {}),
+  ...(selection.effort !== undefined || selection.model !== undefined
+    ? { reasoningEffort: selection.effort }
+    : {}),
+});
+
 export const defineDriver = <S extends z.ZodType>(
   definition: Omit<DriverPlugin<z.output<S>>, "configSchema"> & { configSchema: S },
 ): Omit<DriverPlugin<z.output<S>>, "configSchema"> & { configSchema: S } => definition;

package/src/core/harness-catalog.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+
+export const HARNESS_EFFORTS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+] as const;
+export const ReasoningEffortSchema = z.enum(HARNESS_EFFORTS);
+export type ReasoningEffort = z.infer<typeof ReasoningEffortSchema>;
+
+export type CatalogModels = Readonly<Record<string, readonly ReasoningEffort[]>>;
+
+export type HarnessCatalog<
+  D extends string = string,
+  E extends readonly ReasoningEffort[] = readonly ReasoningEffort[],
+  M extends CatalogModels | undefined = CatalogModels | undefined,
+> = {
+  readonly driver: D;
+  readonly verified: string;
+  readonly sources: readonly string[];
+  readonly efforts: E;
+  readonly models: M;
+};
+
+export type ClosedHarnessCatalog = HarnessCatalog<
+  string,
+  readonly ReasoningEffort[],
+  CatalogModels
+>;
+
+export const defineHarnessCatalog = <
+  const D extends string,
+  const E extends readonly ReasoningEffort[],
+  const M extends CatalogModels | undefined,
+>(
+  catalog: HarnessCatalog<D, E, M>,
+): HarnessCatalog<D, E, M> => catalog;
+
+export const isClosedCatalog = (catalog: HarnessCatalog): catalog is ClosedHarnessCatalog =>
+  catalog.models !== undefined;
+
+export const catalogModelIds = (catalog: HarnessCatalog): string[] =>
+  Object.keys(catalog.models ?? {});
+
+export const catalogEfforts = (
+  catalog: HarnessCatalog,
+  model: string,
+): readonly ReasoningEffort[] | undefined => catalog.models?.[model];
+
+export const defaultCatalogEffort = (
+  catalog: HarnessCatalog,
+  model: string,
+): ReasoningEffort | undefined => {
+  if (!isClosedCatalog(catalog)) return undefined;
+  const accepted = catalog.models[model] ?? catalog.efforts;
+  return accepted.includes("low") ? "low" : accepted[0];
+};
+
+export const describeAcceptedEfforts = (
+  catalog: HarnessCatalog,
+  model: string,
+  accepted: readonly ReasoningEffort[],
+): string =>
+  accepted.length === 0
+    ? `model '${model}' has no reasoning effort in ${catalog.driver}`
+    : `model '${model}' accepts reasoning effort ${accepted.join(", ")} in ${catalog.driver}`;
+
+export const effortIssue = (
+  catalog: HarnessCatalog,
+  model: string,
+  effort: ReasoningEffort | undefined,
+): string | undefined => {
+  if (effort === undefined) return undefined;
+  const accepted = catalogEfforts(catalog, model);
+  if (accepted === undefined || accepted.includes(effort)) return undefined;
+  return describeAcceptedEfforts(catalog, model, accepted);
+};
+
+export type CatalogEffortConfig = {
+  model: string;
+  reasoningEffort?: ReasoningEffort | undefined;
+};
+
+export const applyCatalogEffort =
+  (catalog: HarnessCatalog) =>
+  <C extends CatalogEffortConfig>(config: C, ctx: z.RefinementCtx): C => {
+    const issue = effortIssue(catalog, config.model, config.reasoningEffort);
+    if (issue) {
+      ctx.addIssue({ code: "custom", path: ["reasoningEffort"], message: issue });
+      return config;
+    }
+    if (config.reasoningEffort !== undefined) return config;
+    const effort = defaultCatalogEffort(catalog, config.model);
+    return effort === undefined ? config : { ...config, reasoningEffort: effort };
+  };

package/src/core/harness-catalogs/antigravity.ts

@@ -0,0 +1,24 @@
+import { defineHarnessCatalog } from "../harness-catalog.js";
+
+const flash = ["low", "medium", "high"] as const;
+
+export const antigravityCatalog = defineHarnessCatalog({
+  driver: "antigravity",
+  verified: "2026-09-18",
+  sources: [
+    "https://antigravity.google/docs/models/",
+    "https://antigravity.google/docs/cli/headless/",
+    "agy models (needs a login)",
+  ],
+  efforts: flash,
+  models: {
+    "gemini-3.8-flash": flash,
+    "gemini-3.7-flash": flash,
+    "gemini-3.6-flash": flash,
+    "gemini-3.5-flash": flash,
+    "gemini-3.1-pro": ["low", "high"],
+    "claude-sonnet-4-6": [],
+    "claude-opus-4-6-thinking": [],
+    "gpt-oss-120b-medium": [],
+  },
+});

package/src/core/harness-catalogs/claude-code.ts

@@ -0,0 +1,25 @@
+import { defineHarnessCatalog } from "../harness-catalog.js";
+
+const full = ["low", "medium", "high", "xhigh", "max"] as const;
+const withoutXhigh = ["low", "medium", "high", "max"] as const;
+
+export const claudeCodeCatalog = defineHarnessCatalog({
+  driver: "claude-code",
+  verified: "2026-09-18",
+  sources: [
+    "https://code.claude.com/docs/en/model-config",
+    "https://platform.claude.com/docs/en/about-claude/models/overview",
+  ],
+  efforts: full,
+  models: {
+    "claude-fable-5-1": full,
+    "claude-fable-5": full,
+    "claude-opus-5": full,
+    "claude-opus-4-8": full,
+    "claude-opus-4-7": full,
+    "claude-sonnet-5": full,
+    "claude-opus-4-6": withoutXhigh,
+    "claude-sonnet-4-6": withoutXhigh,
+    "claude-haiku-4-5": [],
+  },
+});

package/src/core/harness-catalogs/codex.ts

@@ -0,0 +1,27 @@
+import { defineHarnessCatalog } from "../harness-catalog.js";
+
+const throughUltra = ["low", "medium", "high", "xhigh", "max", "ultra"] as const;
+const throughMax = ["low", "medium", "high", "xhigh", "max"] as const;
+const throughXhigh = ["low", "medium", "high", "xhigh"] as const;
+const noneThroughXhigh = ["none", "low", "medium", "high", "xhigh"] as const;
+
+export const codexCatalog = defineHarnessCatalog({
+  driver: "codex",
+  verified: "2026-09-18",
+  sources: [
+    "https://learn.chatgpt.com/docs/models",
+    "https://developers.openai.com/api/docs/guides/reasoning",
+    "codex app-server model/list (mirrored in $CODEX_HOME/models_cache.json)",
+  ],
+  efforts: ["none", "low", "medium", "high", "xhigh", "max", "ultra"],
+  models: {
+    "gpt-6-astra": throughUltra,
+    "gpt-5.6-sol": throughUltra,
+    "gpt-5.6-terra": throughUltra,
+    "gpt-5.6-luna": throughMax,
+    "gpt-5.5": throughXhigh,
+    "gpt-5.4": noneThroughXhigh,
+    "gpt-5.4-mini": noneThroughXhigh,
+    "gpt-5.3-codex": throughXhigh,
+  },
+});