@fitchmultz/pi-subagents 0.44.7 → 0.46.0

package/dist/runs/shared/mcp-direct-tool-allowlist.js

@@ -2,8 +2,10 @@ import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { getAgentDir } from "../../shared/utils.js";
-const CACHE_VERSION = 1;
+import { getAgentDir } from "../../shared/agent-dir.js";
+import { Check, ServersSchema, CacheSchema } from "./mcp-config-schema.js";
+import { stableStringify } from "./stable-value.js";
+import { isRecord } from "../../shared/unknown.js";
 const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
 const GENERIC_GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "mcp", "mcp.json");
@@ -14,27 +16,33 @@ const IMPORT_PATHS = {
         path.join(os.homedir(), ".claude.json"),
         path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
     ],
-    "claude-desktop": [path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+    "claude-desktop": [
+        path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
+    ],
     codex: [path.join(os.homedir(), ".codex", "config.json")],
     windsurf: [path.join(os.homedir(), ".windsurf", "mcp.json")],
     vscode: [".vscode/mcp.json"],
 };
 export function resolveMcpDirectToolNames(mcpDirectTools, cwd = process.cwd()) {
-    if (!mcpDirectTools?.length)
+    if (mcpDirectTools === undefined || mcpDirectTools.length === 0) {
         return [];
+    }
     const names = new Set();
     // Keep pre-v5 and independent Fitch configs paired with their own caches.
     for (const directory of ["", "fitch-mcp-adapter"]) {
         try {
             const config = loadMcpConfig(cwd, directory);
             const cache = loadMetadataCache(directory);
-            if (!cache)
+            if (!cache) {
                 continue;
+            }
             for (const name of resolveDirectToolNames(config, cache, getToolPrefix(config.settings?.toolPrefix), mcpDirectTools)) {
                 names.add(name);
             }
         }
-        catch { /* An unavailable adapter does not hide the other adapter's tools. */ }
+        catch {
+            /* An unavailable adapter does not hide the other adapter's tools. */
+        }
     }
     return [...names];
 }
@@ -47,20 +55,15 @@ function loadMetadataCache(directory) {
     catch {
         return null;
     }
-    if (!parsed || typeof parsed !== "object")
-        return null;
-    const raw = parsed;
-    if (raw.version !== CACHE_VERSION || !raw.servers || typeof raw.servers !== "object" || Array.isArray(raw.servers)) {
-        return null;
-    }
-    return raw;
+    return Check(CacheSchema, parsed) ? parsed : null;
 }
 function loadMcpConfig(cwd, directory) {
     let config = { mcpServers: {} };
     for (const sourcePath of getConfigPaths(cwd, directory)) {
         const loaded = readConfig(sourcePath);
-        if (!loaded)
+        if (!loaded) {
             continue;
+        }
         config = mergeConfigs(config, expandImports(loaded, cwd));
     }
     return config;
@@ -70,13 +73,16 @@ function getConfigPaths(cwd, directory) {
     const projectPath = path.resolve(cwd, ".mcp.json");
     const projectPiPath = path.resolve(cwd, ".pi", directory, "mcp.json");
     const sources = [];
-    if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath)
+    if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath) {
         sources.push(GENERIC_GLOBAL_CONFIG_PATH);
+    }
     sources.push(piGlobalPath);
-    if (projectPath !== piGlobalPath)
+    if (projectPath !== piGlobalPath) {
         sources.push(projectPath);
-    if (projectPiPath !== piGlobalPath && projectPiPath !== projectPath)
+    }
+    if (projectPiPath !== piGlobalPath && projectPiPath !== projectPath) {
         sources.push(projectPiPath);
+    }
     return sources;
 }
 function readConfig(configPath) {
@@ -89,35 +95,40 @@ function readConfig(configPath) {
     }
     return validateConfig(parsed);
 }
+function validatedServers(value) {
+    return Check(ServersSchema, value) ? value : {};
+}
 function validateConfig(raw) {
-    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    if (!isRecord(raw)) {
         return { mcpServers: {} };
-    const obj = raw;
-    const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
+    }
+    const settings = isRecord(raw.settings)
+        ? { toolPrefix: getToolPrefix(raw.settings.toolPrefix) }
+        : undefined;
     return {
-        mcpServers: servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {},
-        imports: Array.isArray(obj.imports) ? obj.imports.filter((value) => isImportKind(value)) : undefined,
-        settings: obj.settings && typeof obj.settings === "object" && !Array.isArray(obj.settings)
-            ? obj.settings
-            : undefined,
+        mcpServers: validatedServers(raw.mcpServers ?? raw["mcp-servers"] ?? {}),
+        imports: Array.isArray(raw.imports) ? raw.imports.filter(isImportKind) : undefined,
+        settings,
     };
 }
 function mergeConfigs(base, next) {
     const imports = [...(base.imports ?? []), ...(next.imports ?? [])];
     return {
         mcpServers: { ...base.mcpServers, ...next.mcpServers },
-        imports: imports.length ? [...new Set(imports)] : undefined,
+        imports: imports.length > 0 ? [...new Set(imports)] : undefined,
         settings: next.settings ? { ...base.settings, ...next.settings } : base.settings,
     };
 }
 function expandImports(config, cwd) {
-    if (!config.imports?.length)
+    if (config.imports === undefined || config.imports.length === 0) {
         return config;
-    const importedServers = {};
+    }
+    const importedServers = new Map();
     for (const importKind of config.imports) {
         const importPath = resolveImportPath(importKind, cwd);
-        if (!importPath)
+        if (importPath === null) {
             continue;
+        }
         let imported;
         try {
             imported = JSON.parse(fs.readFileSync(importPath, "utf-8"));
@@ -126,108 +137,125 @@ function expandImports(config, cwd) {
             continue;
         }
         for (const [name, definition] of Object.entries(extractServers(imported, importKind))) {
-            if (!importedServers[name])
-                importedServers[name] = definition;
+            if (!importedServers.has(name)) {
+                importedServers.set(name, definition);
+            }
         }
     }
     return {
         imports: config.imports,
         settings: config.settings,
-        mcpServers: { ...importedServers, ...config.mcpServers },
+        mcpServers: { ...Object.fromEntries(importedServers), ...config.mcpServers },
     };
 }
 function resolveImportPath(importKind, cwd) {
     for (const candidate of IMPORT_PATHS[importKind]) {
         const fullPath = candidate.startsWith(".") ? path.resolve(cwd, candidate) : candidate;
-        if (fs.existsSync(fullPath))
+        if (fs.existsSync(fullPath)) {
             return fullPath;
+        }
     }
     return null;
 }
 function extractServers(config, kind) {
-    if (!config || typeof config !== "object" || Array.isArray(config))
+    if (!isRecord(config)) {
         return {};
-    const obj = config;
+    }
     const servers = kind === "cursor" || kind === "windsurf" || kind === "vscode"
-        ? obj.mcpServers ?? obj["mcp-servers"]
-        : obj.mcpServers;
-    return servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {};
+        ? (config.mcpServers ?? config["mcp-servers"])
+        : config.mcpServers;
+    return validatedServers(servers);
+}
+function cachedNames(cache, exposeResources) {
+    const tools = (cache.tools ?? []).flatMap((tool) => tool.name !== undefined && tool.name !== "" ? [tool.name] : []);
+    if (!exposeResources) {
+        return tools;
+    }
+    const resources = (cache.resources ?? []).flatMap((resource) => {
+        if (resource.name === undefined ||
+            resource.name === "" ||
+            resource.uri === undefined ||
+            resource.uri === "") {
+            return [];
+        }
+        return [`read_${resourceNameToToolName(resource.name)}`];
+    });
+    return [...tools, ...resources];
+}
+function serverDirectNames(input) {
+    const names = [];
+    for (const name of cachedNames(input.cache, input.definition.exposeResources !== false)) {
+        if (input.selection !== true && !input.selection.has(name)) {
+            continue;
+        }
+        if (isToolExcluded(name, input.serverName, input.prefix, input.definition.excludeTools)) {
+            continue;
+        }
+        const prefixed = formatToolName(name, input.serverName, input.prefix);
+        if (!BUILTIN_TOOL_NAMES.has(prefixed)) {
+            names.push(prefixed);
+        }
+    }
+    return names;
 }
 function resolveDirectToolNames(config, cache, defaultPrefix, envOverride) {
     const names = [];
-    const seenNames = new Set();
-    const { servers: selectedServers, tools: selectedTools } = parseSelections(envOverride);
+    const { servers, tools } = parseSelections(envOverride);
     for (const [serverName, definition] of Object.entries(config.mcpServers)) {
-        if (definition.disabled)
-            continue;
         const serverCache = cache.servers[serverName];
-        if (!isServerCacheValid(serverCache, definition))
-            continue;
-        const prefix = definition.toolPrefix ?? defaultPrefix;
-        const toolFilter = selectedServers.has(serverName)
-            ? true
-            : selectedTools.get(serverName);
-        if (!toolFilter)
+        if (definition.disabled === true || !isServerCacheValid(serverCache, definition)) {
             continue;
-        for (const tool of Array.isArray(serverCache.tools) ? serverCache.tools : []) {
-            if (typeof tool?.name !== "string" || !tool.name)
-                continue;
-            if (toolFilter !== true && !toolFilter.has(tool.name))
-                continue;
-            if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools))
-                continue;
-            const prefixedName = formatToolName(tool.name, serverName, prefix);
-            if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName))
-                continue;
-            seenNames.add(prefixedName);
-            names.push(prefixedName);
         }
-        if (definition.exposeResources === false)
+        const selection = servers.has(serverName) ? true : tools.get(serverName);
+        if (selection === undefined) {
             continue;
-        for (const resource of Array.isArray(serverCache.resources) ? serverCache.resources : []) {
-            if (typeof resource?.name !== "string" || !resource.name || typeof resource.uri !== "string" || !resource.uri)
-                continue;
-            const baseName = `read_${resourceNameToToolName(resource.name)}`;
-            if (toolFilter !== true && !toolFilter.has(baseName))
-                continue;
-            if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools))
-                continue;
-            const prefixedName = formatToolName(baseName, serverName, prefix);
-            if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName))
-                continue;
-            seenNames.add(prefixedName);
-            names.push(prefixedName);
         }
+        names.push(...serverDirectNames({
+            serverName,
+            definition,
+            cache: serverCache,
+            prefix: definition.toolPrefix ?? defaultPrefix,
+            selection,
+        }));
     }
-    return names;
+    return [...new Set(names)];
+}
+function parseSelection(item) {
+    const normalized = item.replace(/\/+$/, "");
+    if (!normalized.includes("/")) {
+        return normalized === "" ? undefined : { server: normalized };
+    }
+    const [server = "", tool = ""] = normalized.split("/", 2);
+    if (server === "") {
+        return;
+    }
+    return tool === "" ? { server } : { server, tool };
 }
 function parseSelections(selections) {
     const servers = new Set();
     const tools = new Map();
-    for (let item of selections) {
-        item = item.replace(/\/+$/, "");
-        if (item.includes("/")) {
-            const [server, tool] = item.split("/", 2);
-            if (server && tool) {
-                if (!tools.has(server))
-                    tools.set(server, new Set());
-                tools.get(server).add(tool);
-            }
-            else if (server) {
-                servers.add(server);
-            }
+    for (const item of selections) {
+        const selected = parseSelection(item);
+        if (!selected) {
+            continue;
         }
-        else if (item) {
-            servers.add(item);
+        if (selected.tool === undefined) {
+            servers.add(selected.server);
+            continue;
         }
+        const names = tools.get(selected.server) ?? new Set();
+        names.add(selected.tool);
+        tools.set(selected.server, names);
     }
     return { servers, tools };
 }
 function isServerCacheValid(entry, definition) {
-    if (!entry || entry.configHash !== computeMcpServerHash(definition))
+    if (!entry || entry.configHash !== computeMcpServerHash(definition)) {
         return false;
-    if (!entry.cachedAt || typeof entry.cachedAt !== "number")
+    }
+    if (entry.cachedAt === undefined || entry.cachedAt === 0) {
         return false;
+    }
     return Date.now() - entry.cachedAt <= CACHE_MAX_AGE_MS;
 }
 function computeMcpServerHash(definition) {
@@ -237,7 +265,9 @@ function computeMcpServerHash(definition) {
         socket: resolveConfigPath(definition.socket),
         env: interpolateEnvRecord(definition.env),
         cwd: resolveConfigPath(definition.cwd),
-        url: definition.url ? interpolateEnvVars(definition.url) : definition.url,
+        url: definition.url !== undefined && definition.url !== ""
+            ? interpolateEnvVars(definition.url)
+            : definition.url,
         headers: interpolateEnvRecord(definition.headers),
         auth: definition.auth,
         bearerToken: resolveBearerToken(definition),
@@ -255,21 +285,23 @@ function isImportKind(value) {
     return typeof value === "string" && Object.hasOwn(IMPORT_PATHS, value);
 }
 function getServerPrefix(serverName, mode) {
-    if (mode === "none")
+    if (mode === "none") {
         return "";
+    }
     if (mode === "short") {
         const short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
-        return short || "mcp";
+        return short === "" ? "mcp" : short;
     }
     return serverName.replace(/-/g, "_");
 }
 function formatToolName(toolName, serverName, prefix) {
     const serverPrefix = getServerPrefix(serverName, prefix);
-    return serverPrefix ? `${serverPrefix}_${toolName}` : toolName;
+    return serverPrefix !== "" ? `${serverPrefix}_${toolName}` : toolName;
 }
 function isToolExcluded(toolName, serverName, prefix, excludeTools) {
-    if (!Array.isArray(excludeTools) || excludeTools.length === 0)
+    if (!Array.isArray(excludeTools) || excludeTools.length === 0) {
         return false;
+    }
     const candidates = new Set([
         normalizeToolName(toolName),
         normalizeToolName(formatToolName(toolName, serverName, prefix)),
@@ -288,17 +320,20 @@ function resourceNameToToolName(name) {
         .replace(/^_+/, "")
         .replace(/_+$/, "")
         .toLowerCase();
-    if (!result || /^\d/.test(result))
-        result = `resource${result ? `_${result}` : ""}`;
+    if (result === "" || /^\d/.test(result)) {
+        result = `resource${result !== "" ? `_${result}` : ""}`;
+    }
     return result;
 }
 function interpolateEnvRecord(values) {
-    if (!values || typeof values !== "object" || Array.isArray(values))
+    if (!values || typeof values !== "object" || Array.isArray(values)) {
         return undefined;
+    }
     const resolved = {};
     for (const [key, value] of Object.entries(values)) {
-        if (typeof value === "string")
+        if (typeof value === "string") {
             resolved[key] = interpolateEnvVars(value);
+        }
     }
     return resolved;
 }
@@ -308,27 +343,23 @@ function interpolateEnvVars(value) {
         .replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "");
 }
 function resolveConfigPath(value) {
-    if (typeof value !== "string")
+    if (typeof value !== "string") {
         return undefined;
+    }
     const resolved = interpolateEnvVars(value);
-    if (resolved === "~")
+    if (resolved === "~") {
         return os.homedir();
-    if (resolved.startsWith("~/") || resolved.startsWith("~\\"))
+    }
+    if (resolved.startsWith("~/") || resolved.startsWith("~\\")) {
         return path.join(os.homedir(), resolved.slice(2));
+    }
     return resolved;
 }
 function resolveBearerToken(definition) {
-    if (typeof definition.bearerToken === "string")
+    if (typeof definition.bearerToken === "string") {
         return interpolateEnvVars(definition.bearerToken);
-    return typeof definition.bearerTokenEnv === "string" ? process.env[definition.bearerTokenEnv] : undefined;
-}
-function stableStringify(value) {
-    if (value === null || value === undefined || typeof value !== "object") {
-        const serialized = JSON.stringify(value);
-        return serialized === undefined ? "undefined" : serialized;
-    }
-    if (Array.isArray(value))
-        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
-    const obj = value;
-    return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+    }
+    return typeof definition.bearerTokenEnv === "string"
+        ? process.env[definition.bearerTokenEnv]
+        : undefined;
 }

package/dist/runs/shared/model-fallback.js

@@ -1,39 +1,51 @@
 export function splitThinkingSuffix(model) {
     const colonIdx = model.lastIndexOf(":");
-    if (colonIdx === -1)
+    if (colonIdx === -1) {
         return { baseModel: model, thinkingSuffix: "" };
+    }
     return {
         baseModel: model.substring(0, colonIdx),
         thinkingSuffix: model.substring(colonIdx),
     };
 }
+function preferredModel(matches, provider) {
+    return provider === undefined || provider.length === 0
+        ? undefined
+        : matches.find((entry) => entry.provider === provider);
+}
 export function resolveModelCandidate(model, availableModels, preferredProvider) {
-    if (!model)
+    if (model === undefined || model.length === 0) {
         return undefined;
-    if (model.includes("/"))
+    }
+    if (model.includes("/")) {
         return model;
-    if (!availableModels || availableModels.length === 0)
+    }
+    if (!availableModels || availableModels.length === 0) {
         return model;
+    }
     const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
     const matches = availableModels.filter((entry) => entry.id === baseModel);
-    if (preferredProvider) {
-        const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
-        if (preferredMatch)
-            return `${preferredMatch.fullId}${thinkingSuffix}`;
+    const preferredMatch = preferredModel(matches, preferredProvider);
+    if (preferredMatch) {
+        return `${preferredMatch.fullId}${thinkingSuffix}`;
     }
-    if (matches.length !== 1)
+    if (matches.length !== 1) {
         return model;
-    return `${matches[0].fullId}${thinkingSuffix}`;
+    }
+    const match = matches.at(0);
+    return match === undefined ? model : `${match.fullId}${thinkingSuffix}`;
 }
 export function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider) {
     const seen = new Set();
     const candidates = [];
     for (const raw of [primaryModel, ...(fallbackModels ?? [])]) {
-        if (!raw)
+        if (raw === undefined || raw.length === 0) {
             continue;
+        }
         const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
-        if (!normalized || seen.has(normalized))
+        if (normalized === undefined || normalized.length === 0 || seen.has(normalized)) {
             continue;
+        }
         seen.add(normalized);
         candidates.push(normalized);
     }
@@ -75,8 +87,9 @@ const RETRYABLE_MODEL_FAILURE_PATTERNS = [
     /\b504\b/,
 ];
 export function isRetryableModelFailure(error) {
-    if (!error)
+    if (error === undefined || error.length === 0) {
         return false;
+    }
     return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
 }
 const NON_RECOVERABLE_SAME_MODEL_PATTERNS = [
@@ -119,36 +132,87 @@ const SAME_MODEL_RECOVERY_PATTERNS = [
     /\b504\b/,
 ];
 export function isRecoverableSameModelFailure(error, exitCode) {
-    if (exitCode === 143)
+    if (exitCode === 143) {
         return true;
-    if (!error)
+    }
+    if (error === undefined || error.length === 0) {
         return false;
-    if (NON_RECOVERABLE_SAME_MODEL_PATTERNS.some((pattern) => pattern.test(error)))
+    }
+    if (NON_RECOVERABLE_SAME_MODEL_PATTERNS.some((pattern) => pattern.test(error))) {
         return false;
+    }
     return SAME_MODEL_RECOVERY_PATTERNS.some((pattern) => pattern.test(error));
 }
 export function formatModelAttemptNote(attempt, nextModel) {
-    const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
-    return nextModel
+    const failure = failureDescription(attempt);
+    return nextModel !== undefined && nextModel.length > 0
         ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.`
         : `[fallback] ${attempt.model} failed: ${failure}.`;
 }
 export function formatModelRecoveryAttemptNote(attempt, retryNumber, maxRetries) {
-    const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
+    const failure = failureDescription(attempt);
     return `[retry] ${attempt.model} failed: ${failure}. Retrying same model (${retryNumber}/${maxRetries}).`;
 }
 export function sumAttemptUsage(attempts) {
-    const usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+    const usage = {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        turns: 0,
+    };
     for (const attempt of attempts) {
-        for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"])
+        for (const key of ["input", "output", "cacheRead", "cacheWrite", "cost", "turns"]) {
             usage[key] += attempt.usage?.[key] ?? 0;
-        if (attempt.usage?.contributions?.length)
-            (usage.contributions ??= []).push(...attempt.usage.contributions);
+        }
+        const contributions = attempt.usage?.contributions;
+        if (contributions !== undefined && contributions.length > 0) {
+            (usage.contributions ??= []).push(...contributions);
+        }
     }
     return usage;
 }
+function failureDescription(attempt) {
+    const error = attempt.error?.trim();
+    return error !== undefined && error.length > 0 ? error : `exit ${attempt.exitCode ?? 1}`;
+}
+function successfulAttempt(result) {
+    return (result.exitCode === 0 &&
+        (result.error === undefined || result.error.length === 0) &&
+        result.interrupted !== true);
+}
+function terminalAttempt(result, signal) {
+    return (signal?.aborted === true ||
+        result.resourceLimitExceeded !== undefined ||
+        result.terminalFailure === true ||
+        result.interrupted === true ||
+        result.timedOut === true);
+}
+function summarizeAttempt(model, result) {
+    return {
+        model: model ?? result.model ?? "default",
+        success: successfulAttempt(result),
+        exitCode: result.exitCode,
+        error: result.error,
+        accounting: result.accounting,
+        usage: { ...result.usage },
+    };
+}
+function retryDecision(result, recovery, lastCandidate, signal) {
+    if (terminalAttempt(result, signal) || successfulAttempt(result)) {
+        return "stop";
+    }
+    const recoverable = isRecoverableSameModelFailure(result.error, result.exitCode);
+    if (recoverable && recovery === 0) {
+        return "recover";
+    }
+    return lastCandidate || (!recoverable && !isRetryableModelFailure(result.error))
+        ? "stop"
+        : "fallback";
+}
 export async function runModelAttempts(input) {
-    const candidates = input.candidates.length ? input.candidates : [undefined];
+    const candidates = input.candidates.length > 0 ? input.candidates : [undefined];
     const modelAttempts = [];
     const attemptedModels = [];
     const notes = [];
@@ -156,27 +220,22 @@ export async function runModelAttempts(input) {
     modelLoop: for (let index = 0; index < candidates.length; index++) {
         const model = candidates[index];
         for (let recovery = 0;; recovery++) {
+            // A recovery needs the previous finalized outcome and accumulated notes before it starts.
+            // oxlint-disable-next-line no-await-in-loop
             result = await input.runAttempt(model, notes);
-            if (model)
+            if (model !== undefined && model.length > 0) {
                 attemptedModels.push(model);
-            const attempt = {
-                model: model ?? result.model ?? "default",
-                success: result.exitCode === 0 && !result.error && !result.interrupted,
-                exitCode: result.exitCode,
-                error: result.error,
-                accounting: result.accounting,
-                usage: { ...result.usage },
-            };
+            }
+            const attempt = summarizeAttempt(model, result);
             modelAttempts.push(attempt);
-            if (attempt.success || input.signal?.aborted || result.interrupted || result.timedOut || result.resourceLimitExceeded || result.terminalFailure)
+            const decision = retryDecision(result, recovery, index === candidates.length - 1, input.signal);
+            if (decision === "stop") {
                 break modelLoop;
-            const recoverable = isRecoverableSameModelFailure(result.error, result.exitCode);
-            if (recoverable && recovery === 0) {
+            }
+            if (decision === "recover") {
                 notes.push(formatModelRecoveryAttemptNote(attempt, 1, 1));
                 continue;
             }
-            if ((!recoverable && !isRetryableModelFailure(result.error)) || index === candidates.length - 1)
-                break modelLoop;
             notes.push(formatModelAttemptNote(attempt, candidates[index + 1]));
             break;
         }