teapot-coding-agent 0.22.6 → 0.22.8

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}`);
@@ -677,7 +687,12 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
                     "\n\n[Last conversation turns before finishing]\n" +
                         d.recentContext.map((r) => r).join("\n\n");
             }
-            parent.enqueuePrompt(`[harness] Sub-agent ${ac.id} finished. Final report:\n${report.slice(0, 6000) || "(no summary)"}`, "harness");
+            parent.enqueuePrompt(
+            // NO truncation: the sub's report is the parent's primary input for
+            // deciding what to do next. Clipping it (the old 2000/6000 caps)
+            // silently dropped exactly the details the operator spawned the sub
+            // to gather. Context management is compaction's job, not the pipe's.
+            `[harness] Sub-agent ${ac.id} finished. Final report:\n${report || "(no summary)"}`, "harness");
         }
         else if (e.type === "error") {
             parent.enqueuePrompt(`[harness] Sub-agent ${ac.id} hit an error: ${String(e.data.message ?? "").slice(0, 500)}`, "harness");
@@ -695,12 +710,43 @@ 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; prefix matching only remains
+     * as a fallback for legacy dirs without a manifest.
+     */
+    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
+        }
+    }
+    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.
+        // 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)
@@ -710,18 +756,28 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
             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) {
-                if (other === dir || dir.startsWith(`${other}-`))
-                    return true;
+                const len = matchedLen(other);
+                if (len > bestOther)
+                    bestOther = len;
             }
-            return false;
+            return bestOther > own; // equal-length ids cannot both match one dir
         };
         let dirs = [];
         try {
             dirs = readdirSync(this.sessionsRoot())
-                .filter((d) => d === agentId || d.startsWith(`${agentId}-`))
-                .filter((d) => !belongsToOther(d))
+                .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
@@ -761,7 +817,11 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
         // <agentId>-<suffix> dir when the bare name was taken). Prefix matching
         // alone could hand agent "proj-2" agent "proj"'s directory.
         const selfDir = path.join(root, agentId);
-        if (!fresh && statSync(path.join(selfDir, "chat.jsonl"), { throwIfNoEntry: false })?.size) {
+        // 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) {
             return selfDir; // restart → continue where we left off
         }
         // one-time migration from the ≤0.5.0 flat layout (<dataDir>/<id>.jsonl)
@@ -786,8 +846,46 @@ 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);
     }
+    /**
+     * 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) {
+        let names = [];
+        try {
+            names = readdirSync(this.sessionsRoot());
+        }
+        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);
+    }
+    /** 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 owner = this.readSessionOwner(sessionId);
+        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

@@ -923,13 +923,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 +947,17 @@ export function buildApp(master) {
         }
         return c.json({ events: events.slice(-limit), total: events.length });
     });
+    // 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);
+        if (!known && master.sessionsOf(id).length === 0)
+            return c.json({ error: "not found" }, 404);
+        return c.json({ sessions: master.sessionsOf(id) });
+    });
     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.6",
+  "version": "0.22.8",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",