teapot-coding-agent 0.29.5 → 0.29.7

package/dist/agent/agent.js

@@ -628,9 +628,25 @@ export class Agent {
         this.goal = stored ?? { text: "", status: "active", updatedAt: new Date().toISOString() };
         // operator-maintained task list lives beside goal.md
         this.todo = await fs.readFile(this.todoFile, "utf8").catch(() => "");
-        await this.refreshSkills();
-        // the conversation is NOT restored here: boot cost stays O(agents), not
-        // O(history). It is rebuilt lazily by ensureReady() on first interaction.
+        // #143: NO skill scan here. It was the single largest boot cost — 493 agents
+        // each walking their roots (readdir + stat, recursively) measured 2120 ms of
+        // a 4.7 s boot. Every one of those walks was redundant:
+        //
+        //   - the turn loop calls `refreshSkills()` at the TOP of every turn, before
+        //     the system prompt (which embeds the catalogue) is built, so the scan is
+        //     always current before any LLM request
+        //   - the `list_skills` tool calls it itself before reading the cache
+        //   - `/api/agents/:id/skills` (what the panel uses) does its own fresh
+        //     `currentSkills()` walk and never reads this cache
+        //
+        // Caching the walk was the other option and was WORSE: the fingerprint exists
+        // to notice a NESTED skill's add/edit, which does not change its root's mtime,
+        // so any TTL/mtime key reintroduces the staleness the walk was written to fix
+        // (the skills-fingerprint tests pin exactly that). Skipping boot's copy costs
+        // no freshness at all.
+        //
+        // The conversation is likewise not restored here: boot cost stays O(agents),
+        // not O(history). Both are rebuilt lazily by ensureReady()/the turn loop.
         if (this.opts.restoreSession) {
             this.status = "stopped";
             this.statusReason = "session not loaded — select it or send a prompt";

package/dist/master.js

@@ -13,9 +13,53 @@ import { spawn } from "node:child_process";
 import { Agent } from "./agent/agent.js";
 import { parseSchedule, matches, nextFireAt } from "./scheduler/cron.js";
 import { bus } from "./bus.js";
-import { fetchModelList, contextLengthFor, isReasoningEffort, } from "./model-meta.js";
+import { fetchModelList, peekModelList, contextLengthFor, isReasoningEffort, } from "./model-meta.js";
 /** how deep sub-agent spawning may nest (parent=0, its subs=1, …) */
+/**
+ * Did the effective data dir come from an ENV OVERRIDE that disagrees with the
+ * config file's own `dataDir`? (#143)
+ *
+ * When it does, the config's session pointers are meaningless: they name
+ * directories under the OLD root, and this process is looking at a different
+ * one. Every agent therefore mints a fresh session — and `recordSession` writes
+ * those new pointers back into the config, destroying the real mapping. The
+ * caller then throws the new root away (a test's temp dir), leaving a config that
+ * points at sessions that never existed.
+ *
+ * That is not hypothetical: `test/cli-boot-and-host.test.ts` spawns the built CLI
+ * with `TEAPOT_DATA_DIR=<temp>` but NO config override, so `pnpm test` on a
+ * developer machine rewrote their real config and orphaned 493 sessions' pointers
+ * — twice, before this guard. On CI it is invisible, because CI has no config
+ * file to damage.
+ *
+ * So: a mismatched root makes session resolution READ-ONLY. The boot still works
+ * (agents get working sessions in the new root) — it just does not rewrite a
+ * config that is describing somebody else's data dir.
+ */
+function dataDirOverrideMismatch(configFilePath, effective) {
+    if (!process.env.TEAPOT_DATA_DIR)
+        return false; // not an override: the file is the truth
+    try {
+        const raw = JSON.parse(readFileSync(configFilePath, "utf8"));
+        if (typeof raw.dataDir !== "string" || !raw.dataDir)
+            return false;
+        return path.resolve(raw.dataDir) !== path.resolve(effective);
+    }
+    catch {
+        return false; // unreadable/new config — nothing to protect
+    }
+}
 const MAX_SPAWN_DEPTH = 3;
+/**
+ * How long boot waits for an endpoint's model catalogue (#143).
+ *
+ * The window and the reasoning-effort gate both come from `/models`, so a boot
+ * that waits on it is waiting for metadata, not for anything it needs to start.
+ * The lookup is fired concurrently for every distinct endpoint before the agent
+ * loop (see prefetchModelLists), so this bound is paid once per ENDPOINT rather
+ * than once per agent — and only when the endpoint is slow or dead.
+ */
+const MODEL_META_BOOT_MS = 1_500;
 /** statuses that mean a child has finished working, for #130 */
 const SETTLED = new Set(["idle", "stopped", "waiting", "error"]);
 /**
@@ -312,6 +356,16 @@ export class Master {
     constructor(config, configPath) {
         this.config = config;
         this.configPath = configPath;
+        // #143: an env data-dir override that disagrees with the config file means
+        // this config describes a DIFFERENT data dir — its session pointers cannot be
+        // valid here, so rewriting them would destroy the real mapping. See
+        // dataDirOverrideMismatch().
+        this.sessionsReadOnly = dataDirOverrideMismatch(configPath, config.dataDir);
+        if (this.sessionsReadOnly) {
+            console.warn(`[teapot] TEAPOT_DATA_DIR (${config.dataDir}) disagrees with the config's own dataDir; ` +
+                `sessions will be resolved in the override but NOT written back to ${configPath}. ` +
+                `Set TEAPOT_CONFIG to an isolated config to silence this.`);
+        }
     }
     /**
      * Persist current logical config back to disk (lossless via raw user config).
@@ -362,6 +416,21 @@ export class Master {
      */
     deferConfigWrites = false;
     configDirty = false;
+    /**
+     * Endpoints whose catalogue boot has already WAITED for (#143).
+     *
+     * The wait must be paid once per endpoint, not once per agent. `Promise.race`
+     * against a timeout is per-CALL: with a dead endpoint every agent on it paid
+     * the full timeout again, because the shared request was still pending. 493
+     * agents over one unreachable provider measured 4.4s of boot spent purely
+     * idle, for a single request.
+     */
+    metaWaited = new Set();
+    /**
+     * #143: `TEAPOT_DATA_DIR` points somewhere other than the config's own dataDir,
+     * so session pointers must not be written back (see dataDirOverrideMismatch).
+     */
+    sessionsReadOnly = false;
     /** write once and clear the dirty flag — used at the end of a batched section */
     flushConfig() {
         this.configDirty = false;
@@ -495,6 +564,14 @@ export class Master {
         // boot, which is its own silent data loss.
         this.deferConfigWrites = true;
         this.configDirty = false;
+        // #143: start every endpoint's model-catalogue lookup NOW, concurrently.
+        //
+        // `addAgent` awaits this per agent, and the endpoints are shared by many
+        // agents (493 agents over 6 providers here). Fired up front, the requests
+        // overlap and each subsequent agent finds the promise already in flight or
+        // resolved — instead of the requests being serialised behind the agent loop,
+        // where a slow endpoint's timeout is paid again and again.
+        this.prefetchModelLists();
         try {
             for (const ac of this.config.agents) {
                 try {
@@ -596,6 +673,38 @@ export class Master {
      * Restarts reuse the latest existing session; fresh creations never touch
      * an older one's history.
      */
+    /**
+     * Fire the model-catalogue lookup for every distinct endpoint, concurrently.
+     *
+     * `fetchModelList` already shares an in-flight request per baseUrl, so this is
+     * about STARTING them together: without it the requests begin one at a time, as
+     * the agent loop reaches each provider, and a slow endpoint's timeout is paid
+     * serially by every agent on it.
+     *
+     * Best-effort by design — nothing awaits this. A failure is cached briefly by
+     * `fetchModelList`, and an agent whose lookup is not ready simply gets no
+     * inferred window, which is the same outcome as today's timeout.
+     */
+    prefetchModelLists() {
+        const endpoints = new Set();
+        const add = (baseUrl, apiKey) => {
+            if (!baseUrl)
+                return;
+            const key = baseUrl.replace(/\/+$/, "");
+            if (endpoints.has(key))
+                return;
+            endpoints.add(key);
+            void fetchModelList(baseUrl, apiKey).catch(() => []);
+        };
+        for (const ac of this.config.agents) {
+            const prov = this.config.providers?.[ac.provider ?? this.config.defaultProvider ?? ""];
+            add(ac.baseUrl ?? prov?.baseUrl ?? this.config.llm.baseUrl, ac.apiKey ?? prov?.apiKey ?? this.config.llm.apiKey);
+        }
+        // no configured agents yet (first-run wizard) — still warm the default so the
+        // first created agent does not wait
+        if (endpoints.size === 0)
+            add(this.config.llm.baseUrl, this.config.llm.apiKey);
+    }
     async addAgent(ac, opts = {}) {
         // #72: an agent id becomes a DIRECTORY name (sessions/<id>-<hash>), so it
         // must be a safe path segment. Every caller sanitised its own id — the HTTP
@@ -631,24 +740,33 @@ export class Master {
         // spawn-tree depth: computed from the config chain (ac may not be
         // registered yet when this runs — spawnChildFor persists AFTER creation)
         const myDepth = ac.parent ? this.depthOf(ac.parent) + 1 : 0;
-        // learn the model's real context window from provider metadata (once per
-        // endpoint, cached) unless the config already pins one explicitly
-        let inferredWindow;
-        if (!ac.contextWindowTokens && !this.config.contextWindowTokens) {
-            // don't block the event loop on provider metadata: fire the lookup but
-            // keep boot moving. The agent's gauge fills in when it resolves.
-            const listPromise = fetchModelList(llm.baseUrl, llm.apiKey);
-            inferredWindow = await Promise.race([
-                listPromise.then((l) => contextLengthFor(l, llm.model)),
-                new Promise((r) => setTimeout(() => r(undefined), 1_500)),
+        // Model metadata: the context window (for the compaction budget) and the
+        // catalogue entry that gates reasoning_effort support (#47) come from the
+        // SAME `/models` list.
+        //
+        // #143: boot must not WAIT for this. It only tunes the compaction budget and
+        // the effort controls, so a missing list costs nothing that matters; what it
+        // cost was boot time — measured at 4.4s of pure idle on 493 agents pointed at
+        // one unreachable endpoint, because the `Promise.race` timeout below is
+        // per-CALL and the shared request stayed pending for every agent.
+        //
+        // So: use the catalogue if `prefetchModelLists()` has already produced it
+        // (the common case — the lookups were fired when boot started), and wait only
+        // ONCE per endpoint for the stragglers, where the wait overlaps a request
+        // that is already in flight.
+        const needsWindow = !ac.contextWindowTokens && !this.config.contextWindowTokens;
+        const root = llm.baseUrl.replace(/\/+$/, "");
+        let list = peekModelList(llm.baseUrl);
+        if (list === undefined && !this.metaWaited.has(root)) {
+            this.metaWaited.add(root);
+            list = await Promise.race([
+                fetchModelList(llm.baseUrl, llm.apiKey),
+                // a placeholder so the race can settle without the list
+                new Promise((r) => setTimeout(() => r(undefined), MODEL_META_BOOT_MS)),
             ]);
-            void listPromise.catch(() => []);
         }
-        // catalogue entry for this model — gates reasoning_effort support (#47)
-        const modelMeta = (await Promise.race([
-            fetchModelList(llm.baseUrl, llm.apiKey),
-            new Promise((r) => setTimeout(() => r(undefined), 1_500)),
-        ]))?.find((m) => m.id === llm.model);
+        const inferredWindow = needsWindow && list ? contextLengthFor(list, llm.model) : undefined;
+        const modelMeta = list?.find((m) => m.id === llm.model);
         const sessionDir = this.resolveSessionDir(ac.id, opts.fresh === true);
         await mkdirSync(sessionDir, { recursive: true });
         // every session dir this master hands out carries an ownership manifest —
@@ -806,6 +924,11 @@ export class Master {
         if (!entry)
             return; // not a configured agent — nothing to persist yet
         entry.session = sessionId;
+        // #143: never write session pointers into a config that is describing another
+        // data dir — every one of them would be wrong, and the correct mapping is
+        // destroyed. The in-memory session above still works for this process.
+        if (this.sessionsReadOnly)
+            return;
         this.saveConfig();
     }
     /** spawn-tree depth of an agent (0 = top level); unknown → 0 */

package/dist/model-meta.js

@@ -26,6 +26,24 @@ const NEGATIVE_TTL = 30_000;
 function fresh(entry) {
     return Date.now() - entry.at < (entry.negative ? NEGATIVE_TTL : TTL);
 }
+/**
+ * The catalogue if it is ALREADY known, without starting a fetch (#143).
+ *
+ * Boot uses this so it never waits for metadata it can do without: the context
+ * window only tunes the compaction budget, and `supportedParameters` only gates
+ * the reasoning-effort controls (#47). `prefetchModelLists()` starts the real
+ * lookups in parallel, so an endpoint that answers quickly is usually warm by the
+ * time its first agent is created, and a slow or dead one costs no boot time.
+ */
+export function peekModelList(baseUrl) {
+    const root = baseUrl.replace(/\/+$/, "");
+    const hit = cache.get(root);
+    if (!hit)
+        return undefined;
+    if (!fresh(hit))
+        return undefined;
+    return hit.negative ? [] : hit.list;
+}
 /** Fetch GET /models from an OpenAI-compatible endpoint (cached ~10 min). */
 export async function fetchModelList(baseUrl, apiKey) {
     const root = baseUrl.replace(/\/+$/, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.29.5",
+  "version": "0.29.7",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",