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

package/extensions/goal/tui.ts

@@ -1,20 +1,16 @@
 /**
  * Terminal rendering for the goal.
  *
- * Two surfaces share one vocabulary. `goalWidgetLines` renders the persistent
- * above-editor widget as a single label-first rail line (`Goal · active ·
- * <objective>`, dimmed once achieved), matching the `todo` and `jobs` widgets.
- * `goalRailLines` renders the transcript result as a header (`Goal · active`)
- * plus the objective wrapped and led by the status glyph, with continuation rows
- * aligned under the text; it matches the todo transcript result's indent + glyph
- * grammar so the two read as a pair.
- * `GoalResult` wraps `goalRailLines` uncapped for the transcript.
+ * Two surfaces share one vocabulary. The persistent above-editor widget is a
+ * single label-first rail line (`Goal · active · <objective>`, dimmed once
+ * achieved), matching the `todo` and `jobs` widgets. The transcript result is
+ * the status header alone (`Goal · active`): the call line already names the
+ * objective, so the result only states the new status.
  */
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
-import { BODY_INDENT, GLYPH_GAP } from "../../lib/tui/glyphs.ts";
-import { goalGlyph, goalHeader, goalLine } from "./format.ts";
+import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { goalHeader, goalLine } from "./format.ts";
 import type { AchievedStyle, Goal } from "./types.ts";
 
 /** Widget key used with `ctx.ui.setWidget()`. */
@@ -25,27 +21,6 @@ export interface GoalWidgetOptions {
 	achieved?: AchievedStyle;
 }
 
-/**
- * Rows for the transcript goal rail: the themed header plus `body` wrapped and
- * led by the status glyph. Continuation rows are padded to the text column.
- */
-export function goalRailLines(goal: Goal, body: string, theme: Theme, width: number): string[] {
-	const w = Math.max(1, width);
-	const glyph = goalGlyph(goal, theme);
-	const glyphWidth = visibleWidth(glyph);
-	const textColumn = BODY_INDENT + glyphWidth + GLYPH_GAP;
-	const inner = Math.max(1, w - textColumn);
-
-	const wrapped = wrapTextWithAnsi(body, inner);
-	const pad = " ".repeat(BODY_INDENT);
-	const continuation = " ".repeat(textColumn);
-	const lines = [goalHeader(goal, theme)];
-	wrapped.forEach((line, index) => {
-		lines.push(index === 0 ? `${pad}${glyph}${" ".repeat(GLYPH_GAP)}${line}` : `${continuation}${line}`);
-	});
-	return lines.map((line) => truncateToWidth(line, w, "…"));
-}
-
 /** Rows for the goal widget: a single rail line, or nothing when hidden. */
 export function goalWidgetLines(goal: Goal, theme: Theme, width: number, options: GoalWidgetOptions = {}): string[] {
 	const w = Math.max(1, width);
@@ -68,30 +43,27 @@ export class GoalWidget implements Component {
 	}
 }
 
-/** Transcript result block: the rail, uncapped, with the themed body. */
+/** Transcript result block: the status header, separated from the call line. */
 export class GoalResult implements Component {
 	private goal: Goal;
-	private body: string;
 	private theme: Theme;
 
-	constructor(goal: Goal, body: string, theme: Theme) {
+	constructor(goal: Goal, theme: Theme) {
 		this.goal = goal;
-		this.body = body;
 		this.theme = theme;
 	}
 
 	/** Update in place so the transcript can reuse this component across renders. */
-	update(goal: Goal, body: string, theme: Theme): void {
+	update(goal: Goal, theme: Theme): void {
 		this.goal = goal;
-		this.body = body;
 		this.theme = theme;
 	}
 
 	invalidate(): void {}
 
 	render(width: number): string[] {
-		// The leading blank line separates the rail from the call header, matching
+		// The leading blank line separates the header from the call line, matching
 		// the built-ins' header/output gap.
-		return ["", ...goalRailLines(this.goal, this.body, this.theme, Math.max(1, width))];
+		return ["", truncateToWidth(goalHeader(this.goal, this.theme), Math.max(1, width), "…")];
 	}
 }

package/extensions/job/README.md

@@ -5,18 +5,34 @@ the background and manage them without blocking the turn. A job starts
 immediately and keeps running across tool calls; poll it, tail its output, wait
 for it, or kill it.
 
+<img src="../../assets/job.png" alt="The /jobs screen: a summary line, the job rows with status glyphs and elapsed times, and the focused job's command, cwd, and last output line" width="100%">
+
 ```
 pi --extension ./extensions/job    # load just this extension
 pi -e .                            # load the whole @gavin-hu/my-pi-agent package
 pi install ./                      # install the package
 ```
 
+## Tool rendering
+
+How the `job` call and its result look in the transcript — the call line as a headline and the body indented under it:
+
+<img src="../../assets/tools/job.png" alt="The job tool's result: the call line and an indented body with a finished and a failed job row, each with its status glyph and elapsed time" width="100%">
+
 ## 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.
@@ -32,14 +48,18 @@ pi install ./                      # install the package
 | 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. |
@@ -60,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
 }
 ```
@@ -81,15 +119,15 @@ JobDetails {
 ### Transcript
 
 The call line names the action and its target. The result is themed and reuses
-the slot's component: `list` draws the same row rail as `/jobs`, `logs` draws a
+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
-
   ▸ j1  tests                            3.2s
   ✗ j2  build                            0.4s
 ```
@@ -109,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.
@@ -149,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. |
@@ -170,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
@@ -199,15 +256,32 @@ rewritten.
 | Execution mode | `sequential` — actions share the in-memory job table. |
 | Annotations | `readOnlyHint: false`, `destructiveHint: true`, `idempotentHint: false`, `openWorldHint: true` — plan mode blocks it. |
 | `outputSchema` / `structuredContent` | None. Results return `JobDetails` in tool-result `details` only. |
-| State storage | One durable registry file per session, `~/.pi/agent/jobs/<projectKey>/registry-<sessionHash>.json` (keyed by the session cwd, so entering a worktree does not move it), merged from every session file on load; a dead session's records are adopted and a legacy shared `registry.json` is migrated once. Ids are reserved with an atomic `O_EXCL` `<id>.lock` before `start`, and a POSIX job's exit code is written to a per-job `.status` file. Tool results carry `JobDetails`; unreported completions arrive as hidden `job-context` messages at `before_agent_start`. |
-| Lifecycle | `session_start` loads and reconciles the registry and arms `onFinish` and `onComplete`; `session_shutdown` kills session-owned jobs and clears both status chips. `session_tree` repaints; `agent_start`/`agent_settled` track busy; `context` prunes stale `job-context` messages. |
+| State storage | One durable registry file per session, `~/.pi/agent/jobs/<projectKey>/registry-<sessionHash>.json` (keyed by the session cwd, so entering a worktree does not move it), merged from every session file on load; a dead session's records are adopted and a legacy shared `registry.json` is migrated once. Ids are reserved with an atomic `O_EXCL` `<id>.lock` before `start`, and a POSIX job's exit code is written to a per-job `.status` file. Tool results carry `JobDetails`; unreported completions arrive as a shared transcript notice (`my-pi-agent/notice`) at `before_agent_start`. |
+| Lifecycle | `session_start` loads and reconciles the registry and arms `onFinish` and `onComplete`; `session_shutdown` kills session-owned jobs and clears both status chips. `session_tree` repaints; `agent_start`/`agent_settled` track busy; `context` prunes stale notices of its own source. |
 | Event bus | Each job that reaches a terminal state is published on `my-pi-agent/job-finished` (`lib/events.ts`) with its id, label, status, exit code, and signal, from the one `settle` path every transition goes through. bytefly's notify capability subscribes there instead of importing this extension. |
 
 ## 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
@@ -248,11 +322,11 @@ rewritten.
   settles it (recovering an exit code from the status file, else `unknown`)
   when the pid disappears.
 - **Notify by default, wake opt-in.** A failed job raises one `ctx.ui.notify`
-  (a clean exit is left to the list and chips). Finished jobs are also injected
-  as a hidden `job-context` message at the next `before_agent_start`. A
-  `wake: true` job (or `wakeOnFinish`) additionally triggers one turn when the
-  agent is idle; auto-wake is not the default because it easily loops and burns
-  tokens.
+  (a clean exit is left to the list and chips). Finished jobs are also posted
+  as a shared transcript notice — model-facing text plus the notice block — at the
+  next `before_agent_start`. A `wake: true` job (or `wakeOnFinish`) additionally
+  triggers one turn when the agent is idle; auto-wake is not the default because
+  it easily loops and burns tokens.
 - **Width-1 glyphs and cached latest line.** The running chip is `▸ N` and the
   failure chip `✗ N`, each a two-token badge under its own status key, so the
   status bar compacts each independently (`▸N` / `✗N`) and an unreported
@@ -264,8 +338,10 @@ rewritten.
   spawn/liveness/kill/clock functions, so the whole suite runs without
   launching a process.
 - **The transcript reuses the `/jobs` grammar.** `job list` renders the same
-  `jobRow` rail as the screen (running first, capped, `… N more`), `job logs`
-  draws a themed tail with a `… N earlier lines` note, and single-job actions
+  `jobRow` rows as the screen (running first, capped, `… N more`), minus the
+  selection-marker column (`listRow`'s `marker: false`), which only the
+  interactive screen needs; `job logs` draws a themed tail with a `… N earlier
+  lines` note, and single-job actions
   draw one `formatJobOutcomeLine` (plus a signal note on `kill` and
   `detached`/`wake` badges on `start`). A capped collapsed result ends with the
   `app.tools.expand` hint, and an expanded list shows every job. The renderers
@@ -292,7 +368,7 @@ rewritten.
 | `ui.ts` | Footer status chips, over the shared `lib/tui/status-controller.ts`. |
 | `waiters.ts` | `wait` resolver bookkeeping. |
 | `runtime.ts` | Composition: job table, handles, process events, repaint clock. |
-| `tui.ts` | The `/jobs` screen and the transcript `JobResult` rail, drawn from the `lib/tui/` kit (`titleRule`, `listRow`, `emptyState`, `IdCursor`, `LinePane`). |
+| `tui.ts` | The `/jobs` screen and the transcript `JobResult` rows, drawn from the `lib/tui/` kit (`titleRule`, `listRow`, `emptyState`, `IdCursor`, `LinePane`). |
 | `tools.ts` | The `job` tool and its transcript rendering. |
 | `commands.ts` | The `/jobs` command. |
 | `types.ts` | Shared types. |
@@ -304,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

@@ -14,7 +14,7 @@
 
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import { GLYPHS } from "../../lib/tui/glyphs.ts";
+import { GLYPHS, SEPARATORS } from "../../lib/tui/glyphs.ts";
 import { paint, type TuiRole } from "../../lib/tui/tokens.ts";
 import type { JobRecord, JobStatus } from "./types.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":
@@ -251,7 +262,7 @@ export function jobOutcome(job: JobRecord): string {
 
 /** One-line outcome for a single job, themed for the transcript result. */
 export function formatJobOutcomeLine(job: JobRecord, theme: Theme, now = Date.now()): string {
-	const sep = paint(theme, "faint", " · ");
+	const sep = paint(theme, "faint", SEPARATORS.item);
 	const outcome =
 		job.status === "failed" ? paint(theme, "bad", jobOutcome(job)) : paint(theme, "faint", jobOutcome(job));
 	return (
@@ -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/index.ts

@@ -4,18 +4,19 @@
  * Registers the `job` tool and `/jobs` command. Jobs run as detached shell
  * processes with their output streamed to log files; the status chip shows
  * running and unreported-failure counts, and finished jobs are reported to the
- * model at the next turn (or, for `wake` jobs, by triggering one turn).
+ * model — and shown as a bytefly notice — at the next turn, or by triggering one
+ * turn for a `wake` job.
  *
  * Load with:  pi --extension ./extensions/job
  */
 
-import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isExtensionEnabled } from "../../lib/env.ts";
 import { JOB_FINISHED_CHANNEL, type JobFinishedEvent } from "../../lib/events.ts";
+import { noticeMessage, type NoticeMessage, pruneStaleNotices } from "../../lib/notice.ts";
 import { STATUS_KEYS } from "../../lib/tui/glyphs.ts";
 import { registerCommands } from "./commands.ts";
-import { formatCompletion } from "./format.ts";
+import { formatCompletion, jobOutcome, shortLabel } from "./format.ts";
 import { createJobsRuntime, type JobsRuntime } from "./runtime.ts";
 import { registerTools } from "./tools.ts";
 import type { Job, JobRecord } from "./types.ts";
@@ -23,16 +24,26 @@ import type { Job, JobRecord } from "./types.ts";
 /** Marker embedded in the injected completion context. */
 const JOB_CONTEXT_MARKER = "[BACKGROUND JOBS]";
 
-/** Custom-entry type used for the injected completion message. */
-export const JOB_CONTEXT_TYPE = "job-context";
-
 function buildContext(jobs: JobRecord[]): string {
 	const lines = jobs.map((job) => formatCompletion(job));
 	return `${JOB_CONTEXT_MARKER}\n${jobs.length} background job${jobs.length === 1 ? "" : "s"} finished:\n${lines.join("\n")}\nRun \`job logs <id>\` for output.`;
 }
 
-function isJobContext(message: AgentMessage): boolean {
-	return (message as AgentMessage & { customType?: string }).customType === JOB_CONTEXT_TYPE;
+/** The shared notice for pending completions: model text plus renderer details. */
+function jobNotice(jobs: JobRecord[]): NoticeMessage {
+	const count = jobs.length;
+	return noticeMessage({
+		content: buildContext(jobs),
+		details: {
+			source: "job",
+			title: `${count} background job${count === 1 ? "" : "s"} finished`,
+			items: jobs.map((job) => ({
+				label: `${job.id} ${shortLabel(job)}`,
+				detail: jobOutcome(job),
+				severity: job.status === "failed" ? "bad" : job.status === "exited" ? "ok" : "warn",
+			})),
+		},
+	});
 }
 
 /** Trim a finished record to the fields the event bus carries. */
@@ -67,10 +78,7 @@ export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 		const pending = runtime.pendingCompletions();
 		if (pending.length === 0) return;
 		try {
-			pi.sendMessage(
-				{ customType: JOB_CONTEXT_TYPE, content: buildContext(pending), display: false },
-				{ triggerTurn: true },
-			);
+			pi.sendMessage(jobNotice(pending), { triggerTurn: true });
 			// Mark only once the send succeeded; a throw leaves them for the next turn.
 			runtime.markReported(pending.map((job) => job.id));
 		} catch {
@@ -113,17 +121,14 @@ export default function jobs(pi: ExtensionAPI, deps: JobsDeps = {}): void {
 		if (pending.length === 0) return undefined;
 		runtime.markReported(pending.map((job) => job.id));
 		runtime.setStatus(ctx);
-		return {
-			message: { customType: JOB_CONTEXT_TYPE, content: buildContext(pending), display: false },
-		};
+		return { message: jobNotice(pending) };
 	});
 
-	// Keep stale completion notes out of later turns.
+	// Keep stale completion notices out of later turns. Only this extension's
+	// notices are pruned; another source's are left for its own handler.
 	pi.on("context", (event) => {
-		const contexts = event.messages.filter(isJobContext);
-		if (contexts.length <= 1) return undefined;
-		const last = contexts[contexts.length - 1];
-		return { messages: event.messages.filter((message) => !isJobContext(message) || message === last) };
+		const pruned = pruneStaleNotices(event.messages, "job");
+		return pruned ? { messages: pruned } : undefined;
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {

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,
 	});