teapot-coding-agent 0.37.75 → 0.37.77

package/dist/master.js

@@ -287,6 +287,10 @@ export class Master {
         this.raw.defaultProvider = this.config.defaultProvider;
         this.raw.tasks = this.config.tasks;
         this.raw.mcpServers = this.config.mcpServers;
+        if (this.config.sessionTitles !== undefined)
+            this.raw.sessionTitles = this.config.sessionTitles;
+        else
+            delete this.raw.sessionTitles;
         if (this.config.customThemes !== undefined)
             this.raw.customThemes = this.config.customThemes;
         if (this.config.password !== undefined)
@@ -714,6 +718,28 @@ export class Master {
             agent.toolCtx.subAgents = hooks;
         }
         await agent.init();
+        /**
+         * Seed the title from the SESSION, so a restart shows the name the operator gave it.
+         *
+         * `snapshot().sessionTitle` comes from the agent's own field, and that was only ever set by
+         * `renameSession` — so after a restart the UI fell back to the auto-generated name even though the
+         * title was on disk. The title comes from `config.sessionTitles`, which is the one copy.
+         */
+        const seedTitle = this.readSessionTitle(path.basename(sessionDir));
+        if (seedTitle)
+            agent.setSessionTitle(seedTitle);
+        else {
+            /**
+             * Derive a missing title at BOOT, once, and write it down.
+             *
+             * 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.
+             */
+            const id = path.basename(sessionDir);
+            this.writeSessionTitle(id, this.sessionTitleOf(sessionDir) ?? id);
+            agent.setSessionTitle(this.readSessionTitle(id) ?? id);
+        }
         this.agents.set(ac.id, agent);
         if (opts.persist) {
             this.config.agents.push(ac);
@@ -730,6 +756,9 @@ export class Master {
         if (!entry)
             return;
         entry.session = sessionId;
+        // The title is NOT deleted here: it now lives in the session's own manifest, so moving to another
+        // session simply means reading a different one. (Deleting it was how a rename reverted to the
+        // auto-generated name on the next switch.)
         delete entry.sessionTitle;
         delete ac.sessionTitle;
         if (this.sessionsReadOnly)
@@ -1029,18 +1058,49 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         const a = this.config.agents.find((x) => x.id === agentId);
         if (!a || a.session !== sessionId)
             return undefined;
-        const t = typeof a.sessionTitle === "string" ? a.sessionTitle.trim() : "";
-        return t ? t : undefined;
+        return this.readSessionTitle(sessionId) ?? undefined;
     }
+    /** The session's own name, from its manifest. One place, so it cannot go stale in another. */
+    readSessionTitle(sessionId) {
+        if (!sessionId)
+            return null;
+        const t = this.config.sessionTitles?.[sessionId];
+        return typeof t === "string" && t.trim() ? t.trim() : null;
+    }
+    writeSessionTitle(sessionId, title) {
+        if (!sessionId)
+            return;
+        /**
+         * Never write when the data dir was overridden by `TEAPOT_DATA_DIR`.
+         *
+         * In that mode the sessions being resolved are NOT the ones this config describes, so recording
+         * anything about them — a pointer, or now a title — corrupts a config the operator did not ask to
+         * change (#143). The title is still derived in memory so the UI shows something.
+         */
+        if (this.sessionsReadOnly) {
+            this.config.sessionTitles ??= {};
+            this.config.sessionTitles[sessionId] = title;
+            return;
+        }
+        this.config.sessionTitles ??= {};
+        this.config.sessionTitles[sessionId] = title;
+        this.saveConfig();
+    }
+    /**
+     * Derive a session's title ONCE, into the session's own manifest.
+     *
+     * Deriving it at read time would be worse: `sessionsOf`/`archivedAgents` would scan a `chat.jsonl`
+     * per session on every call (MEASURED earlier: 0.87s for one archive toggle). Writing it down once,
+     * where the session lives, keeps that scan off the hot path and keeps the answer in ONE place.
+     */
     async ensureSessionTitle(agentId, sessionId) {
         const a = this.config.agents.find((x) => x.id === agentId);
         if (!a || a.session !== sessionId)
             return;
-        if (a.sessionTitle?.trim())
+        if (this.readSessionTitle(sessionId))
             return;
         const dir = path.join(this.sessionsRoot(), sessionId);
-        a.sessionTitle = this.sessionTitleOf(dir) ?? sessionId;
-        this.saveConfig();
+        this.writeSessionTitle(sessionId, this.sessionTitleOf(dir) ?? sessionId);
     }
     sessionTitleOf(dirPath) {
         let fd;
@@ -1215,7 +1275,8 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
                 size = st.size;
             }
             catch { }
-            const title = owner ? this.titleFor(owner, d) : undefined;
+            // from the config map — no second per-directory read
+            const title = owner ? this.readSessionTitle(d) ?? undefined : undefined;
             out.push({ id: d, agentId: owner, mtimeMs: m, sizeBytes: size, ...(title ? { title } : {}) });
         }
         return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
@@ -1263,8 +1324,16 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         const clean = title.replace(/\s+/g, " ").trim().slice(0, 80);
         if (!clean)
             throw new Error("a session title cannot be empty");
-        a.sessionTitle = clean;
-        this.saveConfig();
+        /**
+         * The title is keyed by SESSION, not by agent.
+         *
+         * As `agents[].sessionTitle` it was per AGENT, so `recordSession()` had to delete it whenever the
+         * agent moved session — which is what reverted a rename — and a session no agent points at could not
+         * keep a name at all. The map fixes both AND keeps the left panel to one config read: storing it in
+         * `<session>/session.json` instead was MEASURED at 13.2ms for 838 sessions versus 1.2ms here.
+         */
+        this.writeSessionTitle(sessionId, clean);
+        delete a.sessionTitle;
         this.agents.get(agentId)?.setSessionTitle(clean);
         bus.emit("update", { kind: "agent-update", agentId });
         return { title: clean };

package/dist/migrations/session-titles.js

@@ -7,19 +7,48 @@ export const sessionTitles = {
     run(ctx) {
         const raw = ctx.raw();
         const agents = Array.isArray(raw.agents) ? raw.agents : [];
+        const isRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
         let changed = false;
+        /**
+         * Move the title out of `config.json` and into the session's own `session.json`.
+         *
+         * It used to be stored in `config.json` — a second copy of something the session directory owns,
+         * and the copy that went stale. A title already present wins over a derived one, so an operator's
+         * rename is never replaced by the auto-generated name.
+         */
+        /**
+         * Move `agents[].sessionTitle` into the `sessionTitles` MAP, keyed by session id.
+         *
+         * Per-agent was the wrong key: an agent moves between sessions, so the field had to be cleared on
+         * every switch (which reverted a rename), and a session no agent points at could not keep a name.
+         * A map also keeps the left panel to ONE config read instead of a `session.json` per directory —
+         * MEASURED: 838 sessions = 13.2ms of directory reads vs 1.2ms for the config file.
+         */
+        const titles = (raw.sessionTitles = isRecord(raw.sessionTitles) ? raw.sessionTitles : {});
         for (const a of agents) {
             const session = typeof a.session === "string" ? a.session : "";
-            if (!session)
-                continue;
-            if (typeof a.sessionTitle === "string" && a.sessionTitle.trim())
-                continue;
-            if (session.includes("/") || session.includes(".."))
-                continue;
-            const title = firstUserPromptText(path.join(ctx.dataDir, "sessions", session, "chat.jsonl"));
-            a.sessionTitle = title ?? session;
-            changed = true;
+            const legacy = typeof a.sessionTitle === "string" ? a.sessionTitle.trim() : "";
+            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;
+                    titles[session] = derived;
+                    changed = true;
+                }
+            }
+            /**
+             * Only report a change when one happened: a migration that claims success every boot rewrites
+             * the config file forever, and re-running must be a genuine no-op (the suite asserts it).
+             */
+            if (a.sessionTitle !== undefined) {
+                delete a.sessionTitle;
+                changed = true;
+            }
         }
+        if (Object.keys(titles).length === 0 && raw.sessionTitles !== undefined)
+            delete raw.sessionTitles;
         if (changed)
             ctx.touch();
         return changed;

package/package.json

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