@encoredigitalgroup/opencode 0.2.3 → 0.2.5

package/dist/tui/index.js

@@ -1,6 +1,600 @@
 // @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 = {
+  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 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 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");
 
 // src/config/ConfigDefaults.ts
 class ConfigDefaults {
@@ -15,8 +609,11 @@ class ConfigDefaults {
   }
   static getDefaultConfig() {
     return {
+      enforceTodoTracker: true,
       planDirectory: "docs/_planning",
-      skillMappings: this.getDefaultSkillMappings()
+      readOnlyTools: [],
+      skillMappings: this.getDefaultSkillMappings(),
+      writeCapableTools: []
     };
   }
 }
@@ -39,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;
   }
 }
@@ -58,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.`);
@@ -84,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;
@@ -99,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) {
@@ -319,22 +953,382 @@ 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 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) {
+  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 [];
+}
+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) {
+    switch (status) {
+      case "pending":
+        return "[ ]";
+      case "in_progress":
+        return "[~]";
+      case "completed":
+        return "[x]";
+      case "cancelled":
+        return "[-]";
+    }
+  }
+  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 async register(context, config) {
+    const tool = await 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 } };
+        }
+      });
+    });
+    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;
+    }
+  }
+}
+
 // 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 = () => 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__ */ 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({
   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 {