@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/shared/model-exclusions.js

@@ -0,0 +1,207 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
+import { TEMP_ROOT_DIR } from "../../shared/types.js";
+export const EXCLUSIONS_PATH_ENV = "PI_MODEL_EXCLUSIONS_PATH";
+let exclusions = [];
+let loaded = false;
+export const DEFAULT_MODEL_EXCLUSION_TTL_MS = 24 * 60 * 60000;
+export const MAX_MODEL_EXCLUSION_TTL_MS = 8000000000000000;
+const MAX_DATE_TIMESTAMP_MS = 8640000000000000;
+let defaultTTLMs = DEFAULT_MODEL_EXCLUSION_TTL_MS;
+let loadedTTLCeilingMs;
+let persistTimer = null;
+let persistSeq = 0;
+export function setDefaultTTL(ms, options) {
+  if (!Number.isFinite(ms) || ms <= 0 || ms > MAX_MODEL_EXCLUSION_TTL_MS) {
+    throw new Error(`Default model exclusion TTL must be a finite positive number no greater than ${MAX_MODEL_EXCLUSION_TTL_MS}.`);
+  }
+  defaultTTLMs = ms;
+  loadedTTLCeilingMs = options?.shortenExisting ? ms : undefined;
+  if (loaded && loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, Date.now()))
+    schedulePersist();
+}
+export function getExclusionsFilePath() {
+  const envPath = process.env[EXCLUSIONS_PATH_ENV];
+  if (typeof envPath === "string" && envPath.trim())
+    return envPath.trim();
+  return path.join(TEMP_ROOT_DIR, "model-exclusions.json");
+}
+export function flushPersist() {
+  const file = getExclusionsFilePath();
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmpPath = `${file}.${process.pid}.${persistSeq++}.tmp`;
+    fs.writeFileSync(tmpPath, JSON.stringify({
+      version: 1,
+      exclusions: deduplicate(exclusions)
+    }, null, 2), "utf-8");
+    fs.renameSync(tmpPath, file);
+  } catch (error) {
+    console.error(`[model-exclusions] Failed to persist exclusions to ${file}:`, error);
+  }
+}
+function schedulePersist() {
+  if (persistTimer)
+    clearTimeout(persistTimer);
+  persistTimer = setTimeout(() => {
+    persistTimer = null;
+    flushPersist();
+  }, 5000);
+  persistTimer.unref?.();
+}
+function ensureLoaded() {
+  if (loaded)
+    return;
+  loaded = true;
+  try {
+    const raw = fs.readFileSync(getExclusionsFilePath(), "utf-8");
+    const data = JSON.parse(raw);
+    if (data.version === 1) {
+      if (!Array.isArray(data.exclusions))
+        throw new Error("Model exclusion store version 1 must contain an exclusions array.");
+      for (let index = 0;index < data.exclusions.length; index++) {
+        const entry = data.exclusions[index];
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+          throw new Error(`Model exclusion store entry ${index} must be an object.`);
+        if (entry.reason !== undefined && typeof entry.reason !== "string")
+          throw new Error(`Model exclusion store entry ${index} has an invalid reason.`);
+        for (const field of ["recordedAt", "expiresAt"]) {
+          const timestamp = entry[field];
+          if (typeof timestamp !== "number" || !Number.isFinite(timestamp) || timestamp <= 0 || timestamp > MAX_DATE_TIMESTAMP_MS) {
+            throw new Error(`Model exclusion store entry ${index} has an invalid ${field}.`);
+          }
+        }
+      }
+      const now = Date.now();
+      exclusions = (data.exclusions ?? []).filter((e) => e.expiresAt > now);
+      const shortened = loadedTTLCeilingMs !== undefined && shortenExclusionsToTTL(exclusions, loadedTTLCeilingMs, now);
+      exclusions = deduplicate(exclusions);
+      if (shortened)
+        schedulePersist();
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`[model-exclusions] Failed to load exclusions from ${getExclusionsFilePath()}:`, error);
+    }
+  }
+}
+function dedupKey(entry) {
+  return `${entry.provider ?? ""}|${entry.modelId ?? ""}`;
+}
+function deduplicate(items) {
+  const map = new Map;
+  for (const entry of items) {
+    const key = dedupKey(entry);
+    const existing = map.get(key);
+    if (!existing || entry.recordedAt > existing.recordedAt) {
+      map.set(key, entry);
+    }
+  }
+  return Array.from(map.values());
+}
+export function recordModelFailure(options) {
+  ensureLoaded();
+  const ttl = options.ttlMs ?? defaultTTLMs;
+  const now = Date.now();
+  const target = options.modelId !== undefined ? { modelId: options.modelId, ...options.provider ? { provider: options.provider } : {} } : { provider: options.provider };
+  const exclusion = {
+    ...target,
+    reason: options.reason ?? "runtime-failure",
+    recordedAt: now,
+    expiresAt: now + ttl
+  };
+  exclusions.unshift(exclusion);
+  exclusions = deduplicate(exclusions);
+  if (exclusions.length > 200)
+    exclusions.length = 200;
+  flushPersist();
+}
+export function clearExpiredExclusions() {
+  ensureLoaded();
+  prune(exclusions, Date.now());
+  schedulePersist();
+}
+export function clearExclusions() {
+  ensureLoaded();
+  exclusions.length = 0;
+  schedulePersist();
+}
+function entryMatches(entry, candidateModelId, candidateProvider, now) {
+  if (entry.expiresAt <= now)
+    return false;
+  if (entry.modelId) {
+    if (entry.modelId !== candidateModelId)
+      return false;
+    return !entry.provider || !candidateProvider || entry.provider === candidateProvider;
+  }
+  return Boolean(entry.provider) && entry.provider === candidateProvider;
+}
+export function isExcluded(modelId, provider) {
+  ensureLoaded();
+  return exclusions.some((entry) => entryMatches(entry, modelId, provider, Date.now()));
+}
+export function findModelExclusion(fullId, now = Date.now()) {
+  ensureLoaded();
+  const { provider, modelId } = parseModelKey(fullId);
+  return exclusions.find((entry) => entryMatches(entry, modelId, provider, now));
+}
+export function getExcludedCount() {
+  ensureLoaded();
+  clearExpiredExclusions();
+  return exclusions.length;
+}
+export function parseModelKey(fullId) {
+  const base = splitKnownThinkingSuffix(fullId).baseModel;
+  if (!base.includes("/"))
+    return { modelId: base };
+  const slash = base.indexOf("/");
+  return { provider: base.slice(0, slash), modelId: base.slice(slash + 1) };
+}
+export function filterFallbackCandidates(candidates, opts) {
+  ensureLoaded();
+  const timestamp = opts?.now ?? Date.now();
+  const seen = new Set;
+  const filtered = [];
+  for (const raw of candidates) {
+    if (!raw || seen.has(raw))
+      continue;
+    const { provider: candidateProvider, modelId: candidateModelId } = parseModelKey(raw);
+    const exclusion = exclusions.find((entry) => entryMatches(entry, candidateModelId, candidateProvider, timestamp));
+    if (exclusion) {
+      opts?.onExcluded?.(raw, exclusion);
+      continue;
+    }
+    seen.add(raw);
+    filtered.push(raw);
+  }
+  return filtered;
+}
+export function reloadFromDisk() {
+  loaded = false;
+  exclusions = [];
+  ensureLoaded();
+}
+function prune(items, now) {
+  let write = 0;
+  for (let i = 0;i < items.length; i++) {
+    const entry = items[i];
+    if (entry.expiresAt > now) {
+      items[write++] = entry;
+    }
+  }
+  items.length = write;
+}
+function shortenExclusionsToTTL(items, ttlMs, now) {
+  let changed = false;
+  for (const entry of items) {
+    const configuredExpiry = entry.recordedAt + ttlMs;
+    if (entry.expiresAt > configuredExpiry) {
+      entry.expiresAt = configuredExpiry;
+      changed = true;
+    }
+  }
+  const previousLength = items.length;
+  prune(items, now);
+  return changed || items.length !== previousLength;
+}

package/extensions/dm-subagents/src/runs/shared/model-fallback.js

@@ -1,14 +1,39 @@
+import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
+import { filterFallbackCandidates, findModelExclusion, parseModelKey, recordModelFailure } from "./model-exclusions.js";
 import { checkModelScope } from "./model-scope.js";
+import { redactSecretValues } from "./permissions.js";
 export function splitThinkingSuffix(model) {
-  const colonIdx = model.lastIndexOf(":");
-  if (colonIdx === -1)
-    return { baseModel: model, thinkingSuffix: "" };
-  return {
-    baseModel: model.substring(0, colonIdx),
-    thinkingSuffix: model.substring(colonIdx)
-  };
+  return splitKnownThinkingSuffix(model);
+}
+export function formatSubagentModelVerificationError(expectedModel, observedModel, availableModels) {
+  if (!availableModels || availableModels.length === 0)
+    return;
+  const expectedBase = splitThinkingSuffix(expectedModel).baseModel;
+  const observedBase = splitThinkingSuffix(observedModel).baseModel;
+  if (expectedBase === observedBase)
+    return;
+  const expectedEntry = availableModels.find((entry) => entry.fullId === expectedBase);
+  if (expectedEntry) {
+    if (expectedEntry.id === observedBase)
+      return;
+    const expectedIdLeaf = expectedEntry.id.slice(expectedEntry.id.lastIndexOf("/") + 1);
+    const expectedFullIdLeaf = expectedEntry.fullId.slice(expectedEntry.fullId.lastIndexOf("/") + 1);
+    if (expectedIdLeaf === observedBase || expectedFullIdLeaf === observedBase)
+      return;
+  }
+  return `model_verification_failed: child reported a different model than the launch candidate. Expected '${expectedModel}' but observed '${observedModel}'.`;
 }
 export const INHERIT_MODEL = "inherit";
+export function normalizeParentModel(model) {
+  if (!model || typeof model !== "object")
+    return;
+  const candidate = model;
+  if (typeof candidate.provider !== "string" || typeof candidate.id !== "string")
+    return;
+  if (!candidate.provider || !candidate.id)
+    return;
+  return { provider: candidate.provider, id: candidate.id };
+}
 export function normalizeModelSegment(segment) {
   return segment.toLowerCase().replace(/[._]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -27,44 +52,56 @@ function stripTrailingDateStamp(segment) {
     return compact[1];
   return segment;
 }
-function resolveBaseModelCandidate(baseModel, availableModels, preferredProvider) {
-  if (baseModel.includes("/")) {
-    const exact = availableModels.find((entry) => entry.fullId === baseModel);
-    if (exact)
-      return exact.fullId;
-  } else {
-    const exactMatches = availableModels.filter((entry) => entry.id === baseModel);
-    if (preferredProvider) {
-      const preferredMatch = exactMatches.find((entry) => entry.provider === preferredProvider);
-      if (preferredMatch)
-        return preferredMatch.fullId;
-    }
-    if (exactMatches.length === 1)
-      return exactMatches[0].fullId;
-  }
-  return fuzzyResolveModel(baseModel, availableModels, preferredProvider);
+function isRegisteredProvider(provider, availableModels) {
+  const normalized = normalizeModelSegment(provider);
+  return availableModels.some((entry) => normalizeModelSegment(entry.provider) === normalized);
 }
-export function fuzzyResolveModel(baseModel, availableModels, preferredProvider) {
-  let queryProvider;
-  let queryIdRaw = baseModel;
+function splitQualifiedModelQuery(baseModel, availableModels) {
   const slashIdx = baseModel.indexOf("/");
   if (slashIdx !== -1) {
-    queryProvider = normalizeModelSegment(baseModel.slice(0, slashIdx));
-    queryIdRaw = baseModel.slice(slashIdx + 1);
-  } else {
-    const providerSeparators = [":", "."];
-    for (const separator of providerSeparators) {
-      const separatorIdx = baseModel.indexOf(separator);
-      if (separatorIdx <= 0)
-        continue;
-      const providerPart = normalizeModelSegment(baseModel.slice(0, separatorIdx));
-      if (!availableModels.some((entry) => normalizeModelSegment(entry.provider) === providerPart))
-        continue;
-      queryProvider = providerPart;
-      queryIdRaw = baseModel.slice(separatorIdx + 1);
-      break;
+    const providerPart = baseModel.slice(0, slashIdx);
+    if (isRegisteredProvider(providerPart, availableModels)) {
+      return { queryProvider: normalizeModelSegment(providerPart), queryIdRaw: baseModel.slice(slashIdx + 1) };
     }
+    return { queryIdRaw: baseModel };
+  }
+  const providerSeparators = [":", "."];
+  for (const separator of providerSeparators) {
+    const separatorIdx = baseModel.indexOf(separator);
+    if (separatorIdx <= 0)
+      continue;
+    const providerPart = baseModel.slice(0, separatorIdx);
+    if (!isRegisteredProvider(providerPart, availableModels))
+      continue;
+    return { queryProvider: normalizeModelSegment(providerPart), queryIdRaw: baseModel.slice(separatorIdx + 1) };
   }
+  return { queryIdRaw: baseModel };
+}
+function resolveExactIdMatches(baseModel, availableModels, preferredProvider) {
+  const exactMatches = availableModels.filter((entry) => entry.id === baseModel);
+  if (preferredProvider) {
+    const preferredMatch = exactMatches.find((entry) => entry.provider === preferredProvider);
+    if (preferredMatch)
+      return preferredMatch.fullId;
+  }
+  if (exactMatches.length === 1)
+    return exactMatches[0].fullId;
+  return;
+}
+function resolveBaseModelCandidate(baseModel, availableModels, preferredProvider) {
+  const exact = availableModels.find((entry) => entry.fullId === baseModel);
+  if (exact)
+    return exact.fullId;
+  const { queryProvider } = splitQualifiedModelQuery(baseModel, availableModels);
+  if (queryProvider === undefined) {
+    const exactId = resolveExactIdMatches(baseModel, availableModels, preferredProvider);
+    if (exactId)
+      return exactId;
+  }
+  return fuzzyResolveModel(baseModel, availableModels, preferredProvider);
+}
+export function fuzzyResolveModel(baseModel, availableModels, preferredProvider) {
+  const { queryProvider, queryIdRaw } = splitQualifiedModelQuery(baseModel, availableModels);
   const queryId = normalizeModelSegment(queryIdRaw);
   const queryIdNoDate = stripTrailingDateStamp(queryId);
   const candidates = availableModels.filter((entry) => {
@@ -103,30 +140,102 @@ export function resolveModelCandidate(model, availableModels, preferredProvider)
     return `${resolvedBase}${thinkingSuffix}`;
   return model;
 }
+function resolveSubagentModelCandidate(model, availableModels, preferredProvider) {
+  if (!availableModels || availableModels.length === 0)
+    return model;
+  const resolvedWhole = resolveBaseModelCandidate(model, availableModels, preferredProvider);
+  if (resolvedWhole)
+    return resolvedWhole;
+  const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+  const resolvedBase = thinkingSuffix ? resolveBaseModelCandidate(baseModel, availableModels, preferredProvider) : undefined;
+  return resolvedBase ? `${resolvedBase}${thinkingSuffix}` : undefined;
+}
+function suggestAlternateProviderModel(model, availableModels) {
+  if (!availableModels || availableModels.length === 0)
+    return;
+  const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+  const { queryProvider, queryIdRaw } = splitQualifiedModelQuery(baseModel, availableModels);
+  if (queryProvider === undefined)
+    return;
+  const suggestion = resolveBaseModelCandidate(queryIdRaw, availableModels);
+  if (!suggestion)
+    return;
+  const matched = availableModels.find((entry) => entry.fullId === suggestion);
+  if (!matched || normalizeModelSegment(matched.provider) === queryProvider)
+    return;
+  return `${suggestion}${thinkingSuffix}`;
+}
+function resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider) {
+  const resolved = resolveSubagentModelCandidate(model, availableModels, preferredProvider);
+  if (resolved)
+    return resolved;
+  const suggestion = suggestAlternateProviderModel(model, availableModels);
+  throw new Error(`Unknown subagent model '${model}' in the active DM model registry.${suggestion ? ` Did you mean '${suggestion}'?` : ""}`);
+}
 function defaultScopeWarn(violation) {
   console.warn(`[dm-subagents] ${violation.message}`);
 }
+function configuredScopes(scope) {
+  return scope ? Array.isArray(scope) ? scope : [scope] : [];
+}
+function throwForUnresolvedEnforcedInheritScope(scope, includeMixed = false) {
+  const unresolvedInheritScope = configuredScopes(scope).find((entry) => entry.enforce === true && (includeMixed ? entry.allow?.includes(INHERIT_MODEL) : entry.allow?.length === 1 && entry.allow[0] === INHERIT_MODEL));
+  if (!unresolvedInheritScope)
+    return;
+  const origin = unresolvedInheritScope.origin ?? "modelScope";
+  throw new Error(`Cannot enforce subagent model scope (${origin}): 'inherit' requires a current parent session model.`);
+}
+function enforceModelScopes(model, scope, source, onWarn) {
+  const violations = configuredScopes(scope).map((entry) => checkModelScope(model, entry, source)).filter((violation) => violation !== undefined);
+  const error = violations.find((violation) => violation.severity === "error");
+  if (error)
+    throw new Error(error.message);
+  for (const violation of violations)
+    (onWarn ?? defaultScopeWarn)(violation);
+}
+function throwForExplicitModelExclusion(model) {
+  const exclusion = findModelExclusion(model);
+  if (!exclusion)
+    return;
+  const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
+  const expiry = Number.isFinite(exclusion.expiresAt) ? `; expires: ${new Date(exclusion.expiresAt).toISOString()}` : "";
+  throw new Error(`Requested subagent model '${model}' is excluded and cannot be replaced by a fallback (reason: ${reason}${expiry}).`);
+}
 export function resolveSubagentModelOverride(requestedModel, parentModel, availableModels, preferredProvider, options) {
   const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
   const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
+  if (!parentModel)
+    throwForUnresolvedEnforcedInheritScope(options?.scope, explicit === undefined || options?.source === "inherited");
   let resolved;
   if (explicit === undefined) {
     resolved = parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
   } else {
-    resolved = resolveModelCandidate(explicit, availableModels, preferredProvider);
+    resolved = resolveRequiredSubagentModelCandidate(explicit, availableModels, preferredProvider);
   }
-  if (resolved && options?.scope?.enforce) {
+  if (resolved && explicit !== undefined && options?.source === "explicit") {
+    throwForExplicitModelExclusion(resolved);
+  }
+  if (resolved && options?.scope) {
     const source = explicit === undefined ? "inherited" : options.source ?? "inherited";
-    const violation = checkModelScope(resolved, options.scope, source);
-    if (violation) {
-      if (violation.severity === "error")
-        throw new Error(violation.message);
-      (options.onWarn ?? defaultScopeWarn)(violation);
-    }
+    enforceModelScopes(resolved, options.scope, source, options.onWarn);
   }
   return resolved;
 }
+export function resolveEffectiveSubagentModel(explicitModel, agentModel, parentModel, availableModels, preferredProvider, options) {
+  const source = options?.source ?? (explicitModel !== undefined ? "explicit" : "inherited");
+  const resolved = resolveSubagentModelOverride(explicitModel ?? agentModel, parentModel, availableModels, preferredProvider, { ...options, source });
+  if (resolved || explicitModel === undefined)
+    return resolved;
+  return resolveSubagentModelOverride(agentModel, parentModel, availableModels, preferredProvider, { ...options, source: options?.source ?? "inherited" });
+}
+export function inheritsParentModel(explicitModel, agentModel, parentModel) {
+  const requestedModel = explicitModel ?? agentModel;
+  const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
+  return Boolean(parentModel && (!trimmed || trimmed === INHERIT_MODEL));
+}
 export function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider, options) {
+  if (!primaryModel)
+    throwForUnresolvedEnforcedInheritScope(options?.scope, true);
   const seen = new Set;
   const candidates = [];
   const rawCandidates = [primaryModel, ...fallbackModels ?? []];
@@ -134,21 +243,31 @@ export function buildModelCandidates(primaryModel, fallbackModels, availableMode
     const raw = rawCandidates[index];
     if (!raw)
       continue;
-    const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
-    if (!normalized || seen.has(normalized))
+    const model = raw.trim();
+    const normalized = index === 0 ? options?.primaryModelFromParent ? model : resolveRequiredSubagentModelCandidate(model, availableModels, preferredProvider) : resolveSubagentModelCandidate(model, availableModels, preferredProvider);
+    if (!normalized) {
+      console.warn(`[dm-subagents] Skipping fallback model '${model}' because it is unavailable in this environment.`);
       continue;
-    if (index > 0 && options?.scope?.enforce) {
-      const violation = checkModelScope(normalized, options.scope, "inherited");
-      if (violation)
-        (options.onWarn ?? defaultScopeWarn)(violation);
+    }
+    if (seen.has(normalized))
+      continue;
+    const scopes = configuredScopes(options?.scope);
+    if (index > 0 || scopes.some((scope) => scope.enforce === true && scope.strict === true)) {
+      enforceModelScopes(normalized, scopes, "inherited", options?.onWarn);
     }
     seen.add(normalized);
     candidates.push(normalized);
   }
-  return candidates;
+  return filterFallbackCandidates(candidates, {
+    onExcluded(candidate, exclusion) {
+      const reason = redactSecretValues((exclusion.reason ?? "runtime-failure").replace(/[\u0000-\u001f\u007f]+/g, " ")).slice(0, 240);
+      console.warn(`[dm-subagents] Skipping model '${candidate}' due to a cached exclusion (reason: ${reason}; expires: ${new Date(exclusion.expiresAt).toISOString()}).`);
+    }
+  });
 }
 const RETRYABLE_MODEL_FAILURE_PATTERNS = [
   /rate\s*limit/i,
+  /usage\s*limit/i,
   /too many requests/i,
   /\b429\b/,
   /quota/i,
@@ -168,26 +287,77 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
   /overloaded/i,
   /service unavailable/i,
   /temporar(?:ily)? unavailable/i,
+  /connection\s+(?:error|reset|closed|aborted)/i,
   /connection refused/i,
   /fetch failed/i,
   /network error/i,
   /socket hang up/i,
+  /stream ended without finish_reason/i,
   /upstream/i,
   /timed? out/i,
   /timeout/i,
+  /\b500\b/,
   /\b502\b/,
   /\b503\b/,
   /\b504\b/,
+  /internal server error/i,
   /cold.?start/i,
   /empty response/i,
   /no output/i,
   /model.*(?:load|fail|error)/i
 ];
+const TOOL_FAILURE_PREFIX = /^[\w.:@/-]+ failed (?:(?:\(exit \d+\):)|(?:with exit code \d+))(?:\s|$)/i;
 export function isRetryableModelFailure(error) {
   if (!error)
     return false;
+  if (TOOL_FAILURE_PREFIX.test(error.trim()))
+    return false;
   return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
 }
+function messageError(message) {
+  if (!message || typeof message !== "object")
+    return;
+  const value = message.errorMessage;
+  return typeof value === "string" ? value : undefined;
+}
+export function isRetryableModelFailureAttempt(input) {
+  if (!isRetryableModelFailure(input.error))
+    return false;
+  if ((input.toolCount ?? 0) > 0)
+    return false;
+  if (input.error === "Subagent produced no output (possible model cold-start or empty response)." || /^Subagent produced no output after terminal assistant stopReason "[^"]+"\.$/.test(input.error ?? ""))
+    return true;
+  if ((input.toolCount ?? 0) === 0 && (input.messages?.length ?? 0) === 0)
+    return true;
+  const error = input.error?.trim();
+  return Boolean(error && input.messages?.some((message) => messageError(message)?.trim() === error));
+}
+export function recordRetryableModelFailure(model, error) {
+  if (!model || !isRetryableModelFailure(error))
+    return;
+  const { provider, modelId } = parseModelKey(model);
+  recordModelFailure({ modelId, reason: error, ...provider ? { provider } : {} });
+}
+const CONTEXT_OVERFLOW_PATTERNS = [
+  /context(?: length| window| limit)? (?:exceed|overflow|too long)/i,
+  /maximum context length/i,
+  /too many tokens/i,
+  /token limit/i,
+  /context_length_exceeded/i,
+  /length_required/i,
+  /maximum.*tokens/i,
+  /prompt.*too long/i,
+  /input.*too long/i,
+  /exceeded.*context/i,
+  /context.*overflow/i
+];
+export function isContextOverflow(error) {
+  if (!error)
+    return false;
+  if (TOOL_FAILURE_PREFIX.test(error.trim()))
+    return false;
+  return CONTEXT_OVERFLOW_PATTERNS.some((pattern) => pattern.test(error));
+}
 export function formatModelAttemptNote(attempt, nextModel) {
   const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
   return nextModel ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.` : `[fallback] ${attempt.model} failed: ${failure}.`;