@encoredigitalgroup/opencode 0.2.5 → 0.2.7

package/README.md

@@ -32,9 +32,8 @@ The plugin resolves the mapped skills through OpenCode, so those skills can live
 ## Configuration
 
 Set `planDirectory` and `skillMappings` in the object's `options` field. `planDirectory` is a non-empty path relative to the workspace. `skillMappings` can override
-any supported command's installed skill name. `enforceTodoTracker` defaults to `true`; set it to `false` to disable tracker-refresh enforcement. `readOnlyTools`
-and `writeCapableTools` add custom tools to the built-in classifications. Unspecified values use the defaults: `docs/_planning`, the command's existing skill name,
-and no custom tool classifications.
+any supported command's installed skill name. `enforceTodoTracker` defaults to `true`; set it to `false` to disable tracker-refresh enforcement. Unspecified values
+use `docs/_planning` and the command's existing skill name.
 
 ```json
 {
@@ -42,16 +41,14 @@ and no custom tool classifications.
   "plugins": [
     {
       "package": "@encoredigitalgroup/opencode",
-      "options": {
-        "planDirectory": "plans",
-        "enforceTodoTracker": false,
-        "readOnlyTools": ["repository_status"],
-        "skillMappings": {
-          "plan-review": "custom-plan-review",
-          "plan-execute": "custom-plan-execute"
-        },
-        "writeCapableTools": ["deploy"]
-      }
+        "options": {
+          "planDirectory": "plans",
+          "enforceTodoTracker": false,
+          "skillMappings": {
+            "plan-review": "custom-plan-review",
+            "plan-execute": "custom-plan-execute"
+          }
+        }
     }
   ]
 }
@@ -70,17 +67,21 @@ Each todo requires:
 - `status`: `pending`, `in_progress`, `completed`, or `cancelled`.
 - `priority`: `high`, `medium`, or `low`.
 
+Each tracker call replaces the complete ordered list. Include discovered work and current statuses in every replacement. Mark a todo completed only after
+verifying its result. Mark a todo cancelled only when the user explicitly cancels that work. Never clear a list or change a status to avoid tracker updates,
+tool restrictions, or difficult work.
+
 The checklist renders only in the OpenCode terminal TUI sidebar. After a restart, it appears only when the completed `todotracker` result is in the host's loaded
 message cache. That cache starts with the newest 20 messages, so older results are not shown until the host has loaded them.
 
-After a session's first successful `todotracker` call, the plugin requires another call before a later write-capable tool runs. OpenCode's built-in write-capable
-tools are `edit`, `patch`, `shell`, `subagent`, and `write`. Built-in read-only tools are `glob`, `grep`, `lsp`, `read`, `skill`, `webfetch`, and `websearch`; the
-eleventh read-only call requires a tracker update. Session and user-interaction tools, such as `question` and `todo`, are not enforced. `readOnlyTools` and
-`writeCapableTools` extend these lists for custom tools. If a tool appears in both lists, the write-capable classification takes precedence. The plugin also supports
-the `apply_patch` and `bash` compatibility aliases as write-capable tools. Enforcement is disabled for sessions that have never used `todotracker`, and can be
-disabled for all sessions with `"enforceTodoTracker": false`.
+Automatic refresh enforcement runs only while the latest valid list contains nonterminal work. After a session's first successful `todotracker` call, the plugin
+requires another update at least once per minute while that work remains. When an update is due, it blocks every other tool until the tracker is updated. A valid
+empty list or a list containing only `completed` and `cancelled` todos ends automatic refresh enforcement. A tracked subagent completing also requires its parent
+session to update the tracker before continuing. Malformed tracker results remain enforcement-active because completion was not verified. Enforcement is disabled
+for sessions that have never used `todotracker`, and can be disabled for all sessions with `"enforceTodoTracker": false`.
 
-When a session is idle, the sidebar renders pending and in-progress todos as completed. It restores their original statuses when work resumes.
+When a root session is idle, the sidebar renders the final in-progress todo as completed only when every earlier todo is completed. It restores the original status
+when work resumes.
 
 ## Development
 

package/dist/config/ConfigTypes.d.ts

@@ -4,15 +4,19 @@ export type SkillMappings = Record<SkillCommand, string>;
 export type PluginConfig = {
     enforceTodoTracker: boolean;
     planDirectory: string;
+    /** @deprecated Tool classifications no longer affect todo tracker enforcement. */
     readOnlyTools: string[];
     skillMappings: SkillMappings;
+    /** @deprecated Tool classifications no longer affect todo tracker enforcement. */
     writeCapableTools: string[];
 };
 export type UserPluginConfig = {
     enforceTodoTracker?: boolean;
     planDirectory?: string;
+    /** @deprecated Tool classifications no longer affect todo tracker enforcement. */
     readOnlyTools?: string[];
     skillMappings?: Partial<SkillMappings>;
+    /** @deprecated Tool classifications no longer affect todo tracker enforcement. */
     writeCapableTools?: string[];
 };
 /** Configuration type utilities. */

package/dist/lib/TodoTracker.d.ts

@@ -50,5 +50,7 @@ export declare function todosFromMessages(messages: readonly SessionMessageInfo[
 export declare class TodoTracker {
     static marker(status: TodoStatus): string;
     static sidebar(messages: readonly SessionMessageInfo[], completed?: boolean): readonly Todo[];
-    static register(context: ServerPlugin.Context, config: PluginConfig): Promise<import("@opencode/plugin/promise/registration").Registration>;
+    static register(context: ServerPlugin.Context, config: PluginConfig): Promise<{
+        dispose: () => Promise<void>;
+    }>;
 }

package/dist/server/index.js

@@ -192,6 +192,10 @@ var todoTrackerInput = {
 var todoTrackerName = "todotracker";
 var todoTrackerDescription = "Replace the current session's complete ordered todo list. " + "Pass every remaining todo on each call; pass an empty array to clear the list.";
 var trackerRefreshMessage = "Update todotracker with the complete current todo list, including newly discovered work and current statuses, before continuing tool work.";
+var todoTrackerContract = "Todotracker rules: Each call replaces the complete ordered todo list. Include discovered work and current statuses in every replacement. Mark a todo completed only after verifying its result. Mark a todo cancelled only when the user explicitly cancels that work. Never clear a list or change a status to avoid tracker updates, tool restrictions, or difficult work.";
+var compactionTrackerContract = `Retain this TodoTracker contract verbatim in the continuation summary:
+
+${todoTrackerContract}`;
 var todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
 var todoPriorities = ["high", "medium", "low"];
 function isRecord(value) {
@@ -222,22 +226,34 @@ function isTodoTrackerInput(value) {
 function isTodoResultMetadata(value) {
   return isTodoTrackerInput(value);
 }
-function todosFromToolResult(metadata, content) {
+function parseTodoList(metadata, content) {
   if (isTodoResultMetadata(metadata)) {
-    return metadata.todos;
+    return { valid: true, todos: metadata.todos };
   }
-  for (const item of content) {
+  const contentItems = typeof content === "string" ? [{ type: "text", text: content }] : content;
+  for (const item of contentItems) {
     if (item.type !== "text" || item.text === undefined) {
       continue;
     }
     try {
       const todos = JSON.parse(item.text);
       if (isTodoList(todos)) {
-        return todos;
+        return { valid: true, todos };
       }
     } catch {}
   }
-  return [];
+  return { valid: false };
+}
+function todosFromToolResult(metadata, content) {
+  const parsed = parseTodoList(metadata, content);
+  return parsed.valid ? parsed.todos : [];
+}
+function isTerminalTodoList(todos) {
+  return todos.every((todo) => todo.status === "completed" || todo.status === "cancelled");
+}
+function stateFromTodoResult(metadata, content, refreshedAt = Date.now()) {
+  const parsed = parseTodoList(metadata, content);
+  return parsed.valid && isTerminalTodoList(parsed.todos) ? { kind: "untracked" } : refreshedTrackerState(refreshedAt);
 }
 function todosFromMessages(messages) {
   for (const message of messages.toReversed()) {
@@ -251,35 +267,17 @@ function todosFromMessages(messages) {
   }
   return [];
 }
-var builtInReadOnlyTools = new Set(["glob", "grep", "lsp", "read", "skill", "webfetch", "websearch"]);
-var builtInWriteCapableTools = new Set(["edit", "patch", "shell", "subagent", "write"]);
-var compatibilityWriteCapableTools = new Set(["apply_patch", "bash"]);
-var readToolsBeforeRefresh = 10;
-function refreshedTrackerState() {
-  return { kind: "tracked", readToolsSinceRefresh: 0, requiresRefreshBeforeWrite: false };
+var trackerRefreshIntervalMs = 60000;
+function refreshedTrackerState(refreshedAt = Date.now()) {
+  return { kind: "tracked", refreshedAt, refreshRequired: false };
 }
-function isReadOnlyTool(tool, config) {
-  return builtInReadOnlyTools.has(tool) || config.readOnlyTools.includes(tool);
+function trackerRefreshDue(state, now = Date.now()) {
+  return state.kind === "tracked" && (state.refreshRequired || now - state.refreshedAt >= trackerRefreshIntervalMs);
 }
-function isWriteCapableTool(tool, config) {
-  return builtInWriteCapableTools.has(tool) || compatibilityWriteCapableTools.has(tool) || config.writeCapableTools.includes(tool);
+function requiresTrackerRefresh(state, tool, now = Date.now()) {
+  return tool !== todoTrackerName && trackerRefreshDue(state, now);
 }
-function requiresTrackerRefresh(state, tool, config) {
-  if (state.kind === "untracked" || tool === todoTrackerName) {
-    return false;
-  }
-  if (isWriteCapableTool(tool, config)) {
-    return state.requiresRefreshBeforeWrite;
-  }
-  if (isReadOnlyTool(tool, config)) {
-    return state.readToolsSinceRefresh >= readToolsBeforeRefresh;
-  }
-  return false;
-}
-function requiresTrackerRefreshBeforeMoreWork(state) {
-  return state.kind === "tracked" && (state.requiresRefreshBeforeWrite || state.readToolsSinceRefresh >= readToolsBeforeRefresh);
-}
-function trackerStateFromMessages(messages, config) {
+function trackerStateFromMessages(messages) {
   let state = { kind: "untracked" };
   for (const message of messages) {
     if (message.type !== "assistant") {
@@ -290,13 +288,7 @@ function trackerStateFromMessages(messages, config) {
         continue;
       }
       if (part.name === todoTrackerName) {
-        state = refreshedTrackerState();
-      } else if (state.kind === "tracked") {
-        if (isWriteCapableTool(part.name, config)) {
-          state.requiresRefreshBeforeWrite = true;
-        } else if (isReadOnlyTool(part.name, config)) {
-          state.readToolsSinceRefresh += 1;
-        }
+        state = stateFromTodoResult(part.state.metadata, part.state.content, part.time?.completed ?? part.time?.ran ?? part.time?.created ?? message.time.completed ?? message.time.created);
       }
     }
   }
@@ -305,82 +297,81 @@ function trackerStateFromMessages(messages, config) {
 
 class TodoTrackerEnforcement {
   context;
-  config;
   states = new Map;
-  constructor(context, config) {
+  instructedSessionIDs = new Set;
+  constructor(context) {
     this.context = context;
-    this.config = config;
   }
   async stateFor(sessionID) {
     const existing = this.states.get(sessionID);
     if (existing !== undefined) {
       return existing;
     }
-    const state = trackerStateFromMessages(await this.context.session.context({ sessionID }), this.config);
+    const state = trackerStateFromMessages(await this.context.session.context({ sessionID }));
     this.states.set(sessionID, state);
     return state;
   }
-  async markWriteRequiresRefresh(sessionID) {
+  async requireTrackerRefresh(sessionID) {
     const state = await this.stateFor(sessionID);
     if (state.kind === "tracked") {
-      state.requiresRefreshBeforeWrite = true;
+      state.refreshRequired = true;
     }
   }
-  async register() {
+  async register(enforceRefresh) {
     let before;
     let after;
     let context;
+    let compaction;
+    let observer;
+    const controller = new AbortController;
     try {
-      before = await this.context.tool.hook("execute.before", async (event) => {
-        const state = await this.stateFor(event.sessionID);
-        if (requiresTrackerRefresh(state, event.tool, this.config)) {
-          throw new Error(trackerRefreshMessage);
-        }
-        if (state.kind === "tracked") {
-          if (isWriteCapableTool(event.tool, this.config)) {
-            state.requiresRefreshBeforeWrite = true;
-          } else if (isReadOnlyTool(event.tool, this.config)) {
-            state.readToolsSinceRefresh += 1;
-          }
-        }
-      });
-      after = await this.context.tool.hook("execute.after", async (event) => {
-        if (event.status !== "completed") {
-          return;
-        }
-        if (event.tool === todoTrackerName) {
-          this.states.set(event.sessionID, refreshedTrackerState());
-          return;
+      context = await this.context.session.hook("context", async (event) => {
+        if (!this.instructedSessionIDs.has(event.sessionID)) {
+          this.instructedSessionIDs.add(event.sessionID);
+          event.system.push({ type: "text", text: todoTrackerContract });
         }
-        const state = await this.stateFor(event.sessionID);
-        if (state.kind !== "tracked") {
+        if (!enforceRefresh) {
           return;
         }
-      });
-      context = await this.context.session.hook("context", async (event) => {
-        const state = await this.stateFor(event.sessionID);
-        if (requiresTrackerRefreshBeforeMoreWork(state)) {
+        if (trackerRefreshDue(await this.stateFor(event.sessionID))) {
           event.system.push({ type: "text", text: trackerRefreshMessage });
         }
       });
+      compaction = await this.context.session.hook("compaction", async (event) => {
+        event.system.push({ type: "text", text: compactionTrackerContract });
+      });
+      if (enforceRefresh) {
+        before = await this.context.tool.hook("execute.before", async (event) => {
+          if (requiresTrackerRefresh(await this.stateFor(event.sessionID), event.tool)) {
+            throw new Error(trackerRefreshMessage);
+          }
+        });
+        after = await this.context.tool.hook("execute.after", async (event) => {
+          if (event.status === "completed" && event.tool === todoTrackerName) {
+            this.states.set(event.sessionID, stateFromTodoResult(event.result.metadata, event.result.content ?? []));
+          }
+        });
+        observer = this.observeSubagentCompletion(controller.signal);
+      }
       const beforeRegistration = before;
       const afterRegistration = after;
       const contextRegistration = context;
-      const controller = new AbortController;
-      const observer = this.observeSubagentCompletion(controller.signal);
+      const compactionRegistration = compaction;
       return {
         dispose: async () => {
           controller.abort();
           await Promise.all([
-            beforeRegistration.dispose(),
-            afterRegistration.dispose(),
+            beforeRegistration?.dispose(),
+            afterRegistration?.dispose(),
             contextRegistration.dispose(),
+            compactionRegistration.dispose(),
             observer
           ]);
         }
       };
     } catch (error) {
-      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose()]);
+      controller.abort();
+      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose(), compaction?.dispose(), observer]);
       throw error;
     }
   }
@@ -392,7 +383,7 @@ class TodoTrackerEnforcement {
         }
         const session = await this.context.session.get({ sessionID: event.data.sessionID });
         if (session.parentID !== undefined) {
-          await this.markWriteRequiresRefresh(session.parentID);
+          await this.requireTrackerRefresh(session.parentID);
         }
       }
     } catch (error) {
@@ -418,10 +409,11 @@ class TodoTracker {
   }
   static sidebar(messages, completed = false) {
     const todos = todosFromMessages(messages);
-    if (!completed) {
+    const finalTodo = todos.at(-1);
+    if (!completed || finalTodo?.status !== "in_progress" || todos.slice(0, -1).some((todo) => todo.status !== "completed")) {
       return todos;
     }
-    return todos.map((todo) => todo.status === "pending" || todo.status === "in_progress" ? { ...todo, status: "completed" } : todo);
+    return [...todos.slice(0, -1), { ...finalTodo, status: "completed" }];
   }
   static async register(context, config) {
     const tool = await context.tool.transform((tools) => {
@@ -438,11 +430,8 @@ class TodoTracker {
         }
       });
     });
-    if (!config.enforceTodoTracker) {
-      return tool;
-    }
     try {
-      const enforcement = await new TodoTrackerEnforcement(context, config).register();
+      const enforcement = await new TodoTrackerEnforcement(context).register(config.enforceTodoTracker);
       return {
         dispose: async () => {
           try {

package/dist/tui/index.js

@@ -977,6 +977,10 @@ var todoTrackerInput = {
 var todoTrackerName = "todotracker";
 var todoTrackerDescription = "Replace the current session's complete ordered todo list. " + "Pass every remaining todo on each call; pass an empty array to clear the list.";
 var trackerRefreshMessage = "Update todotracker with the complete current todo list, including newly discovered work and current statuses, before continuing tool work.";
+var todoTrackerContract = "Todotracker rules: Each call replaces the complete ordered todo list. Include discovered work and current statuses in every replacement. Mark a todo completed only after verifying its result. Mark a todo cancelled only when the user explicitly cancels that work. Never clear a list or change a status to avoid tracker updates, tool restrictions, or difficult work.";
+var compactionTrackerContract = `Retain this TodoTracker contract verbatim in the continuation summary:
+
+${todoTrackerContract}`;
 var todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
 var todoPriorities = ["high", "medium", "low"];
 function isRecord(value) {
@@ -1007,22 +1011,34 @@ function isTodoTrackerInput(value) {
 function isTodoResultMetadata(value) {
   return isTodoTrackerInput(value);
 }
-function todosFromToolResult(metadata, content) {
+function parseTodoList(metadata, content) {
   if (isTodoResultMetadata(metadata)) {
-    return metadata.todos;
+    return { valid: true, todos: metadata.todos };
   }
-  for (const item of content) {
+  const contentItems = typeof content === "string" ? [{ type: "text", text: content }] : content;
+  for (const item of contentItems) {
     if (item.type !== "text" || item.text === undefined) {
       continue;
     }
     try {
       const todos = JSON.parse(item.text);
       if (isTodoList(todos)) {
-        return todos;
+        return { valid: true, todos };
       }
     } catch {}
   }
-  return [];
+  return { valid: false };
+}
+function todosFromToolResult(metadata, content) {
+  const parsed = parseTodoList(metadata, content);
+  return parsed.valid ? parsed.todos : [];
+}
+function isTerminalTodoList(todos) {
+  return todos.every((todo) => todo.status === "completed" || todo.status === "cancelled");
+}
+function stateFromTodoResult(metadata, content, refreshedAt = Date.now()) {
+  const parsed = parseTodoList(metadata, content);
+  return parsed.valid && isTerminalTodoList(parsed.todos) ? { kind: "untracked" } : refreshedTrackerState(refreshedAt);
 }
 function todosFromMessages(messages) {
   for (const message of messages.toReversed()) {
@@ -1036,35 +1052,17 @@ function todosFromMessages(messages) {
   }
   return [];
 }
-var builtInReadOnlyTools = new Set(["glob", "grep", "lsp", "read", "skill", "webfetch", "websearch"]);
-var builtInWriteCapableTools = new Set(["edit", "patch", "shell", "subagent", "write"]);
-var compatibilityWriteCapableTools = new Set(["apply_patch", "bash"]);
-var readToolsBeforeRefresh = 10;
-function refreshedTrackerState() {
-  return { kind: "tracked", readToolsSinceRefresh: 0, requiresRefreshBeforeWrite: false };
-}
-function isReadOnlyTool(tool, config) {
-  return builtInReadOnlyTools.has(tool) || config.readOnlyTools.includes(tool);
+var trackerRefreshIntervalMs = 60000;
+function refreshedTrackerState(refreshedAt = Date.now()) {
+  return { kind: "tracked", refreshedAt, refreshRequired: false };
 }
-function isWriteCapableTool(tool, config) {
-  return builtInWriteCapableTools.has(tool) || compatibilityWriteCapableTools.has(tool) || config.writeCapableTools.includes(tool);
+function trackerRefreshDue(state, now = Date.now()) {
+  return state.kind === "tracked" && (state.refreshRequired || now - state.refreshedAt >= trackerRefreshIntervalMs);
 }
-function requiresTrackerRefresh(state, tool, config) {
-  if (state.kind === "untracked" || tool === todoTrackerName) {
-    return false;
-  }
-  if (isWriteCapableTool(tool, config)) {
-    return state.requiresRefreshBeforeWrite;
-  }
-  if (isReadOnlyTool(tool, config)) {
-    return state.readToolsSinceRefresh >= readToolsBeforeRefresh;
-  }
-  return false;
+function requiresTrackerRefresh(state, tool, now = Date.now()) {
+  return tool !== todoTrackerName && trackerRefreshDue(state, now);
 }
-function requiresTrackerRefreshBeforeMoreWork(state) {
-  return state.kind === "tracked" && (state.requiresRefreshBeforeWrite || state.readToolsSinceRefresh >= readToolsBeforeRefresh);
-}
-function trackerStateFromMessages(messages, config) {
+function trackerStateFromMessages(messages) {
   let state = { kind: "untracked" };
   for (const message of messages) {
     if (message.type !== "assistant") {
@@ -1075,13 +1073,7 @@ function trackerStateFromMessages(messages, config) {
         continue;
       }
       if (part.name === todoTrackerName) {
-        state = refreshedTrackerState();
-      } else if (state.kind === "tracked") {
-        if (isWriteCapableTool(part.name, config)) {
-          state.requiresRefreshBeforeWrite = true;
-        } else if (isReadOnlyTool(part.name, config)) {
-          state.readToolsSinceRefresh += 1;
-        }
+        state = stateFromTodoResult(part.state.metadata, part.state.content, part.time?.completed ?? part.time?.ran ?? part.time?.created ?? message.time.completed ?? message.time.created);
       }
     }
   }
@@ -1090,82 +1082,81 @@ function trackerStateFromMessages(messages, config) {
 
 class TodoTrackerEnforcement {
   context;
-  config;
   states = new Map;
-  constructor(context, config) {
+  instructedSessionIDs = new Set;
+  constructor(context) {
     this.context = context;
-    this.config = config;
   }
   async stateFor(sessionID) {
     const existing = this.states.get(sessionID);
     if (existing !== undefined) {
       return existing;
     }
-    const state = trackerStateFromMessages(await this.context.session.context({ sessionID }), this.config);
+    const state = trackerStateFromMessages(await this.context.session.context({ sessionID }));
     this.states.set(sessionID, state);
     return state;
   }
-  async markWriteRequiresRefresh(sessionID) {
+  async requireTrackerRefresh(sessionID) {
     const state = await this.stateFor(sessionID);
     if (state.kind === "tracked") {
-      state.requiresRefreshBeforeWrite = true;
+      state.refreshRequired = true;
     }
   }
-  async register() {
+  async register(enforceRefresh) {
     let before;
     let after;
     let context;
+    let compaction;
+    let observer;
+    const controller = new AbortController;
     try {
-      before = await this.context.tool.hook("execute.before", async (event) => {
-        const state = await this.stateFor(event.sessionID);
-        if (requiresTrackerRefresh(state, event.tool, this.config)) {
-          throw new Error(trackerRefreshMessage);
-        }
-        if (state.kind === "tracked") {
-          if (isWriteCapableTool(event.tool, this.config)) {
-            state.requiresRefreshBeforeWrite = true;
-          } else if (isReadOnlyTool(event.tool, this.config)) {
-            state.readToolsSinceRefresh += 1;
-          }
-        }
-      });
-      after = await this.context.tool.hook("execute.after", async (event) => {
-        if (event.status !== "completed") {
-          return;
-        }
-        if (event.tool === todoTrackerName) {
-          this.states.set(event.sessionID, refreshedTrackerState());
-          return;
+      context = await this.context.session.hook("context", async (event) => {
+        if (!this.instructedSessionIDs.has(event.sessionID)) {
+          this.instructedSessionIDs.add(event.sessionID);
+          event.system.push({ type: "text", text: todoTrackerContract });
         }
-        const state = await this.stateFor(event.sessionID);
-        if (state.kind !== "tracked") {
+        if (!enforceRefresh) {
           return;
         }
-      });
-      context = await this.context.session.hook("context", async (event) => {
-        const state = await this.stateFor(event.sessionID);
-        if (requiresTrackerRefreshBeforeMoreWork(state)) {
+        if (trackerRefreshDue(await this.stateFor(event.sessionID))) {
           event.system.push({ type: "text", text: trackerRefreshMessage });
         }
       });
+      compaction = await this.context.session.hook("compaction", async (event) => {
+        event.system.push({ type: "text", text: compactionTrackerContract });
+      });
+      if (enforceRefresh) {
+        before = await this.context.tool.hook("execute.before", async (event) => {
+          if (requiresTrackerRefresh(await this.stateFor(event.sessionID), event.tool)) {
+            throw new Error(trackerRefreshMessage);
+          }
+        });
+        after = await this.context.tool.hook("execute.after", async (event) => {
+          if (event.status === "completed" && event.tool === todoTrackerName) {
+            this.states.set(event.sessionID, stateFromTodoResult(event.result.metadata, event.result.content ?? []));
+          }
+        });
+        observer = this.observeSubagentCompletion(controller.signal);
+      }
       const beforeRegistration = before;
       const afterRegistration = after;
       const contextRegistration = context;
-      const controller = new AbortController;
-      const observer = this.observeSubagentCompletion(controller.signal);
+      const compactionRegistration = compaction;
       return {
         dispose: async () => {
           controller.abort();
           await Promise.all([
-            beforeRegistration.dispose(),
-            afterRegistration.dispose(),
+            beforeRegistration?.dispose(),
+            afterRegistration?.dispose(),
             contextRegistration.dispose(),
+            compactionRegistration.dispose(),
             observer
           ]);
         }
       };
     } catch (error) {
-      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose()]);
+      controller.abort();
+      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose(), compaction?.dispose(), observer]);
       throw error;
     }
   }
@@ -1177,7 +1168,7 @@ class TodoTrackerEnforcement {
         }
         const session = await this.context.session.get({ sessionID: event.data.sessionID });
         if (session.parentID !== undefined) {
-          await this.markWriteRequiresRefresh(session.parentID);
+          await this.requireTrackerRefresh(session.parentID);
         }
       }
     } catch (error) {
@@ -1203,10 +1194,11 @@ class TodoTracker {
   }
   static sidebar(messages, completed = false) {
     const todos = todosFromMessages(messages);
-    if (!completed) {
+    const finalTodo = todos.at(-1);
+    if (!completed || finalTodo?.status !== "in_progress" || todos.slice(0, -1).some((todo) => todo.status !== "completed")) {
       return todos;
     }
-    return todos.map((todo) => todo.status === "pending" || todo.status === "in_progress" ? { ...todo, status: "completed" } : todo);
+    return [...todos.slice(0, -1), { ...finalTodo, status: "completed" }];
   }
   static async register(context, config) {
     const tool = await context.tool.transform((tools) => {
@@ -1223,11 +1215,8 @@ class TodoTracker {
         }
       });
     });
-    if (!config.enforceTodoTracker) {
-      return tool;
-    }
     try {
-      const enforcement = await new TodoTrackerEnforcement(context, config).register();
+      const enforcement = await new TodoTrackerEnforcement(context).register(config.enforceTodoTracker);
       return {
         dispose: async () => {
           try {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@encoredigitalgroup/opencode",
     "type": "module",
-    "version": "0.2.5",
+    "version": "0.2.7",
     "description": "OpenCode file-picker commands for planning skills.",
     "publishConfig": {
         "access": "public"