neurastream 0.1.7 → 0.1.8

package/README.md

@@ -51,6 +51,7 @@ The switch is never automatic:
 - The owner's next plain message then closes the session and starts a fresh one. The fresh session opens with the note verbatim, the generated `main-start` state (including the owner holds), and then the owner's message. The previous session file stays where it is.
 - While own jobs (subagents included) are still running, the switch waits: a rollover would cancel them, so the owner's message stays in the current session until they finish.
 - `/main-rollover <message>` does the same by hand. It refuses below the threshold, without a fresh note, or while jobs run.
+- `/main-rollover` shows a notice at once and gathers `main-start` in the background, so omp keeps repainting and reading keys until the new session opens.
 - `rollover.enabled: false` turns the feature off.
 
 ## Changing a script

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neurastream",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Harness-agnostic agent orchestration: queue, guards, blockers, scoring, ledger.",
   "type": "module",
   "license": "MIT",

package/src/adapters/omp/index.ts

@@ -432,7 +432,8 @@ export function createOmpAdapter(pi: ExtensionHost, cfg: Config): void {
 				c.notify(`main-rollover: own jobs are still running (${c.runningJobs().join(", ")}); a rollover would cancel them.`);
 				return;
 			}
-			const generated = [await mainStartText([], cfg), holdsBlock(q.ownerHolds())].join("\n");
+			c.notify("main-rollover: collecting main-start state for the handoff (this can take a minute)…");
+			const generated = [await mainStartText([], cfg, { inheritStdin: false }), holdsBlock(q.ownerHolds())].join("\n");
 			const handoff = buildHandoff({
 				generated,
 				note: readFileSync(path, "utf8"),

package/src/adapters/omp/sessions.ts

@@ -54,17 +54,10 @@ function costOf(m: Record<string, unknown>): number {
 	return c && typeof c.total === "number" ? c.total : 0;
 }
 
-interface Built {
-	run: Run;
-	mtime: number;
-}
-
-function build(file: string, cfg: Config): Built | null {
+function build(file: string, cfg: Config, mtime: number): Run | null {
 	let text: string;
-	let mtime: number;
 	try {
 		text = readFileSync(file, "utf8");
-		mtime = statSync(file).mtimeMs / 1000;
 	} catch {
 		return null;
 	}
@@ -202,7 +195,7 @@ function build(file: string, cfg: Config): Built | null {
 		scoreSurvived: done && !scoreErr,
 		scoreEnd: scoreErr || (done ? "done" : "no final message"),
 	};
-	return { run, mtime };
+	return run;
 }
 
 function readMain(file: string): MainSession {
@@ -253,9 +246,15 @@ export function ompRunSource(root: string, cfg: Config): RunSource {
 			const files = [...jsonlAt(root, 1), ...jsonlAt(root, 2)];
 			const runs: Run[] = [];
 			for (const file of files) {
-				const built = build(file, cfg);
-				if (!built || built.mtime < since) continue;
-				runs.push(built.run);
+				let mtime: number;
+				try {
+					mtime = statSync(file).mtimeMs / 1000;
+				} catch {
+					continue;
+				}
+				if (mtime < since) continue;
+				const run = build(file, cfg, mtime);
+				if (run) runs.push(run);
 			}
 			return runs;
 		},

package/src/core/agent-ledger.ts

@@ -64,13 +64,21 @@ export function agentLedger(args: string[], cfg: Config, source: RunSource): num
 
 	if (!args.includes("--cap")) return 0;
 	const live: Record<string, string[]> = {};
+	const notLive: string[] = [];
 	for (const r of rows) {
 		if ((r.statusDetail.startsWith("RUNNING") || r.statusDetail.startsWith("WAITING")) && !r.id.startsWith("MAIN")) {
+			if ((nowSec() - r.lastWriteAt) / 60 >= cfg.ledger.idle_not_live_min) {
+				notLive.push(r.id);
+				continue;
+			}
 			const provider = r.model.split("/")[0] ?? "";
 			(live[provider] ??= []).push(r.id);
 		}
 	}
 	process.stdout.write(`running per provider: ${pyDictInt(Object.fromEntries(Object.entries(live).map(([k, v]) => [k, v.length])))}\n`);
+	if (notLive.length) {
+		process.stdout.write(`NOT LIVE (no write for ≥ ${cfg.ledger.idle_not_live_min}m, not counted): ${notLive.join(", ")}\n`);
+	}
 	let full = Object.entries(live).filter(([, v]) => v.length >= cfg.ledger.max_running_per_provider).map(([k]) => k);
 	for (const k of full) process.stdout.write(`FULL ${k}: ${live[k]!.join(", ")}\n`);
 	const over = rows.filter(r => r.statusDetail.includes("OVER-BUDGET")).map(r => r.id);

package/src/core/main-start.ts

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { spawnSync } from "node:child_process";
+import { spawn } from "node:child_process";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { Config } from "./config.ts";
@@ -8,39 +8,83 @@ function bin(name: string, cfg: Config): string {
 	return join(cfg.paths.home, ".local/bin", name);
 }
 
+interface RunOpts {
+	stdin?: "inherit" | "ignore" | "pipe";
+	/** Written to the child's stdin when stdin is "pipe". */
+	input?: string;
+	stderr?: "inherit" | "pipe" | "ignore";
+}
+
+interface RunResult {
+	stdout: string;
+	stderr: string;
+	/** Set when the child could not start (e.g. ENOENT). */
+	error?: Error;
+}
+
+// Runs a child without blocking the caller's event loop. Resolves once the child has closed its
+// streams, or immediately when it fails to start. The handoff runs inside a live agent session,
+// which must keep handling events while Main's state is gathered.
+function run(file: string, args: string[], opts: RunOpts = {}): Promise<RunResult> {
+	const { promise, resolve } = Promise.withResolvers<RunResult>();
+	const child = spawn(file, args, {
+		stdio: [opts.stdin ?? "ignore", "pipe", opts.stderr ?? "pipe"],
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout?.setEncoding("utf8").on("data", chunk => {
+		stdout += chunk;
+	});
+	child.stderr?.setEncoding("utf8").on("data", chunk => {
+		stderr += chunk;
+	});
+	// A filter such as awk may exit before it has read all its input.
+	child.stdin?.on("error", () => {});
+	if (opts.stdin === "pipe") child.stdin?.end(opts.input ?? "");
+	child.on("error", error => resolve({ stdout, stderr, error }));
+	child.on("close", () => resolve({ stdout, stderr }));
+	return promise;
+}
+
 // Main's session-start preflight as one text. The CLI prints it; the session rollover handoff
 // (src/core/rollover.ts) carries the same text into the new session. Children's stdout is
 // collected in order, so the printed output matches the original script line for line.
-export function mainStartText(args: string[], cfg: Config): string {
+// inheritStdin: the CLI passes its terminal to the children that ask the operator something;
+// an agent host passes false, because its stdin is the session's input.
+// stderr: the CLI lets a child's stderr reach the terminal. An agent host captures it and appends it
+// after that child's stdout, because a write to the terminal would draw over the session's UI.
+export async function mainStartText(args: string[], cfg: Config, opts: { inheritStdin: boolean }): Promise<string> {
 	const out: string[] = [];
 	const say = (line: string) => out.push(`${line}\n`);
 	const h = args[0] ?? String(cfg.health.default_hours);
+	const childStdin = opts.inheritStdin ? "inherit" : "ignore";
+	const childStderr = opts.inheritStdin ? "inherit" : "pipe";
 	say("=== machine");
-	const mg = spawnSync(bin("machine-guard", cfg), [], { encoding: "utf8", env: process.env });
-	const mgLines = (mg.stdout ?? "").trim().split("\n");
+	const mg = await run(bin("machine-guard", cfg), [], { stderr: "ignore" });
+	const mgLines = mg.stdout.trim().split("\n");
 	say(mgLines.at(-1) ?? "");
 	say(readFileSync("/proc/loadavg", "utf8").trim());
 	say("");
 	say(`=== agents (last ${h}h; DIED = check its worktree, relaunch FRESH with its progress file)`);
-	const ledger = spawnSync(bin("agent-ledger", cfg), ["--hours", h], { encoding: "utf8", env: process.env });
-	const awk = spawnSync(
+	const ledger = await run(bin("agent-ledger", cfg), ["--hours", h], { stderr: "ignore" });
+	const awk = await run(
 		"awk",
 		["NR==1 || /DIED/ {print; next} {ok[++n]=$0} END {for (i=1;i<=n;i++) print ok[i]}"],
-		{ input: ledger.stdout ?? "", encoding: "utf8" },
+		{ stdin: "pipe", input: ledger.stdout, stderr: "ignore" },
 	);
-	out.push(awk.stdout ?? "");
-	const cap = spawnSync(bin("agent-ledger", cfg), ["--cap"], { encoding: "utf8", env: process.env, stdio: ["ignore", "pipe", "ignore"] });
-	for (const line of (cap.stdout ?? "").split("\n")) {
+	out.push(awk.stdout);
+	const cap = await run(bin("agent-ledger", cfg), ["--cap"], { stderr: "ignore" });
+	for (const line of cap.stdout.split("\n")) {
 		if (/^(PRIORITY IDLE|FULL)/.test(line)) say(line);
 	}
 	say("");
 	say("=== main thread");
-	const health = spawnSync(bin("main-health", cfg), [], { encoding: "utf8", env: process.env, stdio: ["inherit", "pipe", "inherit"] });
-	out.push(health.stdout ?? "");
+	const health = await run(bin("main-health", cfg), [], { stdin: childStdin, stderr: childStderr });
+	out.push(health.stdout + health.stderr);
 	say("");
 	say("=== queue");
-	const check = spawnSync(bin("queue-check", cfg), [], { encoding: "utf8", env: process.env, stdio: ["inherit", "pipe", "inherit"] });
-	out.push(check.stdout ?? "");
+	const check = await run(bin("queue-check", cfg), [], { stdin: childStdin, stderr: childStderr });
+	out.push(check.stdout + check.stderr);
 	say("");
 	say("=== heavy-run lock");
 	try {
@@ -52,14 +96,14 @@ export function mainStartText(args: string[], cfg: Config): string {
 	// The CLI file itself (shebang `#!/usr/bin/env bun`), never process.execPath: inside a host
 	// harness that is the harness binary, which would start a new agent session instead.
 	const cli = join(dirname(fileURLToPath(import.meta.url)), "../cli/main.ts");
-	const doctor = spawnSync(cli, ["doctor"], { encoding: "utf8", env: process.env });
-	const text = `${doctor.stdout ?? ""}${doctor.stderr ?? ""}`;
+	const doctor = await run(cli, ["doctor"]);
+	const text = `${doctor.stdout}${doctor.stderr}`;
 	out.push(text.endsWith("\n") || text === "" ? text : `${text}\n`);
 	if (doctor.error) say(doctor.error.message);
 	return out.join("");
 }
 
-export function mainStart(args: string[], cfg: Config): number {
-	process.stdout.write(mainStartText(args, cfg));
+export async function mainStart(args: string[], cfg: Config): Promise<number> {
+	process.stdout.write(await mainStartText(args, cfg, { inheritStdin: true }));
 	return 0;
 }