agent-lyceum 0.20.0 → 0.21.0

package/dist/cli.js

@@ -22,6 +22,8 @@ import { prepareTask, readTaskFile, taskMessageBody } from "./task.js";
 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 { 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";
 const program = new Command();
@@ -145,6 +147,8 @@ function takeLock(pr, runId, opts = {}) {
 /**
  * Ctrl-C (or SIGTERM) stops the run cleanly: the first signal cancels it (agents are killed, unread mail is kept,
  * the lock is released, exit code 130); a second one quits at once.
+ * Started through a launcher that does not relay SIGHUP (npx, npm exec, tsx), the launcher exiting counts as that
+ * first signal: otherwise closing the terminal would leave this process running on its own (spec 21).
  */
 function cancelOnSignals() {
     const ac = new AbortController();
@@ -157,13 +161,26 @@ function cancelOnSignals() {
         else
             process.exit(130);
     };
+    const onParentGone = () => {
+        if (seen > 0)
+            return; // already stopping
+        seen = 1;
+        // stderr may be a dead terminal or pipe: console.error would throw EPIPE/EIO there
+        try {
+            fs.writeSync(2, "\nLauncher exited (parent process gone): stopping the run (running agents are being stopped; unread mail is kept).\n");
+        }
+        catch { }
+        ac.abort();
+    };
     const onInt = handler("Interrupted");
     const onTerm = handler("Terminated");
     const onHup = handler("Hung up");
     process.on("SIGINT", onInt);
     process.on("SIGTERM", onTerm);
     process.on("SIGHUP", onHup); // the terminal went away
+    const stopWatch = startedByWrapper() ? watchParent(onParentGone, { startPpid: LAUNCH_PPID }) : () => { };
     return { signal: ac.signal, dispose: () => {
+            stopWatch();
             process.off("SIGINT", onInt);
             process.off("SIGTERM", onTerm);
             process.off("SIGHUP", onHup);
@@ -777,8 +794,16 @@ program
             }
             process.stdout.write(`\x1b[2J\x1b[H${text}\n\nRefreshing every ${sec}s — ${new Date().toLocaleTimeString()} — Ctrl-C to quit\n`);
         };
-        draw();
-        setInterval(draw, sec * 1000);
+        runMonitor({
+            draw,
+            intervalMs: sec * 1000,
+            stdout: process.stdout,
+            stdin: process.stdin,
+            ppid: () => process.ppid,
+            exit: (code) => process.exit(code),
+            onSignal: (sig, handler) => process.on(sig, handler),
+            fail: (message) => fail(message),
+        });
         await new Promise(() => { });
     }
     catch (e) {

package/dist/monitor-lifecycle.d.ts

@@ -0,0 +1,19 @@
+import type { EventEmitter } from "node:events";
+export interface MonitorDeps {
+    draw: () => void;
+    intervalMs: number;
+    stdout: EventEmitter & {
+        destroyed?: boolean;
+        writable?: boolean;
+    };
+    stdin: EventEmitter & {
+        isTTY?: boolean;
+        resume: () => unknown;
+    };
+    ppid: () => number;
+    exit: (code: number) => void;
+    onSignal: (sig: NodeJS.Signals, handler: () => void) => void;
+    fail: (message: string) => void;
+}
+/** Run `draw` every interval and end the process when the monitor is closed: signal, dead stdout, TTY stdin close, or lost parent. */
+export declare function runMonitor(d: MonitorDeps): void;

package/dist/monitor-lifecycle.js

@@ -0,0 +1,42 @@
+const SIGNAL_CODES = [["SIGINT", 130], ["SIGTERM", 143], ["SIGHUP", 129]];
+/** Run `draw` every interval and end the process when the monitor is closed: signal, dead stdout, TTY stdin close, or lost parent. */
+export function runMonitor(d) {
+    const startPpid = d.ppid();
+    let timer;
+    let done = false;
+    const stop = (code) => {
+        if (done)
+            return;
+        done = true;
+        if (timer)
+            clearInterval(timer);
+        d.exit(code);
+    };
+    for (const [sig, code] of SIGNAL_CODES)
+        d.onSignal(sig, () => stop(code));
+    d.stdout.on("error", (e) => {
+        if (e.code === "EPIPE" || e.code === "EIO")
+            return stop(0);
+        done = true;
+        if (timer)
+            clearInterval(timer);
+        d.fail(e.message);
+    });
+    if (d.stdin.isTTY) {
+        for (const ev of ["end", "close", "error"])
+            d.stdin.on(ev, () => stop(0));
+        d.stdin.resume(); // a TTY only reports EOF while it is being read
+    }
+    const tick = () => {
+        if (done)
+            return;
+        if (d.ppid() !== startPpid)
+            return stop(129);
+        if (d.stdout.destroyed || d.stdout.writable === false)
+            return stop(0);
+        d.draw();
+    };
+    tick();
+    if (!done)
+        timer = setInterval(tick, d.intervalMs);
+}

package/dist/parent-watch.d.ts

@@ -0,0 +1,17 @@
+/** The parent pid when the process started (read at module load, before config loading and preflight). */
+export declare const LAUNCH_PPID: number;
+/**
+ * Started by a launcher that does not relay SIGHUP: npm/npx/pnpm/yarn (they set `npm_execpath`), or the tsx CLI
+ * (its child runs with `--require …/tsx/dist/preflight.cjs`). A directly run binary is never watched, so runs that are
+ * detached on purpose (`&`, `disown`, `setsid`, supervisors) keep running when their parent exits.
+ */
+export declare function startedByWrapper(env?: NodeJS.ProcessEnv, execArgv?: readonly string[]): boolean;
+/**
+ * Call `onGone` once when the parent pid differs from `startPpid` (the launcher exited and the process was adopted):
+ * checked at once, then every `intervalMs` on an unref'd timer. Returns a function that stops the watch.
+ */
+export declare function watchParent(onGone: () => void, opts: {
+    startPpid: number;
+    ppid?: () => number;
+    intervalMs?: number;
+}): () => void;

package/dist/parent-watch.js

@@ -0,0 +1,37 @@
+/** The parent pid when the process started (read at module load, before config loading and preflight). */
+export const LAUNCH_PPID = process.ppid;
+/**
+ * Started by a launcher that does not relay SIGHUP: npm/npx/pnpm/yarn (they set `npm_execpath`), or the tsx CLI
+ * (its child runs with `--require …/tsx/dist/preflight.cjs`). A directly run binary is never watched, so runs that are
+ * detached on purpose (`&`, `disown`, `setsid`, supervisors) keep running when their parent exits.
+ */
+export function startedByWrapper(env = process.env, execArgv = process.execArgv) {
+    if (env.npm_execpath)
+        return true;
+    return execArgv.some((a) => /[\\/]tsx[\\/]dist[\\/]preflight\.cjs$/.test(a));
+}
+/**
+ * Call `onGone` once when the parent pid differs from `startPpid` (the launcher exited and the process was adopted):
+ * checked at once, then every `intervalMs` on an unref'd timer. Returns a function that stops the watch.
+ */
+export function watchParent(onGone, opts) {
+    const ppid = opts.ppid ?? (() => process.ppid);
+    let timer;
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+    };
+    if (ppid() !== opts.startPpid) {
+        onGone();
+        return stop;
+    }
+    timer = setInterval(() => {
+        if (ppid() === opts.startPpid)
+            return;
+        stop();
+        onGone();
+    }, opts.intervalMs ?? 1000);
+    timer.unref();
+    return stop;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-lyceum",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "description": "Config + dispatcher for teams of Claude Code / Codex agents with scoped context and file-based mailboxes",
   "keywords": [
     "ai",