@oisin-ee/oisinpi 0.4.0 → 0.5.1

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # @oisin-ee/oisinpi
 
+## 0.5.1
+
+### Patch Changes
+
+- [`0170caa`](https://github.com/oisin-ee/oisinpi/commit/0170caa9c59c4e3d71409627b14925cefcc68679) Thanks [@momo-momokaya[bot]](https://github.com/momo-momokaya%5Bbot%5D)! - Bundle pi-wrangle 0.12.2. Show the current task and named agents and jobs above the editor. Alt+W and `/work` expand the same widget in place, without a popup or editor replacement.
+- Updated dependencies []:
+  - @oisin-ee/pi-guardrails@0.5.1
+  - @oisin-ee/pi-prewalk@0.5.1
+  - @oisin-ee/pi-todo@0.5.1
+
+## 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 inline `WORK` widget, `/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,9 @@ 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)).
+
+The compact widget shows the current task and named agents and jobs above the editor.
+Alt+W or `/work` expands that widget in place, without a popup. Typing stays in the editor.
+Todos follow the active Pi branch. Agents and jobs follow 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.1",
   "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.1",
   "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.1",
   "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` widget** above the editor shows the current task and named agents and jobs. Agent/job data refreshes every ten seconds. Compatible pi-todo snapshots update immediately. Empty providers hide the widget. Unavailable providers show an error.
+- **Alt+W or `/work`** expands or collapses that widget in place, without a popup or editor replacement. Alt+J/K moves selection, Alt+] changes views, and Alt+I shows inline details. Typing stays in the editor. Alt+S stops jobs, Alt+C cancels queued work, and Alt+M sends agent messages. Stop and cancel require confirmation. Completed job history starts collapsed.
 - **`/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.2",
   "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 { Box, Text, Key } from "@earendil-works/pi-tui";
+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, WorkDetail, runWorkAction, type WorkAction, type WorkCursor, type WorkData, type WorkTab } from "./work-panel.ts";
 
 const REFRESH_MS = 10_000;
 
@@ -57,13 +61,90 @@ export default function wrangle(pi: ExtensionAPI) {
 	});
 
 	let panelOpen = false;
+	let workOpen = false;
+	let history: JobHistory = { jobs: [] };
+	let workPanel: WorkPanel | undefined;
+	let workDetail: WorkDetail | undefined;
+	let detail: { title: string; body: string } | undefined;
+	let cursor: WorkCursor = { tab: "all", selected: undefined, history: false };
+	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 }; }
+
+	function collapseWork(ctx: ExtensionContext): void {
+		workAbort?.abort();
+		workAbort = undefined;
+		workOpen = false;
+		workPanel = undefined;
+		workDetail = undefined;
+		detail = undefined;
+		history = { jobs: [] };
+		draw(ctx);
+	}
+
+	async function openWork(ctx: ExtensionContext, tab: WorkTab): Promise<void> {
+		if (ctx.mode !== "tui") { ctx.ui.notify(workText(state()), "info"); return; }
+		if (panelOpen) return;
+		workOpen = true;
+		detail = undefined;
+		workDetail = undefined;
+		cursor = { tab, selected: undefined, history: false };
+		workPanel = undefined;
+		const current = generation;
+		draw(ctx);
+		// Draw immediately; remote history must not delay expansion or typing.
+		if (refresh) await refresh;
+		if (current === generation && workOpen) await update(ctx);
+	}
+
+	async function act(ctx: ExtensionContext, action: WorkAction | undefined): Promise<void> {
+		if (!action) { collapseWork(ctx); return; }
+		if (workAbort) return;
+		const interaction = new AbortController();
+		workAbort = interaction;
+		const current = generation;
+		try {
+			const body = await runWorkAction(action, ctx, exec, interaction.signal);
+			if (current !== generation || interaction.signal.aborted) return;
+			if (body !== undefined) { detail = { title: action.entry.label, body }; workDetail = undefined; }
+			draw(ctx);
+			await update(ctx);
+		} catch (error) {
+			if (current === generation && !interaction.signal.aborted) {
+				detail = { title: "Work action unavailable", body: String(error) };
+				workDetail = undefined;
+				draw(ctx);
+			}
+		} finally {
+			if (workAbort === interaction) workAbort = undefined;
+		}
+	}
 
 	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),
-			invalidate: () => {},
-		}), { placement: "aboveEditor" });
+		if (ctx.mode !== "tui") return;
+		workPanel?.update(workData());
+		const data = state();
+		ctx.ui.setWidget("wrangle", panelOpen || (!workOpen && !data.board.rows.length && !data.todo?.tasks.length && !data.error) ? undefined : (tui, theme) => {
+			if (workOpen) {
+				if (detail) {
+					workDetail ??= new WorkDetail(detail.title, detail.body, theme, () => tui.terminal.rows, () => tui.requestRender());
+					workDetail.setTheme(theme);
+					return workDetail;
+				}
+				workDetail = undefined;
+				workPanel = new WorkPanel(workData(), cursor, theme, action => { void act(ctx, action); }, () => tui.requestRender(), () => tui.terminal.rows);
+				return workPanel;
+			}
+			return { render: (width: number) => workStrip(data, width, theme), invalidate() {} };
+		}, { placement: "aboveEditor" });
 	}
 
 	function update(ctx: ExtensionContext): Promise<void> {
@@ -75,15 +156,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;
+					if (workOpen) 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 +180,18 @@ export default function wrangle(pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		if (timer) clearInterval(timer);
 		generation++;
-		if (!owner) return;
+		workAbort?.abort();
+		workAbort = undefined;
+		workOpen = false;
+		workPanel = undefined;
+		workDetail = undefined;
+		detail = undefined;
+		history = { jobs: [] };
+		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 +205,17 @@ export default function wrangle(pi: ExtensionAPI) {
 	});
 	pi.on("session_shutdown", (_event, ctx) => {
 		generation++;
+		workAbort?.abort();
+		workAbort = undefined;
+		workOpen = false;
+		workPanel = undefined;
+		workDetail = undefined;
+		detail = undefined;
 		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 +231,29 @@ export default function wrangle(pi: ExtensionAPI) {
 			return;
 		}
 	});
+	async function toggleWork(ctx: ExtensionContext): Promise<void> {
+		if (workOpen) collapseWork(ctx);
+		else await openWork(ctx, "all");
+	}
+	pi.registerCommand("work", {
+		description: "Expand or collapse work above the editor (Alt+W)",
+		handler: async (_args, ctx) => { await toggleWork(ctx); },
+	});
+	pi.registerShortcut(Key.alt("w"), { description: "Expand or collapse work above the editor", handler: toggleWork });
+	for (const [key, input, description] of [
+		["j", "\u001b[B", "Next work item / scroll down"], ["k", "\u001b[A", "Previous work item / scroll up"],
+		["]", "\t", "Next work view"], ["i", "\r", "Inspect work / return to list"],
+		["s", "s", "Stop selected job"], ["c", "c", "Cancel selected queued work"],
+		["m", "m", "Message selected agent"], ["r", "r", "Refresh work"],
+	] as const) {
+		pi.registerShortcut(Key.alt(key), { description, handler: async (_ctx) => {
+			if (!workOpen || panelOpen || workAbort || !context) return;
+			if (detail) {
+				if (key === "i") { detail = undefined; draw(context); }
+				else if (key === "j" || key === "k") workDetail?.handleInput(input);
+			} else workPanel?.handleInput(input);
+		} });
+	}
 	pi.registerCommand("wrangle", {
 		description: "Hosts, your children and jobs, profiles, and messages",
 		handler: async (_args, ctx) => {
@@ -131,6 +261,7 @@ export default function wrangle(pi: ExtensionAPI) {
 				ctx.ui.notify(await exec(["board"]), "info");
 				return;
 			}
+			if (panelOpen || workAbort) 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,148 @@
+import type { ExtensionContext, 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)} · ${clean(row.state)}`, description: 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 done: (action: WorkAction | undefined) => void;
+	private readonly renderRequest: () => void;
+	private readonly rows: () => number;
+	private height = 0;
+
+	constructor(data: WorkData, cursor: WorkCursor, theme: Theme, done: (action: WorkAction | undefined) => void, request: () => void, rows: () => number) {
+		this.data = data; this.cursor = cursor; this.theme = theme; this.done = done; this.renderRequest = request; this.rows = rows;
+		this.rebuild();
+	}
+	update(data: WorkData): void { this.data = data; this.rebuild(); this.renderRequest(); }
+	private listHeight(): number { return Math.max(1, Math.min(12, Math.floor(this.rows() / 2) - 4)); }
+	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 = this.listHeight();
+		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);
+		this.renderRequest();
+	}
+	invalidate(): void { this.list.invalidate(); }
+	render(width: number): string[] {
+		if (this.height !== this.listHeight()) this.rebuild();
+		const tabbar = tabs.map(tab => tab === this.cursor.tab ? `[${tab.toUpperCase()}]` : tab).join(" · ");
+		return [this.theme.fg("accent", `WORK  ${tabbar}`), ...this.list.render(width), this.theme.fg("dim", "Alt+W collapse · Alt+J/K select · Alt+] view · Alt+I inspect"), this.theme.fg("dim", "Alt+S stop · Alt+C cancel · Alt+M message · Alt+R refresh")].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);
+}
+
+/** Explicit actions may open confirmation/input dialogs; the work widget stays inline. */
+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;
+}
+
+/** Details occupy the same above-editor widget, never an overlay. */
+export class WorkDetail {
+	private readonly text: Text;
+	private readonly scroll: ScrollView;
+	private readonly title: string;
+	private theme: Theme;
+	private readonly rows: () => number;
+	private readonly request: () => void;
+	constructor(title: string, body: string, theme: Theme, rows: () => number, request: () => void) {
+		this.title = title; this.theme = theme; this.rows = rows; this.request = request;
+		this.text = new Text(safeOutput(body) || "No output yet.", 0, 0);
+		this.scroll = new ScrollView(this.text, { overscroll: "contain", scrollbar: "hidden" });
+	}
+	render(width: number): string[] {
+		const height = Math.max(1, Math.min(12, Math.floor(this.rows() / 2) - 2));
+		this.scroll.updateLayout(this.text.render(width).length, height, this.request);
+		return [this.theme.fg("accent", truncateToWidth(this.title, width)), ...this.scroll.render(width).slice(this.scroll.scrollTop, this.scroll.scrollTop + height), this.theme.fg("dim", truncateToWidth("Alt+J/K scroll · Alt+I back · Alt+W collapse", width))];
+	}
+	setTheme(theme: Theme): void { this.theme = theme; this.invalidate(); }
+	invalidate(): void { this.text.invalidate(); this.scroll.invalidate(); }
+	handleInput(input: string): void {
+		if (matchesKey(input, Key.up)) this.scroll.scrollBy(-1);
+		if (matchesKey(input, Key.down)) this.scroll.scrollBy(1);
+		this.request();
+	}
+}

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,57 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { age, clean, type Board, type Paint, type Row } from "./board.ts";
+import type { TodoSnapshot } from "./work-todo.ts";
+
+export interface WorkState {
+	board: Board;
+	todo: TodoSnapshot | undefined;
+	error: string | undefined;
+}
+
+/** A small, persistent readout: names and current work, not just counts. */
+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 lines = [paint.fg("dim", "WORK · Alt+W expand")];
+	if (error) lines.push(paint.fg("warning", `! unavailable · ${clean(error)}`));
+	const tasks = todo?.tasks ?? [];
+	const active = tasks.find(task => task.status === "in_progress");
+	const next = tasks.find(task => task.status === "pending");
+	const current = active ?? next;
+	if (current) lines.push(`${paint.fg("accent", active ? "→ Task" : "· Next")}  ${clean(current.content)}`);
+	else if (tasks.length) lines.push(paint.fg("muted", `Tasks · ${tasks.filter(task => task.status === "completed").length}/${tasks.length} completed`));
+	const priority = (row: Row) => row.group === "attention" || row.group === "to_land" ? 0 : row.group === "running" ? 1 : 2;
+	for (const [label, members] of [
+		["Agents", board.rows.filter(row => row.kind !== "job")],
+		["Jobs", board.rows.filter(row => row.kind === "job")],
+	] as const) {
+		const rows = [...members].sort((a, b) => priority(a) - priority(b));
+		if (!rows.length) continue;
+		let line = `${label}  `;
+		let shown = 0;
+		for (const row of rows) {
+			const warning = priority(row) === 0;
+			const entry = `${warning ? "! " : ""}${clean(row.name)} · ${clean(row.state)} · ${age(row.age_ms)}`;
+			const remaining = rows.length - shown - 1;
+			const suffix = remaining ? `  +${remaining} more` : "";
+			const join = shown ? "  |  " : "";
+			if (shown && visibleWidth(line + join + entry + suffix) > width) break;
+			const room = Math.max(0, width - visibleWidth(line + join + suffix));
+			line += join + paint.fg(warning ? "warning" : "muted", truncateToWidth(entry, room));
+			shown++;
+		}
+		if (shown < rows.length) line += paint.fg("dim", `  +${rows.length - shown} more`);
+		lines.push(line);
+	}
+	return lines.map(line => truncateToWidth(line, width));
+}
+
+/** A plain readout also works in modes where 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 compact `WORK` widget shows the current task and named agents and jobs above the editor. Alt+W or `/work` expands it in place. Work inspection stays inline, not in a popup. 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.1",
   "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.1",
+    "@oisin-ee/pi-prewalk": "0.5.1",
+    "@oisin-ee/pi-todo": "0.5.1",
+    "@oisin-ee/pi-wrangle": "0.12.2"
   },
   "bundleDependencies": [
     "@oisin-ee/pi-guardrails",