teapot-coding-agent 0.22.8 → 0.22.9

package/dist/master.js

@@ -717,8 +717,9 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
      * prefix of the other ("prismrv-root-sub-review" vs
      * "…-review-kernel") excluded each other's own dirs — every restart then
      * generated a fresh empty session and history read as zero. The owner is
-     * now recorded explicitly at creation time; prefix matching only remains
-     * as a fallback for legacy dirs without a manifest.
+     * now recorded explicitly at creation time; legacy dirs without a manifest
+     * fall back to longest-prefix inference and get one backfilled on first
+     * touch.
      */
     readSessionOwner(dirName) {
         try {
@@ -729,6 +730,24 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             return null; // legacy dir or unreadable manifest → fall back to names
         }
     }
+    /**
+     * Owner of a session dir — manifest first; legacy dirs are inferred from
+     * the LONGEST configured/live id whose "<id>" or "<id>-<rest>" shape the
+     * name matches. Returns {owner, hadManifest} so callers can backfill.
+     */
+    inferSessionOwner(dirName, candidateIds) {
+        const fromManifest = this.readSessionOwner(dirName);
+        if (fromManifest)
+            return { owner: fromManifest, hadManifest: true };
+        let best = null;
+        for (const id of candidateIds) {
+            if (!id)
+                continue;
+            if ((id === dirName || dirName.startsWith(`${id}-`)) && (!best || id.length > best.len))
+                best = { id, len: id.length };
+        }
+        return { owner: best?.id ?? null, hadManifest: false };
+    }
     writeSessionManifest(dirPath, agentId) {
         try {
             const file = path.join(dirPath, "session.json");
@@ -744,58 +763,39 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         // Directory names alone are ambiguous: agent "teapot" prefix-matches
         // "teapot-3-<hash>", and sibling ids where one is a prefix of the other
         // ("prismrv-root-sub-review" vs "…-review-kernel") used to exclude each
-        // other's own dirs — every restart then generated a fresh empty session
-        // and history read as zero. The manifest written at creation time
-        // decides; only legacy dirs without one fall back to name matching.
-        const otherIds = new Set();
-        for (const a of this.config.agents) {
-            if (a.id && a.id !== agentId)
-                otherIds.add(a.id);
-        }
-        for (const [liveId] of this.agents) {
-            if (liveId !== agentId)
-                otherIds.add(liveId);
-        }
-        // legacy fallback: ownership goes to the LONGEST id matching the name
-        const belongsToOther = (dir) => {
-            const matchedLen = (id) => id === dir || dir.startsWith(`${id}-`) ? id.length : 0;
-            const own = matchedLen(agentId); // always > 0: caller pre-filtered by id
-            let bestOther = 0;
-            for (const other of otherIds) {
-                const len = matchedLen(other);
-                if (len > bestOther)
-                    bestOther = len;
-            }
-            return bestOther > own; // equal-length ids cannot both match one dir
-        };
+        // other's own dirs. Ownership comes from the manifest; legacy dirs are
+        // inferred by longest matching id.
+        const candidateIds = new Set([agentId]); // the agent itself owns its bare-name dir
+        for (const a of this.config.agents)
+            if (a.id)
+                candidateIds.add(a.id);
+        for (const [liveId] of this.agents)
+            candidateIds.add(liveId);
         let dirs = [];
         try {
-            dirs = readdirSync(this.sessionsRoot())
-                .filter((d) => {
-                const owner = this.readSessionOwner(d);
-                if (owner)
-                    return owner === agentId; // manifest decides
-                // legacy dir without a manifest: name-prefix + longest-match rule
-                return (d === agentId || d.startsWith(`${agentId}-`)) && !belongsToOther(d);
-            })
-                .filter((d) => {
-                // an EMPTY chat.jsonl means the session was never used (created via
-                // web, then abandoned). Reusing it would resurrect another agent's
-                // timeline under this id, and two incarnations could even land in
-                // one directory. Never treat empty logs as existing history.
+            const withHistory = [];
+            const empty = [];
+            for (const d of readdirSync(this.sessionsRoot())) {
+                const { owner } = this.inferSessionOwner(d, candidateIds);
+                if (owner !== agentId)
+                    continue;
+                const dirPath = path.join(this.sessionsRoot(), d);
+                const m = this.sessionMtime(dirPath);
+                // an EMPTY chat.jsonl means the session was never really used — but it
+                // must not SHADOW a real history dir: an incarnation's state events
+                // keep refreshing the empty log's mtime, and newest-wins would then
+                // pick the empty one forever ("timeline of zero" on every restart).
+                let size = 0;
                 try {
-                    return statSync(path.join(this.sessionsRoot(), d, "chat.jsonl")).size > 0;
+                    size = statSync(path.join(dirPath, "chat.jsonl")).size;
                 }
-                catch {
-                    return false;
-                }
-            })
-                .sort((a, b) => {
-                // newest chat.jsonl wins
-                const ma = this.sessionMtime(path.join(this.sessionsRoot(), a));
-                const mb = this.sessionMtime(path.join(this.sessionsRoot(), b));
-                return mb - ma;
-            });
+                catch { /* no log yet */ }
+                (size > 0 ? withHistory : empty).push({ d, m });
+            }
+            const pick = (list) => list.sort((a, b) => b.m - a.m)[0]?.d;
+            // prefer a dir that actually carries history; fall back to the newest
+            // empty one ONLY when no history exists under this id at all
+            dirs = [pick(withHistory) ?? pick(empty)].filter((x) => !!x);
         }
         catch {
             return null;
@@ -814,14 +814,15 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         const root = this.sessionsRoot();
         mkdirSync(root, { recursive: true });
         // exact-restart match first: <agentId> itself (or a previously generated
-        // <agentId>-<suffix> dir when the bare name was taken). Prefix matching
-        // alone could hand agent "proj-2" agent "proj"'s directory.
+        // <agentId>-<suffix> dir when the bare name was taken) — but only when it
+        // actually carries history. An empty log here must not shadow the real
+        // one found by findLatestSessionDir below.
         const selfDir = path.join(root, agentId);
-        // the manifest on the bare-name dir wins: another agent may own it now
-        // (ids are recycled across incarnations). No manifest → legacy behavior.
         const selfOwner = this.readSessionOwner(agentId);
         const selfUsable = selfOwner === null || selfOwner === agentId;
-        if (!fresh && selfUsable && statSync(path.join(selfDir, "chat.jsonl"), { throwIfNoEntry: false })?.size) {
+        if (!fresh &&
+            selfUsable &&
+            statSync(path.join(selfDir, "chat.jsonl"), { throwIfNoEntry: false })?.size) {
             return selfDir; // restart → continue where we left off
         }
         // one-time migration from the ≤0.5.0 flat layout (<dataDir>/<id>.jsonl)
@@ -850,11 +851,17 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         return path.join(root, sid);
     }
     /**
-     * Internal session ids (= directory names) owned by an agent, newest log
-     * first. These are the stable handles the web UI routes by — agent ids can
-     * be recycled across incarnations, internal session ids cannot.
+     * All session dirs on disk with their inferred/manifested owner, newest
+     * log first. One readdir powers every "list sessions" need — the UI calls
+     * the aggregated endpoint instead of fanning out one request per agent.
      */
-    sessionsOf(agentId) {
+    allSessions() {
+        const candidateIds = new Set(this.config.agents.map((a) => a.id).filter(Boolean));
+        for (const [liveId] of this.agents)
+            candidateIds.add(liveId);
+        // dir names themselves are candidate owners too: "s" owns legacy "s",
+        // "teapot-3-3c0048d7" is best matched by the longest configured id —
+        // inference needs the id set only, so nothing extra to add here.
         let names = [];
         try {
             names = readdirSync(this.sessionsRoot());
@@ -862,10 +869,36 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         catch {
             return [];
         }
-        return names
-            .filter((d) => this.readSessionOwner(d) === agentId)
-            .map((d) => ({ id: d, mtimeMs: this.sessionMtime(path.join(this.sessionsRoot(), d)) }))
-            .sort((a, b) => b.mtimeMs - a.mtimeMs);
+        const out = [];
+        for (const d of names) {
+            const dirPath = path.join(this.sessionsRoot(), d);
+            const { owner, hadManifest } = this.inferSessionOwner(d, candidateIds);
+            if (!owner)
+                continue; // orphan dir (unknown owner) — not addressable
+            // backfill legacy dirs so the inference result becomes durable
+            if (!hadManifest)
+                this.writeSessionManifest(dirPath, owner);
+            let m = 0;
+            let size = 0;
+            try {
+                const st = statSync(path.join(dirPath, "chat.jsonl"));
+                m = st.mtimeMs;
+                size = st.size;
+            }
+            catch { /* no log yet — still listable */ }
+            out.push({ id: d, agentId: owner, mtimeMs: m, sizeBytes: size });
+        }
+        return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    }
+    /**
+     * Internal session ids (= directory names) owned by an agent, newest log
+     * first. These are the stable handles the web UI routes by — agent ids can
+     * be recycled across incarnations, internal session ids cannot.
+     */
+    sessionsOf(agentId) {
+        return this.allSessions()
+            .filter((s) => s.agentId === agentId)
+            .map(({ id, mtimeMs, sizeBytes }) => ({ id, mtimeMs, sizeBytes }));
     }
     /** resolve an internal session id to (ownerAgentId, absolute dir) — null when it doesn't exist */
     sessionById(sessionId) {
@@ -873,7 +906,10 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.startsWith("."))
             return null;
         const root = this.sessionsRoot();
-        const owner = this.readSessionOwner(sessionId);
+        const candidateIds = new Set(this.config.agents.map((a) => a.id).filter(Boolean));
+        for (const [liveId] of this.agents)
+            candidateIds.add(liveId);
+        const { owner } = this.inferSessionOwner(sessionId, candidateIds);
         if (!owner)
             return null;
         try {

package/dist/server/api.js

@@ -871,23 +871,6 @@ export function buildApp(master) {
         return c.json({ ok: true });
     });
     // edit a previously-sent prompt: forks there, optionally summarizes the tail
-    app.post("/api/agents/:id/edit-prompt", async (c) => {
-        const a = master.agents.get(c.req.param("id"));
-        if (!a)
-            return c.json({ error: "not found" }, 404);
-        const body = await c.req
-            .json()
-            .catch(() => null);
-        if (!body?.eventId || !body.text?.trim())
-            return c.json({ error: "eventId and text required" }, 400);
-        try {
-            const r = await a.editPromptAt(body.eventId, body.text, body.tail === "summarize" ? "summarize" : "discard");
-            return c.json({ ok: true, ...r });
-        }
-        catch (err) {
-            return c.json({ error: err.message }, 409);
-        }
-    });
     app.post("/api/agents/:id/fork", async (c) => {
         const a = master.agents.get(c.req.param("id"));
         if (!a)
@@ -947,6 +930,10 @@ export function buildApp(master) {
         }
         return c.json({ events: events.slice(-limit), total: events.length });
     });
+    // ONE readdir-backed snapshot of every session on disk, owner included.
+    // The UI fetches this once per agent-set change instead of fanning out one
+    // request per agent — /api/agents/:id/sessions stays for compatibility.
+    app.get("/api/sessions", (c) => c.json({ sessions: master.allSessions() }));
     // list the internal session ids (= stable timeline handles) an agent owns,
     // newest first — the web UI routes /session/<internalId> by these
     app.get("/api/agents/:id/sessions", (c) => {
@@ -954,9 +941,10 @@ export function buildApp(master) {
         // resolvable when live, configured, OR still owning sessions on disk
         // (a stopped/lazy agent must keep its timeline reachable)
         const known = master.agents.has(id) || master.config.agents.some((a) => a.id === id);
-        if (!known && master.sessionsOf(id).length === 0)
+        const owned = master.sessionsOf(id);
+        if (!known && owned.length === 0)
             return c.json({ error: "not found" }, 404);
-        return c.json({ sessions: master.sessionsOf(id) });
+        return c.json({ sessions: owned });
     });
     app.get("/api/agents/:id/branches", async (c) => {
         const a = master.agents.get(c.req.param("id"));

package/package.json

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