oh-my-opencode 5.1.4 → 5.1.6

package/dist/tui.js

@@ -69611,97 +69611,6 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// packages/omo-opencode/src/shared/disabled-providers.ts
-function getModelProvider(model) {
-  const slash = model.indexOf("/");
-  if (slash <= 0)
-    return;
-  const provider = model.slice(0, slash).trim();
-  return provider || undefined;
-}
-function isProviderDisabled(model, disabled) {
-  if (!model || disabled.length === 0)
-    return false;
-  const provider = getModelProvider(model);
-  if (provider === undefined)
-    return false;
-  const providerLower = provider.toLowerCase();
-  return disabled.some((entry) => entry.trim().toLowerCase() === providerLower);
-}
-function filterDisabledProviderModels(models, disabled) {
-  if (disabled.length === 0)
-    return [...models];
-  return models.filter((entry) => {
-    const model = typeof entry === "string" ? entry : entry.model;
-    return !isProviderDisabled(model, disabled);
-  });
-}
-function findFirstAllowedReplacement(chain, disabled) {
-  if (!chain)
-    return;
-  for (const entry of chain) {
-    const model = typeof entry === "string" ? entry : entry.model;
-    if (!isProviderDisabled(model, disabled))
-      return model;
-  }
-  return;
-}
-function applyToHolder(label, holder, disabled) {
-  const normalizedChain = normalizeFallbackModels(holder.fallback_models);
-  if (normalizedChain) {
-    const filteredChain = filterDisabledProviderModels(normalizedChain, disabled);
-    if (filteredChain.length !== normalizedChain.length) {
-      log2(`[${HOOK_NAME}] Filtered disabled-provider entries from fallback chain`, {
-        label,
-        removed: normalizedChain.length - filteredChain.length,
-        remaining: filteredChain.length
-      });
-    }
-    holder.fallback_models = filteredChain.length === 0 ? undefined : filteredChain;
-  }
-  if (typeof holder.model === "string" && isProviderDisabled(holder.model, disabled)) {
-    const replacement = findFirstAllowedReplacement(normalizeFallbackModels(holder.fallback_models), disabled);
-    if (replacement) {
-      log2(`[${HOOK_NAME}] Substituted primary model from fallback chain`, {
-        label,
-        from: holder.model,
-        to: replacement
-      });
-      holder.model = replacement;
-    } else {
-      const message = `${label} primary model "${holder.model}" uses a disabled provider and no allowed entry is available in fallback_models. ` + `Either remove the provider from disabled_providers or add an allowed entry to fallback_models.`;
-      addConfigLoadError({ path: `disabled_providers:${label}`, error: message });
-      log2(`[${HOOK_NAME}] ${message}`, { label, primary: holder.model });
-    }
-  }
-}
-function applyDisabledProviders(config) {
-  const disabled = config.disabled_providers ?? [];
-  if (disabled.length === 0)
-    return config;
-  if (config.agents) {
-    for (const [name, agentConfig] of Object.entries(config.agents)) {
-      if (agentConfig && typeof agentConfig === "object") {
-        applyToHolder(`agents.${name}`, agentConfig, disabled);
-      }
-    }
-  }
-  if (config.categories) {
-    for (const [name, categoryConfig] of Object.entries(config.categories)) {
-      if (categoryConfig && typeof categoryConfig === "object") {
-        applyToHolder(`categories.${name}`, categoryConfig, disabled);
-      }
-    }
-  }
-  return config;
-}
-var HOOK_NAME = "disabled-providers";
-var init_disabled_providers = __esm(() => {
-  init_config_errors();
-  init_logger2();
-  init_model_resolver2();
-});
-
 // packages/omo-config-core/src/schema/reasoning-vocabulary.ts
 function isReasoningLevel(value) {
   return REASONING_LEVEL_SET2.has(value);
@@ -69793,7 +69702,6 @@ function normalizeLegacyModelFields(entry) {
   delete normalized["reasoningEffort"];
   delete normalized["thinking"];
   delete normalized["textVerbosity"];
-  delete normalized["maxTokens"];
   delete normalized["providerOptions"];
   if (typeof entry["model"] === "string")
     normalized["model"] = canonicalModelString(entry["model"]);
@@ -69811,10 +69719,15 @@ function normalizeLegacyModelFields(entry) {
     providerOptions["textVerbosity"] = entry["textVerbosity"];
   if (Object.keys(providerOptions).length > 0)
     normalized["provider_options"] = providerOptions;
-  if (entry["max_tokens"] !== undefined)
+  if (entry["max_tokens"] !== undefined) {
     normalized["max_tokens"] = entry["max_tokens"];
-  else if (entry["maxTokens"] !== undefined)
+    if (entry["maxTokens"] === undefined || typeof entry["maxTokens"] === "number") {
+      delete normalized["maxTokens"];
+    }
+  } else if (typeof entry["maxTokens"] === "number") {
     normalized["max_tokens"] = entry["maxTokens"];
+    delete normalized["maxTokens"];
+  }
   return normalized;
 }
 var OmoThinkingConfigSchema, OmoReasoningEffortSchema, OmoLegacyFallbackModelObjectInputSchema, OmoFallbackModelObjectSchema, OmoFallbackModelsSchema;
@@ -69854,12 +69767,25 @@ var init_fallback_models = __esm(() => {
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var OmoAgentModelEntrySchema, OmoAgentDefInputSchema, OmoAgentDefSchema, OmoAgentsConfigSchema;
+var OmoAgentModelEntrySchema, PermissionValueSchema, BashPermissionSchema, OmoAgentPermissionSchema, OmoAgentDefInputSchema, OmoAgentDefSchema, OmoAgentsConfigSchema;
 var init_agent = __esm(() => {
   init_zod();
   init_fallback_models();
   init_model_ref();
   OmoAgentModelEntrySchema = union([string2(), OmoFallbackModelObjectSchema]);
+  PermissionValueSchema = _enum(["ask", "allow", "deny"]);
+  BashPermissionSchema = union([
+    PermissionValueSchema,
+    record(string2(), PermissionValueSchema)
+  ]);
+  OmoAgentPermissionSchema = object({
+    edit: PermissionValueSchema.optional(),
+    bash: BashPermissionSchema.optional(),
+    webfetch: PermissionValueSchema.optional(),
+    task: PermissionValueSchema.optional(),
+    doom_loop: PermissionValueSchema.optional(),
+    external_directory: PermissionValueSchema.optional()
+  }).catchall(PermissionValueSchema.optional());
   OmoAgentDefInputSchema = object({
     description: string2().optional(),
     prompt: string2().optional(),
@@ -69876,7 +69802,9 @@ var init_agent = __esm(() => {
     disallowed_tools: array(string2()).optional(),
     max_turns: number2().int().nonnegative().optional(),
     temperature: number2().min(0).max(2).optional(),
-    disable: boolean2().optional()
+    disable: boolean2().optional(),
+    permission: OmoAgentPermissionSchema.optional(),
+    prompt_append: string2().optional()
   }).strict();
   OmoAgentDefSchema = preprocess((value) => isRecord5(value) ? normalizeLegacyModelFields(value) : value, OmoAgentDefInputSchema);
   OmoAgentsConfigSchema = record(string2(), OmoAgentDefSchema);
@@ -70656,6 +70584,64 @@ var init_schema = __esm(() => {
   init_computer();
 });
 
+// packages/omo-config-core/src/loader/types.ts
+import { existsSync as existsSync6, lstatSync, readFileSync as readFileSync6, realpathSync as realpathSync4 } from "fs";
+var MERGED_OMO_CONFIG_PATH = "(merged omo config)", DEFAULT_READ_FILE_SYSTEM;
+var init_types3 = __esm(() => {
+  DEFAULT_READ_FILE_SYSTEM = {
+    existsSync: existsSync6,
+    lstatSync,
+    readFileSync: readFileSync6,
+    realpathSync: realpathSync4
+  };
+});
+
+// packages/omo-config-core/src/loader/diagnostic-lines.ts
+function displayOmoConfigPath(path, homeDir) {
+  if (path === MERGED_OMO_CONFIG_PATH)
+    return "merged config";
+  if (homeDir === undefined || homeDir.length === 0)
+    return path;
+  const slashed = (value) => value.replaceAll("\\", "/");
+  const home = slashed(homeDir).replace(/\/+$/, "");
+  const file = slashed(path);
+  const fold = (value) => /^[A-Za-z]:\//.test(home) ? value.toLowerCase() : value;
+  if (fold(file) === fold(home))
+    return "~";
+  return fold(file).startsWith(`${fold(home)}/`) ? `~${file.slice(home.length)}` : path;
+}
+function notLoadedReason(diagnostic) {
+  switch (diagnostic.kind) {
+    case "parse":
+      return "JSONC parse error";
+    case "read":
+      return "unreadable";
+    default:
+      return diagnostic.issuePaths === undefined || diagnostic.issuePaths.length === 0 ? "invalid config" : `invalid: ${diagnostic.issuePaths.join(", ")}`;
+  }
+}
+function omoConfigDiagnosticLines(diagnostics, options = {}) {
+  return diagnostics.flatMap((diagnostic) => {
+    const file = displayOmoConfigPath(diagnostic.path, options.homeDir);
+    switch (diagnostic.kind) {
+      case "invalid-value":
+        return (diagnostic.issuePaths ?? []).map((key) => `config: ${file}: ${key} ignored (invalid value)`);
+      case "unknown-keys":
+        return (diagnostic.issuePaths ?? []).map((key) => `config: ${file}: ${key} ignored (unknown key)`);
+      case "parse":
+      case "read":
+      case "validation":
+        return diagnostic.path === MERGED_OMO_CONFIG_PATH ? [`config: ${file}: reset to defaults (${notLoadedReason(diagnostic)})`] : [`config: ${file}: not loaded (${notLoadedReason(diagnostic)})`];
+      case "deprecated-keys":
+      case "profile":
+        return [];
+    }
+  });
+}
+var init_diagnostic_lines = __esm(() => {
+  init_types3();
+});
+
 // packages/omo-config-core/src/loader/disabled-skills.ts
 var init_disabled_skills = () => {};
 
@@ -70695,24 +70681,265 @@ var init_merge = __esm(() => {
   DANGEROUS_KEYS2 = new Set(["__proto__", "constructor", "prototype"]);
 });
 
+// packages/omo-config-core/src/loader/prune-invalid-leaves.ts
+function isContainer(value) {
+  return typeof value === "object" && value !== null;
+}
+function childOf(container, segment) {
+  return Array.isArray(container) ? container[Number(segment)] : container[String(segment)];
+}
+function hasChild(container, segment) {
+  if (Array.isArray(container)) {
+    const index = Number(segment);
+    return Number.isInteger(index) && index >= 0 && index < container.length;
+  }
+  return Object.hasOwn(container, String(segment));
+}
+function segmentsOf(path) {
+  return path.map((segment) => typeof segment === "number" ? segment : String(segment));
+}
+function targetPaths(root, issue) {
+  const base = segmentsOf(issue.path);
+  if (issue.code === "unrecognized_keys")
+    return issue.keys.map((key) => [...base, key]);
+  let node = root;
+  let depth = 0;
+  for (const segment of base) {
+    if (!isContainer(node) || !hasChild(node, segment))
+      break;
+    node = childOf(node, segment);
+    depth += 1;
+  }
+  return [base.slice(0, depth)];
+}
+function isAncestor(ancestor, path) {
+  return ancestor.length < path.length && ancestor.every((segment, index) => segment === path[index]);
+}
+function compareDescending(left, right) {
+  const length = Math.min(left.length, right.length);
+  for (let index = 0;index < length; index += 1) {
+    const a = left[index];
+    const b = right[index];
+    if (a === b)
+      continue;
+    if (typeof a === "number" && typeof b === "number")
+      return b - a;
+    return String(b).localeCompare(String(a));
+  }
+  return right.length - left.length;
+}
+function removeChild(container, segment) {
+  if (Array.isArray(container))
+    container.splice(Number(segment), 1);
+  else
+    delete container[String(segment)];
+}
+function isEmpty(container) {
+  return Array.isArray(container) ? container.length === 0 : Object.keys(container).length === 0;
+}
+function removePathAndEmptiedAncestors(root, path) {
+  const chain = [root];
+  for (const segment of path.slice(0, -1)) {
+    const current = chain[chain.length - 1];
+    if (current === undefined)
+      return;
+    const next = childOf(current, segment);
+    if (!isContainer(next))
+      return;
+    chain.push(next);
+  }
+  for (let depth = path.length - 1;depth >= 0; depth -= 1) {
+    const container = chain[depth];
+    const segment = path[depth];
+    if (container === undefined || segment === undefined)
+      return;
+    removeChild(container, segment);
+    if (depth === 0 || !isEmpty(container))
+      return;
+  }
+}
+function prunePass(root, issues) {
+  const byKey = new Map;
+  for (const issue of issues) {
+    for (const path of targetPaths(root, issue)) {
+      if (path.length === 0)
+        return null;
+      const key = path.map((segment) => String(segment)).join(".");
+      if (!byKey.has(key))
+        byKey.set(key, { key, message: issue.message, path });
+    }
+  }
+  const targets = [...byKey.values()];
+  const outermost = targets.filter((target) => !targets.some((other) => isAncestor(other.path, target.path))).sort((left, right) => compareDescending(left.path, right.path));
+  const next = structuredClone(root);
+  for (const target of outermost)
+    removePathAndEmptiedAncestors(next, target.path);
+  return { dropped: outermost, next };
+}
+function pruneInvalidConfigPaths(config, issues, validate, maxPasses = MAX_PRUNE_PASSES) {
+  const dropped = [];
+  let current = config;
+  let pending = issues;
+  for (let pass = 0;pass < maxPasses; pass += 1) {
+    const step = prunePass(current, pending);
+    if (step === null || step.dropped.length === 0)
+      return { ok: false, dropped };
+    dropped.push(...step.dropped);
+    current = step.next;
+    if (Object.keys(current).length === 0)
+      return { ok: false, dropped };
+    const validation = validate(current);
+    if (validation.success)
+      return { ok: true, config: current, dropped };
+    pending = validation.issues;
+  }
+  return { ok: false, dropped };
+}
+var MAX_PRUNE_PASSES = 32;
+
+// packages/omo-config-core/src/loader/layer-validation.ts
+function validationDiagnostic(path, issues) {
+  const issuePaths = issues.map((issue) => issue.path.map((segment) => String(segment)).join("."));
+  return {
+    kind: "validation",
+    message: `Invalid omo config at ${path}: ${issuePaths.join(", ")}`,
+    path,
+    issuePaths
+  };
+}
+function invalidValueDiagnostics(path, dropped) {
+  return dropped.map((entry) => ({
+    kind: "invalid-value",
+    message: `Ignored invalid value in ${path}: ${entry.key}: ${entry.message}`,
+    path,
+    issuePaths: [entry.key]
+  }));
+}
+function unrecognizedKeyIssues(issues) {
+  return issues.flatMap((issue) => issue.code === "unrecognized_keys" ? [{ keys: issue.keys, path: issue.path.map((segment) => String(segment)) }] : []);
+}
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitizeUnsafeKeys(value, path = []) {
+  if (Array.isArray(value)) {
+    const issues = [];
+    const sanitized = value.map((entry, index) => {
+      const nested = sanitizeUnsafeKeys(entry, [...path, String(index)]);
+      issues.push(...nested.issues);
+      return nested.value;
+    });
+    return { issues, value: sanitized };
+  }
+  if (!isRecord11(value))
+    return { issues: [], value };
+  const issues = [];
+  if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    issues.push({ keys: ["__proto__"], path });
+  }
+  const sanitized = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (isUnsafeObjectKey2(key)) {
+      issues.push({ keys: [key], path });
+      continue;
+    }
+    const nested = sanitizeUnsafeKeys(entry, [...path, key]);
+    issues.push(...nested.issues);
+    sanitized[key] = nested.value;
+  }
+  return { issues, value: sanitized };
+}
+function containerAt(record, path) {
+  let node = record;
+  for (const segment of path) {
+    if (Array.isArray(node)) {
+      const index = Number(segment);
+      if (!Number.isInteger(index) || index < 0 || index >= node.length)
+        return null;
+      node = node[index];
+    } else if (isRecord11(node) && Object.hasOwn(node, segment)) {
+      node = node[segment];
+    } else {
+      return null;
+    }
+  }
+  return isRecord11(node) ? node : null;
+}
+function stripUnrecognizedKeys(record, issues) {
+  const stripped = structuredClone(record);
+  const issuePaths = [];
+  for (const issue of issues) {
+    const container = containerAt(stripped, issue.path);
+    if (container === null)
+      continue;
+    for (const key of issue.keys) {
+      delete container[key];
+      issuePaths.push([...issue.path, key].join("."));
+    }
+  }
+  return { issuePaths, stripped };
+}
+function toRecord(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = {};
+  for (const [key, entry] of Object.entries(value)) {
+    record[key] = entry;
+  }
+  return record;
+}
+function validateConfigLayer(path, data) {
+  const sanitized = sanitizeUnsafeKeys(data);
+  const record = toRecord(sanitized.value);
+  const unsafeIssuePaths = sanitized.issues.flatMap((issue) => issue.keys.map((key) => [...issue.path, key].join(".")));
+  const unsafeDiagnostics = unsafeIssuePaths.length === 0 ? [] : [{ kind: "unknown-keys", message: `Ignored unknown keys in ${path}: ${unsafeIssuePaths.join(", ")}`, path, issuePaths: unsafeIssuePaths }];
+  const validation = OmoConfigLayerSchema.safeParse(sanitized.value);
+  if (validation.success) {
+    if (record !== null)
+      return { loaded: true, diagnostics: unsafeDiagnostics, value: record };
+    return {
+      loaded: false,
+      diagnostics: [{ kind: "validation", message: `Invalid omo config at ${path}: root must be an object`, path }]
+    };
+  }
+  const rejected = { loaded: false, diagnostics: [validationDiagnostic(path, validation.error.issues)] };
+  const unknownIssues = unrecognizedKeyIssues(validation.error.issues);
+  if (record === null)
+    return rejected;
+  let candidate = record;
+  let issues = validation.error.issues;
+  const diagnostics = [...unsafeDiagnostics];
+  if (unknownIssues.length > 0) {
+    const { issuePaths, stripped } = stripUnrecognizedKeys(record, unknownIssues);
+    if (issuePaths.length > 0) {
+      diagnostics.push({ kind: "unknown-keys", message: `Ignored unknown keys in ${path}: ${issuePaths.join(", ")}`, path, issuePaths });
+    }
+    const strippedValidation = validateLayerRecord(stripped);
+    if (strippedValidation.success)
+      return { loaded: true, diagnostics, value: stripped };
+    candidate = stripped;
+    issues = strippedValidation.issues;
+  }
+  const pruned = pruneInvalidConfigPaths(candidate, issues, validateLayerRecord);
+  if (!pruned.ok)
+    return rejected;
+  return { loaded: true, diagnostics: [...diagnostics, ...invalidValueDiagnostics(path, pruned.dropped)], value: pruned.config };
+}
+var validateLayerRecord = (record) => {
+  const parsed = OmoConfigLayerSchema.safeParse(record);
+  return parsed.success ? { success: true } : { success: false, issues: parsed.error.issues };
+};
+var init_layer_validation = __esm(() => {
+  init_schema();
+  init_merge();
+});
+
 // packages/omo-config-core/src/internal/posix-path.ts
 function toPosixPath(path) {
   return path.split("\\").join("/");
 }
 var init_posix_path = () => {};
 
-// packages/omo-config-core/src/loader/types.ts
-import { existsSync as existsSync6, lstatSync, readFileSync as readFileSync6, realpathSync as realpathSync4 } from "fs";
-var DEFAULT_READ_FILE_SYSTEM;
-var init_types3 = __esm(() => {
-  DEFAULT_READ_FILE_SYSTEM = {
-    existsSync: existsSync6,
-    lstatSync,
-    readFileSync: readFileSync6,
-    realpathSync: realpathSync4
-  };
-});
-
 // packages/omo-config-core/src/loader/paths.ts
 import { userInfo } from "os";
 import { dirname as dirname4, join as join12, posix as posix2, resolve as resolve4 } from "path";
@@ -70813,7 +71040,7 @@ function resolveOmoProfileName(options = {}) {
   const env = options.env ?? process.env;
   return profileName(options.profile) ?? profileName(env["OMO_PROFILE"]) ?? profileName(env["OCX_PROFILE"]) ?? profileNameFromOpenCodeConfigDir(env["OPENCODE_CONFIG_DIR"]);
 }
-function toRecord(value) {
+function toRecord2(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     return;
   return Object.fromEntries(Object.entries(value));
@@ -70834,13 +71061,13 @@ function harnessLayer(config, harness) {
   const legacyKeys = Object.entries(OMO_CONFIG_LEGACY_HARNESS_ALIASES).filter(([, target]) => target === canonical).map(([legacy]) => harnessBlockKey(legacy));
   let layer = {};
   for (const key of [...legacyKeys, harnessBlockKey(canonical)]) {
-    layer = mergeOmoConfigRecords(layer, toRecord(config[key]) ?? {});
+    layer = mergeOmoConfigRecords(layer, toRecord2(config[key]) ?? {});
   }
   return layer;
 }
 function resolveOmoConfigView(options) {
-  const profiles = toRecord(options.config["profiles"]);
-  const profile = options.profile === undefined ? undefined : toRecord(profiles?.[options.profile]);
+  const profiles = toRecord2(options.config["profiles"]);
+  const profile = options.profile === undefined ? undefined : toRecord2(profiles?.[options.profile]);
   const diagnostics = profile === undefined && options.profile !== undefined ? [{
     kind: "profile",
     message: `Activated omo profile "${options.profile}" does not exist; using the base configuration`,
@@ -70895,70 +71122,9 @@ function stripResolutionControlKeys(config) {
   } = config;
   return resolved;
 }
-function validationDiagnostic(path, issues) {
-  const issuePaths = issues.map((issue) => issue.path.map((segment) => String(segment)).join("."));
-  return {
-    kind: "validation",
-    message: `Invalid omo config at ${path}: ${issuePaths.join(", ")}`,
-    path,
-    issuePaths
-  };
-}
-function unrecognizedKeyIssues(issues) {
-  return issues.flatMap((issue) => issue.code === "unrecognized_keys" ? [{ keys: issue.keys, path: issue.path.map((segment) => String(segment)) }] : []);
-}
-function hasUnsafeUnrecognizedKey(issues) {
-  return issues.some((issue) => issue.keys.some((key) => isUnsafeObjectKey2(key)));
-}
-function hasTamperedPrototype(value) {
-  if (Array.isArray(value))
-    return value.some((entry) => hasTamperedPrototype(entry));
-  if (!isRecord11(value))
-    return false;
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null)
-    return true;
-  return Object.values(value).some((entry) => hasTamperedPrototype(entry));
-}
-function isRecord11(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function containerAt(record, path) {
-  let container = record;
-  for (const segment of path) {
-    const next = container[segment];
-    if (!isRecord11(next))
-      return null;
-    container = next;
-  }
-  return container;
-}
-function stripUnrecognizedKeys(record, issues) {
-  const stripped = structuredClone(record);
-  const issuePaths = [];
-  for (const issue of issues) {
-    const container = containerAt(stripped, issue.path);
-    if (container === null)
-      continue;
-    for (const key of issue.keys) {
-      delete container[key];
-      issuePaths.push([...issue.path, key].join("."));
-    }
-  }
-  return { issuePaths, stripped };
-}
-function toRecord2(value) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = {};
-  for (const [key, entry] of Object.entries(value)) {
-    record[key] = entry;
-  }
-  return record;
-}
 function readConfigSource(path, scope, fileSystem) {
   if (!fileSystem.existsSync(path)) {
-    return { source: { exists: false, loaded: false, path, scope } };
+    return { diagnostics: [], source: { exists: false, loaded: false, path, scope } };
   }
   let content;
   try {
@@ -70966,68 +71132,23 @@ function readConfigSource(path, scope, fileSystem) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return {
-      diagnostic: { kind: "read", message: `Failed to read ${path}: ${message}`, path },
+      diagnostics: [{ kind: "read", message: `Failed to read ${path}: ${message}`, path }],
       source: { exists: true, loaded: false, path, scope }
     };
   }
   const parsed = parseJsoncSafe2(content);
   if (parsed.errors.length > 0) {
     return {
-      diagnostic: {
+      diagnostics: [{
         kind: "parse",
         message: `JSONC parse error in ${path}: ${parsed.errors.map((error) => error.message).join(", ")}`,
         path
-      },
+      }],
       source: { exists: true, loaded: false, path, scope }
     };
   }
-  if (hasTamperedPrototype(parsed.data)) {
-    return {
-      diagnostic: { kind: "validation", message: `Invalid omo config at ${path}: "__proto__" member is not allowed`, path },
-      source: { exists: true, loaded: false, path, scope }
-    };
-  }
-  const parsedRecord = toRecord2(parsed.data);
-  const validation = OmoConfigLayerSchema.safeParse(parsed.data);
-  if (!validation.success) {
-    const unrecognized = unrecognizedKeyIssues(validation.error.issues);
-    if (hasUnsafeUnrecognizedKey(unrecognized)) {
-      return {
-        diagnostic: validationDiagnostic(path, validation.error.issues),
-        source: { exists: true, loaded: false, path, scope }
-      };
-    }
-    const rejected = {
-      diagnostic: validationDiagnostic(path, validation.error.issues),
-      source: { exists: true, loaded: false, path, scope }
-    };
-    const unknownIssues = unrecognizedKeyIssues(validation.error.issues);
-    if (parsedRecord === null || unknownIssues.length === 0)
-      return rejected;
-    const { issuePaths, stripped } = stripUnrecognizedKeys(parsedRecord, unknownIssues);
-    if (!OmoConfigLayerSchema.safeParse(stripped).success)
-      return rejected;
-    return {
-      diagnostic: {
-        kind: "unknown-keys",
-        message: `Ignored unknown keys in ${path}: ${issuePaths.join(", ")}`,
-        path,
-        issuePaths
-      },
-      source: { exists: true, loaded: true, path, scope },
-      value: stripped
-    };
-  }
-  if (parsedRecord === null) {
-    return {
-      diagnostic: { kind: "validation", message: `Invalid omo config at ${path}: root must be an object`, path },
-      source: { exists: true, loaded: false, path, scope }
-    };
-  }
-  return {
-    source: { exists: true, loaded: true, path, scope },
-    value: parsedRecord
-  };
+  const layer = validateConfigLayer(path, parsed.data);
+  return layer.loaded ? { diagnostics: layer.diagnostics, source: { exists: true, loaded: true, path, scope }, value: layer.value } : { diagnostics: layer.diagnostics, source: { exists: true, loaded: false, path, scope } };
 }
 function legacyCategoryDiagnostic(path, renames) {
   const detail = renames.map((rename) => rename.dropped ? `${rename.path} ignored because ${rename.canonical} is also configured` : `${rename.path} renamed to ${rename.canonical}`).join(", ");
@@ -71062,8 +71183,7 @@ function loadOmoConfig(options = {}) {
   })) {
     const loaded = readConfigSource(candidate.path, candidate.scope, fileSystem);
     sources.push(loaded.source);
-    if (loaded.diagnostic !== undefined)
-      diagnostics.push(loaded.diagnostic);
+    diagnostics.push(...loaded.diagnostics);
     if (loaded.value !== undefined) {
       const canonicalized = canonicalizeLegacyCategoryNames(loaded.value);
       if (canonicalized.renames.length > 0) {
@@ -71086,7 +71206,8 @@ function loadOmoConfig(options = {}) {
     ...options.harness === undefined ? {} : { harness: options.harness },
     ...requestedProfile === undefined ? {} : { profile: requestedProfile }
   });
-  const finalConfig = OmoConfigSchema.safeParse(mergeOmoConfigRecords(DEFAULT_RAW_CONFIG, resolved.config));
+  const finalInput = mergeOmoConfigRecords(DEFAULT_RAW_CONFIG, resolved.config);
+  const finalConfig = OmoConfigSchema.safeParse(finalInput);
   if (finalConfig.success) {
     return {
       config: stripResolutionControlKeys(finalConfig.data),
@@ -71096,9 +71217,22 @@ function loadOmoConfig(options = {}) {
       sources
     };
   }
+  const pruned = pruneInvalidConfigPaths(finalInput, finalConfig.error.issues, (record) => {
+    const parsed = OmoConfigSchema.safeParse(record);
+    return parsed.success ? { success: true } : { success: false, issues: parsed.error.issues };
+  });
+  if (pruned.ok) {
+    return {
+      config: stripResolutionControlKeys(OmoConfigSchema.parse(pruned.config)),
+      diagnostics: [...diagnostics, ...resolved.diagnostics, ...invalidValueDiagnostics(MERGED_OMO_CONFIG_PATH, pruned.dropped)],
+      layers,
+      ...resolved.profile === undefined ? {} : { profile: resolved.profile },
+      sources
+    };
+  }
   return {
     config: stripResolutionControlKeys(OmoConfigSchema.parse(DEFAULT_RAW_CONFIG)),
-    diagnostics: [...diagnostics, ...resolved.diagnostics, validationDiagnostic("(merged omo config)", finalConfig.error.issues)],
+    diagnostics: [...diagnostics, ...resolved.diagnostics, validationDiagnostic(MERGED_OMO_CONFIG_PATH, finalConfig.error.issues)],
     layers,
     ...resolved.profile === undefined ? {} : { profile: resolved.profile },
     sources
@@ -71108,6 +71242,7 @@ var DEFAULT_RAW_CONFIG;
 var init_loader2 = __esm(() => {
   init_main();
   init_schema();
+  init_layer_validation();
   init_merge();
   init_paths();
   init_resolution();
@@ -71122,6 +71257,7 @@ var init_loader2 = __esm(() => {
 
 // packages/omo-config-core/src/loader/index.ts
 var init_loader3 = __esm(() => {
+  init_diagnostic_lines();
   init_disabled_skills();
   init_loader2();
   init_merge();
@@ -71415,6 +71551,97 @@ var init_src4 = __esm(() => {
   init_migration3();
 });
 
+// packages/omo-opencode/src/shared/disabled-providers.ts
+function getModelProvider(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0)
+    return;
+  const provider = model.slice(0, slash).trim();
+  return provider || undefined;
+}
+function isProviderDisabled(model, disabled) {
+  if (!model || disabled.length === 0)
+    return false;
+  const provider = getModelProvider(model);
+  if (provider === undefined)
+    return false;
+  const providerLower = provider.toLowerCase();
+  return disabled.some((entry) => entry.trim().toLowerCase() === providerLower);
+}
+function filterDisabledProviderModels(models, disabled) {
+  if (disabled.length === 0)
+    return [...models];
+  return models.filter((entry) => {
+    const model = typeof entry === "string" ? entry : entry.model;
+    return !isProviderDisabled(model, disabled);
+  });
+}
+function findFirstAllowedReplacement(chain, disabled) {
+  if (!chain)
+    return;
+  for (const entry of chain) {
+    const model = typeof entry === "string" ? entry : entry.model;
+    if (!isProviderDisabled(model, disabled))
+      return model;
+  }
+  return;
+}
+function applyToHolder(label, holder, disabled) {
+  const normalizedChain = normalizeFallbackModels(holder.fallback_models);
+  if (normalizedChain) {
+    const filteredChain = filterDisabledProviderModels(normalizedChain, disabled);
+    if (filteredChain.length !== normalizedChain.length) {
+      log2(`[${HOOK_NAME}] Filtered disabled-provider entries from fallback chain`, {
+        label,
+        removed: normalizedChain.length - filteredChain.length,
+        remaining: filteredChain.length
+      });
+    }
+    holder.fallback_models = filteredChain.length === 0 ? undefined : filteredChain;
+  }
+  if (typeof holder.model === "string" && isProviderDisabled(holder.model, disabled)) {
+    const replacement = findFirstAllowedReplacement(normalizeFallbackModels(holder.fallback_models), disabled);
+    if (replacement) {
+      log2(`[${HOOK_NAME}] Substituted primary model from fallback chain`, {
+        label,
+        from: holder.model,
+        to: replacement
+      });
+      holder.model = replacement;
+    } else {
+      const message = `${label} primary model "${holder.model}" uses a disabled provider and no allowed entry is available in fallback_models. ` + `Either remove the provider from disabled_providers or add an allowed entry to fallback_models.`;
+      addConfigLoadError({ path: `disabled_providers:${label}`, error: message });
+      log2(`[${HOOK_NAME}] ${message}`, { label, primary: holder.model });
+    }
+  }
+}
+function applyDisabledProviders(config) {
+  const disabled = config.disabled_providers ?? [];
+  if (disabled.length === 0)
+    return config;
+  if (config.agents) {
+    for (const [name, agentConfig] of Object.entries(config.agents)) {
+      if (agentConfig && typeof agentConfig === "object") {
+        applyToHolder(`agents.${name}`, agentConfig, disabled);
+      }
+    }
+  }
+  if (config.categories) {
+    for (const [name, categoryConfig] of Object.entries(config.categories)) {
+      if (categoryConfig && typeof categoryConfig === "object") {
+        applyToHolder(`categories.${name}`, categoryConfig, disabled);
+      }
+    }
+  }
+  return config;
+}
+var HOOK_NAME = "disabled-providers";
+var init_disabled_providers = __esm(() => {
+  init_config_errors();
+  init_logger2();
+  init_model_resolver2();
+});
+
 // packages/omo-opencode/src/plugin-config/omo-config-chain.ts
 function block(config) {
   const value = config["[opencode]"];
@@ -71438,11 +71665,11 @@ function baseView(config) {
   }
   return result;
 }
-function appendViews(views, layers, select) {
+function appendViews(views, layers, select, keyPrefix) {
   for (const layer of layers) {
     const config = select(layer.config);
     if (Object.keys(config).length > 0)
-      views.push({ config, path: layer.source.path });
+      views.push({ config, keyPrefix, path: layer.source.path });
   }
 }
 function recordFields(value, fields) {
@@ -71471,10 +71698,21 @@ function modelInput(view) {
   };
 }
 function modelView(view) {
-  const parsed = OmoConfigSchema.safeParse(modelInput(view));
-  if (!parsed.success)
+  const input = modelInput(view);
+  const parsed = OmoConfigSchema.safeParse(input);
+  const modelConfig = parsed.success ? parsed.data : (() => {
+    const pruned = pruneInvalidConfigPaths(input, parsed.error.issues, (record) => {
+      const validation = OmoConfigSchema.safeParse(record);
+      return validation.success ? { success: true } : { success: false, issues: validation.error.issues };
+    });
+    if (!pruned.ok)
+      return;
+    const validation = OmoConfigSchema.safeParse(pruned.config);
+    return validation.success ? validation.data : undefined;
+  })();
+  if (modelConfig === undefined)
     return { config: {}, diagnostics: [] };
-  const resolved = resolveModelReferences(parsed.data);
+  const resolved = resolveModelReferences(modelConfig);
   return {
     config: {
       ...resolved.view.agents === undefined ? {} : { agents: resolved.view.agents },
@@ -71493,14 +71731,15 @@ function loadOmoOpenCodeConfigChain(directory, environment = process.env) {
   });
   const views = [];
   const selectedProfile = loaded.profile;
-  appendViews(views, loaded.layers, baseView);
-  appendViews(views, loaded.layers, block);
-  appendViews(views, loaded.layers, (config) => baseView(profile(config, selectedProfile)));
-  appendViews(views, loaded.layers, (config) => block(profile(config, selectedProfile)));
+  const profilePrefix = selectedProfile === undefined ? "" : `profiles.${selectedProfile}.`;
+  appendViews(views, loaded.layers, baseView, "");
+  appendViews(views, loaded.layers, block, "[opencode].");
+  appendViews(views, loaded.layers, (config) => baseView(profile(config, selectedProfile)), profilePrefix);
+  appendViews(views, loaded.layers, (config) => block(profile(config, selectedProfile)), `${profilePrefix}[opencode].`);
   const resolvedModels = modelView(resolved.config);
   if (Object.keys(resolvedModels.config).length > 0) {
     const source = loaded.layers[0]?.source.path ?? directory;
-    views.push({ config: resolvedModels.config, path: source });
+    views.push({ config: resolvedModels.config, keyPrefix: "", path: source });
   }
   let protectedUserView = {};
   for (const layer of loaded.layers) {
@@ -71595,7 +71834,7 @@ function unknownPaths(schema, value, path) {
   if (def.type === "object" && isPlainRecord2(value) && def.shape !== undefined) {
     const catchall = def.catchall !== undefined && definition(def.catchall).type !== "never" ? def.catchall : undefined;
     return Object.entries(value).flatMap(([key, entry]) => {
-      const propertySchema = def.shape?.[key];
+      const propertySchema = def.shape !== undefined && Object.hasOwn(def.shape, key) ? def.shape[key] : undefined;
       if (propertySchema !== undefined)
         return unknownPaths(propertySchema, entry, [...path, key]);
       if (catchall !== undefined)
@@ -71712,22 +71951,22 @@ var init_fallback_models2 = __esm(() => {
 });
 
 // packages/omo-opencode/src/config/schema/internal/permission.ts
-var PermissionValueSchema, BashPermissionSchema, AgentPermissionSchema;
+var PermissionValueSchema2, BashPermissionSchema2, AgentPermissionSchema;
 var init_permission = __esm(() => {
   init_zod();
-  PermissionValueSchema = _enum(["ask", "allow", "deny"]);
-  BashPermissionSchema = union([
-    PermissionValueSchema,
-    record(string2(), PermissionValueSchema)
+  PermissionValueSchema2 = _enum(["ask", "allow", "deny"]);
+  BashPermissionSchema2 = union([
+    PermissionValueSchema2,
+    record(string2(), PermissionValueSchema2)
   ]);
   AgentPermissionSchema = object({
-    edit: PermissionValueSchema.optional(),
-    bash: BashPermissionSchema.optional(),
-    webfetch: PermissionValueSchema.optional(),
-    task: PermissionValueSchema.optional(),
-    doom_loop: PermissionValueSchema.optional(),
-    external_directory: PermissionValueSchema.optional()
-  }).catchall(PermissionValueSchema.optional());
+    edit: PermissionValueSchema2.optional(),
+    bash: BashPermissionSchema2.optional(),
+    webfetch: PermissionValueSchema2.optional(),
+    task: PermissionValueSchema2.optional(),
+    doom_loop: PermissionValueSchema2.optional(),
+    external_directory: PermissionValueSchema2.optional()
+  }).catchall(PermissionValueSchema2.optional());
 });
 
 // packages/omo-opencode/src/config/schema/agent-overrides.ts
@@ -72491,6 +72730,30 @@ var init_schema2 = __esm(() => {
   init_websearch();
 });
 
+// packages/omo-opencode/src/config/prune-plugin-view.ts
+function prunePluginView(input) {
+  const validation = OhMyOpenCodeConfigSchema.safeParse(input.config);
+  if (validation.success)
+    return { config: input.config, issues: [], warnings: [] };
+  const pruned = pruneInvalidConfigPaths(input.config, validation.error.issues, validatePluginRecord);
+  if (!pruned.ok)
+    return { config: input.config, issues: validation.error.issues, warnings: [] };
+  const file = displayOmoConfigPath(input.path, input.homeDir);
+  return {
+    config: pruned.config,
+    issues: [],
+    warnings: pruned.dropped.map((entry) => `config: ${file}: ${input.keyPrefix}${entry.key} ignored (invalid value)`)
+  };
+}
+var validatePluginRecord = (record) => {
+  const parsed = OhMyOpenCodeConfigSchema.safeParse(record);
+  return parsed.success ? { success: true } : { success: false, issues: parsed.error.issues };
+};
+var init_prune_plugin_view = __esm(() => {
+  init_src4();
+  init_schema2();
+});
+
 // packages/omo-opencode/src/config/validate.ts
 import { relative } from "path";
 function shortPath(configPath) {
@@ -72501,9 +72764,8 @@ function formatIssuePath(path) {
   const formatted = path.map((segment) => String(segment)).join(".");
   return formatted.length > 0 ? formatted : "<root>";
 }
-function schemaMessages(configPath, rawConfig) {
-  const result = OhMyOpenCodeConfigSchema.safeParse(rawConfig);
-  const validationMessages = result.success ? [] : result.error.issues.map((issue) => `${shortPath(configPath)}: ${formatIssuePath(issue.path)}: ${issue.message}`);
+function schemaMessages(configPath, rawConfig, issues) {
+  const validationMessages = issues.map((issue) => `${shortPath(configPath)}: ${formatIssuePath(issue.path)}: ${issue.message}`);
   const unknownKeyMessages = findUnknownKeyPaths(OhMyOpenCodeConfigSchema, rawConfig).map((path) => `${shortPath(configPath)}: Unknown config key: ${formatIssuePath(path)}`);
   return [...validationMessages, ...unknownKeyMessages];
 }
@@ -72519,11 +72781,13 @@ function parseConfig(rawConfig) {
   }
   return config;
 }
-function parseConfigView(path, rawConfig) {
+function parseConfigView(view, homeDir) {
+  const pruned = prunePluginView({ config: view.config, homeDir, keyPrefix: view.keyPrefix, path: view.path });
   return {
-    config: parseConfig(rawConfig),
-    messages: schemaMessages(path, rawConfig),
-    path
+    config: parseConfig(pruned.config),
+    messages: schemaMessages(view.path, view.config, pruned.issues),
+    path: view.path,
+    warnings: pruned.warnings
   };
 }
 function mergeViews(views) {
@@ -72613,27 +72877,36 @@ function migrateRalphLoopConfig(config) {
 }
 function validatePluginConfig(directory, environment = process.env) {
   const chain = loadOmoOpenCodeConfigChain(directory, environment);
-  const views = chain.views.map((view) => parseConfigView(view.path, view.config));
-  const chainMessages = chain.diagnostics.filter((diagnostic) => diagnostic.kind !== "deprecated-keys").map((diagnostic) => `${shortPath(diagnostic.path)}: ${diagnostic.message}`);
+  const homeDir = environment.HOME ?? environment.USERPROFILE;
+  const views = chain.views.map((view) => parseConfigView(view, homeDir));
+  const failing = chain.diagnostics.filter((diagnostic) => diagnostic.kind !== "deprecated-keys" && diagnostic.kind !== "invalid-value");
+  const chainMessages = failing.map((diagnostic) => `${shortPath(diagnostic.path)}: ${diagnostic.message}`);
   const messages = [...chainMessages, ...views.flatMap((view) => view.messages)];
+  const warnings = [
+    ...omoConfigDiagnosticLines(chain.diagnostics.flatMap((diagnostic) => diagnostic.kind === "invalid-value" ? [diagnostic] : []), { homeDir }),
+    ...views.flatMap((view) => view.warnings)
+  ];
   const firstFailingView = views.find((view) => view.messages.length > 0);
   const firstView = views[0];
-  const userConfig = parseConfig(chain.protectedUserView);
+  const userConfig = parseConfig(prunePluginView({ config: chain.protectedUserView, homeDir, keyPrefix: "", path: "" }).config);
   const config = applyDisabledProviders(materializeAgentModelChains(protectUserFields(mergeViews(views), userConfig)));
   warnLegacyUlwExecuteKey(chain.views);
   return {
     valid: messages.length === 0,
     messages,
-    path: chainMessages.length > 0 ? chain.diagnostics[0]?.path ?? null : firstFailingView?.path ?? firstView?.path ?? null,
+    warnings,
+    path: failing[0]?.path ?? firstFailingView?.path ?? firstView?.path ?? null,
     config: migrateRalphLoopConfig(migrateLegacyUlwExecuteKey(config))
   };
 }
 var START_WORK_DEPRECATION_MESSAGE = 'config key "start_work" is deprecated, rename to "ulw_execute" - will be removed next release', deprecationWarningSink;
 var init_validate = __esm(() => {
+  init_src4();
   init_disabled_providers();
   init_logger2();
   init_omo_config_chain();
   init_config_merger();
+  init_prune_plugin_view();
   init_schema2();
   deprecationWarningSink = log2;
 });
@@ -74344,7 +74617,7 @@ init_shared();
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "5.1.4",
+  version: "5.1.6",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -74521,7 +74794,7 @@ var package_default = {
   },
   devDependencies: {
     "@clack/prompts": "^1.8.1",
-    "@code-yeongyu/senpi": "2026.9.29-5",
+    "@code-yeongyu/senpi": "2026.9.30",
     "@modelcontextprotocol/sdk": "^1.30.0",
     "@oh-my-opencode/agents-md-core": "workspace:*",
     "@oh-my-opencode/ast-grep-mcp": "workspace:*",
@@ -74579,18 +74852,18 @@ var package_default = {
     typescript: "^7.0.2"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "5.1.4",
-    "oh-my-opencode-darwin-x64": "5.1.4",
-    "oh-my-opencode-darwin-x64-baseline": "5.1.4",
-    "oh-my-opencode-linux-arm64": "5.1.4",
-    "oh-my-opencode-linux-arm64-musl": "5.1.4",
-    "oh-my-opencode-linux-x64": "5.1.4",
-    "oh-my-opencode-linux-x64-baseline": "5.1.4",
-    "oh-my-opencode-linux-x64-musl": "5.1.4",
-    "oh-my-opencode-linux-x64-musl-baseline": "5.1.4",
-    "oh-my-opencode-windows-arm64": "5.1.4",
-    "oh-my-opencode-windows-x64": "5.1.4",
-    "oh-my-opencode-windows-x64-baseline": "5.1.4"
+    "oh-my-opencode-darwin-arm64": "5.1.6",
+    "oh-my-opencode-darwin-x64": "5.1.6",
+    "oh-my-opencode-darwin-x64-baseline": "5.1.6",
+    "oh-my-opencode-linux-arm64": "5.1.6",
+    "oh-my-opencode-linux-arm64-musl": "5.1.6",
+    "oh-my-opencode-linux-x64": "5.1.6",
+    "oh-my-opencode-linux-x64-baseline": "5.1.6",
+    "oh-my-opencode-linux-x64-musl": "5.1.6",
+    "oh-my-opencode-linux-x64-musl-baseline": "5.1.6",
+    "oh-my-opencode-windows-arm64": "5.1.6",
+    "oh-my-opencode-windows-x64": "5.1.6",
+    "oh-my-opencode-windows-x64-baseline": "5.1.6"
   },
   overrides: {
     hono: "^4.13.8",