teapot-coding-agent 0.37.57 → 0.37.59

package/dist/agent/agent.js

@@ -610,6 +610,8 @@ export class Agent {
             // so a background job records WHICH agent started it: sibling agents share a workspace,
             // and `isLive()` must not count their jobs as this one's work in flight
             agentId: opts.id,
+            // the job RECORD lives beside the session, not in a global dir: it is this agent's history
+            stateDir: opts.sessionDir,
             defaultTimeoutMs: 120_000,
             maxOutputBytes: 60_000,
             skillRoots: this.skillRoots,

package/dist/agent/tools.js

@@ -3,7 +3,7 @@
  * Tool specs are plain JSON-schema function definitions — provider-agnostic.
  */
 import { spawn } from "node:child_process";
-import { existsSync, promises as fs, readlinkSync, realpathSync } from "node:fs";
+import { existsSync, promises as fs, mkdirSync, readFileSync, readlinkSync, realpathSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import { discoverSkills, isValidSkillName, readSkillFile, saveSkill, SKILL_FILE, } from "./skills.js";
 import { isReasoningEffort } from "../model-meta.js";
@@ -338,6 +338,62 @@ function toolShell() {
 export function elapsed(t0, now = Date.now()) {
     return `\n[took ${((now - t0) / 1000).toFixed(1)}s]`;
 }
+const jobsFile = (dir) => path.join(dir, "bg-jobs.json");
+/** read the persisted records, tolerating a missing or corrupt file (never throws) */
+function readJobRecords(dir) {
+    try {
+        const raw = readFileSync(jobsFile(dir), "utf8");
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((r) => r && typeof r.id === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Write the records atomically enough for this purpose.
+ *
+ * A torn write here is not worth a fsync: the file is a hint for the NEXT boot, and the worst case is
+ * losing one restart's worth of "this was running". Losing a job's identity entirely (the shipped
+ * behaviour) is what this exists to stop.
+ */
+function writeJobRecords(dir, records) {
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(jobsFile(dir), JSON.stringify(records, null, 1));
+    }
+    catch {
+        /* a read-only session dir must not break the tool */
+    }
+}
+/** add or update one record (by id) */
+function rememberJob(dir, rec) {
+    const all = readJobRecords(dir).filter((r) => r.id !== rec.id);
+    all.push(rec);
+    writeJobRecords(dir, all);
+}
+/** drop a record — the job finished AND was reported, or was killed */
+function forgetJob(dir, id) {
+    writeJobRecords(dir, readJobRecords(dir).filter((r) => r.id !== id));
+}
+/**
+ * Jobs a PREVIOUS process started and whose processes may still be alive.
+ *
+ * `alive` is answered by the caller (pidExists) rather than here, so this module stays free of the
+ * signal-plumbing and the test can drive either answer. A record whose pid is gone is stale and is
+ * dropped: reporting a finished job as running is the same class of lie as forgetting a live one.
+ */
+export function recoverableJobs(dir, alive) {
+    const all = readJobRecords(dir);
+    const live = [];
+    for (const r of all) {
+        if (r.pid !== null && alive(r.pid))
+            live.push(r);
+    }
+    if (live.length !== all.length)
+        writeJobRecords(dir, live);
+    return live;
+}
 function startBackgroundShell(cmd, ctx) {
     const map = bgMapFor(ctx.cwd);
     // opportunistic cleanup of long-dead jobs so the map can't grow forever
@@ -367,6 +423,20 @@ function startBackgroundShell(cmd, ctx) {
         else
             sh.truncated = true;
     };
+    /**
+     * Persist the RECORD, so a later process can at least say this job exists.
+     *
+     * The `pid` is what makes it checkable on boot: a job whose pid is gone is dropped, one whose pid
+     * is alive is reported as "still running, output no longer reachable". That is the honest answer
+     * after a restart — see `ToolContext.stateDir`.
+     */
+    if (ctx.stateDir) {
+        rememberJob(ctx.stateDir, {
+            id, cmd, owner: ctx.agentId ?? "", workspace: ctx.cwd,
+            pid: child.pid ?? null,
+            startedAt: sh.startedAt,
+        });
+    }
     child.stdout?.on("data", collect);
     child.stderr?.on("data", collect);
     // "exit" (process gone) and "close" (all stdio drained) are DIFFERENT events.
@@ -389,6 +459,9 @@ function startBackgroundShell(cmd, ctx) {
         if (exitNotified)
             return;
         exitNotified = true;
+        // the job is over: its record must not claim otherwise on the next boot
+        if (ctx.stateDir)
+            forgetJob(ctx.stateDir, id);
         // tell the harness so the agent learns the outcome WITHOUT polling
         try {
             ctx.onBackgroundExit?.({
@@ -434,7 +507,48 @@ export function isContextOverflow(err) {
  * `owner` is included because several agents share one workspace (every sub-agent inherits its
  * parent's), and "whose job is this" is the first thing an operator asks when deciding what to kill.
  */
-export function listBgShells(cwd) {
+export function listBgShells(cwd, stateDir) {
+    const live = liveShells(cwd);
+    /**
+     * Records from a previous process are appended, marked `detached`.
+     *
+     * Without them a job that survived a restart is INVISIBLE — MEASURED: a 3-hour GPU sweep kept
+     * writing while the panel showed nothing and `bash_output` said "forgotten on harness restart".
+     * The process cannot be re-attached (no fd survives the parent), so `detached` is the whole truth
+     * the UI can be given: it is running, and its output lives wherever the command redirected it.
+     */
+    if (!stateDir)
+        return live;
+    const known = new Set(live.map((j) => j.id));
+    const recovered = recoverableJobs(stateDir, pidExists)
+        .filter((r) => !known.has(r.id) && r.workspace === cwd)
+        .map((r) => ({
+        id: r.id,
+        cmd: r.cmd,
+        owner: r.owner,
+        running: true,
+        detached: true,
+        pid: r.pid,
+        code: null,
+        startedAt: r.startedAt,
+        tail: "",
+        bytes: 0,
+        truncated: false,
+    }));
+    return [...live, ...recovered].sort((a, b) => b.startedAt - a.startedAt);
+}
+/** does this pid exist? (EPERM means it exists but is not ours to signal) */
+function pidExists(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** the jobs THIS process is running, as the UI sees them */
+function liveShells(cwd) {
     const m = bgShellsByWs.get(cwd);
     if (!m)
         return [];
@@ -454,20 +568,38 @@ export function listBgShells(cwd) {
     }))
         .sort((a, b) => b.startedAt - a.startedAt);
 }
-/** kill ONE background job; returns whether it existed */
-export function killBgShell(cwd, id) {
+/**
+ * Kill ONE background job; returns whether it existed.
+ *
+ * A DETACHED job (a record from a previous process) is handled differently on purpose: the harness no
+ * longer owns that process, so this drops the RECORD and does NOT signal the pid. Killing a pid we
+ * merely remember is how an unrelated process gets killed after pid reuse — and the operator's own
+ * instruction was to never touch a job from an earlier session. The caller reports what happened.
+ */
+export function killBgShell(cwd, id, stateDir) {
     const m = bgShellsByWs.get(cwd);
     const b = m?.get(id);
-    if (!b)
-        return false;
-    try {
-        killTree(b.child);
+    if (b) {
+        try {
+            killTree(b.child);
+        }
+        catch {
+            /* already gone */
+        }
+        m.delete(id);
+        if (stateDir)
+            forgetJob(stateDir, id);
+        return true;
     }
-    catch {
-        /* already gone */
+    // not ours any more: forget it, leave the process alone
+    if (stateDir) {
+        const rec = readJobRecords(stateDir).find((r) => r.id === id);
+        if (rec) {
+            forgetJob(stateDir, id);
+            return true;
+        }
     }
-    m.delete(id);
-    return true;
+    return false;
 }
 export function hasRunningBgShells(cwd) {
     const m = bgShellsByWs.get(cwd);

package/dist/server/api.js

@@ -626,13 +626,15 @@ export function buildApp(master) {
         const agent = master.agents.get(c.req.param("id"));
         if (!agent)
             return c.json({ error: "no such agent" }, 404);
-        return c.json({ jobs: listBgShells(agent.snapshot().workspace ?? "") });
+        const snap = agent.snapshot();
+        return c.json({ jobs: listBgShells(snap.workspace ?? "", snap.sessionDir) });
     });
     app.delete("/api/agents/:id/bg-jobs/:job", (c) => {
         const agent = master.agents.get(c.req.param("id"));
         if (!agent)
             return c.json({ error: "no such agent" }, 404);
-        const ok = killBgShell(agent.snapshot().workspace ?? "", c.req.param("job"));
+        const snap = agent.snapshot();
+        const ok = killBgShell(snap.workspace ?? "", c.req.param("job"), snap.sessionDir);
         return c.json({ ok }, ok ? 200 : 404);
     });
     app.get("/api/archived", (c) => c.json({ agents: master.archivedAgents() }));

package/package.json

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