opencode-codex-memory 0.6.5 → 0.7.1

package/dist/src/v2/tui.js

@@ -0,0 +1,750 @@
+// @bun
+// src/v2/tui.tsx
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { Plugin } from "@opencode/plugin/tui";
+import { createSignal, onCleanup, For } from "solid-js";
+
+// src/v2/status-rpc.ts
+var MEMORY_STATUS_ACTIVITIES = [
+  "idle",
+  "extracting",
+  "consolidating",
+  "retrying",
+  "error",
+  "read_only",
+  "disabled",
+  "stopping"
+];
+var INJECTED_SCHEMA = {
+  type: "object",
+  properties: {
+    sessionTokens: { type: "number" },
+    sessionRequests: { type: "number" },
+    totalTokens: { type: "number" },
+    totalRequests: { type: "number" }
+  },
+  required: ["sessionTokens", "sessionRequests", "totalTokens", "totalRequests"],
+  additionalProperties: false
+};
+var MemoryStatusRpc = {
+  id: "opencode-codex-memory",
+  methods: {
+    status: {
+      input: {
+        type: "object",
+        properties: { sessionID: { type: "string" } },
+        additionalProperties: false
+      },
+      output: {
+        type: "object",
+        properties: {
+          activity: { type: "string", enum: [...MEMORY_STATUS_ACTIVITIES] },
+          useMemories: { type: "boolean" },
+          generateMemories: { type: "boolean" },
+          extractModel: { type: ["string", "null"] },
+          consolidationModel: { type: ["string", "null"] },
+          codexImport: { type: "boolean" },
+          lastSuccessAt: { type: ["number", "null"] },
+          retryAt: { type: ["number", "null"] },
+          warnings: { type: "array", items: { type: "string" } },
+          sessionMode: { type: ["string", "null"], enum: ["enabled", "disabled", "polluted", null] },
+          memoryRoot: { type: "string" },
+          injected: INJECTED_SCHEMA
+        },
+        required: [
+          "activity",
+          "useMemories",
+          "generateMemories",
+          "extractModel",
+          "consolidationModel",
+          "codexImport",
+          "lastSuccessAt",
+          "retryAt",
+          "warnings",
+          "sessionMode",
+          "memoryRoot",
+          "injected"
+        ],
+        additionalProperties: false
+      }
+    },
+    setOption: {
+      input: {
+        type: "object",
+        properties: {
+          key: { type: "string", enum: ["use_memories", "generate_memories"] },
+          value: { type: "boolean" }
+        },
+        required: ["key", "value"],
+        additionalProperties: false
+      },
+      output: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"], additionalProperties: false }
+    },
+    setSessionMode: {
+      input: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          mode: { type: "string", enum: ["enabled", "disabled"] }
+        },
+        required: ["sessionID", "mode"],
+        additionalProperties: false
+      },
+      output: { type: "object", properties: { ok: { type: "boolean" } }, required: ["ok"], additionalProperties: false }
+    },
+    consolidateNow: {
+      input: { type: "object", properties: {}, additionalProperties: false },
+      output: {
+        type: "object",
+        properties: { status: { type: "string" } },
+        required: ["status"],
+        additionalProperties: false
+      }
+    }
+  },
+  events: {
+    changed: { schema: { type: "object", properties: {}, additionalProperties: false } }
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isMemoryStatus(value) {
+  if (!isRecord(value))
+    return false;
+  if (typeof value.activity !== "string" || !MEMORY_STATUS_ACTIVITIES.includes(value.activity)) {
+    return false;
+  }
+  for (const key of ["useMemories", "generateMemories", "codexImport"]) {
+    if (typeof value[key] !== "boolean")
+      return false;
+  }
+  for (const key of ["extractModel", "consolidationModel", "lastSuccessAt", "retryAt"]) {
+    const v = value[key];
+    if (v !== null && typeof v !== (key === "extractModel" || key === "consolidationModel" ? "string" : "number")) {
+      return false;
+    }
+  }
+  if (!Array.isArray(value.warnings) || !value.warnings.every((w) => typeof w === "string")) {
+    return false;
+  }
+  if (value.sessionMode !== null && value.sessionMode !== "enabled" && value.sessionMode !== "disabled" && value.sessionMode !== "polluted") {
+    return false;
+  }
+  if (typeof value.memoryRoot !== "string")
+    return false;
+  const injected = value.injected;
+  if (!isRecord(injected))
+    return false;
+  for (const key of ["sessionTokens", "sessionRequests", "totalTokens", "totalRequests"]) {
+    if (typeof injected[key] !== "number")
+      return false;
+  }
+  return true;
+}
+
+// src/v2/tui.tsx
+var labels = {
+  idle: "Idle",
+  extracting: "Extracting",
+  consolidating: "Consolidating",
+  retrying: "Waiting to retry",
+  error: "Needs attention",
+  read_only: "Read only",
+  disabled: "Disabled",
+  stopping: "Stopping"
+};
+function elapsed(time, now) {
+  if (time == null)
+    return "\u2014";
+  const minutes = Math.max(0, Math.floor((now - time) / 60000));
+  if (minutes === 0)
+    return "just now";
+  if (minutes < 60)
+    return `${minutes}m ago`;
+  if (minutes < 1440)
+    return `${Math.floor(minutes / 60)}h ago`;
+  return `${Math.floor(minutes / 1440)}d ago`;
+}
+function remaining(time, now) {
+  if (time == null)
+    return "\u2014";
+  const minutes = Math.max(0, Math.ceil((time - now) / 60000));
+  if (minutes < 1)
+    return "in <1m";
+  if (minutes < 60)
+    return `in ${minutes}m`;
+  if (minutes < 1440)
+    return `in ${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+  return `in ${Math.floor(minutes / 1440)}d`;
+}
+function registerSlot(context, name, render) {
+  const slot = context.ui.slot;
+  const claim = slot.length <= 1 ? {
+    append: name,
+    render
+  } : undefined;
+  const dispose = claim ? slot(claim) : slot(name, render);
+  return typeof dispose === "function" ? dispose : () => {};
+}
+function themeColor(theme, ...paths) {
+  for (const path of paths) {
+    let cursor = theme;
+    for (const key of path) {
+      if (cursor === null || typeof cursor !== "object") {
+        cursor = undefined;
+        break;
+      }
+      cursor = cursor[key];
+    }
+    if (cursor !== null && typeof cursor === "object" && "default" in cursor) {
+      cursor = cursor.default;
+    }
+    if (cursor !== undefined && cursor !== null)
+      return cursor;
+  }
+  return;
+}
+function formatTokens(n) {
+  if (n >= 1e6)
+    return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1000)
+    return `${(n / 1000).toFixed(1)}K`;
+  return String(n);
+}
+async function fetchStatus(rpc, context, sessionID) {
+  const result = await rpc.status(sessionID ? {
+    sessionID
+  } : {}, {
+    location: context.location ?? context.data.location.default(),
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!isMemoryStatus(result))
+    throw new Error("invalid memory status payload");
+  return result;
+}
+function statusRows(s, now) {
+  return [{
+    label: "Activity",
+    value: labels[s.activity]
+  }, {
+    label: "Read memories",
+    value: s.useMemories ? "On" : "Off",
+    tone: s.useMemories ? "ok" : "muted"
+  }, {
+    label: "Write memories",
+    value: s.generateMemories ? "On" : "Off",
+    tone: s.generateMemories ? "ok" : "muted"
+  }, ...s.sessionMode ? [{
+    label: "This session",
+    value: s.sessionMode === "enabled" ? "Learning" : s.sessionMode === "disabled" ? "Not learning" : "Excluded (external context)",
+    tone: s.sessionMode === "enabled" ? "ok" : "muted"
+  }] : [], {
+    label: "Last consolidated",
+    value: s.lastSuccessAt == null ? "Never" : elapsed(s.lastSuccessAt, now)
+  }, ...s.retryAt == null ? [] : [{
+    label: "Next retry",
+    value: remaining(s.retryAt, now),
+    tone: "warn"
+  }]];
+}
+function usageRows(s) {
+  const inj = s.injected;
+  const per = inj.sessionRequests > 0 ? Math.round(inj.sessionTokens / inj.sessionRequests) : inj.totalRequests > 0 ? Math.round(inj.totalTokens / inj.totalRequests) : 0;
+  return [{
+    label: "Block size",
+    value: per ? `~${formatTokens(per)} tokens / request` : "\u2014"
+  }, {
+    label: "This session",
+    value: `~${formatTokens(inj.sessionTokens)} tokens \xB7 ${inj.sessionRequests} req`
+  }, {
+    label: "Since start",
+    value: `~${formatTokens(inj.totalTokens)} tokens \xB7 ${inj.totalRequests} req`
+  }];
+}
+function configRows(s) {
+  return [{
+    label: "Extraction",
+    value: s.extractModel ?? "Host default"
+  }, {
+    label: "Consolidation",
+    value: s.consolidationModel ?? "Host default"
+  }, {
+    label: "Codex import",
+    value: s.codexImport ? "On" : "Off",
+    tone: s.codexImport ? "ok" : "muted"
+  }, {
+    label: "Location",
+    value: s.memoryRoot
+  }];
+}
+var TABS = ["Overview", "Controls"];
+function MemoryDialog(context, sessionID, initial) {
+  const rpc = context.client.rpc(MemoryStatusRpc);
+  const [status, setStatus] = createSignal(initial);
+  const [tab, setTab] = createSignal("Overview");
+  const [cursor, setCursor] = createSignal(0);
+  const [notice, setNotice] = createSignal("");
+  const [busy, setBusy] = createSignal(false);
+  const now = () => Date.now();
+  const refresh = async () => {
+    try {
+      setStatus(await fetchStatus(rpc, context, sessionID));
+    } catch {
+      setStatus(null);
+    }
+  };
+  const unsubscribe = rpc.events.on("changed", () => void refresh());
+  const timer = setInterval(() => void refresh(), 30000);
+  onCleanup(() => {
+    clearInterval(timer);
+    unsubscribe();
+  });
+  const call = async (method, input, done) => {
+    if (busy())
+      return;
+    setBusy(true);
+    try {
+      await rpc[method](input, {
+        location: context.location ?? context.data.location.default(),
+        signal: AbortSignal.timeout(5000)
+      });
+      setNotice(done);
+      await refresh();
+    } catch (err2) {
+      setNotice(`Failed: ${err2.message}`);
+    } finally {
+      setBusy(false);
+    }
+  };
+  const controls = () => {
+    const s = status();
+    if (!s)
+      return [];
+    const list = [{
+      id: "read",
+      title: "Use memories",
+      hint: "Inject the memory summary into every model request",
+      on: s.useMemories,
+      enabled: true,
+      run: () => void call("setOption", {
+        key: "use_memories",
+        value: !s.useMemories
+      }, s.useMemories ? "Memories are no longer injected." : "Memories are injected again.")
+    }, {
+      id: "learn",
+      title: "Learn from sessions",
+      hint: "Background extraction and consolidation of finished conversations",
+      on: s.generateMemories,
+      enabled: true,
+      run: () => void call("setOption", {
+        key: "generate_memories",
+        value: !s.generateMemories
+      }, s.generateMemories ? "Learning paused." : "Learning resumed.")
+    }];
+    if (sessionID) {
+      const learning = s.sessionMode !== "disabled" && s.sessionMode !== "polluted";
+      list.push({
+        id: "session",
+        title: "Learn from this session",
+        hint: s.sessionMode === "polluted" ? "Auto-excluded: this session pulled in external context" : "Whether this conversation may be extracted into memory",
+        on: learning,
+        enabled: true,
+        run: () => void call("setSessionMode", {
+          sessionID,
+          mode: learning ? "disabled" : "enabled"
+        }, learning ? "This session will not be learned from." : "This session will be learned from.")
+      });
+    }
+    const running = s.activity === "consolidating" || s.activity === "extracting";
+    list.push({
+      id: "now",
+      title: "Consolidate now",
+      hint: running ? "Already running" : s.generateMemories ? "Extract idle sessions and rebuild the summary, skipping the 6h cooldown" : "Turn on learning first",
+      enabled: s.generateMemories && !running,
+      run: () => void call("consolidateNow", {}, "Consolidation started in the background.")
+    });
+    return list;
+  };
+  const activate = (i) => {
+    const c = controls()[i];
+    if (c && c.enabled)
+      c.run();
+  };
+  const move = (d) => {
+    const n = controls().length;
+    if (n === 0)
+      return;
+    setCursor((cursor() + d + n) % n);
+  };
+  context.keymap.layer(() => ({
+    enabled: () => true,
+    commands: [{
+      title: "Previous tab",
+      bind: "left",
+      run: () => {
+        setTab(TABS[(TABS.indexOf(tab()) + TABS.length - 1) % TABS.length]);
+      }
+    }, {
+      title: "Next tab",
+      bind: "right",
+      run: () => {
+        setTab(TABS[(TABS.indexOf(tab()) + 1) % TABS.length]);
+      }
+    }]
+  }));
+  context.keymap.layer(() => ({
+    enabled: () => tab() === "Controls",
+    commands: [{
+      title: "Previous control",
+      bind: "up",
+      run: () => move(-1)
+    }, {
+      title: "Next control",
+      bind: "down",
+      run: () => move(1)
+    }, {
+      title: "Toggle control",
+      bind: "return",
+      run: () => activate(cursor())
+    }, {
+      title: "Toggle control",
+      bind: "space",
+      run: () => activate(cursor())
+    }]
+  }));
+  const th = context.theme;
+  const text = themeColor(th, ["text", "default"], ["text"]);
+  const muted = themeColor(th, ["text", "subdued"], ["textMuted"], ["text"]);
+  const ok = themeColor(th, ["text", "feedback", "success"], ["text"]);
+  const warn = themeColor(th, ["text", "feedback", "warning"], ["text"]);
+  const err = themeColor(th, ["text", "feedback", "error"], ["text"]);
+  const accent = themeColor(th, ["text", "action", "primary"], ["text"]);
+  const selectedBg = themeColor(th, ["background", "action", "primary", "$focused"], ["background", "action", "primary", "focused"]);
+  const toneColor = (t) => t === "ok" ? ok : t === "warn" ? warn : t === "muted" ? muted : text;
+  const LABEL_W = 18;
+  const Rows = (props) => _$createComponent(For, {
+    get each() {
+      return props.rows;
+    },
+    children: (r) => (() => {
+      var _el$ = _$createElement("text"), _el$2 = _$createElement("span");
+      _$insertNode(_el$, _el$2);
+      _$setProp(_el$2, "style", {
+        fg: muted
+      });
+      _$insert(_el$2, () => r.label.padEnd(LABEL_W));
+      _$insert(_el$, () => r.value, null);
+      _$effect((_$p) => _$setProp(_el$, "fg", toneColor(r.tone), _$p));
+      return _el$;
+    })()
+  });
+  const Section = (props) => (() => {
+    var _el$3 = _$createElement("box"), _el$4 = _$createElement("text"), _el$5 = _$createElement("b");
+    _$insertNode(_el$3, _el$4);
+    _$setProp(_el$3, "marginTop", 1);
+    _$insertNode(_el$4, _el$5);
+    _$setProp(_el$4, "fg", muted);
+    _$insert(_el$5, () => props.title.toUpperCase());
+    return _el$3;
+  })();
+  const Note = (props) => (() => {
+    var _el$6 = _$createElement("box"), _el$7 = _$createElement("text");
+    _$insertNode(_el$6, _el$7);
+    _$setProp(_el$6, "marginTop", 1);
+    _$insert(_el$7, () => props.children);
+    _$effect((_$p) => _$setProp(_el$7, "fg", props.fg, _$p));
+    return _el$6;
+  })();
+  return (() => {
+    var _el$8 = _$createElement("box"), _el$9 = _$createElement("box"), _el$0 = _$createElement("box");
+    _$insertNode(_el$8, _el$9);
+    _$insertNode(_el$8, _el$0);
+    _$setProp(_el$8, "flexDirection", "column");
+    _$setProp(_el$8, "paddingLeft", 1);
+    _$setProp(_el$8, "paddingRight", 1);
+    _$setProp(_el$9, "flexDirection", "row");
+    _$setProp(_el$9, "gap", 2);
+    _$insert(_el$9, _$createComponent(For, {
+      each: TABS,
+      children: (t) => (() => {
+        var _el$1 = _$createElement("box"), _el$10 = _$createElement("text");
+        _$insertNode(_el$1, _el$10);
+        _$setProp(_el$1, "paddingLeft", 1);
+        _$setProp(_el$1, "paddingRight", 1);
+        _$setProp(_el$1, "onMouseDown", () => setTab(t));
+        _$insert(_el$10, (() => {
+          var _c$2 = _$memo(() => tab() === t);
+          return () => _c$2() ? (() => {
+            var _el$11 = _$createElement("b");
+            _$insert(_el$11, t);
+            return _el$11;
+          })() : t;
+        })());
+        _$effect((_p$) => {
+          var _v$ = tab() === t ? selectedBg : undefined, _v$2 = tab() === t ? text : muted;
+          _v$ !== _p$.e && (_p$.e = _$setProp(_el$1, "backgroundColor", _v$, _p$.e));
+          _v$2 !== _p$.t && (_p$.t = _$setProp(_el$10, "fg", _v$2, _p$.t));
+          return _p$;
+        }, {
+          e: undefined,
+          t: undefined
+        });
+        return _el$1;
+      })()
+    }));
+    _$setProp(_el$0, "flexDirection", "column");
+    _$insert(_el$0, (() => {
+      var _c$ = _$memo(() => status() === null);
+      return () => _c$() ? _$createComponent(Note, {
+        fg: err,
+        children: "Memory status unavailable \u2014 is the server plugin loaded?"
+      }) : _$memo(() => tab() === "Overview")() ? (() => {
+        var _el$12 = _$createElement("box");
+        _$setProp(_el$12, "flexDirection", "column");
+        _$insert(_el$12, _$createComponent(Section, {
+          title: "Status"
+        }), null);
+        _$insert(_el$12, _$createComponent(Rows, {
+          get rows() {
+            return statusRows(status(), now());
+          }
+        }), null);
+        _$insert(_el$12, _$createComponent(Section, {
+          title: "Context usage"
+        }), null);
+        _$insert(_el$12, _$createComponent(Rows, {
+          get rows() {
+            return usageRows(status());
+          }
+        }), null);
+        _$insert(_el$12, _$createComponent(Section, {
+          title: "Setup"
+        }), null);
+        _$insert(_el$12, _$createComponent(Rows, {
+          get rows() {
+            return configRows(status());
+          }
+        }), null);
+        _$insert(_el$12, (() => {
+          var _c$3 = _$memo(() => status().warnings.length > 0);
+          return () => _c$3() ? (() => {
+            var _el$13 = _$createElement("box");
+            _$setProp(_el$13, "flexDirection", "column");
+            _$insert(_el$13, _$createComponent(Section, {
+              title: "Attention"
+            }), null);
+            _$insert(_el$13, _$createComponent(For, {
+              get each() {
+                return status().warnings;
+              },
+              children: (w) => (() => {
+                var _el$14 = _$createElement("text");
+                _$setProp(_el$14, "fg", warn);
+                _$insert(_el$14, `! ${w}`);
+                return _el$14;
+              })()
+            }), null);
+            return _el$13;
+          })() : _$createElement("box");
+        })(), null);
+        _$insert(_el$12, _$createComponent(Note, {
+          fg: muted,
+          children: "Token figures are chars/4 estimates; the block is re-sent each request and normally served from the prompt cache."
+        }), null);
+        return _el$12;
+      })() : (() => {
+        var _el$16 = _$createElement("box");
+        _$setProp(_el$16, "flexDirection", "column");
+        _$setProp(_el$16, "marginTop", 1);
+        _$insert(_el$16, _$createComponent(For, {
+          get each() {
+            return controls();
+          },
+          children: (c, i) => {
+            const selected = () => cursor() === i();
+            const fgTitle = () => !c.enabled ? muted : text;
+            const indicator = () => c.on === undefined ? "\u25B8" : c.on ? "\u25CF" : "\u25CB";
+            const indicatorFg = () => !c.enabled ? muted : c.on === undefined ? accent : c.on ? ok : muted;
+            const state = () => c.on === undefined ? "" : c.on ? "On" : "Off";
+            return (() => {
+              var _el$17 = _$createElement("box"), _el$18 = _$createElement("text"), _el$19 = _$createElement("span"), _el$20 = _$createElement("span"), _el$21 = _$createElement("text");
+              _$insertNode(_el$17, _el$18);
+              _$insertNode(_el$17, _el$21);
+              _$setProp(_el$17, "flexDirection", "column");
+              _$setProp(_el$17, "paddingLeft", 1);
+              _$setProp(_el$17, "paddingRight", 1);
+              _$setProp(_el$17, "onMouseDown", () => {
+                setCursor(i());
+                activate(i());
+              });
+              _$insertNode(_el$18, _el$19);
+              _$insertNode(_el$18, _el$20);
+              _$insert(_el$19, indicator);
+              _$insert(_el$18, (() => {
+                var _c$4 = _$memo(() => !!selected());
+                return () => _c$4() ? (() => {
+                  var _el$22 = _$createElement("b");
+                  _$insert(_el$22, () => ` ${c.title.padEnd(26)}`);
+                  return _el$22;
+                })() : ` ${c.title.padEnd(26)}`;
+              })(), _el$20);
+              _$insert(_el$20, state);
+              _$setProp(_el$21, "fg", muted);
+              _$insert(_el$21, () => `  ${c.hint}`);
+              _$effect((_p$) => {
+                var _v$3 = selected() ? selectedBg : undefined, _v$4 = fgTitle(), _v$5 = {
+                  fg: indicatorFg()
+                }, _v$6 = {
+                  fg: c.on ? ok : muted
+                };
+                _v$3 !== _p$.e && (_p$.e = _$setProp(_el$17, "backgroundColor", _v$3, _p$.e));
+                _v$4 !== _p$.t && (_p$.t = _$setProp(_el$18, "fg", _v$4, _p$.t));
+                _v$5 !== _p$.a && (_p$.a = _$setProp(_el$19, "style", _v$5, _p$.a));
+                _v$6 !== _p$.o && (_p$.o = _$setProp(_el$20, "style", _v$6, _p$.o));
+                return _p$;
+              }, {
+                e: undefined,
+                t: undefined,
+                a: undefined,
+                o: undefined
+              });
+              return _el$17;
+            })();
+          }
+        }), null);
+        _$insert(_el$16, _$createComponent(Note, {
+          fg: muted,
+          children: "Global settings last until the server restarts; edit opencode.json to make them permanent."
+        }), null);
+        return _el$16;
+      })();
+    })());
+    _$insert(_el$8, _$createComponent(Note, {
+      fg: ok,
+      get children() {
+        return notice();
+      }
+    }), null);
+    _$insert(_el$8, _$createComponent(Note, {
+      fg: muted,
+      get children() {
+        return tab() === "Controls" ? "\u2191\u2193 move \xB7 enter toggle \xB7 click a tab or control \xB7 esc close" : "click a tab \xB7 esc close \xB7 ask the assistant for memory_inspect for raw diagnostics";
+      }
+    }), null);
+    return _el$8;
+  })();
+}
+function StatusPanel(context, sessionID) {
+  const rpc = context.client.rpc(MemoryStatusRpc);
+  const [status, setStatus] = createSignal();
+  const [unavailable, setUnavailable] = createSignal(false);
+  const refresh = async () => {
+    try {
+      setStatus(await fetchStatus(rpc, context, sessionID));
+      setUnavailable(false);
+    } catch {
+      setUnavailable(true);
+    }
+  };
+  const unsubscribe = rpc.events.on("changed", () => void refresh());
+  const timer = setInterval(() => void refresh(), 30000);
+  onCleanup(() => {
+    clearInterval(timer);
+    unsubscribe();
+  });
+  refresh();
+  const title = () => {
+    if (unavailable())
+      return "Unavailable";
+    const s = status();
+    if (!s)
+      return "Loading\u2026";
+    return s.useMemories ? "Enabled" : "Disabled";
+  };
+  const color = () => {
+    if (unavailable())
+      return themeColor(context.theme, ["text", "feedback", "error"], ["text"]);
+    if (status()?.useMemories)
+      return themeColor(context.theme, ["text", "feedback", "success"], ["text"]);
+    return themeColor(context.theme, ["text", "subdued"], ["textMuted"], ["text"]);
+  };
+  const muted = () => themeColor(context.theme, ["text", "subdued"], ["textMuted"], ["text"]);
+  const heading = () => themeColor(context.theme, ["text", "default"], ["text"]);
+  return (() => {
+    var _el$23 = _$createElement("box"), _el$24 = _$createElement("text"), _el$26 = _$createElement("text"), _el$27 = _$createTextNode(`\u25CF `), _el$28 = _$createElement("text");
+    _$insertNode(_el$23, _el$24);
+    _$insertNode(_el$23, _el$26);
+    _$insertNode(_el$23, _el$28);
+    _$setProp(_el$23, "flexDirection", "column");
+    _$insertNode(_el$24, _$createTextNode(`Memory`));
+    _$insertNode(_el$26, _el$27);
+    _$insert(_el$26, title, null);
+    _$insertNode(_el$28, _$createTextNode(`  /memory`));
+    _$effect((_p$) => {
+      var _v$7 = heading(), _v$8 = color(), _v$9 = muted();
+      _v$7 !== _p$.e && (_p$.e = _$setProp(_el$24, "fg", _v$7, _p$.e));
+      _v$8 !== _p$.t && (_p$.t = _$setProp(_el$26, "fg", _v$8, _p$.t));
+      _v$9 !== _p$.a && (_p$.a = _$setProp(_el$28, "fg", _v$9, _p$.a));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined
+    });
+    return _el$23;
+  })();
+}
+function KeymapLayer(context) {
+  context.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: "opencode-codex-memory.status",
+      title: "Memory",
+      description: "Memory status and controls",
+      group: "Memory",
+      palette: true,
+      slash: {
+        name: "memory",
+        aliases: ["memory-status"]
+      },
+      run: async () => {
+        const rpc = context.client.rpc(MemoryStatusRpc);
+        const route = context.ui.router.current();
+        const sessionID = route.type === "session" ? route.sessionID : undefined;
+        let initial = null;
+        try {
+          initial = await fetchStatus(rpc, context, sessionID);
+        } catch {
+          initial = null;
+        }
+        context.ui.dialog.show(() => MemoryDialog(context, sessionID, initial));
+        context.ui.dialog.set({
+          size: "medium"
+        });
+      }
+    }]
+  }));
+  return null;
+}
+var tui_default = Plugin.define({
+  id: "opencode-codex-memory.tui",
+  setup(context) {
+    const offSidebar = registerSlot(context, "sidebar.content", (input) => StatusPanel(context, input?.sessionID));
+    const offApp = registerSlot(context, "app", () => KeymapLayer(context));
+    return () => {
+      offSidebar();
+      offApp();
+    };
+  }
+});
+export {
+  tui_default as default
+};