teapot-coding-agent 0.37.59 → 0.37.60

package/dist/migrations/index.js

@@ -1,40 +1,3 @@
-/**
- * Ordered, one-way migrations for on-disk state.
- *
- * ## Why order and idempotency matter more than the transformations
- *
- * A single upgrade path is easy. The hard case is a machine that skips several releases: an
- * operator on v0.20 upgrading straight to v0.40 runs EVERY migration in between at once. Two
- * migrations that each look correct can then be wrong together — the canonical example is a future
- * `config.json` split combined with today's "store the session title in `agents[]`":
- *
- *   split first   → titles land in the new config directory, then the old file is read again and
- *                   the titles are written a second time, or to the wrong file;
- *   titles first  → the split then has to carry a field it never knew about.
- *
- * So each migration here:
- *
- *   - is **idempotent** — running it twice is a no-op, because a crash mid-upgrade must be
- *     resumable and a re-run must not double-apply;
- *   - declares an **order** — `order` is ascending, and a later step may assume every earlier one
- *     has run;
- *   - never deletes data it does not fully replace (a rename, not a delete-then-write);
- *   - reports what it did, so a boot log shows which steps actually ran.
- *
- * ## What this module is NOT
- *
- * It does not decide WHICH migrations exist — each one lives in its own file and is registered in
- * `index.ts`. Keeping them out of `master.ts` is the point: they were spread across the boot path,
- * where an ordering mistake is invisible.
- */
-/**
- * Run every registered migration in `order`, skipping nothing.
- *
- * There is no "already ran" gate on purpose: each step is idempotent, so the cheapest correct
- * policy is to always run them. A recorded version would have to be validated against a config the
- * operator may have hand-edited or restored from backup, and a wrong version claim is how a
- * migration silently does not run.
- */
 export async function runMigrations(migrations, ctx) {
     const applied = [];
     for (const m of [...migrations].sort((a, b) => a.order - b.order)) {
@@ -45,26 +8,8 @@ export async function runMigrations(migrations, ctx) {
             }
         }
         catch (err) {
-            // One broken step must not block the boot: the session data is still readable, and refusing
-            // to start would be worse than starting with one conversion unmade.
             ctx.log(`migration ${m.id} FAILED (${err.message}) — continuing without it`);
         }
     }
     return { applied };
 }
-/**
- * ## What is deliberately NOT here
- *
- * Two migrations stay in `src/agent/agent.ts` because they are per-SESSION filesystem moves that
- * need the agent's own paths, and they already satisfy the rules above:
- *
- *   - `migrateGoalFromWorkspace` — `<workspace>/GOAL.md` → the session's goal store. Deletes the
- *     legacy file only after a successful write, so a failure re-runs.
- *   - `migrateMemoryToAgentScope` — a session's `memory.md` → the agent-wide one. APPENDS (the
- *     agent-wide file may already hold other sessions' notes), then removes the source. A missing
- *     write leaves the session copy in place.
- *
- * Moving them here would mean handing this module session paths it has no business knowing. What
- * matters is that they obey the same contract: idempotent, no data destroyed that was not
- * replaced, and ordered after the config-level steps (they run at agent start, which is later).
- */

package/dist/migrations/providers.js

@@ -1,15 +1,4 @@
 import { migrateProviderKeys } from "../master.js";
-/**
- * Fold a legacy single `apiKey` into an `apiKeys` array.
- *
- * `apiKey` is KEPT in step with `apiKeys[0]` rather than deleted: other readers still expect it (the
- * setup wizard, `/api/providers`, hand-edited files), and a migration that removes a field the
- * operator can see is one they will report as data loss.
- *
- * Idempotent because `apiKeys` is AUTHORITATIVE once present: re-running on a migrated entry
- * produces the same list. The single `apiKey` only SEEDS the pool when there is no list — appending
- * it as well would resurrect a credential the operator had already replaced.
- */
 export const providerKeys = {
     order: 10,
     id: "providers-api-keys",
@@ -25,8 +14,6 @@ export const providerKeys = {
                 continue;
             const p = entry;
             const before = JSON.stringify(p);
-            // ONE implementation of the folding rule, shared with the runtime normaliser — a second copy
-            // here is how the two drift and disagree about which key is authoritative.
             const next = migrateProviderKeys(p);
             for (const k of Object.keys(p))
                 delete p[k];

package/dist/migrations/registry.js

@@ -1,14 +1,5 @@
 import { providerKeys } from "./providers.js";
 import { flatSessionLayout } from "./sessions.js";
 import { sessionTitles } from "./session-titles.js";
-/**
- * Every migration, in application order.
- *
- * Add new ones with a HIGHER `order` than everything here, and never renumber an existing one — a
- * machine that already ran it would skip it under the new number.
- *
- * Ordering rule: a migration may assume every lower `order` has run. That is what makes a
- * multi-release jump safe. If two migrations must not be reordered later, say so in both files.
- */
 export const MIGRATIONS = [providerKeys, flatSessionLayout, sessionTitles];
 export { runMigrations } from "./index.js";

package/dist/migrations/session-titles.js

@@ -1,20 +1,5 @@
 import { closeSync, openSync, readSync } from "node:fs";
 import path from "node:path";
-/**
- * Derive each agent's session title ONCE and store it in `config.agents[].sessionTitle`.
- *
- * Titles used to be recomputed on every `allSessions()` — opening up to 830 session logs and
- * allocating a 16KB buffer for each, MEASURED at 83.8ms, 8.1MB read and ~38MB of short-lived
- * garbage per scan, on every `/api/sessions`. Storing it makes listing a config lookup.
- *
- * Runs ONCE PER SESSION rather than once per process: the check is `sessionTitle` on the agent's
- * CURRENT session, so a machine that has already been through this does no file I/O at all. That
- * is what makes it idempotent — and why it must come AFTER any step that could change `agents[]`.
- *
- * A session whose first prompt is a HARNESS prompt yields no title: sub-agent sessions receive only
- * those and are labelled from their id, so inventing one would name a child after its parent's
- * instruction.
- */
 export const sessionTitles = {
     order: 30,
     id: "agents-session-title",
@@ -27,21 +12,11 @@ export const sessionTitles = {
             const session = typeof a.session === "string" ? a.session : "";
             if (!session)
                 continue;
-            // already stored (possibly hand-edited — a chosen name must never be overwritten)
             if (typeof a.sessionTitle === "string" && a.sessionTitle.trim())
                 continue;
             if (session.includes("/") || session.includes(".."))
-                continue; // never a path segment
+                continue;
             const title = firstUserPromptText(path.join(ctx.dataDir, "sessions", session, "chat.jsonl"));
-            /**
-             * The SESSION ID is the fallback, not a marker.
-             *
-             * A sub-agent session receives only harness prompts, so no title can ever be derived from it —
-             * and a session id does not change either, so there is nothing to retry for. Writing the id
-             * makes the field ALWAYS present, which is what makes the pass idempotent without an extra
-             * flag: the next boot sees a title and skips. The sidebar already shows the id in this case,
-             * so nothing visible changes.
-             */
             a.sessionTitle = title ?? session;
             changed = true;
         }
@@ -50,19 +25,6 @@ export const sessionTitles = {
         return changed;
     },
 };
-/**
- * The first USER prompt in a log, trimmed to a title. `null` when there is none.
- *
- * Bounded (256KB) and stops at the first prompt, so one enormous log cannot dominate boot. A torn
- * final line at a chunk boundary is skipped rather than aborting the read.
- */
-/**
- * ONE reusable read buffer for the whole pass.
- *
- * `Buffer.alloc` per session is what made the first boot spike: 830 sessions x 16KB of short-lived
- * buffer, MEASURED as heap 28.2MB → 108.5MB during `start()` (33.4MB after GC). The scan is a
- * single-threaded loop, so sharing one buffer is safe and removes the churn entirely.
- */
 let scanBuffer;
 function firstUserPromptText(file) {
     let fd;
@@ -89,12 +51,12 @@ function firstUserPromptText(file) {
                     e = JSON.parse(l);
                 }
                 catch {
-                    continue; // torn line at a chunk boundary
+                    continue;
                 }
                 if (e.type !== "prompt")
                     continue;
                 if (e.data?.source !== "user")
-                    return null; // a harness prompt is not a label
+                    return null;
                 return titleOf(typeof e.data.text === "string" ? e.data.text : null);
             }
         }
@@ -109,12 +71,10 @@ function firstUserPromptText(file) {
                 closeSync(fd);
             }
             catch {
-                /* already closed */
             }
         }
     }
 }
-/** the first usable line of a prompt, clipped — the sidebar shows one short label */
 function titleOf(text) {
     const line = (text ?? "")
         .split("\n")

package/dist/migrations/sessions.js

@@ -1,28 +1,10 @@
 import { existsSync, mkdirSync, readdirSync, renameSync } from "node:fs";
 import path from "node:path";
-/**
- * Move sessions from the ≤0.5.0 flat layout (`<dataDir>/<id>.jsonl`) into
- * `<dataDir>/sessions/<id>/chat.jsonl`.
- *
- * A RENAME, not a copy-then-delete: a crash between the two would otherwise leave the history in
- * neither place. `rename` within one filesystem is atomic, so a re-run either finds the legacy file
- * (and moves it) or finds it already moved.
- *
- * Order 20: it must run before anything reads a session directory.
- */
 export const flatSessionLayout = {
     order: 20,
     id: "sessions-flat-layout",
     summary: "sessions/<id>.jsonl → sessions/<id>/chat.jsonl",
     run(ctx) {
-        /**
-         * Scan the DATA DIR, not `config.agents`.
-         *
-         * A legacy log can exist for an agent that is no longer in the config (archived, removed, or a
-         * config that failed to load) — and those are exactly the histories worth rescuing. Iterating
-         * the config also made this a no-op whenever the config listed no agents, which is how a test
-         * with an empty agent list silently stopped exercising it.
-         */
         let names;
         try {
             names = readdirSync(ctx.dataDir);
@@ -37,11 +19,11 @@ export const flatSessionLayout = {
                 continue;
             const id = name.slice(0, -".jsonl".length);
             if (!id || id.includes("/") || id.includes(".."))
-                continue; // never a path segment
+                continue;
             const legacy = path.join(ctx.dataDir, name);
             const target = path.join(root, id);
             if (existsSync(target))
-                continue; // already migrated; the legacy file is a leftover
+                continue;
             mkdirSync(target, { recursive: true });
             renameSync(legacy, path.join(target, "chat.jsonl"));
             ctx.log(`${name} → sessions/${id}/chat.jsonl`);

package/dist/model-meta.js

@@ -1,39 +1,11 @@
-/**
- * Provider model metadata (context window sizes) with a small TTL cache.
- * Used to auto-populate contextWindowTokens so compaction budgets derive
- * from the real window instead of the safe default.
- */
 import { providerHeaders } from "./agent/provider-headers.js";
 const cache = new Map();
 const inFlight = new Map();
 const TTL = 10 * 60_000;
-/**
- * How long a FAILED lookup is remembered.
- *
- * A failure used to be dropped on the floor (the `catch` returned `[]` without
- * caching), so a dead, unauthorised, or simply slow endpoint was re-fetched for
- * EVERY agent pointed at it. `addAgent` awaits this twice per agent and races it
- * against a 1.5 s timeout, so with 493 agents across a handful of providers the
- * same failing request — and its timeout — repeated hundreds of times. MEASURED
- * at boot: 1883 ms of the 4.6 s was idle, waiting on exactly this.
- *
- * Negative results expire much sooner than positive ones: a provider coming back
- * up should be usable within a minute, not locked out for ten.
- */
 const NEGATIVE_TTL = 30_000;
-/** is this cached entry still valid? (failures expire sooner) */
 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);
@@ -43,15 +15,11 @@ export function peekModelList(baseUrl) {
         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(/\/+$/, "");
     const hit = cache.get(root);
     if (hit && fresh(hit))
         return hit.list;
-    // An in-flight lookup is SHARED: without this, two callers racing for the
-    // same endpoint each paid the full timeout, and `newSession` in ACP mode
-    // blocked on it before it could even reply to the editor (#15).
     const inflight = inFlight.get(root);
     if (inflight)
         return inflight;
@@ -60,10 +28,8 @@ export async function fetchModelList(baseUrl, apiKey) {
             const res = await fetch(`${root}/models`, {
                 headers: {
                     ...(apiKey ? { authorization: `Bearer ${apiKey}` } : {}),
-                    ...providerHeaders(baseUrl), // OpenRouter app attribution
+                    ...providerHeaders(baseUrl),
                 },
-                // boot-time calls happen per agent; a slow/unroutable endpoint used to
-                // stall startup for up to 15s PER AGENT before this was tightened
                 signal: AbortSignal.timeout(3_000),
             });
             if (!res.ok)
@@ -73,42 +39,21 @@ export async function fetchModelList(baseUrl, apiKey) {
                 .map((m) => ({
                 id: typeof m.id === "string" ? m.id : "",
                 contextLength: typeof m.context_length === "number" ? m.context_length : undefined,
-                // OpenRouter-style USD per token (e.g. "0.000003") — powers the
-                // runtime cost estimate. Providers without pricing stay undefined.
                 pricing: m.pricing && (m.pricing.prompt !== undefined || m.pricing.completion !== undefined)
                     ? {
                         prompt: Number(m.pricing.prompt ?? 0),
                         completion: Number(m.pricing.completion ?? 0),
                     }
                     : undefined,
-                /**
-                 * `modalities` is only known when the provider PUBLISHES it — in practice OpenRouter's
-                 * `architecture.input_modalities`.
-                 *
-                 * Every other endpoint omits the field, so this stays `undefined` and the UI must treat it as
-                 * UNKNOWN rather than as "text only". Reported as "Command Code GOATのモデルカタログが
-                 * input/outputのフォーマットを適切に提供していない? OpenRouterしかちゃんと対応できてない可能性は
-                 * ある" — which is exactly right, and the code was right not to invent a value.
-                 *
-                 * The consequence to know about: without a modality list nothing can decide "this model
-                 * accepts an image", so an operator's screenshot reaches the model as a FILE PATH and an agent
-                 * that tries `read_file` gets bytes. The guard for that lives in `read_file` (it refuses a
-                 * binary file by name instead of returning mojibake), so the failure is at least legible.
-                 */
                 modalities: Array.isArray(m.architecture?.input_modalities) && m.architecture.input_modalities.length
                     ? {
                         input: m.architecture.input_modalities,
                         output: m.architecture.output_modalities ?? ["text"],
                     }
                     : undefined,
-                // OpenRouter advertises per-model capabilities; other endpoints omit
-                // the field entirely, which leaves support "unknown" rather than false.
                 supportedParameters: Array.isArray(m.supported_parameters)
                     ? m.supported_parameters.filter((p) => typeof p === "string")
                     : undefined,
-                // per-model reasoning levels when published (OpenRouter): the UI offers
-                // exactly these, and the request is clamped into them — offering a level the
-                // model does not have is a control that does nothing (#150)
                 supportedEfforts: Array.isArray(m.reasoning?.supported_efforts)
                     ? m.reasoning.supported_efforts.filter((e) => typeof e === "string")
                     : undefined,
@@ -122,10 +67,8 @@ export async function fetchModelList(baseUrl, apiKey) {
             return list;
         }
         catch {
-            // Remember the FAILURE (briefly). Dropping it meant every agent on this
-            // endpoint paid the fetch — and up to the 1.5 s race timeout — again.
             cache.set(root, { at: Date.now(), list: [], negative: true });
-            return []; // unreachable provider — caller treats as "unknown"
+            return [];
         }
     })();
     inFlight.set(root, p);
@@ -139,12 +82,10 @@ export async function fetchModelList(baseUrl, apiKey) {
 export function contextLengthFor(list, model) {
     return list.find((m) => m.id === model)?.contextLength;
 }
-/** Reasoning-effort levels OpenRouter accepts (`reasoning_effort`). */
 export const REASONING_EFFORTS = ["minimal", "low", "medium", "high"];
 export function isReasoningEffort(v) {
     return typeof v === "string" && REASONING_EFFORTS.includes(v);
 }
-/** True when the endpoint is OpenRouter (the only one that documents effort). */
 export function isOpenRouter(baseUrl) {
     try {
         return /(^|\.)openrouter\.ai$/i.test(new URL(String(baseUrl ?? "")).host);
@@ -153,25 +94,12 @@ export function isOpenRouter(baseUrl) {
         return false;
     }
 }
-/**
- * The `reasoning_effort` value to actually SEND, or undefined to omit it.
- *
- * Verified against the live OpenRouter /models endpoint (462 models): 196
- * advertise `reasoning_effort`, 331 the broader `reasoning`, and NONE a bare
- * top-level `effort`. Support is therefore far from universal, and sending the
- * parameter to a model that does not advertise it is how a request gets
- * rejected or a setting silently ignored (#47) — so it is sent only when the
- * endpoint is OpenRouter AND the model advertises it. Off by default: an absent
- * setting means "let the provider apply its own default".
- */
 export function resolveReasoningEffort(opts) {
     if (!isReasoningEffort(opts.effort))
         return undefined;
     if (!isOpenRouter(opts.baseUrl))
         return undefined;
     const meta = opts.list?.find((m) => m.id === opts.model);
-    // No catalogue for this endpoint: we cannot verify support, so do not send.
-    // A wrong body field is worse than an unset one.
     if (!meta?.supportedParameters)
         return undefined;
     if (!meta.supportedParameters.includes("reasoning_effort"))

package/dist/scheduler/cron.js

@@ -1,20 +1,13 @@
-/**
- * Minimal 5-field cron matcher (minute hour day-of-month month day-of-week).
- * Also supports shorthand "every <n>s|m|h".
- * The master ticks once every 15s; matching is a handful of integer compares.
- */
 const BOUNDS = [
     [0, 59],
     [0, 23],
     [1, 31],
     [1, 12],
-    [0, 7], // 0 and 7 are both Sunday
+    [0, 7],
 ];
 function parseField(part, min, max) {
     const out = new Set();
     const clampOrThrow = (v) => {
-        // accepting an out-of-range value produces a set that never matches, i.e. a
-        // cron that silently never fires ("99 * * * *")
         if (!Number.isInteger(v) || v < min || v > max)
             throw new Error(`bad cron field: ${part} (${min}-${max} expected)`);
         return v;
@@ -73,12 +66,10 @@ export function parseSchedule(spec) {
         fields: parts.map((p, i) => parseField(p, BOUNDS[i][0], BOUNDS[i][1])),
     };
 }
-/** Does this schedule fire at the given Date? */
 export function matches(schedule, d) {
     const values = [d.getMinutes(), d.getHours(), d.getDate(), d.getMonth() + 1, d.getDay()];
     for (let i = 0; i < 5; i++) {
         if (!schedule.fields[i].has(values[i])) {
-            // Sunday alias: field 5 with 7 should also match day=0
             if (i === 4 && values[i] === 0 && schedule.fields[i].has(7))
                 continue;
             return false;
@@ -86,14 +77,8 @@ export function matches(schedule, d) {
     }
     return true;
 }
-/**
- * Next fire time after `from`, scanning minute by minute (cheap: a handful of
- * integer compares per minute). The horizon is a year so an annual cron (a
- * December date seen in August) still resolves; a Feb-29-only cron can
- * legitimately report null most of the year.
- */
 export function nextFireAt(schedule, from = new Date()) {
-    const startMinute = Math.floor(from.getTime() / 60_000) + 1; // next whole minute
+    const startMinute = Math.floor(from.getTime() / 60_000) + 1;
     const horizon = 60 * 24 * 366;
     for (let i = 0; i < horizon; i++) {
         const d = new Date((startMinute + i) * 60_000);