teapot-coding-agent 0.22.7 → 0.22.9

package/dist/master.js

@@ -380,6 +380,9 @@ export class Master {
         }
         const sessionDir = this.resolveSessionDir(ac.id, opts.fresh === true);
         await mkdirSync(sessionDir, { recursive: true });
+        // every session dir this master hands out carries an ownership manifest —
+        // legacy dirs get backfilled on their first restart under the new code
+        this.writeSessionManifest(sessionDir, ac.id);
         const agent = new Agent({
             id: ac.id,
             workspace: path.resolve(ac.workspace),
@@ -639,12 +642,19 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         }
     }
     async messageChild(parentId, childId, text) {
-        const cfg = this.config.agents.find((a) => a.id === childId);
+        // childId is normally the live agent id — but an internal session id
+        // (sessions/<id>, the stable timeline handle) also resolves, so callers
+        // holding only a session reference can still reach the owning agent.
+        let targetId = childId;
+        const owned = this.sessionById(childId);
+        if (owned)
+            targetId = owned.agentId;
+        const cfg = this.config.agents.find((a) => a.id === targetId);
         if (!cfg || cfg.parent !== parentId)
             throw new Error(`not your sub-agent: ${childId}`);
-        const child = this.agents.get(childId);
+        const child = this.agents.get(targetId);
         if (!child)
-            throw new Error(`sub-agent not running: ${childId}`);
+            throw new Error(`sub-agent not running: ${targetId}`);
         child.enqueuePrompt(`[harness] Message from @${parentId}:\n\n${text}`, "harness");
         if (child.status !== "running")
             child.start(`message from ${parentId}`);
@@ -700,51 +710,92 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
     sessionsRoot() {
         return path.join(this.config.dataDir, "sessions");
     }
+    /**
+     * Session-dir ownership manifest (sessions/<dir>/session.json). Ownership
+     * used to be GUESSED from the directory name's prefix, which is ambiguous:
+     * agent "teapot" matches "teapot-3-<hash>", and sibling ids where one is a
+     * 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; legacy dirs without a manifest
+     * fall back to longest-prefix inference and get one backfilled on first
+     * touch.
+     */
+    readSessionOwner(dirName) {
+        try {
+            const raw = JSON.parse(readFileSync(path.join(this.sessionsRoot(), dirName, "session.json"), "utf8"));
+            return typeof raw.agentId === "string" ? raw.agentId : null;
+        }
+        catch {
+            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");
+            if (existsSync(file))
+                return; // never clobber an existing manifest
+            writeFileSync(file, `${JSON.stringify({ v: 1, agentId }, null, 2)}\n`);
+        }
+        catch {
+            /* best-effort metadata */
+        }
+    }
     findLatestSessionDir(agentId) {
-        // Directory names are prefix-matched (exact, then "<id>-<suffix>"), which
-        // is ambiguous across ids: agent "teapot" also matches "teapot-3-<hash>",
-        // and newest-wins then handed agent teapot agent teapot-3's live session
-        // — two agents writing one timeline. Exclude directories that belong to
-        // ANOTHER configured agent id (or another live agent) before picking.
-        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);
-        }
-        const belongsToOther = (dir) => {
-            for (const other of otherIds) {
-                if (other === dir || dir.startsWith(`${other}-`))
-                    return true;
-            }
-            return false;
-        };
+        // 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. 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) => d === agentId || d.startsWith(`${agentId}-`))
-                .filter((d) => !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;
-                }
-                catch {
-                    return false;
+                    size = statSync(path.join(dirPath, "chat.jsonl")).size;
                 }
-            })
-                .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;
@@ -763,10 +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);
-        if (!fresh && statSync(path.join(selfDir, "chat.jsonl"), { throwIfNoEntry: false })?.size) {
+        const selfOwner = this.readSessionOwner(agentId);
+        const selfUsable = selfOwner === null || selfOwner === agentId;
+        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)
@@ -791,8 +847,81 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         do {
             sid = `${agentId}-${randomUUID().slice(0, 8)}`;
         } while (existsSync(path.join(root, sid)));
+        this.writeSessionManifest(path.join(root, sid), agentId);
         return path.join(root, sid);
     }
+    /**
+     * 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.
+     */
+    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());
+        }
+        catch {
+            return [];
+        }
+        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) {
+        // internal ids are directory names: refuse anything path-like up front
+        if (!sessionId || sessionId.includes("/") || sessionId.includes("\\") || sessionId.startsWith("."))
+            return null;
+        const root = this.sessionsRoot();
+        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 {
+            const st = statSync(path.join(root, sessionId));
+            if (!st.isDirectory())
+                return null;
+        }
+        catch {
+            return null;
+        }
+        return { agentId: owner, dir: path.join(root, sessionId) };
+    }
     async removeAgent(id) {
         const agent = this.agents.get(id);
         if (!agent)

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)
@@ -923,13 +906,21 @@ export function buildApp(master) {
         if (!a)
             return c.json({ error: "not found" }, 404);
         const limit = Math.min(Number(c.req.query("limit") ?? 200), 5000);
-        let events = await readEventsCached(a.log.filePath);
+        let filePath = a.log.filePath;
+        // ?session=<internalId> reads ANY session owned by this agent (past
+        // incarnations too) — the internal id, not the agent id, is the stable
+        // timeline handle. Ownership is enforced via the manifest.
+        const sessionId = c.req.query("session");
+        if (sessionId) {
+            const rec = master.sessionById(sessionId);
+            if (!rec || rec.agentId !== c.req.param("id"))
+                return c.json({ error: "not found" }, 404);
+            filePath = path.join(rec.dir, "chat.jsonl");
+        }
+        let events = await readEventsCached(filePath);
         const branch = c.req.query("branch");
-        const session = c.req.query("session");
         if (branch)
             events = events.filter((e) => e.branch === branch);
-        if (session)
-            events = events.filter((e) => e.session === session);
         // cursor pagination for older pages: everything strictly BEFORE this id
         const before = c.req.query("before");
         if (before) {
@@ -939,6 +930,22 @@ 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) => {
+        const id = c.req.param("id");
+        // 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);
+        const owned = master.sessionsOf(id);
+        if (!known && owned.length === 0)
+            return c.json({ error: "not found" }, 404);
+        return c.json({ sessions: owned });
+    });
     app.get("/api/agents/:id/branches", async (c) => {
         const a = master.agents.get(c.req.param("id"));
         if (!a)

package/package.json

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