min-agent 0.3.0 → 0.4.0

package/dist/sessions.js

@@ -1,12 +1,40 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, openSync, readSync, closeSync, statSync, } from "fs";
+import { readFileSync, mkdirSync, existsSync, readdirSync, unlinkSync, openSync, readSync, closeSync, statSync, } from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
+import { atomicWriteFileSync } from "./tools/atomic-file.js";
 import { getConfigDir } from "./config.js";
 import { generateTitle } from "./title-gen.js";
 import { isSyntheticMessage } from "./synthetic.js";
+import { parseTaskState } from "./tools/todo.js";
 function getSessionsDir() {
     return path.join(getConfigDir(), "sessions");
 }
+/**
+ * In-process per-session mutex serializing read-modify-write cycles
+ * (load → append → run → save) so concurrent requests on the same session
+ * cannot lose messages. Cross-process safety is NOT provided.
+ */
+const sessionLocks = new Map();
+export async function withSessionLock(sessionId, fn) {
+    if (!sessionId)
+        return fn();
+    const prev = sessionLocks.get(sessionId) ?? Promise.resolve();
+    let release;
+    const ours = new Promise((r) => {
+        release = r;
+    });
+    const chained = prev.then(() => ours);
+    sessionLocks.set(sessionId, chained);
+    await prev;
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+        if (sessionLocks.get(sessionId) === chained)
+            sessionLocks.delete(sessionId);
+    }
+}
 /** Session ids are UUIDs; a strict whitelist blocks path traversal via `/v1/sessions/..%2F..%2Fconfig`. */
 const SESSION_ID_RE = /^[a-zA-Z0-9_-]+$/;
 function sessionPath(id) {
@@ -81,7 +109,10 @@ function generateId() {
 function textOfContent(content) {
     if (typeof content === "string")
         return content;
-    return content.map((p) => (p.type === "text" ? p.text : "")).join(" ").trim();
+    return content
+        .map((p) => (p.type === "text" ? p.text : ""))
+        .join(" ")
+        .trim();
 }
 function deriveTitle(messages) {
     const first = messages.find((m) => m.role === "user");
@@ -118,23 +149,26 @@ export function sanitizeForStorage(messages) {
         return { ...msg, content };
     });
 }
-export function saveSession(messages, existingId, title, created) {
+export function saveSession(messages, existingId, title, created, taskState) {
     const dir = getSessionsDir();
     mkdirSync(dir, { recursive: true });
     const id = existingId && SESSION_ID_RE.test(existingId) ? existingId : generateId();
     const now = new Date().toISOString();
-    const existing = existingId ? readMeta(id) : null;
+    const existingMeta = existingId ? readMeta(id) : null;
+    const preservedState = taskState === undefined && existingId ? loadSession(id)?.taskState : undefined;
+    const resolvedState = taskState ?? preservedState;
     const data = {
         meta: {
             id,
-            title: title ?? existing?.title ?? deriveTitle(messages),
-            created: created ?? existing?.created ?? now,
+            title: title ?? existingMeta?.title ?? deriveTitle(messages),
+            created: created ?? existingMeta?.created ?? now,
             updated: now,
             messageCount: messages.length,
         },
+        ...(resolvedState ? { taskState: resolvedState } : {}),
         messages: sanitizeForStorage(messages),
     };
-    writeFileSync(sessionPath(id), JSON.stringify(data, null, 2), "utf-8");
+    atomicWriteFileSync(sessionPath(id), JSON.stringify(data, null, 2));
     return id;
 }
 /** Read only the meta head to recover the original created/title. */
@@ -165,12 +199,22 @@ export function loadSession(id) {
     if (!existsSync(file))
         return null;
     try {
-        return JSON.parse(readFileSync(file, "utf-8"));
+        const data = JSON.parse(readFileSync(file, "utf-8"));
+        const taskState = parseTaskState(data.taskState);
+        return taskState ? { ...data, taskState } : data;
     }
     catch {
         return null;
     }
 }
+export function loadExecHistory(resumeSessionId) {
+    if (!resumeSessionId)
+        return { ok: true, messages: [], sessionId: undefined };
+    const session = loadSession(resumeSessionId);
+    if (!session)
+        return { ok: false, error: `会话不存在: ${resumeSessionId}` };
+    return { ok: true, messages: [...session.messages], sessionId: resumeSessionId, taskState: session.taskState };
+}
 export function listSessions() {
     const dir = getSessionsDir();
     if (!existsSync(dir))
@@ -212,7 +256,7 @@ export function renameSession(id, title) {
         const data = JSON.parse(readFileSync(file, "utf-8"));
         data.meta.title = title;
         data.meta.updated = new Date().toISOString();
-        writeFileSync(file, JSON.stringify(data, null, 2), "utf-8");
+        atomicWriteFileSync(file, JSON.stringify(data, null, 2));
         return true;
     }
     catch {

package/dist/skills.js

@@ -2,9 +2,26 @@ import { tool, jsonSchema } from "ai";
 import { readFileSync, existsSync, readdirSync, realpathSync } from "fs";
 import os from "os";
 import path from "path";
+import { fileURLToPath } from "url";
 import { globSync } from "glob";
 import { loadConfig, saveConfig, loadProjectConfig, saveProjectConfig } from "./config.js";
 import { truncateToolOutput } from "./tool-output.js";
+/** Packaged self-management skill; keep this name in sync with `skills/self-config/SKILL.md`. */
+export const SELF_CONFIG_SKILL = "self-config";
+function getPackageRoot() {
+    return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+}
+export function getBuiltinSkillsDir() {
+    return path.join(getPackageRoot(), "skills");
+}
+function builtinSkillsAllowed() {
+    const value = process.env.MIN_AGENT_NO_BUILTIN_SKILLS?.trim().toLowerCase();
+    return value !== "1" && value !== "true";
+}
+function isUnderDir(root, filePath) {
+    const rel = path.relative(root, filePath);
+    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
 /** Coerce a config skill list to an array of names, tolerating hand-edited configs. */
 function skillNames(value) {
     return Array.isArray(value) ? value.filter((n) => typeof n === "string") : [];
@@ -48,7 +65,8 @@ const SKILL_CONTENT_MAX_BYTES = 32 * 1024;
  * Skill scan order: later entries win on duplicate `name` in frontmatter.
  * Global user skills first, then project-local dirs so repo skills override ~/.agents.
  * Computed lazily so process.cwd() changes are respected.
- * `MIN_AGENT_SKILLS_DIRS` (path-delimiter separated) replaces the default list.
+ * `MIN_AGENT_SKILLS_DIRS` (path-delimiter separated) replaces the default user list.
+ * Packaged skills are scanned separately and win on name.
  */
 function getSkillDirs() {
     const override = process.env.MIN_AGENT_SKILLS_DIRS?.trim();
@@ -107,21 +125,32 @@ export function scanSkillDir(dir, warn = stderrWarn) {
     }
     return [...byName.values()];
 }
+function mergeSkill(next, skill, warn) {
+    const previous = next[skill.name];
+    if (previous && sameFile(previous.location, skill.location)) {
+        if (skill.builtin && !previous.builtin)
+            next[skill.name] = { ...previous, builtin: true };
+        return;
+    }
+    if (previous) {
+        const versionNote = previous.version && skill.version && previous.version !== skill.version
+            ? ` (version ${previous.version} → ${skill.version})`
+            : "";
+        warn?.(`\x1b[33m  ⚠ Duplicate skill "${skill.name}": ${skill.location} overrides ${previous.location}${versionNote}\x1b[0m`);
+    }
+    next[skill.name] = skill;
+}
 export function discoverSkills(opts) {
     const warn = opts?.silent ? null : stderrWarn;
     const next = {};
     for (const dir of getSkillDirs()) {
-        for (const skill of scanSkillDir(dir, warn)) {
-            const previous = next[skill.name];
-            if (previous && sameFile(previous.location, skill.location))
-                continue;
-            if (previous) {
-                const versionNote = previous.version && skill.version && previous.version !== skill.version
-                    ? ` (version ${previous.version} → ${skill.version})`
-                    : "";
-                warn?.(`\x1b[33m  ⚠ Duplicate skill "${skill.name}": ${skill.location} overrides ${previous.location}${versionNote}\x1b[0m`);
-            }
-            next[skill.name] = skill;
+        for (const skill of scanSkillDir(dir, warn))
+            mergeSkill(next, skill, warn);
+    }
+    if (builtinSkillsAllowed()) {
+        const builtinDir = getBuiltinSkillsDir();
+        for (const skill of scanSkillDir(builtinDir, warn)) {
+            mergeSkill(next, { ...skill, builtin: isUnderDir(builtinDir, skill.location) }, warn);
         }
     }
     const state = resolveSkillState();
@@ -231,7 +260,9 @@ function readRequiredBins(frontmatter) {
 function parseSkillFile(filePath, warn) {
     let raw;
     try {
-        raw = readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
+        raw = readFileSync(filePath, "utf-8")
+            .replace(/^\uFEFF/, "")
+            .replace(/\r\n/g, "\n");
     }
     catch (err) {
         warn?.(`\x1b[33m  ⚠ Skill skipped (unreadable): ${filePath} — ${err.message}\x1b[0m`);
@@ -259,8 +290,17 @@ function parseSkillFile(filePath, warn) {
         allowedTools: readFrontmatterList(frontmatter, "allowed-tools"),
         requiredBins: readRequiredBins(frontmatter),
         version: readFrontmatterValue(frontmatter, "version") ?? undefined,
+        builtin: false,
+        alwaysLoad: readFrontmatterBool(frontmatter, "always-load"),
     };
 }
+function readFrontmatterBool(frontmatter, key) {
+    const raw = readFrontmatterValue(frontmatter, key);
+    if (raw == null)
+        return false;
+    const value = raw.trim().toLowerCase();
+    return value === "true" || value === "yes" || value === "1";
+}
 /** Every discovered skill, disabled ones included (`enabled` reflects config). */
 export function getAllSkills() {
     const state = resolveSkillState();
@@ -386,7 +426,9 @@ export function buildSkillContent(skill) {
             ? [
                 "<skill_files>",
                 ...entries.map((f) => `  <file>${escapeXml(f)}</file>`),
-                total > entries.length ? `  <note>${total - entries.length} more entries not listed; use glob on the base directory</note>` : "",
+                total > entries.length
+                    ? `  <note>${total - entries.length} more entries not listed; use glob on the base directory</note>`
+                    : "",
                 "</skill_files>",
             ]
                 .filter(Boolean)
@@ -418,7 +460,9 @@ export function getSkillsTool(tracker = new Set()) {
         }),
         execute: async ({ name }) => {
             const state = resolveSkillState();
-            const available = Object.keys(loadedSkills).filter((n) => !state.disabled.has(n)).sort();
+            const available = Object.keys(loadedSkills)
+                .filter((n) => !state.disabled.has(n))
+                .sort();
             if (state.disabled.has(name)) {
                 return `Skill "${name}" is disabled (${state.scopeOf.get(name)} scope). Available skills: ${available.join(", ") || "none"}`;
             }
@@ -455,9 +499,13 @@ function unescapeXmlAttr(value) {
 export function buildSkillsPrompt(skills) {
     if (skills.length === 0)
         return "";
+    const hasAlwaysLoad = skills.some((s) => s.alwaysLoad);
     return [
         "Skills provide specialized instructions and workflows for specific tasks.",
         "Use the skill tool to load a skill when a task matches its description.",
+        hasAlwaysLoad
+            ? "Skills with always_load already have their full instructions in this prompt. Do not call the skill tool for those unless compaction dropped them."
+            : "",
         "",
         "<available_skills>",
         ...skills.flatMap((s) => [
@@ -465,10 +513,14 @@ export function buildSkillsPrompt(skills) {
             `    <name>${escapeXml(s.name)}</name>`,
             `    <description>${escapeXml(s.description)}</description>`,
             `    <location>${escapeXml(s.location)}</location>`,
+            s.alwaysLoad ? "    <always_load>true</always_load>" : "",
+            s.builtin ? "    <builtin>true</builtin>" : "",
             "  </skill>",
         ]),
         "</available_skills>",
-    ].join("\n");
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
 }
 const SKILL_CONTENT_MARKER = /<skill_content name="([^"]*)"/g;
 function textOf(part) {
@@ -530,6 +582,18 @@ export function attachSkills(tools, tracker) {
     const skills = getSkills();
     if (skills.length === 0)
         return "";
-    tools["skill"] = getSkillsTool(tracker);
-    return buildSkillsPrompt(skills);
+    const loadTracker = tracker ?? new Set();
+    const auto = skills.filter((s) => s.alwaysLoad);
+    for (const skill of auto)
+        loadTracker.add(skill.name);
+    tools.skill = getSkillsTool(loadTracker);
+    const catalog = buildSkillsPrompt(skills);
+    if (auto.length === 0)
+        return catalog;
+    return [
+        catalog,
+        "",
+        "The following skills are already loaded for this conversation. Follow them without calling the skill tool again.",
+        ...auto.map(buildSkillContent),
+    ].join("\n");
 }

package/dist/title-gen.js

@@ -16,7 +16,10 @@ export async function generateTitle(model, messages) {
     const userContent = typeof userMsg.content === "string"
         ? userMsg.content
         : Array.isArray(userMsg.content)
-            ? userMsg.content.filter((p) => "text" in p).map((p) => p.text ?? "").join(" ")
+            ? userMsg.content
+                .filter((p) => "text" in p)
+                .map((p) => p.text ?? "")
+                .join(" ")
             : "";
     if (!userContent.trim())
         return null;
@@ -40,7 +43,10 @@ export async function generateTitle(model, messages) {
             temperature: 0.5,
             maxOutputTokens: 30,
         });
-        const title = result.text.trim().replace(/^["']|["']$/g, "").slice(0, 60);
+        const title = result.text
+            .trim()
+            .replace(/^["']|["']$/g, "")
+            .slice(0, 60);
         return title || null;
     }
     catch {

package/dist/token-display.js

@@ -0,0 +1,36 @@
+export function formatTokenCount(n) {
+    const v = Math.max(0, Math.round(n));
+    if (v < 1000)
+        return String(v);
+    if (v < 100_000)
+        return `${(v / 1000).toFixed(1).replace(/\.0$/, "")}k`;
+    if (v < 1_000_000)
+        return `${Math.round(v / 1000)}k`;
+    if (v < 10_000_000)
+        return `${(v / 1_000_000).toFixed(1).replace(/\.0$/, "")}M`;
+    return `${Math.round(v / 1_000_000)}M`;
+}
+export function contextUsagePercent(context, contextWindow) {
+    if (context <= 0 || contextWindow <= 0)
+        return null;
+    return Math.round((context / contextWindow) * 100);
+}
+export function tokenInfoFromTracker(tracker, contextWindow, estimatedContext = 0) {
+    return {
+        context: tracker.lastInputTokens > 0 ? tracker.lastInputTokens : estimatedContext,
+        input: tracker.totalInputTokens,
+        output: tracker.totalOutputTokens,
+        contextWindow,
+    };
+}
+export function formatTokenStatusLabel(info) {
+    const parts = [];
+    const pct = contextUsagePercent(info.context, info.contextWindow);
+    if (pct != null) {
+        parts.push(`${formatTokenCount(info.context)}/${formatTokenCount(info.contextWindow)} ${pct}%`);
+    }
+    if (info.input > 0 || info.output > 0) {
+        parts.push(`累计 ${formatTokenCount(info.input)} in · ${formatTokenCount(info.output)} out`);
+    }
+    return parts.join(" · ");
+}

package/dist/tool-display.js

@@ -159,6 +159,11 @@ export function summarizeToolResult(toolName, output, isError = false, maxLen =
             return `${found[1]} results`;
         if (/^No search results found/m.test(text))
             return "no results";
+        const titles = text.match(/^\d+\.\s+Title\s*:/gm);
+        if (titles && titles.length > 0)
+            return `${titles.length} results`;
+        if (/^Search results for /m.test(text))
+            return "results";
     }
     if (toolName === "skill") {
         const loaded = /^<skill_content name="([^"]*)"/m.exec(text);

package/dist/tool-output.js

@@ -121,8 +121,6 @@ export function truncateToolOutput(text, options = {}) {
     const filePath = writeFullToolOutput(text);
     const pv = preview(text, maxLines, maxBytes, direction, lines, totalBytes);
     const header = "...output truncated...\n\n";
-    const content = direction === "tail"
-        ? `${header}${hint(filePath)}\n\n${pv.text}`
-        : `${pv.text}\n\n${header}${hint(filePath)}`;
+    const content = direction === "tail" ? `${header}${hint(filePath)}\n\n${pv.text}` : `${pv.text}\n\n${header}${hint(filePath)}`;
     return { content, truncated: true, outputPath: filePath };
 }

package/dist/tools/apply_patch.js

@@ -1,7 +1,10 @@
 import { tool, jsonSchema } from "ai";
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { readFileSync, existsSync } from "fs";
+import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
 import path from "path";
-import { confirm, isAutoApprove } from "../confirm.js";
+import { confirm, isEditAutoApprove } from "../confirm.js";
+import { pathAccessError } from "../sandbox.js";
+import { atomicWriteFile, tempPathFor } from "./atomic-file.js";
 const OFFSET_TOLERANCE = 3;
 export function parseUnifiedDiff(diff) {
     const files = [];
@@ -127,7 +130,7 @@ export function buildPatchedFiles(files, cwd = process.cwd()) {
                 lines.length = 0;
                 lines.push(...r.lines);
             }
-            contents.push({ file, content: lines.join("\n") + (lines.length > 0 ? "\n" : "") });
+            contents.push({ file, content: lines.join("\n") + (lines.length > 0 ? "\n" : ""), original: null });
             continue;
         }
         if (!exists)
@@ -137,7 +140,7 @@ export function buildPatchedFiles(files, cwd = process.cwd()) {
             content = readFileSync(target, "utf-8");
         }
         catch (err) {
-            return { ok: false, error: `${file.path}: 读取失败 ${err.message}` };
+            return { ok: false, error: `${file.path}: 读取失败 ${err instanceof Error ? err.message : String(err)}` };
         }
         const lines = content.split("\n");
         for (const hunk of file.hunks) {
@@ -147,10 +150,77 @@ export function buildPatchedFiles(files, cwd = process.cwd()) {
             lines.length = 0;
             lines.push(...r.lines);
         }
-        contents.push({ file, content: lines.join("\n") });
+        contents.push({ file, content: lines.join("\n"), original: content });
     }
     return { ok: true, contents };
 }
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/**
+ * 事务化写盘：先把所有新内容写入目标旁的临时文件，再统一 rename 就位。
+ * 第一阶段失败时工作区零改动；rename 中途失败时回滚已就位的文件。
+ */
+async function commitPatchedFiles(contents) {
+    const cwd = process.cwd();
+    const staged = [];
+    // 漂移检查：确认弹窗期间文件可能被用户或其他进程改动。
+    for (const c of contents) {
+        const target = path.resolve(cwd, c.file.path);
+        if (c.original === null) {
+            if (existsSync(target))
+                return { ok: false, error: `${c.file.path}: 文件已存在，未应用任何更改` };
+            continue;
+        }
+        let current;
+        try {
+            current = await readFile(target, "utf-8");
+        }
+        catch (err) {
+            return { ok: false, error: `${c.file.path}: 读取失败 ${errMessage(err)}` };
+        }
+        if (current !== c.original) {
+            return { ok: false, error: `${c.file.path}: 文件在确认期间已被修改，未应用任何更改` };
+        }
+    }
+    for (const c of contents) {
+        const target = path.resolve(cwd, c.file.path);
+        const tmp = tempPathFor(target);
+        try {
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(tmp, c.content, "utf-8");
+        }
+        catch (err) {
+            for (const s of staged)
+                await unlink(s.tmp).catch(() => { });
+            await unlink(tmp).catch(() => { });
+            return { ok: false, error: `${c.file.path}: 写入失败 ${errMessage(err)}` };
+        }
+        staged.push({ rel: c.file.path, target, tmp, original: c.original });
+    }
+    const renamed = [];
+    for (const s of staged) {
+        try {
+            await rename(s.tmp, s.target);
+            renamed.push(s);
+        }
+        catch (err) {
+            for (const d of [...renamed].reverse()) {
+                try {
+                    if (d.original !== null)
+                        await atomicWriteFile(d.target, d.original);
+                    else
+                        await unlink(d.target).catch(() => { });
+                }
+                catch { }
+            }
+            for (const s2 of staged.slice(renamed.length))
+                await unlink(s2.tmp).catch(() => { });
+            return { ok: false, error: `${s.rel}: 写入失败 ${errMessage(err)}，已回滚其他文件` };
+        }
+    }
+    return { ok: true };
+}
 export const applyPatchTool = tool({
     description: "Apply a unified diff to the working tree. Use this for precise multi-file edits or when you have a generated diff. " +
         "Supports standard unified diff format (---/+++ headers, @@ hunks, context/delete/add lines). " +
@@ -166,6 +236,12 @@ export const applyPatchTool = tool({
         const parsed = parseUnifiedDiff(diff);
         if (parsed.length === 0)
             return "Error: 无法解析 diff（缺少 ---/+++ 文件头）";
+        // 先鉴权再读盘：任何目标路径不可写都直接拒绝，不触碰文件内容。
+        for (const f of parsed) {
+            const denied = pathAccessError(f.path, "write");
+            if (denied)
+                return `Error: ${denied}`;
+        }
         const built = buildPatchedFiles(parsed);
         if (!built.ok)
             return `Error: ${built.error}`;
@@ -176,16 +252,14 @@ export const applyPatchTool = tool({
             return `  ${c.file.path} ${c.file.isNew ? "(new)" : ""} -${del}/+${add}`;
         })
             .join("\n");
-        if (!isAutoApprove()) {
+        if (!isEditAutoApprove()) {
             const approved = await confirm(`Apply patch to ${built.contents.length} file(s)?\n${summary}`);
             if (!approved)
                 return "Patch rejected by user.";
         }
-        for (const c of built.contents) {
-            const target = path.resolve(process.cwd(), c.file.path);
-            mkdirSync(path.dirname(target), { recursive: true });
-            writeFileSync(target, c.content, "utf-8");
-        }
+        const committed = await commitPatchedFiles(built.contents);
+        if (!committed.ok)
+            return `Error: ${committed.error}`;
         return `Applied patch:\n${summary}`;
     },
 });

package/dist/tools/atomic-file.js

@@ -0,0 +1,35 @@
+import { writeFile, rename, unlink } from "fs/promises";
+import { writeFileSync, renameSync, unlinkSync } from "fs";
+import { randomBytes } from "crypto";
+import path from "path";
+/** Temp file path living next to the target so the rename stays on the same filesystem. */
+export function tempPathFor(target) {
+    return path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+}
+/** Write content to a sibling temp file, then atomically rename it over the target. */
+export async function atomicWriteFile(target, content) {
+    const tmp = tempPathFor(target);
+    try {
+        await writeFile(tmp, content, "utf-8");
+        await rename(tmp, target);
+    }
+    catch (err) {
+        await unlink(tmp).catch(() => { });
+        throw err;
+    }
+}
+/** Sync variant for call sites that must stay synchronous (config/session stores). */
+export function atomicWriteFileSync(target, content) {
+    const tmp = tempPathFor(target);
+    try {
+        writeFileSync(tmp, content, "utf-8");
+        renameSync(tmp, target);
+    }
+    catch (err) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { }
+        throw err;
+    }
+}

package/dist/tools/backend.js

@@ -39,9 +39,9 @@ export function normalizeBaseURL(raw, source) {
  */
 export function resolveBackendBase(spec, configValue) {
     const env = process.env[spec.envName];
-    if (env && env.trim())
+    if (env?.trim())
         return normalizeBaseURL(env, spec.envName);
-    if (configValue && configValue.trim())
+    if (configValue?.trim())
         return normalizeBaseURL(configValue, `"${spec.configKey}" in config.json`);
     return normalizeBaseURL(spec.fallback, "the built-in default backend URL");
 }