@gamflaz/opencode-todolist 1.1.0 → 1.1.2

package/README.md

@@ -8,6 +8,7 @@ plus a TUI widget above the composer that shows progress in real time.
 - Hierarchical tasks: any number of root tasks, each with up to 9 subtasks.
 - Numeric IDs only: root `1`, `2`, … and subtasks `1.1`, `1.2`, … (`1.9` max).
 - Small partial updates: change one item without resending the whole list.
+- Scoped reads: pull the whole list, one branch, or a single item.
 - Strict forward-only progress with enforced order between root tasks.
 - Real-time TUI widget with collapse, scroll, `↻ Continue`, and clear controls.
 - Bundled skills that teach the agent how to drive the tool.
@@ -40,22 +41,36 @@ dependencies, so `bun install` is required before use.
 
 #### Operation fields
 
-| Operation | Required fields                 | Optional fields                |
-| --------- | ------------------------------- | ------------------------------ |
-| `read`    | `operation`                     | None                           |
-| `write`   | `operation`, `todos`            | None; use `todos: []` to clear |
-| `update`  | `operation`, `id`, `status`     | `content`, `priority`, `note`  |
+| Operation | Required fields             | Optional fields                |
+| --------- | --------------------------- | ------------------------------ |
+| `read`    | `operation`                 | `scope`, `target`              |
+| `write`   | `operation`, `todos`        | None; use `todos: []` to clear |
+| `update`  | `operation`, `id`, `status` | `content`, `priority`, `note`  |
 
 For `update`, send `null` for `priority` or `note` to remove the existing value.
 
 ### Read
 
+By default `read` returns the whole list. An optional `scope` narrows it to one
+branch or one row, which keeps the response small on a long list.
+
+| `scope`    | `target`            | Returns                                      |
+| ---------- | ------------------- | -------------------------------------------- |
+| `all`      | —                   | the whole list (default)                     |
+| `root`     | a root id, e.g. `1` | that root and all of its subtasks            |
+| `children` | a subtask id, `1.1` | that subtask, with its root shown as context |
+| `item`     | `1` or `1.1`        | only that row                                |
+
+`target` is only valid together with `scope: "root"`, `"children"`, or
+`"item"` — passing it without one is rejected, so a scope can never be silently
+ignored.
+
+The whole list:
+
 ```json
 { "operation": "read" }
 ```
 
-Returns the current list as a progress tree:
-
 ```text
 [~] 1. Design architecture (1/2)
     ↳ note: Keep the hierarchy shallow
@@ -64,9 +79,35 @@ Returns the current list as a progress tree:
 [ ] 2. Write tests
 ```
 
+One branch (`root`):
+
+```json
+{ "operation": "read", "scope": "root", "target": 1 }
+```
+
+A single subtask, with its root as context (`children`):
+
+```json
+{ "operation": "read", "scope": "children", "target": 1.2 }
+```
+
+```text
+[~] 1. Design architecture (1/2)
+    [~] 1.2 API endpoints
+```
+
+One row with no context (`item`):
+
+```json
+{ "operation": "read", "scope": "item", "target": 1.2 }
+```
+
 Markers: `[ ]` pending, `[~]` in progress, `[x]` completed, `[-]` cancelled,
 `[!]` error. Notes render under their item as `↳ note: …`.
 
+Even when a scope hides rows, the root keeps its real `(completed/total)` count —
+only the display is narrowed.
+
 ### Write
 
 `write` initializes a session or clears it. A non-empty list is only accepted
@@ -100,14 +141,14 @@ Clear the current list:
 
 #### Todo item fields
 
-| Field      | Type                              | Required        | Description                                                               |
-| ---------- | --------------------------------- | --------------- | ------------------------------------------------------------------------- |
-| `id`       | number                            | Yes             | Root: positive integer. Child: `<root>.<n>`, such as `1.1`.              |
-| `content`  | string                            | Yes             | Task summary.                                                             |
-| `status`   | enum                              | Yes             | `pending`, `in_progress`, `completed`, `cancelled`, or `error`.           |
-| `priority` | `high` \| `medium` \| `low`       | No              | Optional priority label.                                                  |
-| `note`     | string                            | No              | Technical context or evidence.                                            |
-| `children` | array of child items              | No, root only   | Up to 9 subtasks. Child items cannot contain more children.               |
+| Field      | Type                        | Required      | Description                                                     |
+| ---------- | --------------------------- | ------------- | --------------------------------------------------------------- |
+| `id`       | number                      | Yes           | Root: positive integer. Child: `<root>.<n>`, such as `1.1`.     |
+| `content`  | string                      | Yes           | Task summary.                                                   |
+| `status`   | enum                        | Yes           | `pending`, `in_progress`, `completed`, `cancelled`, or `error`. |
+| `priority` | `high` \| `medium` \| `low` | No            | Optional priority label.                                        |
+| `note`     | string                      | No            | Technical context or evidence.                                  |
+| `children` | array of child items        | No, root only | Up to 9 subtasks. Child items cannot contain more children.     |
 
 Root IDs must be unique. A child ID must start with its parent root ID.
 
@@ -129,11 +170,11 @@ Root IDs must be unique. A child ID must start with its parent root ID.
 
 | Field      | Required | Notes                                                        |
 | ---------- | -------- | ------------------------------------------------------------ |
-| `id`       | Yes      | Root number or subtask number (`1`, `1.1`).                   |
-| `status`   | Yes      | `pending`, `in_progress`, `completed`, `cancelled`, `error`.  |
-| `content`  | No       | One-line summary shown in the widget.                         |
-| `note`     | No       | Technical context or evidence. Pass `null` to remove.         |
-| `priority` | No       | `high`, `medium`, or `low`. Pass `null` to remove.            |
+| `id`       | Yes      | Root number or subtask number (`1`, `1.1`).                  |
+| `status`   | Yes      | `pending`, `in_progress`, `completed`, `cancelled`, `error`. |
+| `content`  | No       | One-line summary shown in the widget.                        |
+| `note`     | No       | Technical context or evidence. Pass `null` to remove.        |
+| `priority` | No       | `high`, `medium`, or `low`. Pass `null` to remove.           |
 
 ## Skills
 
@@ -152,15 +193,3 @@ bun run compile # rebuild dist/ (tsc + Solid JSX transform)
 `bun run compile` must be used instead of `bun run build`: the raw `tsc` pass
 alone leaves intermediate `.jsx` files in `dist/`, which Bun then prefers over
 the compiled `.js` and reports as `No renderer found` / `ENOENT ... dist/tui.jsx`.
-
-## Publishing notes
-
-`dist/`, `index.js`, and `tui.js` are generated build output and are not
-committed. They reach users through the npm tarball: npm runs `prepare`
-(`bun run compile`) before packing, and `files` ships the built `dist/`
-directory. The `opencode plugin add` installer skips lifecycle scripts
-(`ignoreScripts: true`), so the tarball — not a post-install build — must
-contain `dist/`.
-
-Before publishing, run `bun run check && bun run compile` and confirm
-`dist/` contains no `.jsx` files.

package/dist/index.d.ts

@@ -1,30 +1,10 @@
 import { Plugin } from "@opencode/plugin";
-import { type TodoReadInput, type TodoRootItem } from "./schemas/todo";
-export declare function formatReadOutput(todos: readonly TodoRootItem[], options?: {
-    visibleIds?: readonly number[];
-}): string;
+import { type TodoRootItem } from "./schemas/todo";
 export declare function formatTransitionLines(before: readonly TodoRootItem[], after: readonly TodoRootItem[]): string[];
 export declare function formatWriteOutput(todos: readonly TodoRootItem[], before?: readonly TodoRootItem[]): string;
 export declare function assertWriteIsInitialization(existing: readonly TodoRootItem[], incoming: readonly TodoRootItem[]): void;
 /** Update response: progress, next step, and transition lines without resending the list. */
 export declare function formatUpdateOutput(todos: readonly TodoRootItem[], before?: readonly TodoRootItem[]): string;
-/**
- * Narrows a list for a scoped read.
- *
- * - `scope: "root"` returns one root with every subtask, so the whole branch is
- *   visible.
- * - `scope: "children"` prints the root line as context plus the targeted
- *   subtask line, matching a "show me this subtask within its root" read.
- * - `scope: "item"` prints only the targeted row.
- *
- * Either way the root keeps every subtask in the *data*, because the root's
- * `(completed/total)` label is computed from them — dropping them would
- * silently turn `(2/2)` into `(1/1)`.
- */
-export declare function selectReadScope(todos: readonly TodoRootItem[], input: TodoReadInput): {
-    todos: TodoRootItem[];
-    visibleIds?: readonly number[];
-};
 export declare function registerTodoTools(ctx: Plugin.Context): Promise<void>;
 export declare function registerTodoPromptHook(ctx: Plugin.Context): Promise<void>;
 declare const _default: Plugin.Plugin;

package/dist/index.js

@@ -3,17 +3,9 @@ import { TodoInputToolSchema, TodoOutputToolSchema, } from "./schemas/todo.js";
 import { registerTodoSkills } from "./skills/loader.js";
 import { readTodoData, readTodos, updateTodos } from "./storage/todo-store.js";
 import { buildTodoHint, consumeTodoHint, findNextTodo, findStuckParent, flattenLeaves, isAnyTodoActive, } from "./todos/hint.js";
+import { runReadOperation } from "./todos/read.js";
 import { TodoTree } from "./todos/todo-tree.js";
 import { updateTodoById } from "./todos/update.js";
-export function formatReadOutput(todos, options) {
-    if (todos.length === 0)
-        return "No todos recorded.";
-    const tree = new TodoTree(todos).render(options);
-    const check = new TodoTree(todos).validateAndNormalize();
-    if (check.valid)
-        return tree;
-    return `Warning: the stored list needs fixing — ${check.error}\n${tree}`;
-}
 export function formatTransitionLines(before, after) {
     const previous = new Map(flattenLeaves(before).map((leaf) => [leaf.id, leaf.status]));
     const leaves = flattenLeaves(after);
@@ -60,7 +52,7 @@ export function formatWriteOutput(todos, before = []) {
 export function assertWriteIsInitialization(existing, incoming) {
     if (existing.length > 0 && incoming.length > 0) {
         const messages = [
-            '[manage_todo_list] Invalid operation: "write".',
+            'Invalid operation: "write".',
             "",
             'The "write" operation is only allowed during initialization.',
             'Use "update" to modify an existing todo list.',
@@ -75,38 +67,6 @@ export function formatUpdateOutput(todos, before = []) {
     const progress = `Todos (${stats.completedSubTasks}/${stats.totalSubTasks}).`;
     return formatWriteOutput(todos, before).replace(/^Todos \(\d+\/\d+\) updated\./, progress.slice(0, -1));
 }
-/**
- * Narrows a list for a scoped read.
- *
- * - `scope: "root"` returns one root with every subtask, so the whole branch is
- *   visible.
- * - `scope: "children"` prints the root line as context plus the targeted
- *   subtask line, matching a "show me this subtask within its root" read.
- * - `scope: "item"` prints only the targeted row.
- *
- * Either way the root keeps every subtask in the *data*, because the root's
- * `(completed/total)` label is computed from them — dropping them would
- * silently turn `(2/2)` into `(1/1)`.
- */
-export function selectReadScope(todos, input) {
-    if (input.scope !== "item" && input.scope !== "children" && input.scope !== "root") {
-        return { todos: [...todos] };
-    }
-    const target = input.target;
-    const rootId = Number.isInteger(target) ? target : Math.floor(target);
-    const root = todos.find((item) => item.id === rootId);
-    const child = Number.isInteger(target)
-        ? undefined
-        : root?.children?.find((item) => item.id === target);
-    if (!root || (!Number.isInteger(target) && !child)) {
-        throw new Error(`[manage_todo_list] todo id ${target} was not found`);
-    }
-    // `root` shows the branch as-is; it needs no row filter at all.
-    if (input.scope === "root")
-        return { todos: [root] };
-    const visibleIds = input.scope === "children" ? [rootId, target] : [target];
-    return { todos: [root], visibleIds };
-}
 export async function registerTodoTools(ctx) {
     await ctx.tool.transform((tools) => {
         tools.add({
@@ -123,18 +83,16 @@ export async function registerTodoTools(ctx) {
             execute: async (input, toolContext) => {
                 const parsed = TodoInputToolSchema.safeParse(input);
                 if (!parsed.success) {
-                    throw new Error(`[manage_todo_list validation failed] ${parsed.error.issues
+                    throw new Error(`Invalid manage_todo_list input: ${parsed.error.issues
                         .map((i) => `${i.path.join(".") || "input"}: ${i.message}`)
                         .join(", ")}`);
                 }
                 if (parsed.data.operation === "read") {
                     const todos = await readTodos(toolContext.sessionID);
-                    const scoped = selectReadScope(todos, parsed.data);
+                    const result = runReadOperation(todos, parsed.data);
                     return {
-                        output: { todos: scoped.todos },
-                        content: formatReadOutput(scoped.todos, {
-                            visibleIds: scoped.visibleIds,
-                        }),
+                        output: { todos: result.todos },
+                        content: result.content,
                     };
                 }
                 if (parsed.data.operation === "update") {

package/dist/storage/migrate-json.js

@@ -54,7 +54,7 @@ export function parseLegacyTodos(raw) {
         parsed = JSON.parse(raw);
     }
     catch (error) {
-        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${error instanceof Error ? error.message : String(error)}`);
+        throw new InvalidTodoDataError(`invalid todo data: ${error instanceof Error ? error.message : String(error)}`);
     }
     const list = Array.isArray(parsed)
         ? parsed
@@ -62,11 +62,11 @@ export function parseLegacyTodos(raw) {
             ? parsed.todos
             : undefined;
     if (!Array.isArray(list)) {
-        throw new InvalidTodoDataError("[todo store read failed] invalid todo data: todo list is missing");
+        throw new InvalidTodoDataError("invalid todo data: todo list is missing");
     }
     const result = TodoListSchema.safeParse(list);
     if (!result.success) {
-        throw new InvalidTodoDataError(`[todo store read failed] invalid todo data: ${result.error.issues
+        throw new InvalidTodoDataError(`invalid todo data: ${result.error.issues
             .map((issue) => issue.message)
             .join(", ")}`);
     }

package/dist/storage/todo-store.js

@@ -26,7 +26,7 @@ export class TodoStore {
     static normalizeSessionID(sessionID) {
         const normalized = sessionID.trim();
         if (!TodoStore.SESSION_ID_PATTERN.test(normalized)) {
-            throw new Error("[todo store] invalid session ID");
+            throw new Error("invalid session ID");
         }
         return normalized;
     }
@@ -281,7 +281,7 @@ export class TodoStore {
             if (!result.valid) {
                 // Throwing inside the transaction rolls it back, so an invalid list
                 // never reaches disk and never bumps the revision.
-                throw new Error(`[todo store validation failed] ${result.error}`);
+                throw new Error(result.error);
             }
             return result.data;
         }).todos;

package/dist/todos/read.d.ts

@@ -0,0 +1,44 @@
+import type { TodoReadInput, TodoRootItem } from "../schemas/todo";
+/**
+ * Render a list as the tree the `read` operation answers with.
+ *
+ * A list that fails validation still renders — showing the rows is more useful
+ * than refusing — but the warning goes first so the caller fixes it before
+ * trusting the shape.
+ */
+export declare function formatReadOutput(todos: readonly TodoRootItem[], options?: {
+    visibleIds?: readonly number[];
+}): string;
+/**
+ * Narrows a list for a scoped read.
+ *
+ * - `scope: "root"` returns one root with every subtask, so the whole branch is
+ *   visible.
+ * - `scope: "children"` prints the root line as context plus the targeted
+ *   subtask line, matching a "show me this subtask within its root" read.
+ * - `scope: "item"` prints only the targeted row.
+ *
+ * Either way the root keeps every subtask in the *data*, because the root's
+ * `(completed/total)` label is computed from them — dropping them would
+ * silently turn `(2/2)` into `(1/1)`.
+ */
+export declare function selectReadScope(todos: readonly TodoRootItem[], input: TodoReadInput): {
+    todos: TodoRootItem[];
+    visibleIds?: readonly number[];
+};
+export interface ReadOperationResult {
+    /** Scope-narrowed list, also what the tool returns as structured output. */
+    todos: TodoRootItem[];
+    /** Rows to print for `children`/`item`; absent means "print everything". */
+    visibleIds?: readonly number[];
+    /** Rendered tree, ready to hand back as tool content. */
+    content: string;
+}
+/**
+ * Whole `read` operation, minus storage.
+ *
+ * Kept pure on purpose: the caller reads the session's list and passes it in,
+ * so this module never needs a session id and mirrors `updateTodoById` instead
+ * of the storage-facing wrappers.
+ */
+export declare function runReadOperation(todos: readonly TodoRootItem[], input: TodoReadInput): ReadOperationResult;

package/dist/todos/read.js

@@ -0,0 +1,67 @@
+import { TodoTree } from "./todo-tree.js";
+/**
+ * Render a list as the tree the `read` operation answers with.
+ *
+ * A list that fails validation still renders — showing the rows is more useful
+ * than refusing — but the warning goes first so the caller fixes it before
+ * trusting the shape.
+ */
+export function formatReadOutput(todos, options) {
+    if (todos.length === 0)
+        return "No todos recorded.";
+    const tree = new TodoTree(todos).render(options);
+    const check = new TodoTree(todos).validateAndNormalize();
+    if (check.valid)
+        return tree;
+    return `Warning: the stored list needs fixing — ${check.error}\n${tree}`;
+}
+/**
+ * Narrows a list for a scoped read.
+ *
+ * - `scope: "root"` returns one root with every subtask, so the whole branch is
+ *   visible.
+ * - `scope: "children"` prints the root line as context plus the targeted
+ *   subtask line, matching a "show me this subtask within its root" read.
+ * - `scope: "item"` prints only the targeted row.
+ *
+ * Either way the root keeps every subtask in the *data*, because the root's
+ * `(completed/total)` label is computed from them — dropping them would
+ * silently turn `(2/2)` into `(1/1)`.
+ */
+export function selectReadScope(todos, input) {
+    if (input.scope !== "item" &&
+        input.scope !== "children" &&
+        input.scope !== "root") {
+        return { todos: [...todos] };
+    }
+    const target = input.target;
+    const rootId = Number.isInteger(target) ? target : Math.floor(target);
+    const root = todos.find((item) => item.id === rootId);
+    const child = Number.isInteger(target)
+        ? undefined
+        : root?.children?.find((item) => item.id === target);
+    if (!root || (!Number.isInteger(target) && !child)) {
+        throw new Error(`todo id ${target} was not found`);
+    }
+    // `root` shows the branch as-is; it needs no row filter at all.
+    if (input.scope === "root")
+        return { todos: [root] };
+    const visibleIds = input.scope === "children" ? [rootId, target] : [target];
+    return { todos: [root], visibleIds };
+}
+/**
+ * Whole `read` operation, minus storage.
+ *
+ * Kept pure on purpose: the caller reads the session's list and passes it in,
+ * so this module never needs a session id and mirrors `updateTodoById` instead
+ * of the storage-facing wrappers.
+ */
+export function runReadOperation(todos, input) {
+    const scoped = selectReadScope(todos, input);
+    const content = formatReadOutput(scoped.todos, {
+        visibleIds: scoped.visibleIds,
+    });
+    return scoped.visibleIds === undefined
+        ? { todos: scoped.todos, content }
+        : { todos: scoped.todos, visibleIds: scoped.visibleIds, content };
+}

package/dist/todos/todo-tree.d.ts

@@ -54,8 +54,26 @@ export declare class TodoTree {
     /**
      * Rejects completed parents with unfinished children, and auto-completes a
      * parent whose children are all completed.
+     *
+     * The order check runs **after** the auto-complete above, never before: a
+     * parent whose children all finished is raised to `completed` here, and that
+     * promotion can itself create an out-of-order list. Checking first would let
+     * the promotion slip past the check.
      */
     private normalize;
+    /**
+     * Roots run in order, so nothing after the first unfinished root may be
+     * finished.
+     *
+     * Only `error` is allowed to follow an open root — a broken task has to be
+     * fixable even while earlier work is still open. Everything else
+     * (`completed`, `in_progress`, `cancelled`) has to wait its turn.
+     *
+     * This lives here rather than in `update.ts` because `write` and the legacy
+     * importer reach the database without passing the update rules at all. One
+     * check in the shared validator closes every path at once.
+     */
+    private static findOrderError;
     /**
      * Renders the tree.
      *

package/dist/todos/todo-tree.js

@@ -132,6 +132,11 @@ export class TodoTree {
     /**
      * Rejects completed parents with unfinished children, and auto-completes a
      * parent whose children are all completed.
+     *
+     * The order check runs **after** the auto-complete above, never before: a
+     * parent whose children all finished is raised to `completed` here, and that
+     * promotion can itself create an out-of-order list. Checking first would let
+     * the promotion slip past the check.
      */
     normalize() {
         const normalized = [];
@@ -156,8 +161,39 @@ export class TodoTree {
                 status: allChildrenCompleted ? "completed" : item.status,
             });
         }
+        const orderError = TodoTree.findOrderError(normalized);
+        if (orderError)
+            return { valid: false, error: orderError };
         return { valid: true, data: normalized };
     }
+    /**
+     * Roots run in order, so nothing after the first unfinished root may be
+     * finished.
+     *
+     * Only `error` is allowed to follow an open root — a broken task has to be
+     * fixable even while earlier work is still open. Everything else
+     * (`completed`, `in_progress`, `cancelled`) has to wait its turn.
+     *
+     * This lives here rather than in `update.ts` because `write` and the legacy
+     * importer reach the database without passing the update rules at all. One
+     * check in the shared validator closes every path at once.
+     */
+    static findOrderError(todos) {
+        const isFinal = (status) => status === "completed" || status === "cancelled";
+        let firstOpen;
+        for (const root of todos) {
+            if (!firstOpen) {
+                if (!isFinal(root.status))
+                    firstOpen = root;
+                continue;
+            }
+            // Past the first open root: a later root must still be untouched.
+            if (root.status === "pending" || root.status === "error")
+                continue;
+            return `Task '${root.id}' is '${root.status}' but earlier task '${firstOpen.id}' is still '${firstOpen.status}'. Roots run in order: finish or cancel '${firstOpen.id}' first.`;
+        }
+        return null;
+    }
     // Rendering
     /**
      * Renders the tree.

package/dist/todos/update.js

@@ -38,7 +38,7 @@ function assertForwardTransition(from, to, id) {
     if (from === to)
         return;
     if (!(FORWARD_TRANSITIONS[from] ?? []).includes(to)) {
-        throw new Error(`[manage_todo_list] todo ${id} cannot move from '${from}' to '${to}'. Progress only moves forward; use 'error' to report a failure and fix it from there.`);
+        throw new Error(`todo ${id} cannot move from '${from}' to '${to}'. Progress only moves forward; use 'error' to report a failure and fix it from there.`);
     }
 }
 /** Any root still open, an `error` root included. */
@@ -65,11 +65,11 @@ export function assertSequentialScope(todos, input) {
     const targetRoot = todos.find((root) => root.id === input.id ||
         root.children?.some((child) => child.id === input.id));
     if (!targetRoot) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     const firstOpen = todos.findIndex((root) => !isFinal(root.status));
     if (firstOpen === -1) {
-        throw new Error("[manage_todo_list] every todo is already finished; nothing can be updated.");
+        throw new Error("every todo is already finished; nothing can be updated.");
     }
     const targetRootIndex = todos.indexOf(targetRoot);
     if (targetRootIndex !== firstOpen && !hasError(targetRoot)) {
@@ -80,10 +80,10 @@ export function assertSequentialScope(todos, input) {
         ? targetRoot
         : targetRoot.children?.find((child) => child.id === input.id);
     if (!target) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     if (isFinal(target.status)) {
-        throw new Error(`[manage_todo_list] todo ${input.id} is '${target.status}' and final; it cannot be changed.`);
+        throw new Error(`todo ${input.id} is '${target.status}' and final; it cannot be changed.`);
     }
     assertForwardTransition(target.status, input.status, input.id);
     if (input.status === "in_progress") {
@@ -93,7 +93,7 @@ export function assertSequentialScope(todos, input) {
         }
         const busyChild = targetRoot.children?.find((child) => child.status === "in_progress" && child.id !== input.id);
         if (busyChild) {
-            throw new Error(`[manage_todo_list] subtask ${busyChild.id} is still in_progress. Finish it (or cancel it) before starting ${input.id}.`);
+            throw new Error(`subtask ${busyChild.id} is still in_progress. Finish it (or cancel it) before starting ${input.id}.`);
         }
     }
     return { targetRoot, target };
@@ -134,7 +134,7 @@ export function updateTodoById(todos, input) {
         return { ...root, status, children };
     });
     if (!updated) {
-        throw new Error(`[manage_todo_list] todo id ${input.id} was not found`);
+        throw new Error(`todo id ${input.id} was not found`);
     }
     return { todos: nextTodos, updated };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamflaz/opencode-todolist",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Hierarchical todo list plugin for OpenCode with a real-time TUI widget.",
   "type": "module",
   "files": [