@encoredigitalgroup/opencode 0.2.3 → 0.2.4

package/README.md

@@ -2,8 +2,8 @@
 
 `@encoredigitalgroup/opencode` adds file pickers for OpenCode planning commands.
 
-The TUI provides `/plan-review`, `/plan-resync`, `/plan-split`, and `/plan-execute` commands. Each command opens a picker for plans in `docs/_planning` and inserts the
-selected plan into the prompt. The server entry attaches the matching installed skill to the prompt.
+The TUI provides `/plan-review`, `/plan-resync`, `/plan-split`, and `/plan-execute` commands. Each command opens a picker for plans in `docs/_planning` and
+inserts the selected plan into the prompt. The server entry attaches the matching installed skill to the prompt.
 
 ## Install
 
@@ -24,15 +24,15 @@ OpenCode v2 loads this package from the `plugins` array. Add an object entry wit
 }
 ```
 
-Restart OpenCode after changing the configuration. OpenCode downloads missing npm plugins that appear in the `plugins` array, so you do not need to install this package
-with Bun or npm yourself. This package supports OpenCode v2 only; replace the legacy `plugin` configuration entry when migrating from OpenCode v1.
+Restart OpenCode after changing the configuration. OpenCode downloads missing npm plugins that appear in the `plugins` array, so you do not need to install this
+package with Bun or npm yourself. This package supports OpenCode v2 only; replace the legacy `plugin` configuration entry when migrating from OpenCode v1.
 
 The plugin resolves the mapped skills through OpenCode, so those skills can live in any location that OpenCode discovers.
 
 ## 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.
+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.
 
 ```json
 {
@@ -52,7 +52,21 @@ supported command's installed skill name. Unspecified values use the defaults: `
 }
 ```
 
-Launching a picker from an existing session submits to that session. Launching one from the home screen creates and displays a new session before submitting the selected plan.
+Launching a picker from an existing session submits to that session. Launching one from the home screen creates and displays a new session before submitting the
+selected plan.
+
+## Todo tracker
+
+The plugin registers the direct `todotracker` tool. Each call replaces the current session's complete ordered todo list. Pass an empty `todos` array to clear the
+list.
+Each todo requires:
+
+- `content`: a non-empty string containing at least one non-whitespace character.
+- `status`: `pending`, `in_progress`, `completed`, or `cancelled`.
+- `priority`: `high`, `medium`, or `low`.
+
+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.
 
 ## Development
 

package/dist/lib/TodoTracker.d.ts

@@ -0,0 +1,53 @@
+import type { SessionMessageInfo } from "@opencode/client";
+import type { Plugin as ServerPlugin } from "@opencode/plugin";
+export type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
+export type TodoPriority = "high" | "medium" | "low";
+export type Todo = {
+    content: string;
+    status: TodoStatus;
+    priority: TodoPriority;
+};
+export type TodoTrackerInput = {
+    todos: Todo[];
+};
+export type TodoTrackerResultMetadata = {
+    todos: Todo[];
+};
+export declare const todoTrackerInput: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["todos"];
+    readonly properties: {
+        readonly todos: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["content", "status", "priority"];
+                readonly properties: {
+                    readonly content: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                        readonly pattern: "\\S";
+                    };
+                    readonly status: {
+                        readonly enum: readonly ["pending", "in_progress", "completed", "cancelled"];
+                    };
+                    readonly priority: {
+                        readonly enum: readonly ["high", "medium", "low"];
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const todoTrackerName = "todotracker";
+export declare const todoTrackerDescription: string;
+export declare function isTodoTrackerInput(value: unknown): value is TodoTrackerInput;
+export declare function isTodoResultMetadata(value: unknown): value is TodoTrackerResultMetadata;
+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>;
+}

package/dist/lib/TodoTracker.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/index.js

@@ -128,6 +128,123 @@ class SkillCommands {
   }
 }
 
+// src/lib/TodoTracker.ts
+var todoTrackerInput = {
+  type: "object",
+  additionalProperties: false,
+  required: ["todos"],
+  properties: {
+    todos: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["content", "status", "priority"],
+        properties: {
+          content: { type: "string", minLength: 1, pattern: "\\S" },
+          status: { enum: ["pending", "in_progress", "completed", "cancelled"] },
+          priority: { enum: ["high", "medium", "low"] }
+        }
+      }
+    }
+  }
+};
+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 todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
+var todoPriorities = ["high", "medium", "low"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+  const expected = new Set(keys);
+  return Object.keys(value).length === keys.length && Object.keys(value).every((key) => expected.has(key));
+}
+function isTodoStatus(value) {
+  return typeof value === "string" && todoStatuses.includes(value);
+}
+function isTodoPriority(value) {
+  return typeof value === "string" && todoPriorities.includes(value);
+}
+function isTodo(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["content", "status", "priority"])) {
+    return false;
+  }
+  return typeof value.content === "string" && value.content.length >= 1 && /\S/.test(value.content) && isTodoStatus(value.status) && isTodoPriority(value.priority);
+}
+function isTodoList(value) {
+  return Array.isArray(value) && value.every(isTodo);
+}
+function isTodoTrackerInput(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["todos"]) && isTodoList(value.todos);
+}
+function isTodoResultMetadata(value) {
+  return isTodoTrackerInput(value);
+}
+function todosFromToolResult(metadata, content) {
+  if (isTodoResultMetadata(metadata)) {
+    return metadata.todos;
+  }
+  for (const item of content) {
+    if (item.type !== "text" || item.text === undefined) {
+      continue;
+    }
+    try {
+      const todos = JSON.parse(item.text);
+      if (isTodoList(todos)) {
+        return todos;
+      }
+    } catch {}
+  }
+  return [];
+}
+function todosFromMessages(messages) {
+  for (const message of messages.toReversed()) {
+    if (message.type !== "assistant")
+      continue;
+    for (const part of message.content.toReversed()) {
+      if (part.type === "tool" && part.name === todoTrackerName && part.state.status === "completed") {
+        return todosFromToolResult(part.state.metadata, part.state.content);
+      }
+    }
+  }
+  return [];
+}
+
+class TodoTracker {
+  static marker(status) {
+    switch (status) {
+      case "pending":
+        return "[ ]";
+      case "in_progress":
+        return "[~]";
+      case "completed":
+        return "[x]";
+      case "cancelled":
+        return "[-]";
+    }
+  }
+  static sidebar(messages) {
+    return todosFromMessages(messages);
+  }
+  static register(context) {
+    return context.tool.transform((tools) => {
+      tools.add({
+        name: todoTrackerName,
+        description: todoTrackerDescription,
+        input: todoTrackerInput,
+        options: { codemode: false },
+        async execute(input) {
+          if (!isTodoTrackerInput(input)) {
+            throw new Error("Invalid todotracker input.");
+          }
+          return { content: JSON.stringify(input.todos), metadata: { todos: input.todos } };
+        }
+      });
+    });
+  }
+}
+
 // src/server/index.ts
 var server_default = Plugin.define({
   id: "@encoredigitalgroup/opencode",
@@ -135,7 +252,7 @@ var server_default = Plugin.define({
     const pluginConfig = ConfigLoader.loadConfig(ctx.options);
     const command = "feature-planning";
     const route = SkillCommands.getCommands(pluginConfig)[command];
-    const registration = await ctx.command.transform((commands) => {
+    const commandRegistration = await ctx.command.transform((commands) => {
       commands.add({
         name: command,
         description: route.description,
@@ -154,7 +271,20 @@ var server_default = Plugin.define({
         }
       });
     });
-    return registration.dispose;
+    let toolRegistration;
+    try {
+      toolRegistration = await TodoTracker.register(ctx);
+    } catch (error) {
+      await commandRegistration.dispose();
+      throw error;
+    }
+    return async () => {
+      try {
+        await toolRegistration.dispose();
+      } finally {
+        await commandRegistration.dispose();
+      }
+    };
   }
 });
 export {

package/dist/tui/index.js

@@ -2,6 +2,749 @@
 // src/tui/index.tsx
 import { Plugin } from "@opencode/plugin/tui";
 
+// node_modules/solid-js/dist/solid.js
+var sharedConfig = {
+  context: undefined,
+  registry: undefined,
+  effects: undefined,
+  done: false,
+  getContextId() {
+    return getContextId(this.context.count);
+  },
+  getNextContextId() {
+    return getContextId(this.context.count++);
+  }
+};
+function getContextId(count) {
+  const num = String(count), len = num.length - 1;
+  return sharedConfig.context.id + (len ? String.fromCharCode(96 + len) : "") + num;
+}
+function setHydrateContext(context) {
+  sharedConfig.context = context;
+}
+var IS_DEV = false;
+var equalFn = (a, b) => a === b;
+var $PROXY = Symbol("solid-proxy");
+var $TRACK = Symbol("solid-track");
+var $DEVCOMP = Symbol("solid-dev-component");
+var signalOptions = {
+  equals: equalFn
+};
+var ERROR = null;
+var runEffects = runQueue;
+var STALE = 1;
+var PENDING = 2;
+var UNOWNED = {
+  owned: null,
+  cleanups: null,
+  context: null,
+  owner: null
+};
+var Owner = null;
+var Transition = null;
+var Scheduler = null;
+var ExternalSourceConfig = null;
+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 = {
+    value,
+    observers: null,
+    observerSlots: null,
+    comparator: options.equals || undefined
+  };
+  const setter = (value) => {
+    if (typeof value === "function") {
+      if (Transition && Transition.running && Transition.sources.has(s))
+        value = value(s.tValue);
+      else
+        value = value(s.value);
+    }
+    return writeSignal(s, value);
+  };
+  return [readSignal.bind(s), setter];
+}
+function createEffect(fn, value, options) {
+  runEffects = runUserEffects;
+  const c = createComputation(fn, value, false, STALE), s = SuspenseContext && useContext(SuspenseContext);
+  if (s)
+    c.suspense = s;
+  if (!options || !options.render)
+    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();
+  const listener = Listener;
+  Listener = null;
+  try {
+    if (ExternalSourceConfig)
+      return ExternalSourceConfig.untrack(fn);
+    return fn();
+  } finally {
+    Listener = listener;
+  }
+}
+function onMount(fn) {
+  createEffect(() => untrack(fn));
+}
+function onCleanup(fn) {
+  if (Owner === null)
+    ;
+  else if (Owner.cleanups === null)
+    Owner.cleanups = [fn];
+  else
+    Owner.cleanups.push(fn);
+  return fn;
+}
+function startTransition(fn) {
+  if (Transition && Transition.running) {
+    fn();
+    return Transition.done;
+  }
+  const l = Listener;
+  const o = Owner;
+  return Promise.resolve().then(() => {
+    Listener = l;
+    Owner = o;
+    let t;
+    if (Scheduler || SuspenseContext) {
+      t = Transition || (Transition = {
+        sources: new Set,
+        effects: [],
+        promises: new Set,
+        disposed: new Set,
+        queue: new Set,
+        running: true
+      });
+      t.done || (t.done = new Promise((res) => t.resolve = res));
+      t.running = true;
+    }
+    runUpdates(fn, false);
+    Listener = Owner = null;
+    return t ? t.done : undefined;
+  });
+}
+var [transPending, setTransPending] = /* @__PURE__ */ createSignal(false);
+function useContext(context) {
+  let value;
+  return Owner && Owner.context && (value = Owner.context[context.id]) !== undefined ? value : context.defaultValue;
+}
+var SuspenseContext;
+function readSignal() {
+  const runningTransition = Transition && Transition.running;
+  if (this.sources && (runningTransition ? this.tState : this.state)) {
+    if ((runningTransition ? this.tState : this.state) === STALE)
+      updateComputation(this);
+    else {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(this), false);
+      Updates = updates;
+    }
+  }
+  if (Listener) {
+    const sSlot = this.observers ? this.observers.length : 0;
+    if (!Listener.sources) {
+      Listener.sources = [this];
+      Listener.sourceSlots = [sSlot];
+    } else {
+      Listener.sources.push(this);
+      Listener.sourceSlots.push(sSlot);
+    }
+    if (!this.observers) {
+      this.observers = [Listener];
+      this.observerSlots = [Listener.sources.length - 1];
+    } else {
+      this.observers.push(Listener);
+      this.observerSlots.push(Listener.sources.length - 1);
+    }
+  }
+  if (runningTransition && Transition.sources.has(this))
+    return this.tValue;
+  return this.value;
+}
+function writeSignal(node, value, isComp) {
+  let current = Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value;
+  if (!node.comparator || !node.comparator(current, value)) {
+    if (Transition) {
+      const TransitionRunning = Transition.running;
+      if (TransitionRunning || !isComp && Transition.sources.has(node)) {
+        Transition.sources.add(node);
+        node.tValue = value;
+      }
+      if (!TransitionRunning)
+        node.value = value;
+    } else
+      node.value = value;
+    if (node.observers && node.observers.length) {
+      runUpdates(() => {
+        for (let i = 0;i < node.observers.length; i += 1) {
+          const o = node.observers[i];
+          const TransitionRunning = Transition && Transition.running;
+          if (TransitionRunning && Transition.disposed.has(o))
+            continue;
+          if (TransitionRunning ? !o.tState : !o.state) {
+            if (o.pure)
+              Updates.push(o);
+            else
+              Effects.push(o);
+            if (o.observers)
+              markDownstream(o);
+          }
+          if (!TransitionRunning)
+            o.state = STALE;
+          else
+            o.tState = STALE;
+        }
+        if (Updates.length > 1e6) {
+          Updates = [];
+          if (IS_DEV)
+            ;
+          throw new Error;
+        }
+      }, false);
+    }
+  }
+  return value;
+}
+function updateComputation(node) {
+  if (!node.fn)
+    return;
+  cleanNode(node);
+  const time = ExecCount;
+  runComputation(node, Transition && Transition.running && Transition.sources.has(node) ? node.tValue : node.value, time);
+  if (Transition && !Transition.running && Transition.sources.has(node)) {
+    queueMicrotask(() => {
+      runUpdates(() => {
+        Transition && (Transition.running = true);
+        Listener = Owner = node;
+        runComputation(node, node.tValue, time);
+        Listener = Owner = null;
+      }, false);
+    });
+  }
+}
+function runComputation(node, value, time) {
+  let nextValue;
+  const owner = Owner, listener = Listener;
+  Listener = Owner = node;
+  try {
+    nextValue = node.fn(value);
+  } catch (err) {
+    if (node.pure) {
+      if (Transition && Transition.running) {
+        node.tState = STALE;
+        node.tOwned && node.tOwned.forEach(cleanNode);
+        node.tOwned = undefined;
+      } else {
+        node.state = STALE;
+        node.owned && node.owned.forEach(cleanNode);
+        node.owned = null;
+      }
+    }
+    node.updatedAt = time + 1;
+    return handleError(err);
+  } finally {
+    Listener = listener;
+    Owner = owner;
+  }
+  if (!node.updatedAt || node.updatedAt <= time) {
+    if (node.updatedAt != null && "observers" in node) {
+      writeSignal(node, nextValue, true);
+    } else if (Transition && Transition.running && node.pure) {
+      if (!Transition.sources.has(node))
+        node.value = nextValue;
+      Transition.sources.add(node);
+      node.tValue = nextValue;
+    } else
+      node.value = nextValue;
+    node.updatedAt = time;
+  }
+}
+function createComputation(fn, init, pure, state = STALE, options) {
+  const c = {
+    fn,
+    state,
+    updatedAt: null,
+    owned: null,
+    sources: null,
+    sourceSlots: null,
+    cleanups: null,
+    value: init,
+    owner: Owner,
+    context: Owner ? Owner.context : null,
+    pure
+  };
+  if (Transition && Transition.running) {
+    c.state = 0;
+    c.tState = state;
+  }
+  if (Owner === null)
+    ;
+  else if (Owner !== UNOWNED) {
+    if (Transition && Transition.running && Owner.pure) {
+      if (!Owner.tOwned)
+        Owner.tOwned = [c];
+      else
+        Owner.tOwned.push(c);
+    } else {
+      if (!Owner.owned)
+        Owner.owned = [c];
+      else
+        Owner.owned.push(c);
+    }
+  }
+  if (ExternalSourceConfig && c.fn) {
+    const sourceFn = c.fn;
+    const [track, trigger] = createSignal(undefined, {
+      equals: false
+    });
+    const ordinary = ExternalSourceConfig.factory(sourceFn, trigger);
+    onCleanup(() => ordinary.dispose());
+    let inTransition;
+    const triggerInTransition = () => startTransition(trigger).then(() => {
+      if (inTransition) {
+        inTransition.dispose();
+        inTransition = undefined;
+      }
+    });
+    c.fn = (x) => {
+      track();
+      if (Transition && Transition.running) {
+        if (!inTransition)
+          inTransition = ExternalSourceConfig.factory(sourceFn, triggerInTransition);
+        return inTransition.track(x);
+      }
+      return ordinary.track(x);
+    };
+  }
+  return c;
+}
+function runTop(node) {
+  const runningTransition = Transition && Transition.running;
+  if ((runningTransition ? node.tState : node.state) === 0)
+    return;
+  if ((runningTransition ? node.tState : node.state) === PENDING)
+    return lookUpstream(node);
+  if (node.suspense && untrack(node.suspense.inFallback))
+    return node.suspense.effects.push(node);
+  const ancestors = [node];
+  while ((node = node.owner) && (!node.updatedAt || node.updatedAt < ExecCount)) {
+    if (runningTransition && Transition.disposed.has(node))
+      return;
+    if (runningTransition ? node.tState : node.state)
+      ancestors.push(node);
+  }
+  for (let i = ancestors.length - 1;i >= 0; i--) {
+    node = ancestors[i];
+    if (runningTransition) {
+      let top = node, prev = ancestors[i + 1];
+      while ((top = top.owner) && top !== prev) {
+        if (Transition.disposed.has(top))
+          return;
+      }
+    }
+    if ((runningTransition ? node.tState : node.state) === STALE) {
+      updateComputation(node);
+    } else if ((runningTransition ? node.tState : node.state) === PENDING) {
+      const updates = Updates;
+      Updates = null;
+      runUpdates(() => lookUpstream(node, ancestors[0]), false);
+      Updates = updates;
+    }
+  }
+}
+function runUpdates(fn, init) {
+  if (Updates)
+    return fn();
+  let wait = false;
+  if (!init)
+    Updates = [];
+  if (Effects)
+    wait = true;
+  else
+    Effects = [];
+  ExecCount++;
+  try {
+    const res = fn();
+    completeUpdates(wait);
+    return res;
+  } catch (err) {
+    if (!wait)
+      Effects = null;
+    Updates = null;
+    handleError(err);
+  }
+}
+function completeUpdates(wait) {
+  if (Updates) {
+    if (Scheduler && Transition && Transition.running)
+      scheduleQueue(Updates);
+    else
+      runQueue(Updates);
+    Updates = null;
+  }
+  if (wait)
+    return;
+  let res;
+  if (Transition) {
+    if (!Transition.promises.size && !Transition.queue.size) {
+      const sources = Transition.sources;
+      const disposed = Transition.disposed;
+      Effects.push.apply(Effects, Transition.effects);
+      res = Transition.resolve;
+      for (const e of Effects) {
+        "tState" in e && (e.state = e.tState);
+        delete e.tState;
+      }
+      Transition = null;
+      runUpdates(() => {
+        for (const d of disposed)
+          cleanNode(d);
+        for (const v of sources) {
+          v.value = v.tValue;
+          if (v.owned) {
+            for (let i = 0, len = v.owned.length;i < len; i++)
+              cleanNode(v.owned[i]);
+          }
+          if (v.tOwned)
+            v.owned = v.tOwned;
+          delete v.tValue;
+          delete v.tOwned;
+          v.tState = 0;
+        }
+        setTransPending(false);
+      }, false);
+    } else if (Transition.running) {
+      Transition.running = false;
+      Transition.effects.push.apply(Transition.effects, Effects);
+      Effects = null;
+      setTransPending(true);
+      return;
+    }
+  }
+  const e = Effects;
+  Effects = null;
+  if (e.length)
+    runUpdates(() => runEffects(e), false);
+  if (res)
+    res();
+}
+function runQueue(queue) {
+  for (let i = 0;i < queue.length; i++)
+    runTop(queue[i]);
+}
+function scheduleQueue(queue) {
+  for (let i = 0;i < queue.length; i++) {
+    const item = queue[i];
+    const tasks = Transition.queue;
+    if (!tasks.has(item)) {
+      tasks.add(item);
+      Scheduler(() => {
+        tasks.delete(item);
+        runUpdates(() => {
+          Transition.running = true;
+          runTop(item);
+        }, false);
+        Transition && (Transition.running = false);
+      });
+    }
+  }
+}
+function runUserEffects(queue) {
+  let i, userLength = 0;
+  for (i = 0;i < queue.length; i++) {
+    const e = queue[i];
+    if (!e.user)
+      runTop(e);
+    else
+      queue[userLength++] = e;
+  }
+  if (sharedConfig.context) {
+    if (sharedConfig.count) {
+      sharedConfig.effects || (sharedConfig.effects = []);
+      sharedConfig.effects.push(...queue.slice(0, userLength));
+      return;
+    }
+    setHydrateContext();
+  }
+  if (sharedConfig.effects && (sharedConfig.done || !sharedConfig.count)) {
+    queue = [...sharedConfig.effects, ...queue];
+    userLength += sharedConfig.effects.length;
+    delete sharedConfig.effects;
+  }
+  for (i = 0;i < userLength; i++)
+    runTop(queue[i]);
+}
+function lookUpstream(node, ignore) {
+  const runningTransition = Transition && Transition.running;
+  if (runningTransition)
+    node.tState = 0;
+  else
+    node.state = 0;
+  for (let i = 0;i < node.sources.length; i += 1) {
+    const source = node.sources[i];
+    if (source.sources) {
+      const state = runningTransition ? source.tState : source.state;
+      if (state === STALE) {
+        if (source !== ignore && (!source.updatedAt || source.updatedAt < ExecCount))
+          runTop(source);
+      } else if (state === PENDING)
+        lookUpstream(source, ignore);
+    }
+  }
+}
+function markDownstream(node) {
+  const runningTransition = Transition && Transition.running;
+  for (let i = 0;i < node.observers.length; i += 1) {
+    const o = node.observers[i];
+    if (runningTransition ? !o.tState : !o.state) {
+      if (runningTransition)
+        o.tState = PENDING;
+      else
+        o.state = PENDING;
+      if (o.pure)
+        Updates.push(o);
+      else
+        Effects.push(o);
+      o.observers && markDownstream(o);
+    }
+  }
+}
+function cleanNode(node) {
+  let i;
+  if (node.sources) {
+    while (node.sources.length) {
+      const source = node.sources.pop(), index = node.sourceSlots.pop(), obs = source.observers;
+      if (obs && obs.length) {
+        const n = obs.pop(), s = source.observerSlots.pop();
+        if (index < obs.length) {
+          n.sourceSlots[s] = index;
+          obs[index] = n;
+          source.observerSlots[index] = s;
+        }
+      }
+    }
+  }
+  if (node.tOwned) {
+    for (i = node.tOwned.length - 1;i >= 0; i--)
+      cleanNode(node.tOwned[i]);
+    delete node.tOwned;
+  }
+  if (Transition && Transition.running && node.pure) {
+    reset(node, true);
+  } else if (node.owned) {
+    for (i = node.owned.length - 1;i >= 0; i--)
+      cleanNode(node.owned[i]);
+    node.owned = null;
+  }
+  if (node.cleanups) {
+    for (i = node.cleanups.length - 1;i >= 0; i--)
+      node.cleanups[i]();
+    node.cleanups = null;
+  }
+  if (Transition && Transition.running)
+    node.tState = 0;
+  else
+    node.state = 0;
+}
+function reset(node, top) {
+  if (!top) {
+    node.tState = 0;
+    Transition.disposed.add(node);
+  }
+  if (node.owned) {
+    for (let i = 0;i < node.owned.length; i++)
+      reset(node.owned[i]);
+  }
+}
+function castError(err) {
+  if (err instanceof Error)
+    return err;
+  return new Error(typeof err === "string" ? err : "Unknown error", {
+    cause: err
+  });
+}
+function runErrors(err, fns, owner) {
+  try {
+    for (const f of fns)
+      f(err);
+  } catch (e) {
+    handleError(e, owner && owner.owner || null);
+  }
+}
+function handleError(err, owner = Owner) {
+  const fns = ERROR && owner && owner.context && owner.context[ERROR];
+  const error = castError(err);
+  if (!fns)
+    throw error;
+  if (Effects)
+    Effects.push({
+      fn() {
+        runErrors(error, fns, owner);
+      },
+      state: STALE
+    });
+  else
+    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 {
   static getDefaultSkillMappings() {
@@ -319,22 +1062,184 @@ class FilePickerCommands {
   }
 }
 
+// src/lib/TodoTracker.ts
+var todoTrackerInput = {
+  type: "object",
+  additionalProperties: false,
+  required: ["todos"],
+  properties: {
+    todos: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["content", "status", "priority"],
+        properties: {
+          content: { type: "string", minLength: 1, pattern: "\\S" },
+          status: { enum: ["pending", "in_progress", "completed", "cancelled"] },
+          priority: { enum: ["high", "medium", "low"] }
+        }
+      }
+    }
+  }
+};
+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 todoStatuses = ["pending", "in_progress", "completed", "cancelled"];
+var todoPriorities = ["high", "medium", "low"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+  const expected = new Set(keys);
+  return Object.keys(value).length === keys.length && Object.keys(value).every((key) => expected.has(key));
+}
+function isTodoStatus(value) {
+  return typeof value === "string" && todoStatuses.includes(value);
+}
+function isTodoPriority(value) {
+  return typeof value === "string" && todoPriorities.includes(value);
+}
+function isTodo(value) {
+  if (!isRecord(value) || !hasOnlyKeys(value, ["content", "status", "priority"])) {
+    return false;
+  }
+  return typeof value.content === "string" && value.content.length >= 1 && /\S/.test(value.content) && isTodoStatus(value.status) && isTodoPriority(value.priority);
+}
+function isTodoList(value) {
+  return Array.isArray(value) && value.every(isTodo);
+}
+function isTodoTrackerInput(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["todos"]) && isTodoList(value.todos);
+}
+function isTodoResultMetadata(value) {
+  return isTodoTrackerInput(value);
+}
+function todosFromToolResult(metadata, content) {
+  if (isTodoResultMetadata(metadata)) {
+    return metadata.todos;
+  }
+  for (const item of content) {
+    if (item.type !== "text" || item.text === undefined) {
+      continue;
+    }
+    try {
+      const todos = JSON.parse(item.text);
+      if (isTodoList(todos)) {
+        return todos;
+      }
+    } catch {}
+  }
+  return [];
+}
+function todosFromMessages(messages) {
+  for (const message of messages.toReversed()) {
+    if (message.type !== "assistant")
+      continue;
+    for (const part of message.content.toReversed()) {
+      if (part.type === "tool" && part.name === todoTrackerName && part.state.status === "completed") {
+        return todosFromToolResult(part.state.metadata, part.state.content);
+      }
+    }
+  }
+  return [];
+}
+
+class TodoTracker {
+  static marker(status) {
+    switch (status) {
+      case "pending":
+        return "[ ]";
+      case "in_progress":
+        return "[~]";
+      case "completed":
+        return "[x]";
+      case "cancelled":
+        return "[-]";
+    }
+  }
+  static sidebar(messages) {
+    return todosFromMessages(messages);
+  }
+  static register(context) {
+    return context.tool.transform((tools) => {
+      tools.add({
+        name: todoTrackerName,
+        description: todoTrackerDescription,
+        input: todoTrackerInput,
+        options: { codemode: false },
+        async execute(input) {
+          if (!isTodoTrackerInput(input)) {
+            throw new Error("Invalid todotracker input.");
+          }
+          return { content: JSON.stringify(input.todos), metadata: { todos: input.todos } };
+        }
+      });
+    });
+  }
+}
+
 // src/tui/index.tsx
-import { jsx, Fragment } from "@opentui/solid/jsx-runtime";
+import { jsx, jsxs, Fragment } from "@opentui/solid/jsx-runtime";
 function PickerCommandLayer(props) {
   FilePickerCommands.register(props.context, props.config);
   return /* @__PURE__ */ jsx(Fragment, {});
 }
+function TodoSidebar(props) {
+  const todos = createMemo(() => TodoTracker.sidebar(props.context.data.session.message.list(props.sessionID)));
+  const color = (status) => status === "in_progress" ? props.context.theme.text.feedback.warning.base : props.context.theme.text.muted;
+  onMount(() => {
+    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}`
+          })
+        })
+      ]
+    })
+  });
+}
 var tui_default = Plugin.define({
   id: "@encoredigitalgroup/opencode",
   setup(ctx) {
-    return ctx.ui.slot({
+    const appSlot = ctx.ui.slot({
       append: "app",
       render: () => /* @__PURE__ */ jsx(PickerCommandLayer, {
         context: ctx,
         config: ConfigLoader.loadConfig(ctx.options)
       })
     });
+    let sidebarSlot;
+    try {
+      sidebarSlot = ctx.ui.slot({
+        append: "sidebar.content",
+        render: (input) => /* @__PURE__ */ jsx(TodoSidebar, {
+          context: ctx,
+          sessionID: input.sessionID
+        })
+      });
+    } catch (error) {
+      appSlot();
+      throw error;
+    }
+    return () => {
+      try {
+        sidebarSlot();
+      } finally {
+        appSlot();
+      }
+    };
   }
 });
 export {

package/package.json

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