@hasna/switcher 0.1.2 → 0.1.4

package/dist/serve/index.js

@@ -11,13 +11,63 @@ import { chmod, mkdir } from "fs/promises";
 import { dirname, resolve } from "path";
 
 // src/domain.ts
+import { z as z2 } from "zod";
+
+// src/model-policy-schema.ts
 import { z } from "zod";
-var VERSION = "0.1.2";
-var harnessSchema = z.enum(["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]);
-var protocolSchema = z.enum(["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]);
-var idSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
-var label = z.string().min(1).max(200);
-var envRef = z.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
+var policyModelIdSchema = z.string().min(1).max(300).regex(/^[^\u0000-\u001f\u007f]+$/);
+var modelPolicyRoleSchema = z.enum(["subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"]);
+var boundedModelList = z.array(policyModelIdSchema).max(500);
+var aliasSchema = z.string().regex(/^[A-Za-z0-9._/-]{1,120}$/).refine((v) => !["__proto__", "prototype", "constructor"].includes(v));
+var boundedModelMap = z.record(aliasSchema, policyModelIdSchema).superRefine((value, ctx) => {
+  if (Object.keys(value).length > 200)
+    ctx.addIssue({ code: "custom", message: "Model policy maps may contain at most 200 entries." });
+});
+var fallbacksSchema = z.record(policyModelIdSchema, z.array(policyModelIdSchema).max(20)).superRefine((value, ctx) => {
+  if (Object.keys(value).length > 200)
+    ctx.addIssue({ code: "custom", message: "Model policy fallback maps may contain at most 200 entries." });
+});
+var modelPolicySchema = z.object({
+  version: z.literal(1).default(1),
+  roles: z.object({
+    subagent: policyModelIdSchema.optional(),
+    fast: policyModelIdSchema.optional(),
+    planning: policyModelIdSchema.optional(),
+    review: policyModelIdSchema.optional(),
+    summary: policyModelIdSchema.optional(),
+    compaction: policyModelIdSchema.optional(),
+    weak: policyModelIdSchema.optional(),
+    editor: policyModelIdSchema.optional()
+  }).strict().optional(),
+  allowedModels: boundedModelList.optional(),
+  aliases: boundedModelMap.optional(),
+  fallbacks: fallbacksSchema.optional()
+}).strict();
+var routingDecisionSchema = z.enum(["allow", "alias", "reject", "fallback"]);
+var routingEventRoleSchema = z.enum(["main", ...modelPolicyRoleSchema.options]);
+var routingEventSchema = z.object({
+  at: z.string().datetime({ offset: true }),
+  requestId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/),
+  requestedModel: policyModelIdSchema,
+  resolvedModel: policyModelIdSchema.optional(),
+  reportedModel: policyModelIdSchema.optional(),
+  decision: routingDecisionSchema,
+  role: routingEventRoleSchema.optional(),
+  reason: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/).optional(),
+  upstreamStatus: z.number().int().min(100).max(599).optional()
+}).strict();
+var routingEventsSchema = z.array(routingEventSchema).max(1000);
+function canonicalPolicyJSON(value) {
+  return JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+}
+
+// src/domain.ts
+var VERSION = "0.1.4";
+var harnessSchema = z2.enum(["claude", "codex", "grok", "opencode", "opencode2", "pi", "omp", "dsh", "cline", "hermes", "prime-agent", "gemini", "aider", "kilo"]);
+var protocolSchema = z2.enum(["anthropic-messages", "openai-responses", "openai-chat", "gemini-generate-content"]);
+var idSchema = z2.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/);
+var label = z2.string().min(1).max(200);
+var envRef = z2.string().regex(/^SWITCHER_PROVIDER_[A-Z0-9_]+$/);
 function endpoint(value) {
   let url;
   try {
@@ -30,74 +80,79 @@ function endpoint(value) {
     throw new Fault(400, "invalid_url", "URL must use HTTPS, contain no credentials/query/fragment, or use HTTP on loopback.");
   return url.href.replace(/\/+$/, "");
 }
-var urlSchema = z.string().max(2000).superRefine((v, ctx) => {
+var urlSchema = z2.string().max(2000).superRefine((v, ctx) => {
   try {
     endpoint(v);
   } catch {
     ctx.addIssue({ code: "custom", message: "Invalid endpoint URL" });
   }
 }).transform(endpoint);
-var modelSchema = z.object({
-  id: z.string().min(1).max(300),
+var modelSchema = z2.object({
+  id: z2.string().min(1).max(300),
   name: label,
-  description: z.string().max(8000).optional(),
-  available: z.boolean().optional(),
-  contextWindow: z.number().int().positive().optional(),
-  maxOutputTokens: z.number().int().positive().optional(),
-  inputModalities: z.array(z.string().max(50)).max(20).optional(),
-  outputModalities: z.array(z.string().max(50)).max(20).optional(),
-  supportedParameters: z.array(z.string().max(100)).max(100).optional(),
-  supportedGenerationMethods: z.array(z.string().min(1).max(100)).max(100).optional()
+  description: z2.string().max(8000).optional(),
+  available: z2.boolean().optional(),
+  contextWindow: z2.number().int().positive().optional(),
+  maxOutputTokens: z2.number().int().positive().optional(),
+  inputModalities: z2.array(z2.string().max(50)).max(20).optional(),
+  outputModalities: z2.array(z2.string().max(50)).max(20).optional(),
+  supportedParameters: z2.array(z2.string().max(100)).max(100).optional(),
+  supportedGenerationMethods: z2.array(z2.string().min(1).max(100)).max(100).optional()
 }).strict();
-var providerInputSchema = z.object({
+var providerInputSchema = z2.object({
   id: idSchema,
   name: label,
   baseUrl: urlSchema,
   protocol: protocolSchema,
   credentialEnv: envRef.optional(),
-  authStyle: z.enum(["bearer", "x-api-key", "api-key"]).default("bearer"),
+  authStyle: z2.enum(["bearer", "x-api-key", "api-key"]).default("bearer"),
   catalogBaseUrl: urlSchema.optional(),
-  catalogFormat: z.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]).optional(),
-  catalogAuthStyle: z.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
+  catalogFormat: z2.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]).optional(),
+  catalogAuthStyle: z2.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
   catalogCredentialEnv: envRef.optional(),
-  catalogAccountId: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/).optional(),
-  modelsPath: z.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
-  manualModels: z.array(modelSchema).max(1e4).default([])
+  catalogAccountId: z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/).optional(),
+  modelsPath: z2.string().regex(/^[a-zA-Z0-9_/-]+$/).max(200).default("models"),
+  manualModels: z2.array(modelSchema).max(1e4).default([])
 }).strict().refine((p) => !p.modelsPath.split("/").includes("..") && !p.modelsPath.startsWith("/"), "modelsPath must be relative");
-var providerPresetSchema = z.object({
+var providerPresetSchema = z2.object({
   id: idSchema,
   name: label,
   credentialEnv: envRef.optional(),
-  credentialAliases: z.array(z.string().regex(/^[A-Z][A-Z0-9_]+$/)),
-  protocols: z.array(z.object({
+  credentialAliases: z2.array(z2.string().regex(/^[A-Z][A-Z0-9_]+$/)),
+  protocols: z2.array(z2.object({
     protocol: protocolSchema,
     baseUrl: urlSchema.optional(),
-    authStyle: z.enum(["bearer", "x-api-key", "api-key"]),
+    authStyle: z2.enum(["bearer", "x-api-key", "api-key"]),
     catalogBaseUrl: urlSchema.optional(),
-    catalogFormat: z.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]),
-    catalogAuthStyle: z.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
-    modelsPath: z.string(),
-    notes: z.array(z.string())
+    catalogFormat: z2.enum(["openai", "ollama", "mistral", "together", "fireworks", "dashscope", "gemini", "none"]),
+    catalogAuthStyle: z2.enum(["bearer", "x-api-key", "api-key", "none"]).optional(),
+    modelsPath: z2.string(),
+    notes: z2.array(z2.string())
   }).strict()).min(1),
-  sources: z.array(z.string().url()),
-  verification: z.literal("documented")
+  sources: z2.array(z2.string().url()),
+  verification: z2.literal("documented")
 }).strict();
-var profileInputSchema = z.object({
+var profileInputSchema = z2.object({
   id: idSchema,
   name: label,
   providerId: idSchema,
   harness: harnessSchema,
-  model: z.string().min(1).max(300)
+  model: z2.string().min(1).max(300),
+  modelPolicy: modelPolicySchema.optional()
 }).strict();
-var runInputSchema = z.object({
+var runInputSchema = z2.object({
+  modelPolicyVersion: z2.literal(1),
   profileId: idSchema,
   harness: harnessSchema,
-  model: z.string().min(1).max(300),
-  planToken: z.string().regex(/^[a-f0-9]{64}$/)
+  model: z2.string().min(1).max(300),
+  modelPolicy: modelPolicySchema.optional(),
+  planToken: z2.string().regex(/^[a-f0-9]{64}$/)
 }).strict();
-var runUpdateSchema = z.object({
-  status: z.enum(["exited", "failed", "interrupted"]),
-  exitCode: z.number().int().min(0).max(255)
+var runUpdateSchema = z2.object({
+  status: z2.enum(["exited", "failed", "interrupted"]),
+  exitCode: z2.number().int().min(0).max(255),
+  routingEvents: routingEventsSchema.optional(),
+  routingEventsDropped: z2.number().int().min(0).max(1e6).optional()
 }).strict();
 
 class Fault extends Error {
@@ -298,8 +353,8 @@ class Store {
 }
 
 // src/service.ts
-import { createHash, timingSafeEqual } from "crypto";
-import { z as z2 } from "zod";
+import { createHash as createHash2, timingSafeEqual } from "crypto";
+import { z as z3 } from "zod";
 
 // src/http.ts
 var MAX_BYTES = 16 * 1024 * 1024;
@@ -595,6 +650,69 @@ async function discover(provider, env = process.env, resolveCredential) {
   throw new Fault(502, "catalog_too_large", "Provider catalog pagination exceeded 100 pages.");
 }
 
+// src/model-policy.ts
+import { createHash } from "crypto";
+var roles = ["subagent", "fast", "planning", "review", "summary", "compaction", "weak", "editor"];
+var id = (v, label2) => {
+  if (typeof v !== "string" || !v || v.length > 300 || /[\u0000-\u001f\u007f]/.test(v))
+    throw new Fault(400, "invalid_model_policy", `${label2} is invalid.`);
+  return v;
+};
+var uniq = (xs) => [...new Set(xs)];
+function stable(value) {
+  return JSON.stringify(value, (_k, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a.localeCompare(b))) : v);
+}
+function compileModelPolicy(model, catalog, policy) {
+  const selected = id(model, "model");
+  const available = new Set(catalog.filter((m) => m.available !== false).map((m) => m.id));
+  if (!available.has(selected))
+    throw new Fault(422, "model_unavailable", "Selected model is not present in the eligible catalog.");
+  if (policy && policy.version !== undefined && policy.version !== 1)
+    throw new Fault(400, "invalid_model_policy", "Unsupported model policy version.");
+  const p = parse(modelPolicySchema, policy ?? {});
+  const roleInput = p.roles ?? {};
+  if (Object.keys(roleInput).some((k) => !roles.includes(k)))
+    throw new Fault(400, "invalid_model_policy", "Unknown model policy role.");
+  const compiledRoles = Object.fromEntries(roles.map((role) => [role, id(roleInput[role] ?? selected, `roles.${role}`)]));
+  for (const value of Object.values(compiledRoles))
+    if (!available.has(value))
+      throw new Fault(422, "model_unavailable", "A model policy role is not present in the eligible catalog.");
+  const explicitAllowed = (p.allowedModels ?? []).map((v, i) => id(v, `allowedModels[${i}]`));
+  if (explicitAllowed.length > 500)
+    throw new Fault(400, "invalid_model_policy", "Model policy allowedModels is too large.");
+  for (const value of explicitAllowed)
+    if (!available.has(value))
+      throw new Fault(422, "model_unavailable", "An allowed model is not present in the eligible catalog.");
+  const aliases = Object.create(null);
+  for (const [name, target] of Object.entries(p.aliases ?? {})) {
+    if (Object.keys(aliases).length >= 200 || !/^[A-Za-z0-9._/-]{1,120}$/.test(name) || ["__proto__", "prototype", "constructor"].includes(name))
+      throw new Fault(400, "invalid_model_policy", "A model alias is invalid or too numerous.");
+    const canonical = id(target, `aliases.${name}`);
+    if (available.has(name) && name !== canonical)
+      throw new Fault(400, "invalid_model_policy", "A model alias cannot shadow a real model ID.");
+    if (!available.has(canonical))
+      throw new Fault(422, "model_unavailable", "A model alias target is not present in the eligible catalog.");
+    aliases[name] = canonical;
+  }
+  const fallbacks = Object.create(null);
+  const allowedSources = new Set([selected, ...Object.values(compiledRoles), ...explicitAllowed]);
+  for (const [source, targets] of Object.entries(p.fallbacks ?? {})) {
+    if (!allowedSources.has(source) || !available.has(source) || !Array.isArray(targets) || Object.keys(fallbacks).length >= 200 || targets.length > 20)
+      throw new Fault(400, "invalid_model_policy", "Fallback source or list is invalid.");
+    const values = targets.map((v, i) => id(v, `fallbacks.${source}[${i}]`));
+    if (values.some((v) => !available.has(v)))
+      throw new Fault(422, "model_unavailable", "A fallback model is not present in the eligible catalog.");
+    if (values.includes(source))
+      throw new Fault(400, "invalid_model_policy", "A model cannot fall back to itself.");
+    fallbacks[source] = uniq(values);
+  }
+  const allowedModels = uniq([selected, ...Object.values(compiledRoles), ...explicitAllowed, ...Object.values(fallbacks).flat()]).sort();
+  if (Object.values(aliases).some((value) => !allowedModels.includes(value)))
+    throw new Fault(422, "model_not_allowed", "A model alias target must be explicitly allowed by the launch policy.");
+  const result = { version: 1, model: selected, roles: compiledRoles, allowedModels, aliases, fallbacks };
+  return { ...result, digest: createHash("sha256").update(stable(result)).digest("hex") };
+}
+
 // src/presets.ts
 var route = (protocol, baseUrl, options = {}) => ({
   protocol,
@@ -605,13 +723,13 @@ var route = (protocol, baseUrl, options = {}) => ({
   notes: [],
   ...options
 });
-var preset = (id, name, protocols, sources, alias) => parse(providerPresetSchema, {
-  id,
+var preset = (id2, name, protocols, sources, alias) => parse(providerPresetSchema, {
+  id: id2,
   name,
   protocols,
   sources,
   credentialAliases: alias ? [alias] : [],
-  credentialEnv: alias ? `SWITCHER_PROVIDER_${id.toUpperCase().replace(/-/g, "_")}` : undefined,
+  credentialEnv: alias ? `SWITCHER_PROVIDER_${id2.toUpperCase().replace(/-/g, "_")}` : undefined,
   verification: "documented"
 });
 var providerPresets = [
@@ -679,8 +797,8 @@ var providerPresets = [
   preset("siliconflow", "SiliconFlow", [route("openai-chat", "https://api.siliconflow.cn/v1", { catalogBaseUrl: "https://api.siliconflow.cn/v1", catalogFormat: "openai", notes: ["The official SiliconCloud OpenAPI contract defines GET /models with Bearer auth and data[] model rows; optional type and sub_type filters are available at the upstream endpoint."] })], ["https://github.com/siliconflow/siliconcloud/blob/main/openapi.yaml", "https://docs.siliconflow.cn/docs/userguide/quickstart", "https://docs.siliconflow.cn/docs/api/chat-completions-post"], "SILICONFLOW_API_KEY"),
   ...["anthropic-messages", "openai-responses", "openai-chat"].map((protocol) => preset(`generic-${protocol}`, `Custom ${protocol}`, [route(protocol)], []))
 ];
-function getProviderPreset(id) {
-  const entry = providerPresets.find((p) => p.id === id);
+function getProviderPreset(id2) {
+  const entry = providerPresets.find((p) => p.id === id2);
   if (!entry)
     throw new Fault(404, "preset_not_found", "Unknown provider preset. Use switcher providers presets to list available presets.");
   return structuredClone(entry);
@@ -690,7 +808,7 @@ var openapi_default = {
   openapi: "3.0.3",
   info: {
     title: "Switcher API",
-    version: "0.1.2",
+    version: "0.1.4",
     description: "Authenticated provider/profile/catalog control plane. Launches run locally; the API never returns provider credentials."
   },
   security: [
@@ -2364,6 +2482,105 @@ var openapi_default = {
             type: "string",
             minLength: 1,
             maxLength: 300
+          },
+          modelPolicy: {
+            type: "object",
+            properties: {
+              version: {
+                type: "number",
+                enum: [
+                  1
+                ],
+                default: 1
+              },
+              roles: {
+                type: "object",
+                properties: {
+                  subagent: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  fast: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  planning: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  review: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  summary: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  compaction: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  weak: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  editor: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  }
+                },
+                additionalProperties: false
+              },
+              allowedModels: {
+                type: "array",
+                items: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                maxItems: 500
+              },
+              aliases: {
+                type: "object",
+                additionalProperties: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                }
+              },
+              fallbacks: {
+                type: "object",
+                additionalProperties: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  maxItems: 20
+                }
+              }
+            },
+            additionalProperties: false
           }
         },
         required: [
@@ -2415,6 +2632,105 @@ var openapi_default = {
             minLength: 1,
             maxLength: 300
           },
+          modelPolicy: {
+            type: "object",
+            properties: {
+              version: {
+                type: "number",
+                enum: [
+                  1
+                ],
+                default: 1
+              },
+              roles: {
+                type: "object",
+                properties: {
+                  subagent: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  fast: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  planning: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  review: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  summary: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  compaction: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  weak: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  editor: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  }
+                },
+                additionalProperties: false
+              },
+              allowedModels: {
+                type: "array",
+                items: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                maxItems: 500
+              },
+              aliases: {
+                type: "object",
+                additionalProperties: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                }
+              },
+              fallbacks: {
+                type: "object",
+                additionalProperties: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  maxItems: 20
+                }
+              }
+            },
+            additionalProperties: false
+          },
           version: {
             type: "integer",
             exclusiveMinimum: true,
@@ -2505,6 +2821,175 @@ var openapi_default = {
         ],
         additionalProperties: false
       },
+      ModelPolicy: {
+        type: "object",
+        properties: {
+          version: {
+            type: "number",
+            enum: [
+              1
+            ],
+            default: 1
+          },
+          roles: {
+            type: "object",
+            properties: {
+              subagent: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              fast: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              planning: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              review: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              summary: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              compaction: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              weak: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              editor: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              }
+            },
+            additionalProperties: false
+          },
+          allowedModels: {
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1,
+              maxLength: 300,
+              pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+            },
+            maxItems: 500
+          },
+          aliases: {
+            type: "object",
+            additionalProperties: {
+              type: "string",
+              minLength: 1,
+              maxLength: 300,
+              pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+            }
+          },
+          fallbacks: {
+            type: "object",
+            additionalProperties: {
+              type: "array",
+              items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 300,
+                pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+              },
+              maxItems: 20
+            }
+          }
+        },
+        additionalProperties: false
+      },
+      RoutingEvent: {
+        type: "object",
+        properties: {
+          at: {
+            type: "string",
+            format: "date-time"
+          },
+          requestId: {
+            type: "string",
+            pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+          },
+          requestedModel: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300,
+            pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+          },
+          resolvedModel: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300,
+            pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+          },
+          reportedModel: {
+            type: "string",
+            minLength: 1,
+            maxLength: 300,
+            pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+          },
+          decision: {
+            type: "string",
+            enum: [
+              "allow",
+              "alias",
+              "reject",
+              "fallback"
+            ]
+          },
+          role: {
+            type: "string",
+            enum: [
+              "main",
+              "subagent",
+              "fast",
+              "planning",
+              "review",
+              "summary",
+              "compaction",
+              "weak",
+              "editor"
+            ]
+          },
+          reason: {
+            type: "string",
+            pattern: "^[a-z][a-z0-9_]{0,63}$"
+          },
+          upstreamStatus: {
+            type: "integer",
+            minimum: 100,
+            maximum: 599
+          }
+        },
+        required: [
+          "at",
+          "requestId",
+          "requestedModel",
+          "decision"
+        ],
+        additionalProperties: false
+      },
       ModelPage: {
         type: "object",
         properties: {
@@ -2924,6 +3409,105 @@ var openapi_default = {
                 minLength: 1,
                 maxLength: 300
               },
+              modelPolicy: {
+                type: "object",
+                properties: {
+                  version: {
+                    type: "number",
+                    enum: [
+                      1
+                    ],
+                    default: 1
+                  },
+                  roles: {
+                    type: "object",
+                    properties: {
+                      subagent: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      fast: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      planning: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      review: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      summary: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      compaction: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      weak: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      editor: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      }
+                    },
+                    additionalProperties: false
+                  },
+                  allowedModels: {
+                    type: "array",
+                    items: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 300,
+                      pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                    },
+                    maxItems: 500
+                  },
+                  aliases: {
+                    type: "object",
+                    additionalProperties: {
+                      type: "string",
+                      minLength: 1,
+                      maxLength: 300,
+                      pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                    }
+                  },
+                  fallbacks: {
+                    type: "object",
+                    additionalProperties: {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 300,
+                        pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                      },
+                      maxItems: 20
+                    }
+                  }
+                },
+                additionalProperties: false
+              },
               version: {
                 type: "integer",
                 exclusiveMinimum: true,
@@ -3060,6 +3644,12 @@ var openapi_default = {
       RunInput: {
         type: "object",
         properties: {
+          modelPolicyVersion: {
+            type: "number",
+            enum: [
+              1
+            ]
+          },
           profileId: {
             type: "string",
             pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
@@ -3088,12 +3678,112 @@ var openapi_default = {
             minLength: 1,
             maxLength: 300
           },
+          modelPolicy: {
+            type: "object",
+            properties: {
+              version: {
+                type: "number",
+                enum: [
+                  1
+                ],
+                default: 1
+              },
+              roles: {
+                type: "object",
+                properties: {
+                  subagent: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  fast: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  planning: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  review: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  summary: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  compaction: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  weak: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  editor: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  }
+                },
+                additionalProperties: false
+              },
+              allowedModels: {
+                type: "array",
+                items: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                maxItems: 500
+              },
+              aliases: {
+                type: "object",
+                additionalProperties: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                }
+              },
+              fallbacks: {
+                type: "object",
+                additionalProperties: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  maxItems: 20
+                }
+              }
+            },
+            additionalProperties: false
+          },
           planToken: {
             type: "string",
             pattern: "^[a-f0-9]{64}$"
           }
         },
         required: [
+          "modelPolicyVersion",
           "profileId",
           "harness",
           "model",
@@ -3116,6 +3806,85 @@ var openapi_default = {
             type: "integer",
             minimum: 0,
             maximum: 255
+          },
+          routingEvents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                at: {
+                  type: "string",
+                  format: "date-time"
+                },
+                requestId: {
+                  type: "string",
+                  pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+                },
+                requestedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                resolvedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                reportedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                decision: {
+                  type: "string",
+                  enum: [
+                    "allow",
+                    "alias",
+                    "reject",
+                    "fallback"
+                  ]
+                },
+                role: {
+                  type: "string",
+                  enum: [
+                    "main",
+                    "subagent",
+                    "fast",
+                    "planning",
+                    "review",
+                    "summary",
+                    "compaction",
+                    "weak",
+                    "editor"
+                  ]
+                },
+                reason: {
+                  type: "string",
+                  pattern: "^[a-z][a-z0-9_]{0,63}$"
+                },
+                upstreamStatus: {
+                  type: "integer",
+                  minimum: 100,
+                  maximum: 599
+                }
+              },
+              required: [
+                "at",
+                "requestId",
+                "requestedModel",
+                "decision"
+              ],
+              additionalProperties: false
+            },
+            maxItems: 1000
+          },
+          routingEventsDropped: {
+            type: "integer",
+            minimum: 0,
+            maximum: 1e6
           }
         },
         required: [
@@ -3127,6 +3896,12 @@ var openapi_default = {
       Run: {
         type: "object",
         properties: {
+          modelPolicyVersion: {
+            type: "number",
+            enum: [
+              1
+            ]
+          },
           profileId: {
             type: "string",
             pattern: "^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$"
@@ -3155,6 +3930,105 @@ var openapi_default = {
             minLength: 1,
             maxLength: 300
           },
+          modelPolicy: {
+            type: "object",
+            properties: {
+              version: {
+                type: "number",
+                enum: [
+                  1
+                ],
+                default: 1
+              },
+              roles: {
+                type: "object",
+                properties: {
+                  subagent: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  fast: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  planning: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  review: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  summary: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  compaction: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  weak: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  editor: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  }
+                },
+                additionalProperties: false
+              },
+              allowedModels: {
+                type: "array",
+                items: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                maxItems: 500
+              },
+              aliases: {
+                type: "object",
+                additionalProperties: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                }
+              },
+              fallbacks: {
+                type: "object",
+                additionalProperties: {
+                  type: "array",
+                  items: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 300,
+                    pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                  },
+                  maxItems: 20
+                }
+              }
+            },
+            additionalProperties: false
+          },
           planToken: {
             type: "string",
             pattern: "^[a-f0-9]{64}$"
@@ -3202,6 +4076,85 @@ var openapi_default = {
           },
           exitCode: {
             type: "integer"
+          },
+          routingEvents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                at: {
+                  type: "string",
+                  format: "date-time"
+                },
+                requestId: {
+                  type: "string",
+                  pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$"
+                },
+                requestedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                resolvedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                reportedModel: {
+                  type: "string",
+                  minLength: 1,
+                  maxLength: 300,
+                  pattern: "^[^\\u0000-\\u001f\\u007f]+$"
+                },
+                decision: {
+                  type: "string",
+                  enum: [
+                    "allow",
+                    "alias",
+                    "reject",
+                    "fallback"
+                  ]
+                },
+                role: {
+                  type: "string",
+                  enum: [
+                    "main",
+                    "subagent",
+                    "fast",
+                    "planning",
+                    "review",
+                    "summary",
+                    "compaction",
+                    "weak",
+                    "editor"
+                  ]
+                },
+                reason: {
+                  type: "string",
+                  pattern: "^[a-z][a-z0-9_]{0,63}$"
+                },
+                upstreamStatus: {
+                  type: "integer",
+                  minimum: 100,
+                  maximum: 599
+                }
+              },
+              required: [
+                "at",
+                "requestId",
+                "requestedModel",
+                "decision"
+              ],
+              additionalProperties: false
+            },
+            maxItems: 1000
+          },
+          routingEventsDropped: {
+            type: "integer",
+            minimum: 0,
+            maximum: 1e6
           }
         },
         required: [
@@ -3328,8 +4281,8 @@ var openapi_default = {
 };
 
 // src/service.ts
-var snapshot = (profile, provider, catalog) => createHash("sha256").update(JSON.stringify([profile, provider, { models: catalog.models, source: catalog.source }])).digest("hex");
-var hash = (s) => createHash("sha256").update(s).digest();
+var snapshot = (profile, provider, catalog) => createHash2("sha256").update(JSON.stringify([profile, provider, { models: catalog.models, source: catalog.source }])).digest("hex");
+var hash = (s) => createHash2("sha256").update(s).digest();
 function createHandler(store, apiKey, providerEnv = process.env, resolveCredential) {
   if (!apiKey || apiKey.length < 24)
     throw new Fault(500, "auth_config", "Set HASNA_SWITCHER_API_KEY to a random token of at least 24 characters.");
@@ -3360,23 +4313,23 @@ function createHandler(store, apiKey, providerEnv = process.env, resolveCredenti
       if (parts[0] !== "v1")
         throw new Fault(404, "not_found", "Route was not found.");
       const resource = parts[1];
-      const id = parts[2];
-      if (id)
-        parse(idSchema, id);
-      const page = () => parse(z2.object({
-        limit: z2.coerce.number().int().min(1).max(1000).default(100),
-        offset: z2.coerce.number().int().min(0).max(1e6).default(0),
-        search: z2.string().max(200).default("")
+      const id2 = parts[2];
+      if (id2)
+        parse(idSchema, id2);
+      const page = () => parse(z3.object({
+        limit: z3.coerce.number().int().min(1).max(1000).default(100),
+        offset: z3.coerce.number().int().min(0).max(1e6).default(0),
+        search: z3.string().max(200).default("")
       }).strict(), Object.fromEntries(url.searchParams));
       if (request.method === "GET") {
         if (resource === "provider-presets" && parts.length <= 3)
-          return json(id ? getProviderPreset(id) : { data: providerPresets });
+          return json(id2 ? getProviderPreset(id2) : { data: providerPresets });
         if (["providers", "profiles", "runs"].includes(resource) && parts.length <= 3) {
           const kind = resource;
-          return json(id ? await store.get(kind, id) : await store.list(kind, page()));
+          return json(id2 ? await store.get(kind, id2) : await store.list(kind, page()));
         }
-        if (resource === "providers" && id && parts[3] === "models" && parts.length === 4) {
-          const catalog = await store.get("catalogs", id);
+        if (resource === "providers" && id2 && parts[3] === "models" && parts.length === 4) {
+          const catalog = await store.get("catalogs", id2);
           const p = page();
           const filtered = catalog.models.filter((m) => [m.id, m.name].some((s) => s.toLowerCase().includes(p.search.toLowerCase())));
           return json({ ...catalog, models: undefined, data: filtered.slice(p.offset, p.offset + p.limit).map((m) => ({ ...m, codingEligible: codingEligible(m) })), total: filtered.length, ...p });
@@ -3407,50 +4360,50 @@ function createHandler(store, apiKey, providerEnv = process.env, resolveCredenti
       };
       const replay = await store.replay(key, fingerprint);
       if (replay.found)
-        return json(replay.value, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id ? 201 : 200);
+        return json(replay.value, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id2 ? 201 : 200);
       let refreshed;
-      if (resource === "providers" && id && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
-        parse(z2.object({}).strict(), body);
-        const provider = await store.get("providers", id);
+      if (resource === "providers" && id2 && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
+        parse(z3.object({}).strict(), body);
+        const provider = await store.get("providers", id2);
         refreshed = { provider, catalog: await discover(provider, providerEnv, resolveCredential) };
       }
       const result = await store.mutate(key, fingerprint, async (db) => {
         if ((resource === "providers" || resource === "profiles") && parts.length <= 3) {
-          if (request.method === "DELETE" && id)
-            return store.remove(resource, id, version(), db);
-          if (request.method === "POST" && !id || request.method === "PUT" && id) {
+          if (request.method === "DELETE" && id2)
+            return store.remove(resource, id2, version(), db);
+          if (request.method === "POST" && !id2 || request.method === "PUT" && id2) {
             const value = resource === "providers" ? parse(providerInputSchema, body) : parse(profileInputSchema, body);
-            if (id && value.id !== id)
+            if (id2 && value.id !== id2)
               throw new Fault(400, "id_mismatch", "Path and body IDs must match.");
             if (resource === "profiles") {
               const profile = value;
               const provider = await store.get("providers", profile.providerId, db);
               validateHarnessProvider(profile.harness, provider);
             }
-            const saved = await store.put(resource, value, id ? version() : undefined, db);
-            if (resource === "providers" && id)
-              await db.unsafe("DELETE FROM switcher_catalogs WHERE id = $1", [id]);
+            const saved = await store.put(resource, value, id2 ? version() : undefined, db);
+            if (resource === "providers" && id2)
+              await db.unsafe("DELETE FROM switcher_catalogs WHERE id = $1", [id2]);
             return saved;
           }
         }
-        if (resource === "providers" && id && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
+        if (resource === "providers" && id2 && parts[3] === "refresh" && parts.length === 4 && request.method === "POST") {
           if (store.engine === "postgresql")
-            await db.unsafe("SELECT id FROM switcher_providers WHERE id = $1 FOR SHARE", [id]);
-          const provider = await store.get("providers", id, db);
+            await db.unsafe("SELECT id FROM switcher_providers WHERE id = $1 FOR SHARE", [id2]);
+          const provider = await store.get("providers", id2, db);
           if (!refreshed || provider.version !== refreshed.provider.version)
             throw new Fault(409, "provider_changed", "Provider changed during discovery; refresh again.");
           const catalog = refreshed.catalog;
           let old;
           try {
-            old = await store.get("catalogs", id, db);
+            old = await store.get("catalogs", id2, db);
           } catch (e) {
             if (!(e instanceof Fault && e.status === 404))
               throw e;
           }
-          return store.put("catalogs", { id, ...catalog }, old?.version, db);
+          return store.put("catalogs", { id: id2, ...catalog }, old?.version, db);
         }
-        if (resource === "launch-plans" && !id && request.method === "POST") {
-          const { profileId } = parse(z2.object({ profileId: idSchema }).strict(), body);
+        if (resource === "launch-plans" && !id2 && request.method === "POST") {
+          const { profileId } = parse(z3.object({ profileId: idSchema }).strict(), body);
           const profile = await store.get("profiles", profileId, db);
           const provider = await store.get("providers", profile.providerId, db);
           validateHarnessProvider(profile.harness, provider);
@@ -3467,6 +4420,7 @@ function createHandler(store, apiKey, providerEnv = process.env, resolveCredenti
             throw new Fault(422, "model_missing", "Selected model is not in the provider catalog.");
           if (!harnessEligible(selected, profile.harness))
             throw new Fault(422, "model_ineligible", "Selected model is unavailable or explicitly lacks a required generation method, text output or tool support.");
+          compileModelPolicy(profile.model, catalog.models.filter((model) => harnessEligible(model, profile.harness)), profile.modelPolicy);
           const warnings = [];
           if (profile.harness !== "aider" && !selected.supportedParameters)
             warnings.push("Provider does not declare tool capabilities; execution compatibility is unverified.");
@@ -3476,7 +4430,9 @@ function createHandler(store, apiKey, providerEnv = process.env, resolveCredenti
             warnings.push("Catalog snapshot is older than five minutes; refresh before launching.");
           return { profile, provider, catalog, warnings, planToken: snapshot(profile, provider, catalog) };
         }
-        if (resource === "runs" && !id && request.method === "POST") {
+        if (resource === "runs" && !id2 && request.method === "POST") {
+          if (body?.modelPolicyVersion !== 1)
+            throw new Fault(409, "launcher_upgrade_required", "This API requires a launcher with automatic model policy version 1; upgrade the Switcher CLI/SDK.");
           const input = parse(runInputSchema, body);
           if (store.engine === "postgresql")
             await db.unsafe("SELECT id FROM switcher_profiles WHERE id = $1 FOR SHARE", [input.profileId]);
@@ -3494,20 +4450,20 @@ function createHandler(store, apiKey, providerEnv = process.env, resolveCredenti
               throw new Fault(409, "plan_changed", "Catalog changed; request a fresh launch plan.");
             throw error;
           }
-          if (profile.harness !== input.harness || profile.model !== input.model || snapshot(profile, provider, catalog) !== input.planToken)
-            throw new Fault(409, "plan_changed", "Provider, profile or catalog changed; request a fresh launch plan.");
-          return store.put("runs", { ...input, providerId: provider.id, providerVersion: provider.version, profileVersion: profile.version, id: crypto.randomUUID(), status: "running", startedAt: new Date().toISOString() }, undefined, db);
+          if (profile.harness !== input.harness || profile.model !== input.model || canonicalPolicyJSON(profile.modelPolicy ?? null) !== canonicalPolicyJSON(input.modelPolicy ?? profile.modelPolicy ?? null) || snapshot(profile, provider, catalog) !== input.planToken)
+            throw new Fault(409, "plan_changed", "Provider, profile, model policy or catalog changed; request a fresh launch plan.");
+          return store.put("runs", { ...input, modelPolicy: profile.modelPolicy, providerId: provider.id, providerVersion: provider.version, profileVersion: profile.version, id: crypto.randomUUID(), status: "running", startedAt: new Date().toISOString() }, undefined, db);
         }
-        if (resource === "runs" && id && request.method === "PATCH" && parts.length === 3) {
+        if (resource === "runs" && id2 && request.method === "PATCH" && parts.length === 3) {
           const input = parse(runUpdateSchema, body);
-          const run = await store.get("runs", id, db);
+          const run = await store.get("runs", id2, db);
           if (run.status !== "running")
             throw new Fault(409, "run_finished", "Run has already finished.");
           return store.put("runs", { ...run, ...input, endedAt: new Date().toISOString() }, version(), db);
         }
         throw new Fault(404, "not_found", "Route was not found.");
       });
-      return json(result, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id ? 201 : 200);
+      return json(result, request.method === "POST" && ["providers", "profiles", "runs"].includes(resource) && !id2 ? 201 : 200);
     } catch (error) {
       const safe = error instanceof Fault ? error : new Fault(500, "internal_error", "Request failed.");
       return json({ error: { code: safe.code, message: safe.message, requestId } }, safe.status);