symbiot 0.54.0 → 0.54.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 What each Symbiot release brought, newest first. When Approve bumps the version, it writes that release here from the tasks it approved, worded as release notes by your connected AI (or in the tasks' own words without one). The app shows the releases newer than yours under "What's new" when it offers an update, and once more after you update.
 
+## 0.54.1
+
+- **No more lag from a big agent log.** An agent's log keeps every run and everything it reads, screenshots included; one reached 144 MB, and Symbiot reread all of it on almost every refresh, so the app stalled for 5–28 seconds at a time and ate a core. Now it reads only the newest run, from the end of the file, and keeps it until the file changes. A log past 8 MB starts afresh at the next run, with the old one kept as `agent.log.old`.
+
 ## 0.54.0
 
 - **Show Symbiot a screenshot.** Paste one into "Talk to Symbiot" (Ctrl+V) or drop it on the bar: it shows as a thumbnail you can remove, goes with what you say, and the AI you connected sees it (Claude, OpenAI, Gemini, or a local model that reads images). If Symbiot hands the work to an agent, the agent gets the screenshot too. Up to 4 at a time; they're kept a week, readable by you only.

package/agents.mjs

@@ -5,10 +5,10 @@ import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { join, dirname, resolve, relative } from "node:path";
 import { fileURLToPath } from "node:url";
-import { readFileSync, writeFileSync, mkdirSync, existsSync, openSync, writeSync, unlinkSync, readdirSync, statSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, openSync, writeSync, unlinkSync, readdirSync, statSync, renameSync } from "node:fs";
 import { randomBytes, createHash } from "node:crypto";
 import { CONFIG_DIR, loadConfig, saveConfig, loadTasks, TASK_MAX, clipWords, sameTask, taskWords, sh, hasCmd } from "./core.mjs";
-import { parseRun, lastRunText } from "./work.mjs";
+import { parseRun, lastRunText, readRunLog } from "./work.mjs";
 import { parseFacts } from "./handover.mjs";
 import { scanRoots, repoPathMap } from "./scan.mjs";
 import { knowledgeFolders } from "./knowledge.mjs";
@@ -273,7 +273,7 @@ function earlierRuns() {
     const busy = runningHandoff(r.path), ask = agentQuestions(r.path, r.name), wait = waitingFor(r.path), facts = busy ? [] : factsOf(r.path);
     if (!busy && !ask.questions.length && !wait && !facts.length) continue;
     const log = join(r.path, ".symbiot", "agent.log"), startedAt = (busy && busy.startedAt) || Number(r.startedAt) || Date.now();
-    let tail = "", work = null, progress = null, end = Date.now(); try { ({ tail, work, progress } = workOf(r.path, readFileSync(log, "utf8"))); if (!busy) end = statSync(log).mtimeMs; } catch {}
+    let tail = "", work = null, progress = null, end = Date.now(); try { ({ tail, work, progress } = workOf(r.path, readRunLog(log))); if (!busy) end = statSync(log).mtimeMs; } catch {}
     out.push({ id: "earlier-" + digest(r.path).slice(0, 8), name: String(r.name || r.path.split("/").pop()), path: r.path, status: busy ? "running" : "done", earlier: true, elapsed: Math.max(0, end - startedAt), exitCode: null, tail, work, progress, changed: agentChanges(r.path, startedAt), ask, held: heldTasks(r.path), waiting: wait, remember: facts.length ? facts : null, fromHeld: false });
   }
   return out;
@@ -576,10 +576,12 @@ function _findOrcaCli() {
 // ---- background jobs --------------------------------------------------------
 // Run a shell command as a tracked, logged background job that shows up live in
 // the Agents tab. Shared by the agent handoff and the local-model setup.
+const LOG_KEEP = 8 * 1024 * 1024;
 function track(name, cmd, cwd, onExit, env) {
   try {
     const dir = join(cwd, ".symbiot"); mkdirSync(dir, { recursive: true });
     const logp = join(dir, "agent.log");
+    try { if (statSync(logp).size > LOG_KEEP) renameSync(logp, logp + ".old"); } catch {} // past 8 MB: kept as agent.log.old, and a fresh one starts
     let fd = "ignore"; try { fd = openSync(logp, "a"); writeSync(fd, `\n=== ${name} ${new Date().toISOString()} ===\n$ ${cmd}\n`); } catch {}
     const entry = { id: randomBytes(4).toString("hex"), name, path: cwd, log: logp, startedAt: Date.now(), status: "running", exitCode: null, endedAt: null };
     const child = spawn(cmd, { shell: true, cwd, detached: true, stdio: ["ignore", fd === "ignore" ? "ignore" : fd, fd === "ignore" ? "ignore" : fd], ...(env ? { env: { ...process.env, ...env } } : {}) });
@@ -623,7 +625,7 @@ const QUESTIONS_MAX = 5;
 // the next moves up. The rest are a click away.
 const OPTIONS_SHOWN = 2, IDEAS_SHOWN = 2;
 const qKey = (s) => String(s || "").trim().toLowerCase().replace(/\s+/g, " ");
-const readSymbiot = (path, f) => { try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
+const readSymbiot = (path, f) => { if (f === "agent.log") return readRunLog(join(path, ".symbiot", f)); try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
 // "## Questions" → "### question", context lines, "- option" bullets;
 // "## Suggestions" (or Ideas / Follow-ups) → "- idea" bullets. Forgiving: a bare
 // bullet under Questions is a question with no options.
@@ -880,8 +882,7 @@ function workOf(path, log) {
 function agentsList() {
   const seen = new Set();
   return HANDOFFS.map((e) => {
-    let log = ""; try { log = readFileSync(e.log, "utf8"); } catch {}
-    const { tail, work, progress } = workOf(e.path, log);
+    const { tail, work, progress } = workOf(e.path, readRunLog(e.log));
     const first = !seen.has(e.path); seen.add(e.path);
     const facts = first && e.status !== "running" ? factsOf(e.path) : [];
     return { id: e.id, name: e.name, path: e.path, status: e.status, elapsed: (e.endedAt || Date.now()) - e.startedAt, exitCode: e.exitCode, tail, work, progress, changed: agentChanges(e.path, e.startedAt), ask: first ? agentQuestions(e.path, e.name) : null, held: first ? heldTasks(e.path) : null, waiting: first && e.status !== "running" ? waitingFor(e.path) : null, remember: facts.length ? facts : null, fromHeld: !!e.fromHeld };

package/lanes.mjs

@@ -23,7 +23,7 @@ import { runHandoff, runningHandoff, waitingFor, agentQuestions } from "./agents
 import { addTask, pushTasks } from "./tasks.mjs";
 import { actNow } from "./mind.mjs";
 import { repoPathMap } from "./scan.mjs";
-import { parseRun, lastRunText } from "./work.mjs";
+import { parseRun, lastRunText, readRunLog } from "./work.mjs";
 import { OPS, parseHandoffs } from "./handover.mjs";
 
 const LEDGER = join(CONFIG_DIR, "lanes.json");
@@ -33,7 +33,7 @@ const MAX_KEEP = 200, MAX_CHAIN = 4, TAIL = 4000;
 function loadLedger() { try { const d = JSON.parse(readFileSync(LEDGER, "utf8")); return { handoffs: Array.isArray(d.handoffs) ? d.handoffs : [] }; } catch { return { handoffs: [] }; } }
 // It can name accounts and what's in them: yours only (0600).
 function saveLedger(d) { try { mkdirSync(CONFIG_DIR, { recursive: true }); writeFileSync(LEDGER, JSON.stringify({ handoffs: d.handoffs.slice(-MAX_KEEP) }, null, 1), { mode: 0o600 }); try { chmodSync(LEDGER, 0o600); } catch {} return true; } catch { return false; } }
-const readSym = (path, f) => { try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
+const readSym = (path, f) => { if (f === "agent.log") return readRunLog(join(path, ".symbiot", f)); try { return readFileSync(join(path, ".symbiot", f), "utf8"); } catch { return ""; } };
 const firstLine = (t) => String(t || "").split("\n").find((l) => l.trim()) || "";
 
 // A folder's lane: the repo it is, or ops for a run of its own.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "symbiot",
-  "version": "0.54.0",
+  "version": "0.54.1",
   "description": "Your week, written from your real work. Reads your local git and writes it up with the AI of your choice \u2014 Claude, OpenAI, Gemini, or a local model.",
   "type": "module",
   "bin": {

package/server.mjs

@@ -7,6 +7,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gunzipSync } from "node:zlib";
+import { readRunLog } from "./work.mjs";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
@@ -413,7 +414,7 @@ async function startApp({ bin, since = 7, all = false, c = PLAIN_COLOURS } = {})
         // giving up and sending you to a terminal.
         const attempt = (n) => track("symbiot update", inst, homedir(), (code) => {
           if (code !== 0) {
-            let tail = ""; try { tail = readFileSync(join(homedir(), ".symbiot", "agent.log"), "utf8").slice(-3000); } catch {}
+            const tail = readRunLog(join(homedir(), ".symbiot", "agent.log")).slice(-3000);
             if (n < 5 && /E404|ETARGET|notarget|No matching version|is not in this registry/i.test(tail)) { UPDATING = { target, retrying: true, attempt: n + 1, at: Date.now() }; setTimeout(() => attempt(n + 1), 30000).unref(); }
             else UPDATING = null;
             return;

package/tasks.mjs

@@ -11,6 +11,7 @@ import { handoverRules, ONLY_YOU, HANDBACK } from "./handover.mjs";
 import { userStyleLine } from "./adapt.mjs";
 import { QUESTIONS_MAX, OPTIONS_SHOWN, IDEAS_SHOWN, handoffCmd, runningHandoff, writeTasks, droppedTasks, startHeldTasks, connectorsLine } from "./agents.mjs";
 import { gitDefaultBranch } from "./drift.mjs";
+import { readRunLog } from "./work.mjs";
 import { repoPathMap, openWork, detectRepo } from "./scan.mjs";
 
 // ---- tasks: a persistent checklist (stored by core.mjs) -------------------
@@ -342,7 +343,7 @@ function shipWithBump(path, texts, opts) {
 // What the last run in a folder said when it finished: agent.log after the last
 // run's "=== name time ===" and "$ command" lines.
 function runSummary(path) {
-  let log = ""; try { log = readFileSync(join(path, ".symbiot", "agent.log"), "utf8"); } catch { return ""; }
+  const log = readRunLog(join(path, ".symbiot", "agent.log")); if (!log) return "";
   const at = log.lastIndexOf("\n=== "), rest = at < 0 ? log : log.slice(log.indexOf("\n", at + 1) + 1);
   return rest.replace(/^\$ .*\n?/, "").trim().slice(-8000);
 }

package/work.mjs

@@ -8,6 +8,8 @@
 // time. Another agent (Codex, Aider, Gemini) writes plain text: its last lines
 // come through as what it said. Pure: text in, data out.
 
+import { statSync, openSync, readSync, closeSync } from "node:fs";
+
 const MAX_STEPS = 60;
 const short = (s, n = 80) => { s = String(s ?? "").replace(/\s+/g, " ").trim(); return s.length > n ? s.slice(0, n - 1) + "…" : s; };
 const base = (p) => String(p || "").split("/").filter(Boolean).slice(-2).join("/");
@@ -103,6 +105,29 @@ function parseRun(text) {
   return out;
 }
 
+// The newest run of an agent.log, from its "=== " header on, read from the end of the
+// file. A log keeps every run and everything they read (one reached 144 MB: 96 runs and
+// the screenshots they looked at), and every view only needs the newest, so it never
+// reads the rest; and it's kept until the file changes, so a view that asks again
+// costs nothing. Past RUN_CAP of one run, it's that run's last RUN_CAP.
+const RUN_CAP = 16 * 1024 * 1024, RUN_CACHE = new Map();
+function readRunLog(file) {
+  let st; try { st = statSync(file); } catch { return ""; }
+  const hit = RUN_CACHE.get(file); if (hit && hit.size === st.size && hit.mtime === st.mtimeMs) return hit.text;
+  let fd; try { fd = openSync(file, "r"); } catch { return ""; }
+  let buf = Buffer.alloc(0), at = -1;
+  try {
+    for (let end = st.size; end > 0 && buf.length < RUN_CAP;) {
+      const start = Math.max(0, end - (1 << 20)), b = Buffer.alloc(end - start);
+      readSync(fd, b, 0, b.length, start); buf = Buffer.concat([b, buf]); end = start;
+      at = buf.lastIndexOf("\n=== "); if (at >= 0) break;
+    }
+  } catch { buf = Buffer.alloc(0); } finally { try { closeSync(fd); } catch {} }
+  const text = (at >= 0 ? buf.subarray(at) : buf).toString("utf8");
+  RUN_CACHE.delete(file); RUN_CACHE.set(file, { size: st.size, mtime: st.mtimeMs, text });
+  if (RUN_CACHE.size > 40) RUN_CACHE.delete(RUN_CACHE.keys().next().value);
+  return text;
+}
 // The newest run's part of an agent.log (after its header and command line).
 function lastRunText(log) {
   const s = String(log || ""), at = s.lastIndexOf("\n=== ");
@@ -111,4 +136,4 @@ function lastRunText(log) {
 // What the agent said last: its final answer, from either kind of log.
 function finalOf(log) { return parseRun(lastRunText(log)).final; }
 
-export { parseRun, lastRunText, finalOf, describe, testsIn };
+export { parseRun, lastRunText, finalOf, describe, testsIn, readRunLog };