@alphacoder-v0/pi-loops 0.22.8 → 0.24.1

package/src/goal.ts

@@ -32,6 +32,15 @@ export function goalActive(state: GoalState): boolean {
 	return state.status === "pursuing" || state.status === "paused" || state.status === "budget_limited";
 }
 
+/**
+ * Whether a queued continuation still has a goal to run for: only a pursued one. A paused goal (Esc,
+ * an evaluator that could not answer, the budget) keeps its condition but not the continuation it
+ * was about to run; `/goal resume` judges the next turn afresh.
+ */
+export function goalPursued(state: GoalState | undefined): boolean {
+	return state?.status === "pursuing";
+}
+
 export interface EvaluatorDecision {
 	ok: boolean;
 	reason: string;
@@ -170,6 +179,45 @@ export function branchMovedSince(entries: Array<{ id: string; type: string; mess
 	return entries.slice(from + 1).some((e) => e.type === "message" && e.message?.role === "user");
 }
 
+/**
+ * Whether a continuation is still on its way: a `goal` row queued for the session, or handed to pi
+ * and not yet in the conversation. While one is, a settled turn is not judged again: the evaluator
+ * charged `iterations` when it asked for that continuation, and the drain delivers it instead. Once
+ * the continuation is in the conversation the turn it started is the next one to judge, so a row
+ * whose id `delivered` already holds does not count.
+ */
+export function continuationPending(queued: ReadonlyArray<{ id: string; source: string }>, inFlight: Iterable<string>, delivered: (id: string) => boolean): boolean {
+	if (queued.some((row) => row.source === "goal" && !delivered(row.id))) return true;
+	for (const id of inFlight) if (id.startsWith("goal-") && !delivered(id)) return true;
+	return false;
+}
+
+/**
+ * What `agent_settled` does, in order: judge the turn (`evaluate`, which hands over a continuation
+ * and says whether it did) unless a continuation is already on its way, in which case the drain
+ * delivers that one instead; then drain, unless the evaluator just handed a continuation over, since
+ * pi may not report itself busy with it yet and a second turn row would be queued behind it.
+ */
+export async function settledTurn(queued: ReadonlyArray<{ id: string; source: string }>, inFlight: Iterable<string>, delivered: (id: string) => boolean, evaluate: () => Promise<boolean>, drain: () => Promise<unknown>): Promise<{ pending: boolean; continued: boolean }> {
+	const pending = continuationPending(queued, inFlight, delivered);
+	const continued = !pending && (await evaluate());
+	if (!continued) await drain();
+	return { pending, continued };
+}
+
+/**
+ * Judge the settled turn, and judge again for as long as another turn settled while the evaluator
+ * ran (`skippedMeanwhile`, which takes the mark). Such a turn found the evaluator busy and was not
+ * judged by anyone, so a continuation held for it ("re-evaluated when this turn settles") waited
+ * for the person to type again. Not after a continuation went out, which settles into a judgement
+ * of its own, and not while pi is busy, since that turn will settle and be judged itself.
+ */
+export async function judgeCaughtUp(evaluate: () => Promise<boolean>, skippedMeanwhile: () => boolean, idle: () => boolean): Promise<boolean> {
+	let continued = await evaluate();
+	while (!continued && skippedMeanwhile() && idle()) continued = await evaluate();
+	return continued;
+}
+
 /** An evaluator that could not decide never loops the agent: it pauses and says why. */
 export function pauseFor(state: GoalState, reason: string, now = new Date()): { state: GoalState; action: GoalAction } {
 	return { state: { ...state, status: "paused", lastReason: reason, updatedAt: stamp(now.getTime()) }, action: { kind: "pause", reason } };
@@ -186,6 +234,29 @@ export function abortedTurn(state: GoalState, now = new Date()): { state: GoalSt
 	return pauseFor(state, "you stopped the turn (Esc); /goal resume to continue", now);
 }
 
+/**
+ * `/goal resume`: pursuing again, and with the allowance started again when it is spent. Spent is
+ * the count, not the status: a budget-limited goal that was paused and then resumed is `paused`
+ * by then, and keeping its count sent the next "not satisfied" straight back to the limit, so the
+ * person had to resume twice (docs/goal.md: resume after a budget limit starts the allowance again).
+ */
+export function resumeGoal(state: GoalState, now = new Date()): GoalState {
+	const spent = state.status === "budget_limited" || state.iterations >= MAX_CONTINUATIONS;
+	return { ...state, status: "pursuing", iterations: spent ? 0 : state.iterations, updatedAt: stamp(now.getTime()) };
+}
+
+/**
+ * Whether an evaluation that just came back may write its verdict over `current`. Not if it was
+ * aborted: every abort is a `/goal` command or Esc, and each has already written the goal the person
+ * asked for. Checking only "still pursuing, same condition" let a `/goal resume`, or the same
+ * `/goal <condition>` typed again, be paused as "goal evaluator cancelled" by the evaluation it had
+ * just stopped. Nor if the goal was paused, cleared or replaced while it ran.
+ */
+export function evaluationApplies(current: GoalState | undefined, pursued: GoalState, aborted: boolean): boolean {
+	if (aborted) return false;
+	return !!current && current.status === "pursuing" && current.condition === pursued.condition;
+}
+
 /** One line for `/goal` and the panel. */
 export function goalLine(state: GoalState): string {
 	const iter = `${state.iterations}/${MAX_CONTINUATIONS}`;

package/src/held-read.ts

@@ -0,0 +1,27 @@
+/**
+ * How big a conversation this process parses: the page server reads held conversations itself, and
+ * the page child asks its pi for every entry. Both run in the process every page and loop shares,
+ * so both ask here first. A module of its own because src/page-server.ts imports
+ * src/page-children.ts, and both need it.
+ */
+import * as fs from "node:fs";
+
+/** The largest session file the page reads itself; a bigger one is answered by the page's pi. The read is synchronous, in the process every page shares. */
+export const HELD_READ_MAX_BYTES = 32 * 1024 * 1024;
+
+/**
+ * Whether this process asks pi for a conversation's entries (run cards, the panel's snapshot, find,
+ * undo, the model to resume on): pi answers with every entry, compacted and abandoned branches too,
+ * and this process parses them, so not for a session file over `HELD_READ_MAX_BYTES`. A file pi has
+ * not named yet is not read: its size is unknown. Nor is a file that is not on disk once it has been
+ * (`everOnDisk`), since it may have moved at any size; one pi has not written yet is read, since pi
+ * writes it at the first message and what it holds until then is small.
+ */
+export function entriesReadable(file: string | undefined, everOnDisk = true): boolean {
+	if (!file) return false; // not known yet: do not parse what we cannot size
+	try {
+		return fs.statSync(file).size <= HELD_READ_MAX_BYTES;
+	} catch (err: any) {
+		return err?.code === "ENOENT" && !everOnDisk; // not written yet is small; gone, or not ours to stat, is unknown
+	}
+}

package/src/hooks.ts

@@ -32,6 +32,44 @@ const MAX_SUMMARY_CHARS = 2000;
 /** What a hook may put in the log per run. The same bound stderr has used for the failure message. */
 const MAX_OUTPUT_CHARS = 4000;
 
+/**
+ * A stream's output, decoded as it arrives and kept up to a bound counted in characters.
+ *
+ * Each chunk used to be decoded on its own and the bound was `.length`, which counts UTF-16 code
+ * units: a character split across two chunks became a replacement glyph, an emoji-heavy hook was cut
+ * at about half the 4000 characters docs/hooks.md promises, and the cut could end on half of one.
+ * One streaming decoder keeps a split character whole; the count is characters. Once the bound is
+ * reached the rest is dropped, and `overflowed` says something was.
+ */
+export class BoundedText {
+	private readonly decoder = new TextDecoder();
+	private value = "";
+	private chars = 0;
+	private readonly max: number;
+	overflowed = false;
+	constructor(max: number) {
+		this.max = max;
+	}
+	push(chunk: Uint8Array): void {
+		if (this.chars >= this.max) {
+			this.overflowed = true;
+			return;
+		}
+		const text = this.decoder.decode(chunk, { stream: true });
+		this.value += text;
+		this.chars += Array.from(text).length;
+	}
+	/** What was kept, with any bytes still held by the decoder flushed when nothing was dropped. */
+	text(): string {
+		if (!this.overflowed && this.chars < this.max) {
+			const rest = this.decoder.decode();
+			this.value += rest;
+			this.chars += Array.from(rest).length;
+		}
+		return this.value;
+	}
+}
+
 export interface HookConfig {
 	event: HookEvent;
 	command?: string;
@@ -84,9 +122,8 @@ export interface HookPayload {
 export type HookEventData = Pick<HookPayload, "event" | "message_kind" | "message_summary" | "assistant_event" | "tool_call_id" | "tool_name" | "tool_is_error" | "tool_args" | "tool_result_summary" | "compaction_trigger" | "compaction_tokens_before" | "compaction_summary" | "compaction_failed" | "run_job" | "run_id" | "run_ok" | "run_findings" | "run_error" | "run_cost_usd">;
 
 /**
- * The same two events the interactive extension and the headless host fire. Whether a run happens
- * here or there is an accident of who held the clock, and a hook rule should not be able to tell —
- * so both processes fire the object these two return.
+ * The two events around a scheduled run. Every loop runs in the host, which fires them; the
+ * interactive extension builds the same objects, so a run's payload has one shape wherever it came from.
  */
 export function runStartEvent(job: LoopJob, runId: string): HookEventData {
 	return { event: "run_start", run_job: job.name ?? job.id, run_id: runId, message_summary: truncateSummary(`${job.name ?? job.id}: ${job.prompt}`) };
@@ -338,23 +375,17 @@ export class HookRunner {
 			// Own process group (setsid equivalent) so a timeout kills the whole tree, not just `sh`.
 			// stdout is piped only when there is somewhere to put it; otherwise it goes to /dev/null as before.
 			const proc = spawn(isWin ? "cmd" : "sh", [isWin ? "/C" : "-c", h.command!], { cwd: this.resolveCwd(h), env, stdio: ["ignore", this.opts.log ? "pipe" : "ignore", "pipe"], detached: !isWin });
-			let stderr = "";
-			proc.stderr?.on("data", (d) => {
-				if (stderr.length < MAX_OUTPUT_CHARS) stderr += d.toString();
-			});
+			const stderr = new BoundedText(MAX_OUTPUT_CHARS);
+			proc.stderr?.on("data", (d: Buffer) => stderr.push(d));
 			// What the hook itself printed. Bounded: a hook that prints a megabyte would otherwise put
 			// a megabyte in the log and rotate away everything the automation had recorded before it.
-			let stdout = "";
-			let overflowed = false;
-			proc.stdout?.on("data", (d) => {
-				if (stdout.length >= MAX_OUTPUT_CHARS) overflowed = true;
-				else stdout += d.toString();
-			});
+			const stdout = new BoundedText(MAX_OUTPUT_CHARS);
+			proc.stdout?.on("data", (d: Buffer) => stdout.push(d));
 			const logOutput = () => {
-				const text = stdout.trim();
-				if (!text) return; // a silent hook stays silent
-				const capped = overflowed || text.length > MAX_OUTPUT_CHARS;
-				this.opts.log?.(`hook ${h.source} ${h.event}${h.tool ? ` (tool=${h.tool})` : ""}: ${capped ? `${text.slice(0, MAX_OUTPUT_CHARS)}… (output truncated)` : text}`);
+				const chars = Array.from(stdout.text().trim());
+				if (!chars.length) return; // a silent hook stays silent
+				const capped = stdout.overflowed || chars.length > MAX_OUTPUT_CHARS;
+				this.opts.log?.(`hook ${h.source} ${h.event}${h.tool ? ` (tool=${h.tool})` : ""}: ${capped ? `${chars.slice(0, MAX_OUTPUT_CHARS).join("")}… (output truncated)` : chars.join("")}`);
 			};
 			const killTree = () => {
 				try {
@@ -388,7 +419,7 @@ export class HookRunner {
 				// managed to say before it was killed is exactly what the reader needs.
 				logOutput();
 				if (code === 0) finish();
-				else finish(new Error(`command exited ${code ?? -1}: ${stderr.trim()}`));
+				else finish(new Error(`command exited ${code ?? -1}: ${stderr.text().trim()}`));
 			});
 		});
 	}