teapot-coding-agent 0.4.0 → 0.6.0

package/README.md

@@ -13,6 +13,11 @@ tab, and any number of long-running agents.
   (`frontend/`, built to `public/`): agents as channels, events flowing as chat
   messages, tool calls as compact embeds. Markdown is rendered by a hand-written,
   XSS-safe renderer (`frontend/md.js`)
+- **Integrated terminal** — humans get an interactive shell (xterm.js over
+  WebSocket) inside the selected agent's workspace: inspect what the agent
+  did, run tests, fix things alongside it. Zero native dependencies — the PTY
+  comes from util-linux `script` when available (colors, line editing,
+  ctrl+c), with a plain-pipe fallback elsewhere.
 - **Human-readable persistence** — append-only JSONL event logs you can read
   with `cat` / `jq`; goal & memory as plain Markdown files in git
 
@@ -105,13 +110,34 @@ master (Hono server, src/master.ts + src/server/api.ts)
   never hard-coded.
 - **Tools** (`src/agent/tools.ts`): provider-agnostic JSON-schema function
   specs — `read_file`, `write_file`, `edit_file`, `list_dir`, `bash` (git goes
-  through bash), plus meta tools `finish` / `report_progress`. Paths are
-  confined to the workspace; bash runs detached in its own process group and
-  the whole group is SIGKILLed on timeout.
-- **Goal / knowledge**: `GOAL.md` (goal + status), `AGENTS.md` (project
-  knowledge), `MEMORY.md` (agent notes) live in each workspace as normal git-
-  editable Markdown. The goal file is the source of truth; the harness re-reads
-  it on restart.
+  through bash), plus meta tools `finish` / `report_progress` / `set_goal` /
+  `set_memory`. Paths are confined to the workspace; bash runs detached in its
+  own process group and the whole group is SIGKILLed on timeout.
+- **Session storage** — everything teapot manages lives under
+  `<dataDir>/sessions/<sid>/` (`chat.jsonl`, `goal.md`, `memory.md`), so agent
+  workspaces stay clean. Each incarnation gets a fresh `<agentId>-<uuid>`
+  directory (no history leaks across projects); restarts reuse the latest one.
+  Legacy layouts are migrated automatically.
+- **Goal / knowledge** — goal + memory are harness-managed and injected into
+  the prompt every turn (agents update them via `set_goal` / `set_memory`);
+  `AGENTS.md` is optional project knowledge in the workspace root that is
+  injected when present. Nothing is seeded into your project anymore.
+
+### Web UI
+
+- **Sessions as channels** — chat feed with live-streamed LLM output (💭
+  reasoning collapsible), tool calls/results as expandable embeds, progress
+  reports and state changes as dividers
+- **Deep links** — every session has a URL (`http://localhost:7788/session/<id>`);
+  the last open session is remembered
+- **Details panel** (`d`) — session info, model switcher (provider select +
+  OpenAI-compatible `GET /models` autocomplete; applies to the running
+  session from the next turn), controls, goal editor, progress, runtime stats
+- **Terminal** (`t`) — interactive shell in the agent's workspace for humans,
+  rendered with xterm.js over WebSocket
+- **Keyboard** — `↑`/`↓` switch sessions · `/` focus composer · `t` terminal ·
+  `d` panel · `esc` interrupt a running agent
+- Realtime updates flow over WebSocket (`/api/ws`) with auto-reconnect
 
 ### Agent Skills
 
@@ -141,13 +167,14 @@ description: Steps to cut a release safely
 
 ### Session log format (JSONL)
 
-One file per agent (`dataDir/<agent>.jsonl`); every conversation *including
-forks* lives in the same interleaved stream:
+One file per session (`<dataDir>/sessions/<sid>/chat.jsonl`, sid =
+`<agentId>-<uuid8>`); every conversation *including forks* lives in the same
+interleaved stream:
 
 ```json
-{"v":1,"id":"e27","seq":27,"ts":"…","agent":"alpha","session":"sess-alpha-main",
+{"v":1,"id":"e27","seq":27,"ts":"…","agent":"alpha","session":"alpha-9f3c21ab",
  "branch":"br032sl","parent":"e26","type":"fork",
- "data":{"fromSession":"sess-alpha-main","fromBranch":"br0","fromEvent":"e26","newBranch":"br032sl"}}
+ "data":{"fromSession":"alpha-9f3c21ab","fromBranch":"br0","fromEvent":"e26","newBranch":"br032sl"}}
 ```
 
 - every event carries `session`, `branch`, `parent` (previous event on the same branch), monotonic `seq`

package/dist/agent/agent.js

@@ -14,12 +14,17 @@ import { executeTool, toolSpecs, currentSkills } from "./tools.js";
 import { bus } from "../bus.js";
 const SYSTEM_TEMPLATE = `You are a coding agent working autonomously inside a workspace.
 
-## Persistent context files (human-readable, git-tracked)
-- AGENTS.md    : project knowledge/conventions written for agents (read it first)
-- GOAL.md      : your current long-term goal and its status
-- MEMORY.md    : durable notes you write for yourself
+## Goal (managed by the harness)
+The current goal is injected into this prompt by the harness. Change it with
+set_goal(text) when the objective itself changes; call finish(goalComplete=true)
+only when the goal is fully achieved.
 
-Keep these files updated with edit_file/write_file. They survive restarts.
+## Persistent context (all optional — create only if useful)
+- AGENTS.md (workspace root): project knowledge/conventions. When present, the
+  harness injects it into this prompt; keep it current with edit_file/write_file.
+- memory.md: your durable notes, harness-managed — update them with
+  set_memory(content); they are injected into future prompts.
+- skills/: reusable playbooks via load_skill / save_skill.
 
 ## Rules
 - Work step by step with tools. Verify results (run tests/builds) before claiming progress.
@@ -66,7 +71,7 @@ export class Agent {
             provider: "",
             ...opts,
         };
-        this.log = new EventLog(opts.logFile, opts.id);
+        this.log = new EventLog(path.join(opts.sessionDir, "chat.jsonl"), opts.id);
         this.skillRoots = [
             { dir: path.join(opts.workspace, "skills"), source: "workspace" },
             ...(opts.globalSkillsDir ? [{ dir: opts.globalSkillsDir, source: "global" }] : []),
@@ -77,7 +82,8 @@ export class Agent {
             maxOutputBytes: 60_000,
             skillRoots: this.skillRoots,
         };
-        this.mainSession = `sess-${opts.id}-main`;
+        // the session id IS the directory name — one directory per incarnation
+        this.mainSession = path.basename(opts.sessionDir);
         this.currentSession = this.mainSession;
     }
     skillRoots;
@@ -124,18 +130,49 @@ export class Agent {
     async init() {
         await this.log.load();
         await fs.mkdir(this.workspace, { recursive: true });
-        // seed persistent context files if missing
-        await this.seed("AGENTS.md", "# Project knowledge\n\n(Describe conventions, build commands, and gotchas here.)\n");
-        await this.seed("MEMORY.md", "# Memory\n");
-        const goalText = await this.readGoalFile();
-        if (goalText !== null)
-            this.goal = this.parseGoalFile(goalText);
-        else
-            await this.writeGoalFile();
+        // goal lives next to the session log (dataDir), NOT in the workspace —
+        // migrate a legacy workspace GOAL.md once, then never touch the workspace
+        await this.migrateGoalFromWorkspace();
+        const stored = await this.readGoalStore();
+        this.goal = stored ?? { text: "", status: "active", updatedAt: new Date().toISOString() };
         if (this.opts.restoreSession)
             await this.restoreFromLog();
         await this.refreshSkills();
     }
+    /** harness-managed files inside the session directory */
+    get goalFile() {
+        return path.join(this.opts.sessionDir, "goal.md");
+    }
+    get memoryFile() {
+        return path.join(this.opts.sessionDir, "memory.md");
+    }
+    async readGoalStoreRaw() {
+        return fs.readFile(this.goalFile, "utf8").catch(() => null);
+    }
+    async readGoalStore() {
+        const raw = await this.readGoalStoreRaw();
+        return raw === null ? null : this.parseGoalFile(raw);
+    }
+    /** One-time import of a pre-0.6.0 workspace GOAL.md; content is preserved. */
+    async migrateGoalFromWorkspace() {
+        const legacy = path.join(this.workspace, "GOAL.md");
+        let wsText;
+        try {
+            wsText = await fs.readFile(legacy, "utf8");
+        }
+        catch {
+            return; // nothing to migrate
+        }
+        const existing = await this.readGoalStoreRaw();
+        if (existing === null)
+            await fs.writeFile(this.goalFile, wsText, "utf8");
+        await fs.rm(legacy).catch(() => { });
+        await this.log.append("system_note", this.currentSession, this.currentBranch, {
+            event: "goal-migrated",
+            from: "GOAL.md",
+            to: this.goalFile,
+        });
+    }
     /**
      * Rebuild the in-memory conversation from the JSONL event log so a restart
      * continues where the agent left off instead of starting blank.
@@ -237,24 +274,20 @@ export class Agent {
             });
         }
     }
-    async seed(file, content) {
-        const p = path.join(this.workspace, file);
-        try {
-            await fs.access(p);
-        }
-        catch {
-            await fs.writeFile(p, content, "utf8");
-        }
-    }
-    readGoalFile() {
-        return fs.readFile(path.join(this.workspace, "GOAL.md"), "utf8").catch(() => null);
-    }
     parseGoalFile(text) {
         // humans and agents may append their own status lines — latest wins
         const all = [...text.matchAll(/status:\s*(\w+)/gi)];
         const last = all[all.length - 1]?.[1];
         const status = last === "done" ? "done" : last === "paused" ? "paused" : "active";
-        return { text: text.trim(), status, updatedAt: new Date().toISOString() };
+        // keep bookkeeping lines out of the injected goal text
+        let body = text.trim();
+        for (let i = 0; i < 4; i++) {
+            const stripped = body.replace(/\n+(?:status|updated):[^\n]*$/i, "").trimEnd();
+            if (stripped === body)
+                break;
+            body = stripped;
+        }
+        return { text: body, status, updatedAt: new Date().toISOString() };
     }
     async writeGoalFile() {
         // don't let previously-appended bookkeeping lines accumulate in the body
@@ -265,7 +298,7 @@ export class Agent {
                 break;
             body = stripped;
         }
-        await fs.writeFile(path.join(this.workspace, "GOAL.md"), `${body}\n\nstatus: ${this.goal.status}\nupdated: ${this.goal.updatedAt}\n`, "utf8");
+        await fs.writeFile(this.goalFile, `${body}\n\nstatus: ${this.goal.status}\nupdated: ${this.goal.updatedAt}\n`, "utf8");
     }
     async setGoal(text) {
         this.goal = { text, status: "active", updatedAt: new Date().toISOString() };
@@ -290,6 +323,7 @@ export class Agent {
             stats: { ...this.stats },
             model: this.opts.llm.model,
             provider: this.opts.provider,
+            sessionDir: this.opts.sessionDir,
         };
     }
     /** Queue a user prompt; wakes the loop if needed. Returns immediately. */
@@ -354,7 +388,7 @@ export class Agent {
                 await this.sleepInterruptible(this.opts.continueDelayMs);
                 if (this.stopRequested)
                     break;
-                const nudge = "Continue working toward the goal in GOAL.md. If you are blocked, explain why briefly.";
+                const nudge = "Continue working toward the current goal. If you are blocked, explain why briefly.";
                 await this.log.append("prompt", this.currentSession, this.currentBranch, {
                     source: "harness",
                     text: nudge,
@@ -445,7 +479,7 @@ export class Agent {
                 turn: ++this.stats.turns,
             });
             // stream the assistant reply live to connected clients
-            const res = await this.llmCall(this.buildMessages(), allToolSpecs(), (s) => {
+            const res = await this.llmCall(await this.buildMessages(), allToolSpecs(), (s) => {
                 bus.emit("update", {
                     kind: "llm-delta",
                     agentId: this.opts.id,
@@ -491,6 +525,29 @@ export class Agent {
                     });
                     continue;
                 }
+                if (call.function.name === "set_goal") {
+                    const a = safeParse(call.function.arguments);
+                    const text = String(a.text ?? "").trim();
+                    if (text)
+                        await this.setGoal(text);
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: call.id,
+                        content: text ? "goal updated" : "empty goal rejected",
+                    });
+                    continue;
+                }
+                if (call.function.name === "set_memory") {
+                    const a = safeParse(call.function.arguments);
+                    const content = String(a.content ?? "").slice(0, 32_000);
+                    await fs.writeFile(this.memoryFile, content, "utf8");
+                    this.messages.push({
+                        role: "tool",
+                        tool_call_id: call.id,
+                        content: "memory saved (injected into future prompts)",
+                    });
+                    continue;
+                }
                 await this.log.append("tool_call", this.currentSession, this.currentBranch, {
                     callId: call.id,
                     name: call.function.name,
@@ -517,11 +574,34 @@ export class Agent {
         }
         throw new Error("runaway detection: too many turns in one round (>200)");
     }
-    buildMessages() {
+    /** AGENTS.md is optional project knowledge — injected when present. */
+    agentsMdCache = null;
+    async readAgentsMd() {
+        try {
+            const p = path.join(this.workspace, "AGENTS.md");
+            const st = await fs.stat(p);
+            if (this.agentsMdCache?.mtimeMs === st.mtimeMs)
+                return this.agentsMdCache.text;
+            const text = await fs.readFile(p, "utf8");
+            this.agentsMdCache = { mtimeMs: st.mtimeMs, text };
+            return text;
+        }
+        catch {
+            this.agentsMdCache = null;
+            return "";
+        }
+    }
+    async buildMessages() {
         const sys = [SYSTEM_TEMPLATE];
         if (this.goal.text) {
             sys.push(`## Current goal (${this.goal.status})\n${this.goal.text}`);
         }
+        const agentsMd = await this.readAgentsMd();
+        if (agentsMd.trim())
+            sys.push(`## Project knowledge (AGENTS.md)\n${clipText(agentsMd, 8000)}`);
+        const memory = await fs.readFile(this.memoryFile, "utf8").catch(() => "");
+        if (memory.trim())
+            sys.push(`## Your notes (memory.md)\n${clipText(memory, 4000)}`);
         sys.push(this.skillsListing());
         const hasSystem = this.messages[0]?.role === "system";
         const head = [{ role: "system", content: sys.join("\n\n") }];
@@ -549,7 +629,7 @@ export class Agent {
             text: request,
         });
         this.messages.push({ role: "user", content: request });
-        const res = await this.llmCall(this.buildMessages(), []); // no tools: pure report
+        const res = await this.llmCall(await this.buildMessages(), []); // no tools: pure report
         await this.recordProgress(JSON.stringify({ freeform: res.message.content }));
         await this.log.append("message", this.currentSession, this.currentBranch, {
             role: "assistant",
@@ -627,7 +707,7 @@ export class Agent {
                 {
                     role: "user",
                     content: `[harness] Context was compacted: ${oldCount} earlier messages were summarized. ` +
-                        "Persistent files (GOAL.md / AGENTS.md / MEMORY.md) are still on disk — re-read them when needed.\n\n" +
+                        "Goal and notes are managed by the harness (AGENTS.md / memory.md are injected into your prompt when present).\n\n" +
                         `## Summary of earlier conversation\n${summary}`,
                 },
                 ...this.messages.slice(cut),
@@ -723,7 +803,7 @@ export class Agent {
         this.currentBranch = branch;
     }
 }
-/** workspace tools + agent-meta tools (finish / report_progress) */
+/** workspace tools + agent-meta tools (finish / report_progress / set_goal / set_memory) */
 function allToolSpecs() {
     return [
         ...toolSpecs(),
@@ -731,7 +811,7 @@ function allToolSpecs() {
             type: "function",
             function: {
                 name: "finish",
-                description: "End the current round. Call with goalComplete=true only when the goal in GOAL.md is fully achieved.",
+                description: "End the current round. Call with goalComplete=true only when the current goal (shown in your prompt) is fully achieved.",
                 parameters: {
                     type: "object",
                     properties: {
@@ -759,8 +839,35 @@ function allToolSpecs() {
                 },
             },
         },
+        {
+            type: "function",
+            function: {
+                name: "set_goal",
+                description: "Replace the harness-managed goal text (it is injected into your prompt). Use when the objective itself changes — not for routine updates.",
+                parameters: {
+                    type: "object",
+                    properties: { text: { type: "string" } },
+                    required: ["text"],
+                },
+            },
+        },
+        {
+            type: "function",
+            function: {
+                name: "set_memory",
+                description: "Overwrite your durable session notes (memory.md, injected into future prompts). Keep them terse: decisions, gotchas, where you left off.",
+                parameters: {
+                    type: "object",
+                    properties: { content: { type: "string" } },
+                    required: ["content"],
+                },
+            },
+        },
     ];
 }
+function clipText(s, max) {
+    return s.length <= max ? s : s.slice(0, max) + `\n… [truncated, ${s.length} chars total]`;
+}
 function str(v) {
     return typeof v === "string" ? v : "";
 }

package/dist/master.js

@@ -3,7 +3,8 @@
  * Agents are in-process async loops (I/O bound only); all CPU-heavy work is
  * delegated to subprocesses managed by the bash tool with hard timeouts.
  */
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, statSync, renameSync } from "node:fs";
+import { randomUUID } from "node:crypto";
 import path from "node:path";
 import os from "node:os";
 import { Agent } from "./agent/agent.js";
@@ -192,8 +193,14 @@ export class Master {
         // single low-frequency tick for everything periodic (idle cost ≈ 0)
         setInterval(() => void this.tick(), 15_000).unref();
     }
-    /** Create an agent; optionally persist it to the config file. */
-    async addAgent(ac, persist = false) {
+    /**
+     * Create an agent; optionally persist it to the config file.
+     * Each incarnation gets its own session directory under
+     * <dataDir>/sessions/<agentId>-<uuid>/ (chat.jsonl, goal.md, memory.md).
+     * Restarts reuse the latest existing session; fresh creations never touch
+     * an older one's history.
+     */
+    async addAgent(ac, opts = {}) {
         if (this.agents.has(ac.id))
             throw new Error(`agent id already exists: ${ac.id}`);
         // provider resolution: inline overrides > named provider > legacy llm block
@@ -210,12 +217,13 @@ export class Master {
         };
         if (!llm.model)
             throw new Error(`agent ${ac.id}: no model configured (set model on the agent or on its provider)`);
-        const logFile = path.join(this.config.dataDir, `${ac.id}.jsonl`);
+        const sessionDir = this.resolveSessionDir(ac.id, opts.fresh === true);
+        await mkdirSync(sessionDir, { recursive: true });
         const agent = new Agent({
             id: ac.id,
             workspace: path.resolve(ac.workspace),
             llm,
-            logFile,
+            sessionDir,
             progressIntervalMs: this.config.progressIntervalMs,
             autoContinue: true,
             ...(this.config.contextTokenBudget ? { contextTokenBudget: this.config.contextTokenBudget } : {}),
@@ -225,12 +233,68 @@ export class Master {
         agent.log.onEvent = (e) => printAgentEvent(e);
         await agent.init();
         this.agents.set(ac.id, agent);
-        if (persist) {
+        if (opts.persist) {
             this.config.agents.push(ac);
             this.saveConfig();
         }
         return agent;
     }
+    /** sessions root + helpers */
+    sessionsRoot() {
+        return path.join(this.config.dataDir, "sessions");
+    }
+    findLatestSessionDir(agentId) {
+        let dirs = [];
+        try {
+            dirs = readdirSync(this.sessionsRoot())
+                .filter((d) => d === agentId || d.startsWith(`${agentId}-`))
+                .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 {
+            return null;
+        }
+        return dirs[0] ? path.join(this.sessionsRoot(), dirs[0]) : null;
+    }
+    sessionMtime(dir) {
+        try {
+            return statSync(path.join(dir, "chat.jsonl")).mtimeMs;
+        }
+        catch {
+            return 0;
+        }
+    }
+    resolveSessionDir(agentId, fresh) {
+        const root = this.sessionsRoot();
+        mkdirSync(root, { recursive: true });
+        // one-time migration from the ≤0.5.0 flat layout (<dataDir>/<id>.jsonl)
+        if (!fresh) {
+            const legacy = path.join(this.config.dataDir, `${agentId}.jsonl`);
+            if (existsSync(legacy)) {
+                const target = path.join(root, agentId);
+                if (!existsSync(target)) {
+                    mkdirSync(target, { recursive: true });
+                    renameSync(legacy, path.join(target, "chat.jsonl"));
+                    console.log(`[teapot] migrated session storage: ${agentId}.jsonl → sessions/${agentId}/chat.jsonl`);
+                }
+            }
+        }
+        if (!fresh) {
+            const existing = this.findLatestSessionDir(agentId);
+            if (existing)
+                return existing; // restart → continue where we left off
+        }
+        // fresh incarnation: guaranteed-unique directory
+        let sid = "";
+        do {
+            sid = `${agentId}-${randomUUID().slice(0, 8)}`;
+        } while (existsSync(path.join(root, sid)));
+        return path.join(root, sid);
+    }
     async removeAgent(id) {
         const agent = this.agents.get(id);
         if (!agent)

package/dist/server/api.js

@@ -4,7 +4,8 @@
 import { Hono } from "hono";
 import { serve, upgradeWebSocket } from "@hono/node-server";
 import { WebSocketServer } from "ws";
-import { readFileSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
+import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { parseSchedule } from "../scheduler/cron.js";
@@ -52,6 +53,78 @@ export function buildApp(master) {
             },
         };
     }));
+    // ---- human terminal: interactive shell in the agent's workspace ----
+    // Uses util-linux `script` as a zero-dependency PTY when available (colors,
+    // line editing, ctrl+c); falls back to plain pipes otherwise.
+    app.get("/api/agents/:id/term", upgradeWebSocket((c) => {
+        const agentId = c.req.param("id") ?? "";
+        let child = null;
+        const cleanup = () => {
+            if (!child)
+                return;
+            try {
+                child.kill("SIGHUP");
+            }
+            catch {
+                /* already gone */
+            }
+            child = null;
+        };
+        return {
+            onOpen(_evt, ws) {
+                const agent = master.agents.get(agentId);
+                const send = (d) => {
+                    try {
+                        ws.send(JSON.stringify(d));
+                    }
+                    catch {
+                        /* client gone */
+                    }
+                };
+                if (!agent) {
+                    send({ kind: "exit", error: `no such agent: ${agentId}` });
+                    return;
+                }
+                const shell = process.env.SHELL || "/bin/bash";
+                const hasScript = existsSync("/usr/bin/script");
+                // script's pty reports a 0x0 winsize, so shells fall back to these
+                const env = { ...process.env, TERM: "xterm-256color", COLUMNS: "100", LINES: "30" };
+                child = hasScript
+                    ? spawn("script", ["-qec", shell, "/dev/null"], { cwd: agent.workspace, env })
+                    : spawn(shell, [], { cwd: agent.workspace, env: { ...env, TERM: "dumb" } });
+                console.log(`[teapot] ⌨ terminal open: ${agentId} @ ${agent.workspace} (${hasScript ? "pty" : "pipe"})`);
+                child.stdout?.on("data", (b) => send({ kind: "data", data: b.toString("utf8") }));
+                child.stderr?.on("data", (b) => send({ kind: "data", data: b.toString("utf8") }));
+                child.on("close", (code) => {
+                    send({ kind: "exit", code });
+                    console.log(`[teapot] ⌨ terminal exit: ${agentId} (${code ?? "signal"})`);
+                    child = null;
+                });
+            },
+            onMessage(evt) {
+                if (!child?.stdin?.writable)
+                    return;
+                let m;
+                try {
+                    m = JSON.parse(String(evt.data));
+                }
+                catch {
+                    return;
+                }
+                if (m.kind === "input")
+                    child.stdin.write(String(m.data ?? ""));
+                else if (m.kind === "resize") {
+                    const r = Number(m.rows) | 0;
+                    const cl = Number(m.cols) | 0;
+                    if (r > 0 && cl > 0)
+                        child.stdin.write(`stty rows ${r} cols ${cl} >/dev/null 2>&1\n`);
+                }
+            },
+            onClose() {
+                cleanup();
+            },
+        };
+    }));
     // ---- agents ----
     app.get("/api/agents", (c) => c.json({ agents: [...master.agents.values()].map((a) => a.snapshot()) }));
     // create + start an agent on an arbitrary directory
@@ -70,7 +143,7 @@ export function buildApp(master) {
         }
         const id = (body.id?.trim() || path.basename(ws)).replace(/[^\w.-]/g, "-").slice(0, 40);
         try {
-            const agent = await master.addAgent({ id, workspace: ws, provider: body.provider, model: body.model }, true);
+            const agent = await master.addAgent({ id, workspace: ws, provider: body.provider, model: body.model }, { persist: true, fresh: true });
             if (body.start !== false)
                 agent.start("created via web");
             return c.json({ ok: true, agent: agent.snapshot() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teapot-coding-agent",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A lightweight, always-on multi-agent harness for AI coding agents",
   "type": "module",
   "license": "AGPL-3.0-or-later",
@@ -46,6 +46,8 @@
   "devDependencies": {
     "@types/node": "^24.0.0",
     "@types/ws": "^8.18.1",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
     "solid-js": "^1.9.15",
     "typescript": "^5.8.0",
     "vite": "^8.2.2",

package/public/assets/addon-fit-DIOBYJe3.js

@@ -0,0 +1 @@
+var e=class{activate(e){this._terminal=e}dispose(){}fit(){let e=this.proposeDimensions();if(!e||!this._terminal||isNaN(e.cols)||isNaN(e.rows))return;let t=this._terminal._core;(this._terminal.rows!==e.rows||this._terminal.cols!==e.cols)&&(t._renderService.clear(),this._terminal.resize(e.cols,e.rows))}proposeDimensions(){if(!this._terminal||!this._terminal.element||!this._terminal.element.parentElement)return;let e=this._terminal._core._renderService.dimensions;if(e.css.cell.width===0||e.css.cell.height===0)return;let t=this._terminal.options.scrollback===0?0:this._terminal.options.overviewRuler?.width||14,n=window.getComputedStyle(this._terminal.element.parentElement),r=parseInt(n.getPropertyValue(`height`)),i=Math.max(0,parseInt(n.getPropertyValue(`width`))),a=window.getComputedStyle(this._terminal.element),o={top:parseInt(a.getPropertyValue(`padding-top`)),bottom:parseInt(a.getPropertyValue(`padding-bottom`)),right:parseInt(a.getPropertyValue(`padding-right`)),left:parseInt(a.getPropertyValue(`padding-left`))},s=o.top+o.bottom,c=o.right+o.left,l=r-s,u=i-c-t;return{cols:Math.max(2,Math.floor(u/e.css.cell.width)),rows:Math.max(1,Math.floor(l/e.css.cell.height))}}};export{e as FitAddon};