oh-my-opencode 4.19.4 → 5.0.0-beta.10

package/dist/tui.js

@@ -15197,7 +15197,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -15458,7 +15458,7 @@ var formatMap, stringProcessor = (schema, ctx, _json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -18836,6 +18836,155 @@ var init_codegraph = __esm(() => {
   }).strict();
 });
 
+// packages/omo-config-core/src/schema/memory.ts
+var OmoMemoryReflectionTriggerSchema, OmoMemoryReflectionSchema, OmoMemorySyncSchema, OmoMemorySearchSchema, OmoMemoryNudgeSchema, OmoMemoryFactsSchema, OmoMemoryDreamSchema, OmoMemoryPeopleSchema, OmoMemorySoulSchema, OmoMemoryReflectionTriggerLayerSchema, OmoMemoryReflectionLayerSchema, OmoMemorySyncLayerSchema, OmoMemorySearchLayerSchema, OmoMemoryNudgeLayerSchema, OmoMemoryFactsLayerSchema, OmoMemoryDreamLayerSchema, OmoMemoryPeopleLayerSchema, OmoMemorySoulLayerSchema, OmoMemoryAgentOverridesSchema, OmoMemorySettingsSchema, OmoMemorySettingsLayerSchema;
+var init_memory = __esm(() => {
+  init_zod();
+  OmoMemoryReflectionTriggerSchema = object({
+    step_count: number2().int().nonnegative().default(25),
+    on_compaction: boolean2().default(true)
+  }).strict();
+  OmoMemoryReflectionSchema = object({
+    enabled: boolean2().default(true),
+    trigger: OmoMemoryReflectionTriggerSchema.default({ step_count: 25, on_compaction: true }),
+    merge: _enum2(["auto", "integration"]).default("auto"),
+    category: string2().min(1).default("quick"),
+    timeout_minutes: number2().int().positive().default(15),
+    sandbox: _enum2(["auto", "required", "off"]).default("auto")
+  }).strict();
+  OmoMemorySyncSchema = object({
+    remote: string2().min(1).optional(),
+    enabled: boolean2().default(true)
+  }).strict();
+  OmoMemorySearchSchema = object({
+    enabled: boolean2().default(true)
+  }).strict();
+  OmoMemoryNudgeSchema = object({
+    enabled: boolean2().default(true),
+    every_user_turns: number2().int().min(1).default(10)
+  }).strict();
+  OmoMemoryFactsSchema = object({
+    enabled: boolean2().default(true),
+    debounce_settles: number2().int().min(1).default(4)
+  }).strict();
+  OmoMemoryDreamSchema = object({
+    enabled: boolean2().default(true),
+    idle_minutes: number2().int().min(0).default(30),
+    min_hours_between: number2().int().min(1).default(24),
+    shutdown_launch: boolean2().default(true),
+    auto_select_max: number2().int().min(1).max(10).default(5),
+    auto_select_max_chars: number2().int().min(1e4).default(150000)
+  }).strict();
+  OmoMemoryPeopleSchema = object({
+    enabled: boolean2().default(true),
+    max_entries: number2().int().min(1).max(100).default(40),
+    max_entry_chars: number2().int().min(50).max(500).default(200)
+  }).strict();
+  OmoMemorySoulSchema = object({
+    edit_notice: boolean2().default(true)
+  }).strict();
+  OmoMemoryReflectionTriggerLayerSchema = object({
+    step_count: number2().int().nonnegative().optional(),
+    on_compaction: boolean2().optional()
+  }).strict();
+  OmoMemoryReflectionLayerSchema = object({
+    enabled: boolean2().optional(),
+    trigger: OmoMemoryReflectionTriggerLayerSchema.optional(),
+    merge: _enum2(["auto", "integration"]).optional(),
+    category: string2().min(1).optional(),
+    timeout_minutes: number2().int().positive().optional(),
+    sandbox: _enum2(["auto", "required", "off"]).optional()
+  }).strict();
+  OmoMemorySyncLayerSchema = object({
+    remote: string2().min(1).optional(),
+    enabled: boolean2().optional()
+  }).strict();
+  OmoMemorySearchLayerSchema = object({
+    enabled: boolean2().optional()
+  }).strict();
+  OmoMemoryNudgeLayerSchema = object({
+    enabled: boolean2().optional(),
+    every_user_turns: number2().int().min(1).optional()
+  }).strict();
+  OmoMemoryFactsLayerSchema = object({
+    enabled: boolean2().optional(),
+    debounce_settles: number2().int().min(1).optional()
+  }).strict();
+  OmoMemoryDreamLayerSchema = object({
+    enabled: boolean2().optional(),
+    idle_minutes: number2().int().min(0).optional(),
+    min_hours_between: number2().int().min(1).optional(),
+    shutdown_launch: boolean2().optional(),
+    auto_select_max: number2().int().min(1).max(10).optional(),
+    auto_select_max_chars: number2().int().min(1e4).optional()
+  }).strict();
+  OmoMemoryPeopleLayerSchema = object({
+    enabled: boolean2().optional(),
+    max_entries: number2().int().min(1).max(100).optional(),
+    max_entry_chars: number2().int().min(50).max(500).optional()
+  }).strict();
+  OmoMemorySoulLayerSchema = object({
+    edit_notice: boolean2().optional()
+  }).strict();
+  OmoMemoryAgentOverridesSchema = object({
+    enabled: boolean2().optional(),
+    agent: string2().min(1).optional(),
+    reflection: OmoMemoryReflectionLayerSchema.optional(),
+    nudge: OmoMemoryNudgeLayerSchema.optional(),
+    facts: OmoMemoryFactsLayerSchema.optional(),
+    dream: OmoMemoryDreamLayerSchema.optional(),
+    people: OmoMemoryPeopleLayerSchema.optional(),
+    soul: OmoMemorySoulLayerSchema.optional(),
+    sync: OmoMemorySyncLayerSchema.optional(),
+    search: OmoMemorySearchLayerSchema.optional(),
+    compile_warn_tokens: number2().int().positive().optional()
+  }).strict();
+  OmoMemorySettingsSchema = object({
+    enabled: boolean2().default(true),
+    agent: string2().min(1).default("auto"),
+    tool_exposure: _enum2(["direct", "search"]).default("direct"),
+    reflection: OmoMemoryReflectionSchema.default({
+      enabled: true,
+      trigger: { step_count: 25, on_compaction: true },
+      merge: "auto",
+      category: "quick",
+      timeout_minutes: 15,
+      sandbox: "auto"
+    }),
+    nudge: OmoMemoryNudgeSchema.default({ enabled: true, every_user_turns: 10 }),
+    facts: OmoMemoryFactsSchema.default({ enabled: true, debounce_settles: 4 }),
+    dream: OmoMemoryDreamSchema.default({
+      enabled: true,
+      idle_minutes: 30,
+      min_hours_between: 24,
+      shutdown_launch: true,
+      auto_select_max: 5,
+      auto_select_max_chars: 150000
+    }),
+    people: OmoMemoryPeopleSchema.default({ enabled: true, max_entries: 40, max_entry_chars: 200 }),
+    soul: OmoMemorySoulSchema.default({ edit_notice: true }),
+    sync: OmoMemorySyncSchema.default({ enabled: true }),
+    search: OmoMemorySearchSchema.default({ enabled: true }),
+    compile_warn_tokens: number2().int().positive().default(30000),
+    agents: record(string2(), OmoMemoryAgentOverridesSchema).default({})
+  }).strict();
+  OmoMemorySettingsLayerSchema = object({
+    enabled: boolean2().optional(),
+    agent: string2().min(1).optional(),
+    tool_exposure: _enum2(["direct", "search"]).optional(),
+    reflection: OmoMemoryReflectionLayerSchema.optional(),
+    nudge: OmoMemoryNudgeLayerSchema.optional(),
+    facts: OmoMemoryFactsLayerSchema.optional(),
+    dream: OmoMemoryDreamLayerSchema.optional(),
+    people: OmoMemoryPeopleLayerSchema.optional(),
+    soul: OmoMemorySoulLayerSchema.optional(),
+    sync: OmoMemorySyncLayerSchema.optional(),
+    search: OmoMemorySearchLayerSchema.optional(),
+    compile_warn_tokens: number2().int().positive().optional(),
+    agents: record(string2(), OmoMemoryAgentOverridesSchema).optional()
+  }).strict();
+});
+
 // packages/omo-config-core/src/schema/model-catalog.ts
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -18859,9 +19008,18 @@ var init_model_catalog = __esm(() => {
 });
 
 // packages/omo-config-core/src/schema/task.ts
-var OmoTaskWaitSchema, OmoTaskTeamSettingsSchema, OmoTaskWarningsSchema, OmoTaskSettingsSchema, OmoTaskWaitLayerSchema, OmoTaskTeamSettingsLayerSchema, OmoTaskWarningsLayerSchema, OmoTaskSettingsLayerSchema;
+import { availableParallelism } from "os";
+function resolveOmoTaskSettings(input, resolveParallelism = availableParallelism) {
+  const record2 = record(string2(), unknown()).parse(input);
+  return OmoTaskSettingsSchema.parse({
+    ...record2,
+    residency_max_children: record2["residency_max_children"] ?? Math.max(8, resolveParallelism() * 3)
+  });
+}
+var ResidencyMaxChildrenInputSchema, OmoTaskWaitSchema, OmoTaskTeamSettingsSchema, OmoTaskWarningsSchema, OmoTaskDagSettingsSchema, OmoTaskSettingsSchema, OmoTaskDagSettingsLayerSchema, OmoTaskWaitLayerSchema, OmoTaskTeamSettingsLayerSchema, OmoTaskWarningsLayerSchema, OmoTaskSettingsLayerSchema;
 var init_task = __esm(() => {
   init_zod();
+  ResidencyMaxChildrenInputSchema = union([number2().int().positive(), literal("unlimited")]);
   OmoTaskWaitSchema = object({
     min_ms: number2().int().positive().default(5000),
     default_ms: number2().int().positive().default(60000),
@@ -18875,23 +19033,45 @@ var init_task = __esm(() => {
   OmoTaskWarningsSchema = object({
     unavailable_categories: boolean2().default(true)
   }).strict();
+  OmoTaskDagSettingsSchema = object({
+    max_nodes_per_run: number2().int().positive().default(64),
+    max_runs_per_session: number2().int().positive().default(16),
+    subscriber_ring: number2().int().positive().default(1000),
+    heartbeat_ms: number2().int().positive().default(15000),
+    history_default_limit: number2().int().positive().default(256),
+    history_max_limit: number2().int().positive().default(1000),
+    retention_days: number2().int().positive().default(7),
+    max_prompt_bytes: number2().int().positive().default(262144)
+  }).strict();
   OmoTaskSettingsSchema = object({
     default_execution_mode: _enum2(["in-process", "process"]).default("in-process"),
     default_concurrency: number2().int().positive().default(5),
     provider_concurrency: record(string2(), number2().int().positive()).optional(),
     model_concurrency: record(string2(), number2().int().positive()).optional(),
     max_depth: number2().int().nonnegative().default(1),
-    residency_max_children: number2().int().positive().default(8),
+    residency_max_children: ResidencyMaxChildrenInputSchema.default(8),
     ttl_ms: number2().int().positive().default(86400000),
     state_dir: string2().optional(),
     reattach_on_reconcile: boolean2().optional(),
+    resume_children: boolean2().default(true),
     warnings: OmoTaskWarningsSchema.default({ unavailable_categories: true }),
     wait: OmoTaskWaitSchema.default({ min_ms: 5000, default_ms: 60000, max_ms: 600000 }),
     team: OmoTaskTeamSettingsSchema.default({
       max_members: 8,
       max_parallel_members: 4,
       max_wall_clock_minutes: 120
-    })
+    }),
+    dag: OmoTaskDagSettingsSchema.optional()
+  }).strict();
+  OmoTaskDagSettingsLayerSchema = object({
+    max_nodes_per_run: number2().int().positive().optional(),
+    max_runs_per_session: number2().int().positive().optional(),
+    subscriber_ring: number2().int().positive().optional(),
+    heartbeat_ms: number2().int().positive().optional(),
+    history_default_limit: number2().int().positive().optional(),
+    history_max_limit: number2().int().positive().optional(),
+    retention_days: number2().int().positive().optional(),
+    max_prompt_bytes: number2().int().positive().optional()
   }).strict();
   OmoTaskWaitLayerSchema = object({
     min_ms: number2().int().positive().optional(),
@@ -18912,13 +19092,15 @@ var init_task = __esm(() => {
     provider_concurrency: record(string2(), number2().int().positive()).optional(),
     model_concurrency: record(string2(), number2().int().positive()).optional(),
     max_depth: number2().int().nonnegative().optional(),
-    residency_max_children: number2().int().positive().optional(),
+    residency_max_children: ResidencyMaxChildrenInputSchema.optional(),
     ttl_ms: number2().int().positive().optional(),
     state_dir: string2().optional(),
     reattach_on_reconcile: boolean2().optional(),
+    resume_children: boolean2().optional(),
     warnings: OmoTaskWarningsLayerSchema.optional(),
     wait: OmoTaskWaitLayerSchema.optional(),
-    team: OmoTaskTeamSettingsLayerSchema.optional()
+    team: OmoTaskTeamSettingsLayerSchema.optional(),
+    dag: OmoTaskDagSettingsLayerSchema.optional()
   }).strict();
 });
 
@@ -18973,6 +19155,19 @@ var init_team = __esm(() => {
   OmoTeamsConfigLayerSchema = record(string2(), OmoTeamSpecLayerSchema);
 });
 
+// packages/omo-config-core/src/schema/telemetry.ts
+var OmoTelemetrySettingsShape, OmoTelemetrySettingsLayerSchema, OmoTelemetrySettingsSchema;
+var init_telemetry = __esm(() => {
+  init_zod();
+  OmoTelemetrySettingsShape = {
+    enabled: boolean2()
+  };
+  OmoTelemetrySettingsLayerSchema = object(OmoTelemetrySettingsShape).partial().strict();
+  OmoTelemetrySettingsSchema = OmoTelemetrySettingsLayerSchema.extend({
+    enabled: boolean2().default(true)
+  }).strict();
+});
+
 // packages/omo-config-core/src/schema/config.ts
 var OmoOpenCodeHarnessConfigSchema, OmoTypedHarnessConfigSchema, OmoConfigProfileSchema, OmoConfigSchema, OmoConfigLayerSchema;
 var init_config = __esm(() => {
@@ -18980,9 +19175,11 @@ var init_config = __esm(() => {
   init_agent();
   init_category();
   init_codegraph();
+  init_memory();
   init_model_catalog();
   init_task();
   init_team();
+  init_telemetry();
   OmoOpenCodeHarnessConfigSchema = record(string2(), unknown());
   OmoTypedHarnessConfigSchema = object({
     categories: OmoCategoriesConfigSchema.optional(),
@@ -18990,7 +19187,9 @@ var init_config = __esm(() => {
     codegraph: OmoCodegraphSettingsLayerSchema.optional(),
     task: OmoTaskSettingsLayerSchema.optional(),
     teams: OmoTeamsConfigLayerSchema.optional(),
-    models: OmoModelCatalogLayerSchema.optional()
+    models: OmoModelCatalogLayerSchema.optional(),
+    memory: OmoMemorySettingsLayerSchema.optional(),
+    telemetry: OmoTelemetrySettingsLayerSchema.optional()
   }).strict();
   OmoConfigProfileSchema = object({
     categories: OmoCategoriesConfigSchema.optional(),
@@ -18999,6 +19198,8 @@ var init_config = __esm(() => {
     task: OmoTaskSettingsLayerSchema.optional(),
     teams: OmoTeamsConfigLayerSchema.optional(),
     models: OmoModelCatalogLayerSchema.optional(),
+    memory: OmoMemorySettingsLayerSchema.optional(),
+    telemetry: OmoTelemetrySettingsLayerSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional()
@@ -19011,6 +19212,8 @@ var init_config = __esm(() => {
     task: OmoTaskSettingsSchema.optional(),
     teams: OmoTeamsConfigSchema.optional(),
     models: OmoModelCatalogSchema.optional(),
+    memory: OmoMemorySettingsSchema.optional(),
+    telemetry: OmoTelemetrySettingsSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional(),
@@ -19026,6 +19229,8 @@ var init_config = __esm(() => {
     task: OmoTaskSettingsLayerSchema.optional(),
     teams: OmoTeamsConfigLayerSchema.optional(),
     models: OmoModelCatalogLayerSchema.optional(),
+    memory: OmoMemorySettingsLayerSchema.optional(),
+    telemetry: OmoTelemetrySettingsLayerSchema.optional(),
     "[opencode]": OmoOpenCodeHarnessConfigSchema.optional(),
     "[senpi]": OmoTypedHarnessConfigSchema.optional(),
     "[codex]": OmoTypedHarnessConfigSchema.optional(),
@@ -19043,10 +19248,12 @@ var init_schema = __esm(() => {
   init_config();
   init_fallback_models();
   init_harness();
+  init_memory();
   init_model_catalog();
   init_model_ref();
   init_task();
   init_team();
+  init_telemetry();
 });
 
 // packages/omo-config-core/src/loader/merge.ts
@@ -19404,7 +19611,7 @@ var init_loader = __esm(() => {
     agents: {},
     categories: {},
     codegraph: OmoCodegraphSettingsSchema.parse({}),
-    task: OmoTaskSettingsSchema.parse({}),
+    task: resolveOmoTaskSettings({}),
     teams: {}
   };
 });
@@ -19674,17 +19881,31 @@ var init_archive_entry_validator = () => {};
 // packages/utils/src/ast-grep/sg-manifest.ts
 var init_sg_manifest = () => {};
 
+// packages/utils/src/ast-grep/install-script.ts
+var init_install_script = () => {};
+
+// packages/utils/src/ast-grep/types.ts
+var SG_PATH_ENV_KEY = "OMO_AST_GREP_SG_PATH";
+
+// packages/utils/src/ast-grep/sg-candidates.ts
+var init_sg_candidates = () => {};
+
+// packages/utils/src/ast-grep/sg-install-hints.ts
+var ENV_OVERRIDE_HINT;
+var init_sg_install_hints = __esm(() => {
+  ENV_OVERRIDE_HINT = `Or point ${SG_PATH_ENV_KEY} at an existing ast-grep binary`;
+});
+
 // packages/utils/src/ast-grep/sg-provisioner.ts
 var init_sg_provisioner = () => {};
 
 // packages/utils/src/ast-grep/sg-resolver.ts
 var init_sg_resolver = () => {};
 
-// packages/utils/src/ast-grep/install-script.ts
-var init_install_script = () => {};
-
 // packages/utils/src/ast-grep/index.ts
 var init_ast_grep = __esm(() => {
+  init_sg_candidates();
+  init_sg_install_hints();
   init_sg_manifest();
   init_sg_provisioner();
   init_sg_resolver();
@@ -20859,10 +21080,10 @@ var init_category_model_requirements = __esm(() => {
     quick: {
       fallbackChain: [
         { providers: ["kimi-for-coding"], model: "kimi-for-coding-highspeed" },
-        { providers: ["quotio-openai"], model: "gpt-5.6-luna-fast", variant: "low" },
+        { providers: ["openai-codex"], model: "gpt-5.6-luna-fast", variant: "low" },
         { providers: ["deepseek"], model: "deepseek-v4-flash", variant: "off" },
         {
-          providers: ["qwen-token-plan", "alibaba-token-plan", "bailian-coding-plan", "opencode-go", "vercel"],
+          providers: ["qwen-token-plan", "alibaba-token-plan", "bailian-coding-plan", "vercel"],
           model: "qwen3.6-flash",
           variant: "low"
         },
@@ -20878,6 +21099,11 @@ var init_category_model_requirements = __esm(() => {
     },
     "unspecified-low": {
       fallbackChain: [
+        {
+          providers: ["xai", "github-copilot", "opencode", "vercel"],
+          model: "grok-4.6",
+          variant: "xhigh"
+        },
         {
           providers: ["openai", "quotio-openai", "github-copilot", "opencode", "vercel"],
           model: "gpt-5.6-terra",
@@ -21050,9 +21276,71 @@ function normalizeModelID(modelID) {
   return modelID.replace(/\.(\d+)/g, "-$1");
 }
 
+// packages/model-core/src/reasoning-level.ts
+function isReasoningLevelOrAuto(value) {
+  return REASONING_LEVEL_OR_AUTO_SET2.has(value);
+}
+function splitReasoningSuffix2(model, options) {
+  if (typeof model !== "string")
+    return { base: "" };
+  const trimmed = model.trim();
+  if (!trimmed)
+    return { base: "" };
+  const separatorIndex = trimmed.lastIndexOf(":");
+  if (separatorIndex === -1)
+    return { base: trimmed };
+  const base = trimmed.slice(0, separatorIndex).trim();
+  const token = trimmed.slice(separatorIndex + 1).trim().toLowerCase();
+  if (!base || !isReasoningLevelOrAuto(token))
+    return { base: trimmed };
+  if (token === "max" && !(options?.allowMaxSuffix ?? base.includes("/")))
+    return { base: trimmed };
+  return { base, level: token };
+}
+var REASONING_LEVELS2, REASONING_AUTO2 = "auto", REASONING_LEVEL_SET2, REASONING_LEVEL_OR_AUTO_SET2;
+var init_reasoning_level = __esm(() => {
+  REASONING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+  REASONING_LEVEL_SET2 = new Set(REASONING_LEVELS2);
+  REASONING_LEVEL_OR_AUTO_SET2 = new Set([...REASONING_LEVELS2, REASONING_AUTO2]);
+});
+
+// packages/model-core/src/model-string-parser.ts
+function parseVariantFromModelID(rawModelID, options) {
+  if (typeof rawModelID !== "string") {
+    return { modelID: "" };
+  }
+  const trimmedModelID = rawModelID.trim();
+  if (!trimmedModelID) {
+    return { modelID: "" };
+  }
+  const parenthesizedVariant = trimmedModelID.match(/^(.*)\(([^()]+)\)\s*$/);
+  if (parenthesizedVariant) {
+    const modelID = parenthesizedVariant[1]?.trim() ?? "";
+    const variant = parenthesizedVariant[2]?.trim();
+    return variant ? { modelID, variant } : { modelID };
+  }
+  const suffixedModel = splitReasoningSuffix2(trimmedModelID, options);
+  if (suffixedModel.level) {
+    return { modelID: suffixedModel.base, variant: suffixedModel.level };
+  }
+  const spaceVariant = trimmedModelID.match(/^(.*\S)\s+([a-z][a-z0-9_-]*)$/i);
+  if (spaceVariant) {
+    const modelID = spaceVariant[1]?.trim() ?? "";
+    const variant = spaceVariant[2]?.trim().toLowerCase();
+    if (variant) {
+      return { modelID, variant };
+    }
+  }
+  return { modelID: trimmedModelID };
+}
+var init_model_string_parser = __esm(() => {
+  init_reasoning_level();
+});
+
 // packages/model-core/src/model-capability-heuristics.ts
 function detectHeuristicModelFamily(modelID) {
-  const normalizedModelID = normalizeModelID(modelID).toLowerCase();
+  const parsedModel = parseVariantFromModelID(modelID, { allowMaxSuffix: true });
+  const normalizedModelID = normalizeModelID(parsedModel.modelID).toLowerCase();
   for (const definition of HEURISTIC_MODEL_FAMILY_REGISTRY) {
     if (definition.pattern?.test(normalizedModelID)) {
       return definition;
@@ -21065,6 +21353,7 @@ function detectHeuristicModelFamily(modelID) {
 }
 var HEURISTIC_MODEL_FAMILY_REGISTRY;
 var init_model_capability_heuristics = __esm(() => {
+  init_model_string_parser();
   HEURISTIC_MODEL_FAMILY_REGISTRY = [
     {
       family: "claude-opus",
@@ -21078,11 +21367,19 @@ var init_model_capability_heuristics = __esm(() => {
       variants: ["low", "medium", "high"],
       supportsThinking: true
     },
+    {
+      family: "openai-deep-research",
+      includes: ["o3-deep-research", "o4-mini-deep-research"],
+      variants: ["low", "medium", "high"],
+      reasoningEfforts: ["none", "minimal", "low", "medium", "high"],
+      supportsTemperature: true
+    },
     {
       family: "openai-reasoning",
       pattern: /(?:^|\/)o\d(?:$|-)/,
       variants: ["low", "medium", "high"],
-      reasoningEfforts: ["none", "minimal", "low", "medium", "high"]
+      reasoningEfforts: ["none", "minimal", "low", "medium", "high"],
+      supportsTemperature: false
     },
     {
       family: "gpt-5",
@@ -21126,7 +21423,13 @@ var init_model_capability_heuristics = __esm(() => {
     {
       family: "glm",
       includes: ["glm"],
-      variants: ["low", "medium", "high"]
+      variants: ["low", "medium", "high", "max"],
+      reasoningEfforts: ["high", "max"],
+      reasoningEffortAliases: {
+        low: "high",
+        medium: "high",
+        xhigh: "max"
+      }
     },
     {
       family: "minimax",
@@ -21161,14 +21464,6 @@ var init_model_capability_heuristics = __esm(() => {
 // packages/model-core/src/model-capability-guardrails.ts
 var init_model_capability_guardrails = () => {};
 
-// packages/model-core/src/reasoning-level.ts
-var REASONING_LEVELS2, REASONING_AUTO2 = "auto", REASONING_LEVEL_SET2, REASONING_LEVEL_OR_AUTO_SET2;
-var init_reasoning_level = __esm(() => {
-  REASONING_LEVELS2 = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-  REASONING_LEVEL_SET2 = new Set(REASONING_LEVELS2);
-  REASONING_LEVEL_OR_AUTO_SET2 = new Set([...REASONING_LEVELS2, REASONING_AUTO2]);
-});
-
 // packages/model-core/src/model-settings-compatibility.ts
 var init_model_settings_compatibility = () => {};
 
@@ -21182,9 +21477,6 @@ function normalizeFallbackModels(models2) {
 }
 var init_model_resolver = () => {};
 
-// packages/model-core/src/model-string-parser.ts
-var init_model_string_parser = () => {};
-
 // packages/model-core/src/fallback-chain-from-models.ts
 var init_fallback_chain_from_models = () => {};
 
@@ -21500,14 +21792,89 @@ function getProviderOverride(providerID, modelID) {
     return;
   return GITHUB_COPILOT_GPT5_MODEL.test(normalizeLookupModelID2(modelID)) ? GITHUB_COPILOT_GPT5_OVERRIDE : undefined;
 }
+function stripSameProviderPrefix(providerID, modelID) {
+  const prefix = `${providerID.trim()}/`;
+  return prefix !== "/" && modelID.slice(0, prefix.length).toLowerCase() === prefix.toLowerCase() ? modelID.slice(prefix.length) : undefined;
+}
+function buildLookupCandidates(providerID, modelID) {
+  const bareModelID = parseVariantFromModelID(modelID, { allowMaxSuffix: true }).modelID;
+  const candidates = [
+    modelID,
+    stripSameProviderPrefix(providerID, modelID),
+    bareModelID,
+    stripSameProviderPrefix(providerID, bareModelID)
+  ];
+  const uniqueCandidates = [];
+  const seen = new Set;
+  for (const candidate of candidates) {
+    if (!candidate || seen.has(candidate))
+      continue;
+    seen.add(candidate);
+    uniqueCandidates.push(candidate);
+  }
+  return uniqueCandidates;
+}
+function findProviderMetadata(providerCache, providerID, modelID) {
+  if (!providerCache)
+    return;
+  for (const candidate of buildLookupCandidates(providerID, modelID)) {
+    const match = providerCache.findProviderModelMetadata(providerID, candidate);
+    if (match)
+      return match;
+  }
+  return;
+}
+function findSnapshotEntry(snapshot, providerID, modelIDs) {
+  if (!snapshot)
+    return;
+  const normalizedProviderID = providerID.trim();
+  const providerSpecificCandidates = [];
+  const generalCandidates = [];
+  for (const modelID of modelIDs) {
+    const strippedModelID = stripSameProviderPrefix(providerID, modelID);
+    const unqualifiedModelID = strippedModelID ?? (modelID.includes("/") ? undefined : modelID);
+    if (!unqualifiedModelID) {
+      generalCandidates.push(...buildLookupCandidates(providerID, modelID));
+      continue;
+    }
+    const bareModelID = parseVariantFromModelID(unqualifiedModelID, { allowMaxSuffix: true }).modelID;
+    if (normalizedProviderID) {
+      providerSpecificCandidates.push(`${normalizedProviderID}/${unqualifiedModelID}`, `${normalizedProviderID}/${bareModelID}`);
+    }
+    generalCandidates.push(unqualifiedModelID, bareModelID);
+  }
+  const seen = new Set;
+  for (const candidate of [...providerSpecificCandidates, ...generalCandidates]) {
+    if (seen.has(candidate))
+      continue;
+    seen.add(candidate);
+    const entry = snapshot.models[candidate];
+    if (entry)
+      return entry;
+  }
+  return;
+}
+function resolveCapabilityModelAlias(modelID, providerID) {
+  const direct = resolveModelIDAlias(modelID, providerID);
+  if (direct.source !== "canonical")
+    return direct;
+  const bareModelID = parseVariantFromModelID(modelID, { allowMaxSuffix: true }).modelID;
+  if (bareModelID === modelID)
+    return direct;
+  const bareAlias = resolveModelIDAlias(bareModelID, providerID);
+  return bareAlias.source === "canonical" ? direct : { ...bareAlias, requestedModelID: modelID };
+}
 function getModelCapabilities(input) {
-  const canonicalization = resolveModelIDAlias(input.modelID, input.providerID);
+  const canonicalization = resolveCapabilityModelAlias(input.modelID, input.providerID);
   const override = getOverride(input.modelID);
   const providerOverride = getProviderOverride(input.providerID, canonicalization.canonicalModelID);
-  const runtimeModel = readRuntimeModel(input.runtimeModel ?? input.providerCache?.findProviderModelMetadata(input.providerID, input.modelID));
+  const runtimeModel = readRuntimeModel(input.runtimeModel ?? findProviderMetadata(input.providerCache, input.providerID, input.modelID));
   const runtimeSnapshot = input.runtimeSnapshot;
   const bundledSnapshot = input.bundledSnapshot;
-  const snapshotEntry = runtimeSnapshot?.models?.[canonicalization.canonicalModelID] ?? bundledSnapshot?.models?.[canonicalization.canonicalModelID];
+  const snapshotModelIDs = canonicalization.source === "canonical" ? [input.modelID, canonicalization.canonicalModelID] : [canonicalization.canonicalModelID, input.modelID];
+  const runtimeSnapshotEntry = findSnapshotEntry(runtimeSnapshot, input.providerID, snapshotModelIDs);
+  const bundledSnapshotEntry = findSnapshotEntry(bundledSnapshot, input.providerID, snapshotModelIDs);
+  const snapshotEntry = runtimeSnapshotEntry ?? bundledSnapshotEntry;
   const heuristicFamily = detectHeuristicModelFamily(canonicalization.canonicalModelID);
   const runtimeVariants = readRuntimeModelVariants(runtimeModel);
   const runtimeReasoning = readRuntimeModelReasoningSupport(runtimeModel);
@@ -21517,7 +21884,7 @@ function getModelCapabilities(input) {
   const runtimeMaxOutputTokens = readRuntimeModelLimitOutput(runtimeModel);
   const runtimeToolCall = readRuntimeModelToolCallSupport(runtimeModel);
   const runtimeModalities = readRuntimeModelModalities(runtimeModel);
-  const snapshotSource = runtimeSnapshot?.models?.[canonicalization.canonicalModelID] ? "runtime-snapshot" : bundledSnapshot?.models?.[canonicalization.canonicalModelID] ? "bundled-snapshot" : "none";
+  const snapshotSource = runtimeSnapshotEntry ? "runtime-snapshot" : bundledSnapshotEntry ? "bundled-snapshot" : "none";
   const familySource = snapshotEntry?.family ? "snapshot" : heuristicFamily?.family ? "heuristic" : "none";
   const variantsSource = runtimeVariants ? "runtime" : providerOverride?.variants ? "override" : override?.variants ? "override" : heuristicFamily?.variants ? "heuristic" : "none";
   const reasoningEffortsSource = providerOverride?.reasoningEfforts ? "override" : override?.reasoningEfforts ? "override" : heuristicFamily?.reasoningEfforts ? "heuristic" : "none";
@@ -21566,6 +21933,7 @@ var MODEL_ID_OVERRIDES, GITHUB_COPILOT_GPT5_MODEL, GITHUB_COPILOT_GPT5_OVERRIDE;
 var init_get_model_capabilities = __esm(() => {
   init_model_capability_aliases();
   init_model_capability_heuristics();
+  init_model_string_parser();
   MODEL_ID_OVERRIDES = {};
   GITHUB_COPILOT_GPT5_MODEL = /(?:^|\/)gpt-5(?:[.-]|$)/;
   GITHUB_COPILOT_GPT5_OVERRIDE = {
@@ -22169,7 +22537,7 @@ function recordFields(value, fields) {
 }
 function modelInput(view) {
   const agents = isPlainRecord(view.agents) ? Object.fromEntries(Object.entries(view.agents).flatMap(([name, definition]) => {
-    const fields = recordFields(definition, ["description", "prompt", "model", "variant", "reasoningEffort", "tools", "temperature", "disable"]);
+    const fields = recordFields(definition, ["description", "prompt", "model", "models", "variant", "reasoningEffort", "tools", "temperature", "disable"]);
     return fields === undefined ? [] : [[name, fields]];
   })) : undefined;
   const categories = isPlainRecord(view.categories) ? Object.fromEntries(Object.entries(view.categories).flatMap(([name, definition]) => {
@@ -22452,6 +22820,7 @@ var init_agent_overrides = __esm(() => {
   init_permission();
   AgentOverrideConfigSchema = exports_external.object({
     model: exports_external.string().optional(),
+    models: exports_external.array(exports_external.union([exports_external.string(), FallbackModelObjectSchema])).optional(),
     fallback_models: FallbackModelsSchema.optional(),
     reasoning: OmoReasoningSchema.optional(),
     variant: exports_external.string().optional(),
@@ -23370,6 +23739,37 @@ function protectUserFields(config4, userConfig) {
     }
   };
 }
+function materializeAgentModelChains(config4) {
+  if (config4.agents === undefined)
+    return config4;
+  let changed = false;
+  const agents = Object.fromEntries(Object.entries(config4.agents).map(([name, agent2]) => {
+    if (agent2?.models === undefined)
+      return [name, agent2];
+    const [primary, ...fallbacks] = agent2.models;
+    const {
+      models: _models,
+      model: _model,
+      fallback_models: _fallbackModels,
+      reasoning: _reasoning,
+      variant: _variant,
+      reasoningEffort: _reasoningEffort,
+      temperature: _temperature,
+      top_p: _topP,
+      maxTokens: _maxTokens,
+      thinking: _thinking,
+      ...rest
+    } = agent2;
+    const primarySettings = primary === undefined ? {} : typeof primary === "string" ? { model: primary } : primary;
+    changed = true;
+    return [name, {
+      ...rest,
+      ...primarySettings,
+      fallback_models: fallbacks
+    }];
+  }));
+  return changed ? { ...config4, agents } : config4;
+}
 function migrateRalphLoopConfig(config4) {
   const legacy = config4.ralph_loop;
   if (legacy === undefined)
@@ -23397,7 +23797,7 @@ function validatePluginConfig(directory, environment2 = process.env) {
   const firstFailingView = views.find((view) => view.messages.length > 0);
   const firstView = views[0];
   const userConfig = parseConfig(chain.protectedUserView);
-  const config4 = applyDisabledProviders(protectUserFields(mergeViews(views), userConfig));
+  const config4 = applyDisabledProviders(materializeAgentModelChains(protectUserFields(mergeViews(views), userConfig)));
   return {
     valid: messages.length === 0,
     messages,
@@ -77570,6 +77970,47 @@ var init_model_capabilities_generated = __esm(() => {
           input: 272000,
           output: 128000
         }
+      },
+      "grok-4.6": {
+        id: "grok-4.6",
+        family: "grok",
+        reasoning: true,
+        temperature: true,
+        toolCall: true,
+        modalities: {
+          input: [
+            "text",
+            "image"
+          ],
+          output: [
+            "text"
+          ]
+        },
+        limit: {
+          context: 500000,
+          output: 500000
+        }
+      },
+      "xai/grok-4.6": {
+        id: "xai/grok-4.6",
+        family: "grok",
+        reasoning: true,
+        temperature: true,
+        toolCall: true,
+        modalities: {
+          input: [
+            "text",
+            "image",
+            "pdf"
+          ],
+          output: [
+            "text"
+          ]
+        },
+        limit: {
+          context: 500000,
+          output: 500000
+        }
       }
     }
   };
@@ -78068,7 +78509,7 @@ This is NOT a default choice - it's for genuinely unclassifiable moderate-effort
 </Category_Context>
 
 <Caller_Warning>
-THIS CATEGORY USES A LIGHTWEIGHT MODEL (gpt-5.6-luna).
+THIS CATEGORY USES GROK 4.6 (xhigh).
 
 **PROVIDE CLEAR STRUCTURE:**
 1. MUST DO: Enumerate required actions explicitly
@@ -78100,7 +78541,7 @@ var init_openai_categories = __esm(() => {
     },
     {
       name: "unspecified-low",
-      config: { model: "openai/gpt-5.6-luna", variant: "xhigh" },
+      config: { model: "xai/grok-4.6", variant: "xhigh" },
       description: "Tasks that don't fit other categories, low effort required",
       promptAppend: UNSPECIFIED_LOW_CATEGORY_PROMPT_APPEND
     }