teapot-coding-agent 0.37.56 → 0.37.58

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,
@@ -655,7 +657,15 @@ export class Agent {
     /**
      * A short human title for this session, derived from the operator's first
      * prompt. Undefined until the log is read (or when there is no usable prompt).
+     *
+     * A MANUAL rename sets it too, and that must survive: the derivation above only fills it when it
+     * is still undefined, so an operator's name is never overwritten by the next restore. Without this
+     * path the header kept showing the old label after a rename — the value lives in `config.json`
+     * (`AgentConfig.sessionTitle`), and nothing wrote it into the live agent.
      */
+    setSessionTitle(title) {
+        this.sessionTitle = title?.trim() || undefined;
+    }
     sessionTitle;
     /** overflow recoveries used in the current turn; reset when a turn succeeds */
     overflowRecoveries = 0;

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?.({
@@ -425,6 +498,109 @@ export function isContextOverflow(err) {
  *  its work on `bash(background=true)` — dev server, watcher, long build —
  *  must NOT be nagged with "Continue working toward the current goal". The
  *  job's exit notification will wake the agent on its own. */
+/**
+ * The background shells for a workspace, as the UI sees them.
+ *
+ * Only a VIEW: no child process, no cursors. The `out` field is the tail kept for `bash_output`, so
+ * showing it costs nothing extra — the buffer is already there.
+ *
+ * `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, 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 [];
+    return [...m.values()]
+        .map((b) => ({
+        id: b.id,
+        cmd: b.cmd,
+        owner: b.owner,
+        running: !b.exited,
+        code: b.code,
+        startedAt: b.startedAt,
+        // the LAST slice: a job is watched to see what it is doing NOW, and the head of a 10MB log is
+        // the least interesting part of it
+        tail: b.out.slice(-4000),
+        bytes: b.out.length,
+        truncated: b.truncated,
+    }))
+        .sort((a, b) => b.startedAt - a.startedAt);
+}
+/**
+ * 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) {
+        try {
+            killTree(b.child);
+        }
+        catch {
+            /* already gone */
+        }
+        m.delete(id);
+        if (stateDir)
+            forgetJob(stateDir, id);
+        return true;
+    }
+    // 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;
+        }
+    }
+    return false;
+}
 export function hasRunningBgShells(cwd) {
     const m = bgShellsByWs.get(cwd);
     if (!m)

package/dist/master.js

@@ -2098,6 +2098,36 @@ When this task is done (or truly blocked), call finish() with a summary for @${p
      * the second: it deleted the config entry, which orphaned the session directory
      * (the files survived, but nothing in the UI could reach them again).
      */
+    /**
+     * Rename a session by hand.
+     *
+     * The stored title is what every surface shows (the sidebar row, the header, the tab), and
+     * `ensureSessionTitle` deliberately never overwrites an existing value — its own comment says so
+     * ("which is also what will let the operator rename a session by hand"). This is that path.
+     *
+     * Refuses an empty name rather than storing one: an empty `sessionTitle` is indistinguishable
+     * from "never derived", so the next `ensureSessionTitle` would silently re-derive and the
+     * operator's intent would vanish. Clearing to the derived default is what `reset` is for.
+     */
+    async renameSession(agentId, sessionId, title) {
+        const a = this.config.agents.find((x) => x.id === agentId);
+        if (!a)
+            throw new Error(`no such agent: ${agentId}`);
+        // the title names THAT session, so it may only be set on the one the agent is on
+        if (a.session !== sessionId)
+            throw new Error(`agent ${agentId} is not on session ${sessionId}`);
+        const clean = title.replace(/\s+/g, " ").trim().slice(0, 80);
+        if (!clean)
+            throw new Error("a session title cannot be empty");
+        a.sessionTitle = clean;
+        this.saveConfig();
+        // the live agent derives its own title from the log, so it has to be told — otherwise the header
+        // and sidebar keep the old label until a restart re-reads the config
+        this.agents.get(agentId)?.setSessionTitle(clean);
+        // the sidebar caches titles by session id, so it has to learn about this one
+        bus.emit("update", { kind: "agent-update", agentId });
+        return { title: clean };
+    }
     async archiveAgent(id) {
         const root = this.config.agents.find((a) => a.id === id);
         if (!root)

package/dist/server/api.js

@@ -13,6 +13,7 @@ import { promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { parseSchedule } from "../scheduler/cron.js";
 import { attachTerminal, closeTerminal, closeTerminalsFor, createTerminal, detachTerminal, forgetTerminalSize, listTerminals, reapIdleTerminals, resizeTerminal, setTerminalResize, writeTerminal, } from "./terminals.js";
+import { listBgShells, killBgShell } from "../agent/tools.js";
 import { applyPtySize, TermSizeTracker, resolvePtySlave } from "./term-size.js";
 import { expandTilde, homeDir } from "../home.js";
 import { SUB_PERSONAS, resolveWorkspace } from "../master.js";
@@ -611,7 +612,55 @@ export function buildApp(master) {
     // archive / restore / purge. "remove" used to mean "delete the config entry and
     // orphan the history on disk"; these make the three intents distinct — put it
     // away (reversible), bring it back, or destroy it for real.
+    /**
+     * Background shells for an agent's workspace.
+     *
+     * Scoped by AGENT rather than by workspace path: the operator thinks in agents, and a workspace is
+     * a shared thing several of them use. The registry keys by workspace (that is what needs killing),
+     * so the lookup is `agent.workspace` here and the response carries `owner` for each job.
+     *
+     * Read-only apart from the DELETE. There is deliberately no "start a job" route: background shells
+     * are an AGENT's tool, and a job the operator started would have no agent to notify.
+     */
+    app.get("/api/agents/:id/bg-jobs", (c) => {
+        const agent = master.agents.get(c.req.param("id"));
+        if (!agent)
+            return c.json({ error: "no such agent" }, 404);
+        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 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() }));
+    /**
+     * Rename the session the operator is looking at.
+     *
+     * `?session=` is required rather than inferred: a title names a SPECIFIC session, and an agent can
+     * own several, so defaulting to the agent's current one would rename the wrong thing whenever the
+     * UI was showing a past session of it.
+     */
+    app.put("/api/agents/:id/session-title", async (c) => {
+        const sessionId = c.req.query("session") ?? "";
+        if (!sessionId)
+            return c.json({ error: "?session= is required" }, 400);
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.title !== "string")
+            return c.json({ error: "title is required" }, 400);
+        try {
+            return c.json(await master.renameSession(c.req.param("id"), sessionId, body.title));
+        }
+        catch (err) {
+            const msg = err.message;
+            const code = /no such agent|not on session/.test(msg) ? 404 : 400;
+            return c.json({ error: msg }, code);
+        }
+    });
     app.post("/api/agents/:id/archive", async (c) => {
         try {
             return c.json(await master.archiveAgent(c.req.param("id")));

package/package.json

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