@gtrabanco/pi-agentic-workflow 0.15.2 → 0.16.0

package/README.md

@@ -97,6 +97,55 @@ The first workflow command you run after install says once that routing is
 configurable, then never again. That acknowledgement is stored in
 `~/.pi/agent/pi-agentic-workflow-state.json`, not in your config.
 
+## Model profiles
+
+The routing config above is the **`default` profile**. A profile is one coherent
+set of routes, and you can define as many as you like under `profiles`:
+
+```json
+{
+  "recommendedModels": true,
+  "profileOrder": ["work", "cheap"],
+  "profileFallback": { "applyTo": "flow", "resume": "continue", "retryAfterSeconds": 86400 },
+  "profiles": {
+    "work": { "default": { "model": "anthropic/claude-opus-4-5", "thinking": "high" } },
+    "cheap": { "default": { "model": "openai/gpt-5.2", "thinking": "medium" } }
+  },
+  "default": { "model": "inherit", "thinking": "inherit" },
+  "commands": { "review-change": { "thinking": "max" } }
+}
+```
+
+- **`profileOrder`** — the preference chain, first = most preferred/active. For each
+  command the router probes the profiles in order and the **first whose model is
+  usable** serves it; when the preferred profile's model is unavailable it falls
+  through to the next. A profile participates only for keys it actually declares.
+- **`profiles`** — unlimited named profiles. The implicit **`default`** profile is
+  the top-level `default` + `commands` above, so a config with just those two keys
+  resolves exactly as before.
+- **Built-in `nan` profile.** With `recommendedModels: true` (the default), when the
+  session has models from the `nan` provider, a code-only `nan` profile is appended
+  to the end of the chain (or used alone when you set no `profileOrder`). It carries
+  the per-command ladders from the README's NaN section. Any route you declare —
+  including an explicit `"inherit"` — wins over it. Set `recommendedModels: false`
+  to switch it off; the settings console writes the key explicitly on save when the
+  provider is available.
+- **`profileFallback`** — what happens when the preferred profile's model is
+  unusable:
+  - `applyTo`: `"flow"` (default) records the switch so later commands keep using the
+    fallback profile; `"command"` falls back for this command only and the next
+    command retries the preferred profile.
+  - `resume`: `"continue"` (default) lets the in-flight stage run on the fallback
+    profile; `"restart"` makes the `advance` conductor defer the switch and re-run
+    the stage under the fallback profile instead.
+  - `retryAfterSeconds`: how long a `flow` demotion lasts before the preferred
+    profile is probed again (default `86400`, one day).
+- **Rotation.** `/agentic-workflow-settings` is scope → profile → routes: pick the
+  scope, pick the profile to edit, then edit its routes. `Rotate the active profile`
+  moves a profile to the front of `profileOrder` and clears any recorded demotion.
+  The built-in `nan` profile is shown but not editable — create a profile to
+  override it.
+
 ## Path protection (optional)
 
 The Tier 2 preventive guard blocks a `write` / `edit` tool call to an existing

package/dist/conductor/loop.js

@@ -62,6 +62,7 @@ export async function runConductorLoop(deps) {
     const bin = deps.runtimeBin ?? "bun";
     let consecutivePartials = 0;
     let consecutiveSenses = 0;
+    let consecutiveDeferred = 0;
     let invoked = 0;
     for (let iteration = 1; iteration <= cap; iteration++) {
         // ── 1. Sensor ───────────────────────────────────────────────────────
@@ -186,7 +187,28 @@ export async function runConductorLoop(deps) {
                     iterations: iteration - 1,
                 };
             }
-            await deps.sendUserMessage(invocation);
+            const sendResult = await deps.sendUserMessage(invocation);
+            if (sendResult.ok === false) {
+                deps.appendRunLog(formatLogLine("stop", "stop-dispatch-refused", invocation, iteration, cap));
+                return {
+                    banner: "ADVANCE: STOPPED",
+                    stopCode: "stop-dispatch-refused",
+                    detail: "the stage dispatch was refused (the router already explained why)",
+                    iterations: iteration - 1,
+                };
+            }
+            if (sendResult.deferred === true) {
+                // AC10 restart: the routing recorded the demotion instead of sending; re-run
+                // the iteration so the stage is decided and served under the fallback profile.
+                deps.appendRunLog(formatLogLine("switch", `${sendResult.profileSwitched?.from ?? "?"}->${sendResult.profileSwitched?.to ?? "?"}`, invocation, iteration, cap));
+                consecutiveDeferred++;
+                if (consecutiveDeferred >= 2) {
+                    deps.appendRunLog(formatLogLine("stop", "stop-profile-switch-loop", "deferred-twice", iteration, cap));
+                    return { banner: "ADVANCE: STOPPED", stopCode: "stop-profile-switch-loop", detail: "profile switch deferred twice without progress", iterations: iteration - 1 };
+                }
+                continue; // do NOT increment `invoked`
+            }
+            consecutiveDeferred = 0;
             deps.appendRunLog(formatLogLine("invoke", decision.reasonCode, invocation, iteration, cap));
             // One-stage-per-invocation wiring: the invoked skill must settle before
             // the next sensor run can see its effect, so the default wiring stops

package/dist/conductor/types.d.ts

@@ -71,7 +71,13 @@ export interface LoopDeps {
     invocation: (decision: ActionDecision, opts: InvocationOpts) => InvocationResult;
     sendUserMessage: (invocation: string) => Promise<{
         ok: boolean;
+        profileSwitched?: {
+            from: string;
+            to: string;
+        };
+        deferred?: boolean;
     }>;
+    profileResume?: "continue" | "restart";
     gitProbe: () => Promise<{
         porcelain: string;
         ahead: number;

package/dist/config/defaults.js

@@ -1,4 +1,5 @@
 import { SHIPPED_PATH_POLICY, intersectPathPolicy } from "./path-policy.js";
+import { DEFAULT_PROFILE_FALLBACK } from "./types.js";
 /**
  * The in-package default (SPEC S6, D-P6): a fresh install with no config file
  * anywhere routes every command on the session model, and the fail-closed
@@ -10,5 +11,15 @@ export const DEFAULT_CONFIG = {
     commands: {},
     onUnavailableRoute: "stop",
     onSettle: "keep",
+    // Feature 60 added the resolved path-protection policy to the effective
+    // config; the shipped floor with no override and no degradation.
     pathProtection: intersectPathPolicy(SHIPPED_PATH_POLICY, {}),
+    // Feature 63 — model profiles: recommended built-in profiles, empty
+    // named profiles, empty order (default-only), and default demotion policy.
+    recommendedModels: true,
+    profiles: {},
+    profileOrder: [],
+    profileFallback: { ...DEFAULT_PROFILE_FALLBACK },
+    // Feature 63 — model profiles: declared keys (none, zero-config).
+    declared: { default: { model: false, thinking: false }, commands: {} },
 };

package/dist/config/merge.js

@@ -1,6 +1,6 @@
 import { DEFAULT_CONFIG, DEFAULT_ROUTE } from "./defaults.js";
 import { SHIPPED_PATH_POLICY, intersectPathPolicy, mergePathProtectionOverrides } from "./path-policy.js";
-import { DEFAULT_ADVANCE_CONFIG } from "./types.js";
+import { DEFAULT_ADVANCE_CONFIG, DEFAULT_PROFILE_FALLBACK } from "./types.js";
 /**
  * Project-over-global merge (SPEC S5, S6).
  *
@@ -19,6 +19,80 @@ function pick(fallback, ...values) {
             return value;
     return fallback;
 }
+/** Merge two RouteFiles key-by-key (used for profile routes). */
+function mergeRouteFiles(globalRoute, projectRoute) {
+    if (globalRoute === undefined && projectRoute === undefined)
+        return undefined;
+    const out = {};
+    if (globalRoute?.model !== undefined || projectRoute?.model !== undefined) {
+        // A chain declared only at global scope survives.
+        // Per-key: project chain wins, or global chain, or inherited string.
+        if (projectRoute?.model !== undefined) {
+            out.model = projectRoute.model;
+        }
+        else if (globalRoute?.model !== undefined) {
+            out.model = globalRoute.model;
+        }
+    }
+    if (globalRoute?.thinking !== undefined || projectRoute?.thinking !== undefined) {
+        out.thinking = pick(DEFAULT_ROUTE.thinking, projectRoute?.thinking, globalRoute?.thinking);
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/** Per-profile merge: each profile's default and commands merge key-by-key.
+ *  A profile name may exist in one scope but not the other; the missing
+ *  scope simply contributes nothing. */
+function mergeProfiles(globalProfiles, projectProfiles) {
+    const allNames = new Set([
+        ...Object.keys(globalProfiles ?? {}),
+        ...Object.keys(projectProfiles ?? {}),
+    ]);
+    const result = {};
+    for (const name of allNames) {
+        const gDef = globalProfiles?.[name];
+        const pDef = projectProfiles?.[name];
+        const mergedDef = {};
+        // Merge default routes key-by-key.
+        if (gDef?.default !== undefined || pDef?.default !== undefined) {
+            const mergedDefault = {};
+            if (pDef?.default !== undefined && pDef.default.model !== undefined) {
+                mergedDefault.model = pDef.default.model;
+            }
+            else if (gDef?.default !== undefined && gDef.default.model !== undefined) {
+                mergedDefault.model = gDef.default.model;
+            }
+            if (gDef?.default?.thinking !== undefined || pDef?.default?.thinking !== undefined) {
+                mergedDefault.thinking = pick(DEFAULT_ROUTE.thinking, pDef?.default?.thinking, gDef?.default?.thinking);
+            }
+            mergedDef.default = mergedDefault;
+        }
+        // Merge commands key-by-key.
+        const gCmds = gDef?.commands ?? {};
+        const pCmds = pDef?.commands ?? {};
+        const allCmdNames = new Set([...Object.keys(gCmds), ...Object.keys(pCmds)]);
+        if (allCmdNames.size > 0) {
+            mergedDef.commands = {};
+            for (const cmd of allCmdNames) {
+                const mergedCmd = mergeRouteFiles(gCmds[cmd], pCmds[cmd]);
+                if (mergedCmd)
+                    mergedDef.commands[cmd] = mergedCmd;
+            }
+        }
+        if (Object.keys(mergedDef).length > 0) {
+            result[name] = mergedDef;
+        }
+    }
+    return result;
+}
+/** Per-key merge for profileFallback: each field independently
+ *  takes project value, then global value, then the shipped default. */
+function mergeProfileFallback(globalFb, projectFb) {
+    return {
+        applyTo: pick(DEFAULT_PROFILE_FALLBACK.applyTo, projectFb?.applyTo, globalFb?.applyTo),
+        resume: pick(DEFAULT_PROFILE_FALLBACK.resume, projectFb?.resume, globalFb?.resume),
+        retryAfterSeconds: pick(DEFAULT_PROFILE_FALLBACK.retryAfterSeconds, projectFb?.retryAfterSeconds, globalFb?.retryAfterSeconds),
+    };
+}
 function resolveRoute(defaults, globalRoute, projectRoute) {
     return {
         model: pick(DEFAULT_ROUTE.model, projectRoute?.model, globalRoute?.model, defaults.model),
@@ -33,12 +107,30 @@ export function mergeConfigs(globalFile = {}, projectFile = {}) {
     for (const name of new Set([...Object.keys(globalCommands), ...Object.keys(projectCommands)])) {
         commands[name] = resolveRoute(effectiveDefault, globalCommands[name], projectCommands[name]);
     }
+    // Feature 63 — model profiles: computed declaredness from raw files.
+    const declaredDefault = {
+        model: globalFile.default?.model !== undefined || projectFile.default?.model !== undefined,
+        thinking: globalFile.default?.thinking !== undefined || projectFile.default?.thinking !== undefined,
+    };
+    const declaredCommands = {};
+    for (const name of new Set([...Object.keys(globalCommands), ...Object.keys(projectCommands)])) {
+        declaredCommands[name] = {
+            model: declaredDefault.model || globalCommands[name]?.model !== undefined || projectCommands[name]?.model !== undefined,
+            thinking: declaredDefault.thinking || globalCommands[name]?.thinking !== undefined || projectCommands[name]?.thinking !== undefined,
+        };
+    }
     const merged = {
         default: effectiveDefault,
         commands,
         onUnavailableRoute: projectFile.onUnavailableRoute ?? globalFile.onUnavailableRoute ?? DEFAULT_CONFIG.onUnavailableRoute,
         onSettle: projectFile.onSettle ?? globalFile.onSettle ?? DEFAULT_CONFIG.onSettle,
         pathProtection: intersectPathPolicy(SHIPPED_PATH_POLICY, mergePathProtectionOverrides(globalFile.pathProtection, projectFile.pathProtection)),
+        // Feature 63 — model profiles.
+        recommendedModels: pick(true, projectFile.recommendedModels, globalFile.recommendedModels),
+        profiles: mergeProfiles(globalFile.profiles, projectFile.profiles),
+        profileOrder: pick([], projectFile.profileOrder, globalFile.profileOrder),
+        profileFallback: mergeProfileFallback(globalFile.profileFallback, projectFile.profileFallback),
+        declared: { default: declaredDefault, commands: declaredCommands },
     };
     // Advance knobs appear only when a scope declares them, so configs that
     // predate feature 62 keep their exact resolved shape (no undefined key).

package/dist/config/profiles.d.ts

@@ -0,0 +1,36 @@
+import type { EffectiveConfig, ProfileCandidate } from "./types.js";
+/** Options for recommended-profile resolution. */
+export interface RecommendedOptions {
+    providerAvailable: (provider: string) => boolean;
+}
+/**
+ * Compute the ordered list of profile names to probe for a command.
+ *
+ * Rules:
+ *  - Start from `config.profileOrder` if non-empty, else `["default"]`.
+ *  - If `config.recommendedModels` is true and the `nan` provider is available,
+ *    append `"nan"` (unless it is already present in the order).
+ *  - Returns a fresh array so callers may mutate without side effects.
+ */
+export declare function effectiveProfileOrder(config: EffectiveConfig, opts: RecommendedOptions): string[];
+/**
+ * Resolve a profile chain for one command.
+ *
+ * Iterates the ordered profile names from `effectiveProfileOrder`. For each name:
+ *  - `nan` → uses `config.profiles.nan` if the user overrode it, else
+ *    the built-in `RECOMMENDED_PROFILES.nan`.
+ *  - `default` → the implicit profile made from `config.default` and
+ *    `config.commands` (top-level, already-merged).
+ *  - Any other name → `config.profiles[name]` (user-defined profile).
+ *
+ * Skip names with no profile definition.
+ * For each candidate, compute the route file from the command's explicit
+ * command route or the profile's default route. Skip if neither is defined.
+ *
+ * Built-in nan profile (`RECOMMENDED_PROFILES.nan`, never user-overridden)
+ * always reports `declared = { model: true, thinking: true }`.
+ *
+ * Returns candidates in order, each with its route and per-key declaration
+ * status.
+ */
+export declare function resolveProfileChain(config: EffectiveConfig, command: string, opts: RecommendedOptions): ProfileCandidate[];

package/dist/config/profiles.js

@@ -0,0 +1,102 @@
+import { RECOMMENDED_PROFILES } from "./recommended.js";
+/**
+ * Compute the ordered list of profile names to probe for a command.
+ *
+ * Rules:
+ *  - Start from `config.profileOrder` if non-empty, else `["default"]`.
+ *  - If `config.recommendedModels` is true and the `nan` provider is available,
+ *    append `"nan"` (unless it is already present in the order).
+ *  - Returns a fresh array so callers may mutate without side effects.
+ */
+export function effectiveProfileOrder(config, opts) {
+    const base = config.profileOrder.length > 0 ? config.profileOrder : ["default"];
+    const result = [...base];
+    if (config.recommendedModels && opts.providerAvailable("nan")) {
+        if (!result.includes("nan")) {
+            result.push("nan");
+        }
+    }
+    return result;
+}
+/**
+ * Resolve a profile chain for one command.
+ *
+ * Iterates the ordered profile names from `effectiveProfileOrder`. For each name:
+ *  - `nan` → uses `config.profiles.nan` if the user overrode it, else
+ *    the built-in `RECOMMENDED_PROFILES.nan`.
+ *  - `default` → the implicit profile made from `config.default` and
+ *    `config.commands` (top-level, already-merged).
+ *  - Any other name → `config.profiles[name]` (user-defined profile).
+ *
+ * Skip names with no profile definition.
+ * For each candidate, compute the route file from the command's explicit
+ * command route or the profile's default route. Skip if neither is defined.
+ *
+ * Built-in nan profile (`RECOMMENDED_PROFILES.nan`, never user-overridden)
+ * always reports `declared = { model: true, thinking: true }`.
+ *
+ * Returns candidates in order, each with its route and per-key declaration
+ * status.
+ */
+export function resolveProfileChain(config, command, opts) {
+    const profileNames = effectiveProfileOrder(config, opts);
+    const candidates = [];
+    for (const name of profileNames) {
+        let def;
+        if (name === "nan") {
+            def = config.profiles.nan ?? RECOMMENDED_PROFILES.nan;
+        }
+        else if (name === "default") {
+            def = { default: config.default, commands: config.commands };
+        }
+        else {
+            def = config.profiles[name];
+        }
+        if (!def) {
+            continue;
+        }
+        const routeFile = def.commands?.[command] ?? def.default;
+        if (routeFile === undefined) {
+            continue;
+        }
+        // Determine per-key declaredness from the raw file presence (not value).
+        // For the "default" profile the declared info comes from the merged
+        // EffectiveConfig.declared surface; for named profiles we check raw
+        // presence; the built-in nan always declares both.
+        let declared;
+        if (name === "nan" && config.profiles.nan === undefined) {
+            // Built-in nan always declares both keys.
+            declared = { model: true, thinking: true };
+        }
+        else if (name === "default") {
+            // Use the merged declared surface (carries raw-file presence).
+            declared = config.declared.commands[command] ?? config.declared.default;
+        }
+        else {
+            // User-defined named profile (including a user-defined "nan"): check raw presence.
+            const routeFileDef = config.profiles[name];
+            const rFile = routeFileDef?.commands?.[command] ?? routeFileDef?.default;
+            declared = {
+                model: rFile?.model !== undefined,
+                thinking: rFile?.thinking !== undefined,
+            };
+        }
+        // Skip candidates that declare nothing (covers both: truly empty
+        // routeFile, and the shipped inherit/inherit default).
+        if (!declared.model && !declared.thinking) {
+            continue;
+        }
+        const route = {
+            model: routeFile.model ?? "inherit",
+            thinking: routeFile.thinking ?? "inherit",
+        };
+        const builtIn = name === "nan" && config.profiles.nan === undefined;
+        candidates.push({
+            profile: name,
+            builtIn,
+            route,
+            declared,
+        });
+    }
+    return candidates;
+}

package/dist/config/recommended.d.ts

@@ -0,0 +1,14 @@
+import type { RouteFile } from "./types.js";
+/** Provider identifiers shipped as built-in profiles. */
+export declare const RECOMMENDED_PROVIDERS: readonly string[];
+/** A built-in profile shape: optional default route + per-command overrides. */
+export interface RecommendedProfile {
+    default?: RouteFile;
+    commands: Record<string, RouteFile>;
+}
+/**
+ * Built-in model profiles keyed by provider identifier.
+ * Only these four models are ever used: nan/glm5.3, nan/glm5.3-flash,
+ * nan/deepseek-v4-flash, nan/mimo-v2.5.
+ */
+export declare const RECOMMENDED_PROFILES: Readonly<Record<string, RecommendedProfile>>;

package/dist/config/recommended.js

@@ -0,0 +1,28 @@
+/** Provider identifiers shipped as built-in profiles. */
+export const RECOMMENDED_PROVIDERS = ["nan"];
+/**
+ * Built-in model profiles keyed by provider identifier.
+ * Only these four models are ever used: nan/glm5.3, nan/glm5.3-flash,
+ * nan/deepseek-v4-flash, nan/mimo-v2.5.
+ */
+export const RECOMMENDED_PROFILES = {
+    nan: {
+        default: { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+        commands: {
+            "audit-pr": { model: ["nan/mimo-v2.5", "nan/deepseek-v4-flash"], thinking: "high" },
+            "product-audit": { model: ["nan/glm5.3", "nan/mimo-v2.5", "nan/deepseek-v4-flash"], thinking: "high" },
+            "review-change": { model: ["nan/mimo-v2.5", "nan/glm5.3-flash", "nan/deepseek-v4-flash"], thinking: "high" },
+            "unit-lane": { model: ["nan/mimo-v2.5", "nan/glm5.3-flash", "nan/deepseek-v4-flash"], thinking: "high" },
+            "triage-issue": { model: ["nan/glm5.3-flash", "nan/deepseek-v4-flash"], thinking: "inherit" },
+            "init-workspace": { model: ["nan/glm5.3-flash", "nan/deepseek-v4-flash"], thinking: "inherit" },
+            "execute-phase": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "fold-findings": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "log-session": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "workflow-status": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "audit-docs": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "discover-repository-state": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "resolve-repository-state": { model: ["nan/deepseek-v4-flash", "nan/glm5.3-flash"], thinking: "inherit" },
+            "advance": { model: ["nan/glm5.3-flash", "nan/deepseek-v4-flash"], thinking: "inherit" },
+        },
+    },
+};

package/dist/config/schema.js

@@ -1,4 +1,4 @@
-import { MAX_MODEL_CHAIN, SETTLE_POLICIES, THINKING_LEVELS, UNAVAILABLE_ROUTE_POLICIES } from "./types.js";
+import { MAX_MODEL_CHAIN, SETTLE_POLICIES, THINKING_LEVELS, UNAVAILABLE_ROUTE_POLICIES, PROFILE_FALLBACK_APPLY_TO, PROFILE_FALLBACK_RESUME, } from "./types.js";
 import { OPERATIONS, PATH_GLOB_MAX_LENGTH, PHASE_STATES, REQUIREMENTS } from "./path-policy.js";
 /**
  * Strict validator for one config file (SPEC S5-S8, D-E5).
@@ -9,7 +9,18 @@ import { OPERATIONS, PATH_GLOB_MAX_LENGTH, PHASE_STATES, REQUIREMENTS } from "./
  * strong model ran when it did not. Only a *missing* file resolves to the
  * default, and that decision belongs to the loader.
  */
-const ROOT_KEYS = new Set(["default", "commands", "onUnavailableRoute", "onSettle", "pathProtection", "advance"]);
+const ROOT_KEYS = new Set([
+    "default",
+    "commands",
+    "onUnavailableRoute",
+    "onSettle",
+    "pathProtection",
+    "advance",
+    "recommendedModels",
+    "profiles",
+    "profileOrder",
+    "profileFallback",
+]);
 const ROUTE_KEYS = new Set(["model", "thinking"]);
 const COMMAND_NAME = /^[a-z0-9][a-z0-9._-]*$/u;
 function isRecord(value) {
@@ -41,6 +52,112 @@ function isUnavailableRoutePolicy(value) {
 function isSettlePolicy(value) {
     return SETTLE_POLICIES.includes(value);
 }
+/** Strict validator for `recommendedModels` (feature 63, AC1). */
+function isRecommendedModels(value) {
+    return typeof value === "boolean";
+}
+/** Strict validator for the `profileOrder` array (feature 63, AC6). */
+const PROFILE_ORDER_ENTRY = /^[a-z0-9][a-z0-9._-]*$/u;
+function checkProfileOrder(value, issues) {
+    if (!Array.isArray(value)) {
+        issues.push({ path: "$.profileOrder", message: "must be an array of non-empty strings" });
+        return undefined;
+    }
+    if (value.length === 0) {
+        issues.push({ path: "$.profileOrder", message: "must be a non-empty array of non-empty strings" });
+        return undefined;
+    }
+    for (let i = 0; i < value.length; i++) {
+        const entry = value[i];
+        if (typeof entry !== "string" || !PROFILE_ORDER_ENTRY.test(entry)) {
+            issues.push({ path: "$.profileOrder", message: "must be a non-empty array of non-empty strings" });
+            return undefined;
+        }
+    }
+    return value;
+}
+/** Strict validator for the `profileFallback` object (feature 63). */
+const PROFILE_FALLBACK_KEYS = new Set(["applyTo", "resume", "retryAfterSeconds"]);
+;
+function checkProfileFallback(value, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path: "$.profileFallback", message: "must be an object with applyTo, resume, retryAfterSeconds" });
+        return undefined;
+    }
+    const out = {};
+    for (const key of Object.keys(value)) {
+        if (!PROFILE_FALLBACK_KEYS.has(key)) {
+            issues.push({ path: `$.profileFallback.${key}`, message: `unknown profileFallback key "${key}" (allowed: applyTo, resume, retryAfterSeconds)` });
+            continue;
+        }
+        const v = value[key];
+        if (key === "applyTo") {
+            if (!PROFILE_FALLBACK_APPLY_TO.includes(v)) {
+                issues.push({ path: "$.profileFallback.applyTo", message: `must be one of ${PROFILE_FALLBACK_APPLY_TO.join(", ")}` });
+            }
+            else {
+                out.applyTo = v;
+            }
+        }
+        else if (key === "resume") {
+            if (!PROFILE_FALLBACK_RESUME.includes(v)) {
+                issues.push({ path: "$.profileFallback.resume", message: `must be one of ${PROFILE_FALLBACK_RESUME.join(", ")}` });
+            }
+            else {
+                out.resume = v;
+            }
+        }
+        else if (key === "retryAfterSeconds") {
+            if (typeof v !== "number" || !Number.isInteger(v) || v < 1) {
+                issues.push({ path: "$.profileFallback.retryAfterSeconds", message: "must be a positive integer" });
+            }
+            else {
+                out.retryAfterSeconds = v;
+            }
+        }
+    }
+    return out;
+}
+/** Strict validator for one profile file (feature 63, AC5). */
+const PROFILE_FILE_KEYS = new Set(["default", "commands"]);
+;
+function checkProfileFile(value, path, issues) {
+    if (!isRecord(value)) {
+        issues.push({ path, message: "profile must be an object with optional default/commands keys" });
+        return undefined;
+    }
+    const out = {};
+    for (const key of Object.keys(value)) {
+        if (!PROFILE_FILE_KEYS.has(key)) {
+            issues.push({ path: `${path}.${key}`, message: `unknown profile key "${key}" (allowed: default, commands)` });
+            continue;
+        }
+        if (key === "default") {
+            const route = checkRoute(value[key], `${path}.default`, issues);
+            if (route)
+                out.default = route;
+        }
+        else if (key === "commands") {
+            if (!isRecord(value[key])) {
+                issues.push({ path: `${path}.commands`, message: "commands must be an object mapping command names to routes" });
+            }
+            else {
+                const commands = {};
+                for (const [cmdName, raw] of Object.entries(value[key])) {
+                    if (!COMMAND_NAME.test(cmdName)) {
+                        issues.push({ path: `${path}.commands.${displayKey(cmdName)}`, message: "command name must be a single lowercase slug" });
+                        continue;
+                    }
+                    const route = checkRoute(raw, `${path}.commands.${displayKey(cmdName)}`, issues);
+                    if (route)
+                        commands[cmdName] = route;
+                }
+                out.commands = commands;
+            }
+        }
+    }
+    return out;
+}
 /** Strict validator for the optional `advance` conductor config (feature 62). */
 const ADVANCE_KEYS = new Set(["iterationsCap", "sensitivePaths", "securityPaths", "runLogPath"]);
 function checkAdvance(value, path, issues) {
@@ -214,7 +331,7 @@ function validateConfig(value) {
         if (!ROOT_KEYS.has(key)) {
             issues.push({
                 path: `$.${displayKey(key)}`,
-                message: `unknown config key "${key}" (allowed: default, commands, onUnavailableRoute, onSettle, pathProtection, advance)`,
+                message: `unknown config key "${key}" (allowed: default, commands, onUnavailableRoute, onSettle, pathProtection, advance, recommendedModels, profiles, profileOrder, profileFallback)`,
             });
         }
     }
@@ -273,6 +390,45 @@ function validateConfig(value) {
         if (override)
             config.pathProtection = override;
     }
+    if (value.recommendedModels !== undefined) {
+        if (!isRecommendedModels(value.recommendedModels)) {
+            issues.push({
+                path: "$.recommendedModels",
+                message: `must be a boolean, got ${describe(value.recommendedModels)}`,
+            });
+        }
+        else {
+            config.recommendedModels = value.recommendedModels;
+        }
+    }
+    if (value.profiles !== undefined) {
+        if (!isRecord(value.profiles)) {
+            issues.push({ path: "$.profiles", message: "must be an object mapping profile names to profile definitions" });
+        }
+        else {
+            const profiles = {};
+            for (const [profileName, profileDef] of Object.entries(value.profiles)) {
+                if (!COMMAND_NAME.test(profileName)) {
+                    issues.push({ path: `$.profiles.${displayKey(profileName)}`, message: "profile name must be a single lowercase slug" });
+                    continue;
+                }
+                const profile = checkProfileFile(profileDef, `$.profiles.${displayKey(profileName)}`, issues);
+                if (profile)
+                    profiles[profileName] = profile;
+            }
+            config.profiles = profiles;
+        }
+    }
+    if (value.profileOrder !== undefined) {
+        const order = checkProfileOrder(value.profileOrder, issues);
+        if (order)
+            config.profileOrder = order;
+    }
+    if (value.profileFallback !== undefined) {
+        const fb = checkProfileFallback(value.profileFallback, issues);
+        if (fb)
+            config.profileFallback = fb;
+    }
     return issues.length > 0 ? { ok: false, issues } : { ok: true, config };
 }
 /**