@encoredigitalgroup/opencode 0.2.4 → 0.2.5

package/README.md

@@ -32,7 +32,9 @@ 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. Unspecified values use the defaults: `docs/_planning` and the command's existing skill name.
+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.
 
 ```json
 {
@@ -42,10 +44,13 @@ any supported command's installed skill name. Unspecified values use the default
       "package": "@encoredigitalgroup/opencode",
       "options": {
         "planDirectory": "plans",
+        "enforceTodoTracker": false,
+        "readOnlyTools": ["repository_status"],
         "skillMappings": {
           "plan-review": "custom-plan-review",
           "plan-execute": "custom-plan-execute"
-        }
+        },
+        "writeCapableTools": ["deploy"]
       }
     }
   ]
@@ -68,6 +73,15 @@ Each todo requires:
 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`.
+
+When a session is idle, the sidebar renders pending and in-progress todos as completed. It restores their original statuses when work resumes.
+
 ## Development
 
 ```sh

package/dist/config/ConfigLoader.d.ts

@@ -4,6 +4,8 @@ import { type PluginConfig } from "./ConfigTypes.js";
 export declare class ConfigLoader {
     private static stringOption;
     private static planDirectoryOption;
+    private static booleanOption;
+    private static toolNamesOption;
     /** Get valid skill mappings from plugin options. */
     private static skillMappingsOption;
     /** Get the configured option values that can override the defaults. */

package/dist/config/ConfigTypes.d.ts

@@ -2,12 +2,18 @@ export declare const skillCommands: readonly ["feature-planning", "plan-execute"
 export type SkillCommand = (typeof skillCommands)[number];
 export type SkillMappings = Record<SkillCommand, string>;
 export type PluginConfig = {
+    enforceTodoTracker: boolean;
     planDirectory: string;
+    readOnlyTools: string[];
     skillMappings: SkillMappings;
+    writeCapableTools: string[];
 };
 export type UserPluginConfig = {
+    enforceTodoTracker?: boolean;
     planDirectory?: string;
+    readOnlyTools?: string[];
     skillMappings?: Partial<SkillMappings>;
+    writeCapableTools?: string[];
 };
 /** Configuration type utilities. */
 export declare class ConfigTypes {

package/dist/lib/TodoTracker.d.ts

@@ -1,5 +1,6 @@
 import type { SessionMessageInfo } from "@opencode/client";
 import type { Plugin as ServerPlugin } from "@opencode/plugin";
+import type { PluginConfig } from "../config";
 export type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
 export type TodoPriority = "high" | "medium" | "low";
 export type Todo = {
@@ -48,6 +49,6 @@ export declare function isTodoResultMetadata(value: unknown): value is TodoTrack
 export declare function todosFromMessages(messages: readonly SessionMessageInfo[]): readonly Todo[];
 export declare class TodoTracker {
     static marker(status: TodoStatus): string;
-    static sidebar(messages: readonly SessionMessageInfo[]): readonly Todo[];
-    static register(context: ServerPlugin.Context): Promise<import("@opencode/plugin/promise/registration").Registration>;
+    static sidebar(messages: readonly SessionMessageInfo[], completed?: boolean): readonly Todo[];
+    static register(context: ServerPlugin.Context, config: PluginConfig): Promise<import("@opencode/plugin/promise/registration").Registration>;
 }

package/dist/server/index.js

@@ -15,8 +15,11 @@ class ConfigDefaults {
   }
   static getDefaultConfig() {
     return {
+      enforceTodoTracker: true,
       planDirectory: "docs/_planning",
-      skillMappings: this.getDefaultSkillMappings()
+      readOnlyTools: [],
+      skillMappings: this.getDefaultSkillMappings(),
+      writeCapableTools: []
     };
   }
 }
@@ -39,14 +42,23 @@ class ConfigTypes {
 class ConfigMerger {
   static merge(userConfig) {
     const config = ConfigDefaults.getDefaultConfig();
+    if (userConfig.enforceTodoTracker !== undefined) {
+      config.enforceTodoTracker = userConfig.enforceTodoTracker;
+    }
     if (userConfig.planDirectory !== undefined) {
       config.planDirectory = userConfig.planDirectory;
     }
+    if (userConfig.readOnlyTools !== undefined) {
+      config.readOnlyTools = userConfig.readOnlyTools;
+    }
     if (userConfig.skillMappings !== undefined) {
       for (const command of ConfigTypes.getSkillCommands()) {
         config.skillMappings[command] = userConfig.skillMappings[command] ?? config.skillMappings[command];
       }
     }
+    if (userConfig.writeCapableTools !== undefined) {
+      config.writeCapableTools = userConfig.writeCapableTools;
+    }
     return config;
   }
 }
@@ -58,6 +70,11 @@ class ConfigValidator {
     if (config.planDirectory.trim() === "") {
       errors.push("Invalid planDirectory: must be a non-empty string.");
     }
+    for (const [option, tools] of [["readOnlyTools", config.readOnlyTools], ["writeCapableTools", config.writeCapableTools]]) {
+      if (tools.some((tool) => tool.trim() === "")) {
+        errors.push(`Invalid ${option}: tool names must be non-empty strings.`);
+      }
+    }
     for (const command of ConfigTypes.getSkillCommands()) {
       if (config.skillMappings[command].trim() === "") {
         errors.push(`Invalid skillMappings.${command}: must be a non-empty string.`);
@@ -84,6 +101,23 @@ class ConfigLoader {
     const directory = this.stringOption(value)?.replace(/\/+$/, "");
     return directory === "" ? undefined : directory;
   }
+  static booleanOption(value) {
+    return typeof value === "boolean" ? value : undefined;
+  }
+  static toolNamesOption(value) {
+    if (!Array.isArray(value)) {
+      return;
+    }
+    const toolNames = [];
+    for (const valueTool of value) {
+      const tool = this.stringOption(valueTool);
+      if (tool === undefined) {
+        return;
+      }
+      toolNames.push(tool);
+    }
+    return toolNames;
+  }
   static skillMappingsOption(value) {
     if (typeof value !== "object" || value === null) {
       return;
@@ -99,11 +133,17 @@ class ConfigLoader {
     return skillMappings;
   }
   static getUserConfig(options) {
+    const enforceTodoTracker = this.booleanOption(options?.enforceTodoTracker);
     const planDirectory = this.planDirectoryOption(options?.planDirectory);
+    const readOnlyTools = this.toolNamesOption(options?.readOnlyTools);
     const skillMappings = this.skillMappingsOption(options?.skillMappings);
+    const writeCapableTools = this.toolNamesOption(options?.writeCapableTools);
     return {
+      ...enforceTodoTracker === undefined ? {} : { enforceTodoTracker },
       ...planDirectory === undefined ? {} : { planDirectory },
-      ...skillMappings === undefined ? {} : { skillMappings }
+      ...readOnlyTools === undefined ? {} : { readOnlyTools },
+      ...skillMappings === undefined ? {} : { skillMappings },
+      ...writeCapableTools === undefined ? {} : { writeCapableTools }
     };
   }
   static loadConfig(options) {
@@ -151,6 +191,7 @@ 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 todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
 var todoPriorities = ["high", "medium", "low"];
 function isRecord(value) {
@@ -210,6 +251,157 @@ 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);
+}
+function isWriteCapableTool(tool, config) {
+  return builtInWriteCapableTools.has(tool) || compatibilityWriteCapableTools.has(tool) || config.writeCapableTools.includes(tool);
+}
+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) {
+  let state = { kind: "untracked" };
+  for (const message of messages) {
+    if (message.type !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool" || part.state.status !== "completed") {
+        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;
+        }
+      }
+    }
+  }
+  return state;
+}
+
+class TodoTrackerEnforcement {
+  context;
+  config;
+  states = new Map;
+  constructor(context, config) {
+    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);
+    this.states.set(sessionID, state);
+    return state;
+  }
+  async markWriteRequiresRefresh(sessionID) {
+    const state = await this.stateFor(sessionID);
+    if (state.kind === "tracked") {
+      state.requiresRefreshBeforeWrite = true;
+    }
+  }
+  async register() {
+    let before;
+    let after;
+    let context;
+    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;
+        }
+        const state = await this.stateFor(event.sessionID);
+        if (state.kind !== "tracked") {
+          return;
+        }
+      });
+      context = await this.context.session.hook("context", async (event) => {
+        const state = await this.stateFor(event.sessionID);
+        if (requiresTrackerRefreshBeforeMoreWork(state)) {
+          event.system.push({ type: "text", text: trackerRefreshMessage });
+        }
+      });
+      const beforeRegistration = before;
+      const afterRegistration = after;
+      const contextRegistration = context;
+      const controller = new AbortController;
+      const observer = this.observeSubagentCompletion(controller.signal);
+      return {
+        dispose: async () => {
+          controller.abort();
+          await Promise.all([
+            beforeRegistration.dispose(),
+            afterRegistration.dispose(),
+            contextRegistration.dispose(),
+            observer
+          ]);
+        }
+      };
+    } catch (error) {
+      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose()]);
+      throw error;
+    }
+  }
+  async observeSubagentCompletion(signal) {
+    try {
+      for await (const event of this.context.event.subscribe({ signal })) {
+        if (event.type !== "session.idle") {
+          continue;
+        }
+        const session = await this.context.session.get({ sessionID: event.data.sessionID });
+        if (session.parentID !== undefined) {
+          await this.markWriteRequiresRefresh(session.parentID);
+        }
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        console.error("Unable to watch subagent completion for todo enforcement.", error);
+      }
+    }
+  }
+}
 
 class TodoTracker {
   static marker(status) {
@@ -224,11 +416,15 @@ class TodoTracker {
         return "[-]";
     }
   }
-  static sidebar(messages) {
-    return todosFromMessages(messages);
+  static sidebar(messages, completed = false) {
+    const todos = todosFromMessages(messages);
+    if (!completed) {
+      return todos;
+    }
+    return todos.map((todo) => todo.status === "pending" || todo.status === "in_progress" ? { ...todo, status: "completed" } : todo);
   }
-  static register(context) {
-    return context.tool.transform((tools) => {
+  static async register(context, config) {
+    const tool = await context.tool.transform((tools) => {
       tools.add({
         name: todoTrackerName,
         description: todoTrackerDescription,
@@ -242,6 +438,24 @@ class TodoTracker {
         }
       });
     });
+    if (!config.enforceTodoTracker) {
+      return tool;
+    }
+    try {
+      const enforcement = await new TodoTrackerEnforcement(context, config).register();
+      return {
+        dispose: async () => {
+          try {
+            await enforcement.dispose();
+          } finally {
+            await tool.dispose();
+          }
+        }
+      };
+    } catch (error) {
+      await tool.dispose();
+      throw error;
+    }
   }
 }
 
@@ -273,7 +487,7 @@ var server_default = Plugin.define({
     });
     let toolRegistration;
     try {
-      toolRegistration = await TodoTracker.register(ctx);
+      toolRegistration = await TodoTracker.register(ctx, pluginConfig);
     } catch (error) {
       await commandRegistration.dispose();
       throw error;

package/dist/tui/index.js

@@ -1,6 +1,7 @@
 // @bun
 // src/tui/index.tsx
 import { Plugin } from "@opencode/plugin/tui";
+import { fg, StyledText } from "@opentui/core";
 
 // node_modules/solid-js/dist/solid.js
 var sharedConfig = {
@@ -48,22 +49,6 @@ var Listener = null;
 var Updates = null;
 var Effects = null;
 var ExecCount = 0;
-function createRoot(fn, detachedOwner) {
-  const listener = Listener, owner = Owner, unowned = fn.length === 0, current = detachedOwner === undefined ? owner : detachedOwner, root = unowned ? UNOWNED : {
-    owned: null,
-    cleanups: null,
-    context: current ? current.context : null,
-    owner: current
-  }, updateFn = unowned ? fn : () => fn(() => untrack(() => cleanNode(root)));
-  Owner = root;
-  Listener = null;
-  try {
-    return runUpdates(updateFn, true);
-  } finally {
-    Listener = listener;
-    Owner = owner;
-  }
-}
 function createSignal(value, options) {
   options = options ? Object.assign({}, signalOptions, options) : signalOptions;
   const s = {
@@ -92,19 +77,6 @@ function createEffect(fn, value, options) {
     c.user = true;
   Effects ? Effects.push(c) : updateComputation(c);
 }
-function createMemo(fn, value, options) {
-  options = options ? Object.assign({}, signalOptions, options) : signalOptions;
-  const c = createComputation(fn, value, true, 0);
-  c.observers = null;
-  c.observerSlots = null;
-  c.comparator = options.equals || undefined;
-  if (Scheduler && Transition && Transition.running) {
-    c.tState = STALE;
-    Updates.push(c);
-  } else
-    updateComputation(c);
-  return readSignal.bind(c);
-}
 function untrack(fn) {
   if (!ExternalSourceConfig && Listener === null)
     return fn();
@@ -623,127 +595,6 @@ function handleError(err, owner = Owner) {
     runErrors(error, fns, owner);
 }
 var FALLBACK = Symbol("fallback");
-function dispose(d) {
-  for (let i = 0;i < d.length; i++)
-    d[i]();
-}
-function mapArray(list, mapFn, options = {}) {
-  let items = [], mapped = [], disposers = [], len = 0, indexes = mapFn.length > 1 ? [] : null;
-  onCleanup(() => dispose(disposers));
-  return () => {
-    let newItems = list() || [], newLen = newItems.length, i, j;
-    newItems[$TRACK];
-    return untrack(() => {
-      let newIndices, newIndicesNext, temp, tempdisposers, tempIndexes, start, end, newEnd, item;
-      if (newLen === 0) {
-        if (len !== 0) {
-          dispose(disposers);
-          disposers = [];
-          items = [];
-          mapped = [];
-          len = 0;
-          indexes && (indexes = []);
-        }
-        if (options.fallback) {
-          items = [FALLBACK];
-          mapped[0] = createRoot((disposer) => {
-            disposers[0] = disposer;
-            return options.fallback();
-          });
-          len = 1;
-        }
-      } else if (len === 0) {
-        mapped = new Array(newLen);
-        for (j = 0;j < newLen; j++) {
-          items[j] = newItems[j];
-          mapped[j] = createRoot(mapper);
-        }
-        len = newLen;
-      } else {
-        temp = new Array(newLen);
-        tempdisposers = new Array(newLen);
-        indexes && (tempIndexes = new Array(newLen));
-        for (start = 0, end = Math.min(len, newLen);start < end && items[start] === newItems[start]; start++)
-          ;
-        for (end = len - 1, newEnd = newLen - 1;end >= start && newEnd >= start && items[end] === newItems[newEnd]; end--, newEnd--) {
-          temp[newEnd] = mapped[end];
-          tempdisposers[newEnd] = disposers[end];
-          indexes && (tempIndexes[newEnd] = indexes[end]);
-        }
-        newIndices = new Map;
-        newIndicesNext = new Array(newEnd + 1);
-        for (j = newEnd;j >= start; j--) {
-          item = newItems[j];
-          i = newIndices.get(item);
-          newIndicesNext[j] = i === undefined ? -1 : i;
-          newIndices.set(item, j);
-        }
-        for (i = start;i <= end; i++) {
-          item = items[i];
-          j = newIndices.get(item);
-          if (j !== undefined && j !== -1) {
-            temp[j] = mapped[i];
-            tempdisposers[j] = disposers[i];
-            indexes && (tempIndexes[j] = indexes[i]);
-            j = newIndicesNext[j];
-            newIndices.set(item, j);
-          } else
-            disposers[i]();
-        }
-        for (j = start;j < newLen; j++) {
-          if (j in temp) {
-            mapped[j] = temp[j];
-            disposers[j] = tempdisposers[j];
-            if (indexes) {
-              indexes[j] = tempIndexes[j];
-              indexes[j](j);
-            }
-          } else
-            mapped[j] = createRoot(mapper);
-        }
-        mapped = mapped.slice(0, len = newLen);
-        items = newItems.slice(0);
-      }
-      return mapped;
-    });
-    function mapper(disposer) {
-      disposers[j] = disposer;
-      if (indexes) {
-        const [s, set] = createSignal(j);
-        indexes[j] = set;
-        return mapFn(newItems[j], s);
-      }
-      return mapFn(newItems[j]);
-    }
-  };
-}
-var narrowedError = (name) => `Stale read from <${name}>.`;
-function For(props) {
-  const fallback = "fallback" in props && {
-    fallback: () => props.fallback
-  };
-  return createMemo(mapArray(() => props.each, props.children, fallback || undefined));
-}
-function Show(props) {
-  const keyed = props.keyed;
-  const conditionValue = createMemo(() => props.when, undefined, undefined);
-  const condition = keyed ? conditionValue : createMemo(conditionValue, undefined, {
-    equals: (a, b) => !a === !b
-  });
-  return createMemo(() => {
-    const c = condition();
-    if (c) {
-      const child = props.children;
-      const fn = typeof child === "function" && child.length > 0;
-      return fn ? untrack(() => child(keyed ? c : () => {
-        if (!untrack(condition))
-          throw narrowedError("Show");
-        return conditionValue();
-      })) : child;
-    }
-    return props.fallback;
-  }, undefined, undefined);
-}
 
 // src/config/ConfigDefaults.ts
 class ConfigDefaults {
@@ -758,8 +609,11 @@ class ConfigDefaults {
   }
   static getDefaultConfig() {
     return {
+      enforceTodoTracker: true,
       planDirectory: "docs/_planning",
-      skillMappings: this.getDefaultSkillMappings()
+      readOnlyTools: [],
+      skillMappings: this.getDefaultSkillMappings(),
+      writeCapableTools: []
     };
   }
 }
@@ -782,14 +636,23 @@ class ConfigTypes {
 class ConfigMerger {
   static merge(userConfig) {
     const config = ConfigDefaults.getDefaultConfig();
+    if (userConfig.enforceTodoTracker !== undefined) {
+      config.enforceTodoTracker = userConfig.enforceTodoTracker;
+    }
     if (userConfig.planDirectory !== undefined) {
       config.planDirectory = userConfig.planDirectory;
     }
+    if (userConfig.readOnlyTools !== undefined) {
+      config.readOnlyTools = userConfig.readOnlyTools;
+    }
     if (userConfig.skillMappings !== undefined) {
       for (const command of ConfigTypes.getSkillCommands()) {
         config.skillMappings[command] = userConfig.skillMappings[command] ?? config.skillMappings[command];
       }
     }
+    if (userConfig.writeCapableTools !== undefined) {
+      config.writeCapableTools = userConfig.writeCapableTools;
+    }
     return config;
   }
 }
@@ -801,6 +664,11 @@ class ConfigValidator {
     if (config.planDirectory.trim() === "") {
       errors.push("Invalid planDirectory: must be a non-empty string.");
     }
+    for (const [option, tools] of [["readOnlyTools", config.readOnlyTools], ["writeCapableTools", config.writeCapableTools]]) {
+      if (tools.some((tool) => tool.trim() === "")) {
+        errors.push(`Invalid ${option}: tool names must be non-empty strings.`);
+      }
+    }
     for (const command of ConfigTypes.getSkillCommands()) {
       if (config.skillMappings[command].trim() === "") {
         errors.push(`Invalid skillMappings.${command}: must be a non-empty string.`);
@@ -827,6 +695,23 @@ class ConfigLoader {
     const directory = this.stringOption(value)?.replace(/\/+$/, "");
     return directory === "" ? undefined : directory;
   }
+  static booleanOption(value) {
+    return typeof value === "boolean" ? value : undefined;
+  }
+  static toolNamesOption(value) {
+    if (!Array.isArray(value)) {
+      return;
+    }
+    const toolNames = [];
+    for (const valueTool of value) {
+      const tool = this.stringOption(valueTool);
+      if (tool === undefined) {
+        return;
+      }
+      toolNames.push(tool);
+    }
+    return toolNames;
+  }
   static skillMappingsOption(value) {
     if (typeof value !== "object" || value === null) {
       return;
@@ -842,11 +727,17 @@ class ConfigLoader {
     return skillMappings;
   }
   static getUserConfig(options) {
+    const enforceTodoTracker = this.booleanOption(options?.enforceTodoTracker);
     const planDirectory = this.planDirectoryOption(options?.planDirectory);
+    const readOnlyTools = this.toolNamesOption(options?.readOnlyTools);
     const skillMappings = this.skillMappingsOption(options?.skillMappings);
+    const writeCapableTools = this.toolNamesOption(options?.writeCapableTools);
     return {
+      ...enforceTodoTracker === undefined ? {} : { enforceTodoTracker },
       ...planDirectory === undefined ? {} : { planDirectory },
-      ...skillMappings === undefined ? {} : { skillMappings }
+      ...readOnlyTools === undefined ? {} : { readOnlyTools },
+      ...skillMappings === undefined ? {} : { skillMappings },
+      ...writeCapableTools === undefined ? {} : { writeCapableTools }
     };
   }
   static loadConfig(options) {
@@ -1085,6 +976,7 @@ 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 todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
 var todoPriorities = ["high", "medium", "low"];
 function isRecord(value) {
@@ -1144,6 +1036,157 @@ 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);
+}
+function isWriteCapableTool(tool, config) {
+  return builtInWriteCapableTools.has(tool) || compatibilityWriteCapableTools.has(tool) || config.writeCapableTools.includes(tool);
+}
+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) {
+  let state = { kind: "untracked" };
+  for (const message of messages) {
+    if (message.type !== "assistant") {
+      continue;
+    }
+    for (const part of message.content) {
+      if (part.type !== "tool" || part.state.status !== "completed") {
+        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;
+        }
+      }
+    }
+  }
+  return state;
+}
+
+class TodoTrackerEnforcement {
+  context;
+  config;
+  states = new Map;
+  constructor(context, config) {
+    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);
+    this.states.set(sessionID, state);
+    return state;
+  }
+  async markWriteRequiresRefresh(sessionID) {
+    const state = await this.stateFor(sessionID);
+    if (state.kind === "tracked") {
+      state.requiresRefreshBeforeWrite = true;
+    }
+  }
+  async register() {
+    let before;
+    let after;
+    let context;
+    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;
+        }
+        const state = await this.stateFor(event.sessionID);
+        if (state.kind !== "tracked") {
+          return;
+        }
+      });
+      context = await this.context.session.hook("context", async (event) => {
+        const state = await this.stateFor(event.sessionID);
+        if (requiresTrackerRefreshBeforeMoreWork(state)) {
+          event.system.push({ type: "text", text: trackerRefreshMessage });
+        }
+      });
+      const beforeRegistration = before;
+      const afterRegistration = after;
+      const contextRegistration = context;
+      const controller = new AbortController;
+      const observer = this.observeSubagentCompletion(controller.signal);
+      return {
+        dispose: async () => {
+          controller.abort();
+          await Promise.all([
+            beforeRegistration.dispose(),
+            afterRegistration.dispose(),
+            contextRegistration.dispose(),
+            observer
+          ]);
+        }
+      };
+    } catch (error) {
+      await Promise.all([before?.dispose(), after?.dispose(), context?.dispose()]);
+      throw error;
+    }
+  }
+  async observeSubagentCompletion(signal) {
+    try {
+      for await (const event of this.context.event.subscribe({ signal })) {
+        if (event.type !== "session.idle") {
+          continue;
+        }
+        const session = await this.context.session.get({ sessionID: event.data.sessionID });
+        if (session.parentID !== undefined) {
+          await this.markWriteRequiresRefresh(session.parentID);
+        }
+      }
+    } catch (error) {
+      if (!signal.aborted) {
+        console.error("Unable to watch subagent completion for todo enforcement.", error);
+      }
+    }
+  }
+}
 
 class TodoTracker {
   static marker(status) {
@@ -1158,11 +1201,15 @@ class TodoTracker {
         return "[-]";
     }
   }
-  static sidebar(messages) {
-    return todosFromMessages(messages);
+  static sidebar(messages, completed = false) {
+    const todos = todosFromMessages(messages);
+    if (!completed) {
+      return todos;
+    }
+    return todos.map((todo) => todo.status === "pending" || todo.status === "in_progress" ? { ...todo, status: "completed" } : todo);
   }
-  static register(context) {
-    return context.tool.transform((tools) => {
+  static async register(context, config) {
+    const tool = await context.tool.transform((tools) => {
       tools.add({
         name: todoTrackerName,
         description: todoTrackerDescription,
@@ -1176,6 +1223,24 @@ class TodoTracker {
         }
       });
     });
+    if (!config.enforceTodoTracker) {
+      return tool;
+    }
+    try {
+      const enforcement = await new TodoTrackerEnforcement(context, config).register();
+      return {
+        dispose: async () => {
+          try {
+            await enforcement.dispose();
+          } finally {
+            await tool.dispose();
+          }
+        }
+      };
+    } catch (error) {
+      await tool.dispose();
+      throw error;
+    }
   }
 }
 
@@ -1186,28 +1251,52 @@ function PickerCommandLayer(props) {
   return /* @__PURE__ */ jsx(Fragment, {});
 }
 function TodoSidebar(props) {
-  const todos = createMemo(() => TodoTracker.sidebar(props.context.data.session.message.list(props.sessionID)));
+  const todos = () => TodoTracker.sidebar(props.context.data.session.message.list(props.sessionID), props.context.data.session.status(props.sessionID) === "idle");
   const color = (status) => status === "in_progress" ? props.context.theme.text.feedback.warning.base : props.context.theme.text.muted;
+  const line = (todo) => `${TodoTracker.marker(todo.status)} (${todo.priority}) ${todo.content}`;
+  const plainContent = (items) => items.map(line).join(`
+`);
+  const content = (items) => new StyledText(items.flatMap((todo, index) => [
+    fg(color(todo.status))(`${line(todo)}${index === items.length - 1 ? "" : `
+`}`)
+  ]));
+  let heading;
+  let list;
+  const render = () => {
+    const items = todos();
+    if (heading !== undefined) {
+      heading.content = items.length > 0 ? "Todos" : "";
+    }
+    if (list !== undefined) {
+      list.content = content(items);
+    }
+  };
+  const initialTodos = todos();
   onMount(() => {
+    render();
+    const unlisten = props.context.data.listen?.(() => {
+      render();
+    });
+    onCleanup(() => unlisten?.());
     props.context.data.session.message.sync(props.sessionID).catch(() => {});
   });
-  return /* @__PURE__ */ jsx(Show, {
-    when: todos().length > 0,
-    children: /* @__PURE__ */ jsxs("box", {
-      flexDirection: "column",
-      children: [
-        /* @__PURE__ */ jsx("text", {
-          children: "Todos"
-        }),
-        /* @__PURE__ */ jsx(For, {
-          each: todos(),
-          children: (todo) => /* @__PURE__ */ jsx("text", {
-            fg: color(todo.status),
-            children: `${TodoTracker.marker(todo.status)} (${todo.priority}) ${todo.content}`
-          })
-        })
-      ]
-    })
+  return /* @__PURE__ */ jsxs("box", {
+    flexDirection: "column",
+    children: [
+      /* @__PURE__ */ jsx("text", {
+        ref: (node) => {
+          heading = node;
+        },
+        children: initialTodos.length > 0 ? "Todos" : ""
+      }),
+      /* @__PURE__ */ jsx("text", {
+        ref: (node) => {
+          list = node;
+        },
+        fg: props.context.theme.text.muted,
+        content: plainContent(initialTodos)
+      })
+    ]
   });
 }
 var tui_default = Plugin.define({

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@encoredigitalgroup/opencode",
     "type": "module",
-    "version": "0.2.4",
+    "version": "0.2.5",
     "description": "OpenCode file-picker commands for planning skills.",
     "publishConfig": {
         "access": "public"
@@ -20,16 +20,16 @@
         "solid-js": "1.9.12"
     },
     "devDependencies": {
-        "@opencode/cli": "2.0.22",
-        "@opencode/client": "2.0.22",
-        "@opencode/plugin": "2.0.22",
+        "@opencode/cli": "2.1.4",
+        "@opencode/client": "2.1.4",
+        "@opencode/plugin": "2.1.4",
         "@opentui/core": "0.5.14",
         "@types/bun": "1.4.0",
         "tsfmt": "^0.3.0-beta9",
         "typescript": "5.8.2"
     },
     "scripts": {
-        "build": "rm -rf dist && bun build src/server/index.ts src/tui/index.tsx --outdir dist --target bun --external '@opencode/plugin' --external '@opencode/plugin/*' --external '@opentui/solid' --external '@opentui/solid/*' && tsc --emitDeclarationOnly",
+        "build": "rm -rf dist && bun build src/server/index.ts src/tui/index.tsx --outdir dist --target bun --external '@opencode/plugin' --external '@opencode/plugin/*' --external '@opentui/core' --external '@opentui/core/*' --external '@opentui/solid' --external '@opentui/solid/*' && tsc --emitDeclarationOnly",
         "check": "bun run typecheck && bun run build",
         "pack:check": "bun pm pack --dry-run",
         "test": "bun test",