teapot-coding-agent 0.37.74 → 0.37.76

package/dist/master.js

@@ -714,6 +714,16 @@ 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 is read from `session.json`, which is the one copy.
+         */
+        const seedTitle = this.readSessionTitle(path.basename(sessionDir));
+        if (seedTitle)
+            agent.setSessionTitle(seedTitle);
         this.agents.set(ac.id, agent);
         if (opts.persist) {
             this.config.agents.push(ac);
@@ -730,6 +740,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 +1042,53 @@ 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 || sessionId.includes("/") || sessionId.includes(".."))
+            return null;
+        try {
+            const raw = JSON.parse(readFileSync(path.join(this.sessionsRoot(), sessionId, "session.json"), "utf8"));
+            const t = typeof raw.title === "string" ? raw.title.trim() : "";
+            return t ? t : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    writeSessionTitle(sessionId, title) {
+        if (!sessionId || sessionId.includes("/") || sessionId.includes(".."))
+            return;
+        const file = path.join(this.sessionsRoot(), sessionId, "session.json");
+        let raw = { v: 1 };
+        try {
+            raw = JSON.parse(readFileSync(file, "utf8"));
+        }
+        catch {
+        }
+        raw.title = title;
+        try {
+            writeFileSync(file, `${JSON.stringify(raw, null, 2)}\n`);
+        }
+        catch {
+        }
+    }
+    /**
+     * 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;
@@ -1263,7 +1311,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;
+        /**
+         * The title belongs to the SESSION, so it is stored with the session.
+         *
+         * It used to live in `config.json` — a second copy of a fact the session directory already owns,
+         * which is how it went stale: `recordSession()` deletes `sessionTitle` whenever the agent moves
+         * session, so a rename followed by any session switch silently reverted the name to the
+         * auto-generated one, and `config.json` was the only place that ever knew better.
+         */
+        this.writeSessionTitle(sessionId, clean);
+        delete a.sessionTitle;
         this.saveConfig();
         this.agents.get(agentId)?.setSessionTitle(clean);
         bus.emit("update", { kind: "agent-update", agentId });

package/dist/migrations/session-titles.js

@@ -1,4 +1,4 @@
-import { closeSync, openSync, readSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, readSync, writeFileSync } from "node:fs";
 import path from "node:path";
 export const sessionTitles = {
     order: 30,
@@ -8,17 +8,48 @@ export const sessionTitles = {
         const raw = ctx.raw();
         const agents = Array.isArray(raw.agents) ? raw.agents : [];
         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.
+         */
         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 dir = path.join(ctx.dataDir, "sessions", session);
+            const file = path.join(dir, "session.json");
+            let manifest = { v: 1 };
+            try {
+                manifest = JSON.parse(readFileSync(file, "utf8"));
+            }
+            catch {
+            }
+            const already = typeof manifest.title === "string" ? manifest.title.trim() : "";
+            if (!already) {
+                const fromConfig = typeof a.sessionTitle === "string" ? a.sessionTitle.trim() : "";
+                const derived = fromConfig || firstUserPromptText(path.join(dir, "chat.jsonl")) || session;
+                manifest.title = derived;
+                try {
+                    mkdirSync(dir, { recursive: true });
+                    writeFileSync(file, `${JSON.stringify(manifest, null, 2)}\n`);
+                }
+                catch {
+                }
+                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 (changed)
             ctx.touch();

package/package.json

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