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

package/extensions/job/README.md

@@ -22,9 +22,17 @@ How the `job` call and its result look in the transcript — the call line as a
 ## What it does
 
 - Registers one model-callable tool, `job`, with actions `start`, `list`,
-  `status`, `logs`, `kill`, `wait`, and `clear`.
+  `status`, `logs`, `send`, `kill`, `wait`, and `clear`.
+- Shows this session's jobs, and — tagged `peer` — a live peer session's, so two
+  Pi sessions on one repo can see each other's builds; the peer's rows are
+  read-only on the screen.
 - Runs each command in its own process group, streaming stdout and stderr to an
-  append-only log file under `~/.pi/agent/jobs/<project>/`.
+  append-only log file under `~/.pi/agent/jobs/<project>/`. A segment rotates
+  to `<id>.log.1` at `maxLogBytes` (8 MiB by default), so a chatty job cannot
+  fill the disk, and `logs` reads across the boundary.
+- Feeds a running job input when it was started with `stdin: true`: `send`
+  writes a line (or a bare keystroke) to its stdin, and `eof: true` closes it, so
+  a REPL, a debugger prompt, or a `read` can be driven without a TTY.
 - Shows a `▸ N` running status chip and a separate `✗ N` unreported-failure
   chip for this session's jobs, plus a `/jobs` screen for selecting, tailing,
   killing, and clearing.
@@ -40,14 +48,18 @@ How the `job` call and its result look in the transcript — the call line as a
 | Field | Value |
 |---|---|
 | `name` | `job` |
-| `action` | `start` \| `list` \| `status` \| `logs` \| `kill` \| `wait` \| `clear` |
+| `action` | `start` \| `list` \| `status` \| `logs` \| `send` \| `kill` \| `wait` \| `clear` |
 | `command` | Shell command to run (`start`). |
 | `cwd` | Working directory (`start`); defaults to the session cwd. |
 | `label` | Short display label (`start`); defaults to the command. |
 | `wake` | Wake the agent with one triggered turn when it finishes (`start`). |
 | `detached` | Leave it running when the session ends (`start`). |
-| `id` | Job id such as `j1` (`status`/`logs`/`kill`/`wait`/`clear`). |
+| `stdin` | Give the job a stdin pipe so `send` can write to it (`start`); not with `detached`. |
+| `id` | Job id such as `j1` (`status`/`logs`/`send`/`kill`/`wait`/`clear`). |
 | `lines` | Log lines to return (`logs`, 1–2000). |
+| `input` | Text to write to a running job's stdin (`send`; max 8192 characters). |
+| `newline` | Append a newline to `input` (`send`; default `true`). |
+| `eof` | End the job's stdin after writing, so it sees EOF (`send`). |
 | `signal` | `SIGTERM` \| `SIGKILL` \| `SIGINT` (`kill`; default `SIGTERM`). |
 | `timeoutMs` | `start`: kill the job after this many ms. `wait`: how long to block (default 30s). |
 | `all` | With `clear`, also remove running jobs. |
@@ -68,20 +80,38 @@ leaves the job running. Validation is pure and runs before any side effect, so
 `codemode` callers that bypass the TypeBox schema cannot start a process with
 missing arguments.
 
+Example: drive an interactive program. Only a job started with `stdin: true`
+accepts input, and `eof` closes it once you are done.
+
+```
+job start { "command": "python3 -q", "stdin": true, "label": "repl" }   → j2
+job send  { "id": "j2", "input": "print(1 + 1)" }
+job logs  { "id": "j2" }
+job send  { "id": "j2", "eof": true }
+```
+
+`send` writes `input` plus a newline by default, so a line-oriented program
+sees one line per call; pass `newline: false` to deliver a bare keystroke.
+Writing to a finished job, a job without `stdin: true`, or a job this session
+does not hold the pipe for is an error, and the call changes nothing.
+
 Each result carries a `JobDetails` object in tool-result `details`:
 
 ```
 JobDetails {
   action: JobAction
-  job?: JobRecord           // start/status/logs/kill/wait
+  job?: JobRecord           // start/status/logs/send/kill/wait
   jobs?: JobRecord[]        // list/clear
   logs?: string             // sanitized tail for `logs`
   truncated?: boolean
   cleared?: number
   signalled?: boolean       // kill sent a signal to a running job
   signal?: KillSignal       // signal sent by kill (SIGTERM/SIGKILL/SIGINT)
+  sent?: number             // characters of `input` written by send
+  stdinClosed?: boolean     // send ended the job's stdin (EOF)
   timedOut?: boolean        // wait hit its timeout
   cancelled?: boolean       // wait was aborted; job still running
+  sessionId?: string        // list/status: who made the call, for tagging peers
   error?: string
 }
 ```
@@ -93,7 +123,8 @@ the slot's component: `list` draws the same rows as `/jobs`, `logs` draws a
 blank line and the sanitized tail, and a single-job action draws one outcome
 line. A `kill` that sent a signal appends it (`· SIGTERM sent`) instead of
 showing the job's pre-kill running state, a `start` badges `detached` and
-`wake`, and a `logs` call on a job with no output yet renders `No output yet.`
+`wake`, a `send` appends what it did (`· sent 5 · stdin closed`), and a `logs`
+call on a job with no output yet renders `No output yet.`
 
 ```
 job list
@@ -116,23 +147,29 @@ job status j1
 ### Command: `/jobs`
 
 `/jobs` opens an interactive list in the TUI, and prints a text summary
-elsewhere. The list is **session-scoped**: it shows the jobs this session
-started, plus a dead session's records adopted into it, not a live peer's. On
+elsewhere. The list shows the jobs this session started, a dead session's
+records adopted into it, and a live peer session's jobs tagged `peer`. On
 the screen: `↑`/`↓` or `j`/`k` select, `PgUp`/`PgDn` page, `Home`/`End` jump,
 `Enter`/`l` opens the log pane, `d` (or `K`) kills the selected running job,
 `x` clears finished jobs, `Esc`/`q` closes. `d` and `x` ask for a `y`/`N`
 confirmation before acting, so a stray key cannot kill a build; when `x` would
 drop an unreported result, the prompt says how many. A `d` on a finished job (or
-an `x` with nothing finished) says so instead of doing nothing. In the log pane,
+an `x` with nothing finished) says so instead of doing nothing. Another
+session's row opens its log but is otherwise left alone: `d` answers
+`j9 is another session's job; not killed.`, and `x` counts and clears only this
+session's finished jobs. In the log pane,
 `↑`/`↓`, `PgUp`/`PgDn`, `Home`/`End`, and `g`/`G` scroll; the view follows the
 tail until you scroll up, and `Esc`/`Backspace`/`q` returns to the list. The
 pane's subheader names the job's log file, notes when only a bounded tail is
 loaded, and shows whether the view is `following` the tail or `paused`.
 
-The screen shows a counts summary (`N jobs · R running · F failed`), running
-jobs first then recent finished jobs, and a focused detail pane (command, cwd,
-outcome, and the last output line). Selection is tracked by job id, so the live
-re-sort cannot move the cursor or switch the open log out from under the user.
+The screen shows a counts summary (`N jobs · R running · F failed · P peer`) over
+the rows it shows, so it includes a peer's running job even though the footer
+chips count only this session's. Running jobs come first, then recent finished
+ones, and a focused detail pane follows (command, cwd, outcome, the owner when
+it is another session, and the last output line). Selection is tracked by job
+id, so the live re-sort cannot move the cursor or switch the open log out from
+under the user.
 Any dock screen (`/todos`, `/jobs`, `/rewind`, or the
 `question` questionnaire) hides the above-editor goal/todo rails for its
 lifetime and restores them on close.
@@ -156,6 +193,7 @@ document, project wins):
 | `detachedByDefault` | `false` | Leave jobs running when the session ends. |
 | `maxJobs` | `20` | Finished jobs kept before the oldest are pruned. |
 | `maxLogLines` | `100` | Log lines returned by `logs`. |
+| `maxLogBytes` | `8388608` | Bytes a log segment may reach before it rotates to `<id>.log.1`; `0` keeps logs unbounded. |
 | `killGraceMs` | `5000` | Grace before SIGTERM escalates to SIGKILL. |
 | `repaintMs` | `1000` | Status-chip refresh interval while jobs run. |
 | `sessionTtlMs` | `60000` | How long a session heartbeat is trusted before its jobs may be reaped. |
@@ -177,14 +215,26 @@ rewritten.
   reattached after its session died reports its real exit code. `exec cmd`
   replaces the shell and bypasses the trap, and Windows has no equivalent, so
   those jobs settle as `unknown`.
-- **A live peer session's jobs are hidden.** Records are still merged from
-  every session file so ids stay unique and a peer's job is not reaped, but
-  `list` and `/jobs` show only this session's jobs (a dead session's records
-  are adopted into it). A peer's job can still be reached by an explicit id
-  (`status`/`logs`/`kill`; `kill` adopts it).
-- **No stdin to running jobs.** Jobs are fire-and-observe; interactive programs
-  (a REPL, a debugger prompt) are out of scope.
-- **No log rotation.** Logs are append-only files; `logs` reads a bounded tail.
+- **Another session's jobs are shown, but not managed here.** Records are merged
+  from every session file so ids stay unique and a peer's job is not reaped, and
+  `list`/`/jobs` show them tagged `peer` (a dead session's records are adopted
+  into this one and lose the tag). The screen opens a peer's log but refuses to
+  kill or clear it, and the tool's `clear` refuses that record too; the tool can
+  still take one over by explicit id (`status`/`logs`/`kill`, where `kill`
+  adopts it). Chips, completion notices, and pruning stay this session's own, so
+  a peer's finished job waits for that session to clear it.
+- **stdin is a pipe, not a TTY.** A job started with `stdin: true` can be fed
+  with `send`, but the child sees a pipe: line-oriented programs (a REPL, a
+  debugger prompt, `read`, `npm init`) work, while a full-screen program that
+  requires a terminal does not. Only the session holding the child's pipe can
+  write to it, so a reattached or peer job cannot be fed, and a `detached` job
+  cannot take stdin at all.
+- **A detached job's log is not rotated.** A POSIX `detached` job points its
+  own stdout at the log file (`exec >> …`), so the file has a writer this
+  process does not own and cannot safely rename or truncate: the child would
+  keep appending to the moved inode, or lose everything. Its log therefore grows
+  without the `maxLogBytes` cap; `logs` still reads a bounded tail, and the file
+  can be emptied by hand.
 - **Windows is best-effort.** Tree-kill uses `taskkill /T`; POSIX uses process
   groups. A detached job only escapes the parent process on POSIX, where its
   shell writes the log directly; on Windows it keeps the parent pipe and is
@@ -212,9 +262,26 @@ rewritten.
 
 ## Design notes
 
+- **Visibility is not ownership.** `list` shows every record in the merged
+  table, but each mutation keeps its own rule: the screen refuses a `peer` row,
+  `clear` refuses another session's record, `kill` adopts it deliberately, and
+  `send` has no pipe to reach it. The chips, completion notices, and pruning
+  stay own-only, so showing a peer never makes this session responsible for it.
 - **Shell commands only, one action-based tool.** A single `job` tool with
-  seven actions mirrors `rewind` and keeps the model surface small. Validation
+  eight actions mirrors `rewind` and keeps the model surface small. Validation
   is pure and runs before any side effect.
+- **The log rotates under the stream, not behind its back.** A parent-owned log
+  is a `WriteStream`; when the live segment reaches `maxLogBytes` the stream is
+  ended, the file renamed to `<id>.log.1`, and a fresh stream opened, with
+  chunks that arrive during the swap queued (and bounded) rather than written
+  into the renamed inode. `logs` fills a request from the previous segment when
+  the live one is shorter, so the rotation is invisible to the model and to the
+  `/jobs` pane. A detached job writes its own log and is exempt.
+- **Stdin is an opt-in pipe.** `start` keeps the child's stdin closed by
+  default, so it gets EOF immediately and a `read` exits instead of blocking;
+  `stdin: true` swaps in a pipe that `send` writes to and `eof` closes. The pipe
+  belongs to this process, so it never outlives the handle that owns it, and a
+  `detached` job is refused rather than handed EOF when the session ends.
 - **`child_process.spawn`, not `pi.exec`.** `pi.exec` resolves on exit, the
   opposite of a background job. Jobs are spawned with a shell in their own
   process group, and signals go to the whole group so a shell and its
@@ -313,6 +380,8 @@ sanitization (`format`), the durable store (`store`), per-session reconciliation
 (`registry`), id reservation (`reservations`), exit-status recovery (`status`),
 session markers (`session`), bounded log reads and tail flags (`logs`), wait
 bookkeeping (`waiters`), the `job` tool (`tools`), the `/jobs` screen (`tui`),
-the runtime's session-scoped list and failure notification (`runtime`), and the
+the runtime's session-scoped list and failure notification (`runtime`), `send`
+to a job's stdin and the pipe's lifecycle (`runtime`), log rotation, its two
+segments, and the cross-segment read (`runtime`), and the
 install/resume/shutdown lifecycle (`extension`). Tests drive a scripted
 `FakeChild` and a temp registry, so the suite runs without launching a process.

package/extensions/job/commands.ts

@@ -37,6 +37,7 @@ export function registerCommands(pi: ExtensionAPI, runtime: JobsRuntime): void {
 							() => runtime.list(),
 							theme,
 							{
+								sessionId: () => runtime.sessionId,
 								logs: (id) => runtime.logs(id, 200),
 								kill: (id) => {
 									runtime.kill(id);

package/extensions/job/config.ts

@@ -21,6 +21,8 @@ export interface JobsConfig {
 	maxJobs: number;
 	/** Log lines returned to the model by the `logs` action. */
 	maxLogLines: number;
+	/** Bytes a log segment may reach before it rotates; 0 keeps logs unbounded. */
+	maxLogBytes: number;
 	/** Grace period before a SIGTERM escalates to SIGKILL. */
 	killGraceMs: number;
 	/** Status-chip refresh interval while jobs run. */
@@ -38,6 +40,7 @@ export const DEFAULT_CONFIG: JobsConfig = {
 	detachedByDefault: false,
 	maxJobs: 20,
 	maxLogLines: 100,
+	maxLogBytes: 8 * 1024 * 1024,
 	killGraceMs: 5000,
 	repaintMs: 1000,
 	sessionTtlMs: 60_000,
@@ -55,6 +58,7 @@ export function normalizeConfig(raw: Record<string, unknown> | undefined, base:
 		detachedByDefault: typeof raw.detachedByDefault === "boolean" ? raw.detachedByDefault : base.detachedByDefault,
 		maxJobs: clampInteger(raw.maxJobs, base.maxJobs, 1, 500),
 		maxLogLines: clampInteger(raw.maxLogLines, base.maxLogLines, 1, 5000),
+		maxLogBytes: clampInteger(raw.maxLogBytes, base.maxLogBytes, 0, 1024 * 1024 * 1024),
 		killGraceMs: clampInteger(raw.killGraceMs, base.killGraceMs, 0, 60_000),
 		repaintMs: clampInteger(raw.repaintMs, base.repaintMs, 100, 10_000),
 		sessionTtlMs: clampInteger(raw.sessionTtlMs, base.sessionTtlMs, 5_000, 600_000),

package/extensions/job/format.ts

@@ -131,22 +131,25 @@ export function shortLabel(job: JobRecord): string {
 }
 
 /** One-line job summary shared by the model output and the `/jobs` screen. */
-function jobSummary(job: JobRecord, now: number): string {
+function jobSummary(job: JobRecord, now: number, ownSessionId?: string): string {
 	const parts = [`${job.id}`, statusWord(job), formatDuration(elapsedMs(job, now))];
 	if (job.status === "running" && job.pid) parts.push(`pid ${job.pid}`);
 	parts.push(shortLabel(job));
+	// A peer session's job is shown but belongs to it: name the owner so the
+	// `clear` refusal reads as intent rather than a bug.
+	if (ownSessionId !== undefined && job.sessionId !== ownSessionId) parts.push("(another session)");
 	return parts.join("  ");
 }
 
 /** Model-facing list of jobs, or a note when there are none. */
-export function formatJobList(jobs: JobRecord[], now = Date.now()): string {
+export function formatJobList(jobs: JobRecord[], now = Date.now(), ownSessionId?: string): string {
 	if (jobs.length === 0) return "No jobs.";
-	const lines = jobs.map((job) => `  ${jobSummary(job, now)}`);
+	const lines = jobs.map((job) => `  ${jobSummary(job, now, ownSessionId)}`);
 	return `Jobs (${jobs.length}):\n${lines.join("\n")}`;
 }
 
 /** Model-facing detail for one job, including its last output line. */
-export function formatJobStatus(job: JobRecord, now = Date.now()): string {
+export function formatJobStatus(job: JobRecord, now = Date.now(), ownSessionId?: string): string {
 	const lines = [
 		`${job.id}: ${statusWord(job)}`,
 		`command: ${sanitizeLogLine(job.command)}`,
@@ -155,6 +158,7 @@ export function formatJobStatus(job: JobRecord, now = Date.now()): string {
 	];
 	if (job.pid) lines.push(`pid: ${job.pid}`);
 	if (job.logPath) lines.push(`log: ${sanitizeLogLine(job.logPath)}`);
+	if (ownSessionId !== undefined && job.sessionId !== ownSessionId) lines.push("session: another session");
 	if (job.lastLine) lines.push(`last: ${job.lastLine}`);
 	return lines.join("\n");
 }
@@ -192,6 +196,13 @@ export function formatCallText(action: string, args: Record<string, unknown>, ar
 		}
 		case "kill":
 			return `kill ${target ?? ""}`.trim();
+		case "send": {
+			if (!target) return "send";
+			const input = typeof args.input === "string" ? sanitizeLogLine(args.input) : "";
+			const preview = input ? truncateToWidth(input, MAX_DISPLAY_LABEL, "…") : "";
+			const parts = [preview, args.eof === true ? "EOF" : ""].filter(Boolean).join(" + ");
+			return parts ? `send ${target} → ${parts}` : `send ${target}`;
+		}
 		case "logs":
 		case "status":
 		case "wait":
@@ -268,11 +279,12 @@ export function formatJobOutcomeLine(job: JobRecord, theme: Theme, now = Date.no
 }
 
 /** Unstyled, sanitized detail lines for the `/jobs` focus pane. */
-export function formatJobDetail(job: JobRecord, now = Date.now()): string[] {
+export function formatJobDetail(job: JobRecord, now = Date.now(), ownSessionId?: string): string[] {
 	const lines = [
 		sanitizeLogLine(`command: ${job.command}`),
 		sanitizeLogLine(`cwd: ${job.cwd} · ${jobOutcome(job)} · ${formatDuration(elapsedMs(job, now))}`),
 	];
+	if (ownSessionId !== undefined && job.sessionId !== ownSessionId) lines.push("owner: another session");
 	const last = sanitizeLogLine(job.lastLine);
 	if (last) lines.push(`last: ${last}`);
 	return lines;

package/extensions/job/process.ts

@@ -14,11 +14,26 @@
 import { execFileSync, spawn as nodeSpawn, spawnSync } from "node:child_process";
 import type { Readable } from "node:stream";
 
+/**
+ * The writable end of a child's stdin pipe.
+ *
+ * Only the operations `send` needs, so tests can hand the runtime a recording
+ * double instead of a real socket.
+ */
+export interface StdinSink {
+	write(chunk: string): boolean;
+	end(): void;
+	destroy?(): void;
+	on(event: "error" | "close", listener: (error?: Error) => void): unknown;
+}
+
 /** The subset of a spawned child the runtime uses. */
 export interface SpawnedProcess {
 	pid?: number;
 	stdout: Readable | null;
 	stderr: Readable | null;
+	/** Present only when spawned with `stdin: true`. */
+	stdin?: StdinSink | null;
 	on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
 	on(event: "error", listener: (error: Error) => void): unknown;
 	kill(signal?: NodeJS.Signals): boolean;
@@ -33,6 +48,8 @@ export type SpawnFn = (
 		env?: NodeJS.ProcessEnv;
 		/** The command writes its own output to the log; keep no parent pipe. */
 		detachOutput?: boolean;
+		/** Give the child a stdin pipe instead of `/dev/null` (no immediate EOF). */
+		stdin?: boolean;
 	},
 ) => SpawnedProcess;
 
@@ -51,13 +68,18 @@ export type KillTreeFn = (pid: number, signal: NodeJS.Signals, force?: boolean)
 export type StartTokenFn = (pid: number) => string | undefined;
 
 /** Default spawn: a shell command in its own process group. A detached job
- * redirects its own output to the log, so it needs no pipe to this process. */
+ * redirects its own output to the log, so it needs no pipe to this process.
+ * Stdin stays closed unless the job asked for it: a closed stdin gives the
+ * child EOF, so `read` exits instead of blocking forever. */
 export const defaultSpawn: SpawnFn = (command, options) =>
 	nodeSpawn(command, {
 		cwd: options.cwd,
 		shell: true,
 		detached: process.platform !== "win32",
-		stdio: options.detachOutput ? ["ignore", "ignore", "ignore"] : ["ignore", "pipe", "pipe"],
+		stdio: [
+			options.stdin ? "pipe" : "ignore",
+			...(options.detachOutput ? (["ignore", "ignore"] as const) : (["pipe", "pipe"] as const)),
+		],
 		env: options.env,
 	});
 

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,10 +1,11 @@
 /**
  * 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";
@@ -19,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";
@@ -49,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.",
 ];
 
@@ -57,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 },
@@ -83,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,
@@ -101,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,
 						};
 					}
 
@@ -110,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,
 						};
 					}
 
@@ -129,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}".`);
@@ -258,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;
@@ -280,6 +313,11 @@ 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");

package/extensions/job/tui.ts

@@ -51,25 +51,28 @@ const LOG_CHROME_ROWS = 6;
 const jobId = (job: JobRecord): string => job.id;
 
 /** One job row: selection marker, status glyph, id, label, and a right-aligned
- *  elapsed value. `statusRow` owns the clipping and the alignment. */
+ *  elapsed value, tagged `peer` when another session owns it. `statusRow` owns
+ *  the clipping and the alignment. */
 function jobRow(
 	job: JobRecord,
 	theme: Theme,
 	width: number,
-	options: Pick<StatusRow, "selected" | "marker"> = {},
+	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)}`,
-		trailing: formatDuration(elapsedMs(job, Date.now())),
+		// The tag rides the right-aligned cell, which survives a narrow terminal.
+		trailing: options.foreign ? `${elapsed}${SEPARATORS.item}peer` : elapsed,
 	});
 }
 
 /** Input for the transcript result: a themed job list or a log tail. */
 export type JobResultInput =
-	| { kind: "list"; jobs: JobRecord[]; more: number }
+	| { kind: "list"; jobs: JobRecord[]; more: number; sessionId?: string }
 	| { kind: "logs"; lines: string[]; earlier: number };
 
 /**
@@ -99,7 +102,10 @@ export class JobResult implements Component {
 		// A leading blank line separates the result from the call header.
 		const lines: string[] = [""];
 		if (this.input.kind === "list") {
-			for (const job of this.input.jobs) lines.push(jobRow(job, this.theme, w, { marker: false }));
+			for (const job of this.input.jobs) {
+				const foreign = this.input.sessionId !== undefined && job.sessionId !== this.input.sessionId;
+				lines.push(jobRow(job, this.theme, w, { marker: false, foreign }));
+			}
 			if (this.input.more > 0) {
 				const note = `${paint(this.theme, "faint", `… ${this.input.more} more`)} ${expandHint(this.theme)}`;
 				lines.push(clip(`  ${note}`, w));
@@ -118,6 +124,8 @@ export class JobResult implements Component {
 }
 
 export interface JobListCallbacks {
+	/** This session's id: a record with another id belongs to a peer session. */
+	sessionId(): string;
 	/** Current sanitized log lines for a job, or undefined when unknown. */
 	logs(id: string): { lines: string[]; more?: boolean } | undefined;
 	kill(id: string): void;
@@ -175,6 +183,11 @@ export class JobListComponent implements Component {
 		return [...this.jobs()].sort(compareJobs);
 	}
 
+	/** Whether another session owns this job, so the screen leaves it alone. */
+	private isForeign(job: JobRecord): boolean {
+		return job.sessionId !== this.callbacks.sessionId();
+	}
+
 	/** Focus job `next` (clamped) and keep it visible. */
 	private select(next: number): void {
 		const jobs = this.ordered;
@@ -256,7 +269,10 @@ export class JobListComponent implements Component {
 		else if (data === "d" || data === "K") {
 			const job = ordered[index];
 			if (!job) return;
-			if (job.status === "running") {
+			if (this.isForeign(job)) {
+				// Another session's job is shown here, not managed from here.
+				this.notice = `${job.id} is another session's job; not killed.`;
+			} else if (job.status === "running") {
 				this.confirm = { kind: "kill", id: job.id, label: shortLabel(job) };
 			} else {
 				// A finished job has nothing to kill; say so instead of a silent no-op.
@@ -264,7 +280,9 @@ export class JobListComponent implements Component {
 			}
 			this.requestRender();
 		} else if (data === "x") {
-			const finished = ordered.filter((job) => job.status !== "running");
+			// Only this session's finished jobs are ours to clear, so the prompt and the
+			// result agree.
+			const finished = ordered.filter((job) => !this.isForeign(job) && job.status !== "running");
 			if (finished.length > 0) {
 				this.confirm = {
 					kind: "clear",
@@ -320,10 +338,11 @@ export class JobListComponent implements Component {
 		if (this.pane.handleKey(data)) this.requestRender();
 	}
 
-	private summary(counts: JobCounts, width: number): string {
+	private summary(counts: JobCounts, width: number, foreign: number): string {
 		const cells = [paint(this.theme, "meta", `${counts.total} job${counts.total === 1 ? "" : "s"}`)];
 		if (counts.running > 0) cells.push(paint(this.theme, "meta", `${counts.running} running`));
 		if (counts.failed > 0) cells.push(paint(this.theme, "bad", `${counts.failed} failed`));
+		if (foreign > 0) cells.push(paint(this.theme, "faint", `${foreign} peer`));
 		const separator = paint(this.theme, "meta", SEPARATORS.item);
 		return clip(`  ${fitCells(cells, Math.max(1, width - 2), separator)}`, width);
 	}
@@ -338,7 +357,7 @@ export class JobListComponent implements Component {
 		this.cursor.clamp(jobs, jobId);
 		const index = this.cursor.indexOf(jobs, jobId);
 		const focused = jobs[index];
-		const detail = focused ? formatJobDetail(focused, Date.now()) : [];
+		const detail = focused ? formatJobDetail(focused, Date.now(), this.callbacks.sessionId()) : [];
 		this.cursor.visible = fitRows(
 			this.viewportRowsSource,
 			jobs.length,
@@ -354,8 +373,10 @@ export class JobListComponent implements Component {
 			body.push(...emptyState(this.theme, w, { label: "No background jobs." }));
 		} else {
 			const end = Math.min(jobs.length, this.cursor.scroll + this.cursor.visible);
-			for (let i = this.cursor.scroll; i < end; i++)
-				body.push(jobRow(jobs[i], this.theme, w, { selected: i === index }));
+			for (let i = this.cursor.scroll; i < end; i++) {
+				const row = jobs[i];
+				body.push(jobRow(row, this.theme, w, { selected: i === index, foreign: this.isForeign(row) }));
+			}
 			if (this.cursor.scroll > 0 || end < jobs.length) {
 				range = formatRange(this.theme, w, { start: this.cursor.scroll, end, total: jobs.length });
 			}
@@ -376,7 +397,7 @@ export class JobListComponent implements Component {
 
 		return dockListFrame({
 			header: titleRule(this.theme, w, "Jobs"),
-			summary: this.summary(jobCounts(jobs), w),
+			summary: this.summary(jobCounts(jobs), w, jobs.filter((job) => this.isForeign(job)).length),
 			body,
 			range,
 			// The detail pane is separated from the list by a blank line.

package/extensions/job/types.ts

@@ -10,7 +10,7 @@ export const JOB_STATUSES = ["running", "exited", "killed", "failed", "unknown"]
 
 export type JobStatus = (typeof JOB_STATUSES)[number];
 
-export const JOB_ACTIONS = ["start", "list", "status", "logs", "kill", "wait", "clear"] as const;
+export const JOB_ACTIONS = ["start", "list", "status", "logs", "send", "kill", "wait", "clear"] as const;
 
 export type JobAction = (typeof JOB_ACTIONS)[number];
 
@@ -40,6 +40,8 @@ export interface JobRecord {
 	detached: boolean;
 	/** Wake the agent with one triggered turn when the job finishes. */
 	wake: boolean;
+	/** Started with a stdin pipe, so `send` can write to it while this session holds the child. */
+	stdin: boolean;
 	/** Session that started the job. */
 	sessionId: string;
 	/** Whether the completion has already been reported to the model. */
@@ -83,10 +85,16 @@ export interface JobDetails {
 	signalled?: boolean;
 	/** Signal sent by `kill`; defaults to SIGTERM. */
 	signal?: KillSignal;
+	/** Characters of `input` written by `send`, excluding the added newline. */
+	sent?: number;
+	/** True when `send` ended the job's stdin (EOF). */
+	stdinClosed?: boolean;
 	/** True when `wait` hit its timeout. */
 	timedOut?: boolean;
 	/** True when `wait` was cancelled by the tool's abort signal. */
 	cancelled?: boolean;
+	/** Session that made the call, so a transcript can mark another session's rows. */
+	sessionId?: string;
 	/** Model-readable validation message when the call was rejected. */
 	error?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavin-hu/my-pi-agent",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, document, memory, wechat, and bytefly.",
   "keywords": [
     "pi-package",