@oisin-ee/oisinpi 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @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
+
+- Updated dependencies [[`0a1434e`](https://github.com/oisin-ee/oisinpi/commit/0a1434eedb156c21abd36ae611a124b06f0ad1d8), [`74a563f`](https://github.com/oisin-ee/oisinpi/commit/74a563f9fa806902d9c0cf7d1d2e01edea255dec)]:
+  - @oisin-ee/pi-todo@0.4.0
+  - @oisin-ee/pi-guardrails@0.4.0
+  - @oisin-ee/pi-prewalk@0.4.0
+
 ## 0.3.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.3.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.3.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/README.md

@@ -42,6 +42,36 @@ Expansion stays open through task updates. Session changes and `/tree` navigatio
 When no task is active, a short status and the shortcut hint remain visible.
 Outside the terminal UI, `/todos` prints the list instead.
 
+## Shared work display
+
+When a compatible pi-wrangle extension is active, its `WORK` strip replaces the standalone todo widget.
+Tasks remain on the current Pi session branch. Wrangle receives read-only snapshots through `pi.events`.
+`/todos` and Alt+T request the shared Todos view. `/todos list` still prints the full list.
+When shared presentation ends, the standalone widget returns without changing task state.
+
+The [version 1 display contract](https://github.com/oisin-ee/wrangle/blob/main/docs/pi-work.md)
+defines the snapshot request, acknowledgement, release, and read-only view events.
+
+## Plannotator plans
+
+With Plannotator external execution, pi-todo continues approved plans in the same session.
+Add this setting to `~/.pi/agent/plannotator.json`:
+
+```json
+{
+  "executionMode": "external"
+}
+```
+
+After approval, the agent reads the current todo list and adds the remaining approved work before implementation.
+It preserves unrelated tasks and completed progress. Free-form plans do not need a special checklist format.
+The todo tool owns progress, persistence, reminders, and the shared work display.
+Plannotator returns to idle and does not maintain a second checklist or require `[DONE:n]` markers.
+
+This integration uses the supported `plannotator:plan-approved` event, verified with Plannotator `0.28.19`.
+It does not import Plannotator internals or change its code.
+Malformed events, a different working directory, or another owner of the `todo` tool stop the handoff with an error.
+
 ## Reminder
 
 When the agent stops with open tasks, pi-todo adds a hidden reminder that lists them and continues the turn.

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

@@ -1,6 +1,6 @@
 {
   "name": "@oisin-ee/pi-todo",
-  "version": "0.3.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-todo/src/index.ts

@@ -1,17 +1,26 @@
-import { ownsTodo, settle, show } from "./lifecycle.ts";
+import { ownsTodo, settle } from "./lifecycle.ts";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { PlannotatorHandoff } from "./plannotator.ts";
 import { StringEnum } from "@earendil-works/pi-ai";
-import { TODO_SHORTCUT } from "./widget.ts";
 import { TodoPresentation } from "./presentation.ts";
+import { TodoWork } from "./work.ts";
 import { Type } from "typebox";
+import type { WorkHost } from "./work.ts";
 import { runTodo } from "./tool.ts";
 
-type TodoAPI = Readonly<
-  Pick<
-    ExtensionAPI,
-    "appendEntry" | "getAllTools" | "on" | "registerCommand" | "registerShortcut" | "registerTool"
-  >
->;
+type TodoAPI = WorkHost &
+  Readonly<
+    Pick<
+      ExtensionAPI,
+      | "appendEntry"
+      | "getAllTools"
+      | "on"
+      | "registerCommand"
+      | "registerShortcut"
+      | "registerTool"
+      | "sendMessage"
+    >
+  >;
 
 const items = Type.Immutable(
     Type.Array(Type.String(), { description: "For init or append: tasks, in order." }),
@@ -32,13 +41,10 @@ const items = Type.Immutable(
  * @param {TodoAPI} pi The extension API methods used here.
  */
 export default function piTodo(pi: TodoAPI): void {
-  const presentation = new TodoPresentation();
-  pi.registerShortcut(TODO_SHORTCUT, {
-    description: "Expand or collapse upcoming and done todos.",
-    handler(ctx) {
-      presentation.toggle(pi, ctx);
-    },
-  });
+  const handoff = new PlannotatorHandoff(pi),
+    presentation = new TodoPresentation(),
+    work = new TodoWork(pi, presentation);
+  work.register(pi);
   pi.registerTool({
     description:
       "Keep the session todo list. Tasks are addressed by their exact content. One task is active; the next open task starts when it closes.",
@@ -49,6 +55,7 @@ export default function piTodo(pi: TodoAPI): void {
         },
         branch: () => ctx.sessionManager.getBranch(),
       });
+      work.publish(ctx);
       presentation.refresh(ctx);
       return result;
     },
@@ -59,23 +66,18 @@ export default function piTodo(pi: TodoAPI): void {
   });
   pi.on("session_start", (_event, ctx) => {
     presentation.start(pi, ctx);
+    work.start(ctx);
+    handoff.start(ctx);
+  });
+  pi.on("session_shutdown", () => {
+    handoff.stop();
+    work.stop();
   });
   pi.on("session_tree", (_event, ctx) => {
     if (ownsTodo(pi)) {
+      work.publish(ctx);
       presentation.reset(ctx);
     }
   });
   pi.on("agent_before_settle", (event, ctx) => settle(pi, event, ctx));
-  pi.registerCommand("todos", {
-    description: "Toggle todo details; /todos list prints the full branch list.",
-    async handler(args, ctx) {
-      if (ownsTodo(pi)) {
-        if (args.trim() === "list" || ctx.mode !== "tui") {
-          show(ctx);
-        } else {
-          presentation.toggle(pi, ctx);
-        }
-      }
-    },
-  });
 }

package/node_modules/@oisin-ee/pi-todo/src/plannotator.ts

@@ -0,0 +1,107 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { TodoContext } from "./lifecycle.ts";
+import type { WorkHost } from "./work.ts";
+import { ownsTodo } from "./lifecycle.ts";
+
+/** The supported Plannotator external-execution event. */
+interface ApprovedPlan {
+  readonly cwd: string;
+  readonly planFilePath: string;
+  readonly planContent: string;
+  readonly feedback?: string;
+}
+
+type PlanHost = WorkHost & Readonly<Pick<ExtensionAPI, "sendMessage">>;
+type PlanContext = TodoContext & { readonly cwd: string };
+
+/**
+ * Validates the event before it enters the model context.
+ * @param {unknown} value The shared event payload.
+ * @returns {boolean} Whether the required handoff fields are present.
+ */
+const isApprovedPlan = (value: unknown): value is ApprovedPlan =>
+    typeof value === "object" &&
+    value !== null &&
+    "cwd" in value &&
+    typeof value.cwd === "string" &&
+    "planFilePath" in value &&
+    typeof value.planFilePath === "string" &&
+    value.planFilePath.trim() !== "" &&
+    "planContent" in value &&
+    typeof value.planContent === "string" &&
+    value.planContent.trim() !== "" &&
+    (!("feedback" in value) || value.feedback === undefined || typeof value.feedback === "string"),
+  /**
+   * Continues the approved plan through the existing todo tool, not a second parser or store.
+   * @param {ApprovedPlan} plan The approved document and reviewer feedback.
+   * @returns {string} Instructions followed by the exact handoff data.
+   */
+  continuation = (plan: ApprovedPlan): string =>
+    [
+      "The user approved this plan in Plannotator. Continue execution in this session.",
+      "Use the todo tool as the only task tracker. Do not maintain Plannotator [DONE:n] markers.",
+      "First call todo with op=view to inspect the current branch list.",
+      "Before implementation, represent the approved plan's remaining work in that list.",
+      "If the list is empty, call todo with op=init and the remaining approved tasks in order.",
+      "Otherwise, reuse matching tasks and append missing tasks. Preserve unrelated work and completed progress.",
+      "If approved work remains, select its next open task with op=start. Never restart a completed task just because the plan was approved again.",
+      "If no approved work remains, report completion without changing tasks. Otherwise, update tasks with op=done or op=drop as work proceeds.",
+      "Resolve a relative planFilePath against cwd. The approved document and reviewer feedback follow as JSON:",
+      JSON.stringify({
+        cwd: plan.cwd,
+        feedback: plan.feedback,
+        planContent: plan.planContent,
+        planFilePath: plan.planFilePath,
+      }),
+    ].join("\n");
+
+/** Owns the approval subscription, never the todo list or execution progress. */
+class PlannotatorHandoff {
+  readonly #host: PlanHost;
+  #unsubscribe: (() => void) | undefined;
+
+  /**
+   * Keeps the supported event bus and conversation API.
+   * @param {PlanHost} host The Pi methods used by the handoff.
+   */
+  public constructor(host: PlanHost) {
+    this.#host = host;
+  }
+
+  /**
+   * Subscribes with the current session context after startup or replacement.
+   * @param {PlanContext} ctx The current branch and working directory.
+   */
+  public start(ctx: PlanContext): void {
+    this.stop();
+    this.#unsubscribe = this.#host.events.on(
+      "plannotator:plan-approved",
+      (value: unknown): void => {
+        if (!isApprovedPlan(value)) {
+          ctx.ui.notify("pi-todo: Invalid Plannotator approval. No execution started.", "error");
+        } else if (value.cwd !== ctx.cwd) {
+          ctx.ui.notify(
+            "pi-todo: The approved plan belongs to another working directory. No execution started.",
+            "error",
+          );
+        } else if (ownsTodo(this.#host)) {
+          this.#host.sendMessage(
+            { content: continuation(value), customType: "todo-plan-approved", display: true },
+            { deliverAs: "followUp", triggerTurn: true },
+          );
+        } else {
+          ctx.ui.notify("pi-todo: Another extension owns todo. No execution started.", "error");
+        }
+      },
+    );
+  }
+
+  /** Removes the previous session's listener before replacement or shutdown. */
+  public stop(): void {
+    this.#unsubscribe?.();
+    this.#unsubscribe = undefined;
+  }
+}
+
+export { PlannotatorHandoff };
+export type { PlanContext, PlanHost };

package/node_modules/@oisin-ee/pi-todo/src/presentation.ts

@@ -4,13 +4,16 @@ import { ownsTodo, replay, start } from "./lifecycle.ts";
 /** Owns transient expansion for one extension instance, never task state. */
 class TodoPresentation {
   #expanded = false;
+  #external = false;
 
   /**
    * Replays current branch tasks without changing expansion.
    * @param {TodoContext} ctx Current branch and UI.
    */
   public refresh(ctx: TodoContext): void {
-    replay(ctx, this.#expanded);
+    if (!this.#external) {
+      replay(ctx, this.#expanded);
+    }
   }
 
   /**
@@ -29,9 +32,28 @@ class TodoPresentation {
    */
   public start(pi: TodoHost, ctx: TodoContext): void {
     this.#expanded = false;
+    this.#external = false;
     start(pi, ctx);
   }
 
+  /**
+   * Yields only this extension's widget to an acknowledged work presenter.
+   * @param {TodoContext} ctx Current terminal UI.
+   */
+  public claim(ctx: TodoContext): void {
+    this.#external = true;
+    ctx.ui.setWidget("pi-todo", undefined);
+  }
+
+  /**
+   * Restores the standalone view without changing task state.
+   * @param {TodoContext} ctx Current terminal UI.
+   */
+  public release(ctx: TodoContext): void {
+    this.#external = false;
+    this.refresh(ctx);
+  }
+
   /**
    * Reveals or hides secondary groups without writing session state.
    * @param {TodoHost} pi Registered tool metadata.

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

@@ -0,0 +1,230 @@
+import type { TodoContext, TodoHost } from "./lifecycle.ts";
+import { ownsTodo, show } from "./lifecycle.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { TODO_SHORTCUT } from "./widget.ts";
+import type { TodoPresentation } from "./presentation.ts";
+import { latestSnapshot } from "./state.ts";
+import { parse } from "./wasm.ts";
+
+interface WorkHost extends TodoHost {
+  readonly events: Readonly<ExtensionAPI["events"]>;
+}
+
+type WorkCommands = Readonly<Pick<ExtensionAPI, "registerCommand" | "registerShortcut">>;
+const protocolVersion = 1,
+  initialRevision = 0;
+
+interface WorkContext extends TodoContext {
+  readonly sessionManager: TodoContext["sessionManager"] & {
+    readonly getSessionId: () => string;
+    readonly getLeafId: () => string | null;
+  };
+}
+
+/** The identity of one work presenter requesting this provider's snapshot. */
+interface Presenter {
+  readonly presenter: string;
+  readonly request: string;
+  readonly version: typeof protocolVersion;
+}
+
+/**
+ * Checks a presentation request without trusting an extension's event payload.
+ * @param {unknown} value Event payload.
+ * @returns {boolean} Whether the envelope uses the supported protocol.
+ */
+const isPresenter = (value: unknown): value is Presenter =>
+  typeof value === "object" &&
+  value !== null &&
+  "version" in value &&
+  value.version === protocolVersion &&
+  "presenter" in value &&
+  typeof value.presenter === "string" &&
+  "request" in value &&
+  typeof value.request === "string";
+
+/** Publishes validated branch data; presentation claims never write task state. */
+class TodoWork {
+  readonly #host: WorkHost;
+  readonly #presentation: Readonly<TodoPresentation>;
+  #context: WorkContext | undefined;
+  #publisher = "";
+  #revision = initialRevision;
+  #presenter: Presenter | undefined;
+  #claimed = false;
+  #subscriptions: (() => void)[] = [];
+
+  /**
+   * Keeps the event bus and the existing standalone presentation owner.
+   * @param {WorkHost} host Pi event bus and tool ownership.
+   * @param {Readonly<TodoPresentation>} presentation Standalone display owner.
+   */
+  public constructor(host: WorkHost, presentation: Readonly<TodoPresentation>) {
+    this.#host = host;
+    this.#presentation = presentation;
+  }
+
+  /**
+   * Registers view entrypoints with a shared or standalone presentation target.
+   * @param {WorkCommands} commands Pi command registration.
+   */
+  public register(commands: WorkCommands): void {
+    commands.registerShortcut(TODO_SHORTCUT, {
+      description: "Show todo details.",
+      handler: (ctx): void => {
+        this.#toggle(ctx);
+      },
+    });
+    commands.registerCommand("todos", {
+      description: "Show todo details; /todos list prints the full branch list.",
+      handler: async (args, ctx): Promise<void> => {
+        if (ownsTodo(this.#host)) {
+          if (args.trim() === "list" || ctx.mode !== "tui") {
+            show(ctx);
+          } else {
+            this.#toggle(ctx);
+          }
+        }
+      },
+    });
+  }
+
+  /**
+   * Opens the shared view or toggles the existing standalone view.
+   * @param {TodoContext} ctx Current UI and branch.
+   */
+  #toggle(ctx: TodoContext): void {
+    if (!this.open()) {
+      this.#presentation.toggle(this.#host, ctx);
+    }
+  }
+
+  /**
+   * Subscribes only when this extension owns the terminal todo tool.
+   * @param {WorkContext} ctx Current Pi session.
+   */
+  public start(ctx: WorkContext): void {
+    this.stop();
+    if (ctx.mode !== "tui" || !ownsTodo(this.#host)) {
+      return;
+    }
+    this.#context = ctx;
+    this.#publisher = crypto.randomUUID();
+    this.#revision = initialRevision;
+    this.#subscriptions = [
+      this.#host.events.on("oisin.work.request", (value: unknown): void => {
+        if (isPresenter(value)) {
+          this.#presenter = value;
+          if (this.#context !== undefined) {
+            this.publish(this.#context);
+          }
+        }
+      }),
+      this.#host.events.on("oisin.work.claim", (value: unknown): void => {
+        this.#claim(value);
+      }),
+      this.#host.events.on("oisin.work.release", (value: unknown): void => {
+        if (this.#matches(value)) {
+          this.#release();
+        }
+      }),
+    ];
+    this.#host.events.emit("oisin.todo.ready", { publisher: this.#publisher, version: 1 });
+  }
+
+  /**
+   * Publishes the actual branch snapshot after tool or branch changes.
+   * @param {WorkContext} ctx Current Pi session, never a stored file's last entry.
+   */
+  public publish(ctx: WorkContext): void {
+    if (this.#context === undefined || this.#presenter === undefined) {
+      return;
+    }
+    this.#context = ctx;
+    this.#revision += 1;
+    const list = parse(latestSnapshot(ctx.sessionManager.getBranch()));
+    this.#host.events.emit("oisin.todo.snapshot", {
+      branch: ctx.sessionManager.getLeafId(),
+      presenter: this.#presenter.presenter,
+      publisher: this.#publisher,
+      request: this.#presenter.request,
+      revision: this.#revision,
+      session: ctx.sessionManager.getSessionId(),
+      tasks: list.tasks,
+      version: 1,
+    });
+  }
+
+  /**
+   * Requests the read-only Todos view without changing expansion or task state.
+   * @returns {boolean} Whether a shared presenter owns the view.
+   */
+  public open(): boolean {
+    if (!this.#claimed || this.#presenter === undefined) {
+      return false;
+    }
+    this.#host.events.emit("oisin.work.open", {
+      presenter: this.#presenter.presenter,
+      request: this.#presenter.request,
+      version: 1,
+      view: "todos",
+    });
+    return true;
+  }
+
+  /** Releases subscriptions and tells the presenter to discard this provider. */
+  public stop(): void {
+    for (const unsubscribe of this.#subscriptions) {
+      unsubscribe();
+    }
+    this.#subscriptions = [];
+    if (this.#context !== undefined) {
+      this.#host.events.emit("oisin.todo.stop", { publisher: this.#publisher, version: 1 });
+    }
+    this.#release();
+    this.#context = undefined;
+  }
+
+  /**
+   * Accepts only an acknowledgement of the latest published snapshot.
+   * @param {unknown} value Claim envelope.
+   */
+  #claim(value: unknown): void {
+    if (
+      this.#matches(value) &&
+      "publisher" in value &&
+      value.publisher === this.#publisher &&
+      "revision" in value &&
+      value.revision === this.#revision &&
+      this.#context !== undefined
+    ) {
+      this.#claimed = true;
+      this.#presentation.claim(this.#context);
+    }
+  }
+
+  /**
+   * Matches a live presenter, excluding delayed messages from replaced sessions.
+   * @param {unknown} value Event envelope.
+   * @returns {boolean} Whether the envelope belongs to the current presenter.
+   */
+  #matches(value: unknown): value is Presenter {
+    return (
+      isPresenter(value) &&
+      value.presenter === this.#presenter?.presenter &&
+      value.request === this.#presenter.request
+    );
+  }
+
+  /** Restores the standalone display when shared presentation ends. */
+  #release(): void {
+    this.#claimed = false;
+    this.#presenter = undefined;
+    if (this.#context !== undefined) {
+      this.#presentation.release(this.#context);
+    }
+  }
+}
+
+export { TodoWork };
+export type { WorkContext, WorkHost };

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.3.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.3.0",
-    "@oisin-ee/pi-prewalk": "0.3.0",
-    "@oisin-ee/pi-todo": "0.3.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",