@oisin-ee/pi-todo 0.5.1 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @oisin-ee/pi-todo
 
-A `todo` tool for [pi](https://pi.dev). The model keeps one ordered task list for the session. Exactly one task is active.
+A `todo` tool for [pi](https://pi.dev). The model keeps one ordered list of outcomes and bounded subtasks for the session. Multiple units can be active together.
 The list rules run in Rust, compiled to WebAssembly.
 
 ```bash
@@ -13,22 +13,60 @@ To install it with the other packages, use [`@oisin-ee/oisinpi`](https://www.npm
 
 The model calls `todo` with one `op`. Tasks are addressed by their exact content.
 
-| `op`     | Effect                                                       |
-| -------- | ------------------------------------------------------------ |
-| `init`   | Replaces the list with `items`.                              |
-| `append` | Adds `items` to the end.                                     |
-| `start`  | Makes `task` the active task.                                |
-| `done`   | Completes `task`. Without `task`, completes every open task. |
-| `drop`   | Abandons `task`. Without `task`, abandons every open task.   |
-| `view`   | Returns the list. It does not change it.                     |
+| `op`     | Effect                                                          |
+| -------- | --------------------------------------------------------------- |
+| `init`   | Replaces the list with `items`.                                 |
+| `append` | Adds `items` to the end.                                        |
+| `start`  | Explicitly activates `task` without demoting other active work. |
+| `done`   | Completes `task`. Without `task`, completes every open task.    |
+| `drop`   | Abandons `task`. Without `task`, abandons every open task.      |
+| `view`   | Returns the list. It does not change it.                        |
 
-When the active task closes, the next open task starts. An empty task, a repeated task, or an unknown task is an error,
-and the list stays as it was.
+Creation and append leave tasks pending. Nothing starts automatically. This replaces the previous single-active, automatic-start behavior.
+Use `start` to activate or reopen work explicitly. Starting a child also opens its parent. Starting a parent does not start its children.
+
+`items` accepts strings or outcomes with string subtasks:
+
+```json
+{
+  "op": "init",
+  "items": [
+    {
+      "content": "Password reset",
+      "subtasks": ["Implement tokens and behavior tests", "Implement form and interaction tests"]
+    },
+    "Update documentation"
+  ]
+}
+```
+
+To target a child, supply its exact `task` content and its exact root `parent` content:
+
+```json
+{ "op": "start", "parent": "Password reset", "task": "Implement tokens and behavior tests" }
+```
+
+To add children, use `append` with `parent` and string `items`. Only two levels are permitted.
+Root names are unique. Child names are unique within their parent. Different parents can use the same child name.
+Blank names, duplicate siblings, unknown targets, grandchildren, and malformed requests fail without saving a change.
+
+Each executable unit fits one agent session, with one deliverable, clear scope, and an acceptance condition.
+Split independent outcomes or work that needs another session. Combine trivial steps with their deliverable and tests.
+Delegate independent units separately. The lead can execute one unit. Keep dependent units ordered.
+Do not delegate an oversized parent as one assignment.
+
+A parent stays open after its children close and shows **Ready for review**.
+Complete the parent explicitly after integration review. Completing a parent with open children fails, including bulk completion.
+Dropping a parent abandons open children but preserves completed and abandoned children.
+Untargeted `done` and `drop` affect open work only. A parent without `task` is not a bulk-child selector.
+Appending children to a closed parent reopens it as pending. An active parent stays active.
+Outcome and subtask progress remain separate. Abandoned work never counts as completed.
 
 ## State
 
 Each task change is saved as a `todo-state` entry on the session branch. A resumed session, a `/tree` move,
 and calls made from inside codemode all see the list of the current branch.
+Old flat snapshots retain their recorded statuses and read with empty subtasks.
 
 ## Widget
 
@@ -45,12 +83,15 @@ 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`.
+Tasks remain on the current Pi session branch. Wrangle receives a read-only presentation capability through `pi.events`.
+Pi-todo owns the renderer in both standalone and shared views. Wrangle hosts it above the editor without opening a popup.
+Alt+J/K scrolls the hosted rows. Alt+I toggles their expansion. Ordinary editor keys remain unchanged.
 `/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)
+The [version 2 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.
+Incompatible versions leave the standalone widget available. Rendering failures restore it without changing saved tasks.
 
 ## Plannotator plans
 
@@ -74,7 +115,8 @@ Malformed events, a different working directory, or another owner of the `todo`
 
 ## Reminder
 
-When the agent stops with open tasks, pi-todo adds a hidden reminder that lists them and continues the turn.
+When the agent stops with open tasks, pi-todo adds a hidden reminder and continues the turn.
+The reminder names open children and parents that await integration review.
 It sends at most 3 reminders per user message. After a reminder, it waits for the list to change before it sends
 another. A new user message resets the count.
 
@@ -84,7 +126,7 @@ If another package already registers `todo`, pi-todo stays inactive and shows a
 
 ## Source
 
-The operations, the active-task rule, and the reminder follow
+The original flat operations and the reminder derive from
 [oh-my-pi](https://github.com/can1357/oh-my-pi/tree/e7fe318/packages/coding-agent/src) (`tools/todo`,
 `todo-tracker.ts`), MIT. Saving a custom entry on every change follows
 [rpiv-todo](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo).

package/package.json

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

package/src/display.ts

@@ -0,0 +1,62 @@
+import type { Subtask, TodoList } from "./wasm.ts";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { TodoView } from "./embedded.ts";
+import { view } from "./wasm.ts";
+
+/** Host-owned layout and rendering services for an inline todo view. */
+interface ViewHost {
+  readonly theme: Readonly<Pick<Theme, "fg" | "bold">>;
+  readonly height: () => number;
+  readonly requestRender: () => void;
+}
+
+/** A provider-owned view. The host forwards updates without interpreting state. */
+interface HostedView {
+  readonly render: (width: number) => string[];
+  readonly handleInput: (input: string) => void;
+  readonly invalidate: () => void;
+  readonly update: (state: unknown) => void;
+  readonly dispose: () => void;
+}
+
+/** Transient presentation data, never persisted in a session entry. */
+interface TodoDisplay {
+  readonly empty: boolean;
+  readonly summary: string;
+  readonly current: string;
+  readonly text: string;
+  readonly state: unknown;
+  readonly createView: (host: ViewHost) => HostedView;
+}
+
+const emptyCount = 0,
+  headerIndex = 0,
+  /**
+   * Projects the core's summary and supplies its reusable renderer.
+   * @param {TodoList} list The validated current branch snapshot.
+   * @returns {TodoDisplay} An in-process presentation capability.
+   */
+  display = (list: TodoList): TodoDisplay => {
+    const text = view(list),
+      active = list.tasks.flatMap((task) => [
+        ...(task.status === "in_progress" ? [task.content] : []),
+        ...(task.subtasks ?? [])
+          .filter((child: Readonly<Subtask>) => child.status === "in_progress")
+          .map((child: Readonly<Subtask>) => `${task.content} → ${child.content}`),
+      ]),
+      current =
+        active.length > emptyCount
+          ? active.join("; ")
+          : (list.tasks.find((task) => task.status === "pending")?.content ?? "");
+    return {
+      createView: (host) => new TodoView(list, host),
+      current,
+      empty: list.tasks.length === emptyCount,
+      state: list,
+      summary: text.split("\n").at(headerIndex) ?? "",
+      text,
+    };
+  };
+
+export { display };
+export type { HostedView, TodoDisplay, ViewHost };

package/src/embedded.ts

@@ -0,0 +1,105 @@
+import { Key, ScrollView, matchesKey } from "@earendil-works/pi-tui";
+import { parse, widget } from "./wasm.ts";
+import type { TodoList } from "./wasm.ts";
+import { TodoWidget } from "./widget.ts";
+import type { ViewHost } from "./display.ts";
+
+const minimumHeight = 1,
+  previousLine = -1,
+  nextLine = 1;
+
+/** Inline viewport over the same renderer used by the standalone widget. */
+class TodoView {
+  readonly #host: ViewHost;
+  #list: TodoList;
+  #expanded = true;
+  #disposed = false;
+  readonly #body: TodoWidget;
+  readonly #scroll: ScrollView;
+
+  /**
+   * Creates an expansion-local view without event subscriptions or task writes.
+   * @param {TodoList} list Validated branch tasks.
+   * @param {ViewHost} host Host layout and rendering services.
+   */
+  public constructor(list: TodoList, host: ViewHost) {
+    this.#host = host;
+    this.#list = list;
+    this.#body = this.#content();
+    this.#scroll = new ScrollView(this.#body, { overscroll: "contain", scrollbar: "hidden" });
+  }
+
+  /**
+   * Creates the shared widget content.
+   * @returns {TodoWidget} Theme-aware rows.
+   */
+  #content(): TodoWidget {
+    const body = new TodoWidget(
+      widget(this.#list, this.#expanded) ?? [],
+      this.#expanded,
+      this.#host.theme,
+    );
+    body.setShortcut("Alt+I");
+    return body;
+  }
+
+  /**
+   * Applies a provider snapshot while preserving the viewport.
+   * @param {unknown} state The opaque state from the display capability.
+   */
+  public update(state: unknown): void {
+    if (!this.#disposed) {
+      this.#list = parse(state);
+      this.#body.setRows(widget(this.#list, this.#expanded) ?? [], this.#expanded);
+      this.invalidate();
+    }
+  }
+
+  /**
+   * Renders a bounded, scrollable view with the active host theme.
+   * @param {number} width Available terminal columns.
+   * @returns {string[]} Visible terminal lines.
+   */
+  public render(width: number): string[] {
+    if (this.#disposed) {
+      return [];
+    }
+    const height = Math.max(minimumHeight, this.#host.height());
+    this.#scroll.updateLayout(this.#body.render(width).length, height, this.#host.requestRender);
+    return this.#scroll
+      .render(width)
+      .slice(this.#scroll.scrollTop, this.#scroll.scrollTop + height);
+  }
+
+  /**
+   * Handles only navigation forwarded by the inline host.
+   * @param {string} input A translated host shortcut.
+   */
+  public handleInput(input: string): void {
+    if (this.#disposed) {
+      return;
+    }
+    if (matchesKey(input, Key.enter)) {
+      this.#expanded = !this.#expanded;
+      this.#body.setRows(widget(this.#list, this.#expanded) ?? [], this.#expanded);
+    } else if (matchesKey(input, Key.up)) {
+      this.#scroll.scrollBy(previousLine);
+    } else if (matchesKey(input, Key.down)) {
+      this.#scroll.scrollBy(nextLine);
+    }
+    this.#host.requestRender();
+  }
+
+  /** Invalidates both native components after a theme or data change. */
+  public invalidate(): void {
+    this.#body.invalidate();
+    this.#scroll.invalidate();
+  }
+
+  /** Ends this view's lifetime without modifying task state. */
+  public dispose(): void {
+    this.#disposed = true;
+  }
+}
+
+export { TodoView };

package/src/generated/todo_core.d.ts

@@ -1,5 +1,13 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * A leaf work unit. Grandchildren are not accepted.
+ */
+export interface Subtask {
+    content: string;
+    status: Status;
+}
+
 /**
  * A successful operation; views never persist a snapshot.
  */
@@ -8,6 +16,15 @@ export interface Change {
     persist: boolean;
 }
 
+/**
+ * An outcome, optionally divided into bounded work units.
+ */
+export interface Task {
+    content: string;
+    status: Status;
+    subtasks?: Subtask[];
+}
+
 /**
  * Branch facts supplied to the reminder boundary.
  */
@@ -16,12 +33,13 @@ export interface ReminderHistory {
 }
 
 /**
- * One operation, with task content used as an exact identifier.
+ * Exact task content, scoped by an optional root parent.
  */
 export interface Request {
     op: Operation;
-    items: string[] | undefined;
-    task: string | undefined;
+    items?: readonly Item[] | undefined;
+    task?: string | undefined;
+    parent?: string | undefined;
 }
 
 /**
@@ -33,17 +51,14 @@ export interface WidgetRow {
 }
 
 /**
- * One task, addressed by its exact content.
+ * Relevant facts in branch order, including proposed boundary entries.
  */
-export interface Task {
-    content: string;
-    status: Status;
-}
+export type ReminderFact = { kind: "user" } | { kind: "snapshot"; list: TodoList } | { kind: "reminder" };
 
 /**
- * Relevant facts in branch order, including proposed boundary entries.
+ * Root creation accepts standalone outcomes or outcomes with leaf work units.
  */
-export type ReminderFact = { kind: "user" } | { kind: "snapshot"; list: TodoList } | { kind: "reminder" };
+export type Item = string | { content: string; subtasks: readonly string[] };
 
 /**
  * Semantic styling for a terminal row.
@@ -56,7 +71,7 @@ export type WidgetKind = "heading" | "active" | "upcoming" | "done" | "dropped"
 export type Operation = "init" | "start" | "done" | "drop" | "append" | "view";
 
 /**
- * The state of one task.
+ * The state of one outcome or work unit.
  */
 export type Status = "pending" | "in_progress" | "completed" | "abandoned";
 

package/src/guidance.ts

@@ -0,0 +1,8 @@
+/** Shared instructions for creation results, tool calls, and approved plans. */
+const workUnitGuidance =
+  "Size each executable unit for one agent session, with one deliverable, clear scope, and an acceptance condition. " +
+  "Split independent outcomes or work that needs another session. Combine trivial steps with their deliverable and tests. " +
+  "Delegate independent units separately; the lead can execute one unit. Keep dependent units ordered. " +
+  "Do not delegate an oversized parent as one assignment. Close children before explicit parent integration review.";
+
+export { workUnitGuidance };

package/src/index.ts

@@ -7,6 +7,7 @@ import { TodoWork } from "./work.ts";
 import { Type } from "typebox";
 import type { WorkHost } from "./work.ts";
 import { runTodo } from "./tool.ts";
+import { workUnitGuidance } from "./guidance.ts";
 
 type TodoAPI = WorkHost &
   Readonly<
@@ -22,17 +23,34 @@ type TodoAPI = WorkHost &
     >
   >;
 
-const items = Type.Immutable(
-    Type.Array(Type.String(), { description: "For init or append: tasks, in order." }),
+const subtasks = Type.Immutable(Type.Array(Type.String())),
+  outcome = Type.Immutable(
+    Type.Object({ content: Type.String(), subtasks }, { additionalProperties: false }),
+  ),
+  item = Type.Union([Type.String(), outcome]),
+  items = Type.Immutable(
+    Type.Array(item, {
+      description:
+        "Pending outcomes for init/append. With parent, append accepts string work units only. Two levels only.",
+    }),
   ),
   parameters = Type.Object({
     items: Type.Optional(items),
     op: StringEnum(["init", "start", "done", "drop", "append", "view"] as const, {
       description:
-        "init replaces; start selects; done completes; drop abandons; append adds; view reads.",
+        "init replaces; start explicitly activates without demoting others; done completes; drop abandons open work; append adds pending work; view reads.",
     }),
+    parent: Type.Optional(
+      Type.String({
+        description:
+          "Exact root content to target a child. Child start/done/drop also require task.",
+      }),
+    ),
     task: Type.Optional(
-      Type.String({ description: "Exact task content. Omit for done/drop to close all tasks." }),
+      Type.String({
+        description:
+          "Exact task content within parent, or at root. Omit for done/drop to close open roots. Complete children before parents.",
+      }),
     ),
   });
 
@@ -46,8 +64,7 @@ export default function piTodo(pi: TodoAPI): void {
     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.",
+    description: `Keep branch-local outcomes and optional bounded subtasks. Address exact content plus optional parent. Creation is pending. Start explicitly; parallel starts preserve other active work. Parents require explicit integration review after children close. ${workUnitGuidance}`,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const result = runTodo(params, {
         append: (customType, list) => {

package/src/plannotator.ts

@@ -2,6 +2,7 @@ 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";
+import { workUnitGuidance } from "./guidance.ts";
 
 /** The supported Plannotator external-execution event. */
 interface ApprovedPlan {
@@ -41,10 +42,11 @@ const isApprovedPlan = (value: unknown): value is ApprovedPlan =>
       "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.",
+      "Before implementation, represent remaining outcomes with optional bounded subtasks in that list. Use parent plus exact task for child operations.",
+      workUnitGuidance,
       "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 approved work remains, explicitly start its open units with op=start. Independent units can stay active together. Never restart completed work 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({

package/src/tool.ts

@@ -2,11 +2,16 @@ import { STATE_ENTRY, latestSnapshot } from "./state.ts";
 import { apply, parse, view } from "./wasm.ts";
 import type { SessionEntry } from "@earendil-works/pi-coding-agent";
 import type { TodoList } from "./wasm.ts";
+import { workUnitGuidance } from "./guidance.ts";
 
 /** One `todo` call, as the schema in `index.ts` admits it. */
 interface TodoParams {
   readonly op: "init" | "start" | "done" | "drop" | "append" | "view";
-  readonly items?: readonly string[];
+  readonly items?: readonly (
+    | string
+    | { readonly content: string; readonly subtasks: readonly string[] }
+  )[];
+  readonly parent?: string;
   readonly task?: string;
 }
 
@@ -25,10 +30,13 @@ interface TodoResult {
 /**
  * The result for `list`.
  * @param {TodoList} list A valid list.
+ * @param {boolean} creation Whether the call created work.
  * @returns {TodoResult} The summary and the list.
  */
-const result = (list: TodoList): TodoResult => ({
-    content: [{ text: view(list), type: "text" }],
+const result = (list: TodoList, creation: boolean): TodoResult => ({
+    content: [
+      { text: creation ? `${view(list)}\n\n${workUnitGuidance}` : view(list), type: "text" },
+    ],
     details: list,
   }),
   /**
@@ -40,15 +48,11 @@ const result = (list: TodoList): TodoResult => ({
    */
   runTodo = (params: TodoParams, session: TodoSession): TodoResult => {
     const current = parse(latestSnapshot(session.branch())),
-      { list, persist } = apply(current, {
-        items: params.items ? [...params.items] : params.items,
-        op: params.op,
-        task: params.task,
-      });
+      { list, persist } = apply(current, params);
     if (persist) {
       session.append(STATE_ENTRY, list);
     }
-    return result(list);
+    return result(list, params.op === "init" || params.op === "append");
   };
 
 export { runTodo };

package/src/wasm.ts

@@ -26,6 +26,7 @@ export type {
   ReminderFact,
   Request,
   Status,
+  Subtask,
   Task,
   TodoList,
   WidgetKind,

package/src/widget.ts

@@ -16,8 +16,9 @@ const TODO_SHORTCUT = "alt+t",
 
 /** The presentation-only component; task state stays on the session branch. */
 class TodoWidget extends Text {
-  readonly #rows: readonly Readonly<WidgetRow>[];
-  readonly #expanded: boolean;
+  #rows: readonly Readonly<WidgetRow>[];
+  #expanded: boolean;
+  #shortcut = "Alt+T";
   readonly #theme: Readonly<Pick<Theme, "fg" | "bold">>;
 
   /**
@@ -37,6 +38,25 @@ class TodoWidget extends Text {
     this.#theme = theme;
   }
 
+  /**
+   * Updates rows without replacing the host's scrollable component.
+   * @param {readonly Readonly<WidgetRow>[]} rows Updated semantic rows.
+   * @param {boolean} expanded Whether secondary groups are visible.
+   */
+  public setRows(rows: readonly Readonly<WidgetRow>[], expanded: boolean): void {
+    this.#rows = rows;
+    this.#expanded = expanded;
+    this.invalidate();
+  }
+
+  /**
+   * Uses the shortcut owned by the containing surface.
+   * @param {string} shortcut The host's display shortcut.
+   */
+  public setShortcut(shortcut: string): void {
+    this.#shortcut = shortcut;
+  }
+
   /**
    * Wraps all task text with Pi's native terminal component.
    * @param {number} width Available terminal columns.
@@ -48,7 +68,7 @@ class TodoWidget extends Text {
         return row.kind === "active" ? this.#theme.bold(text) : text;
       }),
       action = this.#expanded ? "collapse" : "upcoming / done";
-    lines.push(this.#theme.fg("dim", `Alt+T · ${action}`));
+    lines.push(this.#theme.fg("dim", `${this.#shortcut} · ${action}`));
     this.setText(lines.join("\n"));
     return super.render(width).map((line) => truncateToWidth(line, width));
   }

package/src/work.ts

@@ -3,6 +3,7 @@ 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 { display } from "./display.ts";
 import { latestSnapshot } from "./state.ts";
 import { parse } from "./wasm.ts";
 
@@ -11,7 +12,7 @@ interface WorkHost extends TodoHost {
 }
 
 type WorkCommands = Readonly<Pick<ExtensionAPI, "registerCommand" | "registerShortcut">>;
-const protocolVersion = 1,
+const protocolVersion = 2,
   initialRevision = 0;
 
 interface WorkContext extends TodoContext {
@@ -129,7 +130,10 @@ class TodoWork {
         }
       }),
     ];
-    this.#host.events.emit("oisin.todo.ready", { publisher: this.#publisher, version: 1 });
+    this.#host.events.emit("oisin.todo.ready", {
+      publisher: this.#publisher,
+      version: protocolVersion,
+    });
   }
 
   /**
@@ -145,13 +149,13 @@ class TodoWork {
     const list = parse(latestSnapshot(ctx.sessionManager.getBranch()));
     this.#host.events.emit("oisin.todo.snapshot", {
       branch: ctx.sessionManager.getLeafId(),
+      display: display(list),
       presenter: this.#presenter.presenter,
       publisher: this.#publisher,
       request: this.#presenter.request,
       revision: this.#revision,
       session: ctx.sessionManager.getSessionId(),
-      tasks: list.tasks,
-      version: 1,
+      version: protocolVersion,
     });
   }
 
@@ -166,7 +170,7 @@ class TodoWork {
     this.#host.events.emit("oisin.work.open", {
       presenter: this.#presenter.presenter,
       request: this.#presenter.request,
-      version: 1,
+      version: protocolVersion,
       view: "todos",
     });
     return true;
@@ -179,7 +183,10 @@ class TodoWork {
     }
     this.#subscriptions = [];
     if (this.#context !== undefined) {
-      this.#host.events.emit("oisin.todo.stop", { publisher: this.#publisher, version: 1 });
+      this.#host.events.emit("oisin.todo.stop", {
+        publisher: this.#publisher,
+        version: protocolVersion,
+      });
     }
     this.#release();
     this.#context = undefined;