@gavin-hu/my-pi-agent 0.9.0 → 0.11.0

package/extensions/job/registry.ts

@@ -66,6 +66,9 @@ function normalizeRecord(record: JobRecord): JobRecord {
 		...record,
 		statusPath: record.statusPath ?? null,
 		startToken: record.startToken ?? null,
+		// A registry written before stdin support has no such flag; such a job was
+		// started without a pipe, and its session is long gone anyway.
+		stdin: record.stdin === true,
 	};
 }
 

package/extensions/job/runtime.ts

@@ -18,11 +18,19 @@
  * twice and listeners/waiters are removed on cleanup.
  */
 
-import { createWriteStream, existsSync, mkdirSync, unlinkSync, writeFileSync, type WriteStream } from "node:fs";
+import {
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	renameSync,
+	unlinkSync,
+	writeFileSync,
+	type WriteStream,
+} from "node:fs";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { resolveEffectiveCwd } from "../../lib/env.ts";
 import { loadConfig, type JobsConfig } from "./config.ts";
-import { clipLabel, formatLogs, sanitizeLogLine } from "./format.ts";
+import { clipLabel, compareJobs, formatLogs, sanitizeLogLine } from "./format.ts";
 import { readLogTail } from "./logs.ts";
 import {
 	defaultKillTree,
@@ -34,6 +42,7 @@ import {
 	type SpawnFn,
 	type SpawnedProcess,
 	type StartTokenFn,
+	type StdinSink,
 } from "./process.ts";
 import {
 	loadRegistries,
@@ -61,6 +70,8 @@ import { createWaiters } from "./waiters.ts";
 const LOG_MODEL_CHARS = 16 * 1024;
 /** Cap on the buffered partial line used to track the latest output. */
 const MAX_PENDING = 16 * 1024;
+/** Bytes held while a rotation swaps the log stream before writes resume. */
+const MAX_ROTATION_QUEUE_BYTES = 2 * 1024 * 1024;
 /** Default `wait` timeout. */
 const DEFAULT_WAIT_MS = 30_000;
 
@@ -70,6 +81,8 @@ export interface StartOptions {
 	label?: string;
 	wake?: boolean;
 	detached?: boolean;
+	/** Give the child a stdin pipe, so `send` can write to it while it runs here. */
+	stdin?: boolean;
 	/** Auto-kill the job after this many milliseconds (SIGTERM, escalating to SIGKILL). */
 	timeoutMs?: number;
 }
@@ -91,6 +104,23 @@ export interface WaitResult {
 	cancelled: boolean;
 }
 
+export interface SendOptions {
+	/** Text written to the job's stdin. */
+	input?: string;
+	/** Append a newline to `input`; defaults to true. */
+	newline?: boolean;
+	/** End the job's stdin after writing, so the child sees EOF. */
+	eof?: boolean;
+}
+
+export interface SendResult {
+	job: Job;
+	/** Characters of `input` written, excluding any newline this call added. */
+	sent: number;
+	/** True when this call ended the job's stdin. */
+	closed: boolean;
+}
+
 export interface RuntimeOptions {
 	spawn?: SpawnFn;
 	liveness?: LivenessFn;
@@ -106,10 +136,26 @@ interface Handle {
 	pending: string;
 	killTimer?: ReturnType<typeof setTimeout>;
 	timeoutTimer?: ReturnType<typeof setTimeout>;
+	/** The child's stdin pipe, present only for a job started with `stdin: true`. */
+	stdin?: StdinSink | null;
+	/** True once stdin was ended, or the child closed its end. */
+	stdinClosed?: boolean;
+	/** Chunks that arrived while the log stream was being swapped. */
+	queue: Buffer[];
+	/** Bytes currently in `queue`. */
+	queuedBytes: number;
+	/** True between ending the old stream and reopening the log. */
+	rotating: boolean;
+	/** Bytes dropped because a rotation could not keep up; reported by `logs`. */
+	droppedBytes: number;
+	/** Bytes written to the live segment, counted exactly as chunks arrive. */
+	logBytes: number;
 }
 
 export interface JobsRuntime {
 	readonly config: JobsConfig;
+	/** This session's id, so a caller can tell its own records from a peer's. */
+	readonly sessionId: string;
 	/** Effective working directory, honoring an active worktree root. */
 	effectiveCwd(ctx: ExtensionContext): string;
 	/** Load and reconcile the registry, then paint the UI. */
@@ -118,6 +164,11 @@ export interface JobsRuntime {
 	list(): JobRecord[];
 	get(id: string): Job | undefined;
 	logs(id: string, lines?: number): LogResult | undefined;
+	/**
+	 * Write to a running job's stdin. Throws a model-readable error when the job is
+	 * gone, was started without `stdin: true`, or belongs to another session.
+	 */
+	send(id: string, options: SendOptions): SendResult;
 	kill(id: string, signal?: KillSignal): Job | undefined;
 	wait(
 		id: string,
@@ -177,6 +228,9 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		try {
 			const path = store.safeLogPath(job);
 			if (path && existsSync(path)) unlinkSync(path);
+			// Both segments are the job's own log; drop the rotated one too.
+			const rotated = store.safeRotatedLogPath(job);
+			if (rotated && existsSync(rotated)) unlinkSync(rotated);
 		} catch {
 			// Log cleanup is best-effort.
 		}
@@ -369,6 +423,21 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		if (!handle) return;
 		if (handle.killTimer) clearTimeout(handle.killTimer);
 		if (handle.timeoutTimer) clearTimeout(handle.timeoutTimer);
+		// A rotation still in flight checks the handle map before reopening, so
+		// dropping the queue here cannot leak a reopened stream for a dead job.
+		handle.queue = [];
+		handle.queuedBytes = 0;
+		// Release the stdin pipe so a child waiting on input sees EOF instead of a
+		// half-open pipe nobody can write to.
+		if (handle.stdin && !handle.stdinClosed) {
+			try {
+				handle.stdin.end();
+			} catch {
+				// Already closed.
+			}
+		}
+		handle.stdin = null;
+		handle.stdinClosed = true;
 		if (options.endStream) {
 			try {
 				handle.stream?.end();
@@ -383,11 +452,7 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		const handle = handles.get(id);
 		const job = jobs.get(id);
 		if (!handle || !job) return;
-		try {
-			handle.stream?.write(chunk);
-		} catch {
-			// A closed stream must not break output handling.
-		}
+		writeChunk(handle, job, chunk);
 		handle.pending += chunk.toString("utf8");
 		if (handle.pending.length > MAX_PENDING) handle.pending = handle.pending.slice(-MAX_PENDING);
 		consume(handle, job);
@@ -398,6 +463,98 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		}
 	};
 
+	const writeLog = (handle: Handle, chunk: Buffer): void => {
+		try {
+			handle.stream?.write(chunk);
+		} catch {
+			// A closed stream must not break output handling.
+		}
+		// Count what we handed the stream: `WriteStream.bytesWritten` only updates on
+		// its completion callback, which can lag a tick behind the file on disk.
+		if (handle.stream) handle.logBytes += chunk.length;
+	};
+
+	/** Buffer a chunk while the log stream is being swapped, dropping the oldest past the cap. */
+	const enqueue = (handle: Handle, chunk: Buffer, front = false): void => {
+		if (front) handle.queue.unshift(chunk);
+		else handle.queue.push(chunk);
+		handle.queuedBytes += chunk.length;
+		while (handle.queuedBytes > MAX_ROTATION_QUEUE_BYTES && handle.queue.length > 1) {
+			const dropped = handle.queue.shift();
+			if (!dropped) break;
+			handle.queuedBytes -= dropped.length;
+			handle.droppedBytes += dropped.length;
+		}
+	};
+
+	/**
+	 * Move the live segment aside, queueing `chunk` ahead of the backlog, and reopen.
+	 *
+	 * Returns false when no rotation can start (no stream, or a record whose log
+	 * paths do not validate), so the caller writes the chunk instead of stranding it
+	 * in a queue nothing will drain.
+	 *
+	 * The old stream is ended and its `close` awaited before the rename, because
+	 * Windows refuses to rename an open file; chunks that arrive in that window
+	 * are queued rather than written, so nothing lands in the renamed inode.
+	 */
+	const rotateLog = (handle: Handle, job: Job, chunk: Buffer): boolean => {
+		const stream = handle.stream;
+		const logPath = store.safeLogPath(job);
+		const rotated = store.safeRotatedLogPath(job);
+		if (!stream || !logPath || !rotated || handle.rotating) return false;
+		// This chunk precedes whatever queued while the previous segment was closing.
+		enqueue(handle, chunk, true);
+		handle.rotating = true;
+		stream.once("close", () => {
+			// A killed or cleared job drops its handle; never reopen for it.
+			if (handles.get(job.id) !== handle) return;
+			try {
+				if (existsSync(rotated)) unlinkSync(rotated);
+				renameSync(logPath, rotated);
+			} catch {
+				// A failed rename leaves the oversized segment in place; keep appending.
+			}
+			const reopened = createWriteStream(logPath, { flags: "a" });
+			reopened.on("error", () => {});
+			handle.stream = reopened;
+			handle.rotating = false;
+			handle.logBytes = 0;
+			drain(handle, job);
+		});
+		try {
+			stream.end();
+		} catch {
+			// Already ended.
+		}
+		return true;
+	};
+
+	/** Write one output chunk, rotating the segment first when it reached the cap. */
+	const writeChunk = (handle: Handle, job: Job, chunk: Buffer): void => {
+		if (handle.rotating) {
+			// Later than everything already queued.
+			enqueue(handle, chunk);
+			return;
+		}
+		const cap = config.maxLogBytes;
+		if (handle.stream && cap > 0 && handle.logBytes >= cap && rotateLog(handle, job, chunk)) return;
+		writeLog(handle, chunk);
+	};
+
+	/**
+	 * Replay the queue through `writeChunk` after a rotation, so a backlog that is
+	 * itself larger than the cap rotates again instead of filling one segment.
+	 */
+	const drain = (handle: Handle, job: Job): void => {
+		while (!handle.rotating && handle.queue.length > 0) {
+			const chunk = handle.queue.shift();
+			if (!chunk) break;
+			handle.queuedBytes -= chunk.length;
+			writeChunk(handle, job, chunk);
+		}
+	};
+
 	const finalize = (id: string, code: number | null, signal: string | null): void => {
 		const handle = handles.get(id);
 		const job = jobs.get(id);
@@ -447,12 +604,16 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		get config() {
 			return config;
 		},
+		get sessionId() {
+			return sessionId;
+		},
 		effectiveCwd,
 		load,
 		start,
-		list: () => ownJobs().map(toRecord),
+		list: () => [...jobs.values()].sort(compareJobs).map(toRecord),
 		get: (id) => jobs.get(id),
 		logs,
+		send,
 		kill,
 		wait,
 		clear,
@@ -555,6 +716,14 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 	function start(startOptions: StartOptions, ctx: ExtensionContext): Job {
 		if (!config.enabled) throw new Error("jobs are disabled.");
 		ui.attach(ctx);
+		const wantsStdin = startOptions.stdin === true;
+		const detached = startOptions.detached ?? config.detachedByDefault;
+		// A detached job outlives this process, so a stdin pipe owned by this session
+		// would hand it EOF the moment the session ends; refuse instead of silently
+		// dropping the pipe (or the detach).
+		if (wantsStdin && detached) {
+			throw new Error("a detached job cannot take stdin; start it with `detached: false`.");
+		}
 		const cwd = startOptions.cwd ? startOptions.cwd : effectiveCwd(ctx);
 		// The registry directory must exist before `nextId`, which reserves the id
 		// with an `O_EXCL` lock file inside it.
@@ -564,7 +733,6 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		const id = store.nextId(jobs.keys());
 		const logPath = store.logPath(id);
 		const statusPath = process.platform === "win32" ? null : store.statusPath(id);
-		const detached = startOptions.detached ?? config.detachedByDefault;
 		// A detached POSIX job points its own output at the log, so it keeps logging
 		// and survives after this process ends; Windows keeps the parent pipe.
 		const detachOutput = detached && process.platform !== "win32";
@@ -577,7 +745,7 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		if (detachOutput) env[LOG_ENV] = logPath;
 		let process_: SpawnedProcess;
 		try {
-			process_ = spawn(program, { cwd, env, detachOutput });
+			process_ = spawn(program, { cwd, env, detachOutput, stdin: wantsStdin });
 		} catch (error) {
 			// A failed spawn must not leave the reserved id behind.
 			store.releaseId(id);
@@ -612,6 +780,7 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 			statusPath,
 			detached,
 			wake: startOptions.wake ?? config.wakeOnFinish,
+			stdin: wantsStdin,
 			sessionId,
 			seen: false,
 			lastLine: "",
@@ -619,7 +788,28 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 			owned: true,
 		};
 
-		const handle: Handle = { stream, pending: "" };
+		const handle: Handle = {
+			stream,
+			pending: "",
+			queue: [],
+			queuedBytes: 0,
+			rotating: false,
+			droppedBytes: 0,
+			logBytes: 0,
+		};
+		if (wantsStdin) {
+			const sink = process_.stdin ?? null;
+			handle.stdin = sink;
+			handle.stdinClosed = sink === null;
+			// A child that exits can emit `error`/`close` on the pipe; record it so a
+			// later `send` reports the truth instead of throwing an unhandled stream error.
+			const markClosed = (): void => {
+				const current = handles.get(id);
+				if (current) current.stdinClosed = true;
+			};
+			sink?.on("error", markClosed);
+			sink?.on("close", markClosed);
+		}
 		handles.set(id, handle);
 		jobs.set(id, job);
 
@@ -643,16 +833,33 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 	function logs(id: string, lines = config.maxLogLines): LogResult | undefined {
 		const job = jobs.get(id);
 		if (!job) return undefined;
-		const tail = readLogTail(store.safeLogPath(job), lines);
-		const last = tail.lines.at(-1);
+		const current = readLogTail(store.safeLogPath(job), lines);
+		let all = current.lines;
+		let more = current.more;
+		let truncated = current.truncated;
+		// Keep `logs` continuous across a rotation: fill the request from the
+		// previous segment when the live one holds fewer lines.
+		if (all.length < lines) {
+			const previous = readLogTail(store.safeRotatedLogPath(job), lines - all.length);
+			if (previous.lines.length > 0) {
+				all = [...previous.lines, ...all];
+				more = more || previous.more;
+				truncated = truncated || previous.truncated;
+			}
+		}
+		const last = all.at(-1);
 		if (last) job.lastLine = last;
-		const formatted = formatLogs(job, tail.lines, LOG_MODEL_CHARS);
+		const formatted = formatLogs(job, all, LOG_MODEL_CHARS);
+		// A rotation that outran its drain drops the oldest queued chunks; say so once
+		// rather than letting the gap look like a program that skipped output.
+		const dropped = handles.get(id)?.droppedBytes ?? 0;
+		const text = dropped > 0 ? `${formatted.text}\n… ${dropped} bytes dropped while the log rotated.` : formatted.text;
 		return {
 			job,
-			text: formatted.text,
-			lines: tail.lines,
-			truncated: formatted.truncated || tail.truncated,
-			more: tail.more,
+			text,
+			lines: all,
+			truncated: formatted.truncated || truncated,
+			more,
 		};
 	}
 
@@ -725,6 +932,34 @@ export function createJobsRuntime(options: RuntimeOptions = {}): JobsRuntime {
 		return job;
 	}
 
+	function send(id: string, options: SendOptions): SendResult {
+		const job = jobs.get(id);
+		if (!job) throw new Error(`no job "${id}".`);
+		if (job.status !== "running") throw new Error(`job ${id} is ${job.status}; stdin is closed.`);
+		if (!job.stdin) throw new Error(`job ${id} was not started with stdin; restart it with \`stdin: true\`.`);
+		const handle = handles.get(id);
+		// A pipe this session opened but that is closed is a different fact from one
+		// that was never ours, so state it first.
+		if (handle?.stdinClosed) throw new Error(`job ${id} closed its stdin.`);
+		if (!handle?.stdin) throw new Error(`job ${id}'s stdin belongs to the session that started it.`);
+
+		const input = options.input ?? "";
+		const payload = input && options.newline !== false ? `${input}\n` : input;
+		try {
+			if (payload) handle.stdin.write(payload);
+			if (options.eof) {
+				handle.stdin.end();
+				handle.stdinClosed = true;
+			}
+		} catch {
+			// The child closed its end; record it so the next `send` says so.
+			handle.stdinClosed = true;
+			handle.stdin = null;
+			throw new Error(`job ${id} closed its stdin.`);
+		}
+		return { job, sent: input.length, closed: options.eof === true };
+	}
+
 	function wait(
 		id: string,
 		timeoutMs: number | undefined,

package/extensions/job/schema.ts

@@ -14,6 +14,8 @@ import { JOB_ACTIONS, KILL_SIGNALS, type JobAction, type KillSignal } from "./ty
 export const MAX_COMMAND = 4000;
 /** Longest accepted label. */
 export const MAX_LABEL = 120;
+/** Longest accepted `send.input`, in characters. */
+export const MAX_STDIN = 8192;
 /** Bounds for `logs.lines`. */
 const MIN_LOG_LINES = 1;
 const MAX_LOG_LINES = 2000;
@@ -31,10 +33,20 @@ export const JobParams = Type.Object({
 	label: Type.Optional(Type.String({ description: "Short display label; defaults to the command." })),
 	wake: Type.Optional(Type.Boolean({ description: "Wake the agent with one triggered turn when the job finishes." })),
 	detached: Type.Optional(Type.Boolean({ description: "Leave the job running when the session ends." })),
+	stdin: Type.Optional(
+		Type.Boolean({
+			description: "Give the job a stdin pipe so `send` can write to it (for `start`); not with `detached`.",
+		}),
+	),
 	id: Type.Optional(Type.String({ description: "Job id, e.g. `j1`." })),
 	lines: Type.Optional(
 		Type.Integer({ minimum: MIN_LOG_LINES, maximum: MAX_LOG_LINES, description: "Log lines to return." }),
 	),
+	input: Type.Optional(
+		Type.String({ description: `Text to write to a running job's stdin (for \`send\`; max ${MAX_STDIN} characters).` }),
+	),
+	newline: Type.Optional(Type.Boolean({ description: "Append a newline to `input` (for `send`; default true)." })),
+	eof: Type.Optional(Type.Boolean({ description: "End the job's stdin after writing, so it sees EOF (for `send`)." })),
 	signal: Type.Optional(StringEnum(KILL_SIGNALS, { description: "Signal for `kill`; defaults to SIGTERM." })),
 	timeoutMs: Type.Optional(
 		Type.Integer({
@@ -64,11 +76,13 @@ export type JobCall =
 			label?: string;
 			wake?: boolean;
 			detached?: boolean;
+			stdin?: boolean;
 			timeoutMs?: number;
 	  }
 	| { action: "list" }
 	| { action: "status"; id: string }
 	| { action: "logs"; id: string; lines?: number }
+	| { action: "send"; id: string; input?: string; newline?: boolean; eof?: boolean }
 	| { action: "kill"; id: string; signal?: KillSignal }
 	| { action: "wait"; id: string; timeoutMs?: number }
 	| { action: "clear"; id?: string; all?: boolean };
@@ -110,6 +124,7 @@ export function normalizeCall(raw: unknown): JobCall {
 				...(cwd ? { cwd } : {}),
 				...(typeof args.wake === "boolean" ? { wake: args.wake } : {}),
 				...(typeof args.detached === "boolean" ? { detached: args.detached } : {}),
+				...(typeof args.stdin === "boolean" ? { stdin: args.stdin } : {}),
 				...(timeoutMs !== undefined ? { timeoutMs } : {}),
 			};
 		}
@@ -124,6 +139,25 @@ export function normalizeCall(raw: unknown): JobCall {
 			}
 			return { action: "logs", id: requireId(), ...(lines !== undefined ? { lines } : {}) };
 		}
+		case "send": {
+			const jobId = requireId();
+			if (args.input !== undefined && typeof args.input !== "string") {
+				throw new Error('"send" input must be a string.');
+			}
+			const input = typeof args.input === "string" ? args.input : undefined;
+			if (input !== undefined && input.length > MAX_STDIN) {
+				throw new Error(`input is longer than ${MAX_STDIN} characters.`);
+			}
+			const eof = args.eof === true;
+			if (!input && !eof) throw new Error('"send" requires `input` or `eof: true`.');
+			return {
+				action: "send",
+				id: jobId,
+				...(input ? { input } : {}),
+				...(typeof args.newline === "boolean" ? { newline: args.newline } : {}),
+				...(eof ? { eof } : {}),
+			};
+		}
 		case "kill": {
 			const signal = args.signal;
 			if (signal !== undefined && !(KILL_SIGNALS as readonly string[]).includes(signal)) {

package/extensions/job/store.ts

@@ -11,7 +11,7 @@
  * is otherwise running fine.
  */
 
-import { join, resolve } from "node:path";
+import { join, resolve, sep } from "node:path";
 import { REGISTRY_VERSION, loadRegistries, registryDirFor, saveRegistry } from "./registry.ts";
 import { listReservedIds, pruneReservations, releaseReservation, reserveId } from "./reservations.ts";
 import { statusPathFor } from "./paths.ts";
@@ -38,6 +38,10 @@ export interface JobStore {
 	logPath(id: string): string;
 	/** The log path only when it is exactly this job's file in the directory. */
 	safeLogPath(job: JobRecord): string | undefined;
+	/** Absolute path of the segment a rotation moved the previous log to. */
+	rotatedLogPath(id: string): string;
+	/** The rotated path only when it stays inside the directory. */
+	safeRotatedLogPath(job: JobRecord): string | undefined;
 	/** Absolute status path for a job id in the current directory. */
 	statusPath(id: string): string;
 	/** The status path only when it is exactly this job's file in the directory. */
@@ -84,6 +88,14 @@ export function createJobStore(initialDir = registryDirFor(process.cwd())): JobS
 		},
 		logPath: (id) => join(dir, `${id}.log`),
 		safeLogPath: (job) => safeArtifact(job.logPath, join(dir, `${job.id}.log`)),
+		rotatedLogPath: (id) => join(dir, `${id}.log.1`),
+		// No record field names this file, so the id is the only input: refuse an id
+		// that would resolve outside the registry directory.
+		safeRotatedLogPath: (job) => {
+			const root = resolve(dir);
+			const target = resolve(root, `${job.id}.log.1`);
+			return target.startsWith(`${root}${sep}`) ? target : undefined;
+		},
 		statusPath: (id) => statusPathFor(dir, id),
 		safeStatusPath: (job) => safeArtifact(job.statusPath ?? undefined, join(dir, `${job.id}.status`)),
 	};

package/extensions/job/tools.ts

@@ -1,15 +1,17 @@
 /**
  * Model-facing registration for the `job` tool.
  *
- * One tool with seven actions: `start`, `list`, `status`, `logs`, `kill`,
- * `wait`, `clear`. A background process can outlive the tool call, so `start`
- * returns immediately with an id; the model polls with `status`/`logs` or
- * blocks with `wait`. Failures come back as an error result.
+ * One tool with eight actions: `start`, `list`, `status`, `logs`, `send`,
+ * `kill`, `wait`, `clear`. A background process can outlive the tool call, so
+ * `start` returns immediately with an id; the model polls with `status`/`logs` or
+ * blocks with `wait`. `stdin: true` opens a pipe that `send` writes to. Failures
+ * come back as an error result.
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { sanitizeLine } from "../../lib/format.ts";
 import { reuseText, toolDetails } from "../../lib/tui/chrome.ts";
+import { SEPARATORS } from "../../lib/tui/glyphs.ts";
 import { paint } from "../../lib/tui/tokens.ts";
 import {
 	compareJobs,
@@ -18,6 +20,7 @@ import {
 	formatJobList,
 	formatJobOutcomeLine,
 	formatJobStatus,
+	shortLabel,
 } from "./format.ts";
 import type { JobsRuntime } from "./runtime.ts";
 import { JobParams, normalizeCall, type JobArgs, type JobCall } from "./schema.ts";
@@ -48,6 +51,7 @@ function errorResult(
 const GUIDELINES = [
 	"Use `job start` for long-running or background commands (builds, test suites, servers, watchers) so the turn is not blocked.",
 	"Poll with `job status`/`job logs`, or use `job wait` when you must have the result before continuing.",
+	"Start a job with `stdin: true` to drive an interactive program: `job send` writes a line to it and `eof: true` closes its input.",
 	"Use `job kill` to stop a running job and `job clear` to drop finished ones.",
 ];
 
@@ -56,9 +60,9 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 		name: TOOL_NAME,
 		label: "Job",
 		description:
-			"Manage background shell-command jobs. Actions: `start` (returns a job id immediately), `list`, `status`/`logs`/" +
-			"`kill`/`wait` (by id), and `clear`. Jobs are killed when the session ends unless started `detached`.",
-		promptSnippet: "Run and manage background shell-command jobs (start, list, status, logs, kill, wait, clear).",
+			"Manage background shell-command jobs. Actions: `start` (returns a job id immediately; `stdin: true` opens a stdin pipe), " +
+			"`list`, `status`/`logs`/`send`/`kill`/`wait` (by id), and `clear`. Jobs are killed when the session ends unless started `detached`.",
+		promptSnippet: "Run and manage background shell-command jobs (start, list, status, logs, send, kill, wait, clear).",
 		promptGuidelines: GUIDELINES,
 		parameters: JobParams,
 		annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true },
@@ -82,6 +86,7 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 								label: call.label,
 								wake: call.wake,
 								detached: call.detached,
+								stdin: call.stdin,
 								timeoutMs: call.timeoutMs,
 							},
 							ctx,
@@ -100,8 +105,8 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 					case "list": {
 						const jobs = runtime.list();
 						return {
-							content: [{ type: "text" as const, text: formatJobList(jobs) }],
-							details: { action: "list", jobs } satisfies JobDetails,
+							content: [{ type: "text" as const, text: formatJobList(jobs, Date.now(), runtime.sessionId) }],
+							details: { action: "list", jobs, sessionId: runtime.sessionId } satisfies JobDetails,
 						};
 					}
 
@@ -109,8 +114,8 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 						const job = runtime.get(call.id);
 						if (!job) return errorResult("status", `no job "${call.id}".`);
 						return {
-							content: [{ type: "text" as const, text: formatJobStatus(job) }],
-							details: { action: "status", job: toRecord(job) } satisfies JobDetails,
+							content: [{ type: "text" as const, text: formatJobStatus(job, Date.now(), runtime.sessionId) }],
+							details: { action: "status", job: toRecord(job), sessionId: runtime.sessionId } satisfies JobDetails,
 						};
 					}
 
@@ -128,6 +133,30 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 						};
 					}
 
+					case "send": {
+						const result = runtime.send(call.id, {
+							input: call.input,
+							newline: call.newline,
+							eof: call.eof,
+						});
+						const job = result.job;
+						const text =
+							result.sent > 0
+								? `Sent ${result.sent} character${result.sent === 1 ? "" : "s"} to ${job.id} (${shortLabel(job)})${
+										result.closed ? " and closed its stdin" : ""
+									}.`
+								: `Closed ${job.id}'s stdin.`;
+						return {
+							content: [{ type: "text" as const, text }],
+							details: {
+								action: "send",
+								job: toRecord(job),
+								sent: result.sent,
+								stdinClosed: result.closed,
+							} satisfies JobDetails,
+						};
+					}
+
 					case "kill": {
 						const before = runtime.get(call.id);
 						if (!before) return errorResult("kill", `no job "${call.id}".`);
@@ -209,8 +238,9 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 			const text = reuseText(context.lastComponent);
 			text.setText(
 				theme.fg("toolTitle", theme.bold(`${TOOL_NAME} `)) +
-					theme.fg(
-						"muted",
+					paint(
+						theme,
+						"meta",
 						sanitizeLine(formatCallText(action, args as Record<string, unknown>, context.argsComplete)),
 					),
 			);
@@ -256,7 +286,12 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 				}
 				const ordered = [...details.jobs].sort(compareJobs);
 				const shown = options.expanded ? ordered : ordered.slice(0, RESULT_ROWS);
-				const input: JobResultInput = { kind: "list", jobs: shown, more: ordered.length - shown.length };
+				const input: JobResultInput = {
+					kind: "list",
+					jobs: shown,
+					more: ordered.length - shown.length,
+					sessionId: details.sessionId,
+				};
 				const view = context.lastComponent instanceof JobResult ? context.lastComponent : new JobResult(input, theme);
 				view.setInput(input, theme);
 				return view;
@@ -278,11 +313,16 @@ export function registerTools(pi: ExtensionAPI, runtime: JobsRuntime): void {
 					line += paint(theme, "warn", " · wait cancelled; job still running");
 				} else if (details.action === "kill" && details.signalled) {
 					line += paint(theme, "warn", ` · ${details.signal ?? "SIGTERM"} sent`);
+				} else if (details.action === "send") {
+					const badges: string[] = [];
+					if (details.sent) badges.push(`sent ${details.sent}`);
+					if (details.stdinClosed) badges.push("stdin closed");
+					if (badges.length > 0) line += paint(theme, "faint", `${SEPARATORS.item}${badges.join(SEPARATORS.item)}`);
 				} else if (details.action === "start") {
 					const badges: string[] = [];
 					if (details.job.detached) badges.push("detached");
 					if (details.job.wake) badges.push("wake");
-					if (badges.length > 0) line += paint(theme, "faint", ` · ${badges.join(" · ")}`);
+					if (badges.length > 0) line += paint(theme, "faint", `${SEPARATORS.item}${badges.join(SEPARATORS.item)}`);
 				}
 				text.setText(line);
 				return text;