agent-lyceum 0.28.0 → 0.30.0

package/README.md

@@ -49,7 +49,7 @@ Its own data (config, mailboxes, logs, memory, worktrees) lives in `~/agent-lyce
 | `init` | Create the home and the global agent library. [details](docs/commands.md#init) |
 | `project add` / `project` / `project remove` | Register, list or remove projects. [details](docs/commands.md#project-add) |
 | `doctor` | Check config, git, lock and runtime CLIs without running agents. [details](docs/commands.md#doctor) |
-| `status` | Show agents, mail, the current wake-up and past runs. [details](docs/commands.md#status) |
+| `status` | Show agents, mail, the current wake-up and past runs. `status --web` opens every registered project in a browser. [details](docs/commands.md#status) |
 | `run` | Give the task to the lead and run until done. [details](docs/commands.md#run) |
 | `resume` | Continue an interrupted run, or reopen a finished one with a follow-up. [details](docs/commands.md#resume) |
 | `clear` | Delete a run, or remove a stale lock. [details](docs/commands.md#clear) |

package/README.zh-TW.md

@@ -49,7 +49,7 @@ npx agent-lyceum status
 | `init` | 建立 home 與全域 agent 庫。 [詳細](docs/commands.zh-TW.md#init) |
 | `project add` / `project` / `project remove` | 註冊、列出或移除專案。 [詳細](docs/commands.zh-TW.md#project-add) |
 | `doctor` | 不執行 agent，檢查設定、git、鎖與 runtime CLI。 [詳細](docs/commands.zh-TW.md#doctor) |
-| `status` | 顯示 agent、信件、目前的喚醒與過去的 run。 [詳細](docs/commands.zh-TW.md#status) |
+| `status` | 顯示 agent、信件、目前的喚醒與過去的 run。`status --web` 在瀏覽器看全部已註冊專案。 [詳細](docs/commands.zh-TW.md#status) |
 | `run` | 把任務交給 lead，執行到完成。 [詳細](docs/commands.zh-TW.md#run) |
 | `resume` | 繼續中斷的 run，或用追加需求重開已完成的 run。 [詳細](docs/commands.zh-TW.md#resume) |
 | `clear` | 刪除 run，或移除殘留的鎖。 [詳細](docs/commands.zh-TW.md#clear) |

package/dist/cli.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import readline from "node:readline/promises";
 import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { Command } from "commander";
 import { ConfigError, findProjectForCwd, flattenResolved, listProjects, loadGlobal, resolveProject, resolveProjectWithSources } from "./config.js";
 import { openInEditor, prepareAnswers } from "./ask-answer.js";
@@ -23,10 +24,12 @@ import { callAgent, callProject, callsDir, resolveCallAgent } from "./call.js";
 import { formatEnforcement, validateProject } from "./validate.js";
 import { must } from "./assert.js";
 import { runMonitor } from "./monitor-lifecycle.js";
+import { codeFingerprint, watchCodeChange, WATCH_RESTART_EXIT, WATCH_RESTART_MESSAGE } from "./code-change.js";
 import { createStatusWatcher } from "./status-watch.js";
 import { LAUNCH_PPID, startedByWrapper, watchParent } from "./parent-watch.js";
 import { onlyAgent, soloProject } from "./solo.js";
 import { DEMO_PROJECT, DEMO_TASK, defaultDemoDir, detectRuntime, prepareDemo } from "./demo.js";
+import { claudeQuota, codexQuota } from "./quota.js";
 const program = new Command();
 program
     .name("agent-lyceum")
@@ -764,9 +767,57 @@ program
     .option("--interval <sec>", "refresh interval for --monitor", "2")
     .option("--json", "print the report as JSON (no colour); works with --task-list and --task-id")
     .option("--watch", "with --json: keep running and print one JSON line (the project report plus one per running task) whenever it changes (Ctrl-C to quit)")
-    .option("--heartbeat <sec>", "with --watch: how often to re-check when no file event came", "5")
+    .option("--heartbeat <sec>", "with --watch or --web: how often to re-check when no file event came", "5")
+    .option("--web", "open a local page for every registered project")
+    .option("--port <n>", "with --web: TCP port", "8787")
+    .option("--host <addr>", "with --web: bind address", "127.0.0.1")
+    .option("--no-open", "with --web: do not open a browser")
     .action(async (opts) => {
     try {
+        if (opts.web) {
+            if (opts.json || opts.watch || opts.monitor || opts.taskList || opts.taskId !== undefined)
+                fail("--web cannot be combined with --json, --watch, --monitor, --task-list or --task-id.");
+            if (opts.project)
+                fail("--web shows every registered project; it does not take --project.");
+            const port = Number(opts.port);
+            if (!Number.isInteger(port) || port < 1 || port > 65535)
+                fail("--port must be a TCP port.");
+            const beat = Number(opts.heartbeat);
+            if (!(beat > 0))
+                fail("--heartbeat must be a positive number of seconds.");
+            const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+            const entry = path.join(root, "web", "dist", "start.js");
+            const staticDir = path.join(root, "web", "dist", "public");
+            if (!fs.existsSync(entry) || !fs.existsSync(path.join(staticDir, "index.html"))) {
+                fail(`The web monitor is not built.\nFrom the repo: pnpm --dir web install && pnpm --dir web build\nExpected ${entry}`);
+            }
+            const mod = (await import(pathToFileURL(entry).href));
+            const page = await mod.startWebServer({
+                port,
+                host: opts.host,
+                open: opts.open !== false,
+                staticDir,
+                heartbeatMs: beat * 1000,
+                factory: {
+                    list: () => listProjects(home()).map((item) => item.name),
+                    watch: (name, onFrame) => createStatusWatcher({
+                        load: () => resolveProject(home(), name),
+                        dir: (project) => project.paths.runs,
+                        write: (line) => onFrame(JSON.parse(line)),
+                        debounceMs: 100,
+                        allTasks: true,
+                    }),
+                    quota: () => Promise.all([claudeQuota(), codexQuota()]),
+                },
+            });
+            console.log(page.url);
+            const stop = (code) => {
+                void page.close().finally(() => process.exit(code));
+            };
+            process.on("SIGINT", () => stop(130));
+            process.on("SIGTERM", () => stop(143));
+            await new Promise(() => { });
+        }
         if (opts.watch) {
             if (!opts.json)
                 fail("--watch needs --json.");
@@ -782,8 +833,22 @@ program
                 write: (line) => process.stdout.write(`${line}\n`),
                 debounceMs: 100,
             });
+            const codeFile = fileURLToPath(import.meta.url);
+            const changed = watchCodeChange(() => codeFingerprint(path.dirname(codeFile), path.extname(codeFile)));
             runMonitor({
-                draw: watcher.beat,
+                draw: () => {
+                    if (changed()) {
+                        try {
+                            fs.writeSync(2, `${WATCH_RESTART_MESSAGE}\n`);
+                        }
+                        catch {
+                            // A closed stderr must not prevent replacement.
+                        }
+                        watcher.close();
+                        process.exit(WATCH_RESTART_EXIT);
+                    }
+                    watcher.beat();
+                },
                 intervalMs: beat * 1000,
                 stdout: process.stdout,
                 stdin: process.stdin,

package/dist/code-change.d.ts

@@ -0,0 +1,6 @@
+export declare const WATCH_RESTART_EXIT = 75;
+export declare const WATCH_RESTART_MESSAGE = "status --watch: agent-lyceum code changed on disk; restart to load it";
+/** Sorted relative paths, sizes and mtimes; unreadable trees never trigger a restart. */
+export declare function codeFingerprint(dir: string, ext: string): string;
+/** Two equal reads debounce changes; they do not establish build completion. */
+export declare function watchCodeChange(read: () => string): () => boolean;

package/dist/code-change.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+export const WATCH_RESTART_EXIT = 75;
+export const WATCH_RESTART_MESSAGE = "status --watch: agent-lyceum code changed on disk; restart to load it";
+/** Sorted relative paths, sizes and mtimes; unreadable trees never trigger a restart. */
+export function codeFingerprint(dir, ext) {
+    const files = [];
+    function visit(relative) {
+        for (const entry of fs.readdirSync(path.join(dir, relative), { withFileTypes: true })) {
+            const rel = path.join(relative, entry.name);
+            if (entry.isDirectory())
+                visit(rel);
+            else if (entry.isFile() && path.extname(entry.name) === ext) {
+                const stat = fs.statSync(path.join(dir, rel));
+                files.push(`${rel}:${stat.size}:${stat.mtimeMs}`);
+            }
+        }
+    }
+    try {
+        visit("");
+        return files.sort().join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+/** Two equal reads debounce changes; they do not establish build completion. */
+export function watchCodeChange(read) {
+    const initial = read();
+    let previous = initial;
+    return () => {
+        const current = read();
+        const changed = current !== "" && current !== initial && current === previous;
+        previous = current;
+        return changed;
+    };
+}

package/dist/project-lock.d.ts

@@ -44,11 +44,27 @@ export interface PidStartIo {
 }
 /** A start time that identifies one process: `proc:<ticks>` on Linux, the `ps` text elsewhere or when /proc cannot be read. */
 export declare function pidStartFrom(pid: number, io: PidStartIo): string | undefined;
+/** Reader side: C locale, so `ps` start times stay in one language and `samePidStart` can compare them. */
+export declare const readerPs: (pid: number) => string | undefined;
+/** Writer side: the inherited environment, exactly what versions before 0.29.0 wrote and compare against raw; never pin it, or an older reader in a non-C locale judges the lock dead and takes the run over. */
+export declare const writerPs: (pid: number) => string | undefined;
+/** True when both strings name the same process start. Locale-specific `ps` text for one instant matches. */
+export declare function samePidStart(a: string, b: string): boolean;
+export interface LivenessIo extends PidStartIo {
+    signal0(pid: number): boolean;
+    psUtc(pid: number): string | undefined;
+}
+export declare const utcPsEnv: (base: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const readerPsUtc: (pid: number) => string | undefined;
+/** Only ESRCH proves absence; permissions and unknown signal errors are conservative. */
+export declare function signalAlive(pid: number, kill?: (pid: number, signal: 0) => unknown): boolean;
+/** Conventional quarter-hour offsets only; arbitrary POSIX TZ offsets remain a limitation. */
+export declare function sameStartAnyZone(written: string, utc: string): boolean | undefined;
 /**
  * Is the process that wrote this lock still the same running process? Judged by pid and its start time,
  * never by hostname (macOS changes it with the network) or by heartbeat age (a busy holder may be late).
  */
-export declare function lockHolderAlive(info: LockInfo): boolean;
+export declare function lockHolderAlive(info: Pick<LockInfo, "pid" | "pid_started">, io?: LivenessIo): boolean;
 /** Every lock of a project that can be read: one per run, plus an older version's `lock.json`. Oldest first. */
 export declare function listRunLocks(root: string): LockInfo[];
 /** Run ids whose per-run lock file exists but cannot be read (it can only be removed with `forceUnlock(root, runId)`). */

package/dist/project-lock.js

@@ -39,45 +39,107 @@ export function pidStartFrom(pid, io) {
     }
     return io.ps(pid);
 }
-const realIo = {
-    platform: process.platform,
-    readFile: (p) => {
-        try {
-            return fs.readFileSync(p, "utf8");
-        }
-        catch {
-            return undefined;
-        }
-    },
-    ps: (pid) => {
-        const r = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
-        const out = r.status === 0 ? r.stdout.trim() : "";
-        return out || undefined;
-    },
+const psLstart = (pid, env) => {
+    const r = spawnSync("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8", env });
+    return (r.status === 0 ? r.stdout.trim() : "") || undefined;
 };
+/** Reader side: C locale, so `ps` start times stay in one language and `samePidStart` can compare them. */
+export const readerPs = (pid) => psLstart(pid, { ...process.env, LANG: "C", LC_ALL: "C" });
+/** Writer side: the inherited environment, exactly what versions before 0.29.0 wrote and compare against raw; never pin it, or an older reader in a non-C locale judges the lock dead and takes the run over. */
+export const writerPs = (pid) => psLstart(pid, process.env);
+const fileReader = (p) => {
+    try {
+        return fs.readFileSync(p, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+};
+const realIo = { platform: process.platform, readFile: fileReader, ps: readerPs };
+const writerIo = { ...realIo, ps: writerPs };
 function pidStart(pid) {
-    return pidStartFrom(pid, realIo);
+    return pidStartFrom(pid, writerIo);
 }
-/** Two start times can only be compared when they were taken the same way. */
-const sameKind = (a, b) => a.startsWith("proc:") === b.startsWith("proc:");
-/**
- * Is the process that wrote this lock still the same running process? Judged by pid and its start time,
- * never by hostname (macOS changes it with the network) or by heartbeat age (a busy holder may be late).
- */
-export function lockHolderAlive(info) {
+const MONTHS = { Jan: "01", Feb: "02", Mar: "03", Apr: "04", May: "05", Jun: "06", Jul: "07", Aug: "08", Sep: "09", Oct: "10", Nov: "11", Dec: "12" };
+/** `ps -o lstart` in the C locale, or the same instant from a Chinese macOS locale, as `YYYY-MM-DDTHH:mm:ss`. */
+function canonicalLstart(text) {
+    const s = text.trim();
+    const en = /^[A-Za-z]{3}\s+([A-Za-z]{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})$/.exec(s);
+    if (en) {
+        const month = MONTHS[en[1] ?? ""];
+        if (!month)
+            return undefined;
+        return `${en[6]}-${month}-${(en[2] ?? "").padStart(2, "0")}T${en[3]}:${en[4]}:${en[5]}`;
+    }
+    const zh = /^\S+\s+(\d{1,2})月\/\s*(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})$/.exec(s);
+    if (zh)
+        return `${zh[6]}-${(zh[1] ?? "").padStart(2, "0")}-${(zh[2] ?? "").padStart(2, "0")}T${zh[3]}:${zh[4]}:${zh[5]}`;
+    return undefined;
+}
+/** True when both strings name the same process start. Locale-specific `ps` text for one instant matches. */
+export function samePidStart(a, b) {
+    if (a === b)
+        return true;
+    const left = canonicalLstart(a);
+    const right = canonicalLstart(b);
+    return !!left && left === right;
+}
+export const utcPsEnv = (base) => ({ ...base, LANG: "C", LC_ALL: "C", TZ: "UTC0" });
+export const readerPsUtc = (pid) => psLstart(pid, utcPsEnv(process.env));
+/** Only ESRCH proves absence; permissions and unknown signal errors are conservative. */
+export function signalAlive(pid, kill = process.kill) {
     try {
-        process.kill(info.pid, 0);
+        kill(pid, 0);
+        return true;
     }
     catch (e) {
-        if (e.code !== "EPERM")
-            return false;
+        return e?.code !== "ESRCH";
     }
-    if (info.pid_started) {
-        const now = pidStart(info.pid);
-        if (now && sameKind(now, info.pid_started) && now !== info.pid_started)
-            return false;
+}
+const realLivenessIo = {
+    ...realIo,
+    signal0: signalAlive,
+    psUtc: readerPsUtc,
+};
+function lstartFieldsMs(text) {
+    const c = canonicalLstart(text);
+    const ms = c === undefined ? NaN : Date.parse(`${c}Z`);
+    return Number.isFinite(ms) && new Date(ms).toISOString().slice(0, 19) === c ? ms : undefined;
+}
+/** Conventional quarter-hour offsets only; arbitrary POSIX TZ offsets remain a limitation. */
+export function sameStartAnyZone(written, utc) {
+    const a = lstartFieldsMs(written);
+    const b = lstartFieldsMs(utc);
+    if (a === undefined || b === undefined)
+        return undefined;
+    const d = (a - b) / 1000;
+    return Number.isInteger(d) && d % 900 === 0 && Math.abs(d) <= 26 * 3600;
+}
+/**
+ * Is the process that wrote this lock still the same running process? Judged by pid and its start time,
+ * never by hostname (macOS changes it with the network) or by heartbeat age (a busy holder may be late).
+ */
+export function lockHolderAlive(info, io = realLivenessIo) {
+    if (!io.signal0(info.pid))
+        return false;
+    const written = info.pid_started;
+    if (typeof written !== "string" || !written)
+        return true;
+    if (io.platform === "linux") {
+        if (!written.startsWith("proc:"))
+            return true;
+        const ticks = parseProcStat(io.readFile(`/proc/${info.pid}/stat`) ?? "");
+        return !ticks || `proc:${ticks}` === written;
     }
-    return true;
+    if (written.startsWith("proc:"))
+        return true;
+    const local = io.ps(info.pid);
+    if (!local || samePidStart(written, local))
+        return true;
+    const utc = io.psUtc(info.pid);
+    if (!utc)
+        return true;
+    return sameStartAnyZone(written, utc) !== false;
 }
 function readLockFile(file) {
     let text;

package/dist/quota.d.ts

@@ -0,0 +1,25 @@
+export type QuotaWindow = {
+    label: string;
+    used_percent: number;
+    remaining_percent: number;
+    resets: string;
+};
+export type QuotaReport = {
+    runtime: "claude" | "codex";
+    windows: QuotaWindow[];
+    error?: string;
+};
+export declare function parseClaudeUsage(text: string): QuotaWindow[];
+type LimitWindow = {
+    usedPercent?: number;
+    windowDurationMins?: number;
+    resetsAt?: number;
+};
+type RateLimits = {
+    primary?: LimitWindow | null;
+    secondary?: LimitWindow | null;
+};
+export declare function codexWindows(limits: RateLimits): QuotaWindow[];
+export declare function claudeQuota(): Promise<QuotaReport>;
+export declare function codexQuota(): Promise<QuotaReport>;
+export {};

package/dist/quota.js

@@ -0,0 +1,141 @@
+import { spawn } from "node:child_process";
+export function parseClaudeUsage(text) {
+    const session = text.match(/Current session:\s*(\d+(?:\.\d+)?)%\s*used\s*·\s*resets\s+(.+)/);
+    const week = text.match(/Current week(?: \([^)]*\))?:\s*(\d+(?:\.\d+)?)%\s*used\s*·\s*resets\s+(.+)/);
+    const windows = [];
+    if (session)
+        windows.push(windowOf("這 5 小時", Number(session[1]), (session[2] ?? "").trim()));
+    if (week)
+        windows.push(windowOf("本週", Number(week[1]), (week[2] ?? "").trim()));
+    return windows;
+}
+export function codexWindows(limits) {
+    return [limits.primary, limits.secondary].flatMap((window) => {
+        if (!window || window.usedPercent === undefined)
+            return [];
+        const mins = window.windowDurationMins ?? 0;
+        const resets = window.resetsAt ? new Date(window.resetsAt * 1000).toLocaleString("zh-Hant", { month: "numeric", day: "numeric", hour: "2-digit", minute: "2-digit" }) : "時間不明";
+        return [windowOf(durationLabel(mins), window.usedPercent, resets)];
+    });
+}
+function durationLabel(mins) {
+    if (mins === 300)
+        return "這 5 小時";
+    if (mins === 10080)
+        return "7 天";
+    if (mins > 0 && mins % 1440 === 0)
+        return `${mins / 1440} 天`;
+    if (mins > 0 && mins % 60 === 0)
+        return `${mins / 60} 小時`;
+    return mins > 0 ? `${mins} 分鐘` : "用量";
+}
+function windowOf(label, used, resets) {
+    const usedPercent = roundPercent(used);
+    return { label, used_percent: usedPercent, remaining_percent: roundPercent(Math.max(0, 100 - used)), resets };
+}
+function roundPercent(n) {
+    return Math.round(n * 10) / 10;
+}
+export async function claudeQuota() {
+    try {
+        const text = await capture("claude", ["-p", "--no-session-persistence", "--output-format", "text", "/usage"], 20_000);
+        const windows = parseClaudeUsage(text.stdout);
+        if (windows.length === 0)
+            return { runtime: "claude", windows: [], error: firstLine(text.stderr) || firstLine(text.stdout) || "claude /usage 沒有回傳額度。" };
+        return { runtime: "claude", windows };
+    }
+    catch (error) {
+        return { runtime: "claude", windows: [], error: missing("claude", error) };
+    }
+}
+export async function codexQuota() {
+    try {
+        const limits = await readCodexLimits();
+        return { runtime: "codex", windows: codexWindows(limits) };
+    }
+    catch (error) {
+        return { runtime: "codex", windows: [], error: missing("codex", error) };
+    }
+}
+function missing(cmd, error) {
+    const code = error.code;
+    if (code === "ENOENT")
+        return `找不到 ${cmd}。`;
+    return error.message || `${cmd} 沒有回傳額度。`;
+}
+function firstLine(text) {
+    return text.split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+}
+function capture(cmd, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error(`${cmd} 超過 ${Math.round(timeoutMs / 1000)} 秒沒有回應。`));
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => (stdout += String(chunk)));
+        child.stderr.on("data", (chunk) => (stderr += String(chunk)));
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", () => {
+            clearTimeout(timer);
+            resolve({ stdout, stderr });
+        });
+    });
+}
+function readCodexLimits() {
+    return new Promise((resolve, reject) => {
+        const child = spawn("codex", ["app-server", "--stdio"], { stdio: ["pipe", "pipe", "pipe"] });
+        let buf = "";
+        const timer = setTimeout(() => {
+            child.kill();
+            reject(new Error("codex 超過 20 秒沒有回應。"));
+        }, 20_000);
+        let done = false;
+        const finish = (error, limits) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(limits ?? {});
+        };
+        child.on("error", (error) => finish(error));
+        child.stdout.on("data", (chunk) => {
+            buf += String(chunk);
+            let cut = buf.indexOf("\n");
+            while (cut >= 0) {
+                const line = buf.slice(0, cut).trim();
+                buf = buf.slice(cut + 1);
+                cut = buf.indexOf("\n");
+                if (!line)
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (message.id === 1 && message.result) {
+                    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method: "initialized", params: {} })}\n`);
+                    child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 2, method: "account/rateLimits/read", params: {} })}\n`);
+                }
+                if (message.id === 2) {
+                    if (message.error)
+                        finish(new Error(message.error.message || "codex 沒有回傳額度。"));
+                    else
+                        finish(undefined, message.result?.rateLimits ?? {});
+                }
+            }
+        });
+        child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: { clientInfo: { name: "agent-lyceum", version: "0" }, capabilities: {} } })}\n`);
+    });
+}

package/dist/status-watch.d.ts

@@ -1,6 +1,6 @@
 import type { ResolvedProject } from "./config.js";
 import { type StatusReport } from "./status.js";
-/** What `status --json --watch` prints, one JSON object per line: the project's report plus one per task that is not completed. */
+/** What `status --json --watch` prints, one JSON object per line: the project's report plus one per task that is not finished (completed or partial). */
 export type WatchFrame = {
     schema_version: 1;
     report?: StatusReport;
@@ -8,12 +8,14 @@ export type WatchFrame = {
     error?: string;
 };
 /**
- * The frame for now. Every task that is not completed (running, interrupted, waiting for answers, or ended partial,
- * blocked, failed or cancelled) gets its own report, so it stays listed until it is resumed to completion or cleared.
- * A task that was running in the previous frame and has completed since is included once more, so the reader sees
+ * The frame for now. Every task that is not finished (running, interrupted, waiting for answers, or ended blocked,
+ * failed or cancelled) gets its own report, so it stays listed until it is resumed or cleared.
+ * A task that was running in the previous frame and has finished (completed or partial) since is included once more, so the reader sees
  * it finish (and can toast) before it is dropped. `tracked` is that previous set; it is replaced by the ids running now.
  */
-export declare function buildWatchFrame(project: ResolvedProject, tracked: Set<string>): WatchFrame;
+export declare function buildWatchFrame(project: ResolvedProject, tracked: Set<string>, opts?: {
+    allTasks?: boolean;
+}): WatchFrame;
 export interface WatchDeps {
     /** The project, loaded again each time so config edits and new runs show up. */
     load: () => ResolvedProject;
@@ -21,6 +23,8 @@ export interface WatchDeps {
     dir: (project: ResolvedProject) => string;
     write: (line: string) => void;
     debounceMs: number;
+    /** Include finished tasks. The browser page uses this; `status --json --watch` does not. */
+    allTasks?: boolean;
     watch?: (dir: string, onChange: () => void) => {
         close: () => void;
     };

package/dist/status-watch.js

@@ -1,17 +1,19 @@
 import fs from "node:fs";
-import { buildStatusReport, buildTaskListReport, isCompletedRun } from "./status.js";
+import { buildStatusReport, buildTaskListReport, isFinishedRun } from "./status.js";
 /**
- * The frame for now. Every task that is not completed (running, interrupted, waiting for answers, or ended partial,
- * blocked, failed or cancelled) gets its own report, so it stays listed until it is resumed to completion or cleared.
- * A task that was running in the previous frame and has completed since is included once more, so the reader sees
+ * The frame for now. Every task that is not finished (running, interrupted, waiting for answers, or ended blocked,
+ * failed or cancelled) gets its own report, so it stays listed until it is resumed or cleared.
+ * A task that was running in the previous frame and has finished (completed or partial) since is included once more, so the reader sees
  * it finish (and can toast) before it is dropped. `tracked` is that previous set; it is replaced by the ids running now.
  */
-export function buildWatchFrame(project, tracked) {
+export function buildWatchFrame(project, tracked, opts) {
     const all = buildTaskListReport(project).runs;
     const running = all.filter((r) => r.state === "running").map((r) => r.run_id);
-    const open = all.filter((r) => !isCompletedRun(r)).map((r) => r.run_id);
+    const open = all.filter((r) => !isFinishedRun(r)).map((r) => r.run_id);
     const runs = {};
-    for (const id of new Set([...open, ...tracked]))
+    // The web page keeps every task. The terminal watch drops one after it has finished, once the finish has been seen.
+    const ids = opts?.allTasks ? all.map((r) => r.run_id) : [...open, ...tracked];
+    for (const id of new Set(ids))
         runs[id] = buildStatusReport(project, id);
     const report = buildStatusReport(project);
     tracked.clear();
@@ -39,7 +41,7 @@ export function createStatusWatcher(d) {
         let project;
         try {
             project = d.load();
-            frame = buildWatchFrame(project, tracked);
+            frame = buildWatchFrame(project, tracked, { allTasks: d.allTasks });
         }
         catch (e) {
             frame = { schema_version: 1, error: e.message };

package/dist/status.d.ts

@@ -173,8 +173,8 @@ export declare function buildRunReport(run: {
 }, project?: ResolvedProject, opts?: {
     detail?: boolean;
 }): RunReport;
-/** A run that ended with a verified-or-inferred `completed` outcome: the only kind the monitor stops listing. */
-export declare const isCompletedRun: (r: Pick<RunReport, "state" | "outcome">) => boolean;
+/** A run that ended with a `completed` or `partial` outcome: the only kinds the monitor stops listing (blocked, failed and cancelled stay). */
+export declare const isFinishedRun: (r: Pick<RunReport, "state" | "outcome">) => boolean;
 /** The status of a project: its agents and one run (the newest running one, else the newest, or the one named by `runId`). */
 export declare function buildStatusReport(base: ResolvedProject, runId?: string, now?: number): StatusReport;
 /** Every run of the project, newest first. */

package/dist/status.js

@@ -266,8 +266,8 @@ export function buildRunReport(run, project, opts = {}) {
         ...(ask ? { ask } : {}),
     };
 }
-/** A run that ended with a verified-or-inferred `completed` outcome: the only kind the monitor stops listing. */
-export const isCompletedRun = (r) => r.state === "ended" && r.outcome === "completed";
+/** A run that ended with a `completed` or `partial` outcome: the only kinds the monitor stops listing (blocked, failed and cancelled stay). */
+export const isFinishedRun = (r) => r.state === "ended" && (r.outcome === "completed" || r.outcome === "partial");
 const projectInfo = (p) => ({ name: p.name, dir: p.dir, lead: p.lead });
 /** The fallback part of an agent's report: nothing at all for an agent without a chain. */
 function fallbackView(a, state, now) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",
@@ -27,7 +27,9 @@
   },
   "files": [
     "dist",
-    "!dist/**/*.map"
+    "!dist/**/*.map",
+    "web/dist",
+    "!web/dist/**/*.map"
   ],
   "engines": {
     "node": ">=20"
@@ -41,7 +43,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit && npm run typecheck:plugin",
     "test": "vitest run",
     "prepare": "npm run build",
-    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build && pnpm --dir web install --frozen-lockfile && pnpm --dir web typecheck && pnpm --dir web build",
     "release": "bash scripts/release.sh",
     "typecheck:plugin": "tsc -p plugins/status-monitor/tsconfig.ci.json",
     "check:pack": "node scripts/check-pack.mjs",