@gavin-hu/my-pi-agent 0.21.0 → 0.22.0

package/extensions/job/config.ts

@@ -27,7 +27,14 @@ export interface JobsConfig {
 	killGraceMs: number;
 	/** Status-chip refresh interval while jobs run. */
 	repaintMs: number;
-	/** How long a session heartbeat is trusted before its jobs are reaped. */
+	/**
+	 * How old a session's heartbeat may be before its pid is re-checked against the process
+	 * it named.
+	 *
+	 * The heartbeat only ticks while a job runs, so age alone means the session is idle, not
+	 * gone: a quiet session keeps its jobs. The token check is what catches a pid that has
+	 * since been reused by another program.
+	 */
 	sessionTtlMs: number;
 	/** Override for the registry directory; defaults under the agent dir. */
 	registryDir: string | undefined;

package/extensions/job/format.ts

@@ -16,7 +16,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { boundedTail, formatDuration, sanitizeUntrustedLine } from "../../lib/format.ts";
 import { clip, clipLabel, LABEL_WIDTH } from "../../lib/tui/columns.ts";
 import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
-import { byRunningFirst } from "../../lib/tui/rows.ts";
+import { byRunningFirst, statusRow, type StatusRow } from "../../lib/tui/rows.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { JobRecord, JobStatus } from "./types.ts";
 
@@ -74,6 +74,27 @@ export function shortLabel(job: JobRecord): string {
 	return clipLabel(job.label || job.command);
 }
 
+/** One row for the `/jobs` screen and its transcript mirror: selection marker,
+ *  status glyph, id, label, and a right-aligned elapsed value, tagged `peer`
+ *  when another session owns it. `statusRow` owns the clipping and alignment. */
+export function jobRow(
+	job: JobRecord,
+	theme: Theme,
+	width: number,
+	options: Pick<StatusRow, "selected" | "marker"> & { foreign?: boolean } = {},
+): string {
+	const elapsed = formatDuration(elapsedMs(job, Date.now()));
+	return statusRow(theme, width, {
+		...options,
+		glyph: statusGlyphChar(job.status),
+		glyphRole: statusRole(job.status),
+		label: `${job.id}  ${shortLabel(job)}`,
+		labelRole: options.selected ? "accent" : "label",
+		// The tag rides the right-aligned cell, which survives a narrow terminal.
+		trailing: options.foreign ? `${elapsed}${SEPARATORS.item}peer` : elapsed,
+	});
+}
+
 /** One-line job summary shared by the model output and the `/jobs` screen. */
 function jobSummary(job: JobRecord, now: number, ownSessionId?: string): string {
 	const parts = [`${job.id}`, statusWord(job), formatDuration(elapsedMs(job, now))];

package/extensions/job/log-writer.ts

@@ -6,10 +6,14 @@
  * plumbing can be read separately. The writer owns no job state: every path and
  * limit is a callback over the runtime's live config, and a buffered line is
  * handed back through `onLine`.
+ *
+ * The line splitter is a seam rather than an import: `lib/lines.ts` is loaded with
+ * the process seam on the first job, so a session that never starts one never
+ * loads it.
  */
 
 import { createWriteStream, existsSync, renameSync, unlinkSync, type WriteStream } from "node:fs";
-import { LineSplitter } from "../../lib/lines.ts";
+import type { LineSplitter } from "../../lib/lines.ts";
 import type { Job, JobRecord } from "./types.ts";
 
 /** Bytes held while a rotation swaps the log stream before writes resume. */
@@ -36,6 +40,13 @@ export interface LogHandle {
 export interface LogWriterOptions {
 	/** The clock the repaint window is measured on. */
 	now(): number;
+	/**
+	 * A fresh line splitter for one job's stream.
+	 *
+	 * Injected rather than imported: the splitter is the only piece of `lib/lines.ts`
+	 * a writer needs, and a runtime that never starts a job must not load it.
+	 */
+	newSplitter(): LineSplitter;
 	/** The live segment for a job, or undefined when it cannot be used. */
 	logPath(job: JobRecord): string | undefined;
 	/** The rotated segment for a job, or undefined when it cannot be used. */
@@ -163,7 +174,7 @@ export function createLogWriter(options: LogWriterOptions): LogWriter {
 			stream?.on("error", () => {});
 			return {
 				stream,
-				lines: new LineSplitter(),
+				lines: options.newSplitter(),
 				queue: [],
 				queuedBytes: 0,
 				rotating: false,

package/extensions/job/registry.ts

@@ -22,6 +22,7 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { RosterState } from "../../lib/session-roster.ts";
 import { registryPathFor } from "./paths.ts";
 import { JOB_STATUSES, type JobRecord, type JobStatus, type RegistryFile } from "./types.ts";
 
@@ -203,6 +204,59 @@ export function settleGone(record: JobRecord, options: SettleGoneOptions): JobRe
 	return { ...record, status, exitCode: code, finishedAt: options.now };
 }
 
+/** What a load makes of every session's file, before the runtime touches a record. */
+export interface LoadedRecords {
+	/** Every record, merged across the session files and reconciled against liveness. */
+	records: JobRecord[];
+	/** Live, non-detached leftovers for the caller to kill. */
+	orphans: JobRecord[];
+	/** Sessions whose file may be dropped once their records are rewritten here. */
+	deadSessions: Set<string>;
+}
+
+/** The liveness and ownership seams a load reconciles against. */
+export interface LoadSeams {
+	/** This session, which adopts a dead one's records. */
+	sessionId: string;
+	/** What the session that wrote a file is now. */
+	ownerState: (sessionId: string) => RosterState;
+	/** The process seams: whether a pid runs, whether its token still matches, its exit code. */
+	process: {
+		alive: (pid: number) => boolean;
+		owns: (record: JobRecord) => boolean;
+		exitCode: (record: JobRecord) => number | undefined;
+	};
+	now: number;
+}
+
+/** Merge every session's file, recover dead pids, and classify the survivors. */
+export function loadRecords(files: readonly RegistryFile[], seams: LoadSeams): LoadedRecords {
+	const merged = new Map<string, JobRecord>();
+	const deadSessions = new Set<string>();
+	for (const file of files) {
+		if (file.sessionId !== seams.sessionId && seams.ownerState(file.sessionId) === "gone")
+			deadSessions.add(file.sessionId);
+		for (const record of file.jobs) {
+			const existing = merged.get(record.id);
+			merged.set(record.id, existing ? mergeRecords(existing, record, seams.sessionId) : record);
+		}
+	}
+	// Resolve dead pids (recovering exit codes), then classify the survivors.
+	const settled = [...merged.values()].map((record) =>
+		settleGone(record, {
+			isAlive: seams.process.alive,
+			tokenMatches: seams.process.owns,
+			readExitCode: seams.process.exitCode,
+			now: seams.now,
+		}),
+	);
+	const { jobs, orphans } = planReconcile(settled, seams.process.alive, seams.now, {
+		ownerState: seams.ownerState,
+		currentSessionId: seams.sessionId,
+	});
+	return { records: jobs, orphans, deadSessions };
+}
+
 export interface ReconcileResult {
 	/** The records after liveness reconciliation. */
 	jobs: JobRecord[];
@@ -213,10 +267,12 @@ export interface ReconcileResult {
 /** Owner-liveness context for {@link planReconcile}. */
 export interface ReconcileOptions {
 	/**
-	 * Whether the session that started a job is still alive. A live owner means
-	 * another session owns the job, so it is left running rather than reaped.
+	 * What the session that started a job is: `live`, `quiet`, or `gone`.
+	 *
+	 * Only `gone` frees the job to be reaped. A `quiet` owner is an idle one — its
+	 * heartbeat stops while it has nothing running — and its job is still its own.
 	 */
-	isOwnerAlive?: (sessionId: string) => boolean;
+	ownerState?: (sessionId: string) => RosterState;
 	/** The reconciling session; its own leftovers are always reaped. */
 	currentSessionId?: string;
 }
@@ -250,12 +306,12 @@ export function planReconcile(
 			jobs.push(record);
 			continue;
 		}
-		// Another live session still owns this job: keep it running instead of
-		// reaping a peer's work.
+		// Another session still owns this job: keep it running instead of reaping a
+		// peer's work. Its owner is only `gone` when its process is.
 		if (
-			options.isOwnerAlive &&
+			options.ownerState &&
 			record.sessionId !== options.currentSessionId &&
-			options.isOwnerAlive(record.sessionId)
+			options.ownerState(record.sessionId) !== "gone"
 		) {
 			jobs.push(record);
 			continue;

package/extensions/job/render.ts

@@ -0,0 +1,34 @@
+/**
+ * The `JobResult` transcript block: the `job` tool's list-or-log-tail result.
+ *
+ * It maps the job vocabulary onto the shared `TailResult` kit, so the tool's
+ * `renderResult` stays a few lines and every row is drawn by `jobRow` in
+ * `format.ts`. The `/jobs` screen draws the same rows through the same helper,
+ * which is why it lives beside the pure format helpers rather than here: this
+ * module is on the registration path, and the screen is not.
+ */
+
+import type { TailResultInput } from "../../lib/tui/tool.ts";
+import { jobRow } from "./format.ts";
+import type { JobRecord } from "./types.ts";
+
+/** Input for the transcript result: a themed job list or a log tail. */
+export type JobResultInput =
+	| { kind: "list"; jobs: JobRecord[]; more: number; sessionId?: string }
+	| { kind: "logs"; lines: string[]; earlier: number };
+
+/** Map the job vocabulary onto the shared transcript tail block. */
+export function jobTail(input: JobResultInput): TailResultInput<JobRecord> {
+	if (input.kind === "logs") {
+		return { kind: "lines", lines: input.lines, earlier: input.earlier, earlierLabel: "lines" };
+	}
+	return {
+		kind: "list",
+		rows: input.jobs,
+		more: input.more,
+		rowLine: (job, width, theme) => {
+			const foreign = input.sessionId !== undefined && job.sessionId !== input.sessionId;
+			return jobRow(job, theme, width, { marker: false, foreign });
+		},
+	};
+}