orchestrator-workflow 0.28.0 → 0.29.0

package/dist/routing-state.js

@@ -0,0 +1,277 @@
+import { HARNESSES } from "./detect.js";
+import { CLASS_MODELS, DEFAULT_MODELS, DEFAULT_TIER, MODEL_CLASSES, ROLE_TIERS, ROLES, TIER_DEFS, opencodeModelValue, rolesForProfile, } from "./models.js";
+import { defaultCodexRouting, mergeRouting, parseRouting, validateCodexCatalog, } from "./routing.js";
+/** Validate compatibility maps independently of strict explicit routing. */
+export function parseOpencodeModelMaps(value) {
+    const parse = (raw, keys, name) => {
+        if (raw === undefined)
+            return undefined;
+        if (raw === null ||
+            typeof raw !== "object" ||
+            Array.isArray(raw) ||
+            ![Object.prototype, null].includes(Object.getPrototypeOf(raw))) {
+            throw new Error(`${name} must be a model map`);
+        }
+        const result = {};
+        for (const [key, model] of Object.entries(raw)) {
+            if (!keys.includes(key))
+                throw new Error(`Unknown ${name} key "${key}"`);
+            if (model === undefined) {
+                result[key] = undefined;
+                continue;
+            }
+            if (typeof model !== "string")
+                throw new Error(`${name}.${key} must be a model id`);
+            // A synthetic provider checks the same safe ID grammar while retaining
+            // the bare legacy value, without relaxing parseRouting for user patches.
+            parseRouting({
+                opencode: {
+                    implementer: {
+                        medium: {
+                            model: model.includes("/") ? model : `legacy/${model}`,
+                            effort: "medium",
+                        },
+                    },
+                },
+            });
+            result[key] = model;
+        }
+        return result;
+    };
+    const opencodeModels = parse(value.opencodeModels, ROLES, "opencodeModels");
+    const opencodeClassModels = parse(value.opencodeClassModels, MODEL_CLASSES, "opencodeClassModels");
+    return {
+        ...(opencodeModels !== undefined ? { opencodeModels } : {}),
+        ...(opencodeClassModels !== undefined ? { opencodeClassModels } : {}),
+    };
+}
+/** Persist only the compatibility values that cannot live in strict routing. */
+export function legacyOpencodeFallbacks(value) {
+    const parsed = parseOpencodeModelMaps(value);
+    const result = {};
+    for (const field of ["opencodeModels", "opencodeClassModels"]) {
+        const bare = Object.fromEntries(Object.entries(parsed[field] ?? {}).filter(([, model]) => model !== undefined && !model.includes("/")));
+        const keys = field === "opencodeModels" ? ROLES : MODEL_CLASSES;
+        const map = parsed[field];
+        // Complete qualified maps are represented entirely by routing. Otherwise
+        // presence (including {}) records inheritance for missing map keys.
+        if (map !== undefined && !keys.every((key) => map[key]?.includes("/")))
+            result[field] = bare;
+    }
+    return result;
+}
+/** Strip compatibility-only leaves before saving or parsing strict routing. */
+export function persistableRouting(routing) {
+    const result = mergeRouting(routing);
+    for (const role of ROLES) {
+        for (const tier of ROLE_TIERS[role]) {
+            const model = result.opencode?.[role]?.[tier]?.model;
+            if (model !== undefined && !model.includes("/"))
+                delete result.opencode?.[role]?.[tier];
+        }
+    }
+    return result;
+}
+export function selectedTiers(role, tiers) {
+    return tiers ? ROLE_TIERS[role] : [DEFAULT_TIER[role]];
+}
+/** Selects only leaves that the requested adapters actually install. */
+export function selectedRouting(routing, scope) {
+    const result = {};
+    for (const harness of scope.harnesses) {
+        for (const role of rolesForProfile(scope.profile)) {
+            for (const tier of selectedTiers(role, scope.tiers)) {
+                const selection = routing[harness]?.[role]?.[tier];
+                if (!selection)
+                    continue;
+                result[harness] ??= {};
+                result[harness][role] ??= {};
+                result[harness][role][tier] = { ...selection };
+            }
+        }
+    }
+    return result;
+}
+/** One shared, offline catalog check for setup and installation. */
+export function codexCatalogWarnings(routing, scope, catalog) {
+    if (!scope.harnesses.includes("codex"))
+        return [];
+    if (catalog === undefined) {
+        return [
+            "Codex model availability and reasoning-effort support were not validated: no capability catalog supplied. The requested selections are used without capability validation.",
+        ];
+    }
+    return validateCodexCatalog(selectedRouting(routing, { ...scope, harnesses: ["codex"] }), catalog);
+}
+export function legacyRouting(harnesses, models, opencodeModels, opencodeClassModels) {
+    const routing = {};
+    if (harnesses.includes("claude")) {
+        routing.claude = {};
+        for (const role of rolesForProfile("full")) {
+            routing.claude[role] = {
+                [DEFAULT_TIER[role]]: {
+                    model: models[role],
+                    effort: DEFAULT_TIER[role],
+                },
+            };
+            for (const tier of ROLE_TIERS[role]) {
+                if (tier === DEFAULT_TIER[role])
+                    continue;
+                routing.claude[role][tier] = {
+                    model: CLASS_MODELS[TIER_DEFS[tier].modelClass],
+                    effort: tier,
+                };
+            }
+        }
+    }
+    if (harnesses.includes("opencode")) {
+        routing.opencode = {};
+        for (const role of rolesForProfile("full")) {
+            const defaultModel = opencodeModels !== undefined
+                ? opencodeModels[role]
+                : opencodeModelValue(models[role]);
+            if (defaultModel) {
+                routing.opencode[role] = {
+                    [DEFAULT_TIER[role]]: {
+                        model: defaultModel,
+                        effort: DEFAULT_TIER[role],
+                    },
+                };
+            }
+            for (const tier of ROLE_TIERS[role]) {
+                if (tier === DEFAULT_TIER[role])
+                    continue;
+                const model = opencodeClassModels?.[TIER_DEFS[tier].modelClass];
+                if (!model)
+                    continue;
+                routing.opencode[role] ??= {};
+                routing.opencode[role][tier] = { model, effort: tier };
+            }
+        }
+    }
+    return routing;
+}
+/** Materializes legacy inputs and preserves leaves unless explicitly replaced. */
+export function normalizeRoutingState(input) {
+    const mode = input.routingMode === undefined ? "patch" : input.routingMode;
+    if (mode !== "patch" && mode !== "replace") {
+        throw new Error('routingMode must be "patch" or "replace"');
+    }
+    // Validate every caller-supplied layer before merge can drop unknown keys.
+    const patch = input.routing === undefined ? undefined : parseRouting(input.routing);
+    const previous = input.previousRouting === undefined
+        ? undefined
+        : parseRouting(input.previousRouting);
+    parseOpencodeModelMaps(input);
+    const legacy = legacyRouting(input.harnesses, input.models, input.opencodeModels, input.opencodeClassModels);
+    const result = mergeRouting(defaultCodexRouting(), legacy, mode === "patch" ? previous : undefined);
+    if (mode === "patch") {
+        for (const harness of ["claude", "opencode"]) {
+            if (!input.harnesses.includes(harness))
+                continue;
+            for (const role of ROLES) {
+                for (const tier of ROLE_TIERS[role]) {
+                    const defaultTier = tier === DEFAULT_TIER[role];
+                    const updatesLegacy = defaultTier && input.legacyOverrideRoles?.includes(role);
+                    const updatesResolved = harness === "opencode" &&
+                        (defaultTier
+                            ? input.updateOpencodeModels
+                            : input.updateOpencodeClassModels);
+                    if (!updatesLegacy && !updatesResolved)
+                        continue;
+                    const selection = legacy[harness]?.[role]?.[tier];
+                    if (selection) {
+                        result[harness] ??= {};
+                        result[harness][role] ??= {};
+                        result[harness][role][tier] = { ...selection };
+                    }
+                    else {
+                        // Explicitly unresolved legacy inputs restore session inheritance.
+                        delete result[harness]?.[role]?.[tier];
+                    }
+                }
+            }
+        }
+    }
+    return persistableRouting(mergeRouting(result, patch));
+}
+/** Materialize each precedence layer before a higher layer overrides it. */
+export function routingStateLayer(state) {
+    const maps = parseOpencodeModelMaps(state);
+    const routing = state.routing === undefined ? undefined : parseRouting(state.routing);
+    return mergeRouting(selectedRouting(legacyRouting(state.harnesses, { ...DEFAULT_MODELS, ...state.models }, maps.opencodeModels, maps.opencodeClassModels), state), 
+    // Supplied resolutions also record dormant roles and tiers for later use.
+    maps.opencodeModels !== undefined || maps.opencodeClassModels !== undefined
+        ? legacyRouting(["opencode"], DEFAULT_MODELS, maps.opencodeModels, maps.opencodeClassModels)
+        : undefined, routing);
+}
+/** Whether a missing concrete leaf has an explicit legacy inheritance record. */
+export function recordedOpencodeInheritance(maps, role, tier) {
+    return tier === DEFAULT_TIER[role]
+        ? maps.opencodeModels !== undefined &&
+            maps.opencodeModels[role] === undefined
+        : maps.opencodeClassModels !== undefined &&
+            maps.opencodeClassModels[TIER_DEFS[tier].modelClass] === undefined;
+}
+/** Merge recorded resolution state independently of the active render scope. */
+export function mergeRoutingStateLayers(...states) {
+    let routing = {};
+    const maps = {};
+    for (const state of states) {
+        const nextMaps = parseOpencodeModelMaps(state);
+        // A present map records every slot, including missing keys (inheritance).
+        // Replace it whole: inactive harnesses, roles, and tiers retain that intent.
+        if (nextMaps.opencodeModels !== undefined)
+            maps.opencodeModels = { ...nextMaps.opencodeModels };
+        if (nextMaps.opencodeClassModels !== undefined)
+            maps.opencodeClassModels = { ...nextMaps.opencodeClassModels };
+        for (const role of ROLES) {
+            for (const tier of ROLE_TIERS[role]) {
+                if (recordedOpencodeInheritance(nextMaps, role, tier))
+                    delete routing.opencode?.[role]?.[tier];
+            }
+        }
+        // The layer's concrete map entries and explicit routing win after masks.
+        routing = mergeRouting(routing, routingStateLayer(state));
+    }
+    return {
+        routing: persistableRouting(routing),
+        ...legacyOpencodeFallbacks(maps),
+    };
+}
+/** Compares installed scope without consulting a live opencode catalog. */
+export function compareRoutingState(repo, operator, scope) {
+    const effective = (state) => mergeRouting(defaultCodexRouting(), routingStateLayer({ ...state, ...scope }));
+    const actual = effective(repo);
+    const expected = effective(operator);
+    const actualLegacy = effective({ models: repo.models });
+    const expectedLegacy = effective({ models: operator.models });
+    const same = (left, right) => left?.model === right?.model && left?.effort === right?.effort;
+    let differs = false;
+    const gaps = [];
+    for (const harness of HARNESSES) {
+        if (!scope.harnesses.includes(harness))
+            continue;
+        for (const role of rolesForProfile(scope.profile)) {
+            for (const tier of selectedTiers(role, scope.tiers)) {
+                const left = actual[harness]?.[role]?.[tier];
+                const right = expected[harness]?.[role]?.[tier];
+                if (harness === "opencode" &&
+                    ((!left && !recordedOpencodeInheritance(repo, role, tier)) ||
+                        (!right && !recordedOpencodeInheritance(operator, role, tier)))) {
+                    gaps.push(`opencode/${role}/${tier}: a legacy model lacks a recorded provider id; routing comparison requires an explicit selection.`);
+                    continue;
+                }
+                if (!same(left, right)) {
+                    // A legacy model difference is already reported in divergence.models.
+                    // Reserve divergence.routing for a difference in the routing layer.
+                    const explainedByLegacy = same(left, actualLegacy[harness]?.[role]?.[tier]) &&
+                        same(right, expectedLegacy[harness]?.[role]?.[tier]);
+                    if (!explainedByLegacy)
+                        differs = true;
+                }
+            }
+        }
+    }
+    return { differs, gaps };
+}

package/dist/routing.d.ts

@@ -0,0 +1,103 @@
+import type { Harness } from "./detect.js";
+import type { Role, Tier } from "./models.js";
+export interface ModelSelection {
+    model: string;
+    effort: Tier;
+}
+/**
+ * A sparse harness-specific model-routing patch. Later layers supplied to
+ * mergeRouting replace a selection leaf while preserving unrelated entries.
+ */
+export type HarnessRouting = Partial<Record<Harness, Partial<Record<Role, Partial<Record<Tier, ModelSelection>>>>>>;
+/**
+ * Parses one strict, sparse routing layer. It deliberately never drops
+ * unrecognised data: a typo in a harness, role, tier, or selection is an
+ * error so configuration can be fixed before an installation changes files.
+ */
+export declare function parseRouting(value: unknown): HarnessRouting;
+/** Deeply merges sparse routing layers without mutating any input layer. */
+export declare function mergeRouting(...layers: (HarnessRouting | undefined)[]): HarnessRouting;
+declare const CODEX_DEFAULTS: {
+    explorer: {
+        low: {
+            model: string;
+            effort: "low";
+        };
+        medium: {
+            model: string;
+            effort: "medium";
+        };
+        high: {
+            model: string;
+            effort: "high";
+        };
+    };
+    "task-slicer": {
+        low: {
+            model: string;
+            effort: "low";
+        };
+        medium: {
+            model: string;
+            effort: "medium";
+        };
+        high: {
+            model: string;
+            effort: "high";
+        };
+    };
+    implementer: {
+        low: {
+            model: string;
+            effort: "low";
+        };
+        medium: {
+            model: string;
+            effort: "medium";
+        };
+        high: {
+            model: string;
+            effort: "high";
+        };
+        xhigh: {
+            model: string;
+            effort: "xhigh";
+        };
+    };
+    reviewer: {
+        medium: {
+            model: string;
+            effort: "medium";
+        };
+        high: {
+            model: string;
+            effort: "high";
+        };
+        xhigh: {
+            model: string;
+            effort: "xhigh";
+        };
+    };
+    advisor: {
+        high: {
+            model: string;
+            effort: "high";
+        };
+        xhigh: {
+            model: string;
+            effort: "xhigh";
+        };
+    };
+};
+export type CodexDefaultRouting = HarnessRouting & {
+    codex: typeof CODEX_DEFAULTS;
+};
+/** Returns a fresh complete Codex routing layer, including each default tier. */
+export declare function defaultCodexRouting(): CodexDefaultRouting;
+/**
+ * Validates the selected Codex leaves against a caller-provided debug-model
+ * catalog. This helper makes no CLI or network call; callers decide how to
+ * acquire the catalog and which installed roles and tiers to pass in.
+ */
+export declare function validateCodexCatalog(routing: HarnessRouting, catalog: unknown): string[];
+export {};

package/dist/routing.js

@@ -0,0 +1,254 @@
+import { HARNESSES } from "./detect.js";
+import { ROLE_TIERS, ROLES } from "./models.js";
+const TIERS = ["low", "medium", "high", "xhigh"];
+const DANGEROUS_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+const CLAUDE_ALIASES = new Set(["sonnet", "opus", "haiku"]);
+const YAML_IMPLICIT_SCALARS = new Set([
+    "true",
+    "false",
+    "null",
+    "yes",
+    "no",
+    "on",
+    "off",
+]);
+function isRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function assertSafeKeys(value, location) {
+    for (const key of Object.keys(value)) {
+        if (DANGEROUS_KEYS.has(key)) {
+            throw new Error(`Dangerous key "${key}" at ${location}`);
+        }
+    }
+}
+function assertKnownKey(key, known, location) {
+    if (!known.includes(key)) {
+        throw new Error(`Unknown ${location} "${key}"; valid values: ${known.join(", ")}`);
+    }
+}
+function assertModelId(model, harness, location) {
+    if (typeof model !== "string" ||
+        model.length === 0 ||
+        model !== model.trim()) {
+        throw new Error(`${location}.model must be a non-empty trimmed string`);
+    }
+    if (/\s|[\u0000-\u001f\u007f]/.test(model)) {
+        throw new Error(`${location}.model must not contain whitespace or control characters`);
+    }
+    const idPattern = harness === "opencode"
+        ? /^[A-Za-z][A-Za-z0-9._/@+-]*(?::[A-Za-z0-9][A-Za-z0-9._/@+-]*)*$/
+        : /^[A-Za-z][A-Za-z0-9._/@+-]*$/;
+    if (!idPattern.test(model)) {
+        throw new Error(`${location}.model must be a plain model id using letters, numbers, dots, underscores, slashes, at signs, pluses, hyphens, and (for opencode) version colons`);
+    }
+    if (YAML_IMPLICIT_SCALARS.has(model.toLowerCase())) {
+        throw new Error(`${location}.model must not be a YAML implicit scalar`);
+    }
+    if (harness === "codex" && CLAUDE_ALIASES.has(model)) {
+        throw new Error(`${location}.model must be a Codex model id, not Claude alias "${model}"`);
+    }
+    if (harness === "opencode" &&
+        (!model.includes("/") || model.startsWith("/") || model.endsWith("/"))) {
+        throw new Error(`${location}.model must be a qualified provider/model id for explicit opencode routing`);
+    }
+    return model;
+}
+function parseSelection(value, harness, location) {
+    if (!isRecord(value)) {
+        throw new Error(`${location} must be a selection object`);
+    }
+    assertSafeKeys(value, location);
+    const keys = Object.keys(value);
+    for (const key of keys) {
+        if (key !== "model" && key !== "effort") {
+            throw new Error(`Unknown ${location} field "${key}"; expected model, effort`);
+        }
+    }
+    if (!("model" in value) || !("effort" in value)) {
+        throw new Error(`${location} must contain both model and effort`);
+    }
+    const model = assertModelId(value.model, harness, location);
+    if (typeof value.effort !== "string") {
+        throw new Error(`${location}.effort must be one of ${TIERS.join(", ")}`);
+    }
+    assertKnownKey(value.effort, TIERS, `${location}.effort`);
+    return { model, effort: value.effort };
+}
+/**
+ * Parses one strict, sparse routing layer. It deliberately never drops
+ * unrecognised data: a typo in a harness, role, tier, or selection is an
+ * error so configuration can be fixed before an installation changes files.
+ */
+export function parseRouting(value) {
+    if (!isRecord(value)) {
+        throw new Error("Routing must be an object");
+    }
+    assertSafeKeys(value, "routing");
+    const result = {};
+    for (const [harnessName, harnessValue] of Object.entries(value)) {
+        assertKnownKey(harnessName, HARNESSES, "harness");
+        if (!isRecord(harnessValue)) {
+            throw new Error(`Routing for harness "${harnessName}" must be an object`);
+        }
+        assertSafeKeys(harnessValue, `routing.${harnessName}`);
+        const roleRouting = {};
+        for (const [roleName, roleValue] of Object.entries(harnessValue)) {
+            assertKnownKey(roleName, ROLES, `role for harness "${harnessName}"`);
+            if (!isRecord(roleValue)) {
+                throw new Error(`Routing for ${harnessName}.${roleName} must be an object`);
+            }
+            assertSafeKeys(roleValue, `routing.${harnessName}.${roleName}`);
+            const tierRouting = {};
+            for (const [tierName, selection] of Object.entries(roleValue)) {
+                assertKnownKey(tierName, TIERS, `tier for ${harnessName}.${roleName}`);
+                if (!ROLE_TIERS[roleName].includes(tierName)) {
+                    throw new Error(`Tier "${tierName}" is not allowed for role "${roleName}"; allowed tiers: ${ROLE_TIERS[roleName].join(", ")}`);
+                }
+                tierRouting[tierName] = parseSelection(selection, harnessName, `routing.${harnessName}.${roleName}.${tierName}`);
+            }
+            roleRouting[roleName] = tierRouting;
+        }
+        result[harnessName] = roleRouting;
+    }
+    return result;
+}
+/** Deeply merges sparse routing layers without mutating any input layer. */
+export function mergeRouting(...layers) {
+    const result = {};
+    for (const layer of layers) {
+        if (layer === undefined)
+            continue;
+        for (const harness of HARNESSES) {
+            const harnessLayer = layer[harness];
+            if (harnessLayer === undefined)
+                continue;
+            const resultHarness = (result[harness] ??= {});
+            for (const role of ROLES) {
+                const roleLayer = harnessLayer[role];
+                if (roleLayer === undefined)
+                    continue;
+                const resultRole = (resultHarness[role] ??= {});
+                for (const tier of ROLE_TIERS[role]) {
+                    const selection = roleLayer[tier];
+                    if (selection !== undefined) {
+                        resultRole[tier] = { ...selection };
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+const CODEX_DEFAULTS = {
+    explorer: {
+        low: { model: "gpt-5.6-luna", effort: "low" },
+        medium: { model: "gpt-5.6-sol", effort: "medium" },
+        high: { model: "gpt-5.6-sol", effort: "high" },
+    },
+    "task-slicer": {
+        low: { model: "gpt-5.6-luna", effort: "low" },
+        medium: { model: "gpt-5.6-sol", effort: "medium" },
+        high: { model: "gpt-5.6-sol", effort: "high" },
+    },
+    implementer: {
+        low: { model: "gpt-5.6-luna", effort: "low" },
+        medium: { model: "gpt-5.6-terra", effort: "medium" },
+        high: { model: "gpt-5.6-terra", effort: "high" },
+        xhigh: { model: "gpt-6-astra", effort: "xhigh" },
+    },
+    reviewer: {
+        medium: { model: "gpt-5.6-terra", effort: "medium" },
+        high: { model: "gpt-6-astra", effort: "high" },
+        xhigh: { model: "gpt-6-astra", effort: "xhigh" },
+    },
+    advisor: {
+        high: { model: "gpt-6-astra", effort: "high" },
+        xhigh: { model: "gpt-6-astra", effort: "xhigh" },
+    },
+};
+/** Returns a fresh complete Codex routing layer, including each default tier. */
+export function defaultCodexRouting() {
+    return mergeRouting({ codex: CODEX_DEFAULTS });
+}
+function normalizeCodexCatalog(catalog) {
+    const modelsValue = Array.isArray(catalog)
+        ? catalog
+        : isRecord(catalog)
+            ? catalog.models
+            : undefined;
+    if (!Array.isArray(modelsValue)) {
+        throw new Error("Codex catalog must be an array of models or an object with a models array");
+    }
+    const models = new Map();
+    for (const [index, modelValue] of modelsValue.entries()) {
+        if (!isRecord(modelValue) ||
+            typeof modelValue.slug !== "string" ||
+            modelValue.slug.trim() === "") {
+            throw new Error(`Codex catalog model at index ${index} must have a non-empty slug`);
+        }
+        if (models.has(modelValue.slug)) {
+            throw new Error(`Codex catalog contains duplicate model slug "${modelValue.slug}"`);
+        }
+        const support = modelValue.supported_reasoning_levels;
+        if (support === undefined) {
+            models.set(modelValue.slug, {
+                slug: modelValue.slug,
+                supportWarning: `Codex catalog does not provide reasoning-effort support for "${modelValue.slug}"; its selected effort could not be validated.`,
+            });
+            continue;
+        }
+        if (!Array.isArray(support)) {
+            throw new Error(`Codex catalog model "${modelValue.slug}" has malformed supported_reasoning_levels`);
+        }
+        const efforts = new Set();
+        for (const level of support) {
+            if (!isRecord(level) || typeof level.effort !== "string") {
+                throw new Error(`Codex catalog model "${modelValue.slug}" has malformed reasoning-effort support`);
+            }
+            efforts.add(level.effort);
+        }
+        models.set(modelValue.slug, {
+            slug: modelValue.slug,
+            supportedEfforts: efforts,
+        });
+    }
+    return models;
+}
+/**
+ * Validates the selected Codex leaves against a caller-provided debug-model
+ * catalog. This helper makes no CLI or network call; callers decide how to
+ * acquire the catalog and which installed roles and tiers to pass in.
+ */
+export function validateCodexCatalog(routing, catalog) {
+    const codexRouting = routing.codex;
+    if (codexRouting === undefined)
+        return [];
+    const models = normalizeCodexCatalog(catalog);
+    const warnings = new Set();
+    for (const role of ROLES) {
+        const roleRouting = codexRouting[role];
+        if (roleRouting === undefined)
+            continue;
+        for (const tier of ROLE_TIERS[role]) {
+            const selection = roleRouting[tier];
+            if (selection === undefined)
+                continue;
+            const model = models.get(selection.model);
+            if (model === undefined) {
+                throw new Error(`Codex model "${selection.model}" selected for ${role}/${tier} is unavailable in the supplied catalog`);
+            }
+            if (model.supportWarning !== undefined) {
+                warnings.add(model.supportWarning);
+            }
+            else if (!model.supportedEfforts?.has(selection.effort)) {
+                throw new Error(`Codex model "${selection.model}" does not support reasoning effort "${selection.effort}" selected for ${role}/${tier}`);
+            }
+        }
+    }
+    return [...warnings];
+}

package/dist/uninstall.js

@@ -81,6 +81,8 @@ const PRUNE_CANDIDATES = [
     join(".agents", "skills", "orchestrator-workflow"),
     join(".agents", "skills"),
     ".agents",
+    join(".codex", "agents"),
+    ".codex",
     join(".opencode", "skills", "orchestrator-workflow"),
     join(".opencode", "skills"),
     join(".opencode", "agents"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orchestrator-workflow",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Installer for an orchestrator-led agent workflow: .ai/ run state, an AGENTS.md policy section, and per-harness subagent definitions for Claude Code, OpenAI Codex, and opencode",
   "main": "dist/index.js",
   "type": "module",
@@ -50,6 +50,7 @@
     "inquirer": "^9.2.0"
   },
   "devDependencies": {
+    "@iarna/toml": "^2.2.5",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.11.0",
     "prettier": "^3.8.1",