teapot-coding-agent 0.37.87 → 0.37.88

package/dist/agent/agent.js

@@ -508,26 +508,71 @@ export class Agent {
         this.opts.llm = llm;
     }
     async init() {
-        await this.log.load();
+        /**
+         * NO `log.load()` here.
+         *
+         * It read up to 512KB of `chat.jsonl` for EVERY agent at boot — 445 of them on the operator's
+         * machine, MEASURED at 3.5s of a 7.8s start plus the parsed events on the heap (rss 1GB / heap
+         * 800MB at start-up). An agent that is never used needs none of it: the first `append` awaits
+         * `ensureLoaded()`, and `ensureReady()` reads it before restoring a session.
+         */
+        /**
+         * …and no SESSION-DIRECTORY reads at boot either.
+         *
+         * This block read goal.json, todo.md and stat()ed the workspace for every agent, four calls each —
+         * MEASURED 1,780 `readFile`s costing 4.5s of the same boot. They are now done in `ensureReady()`,
+         * i.e. when the session is actually loaded or used. `goal` and `todo` already have empty defaults
+         * (declared above), so a panel that reads them before the load shows "nothing yet" rather than
+         * waiting — which is the right trade for a boot that touches only config.json and skills.
+         */
+        if (!this.opts.deferSessionReads)
+            await this.loadSessionState();
+        if (this.opts.restoreSession) {
+            this.status = "stopped";
+            this.statusReason = "session not loaded — select it or send a prompt";
+            bus.emit("update", { kind: "agent-update", agentId: this.opts.id });
+        }
+    }
+    /**
+     * Everything in the session directory that the panel needs: goal, todo, workspace presence.
+     *
+     * Idempotent, so `init()` and `ensureReady()` can both ask without reading twice.
+     */
+    sessionStateLoaded = false;
+    async loadSessionState() {
+        if (this.sessionStateLoaded)
+            return;
+        this.sessionStateLoaded = true;
         await this.migrateMemoryToAgentScope();
         this.workspaceMissing = !(await fs
             .stat(this.workspace)
             .then(() => true)
             .catch(() => false));
         await this.migrateGoalFromWorkspace();
-        const stored = await this.readGoalStore();
-        this.goal = stored ?? { text: "", status: "active", updatedAt: new Date().toISOString() };
+        this.goal = (await this.readGoalStore()) ?? this.goal;
         this.todo = await fs.readFile(this.todoFile, "utf8").catch(() => "");
-        if (this.opts.restoreSession) {
-            this.status = "stopped";
-            this.statusReason = "session not loaded — select it or send a prompt";
-            bus.emit("update", { kind: "agent-update", agentId: this.opts.id });
-        }
     }
     ensureReady() {
         if (!this.readyPromise) {
             this.readyPromise = (async () => {
+                /**
+                 * The session directory is opened HERE, on demand — see the note in `init()`.
+                 *
+                 * When it was DEFERRED (a booted agent, and every spawned child) this must not hold up the
+                 * "running" transition that follows: the panel's goal/todo are not needed to run a turn, and
+                 * awaiting them here delayed `setStatus("running")` past the point where a parent's
+                 * `wait_children` inspects its children — it then reported "all sub-agents already settled"
+                 * while the child was about to work. So it loads in the background and announces itself.
+                 */
+                const state = this
+                    .loadSessionState()
+                    .then(() => bus.emit("update", { kind: "agent-update", agentId: this.opts.id }))
+                    .catch(() => { });
+                if (!this.opts.deferSessionReads)
+                    await state;
                 if (this.opts.restoreSession) {
+                    // the restore reads the log itself, but `seq`/`lastByBranch` must be known for later appends
+                    await this.log.ensureLoaded();
                     await this.restoreFromLog();
                     if (this.status === "stopped")
                         this.setStatus("idle", "session loaded");

package/dist/log/events.js

@@ -17,6 +17,23 @@ export class EventLog {
         this.agentId = agentId;
     }
     static LOAD_TAIL_BYTES = 512 * 1024;
+    /**
+     * Read the log TAIL to learn `seq` and the last event per branch.
+     *
+     * LAZY, and memoised. `Agent.init()` ran it for every agent at boot, which is the startup cost the
+     * operator reported: 445 agents × up to 512KB of `chat.jsonl` parsed before the first request —
+     * MEASURED 3.5s of a 7.8s boot, plus the parsed events on the heap ("起動直後のメモリバースト",
+     * rss 1GB / heap 800MB).
+     *
+     * Nothing needs it until something WRITES (`append` increments `seq`) or asks for a branch's last
+     * event, so it now happens then. The rule from the operator: "起動中に読んでいいのはconfig.jsonと
+     * skillsだけ / セッションディレクトリはセッションがロードされるまで開かない".
+     */
+    ensureLoaded() {
+        this.loadPromise ??= this.load();
+        return this.loadPromise;
+    }
+    loadPromise;
     async load() {
         mkdirSync(path.dirname(this.filePath), { recursive: true });
         try {
@@ -103,7 +120,21 @@ export class EventLog {
         await new Promise((res) => s.end(res)).catch(() => {
         });
     }
+    /**
+     * Queue a write, reading the log first if it has not been read yet.
+     *
+     * NOT `async` on purpose. An `async` function returns a NEW promise, so `void this.log.append(…)`
+     * — which is how most call sites fire a log write — would leave that wrapper promise unhandled when
+     * the write fails, and the failure surfaced as an `unhandledRejection` instead of the caller's
+     * problem. Returning the inner promise (which already has handlers attached below) keeps the old
+     * behaviour: awaiting still throws, ignoring stays silent.
+     */
     append(type, session, branch, data) {
+        const p = this.ensureLoaded().then(() => this.writeEvent(type, session, branch, data));
+        void p.catch(() => { });
+        return p;
+    }
+    async writeEvent(type, session, branch, data) {
         const evt = {
             v: 1,
             id: `e${++this.seq}`,

package/dist/master.js

@@ -636,6 +636,8 @@ export class Master {
             },
             llm,
             sessionDir,
+            // boot must touch ONLY config.json and skills; this agent's directory is opened when it is used
+            deferSessionReads: true,
             progressIntervalMs: this.config.progressIntervalMs,
             ...(this.config.progressMinChars ? { progressMinChars: this.config.progressMinChars } : {}),
             ...(this.config.maxTurnsPerRound !== undefined ? { maxTurnsPerRound: this.config.maxTurnsPerRound } : {}),
@@ -732,14 +734,14 @@ export class Master {
             agent.setSessionTitle(seedTitle);
         else {
             /**
-             * Derive a missing title at BOOT, once, and write it down.
+             * NOT derived here. Deriving a missing title reads `chat.jsonl`, and boot must not open session
+             * directories at all — "起動中に読んでいいのはconfig.jsonとskillsだけ / セッションディレクトリは
+             * セッションがロードされるまで開かない".
              *
-             * Waiting for the session's next user prompt means an existing session shows no name until the
-             * operator types into it, and every left-panel read has to fall back. Doing it here keeps the
-             * derivation to one pass per session and off the read path.
+             * The session ID is a perfectly good fallback for the panel, and the real derivation happens
+             * when that session is actually loaded (`ensureSessionTitle`, via the agent's first prompt).
              */
             const id = path.basename(sessionDir);
-            this.writeSessionTitle(id, this.sessionTitleOf(sessionDir) ?? id);
             agent.setSessionTitle(this.readSessionTitle(id) ?? id);
         }
         this.agents.set(ac.id, agent);

package/dist/migrations/session-titles.js

@@ -1,5 +1,4 @@
 import { closeSync, openSync, readSync } from "node:fs";
-import path from "node:path";
 export const sessionTitles = {
     order: 30,
     id: "agents-session-title",
@@ -31,9 +30,16 @@ export const sessionTitles = {
             if (session && !session.includes("/") && !session.includes("..")) {
                 const already = typeof titles[session] === "string" ? String(titles[session]).trim() : "";
                 if (!already) {
-                    const derived = legacy ||
-                        firstUserPromptText(path.join(ctx.dataDir, "sessions", session, "chat.jsonl")) ||
-                        session;
+                    /**
+                   * NOT derived from `chat.jsonl` here.
+                   *
+                   * A migration runs for EVERY agent at boot, and reading each session's log is exactly what the
+                   * operator ruled out — "起動中に読んでいいのはconfig.jsonとskillsだけ / セッションディレクトリは
+                   * セッションがロードされるまで開かない". A legacy `sessionTitle` is used when present; otherwise
+                   * the session id is a perfectly good name, and a real title is derived once when that session is
+                   * actually opened (`Master.ensureSessionTitle`).
+                   */
+                    const derived = legacy || session;
                     titles[session] = derived;
                     changed = true;
                 }

package/package.json

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