@hacky.software/opencode-todo-supervisor 0.3.4 → 0.3.5

package/README.md

@@ -4,7 +4,8 @@ An [OpenCode](https://opencode.ai) **V2** plugin that gives every session a real
 todo list — and then keeps the agent working on it. A live progress strip in the
 composer (`📋 ███░░░░░ 8/17 open`) tracks the list.
 
-- `todo_write` / `todo_read` tools (V2 ships none), stored per session;
+- `todo_write` / `todo_read` / `todo_add` / `todo_remove` tools (V2 ships none),
+  stored per session, with stable per-item ids;
 - a **supervisor** that re-prompts an idle session while its list still has open
   items — and stays quiet while the agent is actually working (thinking,
   preparing a tool, a running tool or `task` subagent, background shells, child
@@ -22,7 +23,7 @@ Tested against OpenCode `2.0.24`.
 ## Install
 
 ```sh
-opencode plugin add @hacky.software/opencode-todo-supervisor@0.3.4
+opencode plugin add @hacky.software/opencode-todo-supervisor@0.3.5
 ```
 
 This also loads the bundled TUI entry. To pass options, use the object form:
@@ -77,9 +78,14 @@ and makes finishing it the path of least resistance:
 
 ## Tools
 
-Four tools, all registered with `codemode: true` so Code Mode agents can call
+Six tools, all registered with `codemode: true` so Code Mode agents can call
 them too. Together they are the whole interface the model uses.
 
+Every item has a **stable id** (a number, e.g. `3`), assigned when the item is
+first written and preserved across list rewrites by matching content. Ids are
+shown as `#3` in `todo_read`, in the injected context block, and in the panel,
+and are what `todo_remove` and the panel's remove key take.
+
 ### `todo_write`
 
 Replaces the session's list.
@@ -88,6 +94,7 @@ Replaces the session's list.
 {
   "todos": [
     {
+      "id": "3",
       "content": "string",
       "status": "pending | in_progress | completed | canceled",
       "priority": "high | medium | low"
@@ -96,14 +103,35 @@ Replaces the session's list.
 }
 ```
 
-`content` and `status` are required; `priority` is optional.
+`content` and `status` are required; `id` and `priority` are optional.
 
-- The list **replaces** the previous one — always send the complete list.
+- The list **replaces** the previous one — always send the complete list. Echo
+  each item's `id` to keep it; items without an id are matched to the previous
+  list by content, and anything new gets a fresh id.
 - At most one item may be `in_progress`; extra ones are demoted to `pending` and
   the result says so.
 - Content is trimmed, empty entries dropped, duplicates removed.
-- Returns the summary plus the canonical list, and resets the supervisor's
-  no-progress counter and any pause.
+- Returns the summary plus the canonical list (with ids), and resets the
+  supervisor's no-progress counter and any pause.
+
+### `todo_add`
+
+```json
+{ "content": "string", "priority": "high | medium | low", "status": "pending | …" }
+```
+
+Appends one item without resending the whole list, and returns its new id.
+`content` is required; `priority` and `status` are optional (`pending` by
+default). Adding content that is already on the list returns the existing id
+instead of creating a duplicate.
+
+### `todo_remove`
+
+```json
+{ "id": "3" }
+```
+
+Removes one item by its id.
 
 ### `todo_read`
 
@@ -128,7 +156,7 @@ Same input as `todo_subscribe`. Stops supervising a file, and also shadows a
 
 ## Markdown mode
 
-Subscribe files with `todo_subscribe`, the panel (`a` / `d`), or config. The
+Subscribe files with `todo_subscribe`, the panel (`A` / `D`), or config. The
 effective set is `config.markdownFiles ∪ stored files − removed` per session.
 
 - Conventions: `- [ ]` open, `- [x]`/`- [X]` completed, `- [~]` canceled. `-`,
@@ -147,17 +175,21 @@ effective set is `config.markdownFiles ∪ stored files − removed` per session
 - **Composer strip** (`session.composer.top`): `📋 ███░░░░░ 8/17 open` (plus `⏸`
   while paused), hidden when there is neither a list nor a subscription.
 - **Popover** (`/todos`, palette "Todo: open todos"): a centered overlay dialog.
-  The body is height-bounded (up to 16 rows) so the key legend is always visible;
-  the header shows `open/total` and the selected `row n/m`. `f` cycles the dialog
-  size (medium → large → xlarge), `esc` closes it.
+  Its body and width scale with the terminal (up to 48 rows / a share of the
+  window), so the key legend stays visible on a short terminal and a tall one
+  shows more rows; the header shows `open/total` and the selected `row n/m`. `f`
+  cycles the dialog size (medium → large → xlarge), `esc` closes it.
   - header: progress bar, `open/total`, and a supervision chip (`idle · quiet
     12s · nudges 2`, `working: 1 tool · 1 shell · quiet 4s`, `paused
     (no-progress)`, `not supervised`);
   - body: a `SESSION` section, then one collapsible section per subscribed file
-    (`n open of m`, `(missing)` badge, `:line` refs);
+    (`n open of m`, `(missing)` badge, `:line` refs). Session rows lead with the
+    item's `#id` and a priority column (`high` / `med` / `low`), so both are
+    visible at a glance and columns line up across the list;
   - keys: `↑↓`/`jk` move, `pgup`/`pgdn`, `home`/`end`/`g`/`G`, `space`/`x` toggle
     (session item, markdown item, or collapse a file row), `enter` collapse, `n`
-    nudge now, `s` pause/resume, `a` add file, `d` remove file, `r` refresh, `/`
+    nudge now, `s` pause/resume, `a` add task, `d` remove task (confirmed), `p`
+    cycle a task's priority, `A` add file, `D` remove file, `r` refresh, `/`
     filter, `f` resize, `c` clear (confirm), `?` help, `escape` close;
   - it re-reads every 3 s while open, so edits made outside OpenCode show up
     without waiting for an event.
@@ -188,7 +220,10 @@ Contract id `todo` (`opencode-todo-supervisor/rpc`). The TUI uses
 | `clear` | `{ sessionID }` | Drop the stored list (subscriptions stay) |
 | `nudge` | `{ sessionID }` | Send a nudge now (same dedupe/ownership rules as automatic nudges) |
 | `setEnabled` | `{ sessionID, enabled }` | Per-session supervision kill switch |
-| `toggle` | `{ sessionID, index }` | Flip one session item between completed and pending |
+| `toggle` | `{ sessionID, id }` or `{ sessionID, index }` | Flip one session item between completed and pending |
+| `addItem` | `{ sessionID, content, priority? }` | Append one item; returns its new id |
+| `removeItem` | `{ sessionID, id }` | Remove one session item by id |
+| `setPriority` | `{ sessionID, id, priority }` | Set a priority (`high`/`medium`/`low`) or clear it with `none` |
 | `toggleFile` | `{ sessionID, path, line }` | Toggle a checklist item inside a subscribed markdown file |
 | `subscribe` | `{ sessionID, path }` | Subscribe a markdown file |
 | `unsubscribe` | `{ sessionID, path }` | Shadow a subscription |
@@ -307,12 +342,14 @@ A thin wrapper over `ctx.storage` (durable JSON scoped to the plugin):
 
 | Key | Value |
 | --- | --- |
-| `todos/<sessionID>` | `{ version, sessionID, items[], updatedAt }` |
+| `todos/<sessionID>` | `{ version, sessionID, items[{ id, content, status, priority? }], updatedAt }` |
 | `subs/<sessionID>` | `{ version, sessionID, files[], removed[], updatedAt }` |
 | `claims/<sessionID>` | `{ tag, at }` — hot-reload ownership |
 
 On startup the plugin scans `todos/` and reconciles against `ctx.session.get()`
 (session gone → drop the entry; session alive → register and evaluate once).
+Ids are assigned centrally on every write (and backfilled deterministically when
+loading rows that predate them), so a list read from disk always has ids.
 Supervision counters (nudge counts, no-progress, pause) are in-memory only; a
 restart resets them, which is deliberate and simpler. Sessions are dropped on
 `session.deleted`.
@@ -340,7 +377,7 @@ There is no filesystem watcher. Instead:
   (source edits and config content changes; `touch` alone does not).
 - `opencode2 reload` forces reconciliation; `opencode2 service restart` only as a
   last resort (it interrupts sessions).
-- Tests: `bun test` (106 tests across parser, storage, tools, RPC, state machine,
+- Tests: `bun test` (121 tests across parser, storage, tools, RPC, state machine,
   panel helpers).
 - Watch logs: `tail -f ~/.local/share/opencode/log/todo-supervisor.log`.
 
@@ -348,6 +385,8 @@ There is no filesystem watcher. Instead:
 
 - The TUI panel/keyboard actions and toasts need a running TUI; the strip counts
   refresh on RPC `updated` (i.e. immediately after `todo_write`).
+- The panel adds and removes **session** tasks (`a` / `d`). Markdown items are
+  owned by their file: toggle one with `x`/`space`, edit the file to remove it.
 - Markdown write-back edits your files: `x` on a markdown row rewrites that
   checkbox in place (temp file + atomic rename, only for subscribed paths). Use
   the panel filter and `d` if you only want to read.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hacky.software/opencode-todo-supervisor",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "OpenCode V2 plugin that gives every session a todo list (todo_write/todo_read), supervises idle sessions until the list is done, and can drive checklists in markdown files from a TUI panel.",
   "type": "module",
   "license": "MIT",

package/src/panel.test.ts

@@ -6,9 +6,12 @@ import {
   countOpen,
   dialogWidth,
   footerHints,
+  idTag,
   isSelectable,
+  itemColumns,
   moveCursor,
   popoverBodyHeight,
+  priorityTag,
   progressBar,
   quietLabel,
   statusMark,
@@ -20,9 +23,9 @@ import {
 
 const snapshot = (): PanelSnapshot => ({
   items: [
-    { content: "first task", status: "pending", priority: "high" },
-    { content: "second task", status: "in_progress" },
-    { content: "third task", status: "completed" },
+    { id: "1", content: "first task", status: "pending", priority: "high" },
+    { id: "2", content: "second task", status: "in_progress" },
+    { id: "3", content: "third task", status: "completed" },
   ],
   files: [
     {
@@ -104,6 +107,7 @@ describe("panel rows", () => {
     expect(sessionHeader.kind === "section" && sessionHeader.detail).toBe("2 open of 3")
     const firstItem = rows[1]!
     expect(firstItem.kind === "item" && firstItem.key).toBe("session:0")
+    expect(firstItem.kind === "item" && firstItem.id).toBe("1")
     expect(firstItem.kind === "item" && firstItem.priority).toBe("high")
     const fileRow = rows[4]!
     expect(fileRow.kind === "file" && fileRow.open).toBe(1)
@@ -168,26 +172,43 @@ describe("panel cursor", () => {
   })
 
   test("footer hints shrink with the terminal width", () => {
-    expect(footerHints(140).length).toBe(13)
+    expect(footerHints(140).length).toBe(16)
+    expect(footerHints(140)).toContain("a add task")
+    expect(footerHints(140)).toContain("p priority")
     expect(footerHints(90).length).toBe(8)
     expect(footerHints(40)).toEqual(["↑↓", "space toggle", "n nudge", "/ filter", "? help", "esc"])
   })
 
-  test("popover body height stays a popover on any terminal", () => {
-    expect(popoverBodyHeight(40)).toBe(16)
-    expect(popoverBodyHeight(24)).toBe(14)
-    expect(popoverBodyHeight(24, 1)).toBe(13)
-    expect(popoverBodyHeight(14)).toBe(4)
-    expect(popoverBodyHeight(50, 2)).toBe(16)
+  test("popover body height scales with the terminal", () => {
+    expect(popoverBodyHeight(40)).toBe(28)
+    expect(popoverBodyHeight(24)).toBe(16)
+    expect(popoverBodyHeight(24, 1)).toBe(15)
+    expect(popoverBodyHeight(14)).toBe(6)
+    expect(popoverBodyHeight(50, 2)).toBe(35)
+    // Never taller than a popover on a very tall terminal.
+    expect(popoverBodyHeight(200)).toBe(48)
   })
 
   test("popover width follows the dialog size and clamps", () => {
-    expect(dialogWidth("medium", 200)).toBe(72)
-    expect(dialogWidth("large", 200)).toBe(140)
-    expect(dialogWidth("xlarge", 200)).toBe(140)
-    expect(dialogWidth("medium", 80)).toBe(56)
+    expect(dialogWidth("medium", 200)).toBe(120)
+    expect(dialogWidth("large", 200)).toBe(160)
+    expect(dialogWidth("xlarge", 200)).toBe(180)
+    expect(dialogWidth("medium", 80)).toBe(48)
     expect(dialogWidth("large", 80)).toBe(64)
-    expect(dialogWidth("xlarge", 80)).toBe(72)
+    expect(dialogWidth("xlarge", 80)).toBe(76)
     expect(dialogWidth("xlarge", 20)).toBe(36)
+    // xlarge tracks the window instead of a fixed cap.
+    expect(dialogWidth("xlarge", 120)).toBe(114)
+  })
+
+  test("id and priority tags and their column widths", () => {
+    expect(idTag(undefined)).toBe("")
+    expect(idTag("12")).toBe("#12")
+    expect(priorityTag(undefined)).toBe("")
+    expect(priorityTag("high")).toBe("high")
+    expect(priorityTag("medium")).toBe("med")
+    expect(priorityTag("low")).toBe("low")
+    expect(itemColumns([{ id: "3", priority: "high" }, { id: "12" }])).toEqual({ id: 3, priority: 4 })
+    expect(itemColumns([{ content: "x", status: "pending" }])).toEqual({ id: 0, priority: 0 })
   })
 })

package/src/panel.ts

@@ -4,7 +4,7 @@
 // and truncation are unit-tested without an OpenTUI renderer. src/tui.tsx only
 // maps these rows to <text>/<box> elements.
 
-export type PanelItem = { content: string; status: string; priority?: string }
+export type PanelItem = { id?: string; content: string; status: string; priority?: string }
 export type PanelFileItem = { content: string; status: string; line?: number }
 export type PanelFile = { path: string; exists: boolean; items: PanelFileItem[] }
 
@@ -47,6 +47,7 @@ export type Row =
       kind: "item"
       key: string
       source: "session" | "file"
+      id?: string
       content: string
       status: string
       priority?: string
@@ -69,6 +70,29 @@ export function statusMark(status: string): string {
   return "[ ]"
 }
 
+/** `#3` for a session item (empty when the item has no id / is a file item). */
+export function idTag(id: string | undefined): string {
+  return id ? `#${id}` : ""
+}
+
+/** Short priority word for a fixed-width column: `high` / `med` / `low` / ``. */
+export function priorityTag(priority: string | undefined): string {
+  if (priority === "high") return "high"
+  if (priority === "medium") return "med"
+  if (priority === "low") return "low"
+  return ""
+}
+
+/**
+ * Width of the `#id` and priority columns for a list, so rows line up. Returns
+ * 0 for a column when no item in the list uses it (keeps narrow lists compact).
+ */
+export function itemColumns(items: readonly { id?: string; priority?: string }[]): { id: number; priority: number } {
+  const id = items.reduce((max, item) => Math.max(max, idTag(item.id).length), 0)
+  const priority = items.reduce((max, item) => Math.max(max, priorityTag(item.priority).length), 0)
+  return { id, priority }
+}
+
 export function countOpen(items: readonly { status: string }[]): number {
   return items.filter((item) => item.status !== "completed").length
 }
@@ -153,6 +177,7 @@ export function buildRows(snapshot: PanelSnapshot, options: BuildOptions = {}):
         key: `session:${index}`,
         source: "session",
         index,
+        id: item.id,
         content: item.content,
         status: item.status,
         priority: item.priority,
@@ -249,8 +274,11 @@ export function footerHints(width: number): string[] {
     "enter collapse",
     "n nudge",
     "s pause",
-    "a add",
-    "d remove",
+    "a add task",
+    "d remove task",
+    "p priority",
+    "A add file",
+    "D remove file",
     "r refresh",
     "/ filter",
     "f size",
@@ -265,25 +293,28 @@ export function footerHints(width: number): string[] {
 
 /**
  * Rows the popover list body may occupy. The dialog hugs its content, so the
- * body must be bounded or the overlay grows to the whole screen; the cap keeps
- * it a popover and leaves room for the header and the key legend. `extraRows`
- * accounts for conditional chrome (e.g. the filter line).
+ * body must be bounded or the overlay grows to the whole screen; the budget
+ * scales with the terminal (a taller window gets a taller popover) and is
+ * capped so it stays a popover. `extraRows` accounts for conditional chrome
+ * (e.g. the filter line).
  */
 export function popoverBodyHeight(viewportHeight: number, extraRows = 0): number {
   const total = Math.max(10, viewportHeight)
-  return Math.max(4, Math.min(total - 10 - Math.max(0, extraRows), 16))
+  const cap = Math.max(8, Math.min(48, Math.floor(total * 0.7)))
+  return Math.max(4, Math.min(total - 8 - Math.max(0, extraRows), cap))
 }
 
 export type DialogSizeName = "medium" | "large" | "xlarge"
 
+const DIALOG_FACTOR: Record<DialogSizeName, number> = { medium: 0.6, large: 0.8, xlarge: 0.95 }
+
 /**
- * Content width for the popover dialog. The host owns the dialog box, so the
- * list sizes its rows from the render region instead and clamps for small
- * terminals (a wider dialog just shows more of each row).
+ * Content width for the popover dialog, as a fraction of the terminal width so
+ * it scales with the window (`medium` 60%, `large` 80%, `xlarge` 95%), clamped
+ * for small terminals and capped so it never spans an ultrawide screen.
  */
 export function dialogWidth(size: DialogSizeName, viewportWidth: number): number {
   const total = Math.max(40, viewportWidth)
-  const bySize =
-    size === "xlarge" ? total - 8 : size === "large" ? total - 16 : Math.min(72, Math.max(48, total - 24))
-  return Math.max(36, Math.min(bySize, 140))
+  const target = Math.round(total * DIALOG_FACTOR[size])
+  return Math.max(36, Math.min(target, total - 4, 180))
 }

package/src/rpc.test.ts

@@ -81,10 +81,13 @@ describe("RPC contract (§5.6)", () => {
   test("contract exposes all methods and events", () => {
     expect(TodoRpc.id).toBe("todo")
     expect(Object.keys(TodoRpc.methods).sort()).toEqual([
+      "addItem",
       "clear",
       "list",
       "nudge",
+      "removeItem",
       "setEnabled",
+      "setPriority",
       "subscribe",
       "toggle",
       "toggleFile",
@@ -149,6 +152,54 @@ describe("RPC contract (§5.6)", () => {
     await expect(w.handlers.toggle!({ sessionID: "s1", index: 9 })).rejects.toThrow(/range/)
   })
 
+  test("toggle by id finds the item and reports its id", async () => {
+    const w = await setup([
+      { id: "1", content: "one", status: "pending" },
+      { id: "2", content: "two", status: "pending" },
+    ])
+    const result = (await w.handlers.toggle!({ sessionID: "s1", id: "2" })) as Record<string, unknown>
+    expect(result).toMatchObject({ id: "2", index: 1, status: "completed" })
+    expect(w.todos.get("s1")![1]!.status).toBe("completed")
+    await expect(w.handlers.toggle!({ sessionID: "s1", id: "9" })).rejects.toThrow(/no item with id/)
+    await expect(w.handlers.toggle!({ sessionID: "s1" })).rejects.toThrow(/index/)
+  })
+
+  test("addItem appends a pending item with a fresh id and emits updated", async () => {
+    const w = await setup([{ id: "1", content: "one", status: "pending" }])
+    const result = (await w.handlers.addItem!({ sessionID: "s1", content: "  two  ", priority: "high" })) as Record<
+      string,
+      unknown
+    >
+    expect(result).toMatchObject({ id: "2", content: "two", priority: "high" })
+    expect(w.todos.get("s1")!.map((item) => [item.id, item.content, item.status, item.priority])).toEqual([
+      ["1", "one", "pending", undefined],
+      ["2", "two", "pending", "high"],
+    ])
+    expect(w.calls.filter((call) => call === "changed s1").length).toBe(1)
+    expect(w.emitted.filter((event) => event.name === "updated").length).toBe(1)
+    await expect(w.handlers.addItem!({ sessionID: "s1", content: "   " })).rejects.toThrow(/content/)
+  })
+
+  test("removeItem drops the item by id and rejects unknown ids", async () => {
+    const w = await setup([
+      { id: "1", content: "one", status: "pending" },
+      { id: "2", content: "two", status: "pending" },
+    ])
+    await w.handlers.removeItem!({ sessionID: "s1", id: "1" })
+    expect(w.todos.get("s1")!.map((item) => item.id)).toEqual(["2"])
+    await expect(w.handlers.removeItem!({ sessionID: "s1", id: "9" })).rejects.toThrow(/no item with id/)
+  })
+
+  test("setPriority sets and clears a priority", async () => {
+    const w = await setup([{ id: "1", content: "one", status: "pending" }])
+    await w.handlers.setPriority!({ sessionID: "s1", id: "1", priority: "high" })
+    expect(w.todos.get("s1")![0]!.priority).toBe("high")
+    await w.handlers.setPriority!({ sessionID: "s1", id: "1", priority: "none" })
+    expect(w.todos.get("s1")![0]!.priority).toBeUndefined()
+    await expect(w.handlers.setPriority!({ sessionID: "s1", id: "1", priority: "urgent" })).rejects.toThrow(/priority/)
+    await expect(w.handlers.setPriority!({ sessionID: "s1", id: "9", priority: "low" })).rejects.toThrow(/no item with id/)
+  })
+
   test("toggleFile rewrites a subscribed file, refuses other paths and notifies", async () => {
     const dir = "/tmp/opencode"
     mkdirSync(dir, { recursive: true })

package/src/rpc.ts

@@ -10,7 +10,7 @@ import type { Plugin } from "@opencode/plugin"
 import { Rpc } from "@opencode/plugin/rpc"
 import { effectiveFiles, MarkdownCache, resolveMarkdownPath, toggleMarkdownItem } from "./markdown"
 import type { Options } from "./options"
-import type { TodoStore } from "./storage"
+import { nextId, type TodoItem, type TodoStore } from "./storage"
 import type { Supervisor } from "./supervisor"
 
 // Kept for consumers/tests that import the resolver from the RPC module.
@@ -55,8 +55,46 @@ export const TodoRpc = Rpc.define({
     toggle: {
       input: {
         type: "object",
-        properties: { sessionID: { type: "string" }, index: { type: "number" } },
-        required: ["sessionID", "index"],
+        properties: { sessionID: { type: "string" }, id: { type: "string" }, index: { type: "number" } },
+        required: ["sessionID"],
+        additionalProperties: false,
+      } as const,
+      output: objectOutput,
+    },
+    /** Append one item to the session list; returns its new id. */
+    addItem: {
+      input: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          content: { type: "string" },
+          priority: { type: "string", enum: ["high", "medium", "low"] },
+        },
+        required: ["sessionID", "content"],
+        additionalProperties: false,
+      } as const,
+      output: objectOutput,
+    },
+    /** Remove one session item by id. */
+    removeItem: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" }, id: { type: "string" } },
+        required: ["sessionID", "id"],
+        additionalProperties: false,
+      } as const,
+      output: objectOutput,
+    },
+    /** Set one item's priority (or clear it with `none`). */
+    setPriority: {
+      input: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          id: { type: "string" },
+          priority: { type: "string", enum: ["high", "medium", "low", "none"] },
+        },
+        required: ["sessionID", "id", "priority"],
         additionalProperties: false,
       } as const,
       output: objectOutput,
@@ -217,18 +255,89 @@ export async function registerTodoRpc(ctx: Plugin.Context, deps: RpcDeps): Promi
     toggle: async (raw) => {
       const input = requireObject(raw)
       const sessionID = requireString(input.sessionID, "sessionID")
-      const index = requireNumber(input.index, "index")
       const state = await store.refreshTodos(sessionID)
       const items = state?.items ?? []
-      const item = items[index]
-      if (!item) throw new Error(`invalid input: "index" ${index} is out of range`)
+      let index: number
+      if (input.id !== undefined) {
+        const id = requireString(input.id, "id")
+        index = items.findIndex((item) => item.id === id)
+        if (index === -1) throw new Error(`invalid input: no item with id ${JSON.stringify(id)}`)
+      } else {
+        index = requireNumber(input.index, "index")
+        if (!items[index]) throw new Error(`invalid input: "index" ${index} is out of range`)
+      }
+      const item = items[index]!
       const status: "pending" | "completed" = item.status === "completed" ? "pending" : "completed"
       const next = items.map((entry, i) => (i === index ? { ...entry, status } : entry))
       await store.setTodos(sessionID, next)
       supervisor.notifyTodosChanged(sessionID)
       await emitEvent("updated", { sessionID })
-      log(`rpc toggle (${sessionID}) index=${index} → ${status}`)
-      return { sessionID, index, status }
+      log(`rpc toggle (${sessionID}) ${item.id ? `#${item.id}` : `index ${index}`} → ${status}`)
+      return { sessionID, index, id: item.id, status }
+    },
+    addItem: async (raw) => {
+      const input = requireObject(raw)
+      const sessionID = requireString(input.sessionID, "sessionID")
+      const content = requireString(input.content, "content").trim()
+      const priority =
+        input.priority === "high" || input.priority === "medium" || input.priority === "low"
+          ? input.priority
+          : undefined
+      const state = await store.refreshTodos(sessionID)
+      const items = state?.items ?? []
+      const item: TodoItem = { id: nextId(items), content, status: "pending" }
+      if (priority) item.priority = priority
+      const saved = await store.setTodos(sessionID, [...items, item])
+      supervisor.notifyTodosChanged(sessionID)
+      await emitEvent("updated", { sessionID })
+      const added = saved.items[saved.items.length - 1]!
+      log(`rpc addItem (${sessionID}) #${added.id} ${content}`)
+      return { sessionID, id: added.id, content, priority: added.priority ?? null }
+    },
+    removeItem: async (raw) => {
+      const input = requireObject(raw)
+      const sessionID = requireString(input.sessionID, "sessionID")
+      const id = requireString(input.id, "id")
+      const state = await store.refreshTodos(sessionID)
+      const items = state?.items ?? []
+      if (!items.some((item) => item.id === id)) {
+        throw new Error(`invalid input: no item with id ${JSON.stringify(id)}`)
+      }
+      await store.setTodos(
+        sessionID,
+        items.filter((item) => item.id !== id),
+      )
+      supervisor.notifyTodosChanged(sessionID)
+      await emitEvent("updated", { sessionID })
+      log(`rpc removeItem (${sessionID}) #${id}`)
+      return { sessionID, id }
+    },
+    setPriority: async (raw) => {
+      const input = requireObject(raw)
+      const sessionID = requireString(input.sessionID, "sessionID")
+      const id = requireString(input.id, "id")
+      const priority = input.priority
+      if (priority !== "high" && priority !== "medium" && priority !== "low" && priority !== "none") {
+        throw new Error('invalid input: "priority" must be high, medium, low or none')
+      }
+      const state = await store.refreshTodos(sessionID)
+      const items = state?.items ?? []
+      if (!items.some((item) => item.id === id)) {
+        throw new Error(`invalid input: no item with id ${JSON.stringify(id)}`)
+      }
+      const next = items.map((item) => {
+        if (item.id !== id) return item
+        if (priority === "none") {
+          const { priority: _dropped, ...rest } = item
+          return rest
+        }
+        return { ...item, priority }
+      })
+      await store.setTodos(sessionID, next)
+      supervisor.notifyTodosChanged(sessionID)
+      await emitEvent("updated", { sessionID })
+      log(`rpc setPriority (${sessionID}) #${id} → ${priority}`)
+      return { sessionID, id, priority: priority === "none" ? null : priority }
     },
     toggleFile: async (raw) => {
       const input = requireObject(raw)

package/src/storage.test.ts

@@ -1,7 +1,10 @@
 import { describe, expect, test } from "bun:test"
 import {
+  assignIds,
   hashList,
   isDone,
+  maxId,
+  nextId,
   openItems,
   TodoStore,
   type StorageLike,
@@ -34,7 +37,7 @@ export class FakeStorage implements StorageLike {
 }
 
 const items = (n: number): TodoItem[] =>
-  Array.from({ length: n }, (_, i) => ({ content: `task ${i}`, status: "pending" as const }))
+  Array.from({ length: n }, (_, i) => ({ id: String(i + 1), content: `task ${i}`, status: "pending" as const }))
 
 describe("TodoStore", () => {
   test("round-trips items identically in order", async () => {
@@ -98,4 +101,56 @@ describe("helpers", () => {
     expect(hashList(a)).toBe(hashList(b))
     expect(hashList(a)).not.toBe(hashList([{ content: "a", status: "completed", priority: "high" }]))
   })
+
+  test("hashList ignores ids (renumbering is not a content change)", () => {
+    const withA: TodoItem[] = [{ id: "1", content: "a", status: "pending" }]
+    const withB: TodoItem[] = [{ id: "9", content: "a", status: "pending" }]
+    expect(hashList(withA)).toBe(hashList(withB))
+  })
+})
+
+describe("stable ids", () => {
+  test("assignIds numbers a fresh list and is stable", () => {
+    const first = assignIds([{ content: "a", status: "pending" }, { content: "b", status: "pending" }])
+    expect(first.map((item) => item.id)).toEqual(["1", "2"])
+    // Re-running over its own output changes nothing.
+    expect(assignIds(first)).toEqual(first)
+  })
+
+  test("assignIds preserves ids across a content rewrite, matching by content", () => {
+    const previous = assignIds([{ content: "a", status: "pending" }, { content: "b", status: "pending" }])
+    const rewritten = assignIds([{ content: "b", status: "completed" }, { content: "c", status: "pending" }], previous)
+    expect(rewritten).toEqual([
+      { id: "2", content: "b", status: "completed" },
+      { id: "3", content: "c", status: "pending" },
+    ])
+  })
+
+  test("assignIds keeps explicit ids and never reuses a freed one immediately", () => {
+    const previous: TodoItem[] = [{ id: "1", content: "a", status: "pending" }]
+    const explicit = assignIds([{ id: "7", content: "z", status: "pending" }], previous)
+    expect(explicit[0]!.id).toBe("7")
+
+    // ids continue above the highest ever used, even after removals.
+    const grown = assignIds([{ content: "fresh", status: "pending" }], [{ id: "5", content: "gone", status: "completed" }])
+    expect(grown[0]!.id).toBe("6")
+  })
+
+  test("maxId / nextId", () => {
+    expect(maxId([])).toBe(0)
+    expect(maxId([{ content: "a", status: "pending" }, { id: "4", content: "b", status: "pending" }])).toBe(4)
+    expect(nextId([{ id: "4", content: "b", status: "pending" }])).toBe("5")
+  })
+
+  test("the store backfills ids for legacy rows", async () => {
+    const storage = new FakeStorage()
+    await storage.set("todos/legacy", {
+      version: 1,
+      sessionID: "legacy",
+      items: [{ content: "one", status: "pending" }, { content: "two", status: "pending" }],
+      updatedAt: 0,
+    })
+    const store = new TodoStore(storage)
+    expect((await store.loadTodos("legacy"))?.items.map((item) => item.id)).toEqual(["1", "2"])
+  })
 })

package/src/storage.ts

@@ -10,6 +10,14 @@ export type TodoStatus = "pending" | "in_progress" | "completed" | "canceled"
 export type TodoPriority = "high" | "medium" | "low"
 
 export type TodoItem = {
+  /**
+   * Stable per-session identifier (a numeric string, e.g. `"3"`), assigned by
+   * the store when an item is first written and preserved across full-list
+   * rewrites by matching content. Optional in the type so callers and tests can
+   * build ad-hoc items; anything reaching storage is normalised by
+   * {@link assignIds}.
+   */
+  id?: string
   content: string
   status: TodoStatus
   priority?: TodoPriority
@@ -54,6 +62,7 @@ export function parseTodoState(value: unknown): TodoState | undefined {
     const status = entry.status
     if (status !== "pending" && status !== "in_progress" && status !== "completed" && status !== "canceled") continue
     const item: TodoItem = { content: entry.content, status }
+    if (typeof entry.id === "string" && entry.id !== "") item.id = entry.id
     if (entry.priority === "high" || entry.priority === "medium" || entry.priority === "low") {
       item.priority = entry.priority
     }
@@ -62,7 +71,8 @@ export function parseTodoState(value: unknown): TodoState | undefined {
   return {
     version: 1,
     sessionID: value.sessionID,
-    items,
+    // Legacy rows predate ids; backfill them deterministically on load.
+    items: assignIds(items),
     updatedAt: typeof value.updatedAt === "number" ? value.updatedAt : 0,
   }
 }
@@ -113,7 +123,10 @@ export class TodoStore {
   }
 
   async setTodos(sessionID: string, items: TodoItem[]): Promise<TodoState> {
-    const state: TodoState = { version: 1, sessionID, items, updatedAt: Date.now() }
+    // Central id assignment: every stored list has stable ids, and a rewrite
+    // that keeps an item's content keeps its id (see assignIds).
+    const previous = this.todos.get(sessionID)?.items ?? []
+    const state: TodoState = { version: 1, sessionID, items: assignIds(items, previous), updatedAt: Date.now() }
     await this.storage.set(todosKey(sessionID), state)
     this.todos.set(sessionID, state)
     return state
@@ -184,3 +197,54 @@ export function isDone(items: readonly TodoItem[]): boolean {
 export function hashList(items: readonly TodoItem[]): string {
   return JSON.stringify(items.map((item) => [item.content, item.status, item.priority ?? ""]))
 }
+
+// ---- stable ids (§5.3) ------------------------------------------------------
+
+function numericId(id: string | undefined): number {
+  const value = Number(id)
+  return Number.isInteger(value) && value > 0 ? value : 0
+}
+
+/** Highest numeric id in a list (0 when the list is empty or unnumbered). */
+export function maxId(items: readonly TodoItem[]): number {
+  return items.reduce((max, item) => Math.max(max, numericId(item.id)), 0)
+}
+
+/** Next free id for a list (one above the highest id ever used). */
+export function nextId(items: readonly TodoItem[]): string {
+  return String(maxId(items) + 1)
+}
+
+/**
+ * Give every item a stable id. An id already on the item is kept when it is
+ * valid and unique; otherwise the id of a `previous` item with the same content
+ * is reused (so `todo_write`, which resends the whole list, does not renumber
+ * everything); otherwise a fresh id above every id seen so far is allocated.
+ *
+ * Ids are deliberately not part of {@link hashList}: renumbering must never look
+ * like a content change to the supervisor.
+ */
+export function assignIds(items: readonly TodoItem[], previous: readonly TodoItem[] = []): TodoItem[] {
+  const pool = [...previous]
+  const used = new Set<string>()
+  let counter = Math.max(maxId(previous), maxId(items))
+  const out: TodoItem[] = []
+
+  for (const item of items) {
+    let id = typeof item.id === "string" && item.id !== "" && !used.has(item.id) ? item.id : undefined
+    if (id === undefined) {
+      const index = pool.findIndex(
+        (entry) => entry.content === item.content && typeof entry.id === "string" && !used.has(entry.id),
+      )
+      if (index !== -1) {
+        id = pool[index]!.id
+        pool.splice(index, 1)
+      }
+    }
+    if (id === undefined) id = String(++counter)
+    used.add(id)
+    out.push(item.id === id ? item : { ...item, id })
+  }
+
+  return out
+}

package/src/tools.test.ts

@@ -7,7 +7,9 @@ import { DEFAULTS } from "./options"
 import { MarkdownCache } from "./markdown"
 import {
   makeContextInjector,
+  makeTodoAdd,
   makeTodoRead,
+  makeTodoRemove,
   makeTodoSubscribe,
   makeTodoUnsubscribe,
   makeTodoWrite,
@@ -55,6 +57,14 @@ describe("renderers", () => {
     expect(renderList([])).toBe("No todos.")
   })
 
+  test("renderList prefixes ids when present", () => {
+    const list: TodoItem[] = [
+      { id: "1", content: "done", status: "completed" },
+      { id: "2", content: "open", status: "pending", priority: "high" },
+    ]
+    expect(renderList(list)).toBe("- #1 [x] done\n- #2 [ ] open (high)")
+  })
+
   test("renderSummary counts and flags open work", () => {
     const summary = renderSummary([
       { content: "done", status: "completed" },
@@ -80,11 +90,11 @@ describe("todo tools round-trip", () => {
       { todos: [{ content: "step 1", status: "in_progress" }, { content: "step 2", status: "pending" }] },
       { sessionID: "ses_1" },
     )
-    expect(writeResult.content[0]?.text).toContain("- [~] step 1")
+    expect(writeResult.content[0]?.text).toContain("- #1 [~] step 1")
     expect(changed).toEqual(["ses_1"])
 
     const readResult = await read.execute({}, { sessionID: "ses_1" })
-    expect(readResult.content[0]?.text).toContain("- [ ] step 2")
+    expect(readResult.content[0]?.text).toContain("- #2 [ ] step 2")
     expect(readResult.content[0]?.text).toContain("2 open of 2 items.")
   })
 
@@ -110,6 +120,53 @@ describe("todo tools round-trip", () => {
   })
 })
 
+describe("todo_add / todo_remove", () => {
+  test("add appends with a fresh id and reports it", async () => {
+    const store = new TodoStore(new FakeStorage())
+    await store.setTodos("s1", [{ content: "one", status: "pending" }])
+    const changed: string[] = []
+    const add = makeTodoAdd(store, { onTodosChanged: (id) => changed.push(id) })
+    const result = await add.execute({ content: "  two  ", priority: "high" }, { sessionID: "s1" })
+    expect(result.content[0]?.text).toContain("Added #2 two (high)")
+    expect((result.metadata as { id?: string }).id).toBe("2")
+    expect(store.getTodos("s1")?.items.map((item) => [item.id, item.content, item.priority])).toEqual([
+      ["1", "one", undefined],
+      ["2", "two", "high"],
+    ])
+    expect(changed).toEqual(["s1"])
+  })
+
+  test("add refuses a duplicate content and an empty content", async () => {
+    const store = new TodoStore(new FakeStorage())
+    await store.setTodos("s1", [{ content: "one", status: "pending" }])
+    const add = makeTodoAdd(store, {})
+    const duplicate = await add.execute({ content: "one" }, { sessionID: "s1" })
+    expect(duplicate.content[0]?.text).toContain("Already on the list as #1")
+    expect(store.getTodos("s1")?.items.length).toBe(1)
+
+    const empty = await add.execute({ content: "   " }, { sessionID: "s1" })
+    expect(empty.content[0]?.text).toContain("todo_add failed")
+    expect(store.getTodos("s1")?.items.length).toBe(1)
+  })
+
+  test("remove drops one item by id and reports it", async () => {
+    const store = new TodoStore(new FakeStorage())
+    await store.setTodos("s1", [
+      { content: "one", status: "pending" },
+      { content: "two", status: "pending" },
+    ])
+    const changed: string[] = []
+    const remove = makeTodoRemove(store, { onTodosChanged: (id) => changed.push(id) })
+    const result = await remove.execute({ id: "1" }, { sessionID: "s1" })
+    expect(result.content[0]?.text).toContain("Removed #1: one")
+    expect(store.getTodos("s1")?.items.map((item) => item.id)).toEqual(["2"])
+    expect(changed).toEqual(["s1"])
+
+    const missing = await remove.execute({ id: "9" }, { sessionID: "s1" })
+    expect(missing.content[0]?.text).toContain("todo_remove failed")
+  })
+})
+
 describe("markdown tools (§5.2, aspect 14)", () => {
   const dir = "/tmp/opencode"
   const file = `${dir}/tools-md-${process.pid}.md`
@@ -158,7 +215,7 @@ describe("markdown tools (§5.2, aspect 14)", () => {
     const result = await read.execute({}, { sessionID: "s1" })
     const text = result.content[0]?.text ?? ""
     expect(text).toContain("2 open of 2 items.")
-    expect(text).toContain("- [ ] session task")
+    expect(text).toContain("- #1 [ ] session task")
     expect(text).toContain("- [ ] file task  (" + shown + ":1)")
   })
 })

package/src/tools.ts

@@ -3,7 +3,7 @@ import { isAbsolute, resolve as resolvePath } from "node:path"
 import type { Plugin } from "@opencode/plugin"
 import { effectiveFiles, MarkdownCache, renderFileSection, resolveMarkdownPath } from "./markdown"
 import type { Options } from "./options"
-import { openItems, type TodoItem, type TodoStore, type TodoStatus } from "./storage"
+import { nextId, openItems, type TodoItem, type TodoPriority, type TodoStore, type TodoStatus } from "./storage"
 
 export interface ToolHooks {
   /** Fired after a successful `todo_write` (supervisor reset, RPC notify, …). */
@@ -45,6 +45,7 @@ export function normalizeItems(raw: readonly TodoItem[]): { items: TodoItem[]; n
     }
 
     const item: TodoItem = { content, status }
+    if (typeof entry.id === "string" && entry.id.trim() !== "") item.id = entry.id.trim()
     if (entry.priority === "high" || entry.priority === "medium" || entry.priority === "low") {
       item.priority = entry.priority
     }
@@ -68,7 +69,10 @@ export function normalizeItems(raw: readonly TodoItem[]): { items: TodoItem[]; n
 export function renderList(items: readonly TodoItem[]): string {
   if (items.length === 0) return "No todos."
   return items
-    .map((item) => `- ${MARKERS[item.status]} ${item.content}${item.priority ? ` (${item.priority})` : ""}`)
+    .map((item) => {
+      const tag = item.id ? `#${item.id} ` : ""
+      return `- ${tag}${MARKERS[item.status]} ${item.content}${item.priority ? ` (${item.priority})` : ""}`
+    })
     .join("\n")
 }
 
@@ -93,6 +97,7 @@ export function renderSummary(items: readonly TodoItem[], notes: readonly string
 const TODO_ITEM_SCHEMA = {
   type: "object",
   properties: {
+    id: { type: "string" },
     content: { type: "string" },
     status: { type: "string", enum: ["pending", "in_progress", "completed", "canceled"] },
     priority: { type: "string", enum: ["high", "medium", "low"] },
@@ -104,7 +109,15 @@ const TODO_ITEM_SCHEMA = {
 const WRITE_DESCRIPTION =
   "Replace the session's todo list. Use this to plan multi-step work and keep progress visible: " +
   "send the complete list every time (it replaces the previous one). Keep exactly one item `in_progress`. " +
-  "Before ending your turn every item must be `completed` or `canceled` — a supervisor will continue the session while items remain open."
+  "Before ending your turn every item must be `completed` or `canceled` — a supervisor will continue the session while items remain open. " +
+  "Each item has a stable `id`; include it to keep the same item across rewrites (otherwise it is matched by content)."
+
+const ADD_DESCRIPTION =
+  "Add one item to the session's todo list without resending the whole list. Returns the new item's id. " +
+  "Prefer this (or todo_write) over rewriting the list to append a single task."
+
+const REMOVE_DESCRIPTION =
+  "Remove one item from the session's todo list by its id (see the ids in todo_read / the injected todo block)."
 
 const READ_DESCRIPTION =
   "Read the session's current todo list (canonical state as stored by todo_write). " +
@@ -155,11 +168,12 @@ export function makeTodoWrite(store: TodoStore, hooks: ToolHooks) {
     async execute(input: { todos: TodoItem[] }, context: ToolContextLike) {
       try {
         const { items, notes } = normalizeItems(Array.isArray(input?.todos) ? input.todos : [])
-        await store.setTodos(context.sessionID, items)
+        const state = await store.setTodos(context.sessionID, items)
         hooks.onTodosChanged?.(context.sessionID)
+        const saved = state.items
         return {
-          content: [{ type: "text" as const, text: `${renderSummary(items, notes)}\n\n${renderList(items)}` }],
-          metadata: { items: items.length, open: openItems(items).length },
+          content: [{ type: "text" as const, text: `${renderSummary(saved, notes)}\n\n${renderList(saved)}` }],
+          metadata: { items: saved.length, open: openItems(saved).length },
         }
       } catch (err) {
         hooks.log?.(`todo_write failed (${context.sessionID}): ${String(err)}`)
@@ -216,6 +230,121 @@ export function makeTodoRead(store: TodoStore, hooks: ToolHooks = {}, deps?: Mar
   }
 }
 
+function validPriority(value: unknown): TodoPriority | undefined {
+  return value === "high" || value === "medium" || value === "low" ? value : undefined
+}
+
+function validStatus(value: unknown): TodoStatus | undefined {
+  return value === "pending" || value === "in_progress" || value === "completed" || value === "canceled"
+    ? value
+    : undefined
+}
+
+export function makeTodoAdd(store: TodoStore, hooks: ToolHooks) {
+  return {
+    name: "todo_add",
+    description: ADD_DESCRIPTION,
+    input: {
+      type: "object",
+      properties: {
+        content: { type: "string" },
+        priority: { type: "string", enum: ["high", "medium", "low"] },
+        status: { type: "string", enum: ["pending", "in_progress", "completed", "canceled"] },
+      },
+      required: ["content"],
+      additionalProperties: false,
+    },
+    options: { codemode: true as const },
+    async execute(input: { content?: string; priority?: string; status?: string }, context: ToolContextLike) {
+      try {
+        const content = String(input?.content ?? "").trim()
+        if (!content) throw new Error('"content" must be a non-empty string')
+        const state = await store.refreshTodos(context.sessionID)
+        const existing = state?.items ?? []
+        const duplicate = existing.find((item) => item.content === content)
+        if (duplicate) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Already on the list as #${duplicate.id ?? "?"}: ${content}\n\n${renderList(existing)}`,
+              },
+            ],
+            metadata: { items: existing.length, open: openItems(existing).length, id: duplicate.id },
+          }
+        }
+        const item: TodoItem = { id: nextId(existing), content, status: validStatus(input?.status) ?? "pending" }
+        const priority = validPriority(input?.priority)
+        if (priority) item.priority = priority
+        const saved = await store.setTodos(context.sessionID, [...existing, item])
+        hooks.onTodosChanged?.(context.sessionID)
+        const added = saved.items[saved.items.length - 1]!
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text:
+                `Added #${added.id} ${added.content}${added.priority ? ` (${added.priority})` : ""}.\n\n` +
+                `${renderSummary(saved.items)}\n\n${renderList(saved.items)}`,
+            },
+          ],
+          metadata: { items: saved.items.length, open: openItems(saved.items).length, id: added.id },
+        }
+      } catch (err) {
+        hooks.log?.(`todo_add failed (${context.sessionID}): ${String(err)}`)
+        return {
+          content: [{ type: "text" as const, text: `todo_add failed: ${String(err)}` }],
+          metadata: { error: String(err) },
+        }
+      }
+    },
+  }
+}
+
+export function makeTodoRemove(store: TodoStore, hooks: ToolHooks) {
+  return {
+    name: "todo_remove",
+    description: REMOVE_DESCRIPTION,
+    input: {
+      type: "object",
+      properties: { id: { type: "string" } },
+      required: ["id"],
+      additionalProperties: false,
+    },
+    options: { codemode: true as const },
+    async execute(input: { id?: string }, context: ToolContextLike) {
+      try {
+        const id = String(input?.id ?? "").trim()
+        if (!id) throw new Error('"id" must be a non-empty string')
+        const state = await store.refreshTodos(context.sessionID)
+        const existing = state?.items ?? []
+        const removed = existing.find((item) => item.id === id)
+        if (!removed) throw new Error(`no todo with id ${JSON.stringify(id)}`)
+        const saved = await store.setTodos(
+          context.sessionID,
+          existing.filter((item) => item.id !== id),
+        )
+        hooks.onTodosChanged?.(context.sessionID)
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Removed #${id}: ${removed.content}\n\n${renderSummary(saved.items)}\n\n${renderList(saved.items)}`,
+            },
+          ],
+          metadata: { items: saved.items.length, open: openItems(saved.items).length, id },
+        }
+      } catch (err) {
+        hooks.log?.(`todo_remove failed (${context.sessionID}): ${String(err)}`)
+        return {
+          content: [{ type: "text" as const, text: `todo_remove failed: ${String(err)}` }],
+          metadata: { error: String(err) },
+        }
+      }
+    },
+  }
+}
+
 export function makeTodoSubscribe(store: TodoStore, hooks: ToolHooks, directory: string) {
   return {
     name: "todo_subscribe",
@@ -302,6 +431,8 @@ export async function registerTools(
   const registration = await ctx.tool.transform((editor) => {
     editor.add(makeTodoWrite(store, hooks))
     editor.add(makeTodoRead(store, hooks, { ...markdownDeps, options }))
+    editor.add(makeTodoAdd(store, hooks))
+    editor.add(makeTodoRemove(store, hooks))
     editor.add(makeTodoSubscribe(store, hooks, markdownDeps.directory))
     editor.add(makeTodoUnsubscribe(store, hooks, markdownDeps.directory))
   })

package/src/tui.tsx

@@ -23,8 +23,11 @@ import {
   countOpen,
   dialogWidth,
   footerHints,
+  idTag,
+  itemColumns,
   moveCursor,
   popoverBodyHeight,
+  priorityTag,
   progressBar,
   rowIndex,
   statusMark,
@@ -322,6 +325,68 @@ export default Plugin.define({
             notify("Unsubscribed", "success")
           })
 
+        const addTask = () =>
+          guard("add task", async () => {
+            const content = await context.ui.dialog.prompt({
+              title: "Add todo",
+              description: "Press p on the new row to set its priority.",
+              placeholder: "what needs doing?",
+            })
+            if (!content || !content.trim()) return
+            const result = (await rpc.addItem({ sessionID: sessionID(), content })) as { id?: string } | undefined
+            notify(result?.id ? `Added #${result.id}` : "Added", "success")
+          })
+
+        /** The selected row, when it is an editable session item. */
+        const selectedSessionItem = (): Extract<Row, { kind: "item" }> | undefined => {
+          const row = current()
+          return row && row.kind === "item" && row.source === "session" && row.id ? row : undefined
+        }
+
+        const removeTask = () => {
+          const row = current()
+          if (!row || row.kind !== "item") {
+            notify("Select a task first", "warning")
+            return
+          }
+          if (row.source === "file" || !row.id) {
+            notify("File items are removed by editing the file", "warning")
+            return
+          }
+          const { id, content } = row
+          guard("remove task", async () => {
+            const ok = await context.ui.dialog.confirm({
+              title: "Remove task",
+              message: `Remove #${id}: ${truncate(content, 48)}?`,
+              label: { confirm: "Remove", cancel: "Cancel" },
+            })
+            if (!ok) return
+            await rpc.removeItem({ sessionID: sessionID(), id })
+            notify(`Removed #${id}`, "success")
+          })
+        }
+
+        const cyclePriority = () => {
+          const row = selectedSessionItem()
+          if (!row || !row.id) {
+            notify("Select a task first", "warning")
+            return
+          }
+          const id = row.id
+          const next =
+            row.priority === undefined
+              ? "low"
+              : row.priority === "low"
+                ? "medium"
+                : row.priority === "medium"
+                  ? "high"
+                  : "none"
+          guard("priority", async () => {
+            await rpc.setPriority({ sessionID: sessionID(), id, priority: next })
+            notify(next === "none" ? `#${id} priority cleared` : `#${id} priority: ${next}`, "success")
+          })
+        }
+
         const pauseResume = () => {
           const paused = snap().supervisor?.paused === true
           guard("supervision", async () => {
@@ -378,8 +443,11 @@ export default Plugin.define({
                 }),
             },
             { title: "Todo: pause/resume supervision", bind: "s", run: pauseResume },
-            { title: "Todo: add markdown file", bind: "a", run: addFile },
-            { title: "Todo: remove markdown file", bind: "d", run: removeFile },
+            { title: "Todo: add task", bind: "a", run: addTask },
+            { title: "Todo: remove task", bind: "d", run: removeTask },
+            { title: "Todo: cycle priority", bind: "p", run: cyclePriority },
+            { title: "Todo: add markdown file", bind: "A", run: addFile },
+            { title: "Todo: remove markdown file", bind: "D", run: removeFile },
             {
               title: "Todo: refresh",
               bind: "r",
@@ -417,7 +485,8 @@ export default Plugin.define({
                     title: "Todo panel",
                     message:
                       "↑↓/jk move · space/x toggle · enter collapse · n nudge · s pause/resume\n" +
-                      "a add file · d remove file · r refresh · / filter · f resize · c clear · esc close",
+                      "a add task · d remove task · p priority · A add file · D remove file\n" +
+                      "r refresh · / filter · f resize · c clear · esc close",
                   })
                 }),
             },
@@ -448,17 +517,30 @@ export default Plugin.define({
           return Math.max(3, available - filtered)
         }
 
-        const barWidth = () => Math.max(6, Math.min(24, width() - 44))
+        const barWidth = () => Math.max(6, Math.min(40, Math.floor(width() * 0.25)))
+
+        // Column widths for the `#id` / priority columns, sized to the list.
+        const columns = createMemo(() => {
+          const current = snap()
+          return itemColumns([...current.items, ...current.files.flatMap((file) => file.items)])
+        })
+        const contentWidth = () =>
+          Math.max(
+            8,
+            width() -
+              6 -
+              (columns().id > 0 ? columns().id + 2 : 0) -
+              (columns().priority > 0 ? columns().priority + 2 : 0),
+          )
 
         const renderRow = (row: Row) => {
           const isCurrent = () => row.key === cursor()
           const prefix = () => (isCurrent() ? "❯ " : "  ")
-          const contentWidth = () => Math.max(8, width() - 6)
           const background = () => (isCurrent() ? selectedBg() : undefined)
           if (row.kind === "section") {
             return (
               <text fg={muted()}>
-                {prefix() + truncate(row.label + (row.detail ? "  ·  " + row.detail : ""), contentWidth())}
+                {prefix() + truncate(row.label + (row.detail ? "  ·  " + row.detail : ""), width() - 6)}
               </text>
             )
           }
@@ -468,17 +550,20 @@ export default Plugin.define({
             return (
               <box backgroundColor={background()}>
                 <text fg={isCurrent() ? accent() : base()}>
-                  {prefix() + (row.collapsed ? "▸ " : "▾ ") + truncate(`${label}  ·  ${detail}`, contentWidth())}
+                  {prefix() + (row.collapsed ? "▸ " : "▾ ") + truncate(`${label}  ·  ${detail}`, width() - 6)}
                 </text>
               </box>
             )
           }
-          const suffix =
-            (row.priority ? ` (${row.priority})` : "") + (row.line !== undefined ? `  :${row.line}` : "")
+          const cols = columns()
+          const parts = [prefix() + statusMark(row.status)]
+          if (cols.id > 0) parts.push(idTag(row.id).padEnd(cols.id))
+          if (cols.priority > 0) parts.push(priorityTag(row.priority).padEnd(cols.priority))
+          parts.push(truncate(row.content + (row.line !== undefined ? `  :${row.line}` : ""), contentWidth()))
           return (
             <box backgroundColor={background()}>
               <text fg={row.status === "completed" ? muted() : isCurrent() ? accent() : base()}>
-                {prefix() + statusMark(row.status) + " " + truncate(row.content + suffix, contentWidth())}
+                {parts.join("  ")}
               </text>
             </box>
           )