@oisin-ee/oisinpi 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @oisin-ee/oisinpi
 
+## 0.5.0
+
+### Minor Changes
+
+- Bundle the released shared work strip and panel. Use Wrangle for background jobs and keep todo state on its Pi branch. Include updated guardrails that direct long work to Wrangle without relaxing timeout or wait checks.
+
+### Patch Changes
+
+- Updated dependencies [`1f4a622`]:
+  - @oisin-ee/pi-guardrails@0.5.0
+  - @oisin-ee/pi-prewalk@0.5.0
+  - @oisin-ee/pi-todo@0.5.0
+
 ## 0.4.0
 
 ### Patch Changes

package/README.md

@@ -6,7 +6,7 @@ Oisin's [pi](https://pi.dev) packages in one install, at versions tested togethe
 | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
 | [`@oisin-ee/pi-prewalk`](https://www.npmjs.com/package/@oisin-ee/pi-prewalk)       | A frontier model plans and makes the first edit; a cheaper model finishes. |
 | [`@oisin-ee/pi-todo`](https://www.npmjs.com/package/@oisin-ee/pi-todo)             | The `todo` tool, which also opens the prewalk gate.                        |
-| [`@oisin-ee/pi-wrangle`](https://www.npmjs.com/package/@oisin-ee/pi-wrangle)       | The board, `/wrangle`, and the inbox for children and jobs across hosts.   |
+| [`@oisin-ee/pi-wrangle`](https://www.npmjs.com/package/@oisin-ee/pi-wrangle)       | The shared `WORK` strip, `/work`, `/wrangle`, and the agent/job inbox.     |
 | [`@oisin-ee/pi-guardrails`](https://www.npmjs.com/package/@oisin-ee/pi-guardrails) | Git safety, the wait gate, and the agent-typing gate on every tool call.   |
 
 ```bash
@@ -16,3 +16,7 @@ pi install npm:@oisin-ee/oisinpi
 The collection bundles the four packages in its tarball and adds no code. No member imports another, so each one also
 installs by itself. pi-wrangle needs the `wrangle` binary at the same version
 ([oisin-ee/wrangle](https://github.com/oisin-ee/wrangle)).
+
+`/work` shows read-only todos for the active Pi branch and agents/jobs for the Herdr owner pane.
+Use Wrangle `run`, `read`, and `stop` for background work. The collection does not require `pi-background-tasks`.
+Standalone pi-todo keeps its own widget when Wrangle does not claim the shared display.

package/node_modules/@oisin-ee/pi-guardrails/dist/policies/shell.js

@@ -177,7 +177,9 @@ export const IMPERATIVE_MSG = {
 };
 export const WAIT_MSG = "wait-gate: blocked a command that waits instead of working (sleep, watch, a follow flag, a --watch or --wait " +
     "flag, or a wait subcommand). Never hold a tool call to wait, and never re-read a log to check progress. " +
-    "Start long work so the host reports its exit: in pi, the `bg_task` tool; in Claude Code, `run_in_background` " +
+    "For long work in pi, use Wrangle `run` (mcp__wrangle__run) and continue other work. " +
+    "Use `read` (mcp__wrangle__read) for output and `stop` (mcp__wrangle__stop) to cancel the job. " +
+    "Start long work so the host reports its exit: in Claude Code, `run_in_background` " +
     "or Monitor (the exit arrives as a message); in Codex, exec_command, then empty write_stdin calls, which " +
     "return when the process exits. " +
     "For CI, use ci_find and ci_watch.";

package/node_modules/@oisin-ee/pi-guardrails/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-guardrails",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Agent guardrails for pi, Claude Code, and Codex: Git safety, no waiting, no typing into other agents, GitOps-only clusters.",
   "keywords": [
     "claude-code",

package/node_modules/@oisin-ee/pi-guardrails/src/pi/tool-timeouts.ts

@@ -41,7 +41,8 @@ export function codeWaitViolation(
   }
   return CODE_WAITS.some((pattern) => pattern.test(code))
     ? "wait-gate: blocked a sleep or timer wait in sandbox code. Never hold a tool call to wait. Start long work with " +
-        "the `bg_task` tool and continue other work; its exit arrives as a message."
+        "Wrangle `run` (mcp__wrangle__run) and continue other work. Use `read` (mcp__wrangle__read) for output " +
+        "and `stop` (mcp__wrangle__stop) to cancel the job."
     : null;
 }
 
@@ -61,7 +62,8 @@ function limitMessage(
   return (
     `timeout-gate: blocked ${toolName} ${field}=${value}. The ${field} unit is ${unit === "s" ? "seconds" : "milliseconds"} ` +
     `and the limit is ${max} (${MAX_TIMEOUT_SECONDS / 60} minutes).${unitHint} ` +
-    "For a longer job, start it with the `bg_task` tool and continue other work; its exit arrives as a message. " +
+    "For a longer job, start it with Wrangle `run` (mcp__wrangle__run) and continue other work. " +
+    "Use `read` (mcp__wrangle__read) for output and `stop` (mcp__wrangle__stop) to cancel the job. " +
     "For CI, use the ci_find and ci_watch tools."
   );
 }

package/node_modules/@oisin-ee/pi-guardrails/src/policies/shell.ts

@@ -229,7 +229,9 @@ export const IMPERATIVE_MSG = {
 export const WAIT_MSG =
   "wait-gate: blocked a command that waits instead of working (sleep, watch, a follow flag, a --watch or --wait " +
   "flag, or a wait subcommand). Never hold a tool call to wait, and never re-read a log to check progress. " +
-  "Start long work so the host reports its exit: in pi, the `bg_task` tool; in Claude Code, `run_in_background` " +
+  "For long work in pi, use Wrangle `run` (mcp__wrangle__run) and continue other work. " +
+  "Use `read` (mcp__wrangle__read) for output and `stop` (mcp__wrangle__stop) to cancel the job. " +
+  "Start long work so the host reports its exit: in Claude Code, `run_in_background` " +
   "or Monitor (the exit arrives as a message); in Codex, exec_command, then empty write_stdin calls, which " +
   "return when the process exits. " +
   "For CI, use ci_find and ci_watch.";

package/node_modules/@oisin-ee/pi-prewalk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-prewalk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A one-shot planner-to-executor handoff for pi, with branch-backed Rust rules.",
   "keywords": [
     "pi-extension",

package/node_modules/@oisin-ee/pi-todo/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-todo",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A todo tool for pi with a Rust core: one active task, state on the session branch.",
   "keywords": [
     "pi-extension",

package/node_modules/@oisin-ee/pi-wrangle/README.md

@@ -466,11 +466,16 @@ The caller is the harness's `HERDR_PANE_ID`. Pi registers the server from its ex
 
 The extension adds host status before each prompt, registers the tools, and draws:
 
-- **The board widget** above the editor: `wrangle board --json` for this pane, every ten seconds. The header counts each group and shows a meter per host. On a narrow terminal the activity column goes first, then the host. An empty board removes the widget.
+- **The `WORK` strip** above the editor: one row for todo progress, agents, jobs, and attention. Agent/job data refreshes every ten seconds. Compatible pi-todo snapshots update immediately. Empty providers hide the strip; unavailable providers show an error instead of false zero counts.
+- **`/work`**, a bounded overlay with All, Todos, Agents, and Jobs views. Tab changes views; Enter opens details. Todos are read-only. Explicit actions stop jobs, cancel queued tickets, or message agents through the inbox. Stop and cancel require confirmation. Escape returns to the unchanged editor draft. Completed job history stays collapsed until selected.
 - **`/wrangle`**, the control panel, with four tabs: Status (hosts with their retry state, then your rows; Enter on a host reads it again now), Hosts (reconnect, rename, enable, disable, add), Profiles (Enter edits `prompt.md`), and Inbox. The widget steps aside while the panel is open.
 - **The inbox reader** and a renderer that shows each record's kind, sender, and text, folded past twelve lines.
 
-Without `HERDR_PANE_ID` the extension starts nothing. `$WRANGLE_BIN` selects the binary.
+Without `HERDR_PANE_ID`, the extension starts no Wrangle polling or jobs. The shared display can still show todos and reports Wrangle unavailable. `$WRANGLE_BIN` selects the binary.
+
+Todos follow the active Pi session branch. Agents and jobs follow the calling Herdr owner pane, including after a Pi session change. `/todos` and Alt+T open the Todos view when compatible pi-todo is active. `/todos list` remains a plain readout. The [display contract](docs/pi-work.md) keeps task state and reminders in pi-todo. Wrangle retains execution, logs, cancellation, and completion delivery.
+
+The Jobs view joins retained records to the current owner's ledger by host and job ID. It does not show unrelated fleet jobs. Job inspection uses `wrangle read` for a bounded log tail and shows the `wrangle logs` command for full output. Expired records and unavailable hosts produce explicit errors. The panel never starts a new process manager, edits todos, or writes into an agent terminal.
 
 The Herdr plugin keeps only the status-board popup:
 

package/node_modules/@oisin-ee/pi-wrangle/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-wrangle",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Pi extension for wrangle: the board, the /wrangle panel, the inbox reader, and the wrangle tools. Needs the wrangle binary of the same version.",
   "type": "module",
   "license": "MIT",

package/node_modules/@oisin-ee/pi-wrangle/pi/index.ts

@@ -1,9 +1,13 @@
 import { readFileSync } from "node:fs";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
-import { type Board, clean, parseBoard, renderBoard } from "./board.ts";
+import { type Board, clean, parseBoard } from "./board.ts";
+import { WorkTodo } from "./work-todo.ts";
+import { workStrip, workText, type WorkState } from "./work.ts";
 import { type Details, InboxReader, MESSAGE_TYPE } from "./inbox.ts";
 import { openPanel } from "./panel.ts";
+import { loadJobHistory, type JobHistory } from "./work-history.ts";
+import { WorkPanel, runWorkAction, showWorkDetail, type WorkAction, type WorkCursor, type WorkData, type WorkTab } from "./work-panel.ts";
 
 const REFRESH_MS = 10_000;
 
@@ -57,11 +61,69 @@ export default function wrangle(pi: ExtensionAPI) {
 	});
 
 	let panelOpen = false;
+	let workOpen = false;
+	let history: JobHistory = { jobs: [] };
+	let workPanel: WorkPanel | undefined;
+	let closeWork: (() => void) | undefined;
+	let workAbort: AbortController | undefined;
+	let context: ExtensionContext | undefined;
+	const todos = new WorkTodo(pi.events, () => { if (context) draw(context); }, () => {
+		if (context) void openWork(context, "todos").catch(error => context?.ui.notify(String(error), "error"));
+	});
+
+	function state(): WorkState {
+		return { board, todo: todos.current, error: failure ?? todos.error };
+	}
+
+	function workData(): WorkData { return { ...state(), history }; }
+
+	async function openWork(ctx: ExtensionContext, tab: WorkTab): Promise<void> {
+		if (ctx.mode !== "tui") { ctx.ui.notify(workText(state()), "info"); return; }
+		if (workOpen || panelOpen) return;
+		workOpen = true;
+		const interaction = new AbortController();
+		workAbort = interaction;
+		const current = generation;
+		let cursor: WorkCursor = { tab, selected: undefined, history: false };
+		try {
+			// An older refresh may predate history demand; finish it before the panel refresh.
+			if (refresh) await refresh;
+			if (interaction.signal.aborted || current !== generation) return;
+			await update(ctx);
+			while (current === generation && workOpen) {
+				const action = await ctx.ui.custom<WorkAction | undefined>((tui, theme, keys, done) => {
+					closeWork = () => done(undefined);
+					workPanel = new WorkPanel(workData(), cursor, theme, keys, done, () => tui.requestRender(), () => tui.terminal.rows);
+					return workPanel;
+				}, { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
+				workPanel = undefined;
+				closeWork = undefined;
+				if (!action || current !== generation) break;
+				cursor = action.cursor;
+				try {
+					const detail = await runWorkAction(action, ctx, exec, interaction.signal);
+					if (detail !== undefined && current === generation) await showWorkDetail(ctx, action.entry.label, detail, interaction.signal);
+				} catch (error) {
+					if (current === generation) await showWorkDetail(ctx, "Work action unavailable", String(error), interaction.signal);
+				}
+				if (current === generation) await update(ctx);
+			}
+		} finally {
+			interaction.abort();
+			if (workAbort === interaction) workAbort = undefined;
+			workPanel = undefined;
+			closeWork = undefined;
+			workOpen = false;
+			history = { jobs: [] };
+		}
+	}
 
 	function draw(ctx: ExtensionContext) {
-		// The panel lists the same rows; while it is open the widget steps aside.
-		ctx.ui.setWidget("wrangle", panelOpen || board.rows.length === 0 ? undefined : (_tui, theme) => ({
-			render: (width: number) => renderBoard(board, width, theme),
+		if (ctx.mode !== "tui") return;
+		workPanel?.update(workData());
+		const data = state();
+		ctx.ui.setWidget("wrangle", panelOpen || (!data.board.rows.length && !data.todo?.tasks.length && !data.error) ? undefined : (_tui, theme) => ({
+			render: (width: number) => workStrip(data, width, theme),
 			invalidate: () => {},
 		}), { placement: "aboveEditor" });
 	}
@@ -75,15 +137,22 @@ export default function wrangle(pi: ExtensionAPI) {
 			if (ctx.mode !== "tui") return;
 			try {
 				const next = parseBoard(JSON.parse(await exec(["board", "--json"])));
-				failure = undefined;
 				if (current !== generation) return;
+				failure = undefined;
 				board = next;
+				if (workOpen) {
+					const loaded = await loadJobHistory(exec, owner);
+					if (current !== generation) return;
+					history = loaded;
+				}
 				draw(ctx);
 			} catch (error) {
 				// Say so once, not on every refresh; the last board stays on screen.
 				const text = String(error);
+				if (current !== generation) return;
 				if (text !== failure) ctx.ui.notify(text, "error");
 				failure = text;
+				draw(ctx);
 			}
 		})().finally(() => { refresh = undefined; });
 		return refresh;
@@ -92,7 +161,13 @@ export default function wrangle(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		if (timer) clearInterval(timer);
 		generation++;
-		if (!owner) return;
+		workAbort?.abort();
+		closeWork?.();
+		context = ctx;
+		board = { hosts: [], rows: [] };
+		failure = owner ? undefined : "Wrangle needs a Herdr owner pane";
+		todos.start(ctx);
+		if (!owner) { draw(ctx); return; }
 		timer = setInterval(() => { void update(ctx); }, REFRESH_MS);
 		timer.unref();
 		await inbox.start(ctx);
@@ -106,9 +181,13 @@ export default function wrangle(pi: ExtensionAPI) {
 	});
 	pi.on("session_shutdown", (_event, ctx) => {
 		generation++;
+		workAbort?.abort();
+		closeWork?.();
 		if (timer) clearInterval(timer);
 		timer = undefined;
 		inbox.stop();
+		todos.stop();
+		context = undefined;
 		if (ctx.mode === "tui") ctx.ui.setWidget("wrangle", undefined);
 	});
 	// A delivered message is in the transcript once Pi ends it: only then is it acknowledged.
@@ -124,6 +203,12 @@ export default function wrangle(pi: ExtensionAPI) {
 			return;
 		}
 	});
+	pi.registerCommand("work", {
+		description: "Read todos on this branch and this owner's agents and jobs",
+		handler: async (_args, ctx) => {
+			await openWork(ctx, "all");
+		},
+	});
 	pi.registerCommand("wrangle", {
 		description: "Hosts, your children and jobs, profiles, and messages",
 		handler: async (_args, ctx) => {
@@ -131,6 +216,7 @@ export default function wrangle(pi: ExtensionAPI) {
 				ctx.ui.notify(await exec(["board"]), "info");
 				return;
 			}
+			if (workOpen || panelOpen) return;
 			panelOpen = true;
 			draw(ctx);
 			try {

package/node_modules/@oisin-ee/pi-wrangle/pi/work-history.ts

@@ -0,0 +1,33 @@
+import { clean } from "./board.ts";
+
+export interface WorkJob {
+	id: string; host: string; owner: string; cmd: string[]; state: string;
+	ended_ms: number | null; exit: number | null;
+}
+export interface JobHistory { jobs: WorkJob[]; hosts?: { id: string; label: string }[]; error?: string }
+export type WorkExec = (args: string[]) => Promise<string>;
+function record(value: unknown): value is Record<string, unknown> { return value !== null && typeof value === "object"; }
+function job(value: unknown): value is WorkJob {
+	return record(value) && ["id", "host", "owner", "state"].every(key => typeof value[key] === "string")
+		&& Array.isArray(value["cmd"]) && value["cmd"].every(part => typeof part === "string")
+		&& (value["ended_ms"] === null || typeof value["ended_ms"] === "number")
+		&& (value["exit"] === null || typeof value["exit"] === "number");
+}
+
+/** History comes from the owner's ledger, not a coincidentally equal pane on another host. */
+export async function loadJobHistory(exec: WorkExec, owner: string): Promise<JobHistory> {
+	try {
+		const [itemText, jobText, hostText] = await Promise.all([exec(["items", "--owner", owner, "--json"]), exec(["ps", "--all", "--json"]), exec(["machine", "list", "--json"])]);
+		const items: unknown = JSON.parse(itemText), jobs: unknown = JSON.parse(jobText), hosts: unknown = JSON.parse(hostText);
+		if (!Array.isArray(hosts) || !hosts.every((host): host is { id: string; label: string } => record(host) && typeof host["id"] === "string" && typeof host["label"] === "string")) throw new Error("Invalid Wrangle host identities");
+		if (!record(items) || !Array.isArray(items["items"]) || !Array.isArray(jobs) || !jobs.every(job)) throw new Error("Invalid Wrangle job history");
+		const allowed = new Set<string>();
+		for (const item of items["items"]) {
+			if (!record(item) || typeof item["id"] !== "string" || typeof item["host"] !== "string" || typeof item["owner_pane"] !== "string") throw new Error("Invalid Wrangle owner item");
+			if (item["owner_pane"] === owner && item["kind"] === "job") allowed.add(JSON.stringify([item["host"], item["id"]]));
+		}
+		return { jobs: jobs.filter(item => allowed.has(JSON.stringify([item.host, item.id]))), hosts };
+	} catch (error) {
+		return { jobs: [], error: `History unavailable: ${clean(String(error))}` };
+	}
+}

package/node_modules/@oisin-ee/pi-wrangle/pi/work-panel.ts

@@ -0,0 +1,147 @@
+import type { ExtensionContext, KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, SelectList, Text, ScrollView, truncateToWidth } from "@earendil-works/pi-tui";
+import { clean } from "./board.ts";
+import type { WorkState } from "./work.ts";
+import type { JobHistory, WorkExec } from "./work-history.ts";
+
+export type WorkTab = "all" | "todos" | "agents" | "jobs";
+const tabs: WorkTab[] = ["all", "todos", "agents", "jobs"];
+export interface WorkEntry {
+	value: string; label: string; description?: string;
+	kind: "todo" | "agent" | "job" | "queued" | "history" | "empty";
+	id?: string; host?: string; pane?: string; detail?: string; running?: boolean;
+}
+export interface WorkData extends WorkState { history: JobHistory }
+export interface WorkCursor { tab: WorkTab; selected: string | undefined; history: boolean }
+export interface WorkAction { action: "inspect" | "stop" | "cancel" | "send" | "refresh"; entry: WorkEntry; cursor: WorkCursor }
+
+/** The same content in every tab, without task mutation or duplicate job rows. */
+export function workEntries(data: WorkData, tab: WorkTab, history: boolean): WorkEntry[] {
+	const todos: WorkEntry[] = (data.todo?.tasks ?? []).map(task => ({ value: `todo:${task.content}`, label: `${task.status === "in_progress" ? "→" : task.status === "completed" ? "✓" : task.status === "abandoned" ? "−" : "·"} ${clean(task.content)}`, description: task.status, kind: "todo", detail: task.content }));
+	const canonicalHost = (label: string) => data.history.hosts?.find(host => host.label === label)?.id ?? label;
+	const rows: WorkEntry[] = data.board.rows.map(row => ({ value: `${row.kind}:${canonicalHost(row.host)}:${row.id}`, id: row.id, host: canonicalHost(row.host), ...(row.pane ? { pane: row.pane } : {}), kind: row.group === "waiting" ? "queued" : row.kind === "job" ? "job" : "agent", label: `${row.group === "attention" || row.group === "to_land" ? "!" : "●"} ${clean(row.name)}`, description: `${clean(row.state)} · ${clean(row.host)}`, running: row.group === "running" }));
+	const visible = tab === "todos" ? todos : tab === "agents" ? rows.filter(row => row.value.startsWith("agent:")) : tab === "jobs" ? rows.filter(row => row.value.startsWith("job:")) : [...rows.filter(row => row.label.startsWith("!")), ...todos.filter(row => row.description === "in_progress"), ...rows.filter(row => !row.label.startsWith("!")), ...todos.filter(row => row.description === "pending")];
+	if (tab === "all" || tab === "jobs") {
+		const known = new Set(rows.map(row => row.value));
+		const done = data.history.jobs.filter(job => job.ended_ms !== null && !known.has(`job:${job.host}:${job.id}`));
+		if (done.length) visible.push({ value: "history", kind: "history", label: `${history ? "▾" : "▸"} Completed jobs (${done.length})` });
+		if (history) visible.push(...done.map(job => ({ value: `job:${job.host}:${job.id}`, id: job.id, host: job.host, kind: "job" as const, label: `${job.exit === 0 ? "✓" : "!"} ${clean(job.cmd.join(" "))}`, description: `${clean(job.state)} · exit ${job.exit ?? "unknown"} · ${clean(job.host)}`, running: false })));
+		if (data.history.error) visible.push({ value: "history-error", kind: "empty", label: data.history.error });
+	}
+	if (data.error) visible.unshift({ value: "error", kind: "empty", label: clean(data.error) });
+	return visible.length ? visible : [{ value: "empty", kind: "empty", label: "No work in this view." }];
+}
+
+/** One interaction. The existing refresh coordinator supplies changes without another timer. */
+export class WorkPanel {
+	private list!: SelectList;
+	private entries: WorkEntry[] = [];
+	private data: WorkData;
+	readonly cursor: WorkCursor;
+	private readonly theme: Theme;
+	private readonly keys: KeybindingsManager;
+	private readonly done: (action: WorkAction | undefined) => void;
+	private readonly renderRequest: () => void;
+	private readonly rows: () => number;
+	private height = 0;
+
+	constructor(data: WorkData, cursor: WorkCursor, theme: Theme, keys: KeybindingsManager, done: (action: WorkAction | undefined) => void, request: () => void, rows: () => number) {
+		this.data = data; this.cursor = cursor; this.theme = theme; this.keys = keys; this.done = done; this.renderRequest = request; this.rows = rows;
+		this.rebuild();
+	}
+	update(data: WorkData): void { this.data = data; this.rebuild(); this.renderRequest(); }
+	private rebuild(preserveSelection = true): void {
+		if (preserveSelection) this.cursor.selected = this.list?.getSelectedItem()?.value ?? this.cursor.selected;
+		this.entries = workEntries(this.data, this.cursor.tab, this.cursor.history);
+		this.height = Math.max(1, Math.min(14, Math.floor(this.rows() * 0.8) - 5));
+		this.list = new SelectList(this.entries, this.height, {
+			selectedPrefix: text => this.theme.fg("accent", text), selectedText: text => this.theme.fg("accent", text),
+			description: text => this.theme.fg("muted", text), scrollInfo: text => this.theme.fg("dim", text), noMatch: text => this.theme.fg("muted", text),
+		}, { minPrimaryColumnWidth: 8, maxPrimaryColumnWidth: 60 });
+		this.list.setSelectedIndex(Math.max(0, this.entries.findIndex(entry => entry.value === this.cursor.selected)));
+		this.list.onCancel = () => this.done(undefined);
+		this.list.onSelect = () => this.act("inspect");
+	}
+	private act(action: WorkAction["action"]): void {
+		const selected = this.list.getSelectedItem();
+		const entry = this.entries.find(item => item.value === selected?.value);
+		if (!entry) return;
+		if (entry.kind === "history" && action === "inspect") { this.cursor.history = !this.cursor.history; this.rebuild(); this.renderRequest(); return; }
+		if (entry.kind === "empty" && action !== "refresh") return;
+		if (action === "stop" && (entry.kind !== "job" || !entry.running)) return;
+		if (action === "cancel" && entry.kind !== "queued") return;
+		if (action === "send" && entry.kind !== "agent") return;
+		this.cursor.selected = entry.value;
+		this.done({ action, entry, cursor: this.cursor });
+	}
+	handleInput(input: string): void {
+		const step = matchesKey(input, Key.tab) ? 1 : matchesKey(input, Key.shift("tab")) ? -1 : 0;
+		if (step) { this.cursor.tab = tabs[(tabs.indexOf(this.cursor.tab) + step + tabs.length) % tabs.length]!; this.cursor.selected = undefined; this.rebuild(false); this.renderRequest(); return; }
+		if (input === "r") this.act("refresh");
+		else if (input === "s") this.act("stop");
+		else if (input === "c") this.act("cancel");
+		else if (input === "m") this.act("send");
+		else this.list.handleInput(input);
+	}
+	invalidate(): void { this.list.invalidate(); }
+	render(width: number): string[] {
+		if (this.height !== Math.max(1, Math.min(14, Math.floor(this.rows() * 0.8) - 5))) this.rebuild();
+		const tabbar = tabs.map(tab => tab === this.cursor.tab ? `[${tab.toUpperCase()}]` : tab).join(" · ");
+		return [this.theme.fg("accent", `WORK  ${tabbar}`), this.theme.fg("dim", "Todos: Pi branch · Agents/jobs: Herdr owner pane"), ...this.list.render(width), this.theme.fg("dim", "Tab view · Enter inspect · s stop · c cancel · m message"), this.theme.fg("dim", `r refresh · ${this.keys.getKeys("tui.select.cancel").join("/")} close`)].map(line => truncateToWidth(line, width));
+	}
+}
+
+/** Strip terminal control sequences from output while retaining line breaks. */
+function safeOutput(value: string): string {
+	return value.replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").split("\n").map(clean).join("\n");
+}
+
+export async function inspectEntry(entry: WorkEntry, exec: WorkExec): Promise<string> {
+	if (entry.kind === "todo") return entry.detail ?? "";
+	if (entry.kind === "queued") return `${entry.label}\n${entry.description ?? ""}\nWaiting for placement. Cancel explicitly to remove this ticket.`;
+	if (!entry.id) return "This record is unavailable.";
+	const output = await exec(["read", entry.kind === "job" ? entry.id : entry.pane ?? entry.id, "--host", entry.host ?? "local"]);
+	const hint = entry.kind === "job" ? `Recent job output (Wrangle's bounded tail).\nFull log: wrangle logs ${clean(entry.id)}\n\n` : "";
+	return hint + safeOutput(output);
+}
+
+/** Actions run after closing the list, so confirmation/input dialogs own focus. */
+export async function runWorkAction(action: WorkAction, ctx: ExtensionContext, exec: WorkExec, signal: AbortSignal): Promise<string | undefined> {
+	if (signal.aborted) return undefined;
+	const entry = action.entry;
+	if (action.action === "inspect") return inspectEntry(entry, exec);
+	if (action.action === "stop" && entry.kind === "job" && entry.running && entry.id && await ctx.ui.confirm("Stop job?", clean(entry.label), { signal }) && !signal.aborted) await exec(["stop", entry.id]);
+	if (action.action === "cancel" && entry.kind === "queued" && entry.id && await ctx.ui.confirm("Cancel queued work?", clean(entry.label), { signal }) && !signal.aborted) await exec(["cancel", entry.id]);
+	if (action.action === "send" && entry.kind === "agent") {
+		const message = await ctx.ui.input(`Message ${clean(entry.label)}`, undefined, { signal });
+		if (!signal.aborted && message?.trim() && entry.id) await exec(["send", entry.pane ?? entry.id, "--host", entry.host ?? "local", "--message", message]);
+	}
+	return undefined;
+}
+
+export async function showWorkDetail(ctx: ExtensionContext, title: string, body: string, signal: AbortSignal): Promise<void> {
+	if (signal.aborted) return;
+	await ctx.ui.custom<void>((tui, theme, keys, done) => {
+		const abort = () => done();
+		signal.addEventListener("abort", abort, { once: true });
+		const text = new Text(safeOutput(body) || "No output yet.", 0, 0);
+		const scroll = new ScrollView(text, { overscroll: "contain", scrollbar: "hidden" });
+		return {
+			dispose() { signal.removeEventListener("abort", abort); },
+			render(width: number) {
+				const height = Math.max(1, Math.min(24, Math.floor(tui.terminal.rows * 0.8) - 3));
+				scroll.updateLayout(text.render(width).length, height, () => tui.requestRender());
+				return [theme.fg("accent", truncateToWidth(title, width)), ...scroll.render(width).slice(scroll.scrollTop, scroll.scrollTop + height), theme.fg("dim", truncateToWidth("↑↓ / PageUp / PageDown scroll · Esc back", width))];
+			},
+			invalidate() { text.invalidate(); scroll.invalidate(); },
+			handleInput(input: string) {
+				if (keys.matches(input, "tui.select.cancel")) { done(); return; }
+				if (matchesKey(input, Key.up)) scroll.scrollBy(-1);
+				if (matchesKey(input, Key.down)) scroll.scrollBy(1);
+				if (matchesKey(input, Key.pageUp)) scroll.scrollBy(-scroll.viewportHeight);
+				if (matchesKey(input, Key.pageDown)) scroll.scrollBy(scroll.viewportHeight);
+				tui.requestRender();
+			},
+		};
+	}, { overlay: true, overlayOptions: { width: "90%", maxHeight: "85%", anchor: "center" } });
+}

package/node_modules/@oisin-ee/pi-wrangle/pi/work-todo.ts

@@ -0,0 +1,114 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { randomUUID } from "node:crypto";
+
+export interface WorkTask { content: string; status: "pending" | "in_progress" | "completed" | "abandoned" }
+export interface TodoSnapshot {
+	version: 1;
+	presenter: string;
+	request: string;
+	publisher: string;
+	revision: number;
+	session: string;
+	branch: string | null;
+	tasks: WorkTask[];
+}
+
+type Bus = ExtensionAPI["events"];
+function record(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null; }
+
+/** Validate the independently installed provider's wire envelope, not rendered widget text. */
+export function snapshot(value: unknown): TodoSnapshot | undefined {
+	if (!record(value) || value["version"] !== 1 || typeof value["presenter"] !== "string" || typeof value["request"] !== "string"
+		|| typeof value["publisher"] !== "string" || typeof value["session"] !== "string"
+		|| (value["branch"] !== null && typeof value["branch"] !== "string")
+		|| !Number.isSafeInteger(value["revision"]) || Number(value["revision"]) < 1 || !Array.isArray(value["tasks"])) return undefined;
+	if (!value["tasks"].every((task: unknown) => record(task) && typeof task["content"] === "string"
+		&& ["pending", "in_progress", "completed", "abandoned"].includes(String(task["status"])))) return undefined;
+	return value as unknown as TodoSnapshot;
+}
+
+/** A session-scoped display lease. The provider remains the only task-state writer. */
+export class WorkTodo {
+	private readonly bus: Bus;
+	private readonly changed: () => void;
+	private readonly open: () => void;
+	private subscriptions: (() => void)[] = [];
+	private ctx: ExtensionContext | undefined;
+	private presenter = "";
+	private request = "";
+	private retired = new Set<string>();
+	current: TodoSnapshot | undefined;
+	error: string | undefined;
+
+	constructor(bus: Bus, changed: () => void, open: () => void) { this.bus = bus; this.changed = changed; this.open = open; }
+
+	start(ctx: ExtensionContext): void {
+		this.stop();
+		if (ctx.mode !== "tui") return;
+		this.ctx = ctx;
+		this.presenter = randomUUID();
+		this.retired.clear();
+		this.subscriptions = [
+			this.bus.on("oisin.todo.ready", value => {
+				if (!record(value) || value["version"] !== 1 || typeof value["publisher"] !== "string") { this.reject(); return; }
+				if (this.retired.has(value["publisher"])) return;
+				this.ask();
+			}),
+			this.bus.on("oisin.todo.snapshot", value => this.receive(value)),
+			this.bus.on("oisin.todo.stop", value => {
+				if (!record(value) || !this.current || value["publisher"] !== this.current.publisher) return;
+				this.retired.add(this.current.publisher);
+				this.current = undefined;
+				this.changed();
+			}),
+			this.bus.on("oisin.work.open", value => {
+				if (record(value) && value["version"] === 1 && value["presenter"] === this.presenter && value["request"] === this.request) this.open();
+			}),
+		];
+		this.ask();
+	}
+
+	private ask(): void {
+		this.request = randomUUID();
+		this.bus.emit("oisin.work.request", { version: 1, presenter: this.presenter, request: this.request });
+	}
+
+	private reject(): void {
+		this.error = "Todo integration unavailable";
+		this.release();
+		this.changed();
+	}
+
+	private receive(value: unknown): void {
+		if (!record(value) || value["presenter"] !== this.presenter || value["request"] !== this.request) return;
+		const next = snapshot(value);
+		if (!next) { this.reject(); return; }
+		if (!this.ctx || next.session !== this.ctx.sessionManager.getSessionId() || next.branch !== this.ctx.sessionManager.getLeafId() || this.retired.has(next.publisher)) return;
+		if (this.current?.publisher === next.publisher && next.revision <= this.current.revision) return;
+		if (this.current && this.current.publisher !== next.publisher) this.retired.add(this.current.publisher);
+		this.current = next;
+		this.error = undefined;
+		try {
+			// The strip must render successfully before its provider relinquishes the widget.
+			this.changed();
+			this.bus.emit("oisin.work.claim", { version: 1, presenter: this.presenter, request: this.request, publisher: next.publisher, revision: next.revision });
+		} catch (error) {
+			this.error = "Todo integration unavailable";
+			this.release();
+			this.ctx.ui.notify(`Work display unavailable: ${String(error)}`, "error");
+		}
+	}
+
+	private release(): void {
+		if (this.presenter) this.bus.emit("oisin.work.release", { version: 1, presenter: this.presenter, request: this.request });
+		this.current = undefined;
+	}
+
+	stop(): void {
+		for (const off of this.subscriptions) off();
+		this.subscriptions = [];
+		this.release();
+		this.ctx = undefined;
+		this.error = undefined;
+	}
+}

package/node_modules/@oisin-ee/pi-wrangle/pi/work.ts

@@ -0,0 +1,45 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { clean, type Board, type Paint } from "./board.ts";
+import type { TodoSnapshot } from "./work-todo.ts";
+
+export interface WorkState {
+	board: Board;
+	todo: TodoSnapshot | undefined;
+	error: string | undefined;
+}
+
+/** One bounded row. Attention survives before progress and descriptive labels. */
+export function workStrip(state: WorkState, width: number, paint: Paint): string[] {
+	const { board, todo, error } = state;
+	if (!board.rows.length && !todo?.tasks.length && !error) return [];
+	const attention = board.rows.filter(row => row.group === "attention" || row.group === "to_land");
+	const urgent = attention.length ? `!${attention.length}` : error ? "!" : "";
+	const prefix = `WORK${urgent ? ` ${urgent}` : ""}`;
+	const counts: string[] = [];
+	if (todo?.tasks.length) counts.push(`${todo.tasks.filter(task => task.status === "completed").length}/${todo.tasks.length} todos`);
+	const jobs = board.rows.filter(row => row.kind === "job").length;
+	const agents = board.rows.filter(row => row.kind !== "job").length;
+	if (agents) counts.push(`${agents} agent${agents === 1 ? "" : "s"}`);
+	if (jobs) counts.push(`${jobs} job${jobs === 1 ? "" : "s"}`);
+	const item = attention[0];
+	const detail = error ? `unavailable · ${clean(error)}` : item ? `${clean(item.name)} · ${clean(item.state)}`
+		: todo?.tasks.find(task => task.status === "in_progress")?.content;
+	let line = prefix;
+	for (const count of counts) {
+		const next = `${line} · ${count}`;
+		if (visibleWidth(next) + 8 <= width) line = next;
+	}
+	if (detail && width - visibleWidth(line) > 12) line += ` · ${truncateToWidth(clean(detail), width - visibleWidth(line) - 11)}`;
+	if (visibleWidth(line) + 8 <= width) line += "  /work";
+	return [truncateToWidth(paint.fg(urgent ? "warning" : "accent", line), width)];
+}
+
+/** A plain readout also works in modes where custom terminal UI is unavailable. */
+export function workText(state: WorkState): string {
+	const lines = ["WORK · todos: Pi branch · agents/jobs: Herdr owner pane"];
+	if (state.error) lines.push(state.error);
+	for (const task of state.todo?.tasks ?? []) lines.push(`${task.status}: ${clean(task.content)}`);
+	for (const row of state.board.rows) lines.push(`${clean(row.name)} · ${clean(row.state)} · ${clean(row.host)}`);
+	if (lines.length === 1) lines.push("No work.");
+	return lines.join("\n");
+}

package/node_modules/@oisin-ee/pi-wrangle/plugins/wrangle/skills/wrangle/SKILL.md

@@ -18,7 +18,7 @@ wrangle read NAME_OR_PANE [--host H]
 ```
 
 The board groups what you started by what you must do: TO LAND (a finished child with commits), ATTENTION (blocked, stalled, failed), RUNNING, and WAITING (queued for a host). Each agent row shows its harness and model; each job row its command.
-Your prompt context carries host status and a `To land:` line. In Pi, the board widget sits above the editor and `/wrangle` opens the control panel.
+Your prompt context carries host status and a `To land:` line. In Pi, the one-row `WORK` strip sits above the editor. `/work` opens read-only todos and agent/job inspection. Todos follow the Pi branch; agents and jobs follow the owner pane. `/wrangle` retains host, profile, and inbox administration.
 
 ## Delegate
 
@@ -66,14 +66,16 @@ It refuses, before it changes anything, a busy agent, a dirty or detached worktr
 ## Run a job
 
 ```sh
-wrangle run --wait --max 30m --timeout 1h --idle-timeout 10m -- cargo test
+wrangle run --host local --timeout 1h --idle-timeout 10m -- cargo test
+wrangle read JOB
 wrangle ps --all
-wrangle logs JOB --follow
-wrangle wait JOB --max 30m
+wrangle logs JOB
 wrangle stop JOB
 ```
 
-Run long waits through the harness's background-task tool. A completed wait returns the job's exit code. At the wait deadline, wrangle prints `still running` and exits 124; the job continues.
+Use `run` without `--wait` so the conversation stays usable. Continue other work; Wrangle delivers owner check-ins for job completion. Use `read` for a bounded output tail. Use `logs` when you need the full retained log, not as a polling loop. Do not run `wait` or `logs --follow` in a foreground agent tool call.
+
+Pin `--host local` when a job needs your working tree, local environment, or ports. Choose a remote host explicitly when required. Without a host, Wrangle selects one with room. Stop only jobs you own or have permission to stop.
 Job timeouts kill the process group. Both timeout defaults are unlimited. Durations accept `ms`, `s`, `m`, and `h`.
 When the job ends, `exec` saves the final record, then closes its own tab. `logs` and `wait` still work after that.
 Jobs use a tab in your workspace. Remote work uses a workspace with the same name.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/oisinpi",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Oisin's pi packages in one install: prewalk, todo, wrangle, and guardrails.",
   "keywords": [
     "guardrails",
@@ -18,10 +18,10 @@
   },
   "type": "module",
   "dependencies": {
-    "@oisin-ee/pi-guardrails": "0.4.0",
-    "@oisin-ee/pi-prewalk": "0.4.0",
-    "@oisin-ee/pi-todo": "0.4.0",
-    "@oisin-ee/pi-wrangle": "0.11.0"
+    "@oisin-ee/pi-guardrails": "0.5.0",
+    "@oisin-ee/pi-prewalk": "0.5.0",
+    "@oisin-ee/pi-todo": "0.5.0",
+    "@oisin-ee/pi-wrangle": "0.12.1"
   },
   "bundleDependencies": [
     "@oisin-ee/pi-guardrails",