@ephemushroom/opencode-claude-mem 0.7.0 → 0.7.1

package/README.md

@@ -18,10 +18,17 @@ The **Memory sidebar** for [OpenCode](https://opencode.ai), backed by
   Click an item for details           ← opens the full summary or observation
 ```
 
-From **v0.7.0** this package is sidebar only. Memory capture, context injection, search
-and the MCP tools come from the **official claude-mem OpenCode plugin**, which tracks the
-Worker's API in the same release. Earlier versions shipped their own capture adapter; it is
-removed so the two can never run side by side.
+One package brings claude-mem to OpenCode 2, installed and updated like any other plugin:
+
+- **Capture and context injection** run the **official claude-mem OpenCode plugin**. This
+  package downloads it at the running Worker's version (from the `claude-mem` npm release,
+  checked against the registry's sha512) and loads it, so capture always matches the
+  Worker's API and no file has to be copied by hand.
+- **Memory tools** beyond the official plugin's search: `save_memory`, `work_state_write`,
+  `work_state_read`, `dumb_search`, `get_tool_uses` and the six corpus tools, served straight
+  from the Worker's HTTP API. No MCP server is needed.
+- **The Worker is started** when nothing answers on its port.
+- **The Memory sidebar**, below.
 
 - Counts are for the current project (the directory name), matching the Worker's own
   project filter: case-insensitive, merged projects included. They are read from the Worker's
@@ -38,61 +45,81 @@ removed so the two can never run side by side.
 - Recent rows are fetched only while expanded; collapsed, it polls stats every 5s.
 - Read-only and fail-open: an offline Worker shows the offline state, never blocks the TUI.
 
-Tested with OpenCode **2.2.7** (`@opencode/plugin` 2.2.7, `@opentui/solid` 0.8.1). The V1
-sidebar contract is kept on the same `./tui` export.
+Verified on macOS with OpenCode **2.3.0** (built against `@opencode/plugin` 2.2.7,
+`@opentui/solid` 0.8.1). The Windows paths follow claude-mem's own launcher location but
+have not been run on Windows yet.
 
 ## Setup (OpenCode 2)
 
-1. **Install Claude-Mem** in Claude Code and make sure the Worker is healthy:
+1. **Install claude-mem** once per machine. This installs the Worker and its launcher:
 
    ```bash
-   curl -s http://127.0.0.1:37777/api/health
+   npx claude-mem install
    ```
 
-2. **Install the official server plugin.** OpenCode 2 auto-loads single files from
-   `~/.config/opencode/plugins/`; the file ships in the `claude-mem` npm package:
+2. **Add the plugin.** This installs the package and lists it in
+   `~/.config/opencode/opencode.json`:
 
    ```bash
-   mkdir -p ~/.config/opencode/plugins
-   cd "$(mktemp -d)" && npm pack claude-mem@latest --silent \
-     && tar -xzf claude-mem-*.tgz package/dist/opencode-plugin/index.js \
-     && cp package/dist/opencode-plugin/index.js ~/.config/opencode/plugins/claude-mem.js
+   opencode plugin add @ephemushroom/opencode-claude-mem
    ```
 
-   Claude-Mem's auto-update upgrades the Worker, not this copy: repeat this step after a
-   Worker upgrade.
-
-3. **Register the MCP server** (search, timeline, observations, `save_memory`,
-   `work_state_*`) in `~/.config/opencode/opencode.json`, under V2's `mcp.servers`:
+3. **Add the sidebar** to `~/.config/opencode/cli.json`:
 
    ```json
-   {
-     "mcp": {
-       "servers": {
-         "claude-mem": {
-           "type": "local",
-           "command": [
-             "/opt/homebrew/bin/node",
-             "/Users/<you>/.claude/plugins/marketplaces/thedotmack/plugin/scripts/mcp-server.cjs"
-           ]
-         }
-       }
-     }
-   }
+   { "plugins": ["@ephemushroom/opencode-claude-mem"] }
    ```
 
-   Point at the marketplace path, not a versioned `plugins/cache/.../<version>/` path, so
-   Worker upgrades keep it valid. Prefer this over `npx claude-mem install --ide=opencode`,
-   which writes the V1 `mcp` shape.
+Restart OpenCode. The first start downloads the official files (about 10 MB) in the
+background; the memory tools work at once, and capture begins when the download finishes.
 
-4. **Add the sidebar** to `~/.config/opencode/cli.json`:
+### Updating
 
-   ```json
-   { "plugins": ["@ephemushroom/opencode-claude-mem"] }
-   ```
+```bash
+opencode plugin update     # this package: server part and sidebar
+```
+
+OpenCode does not update plugins by itself. The official claude-mem files need no command:
+after a Worker upgrade, the next OpenCode start fetches the matching version.
+
+### Options
+
+```json
+{
+  "plugins": [{ "package": "@ephemushroom/opencode-claude-mem", "options": { "mcp": true } }]
+}
+```
+
+- `mcp: true` registers claude-mem's own MCP server (every tool it has, including the
+  `smart_*` code-outline tools) in a separate process, instead of this package's tools.
+  A `claude-mem` entry you wrote under `mcp.servers` is left as it is.
+
+claude-mem's settings apply as usual (its `settings.json`, in `~/.claude-mem` or
+`CLAUDE_MEM_DATA_DIR`, or the environment):
 
-5. **Remove this package from `opencode.json` `plugins`** if an older version put it there.
-   Both server plugins use the id `claude-mem`; keeping both captures every tool twice.
+- `CLAUDE_MEM_WORKER_HOST` / `CLAUDE_MEM_WORKER_PORT` select the Worker. Without a port,
+  claude-mem's own default applies (37700 plus the last two digits of the user id).
+- `CLAUDE_MEM_LOCAL_API_TOKEN` is sent to a Worker on this machine that requires it. This
+  package's own requests refuse redirects; the official plugin's capture requests are
+  claude-mem's code and follow them (as of 15.18.3).
+- `CLAUDE_MEM_WORKER_AUTOSTART=false` keeps this package from starting the Worker.
+- `CLAUDE_MEM_WORK_STATE_ENABLED=false` removes the two work-state tools.
+- `CLAUDE_MEM_WORKER_URL` is not supported: the official OpenCode plugin addresses the
+  Worker by host and port only, so the sidebar reports it and nothing is captured.
+
+### Tools
+
+OpenCode lists them as the `claude_mem` namespace (`tools.claude_mem.save_memory(...)` in
+Code Mode, `claude_mem_save_memory` as a direct tool call). The official plugin adds
+`claude_mem_search`, `claude_mem_timeline` and `claude_mem_get_observations`.
+
+| Tool | Purpose |
+|---|---|
+| `save_memory` | Save a durable note |
+| `work_state_write` / `work_state_read` | Per-project to-do lists and working state, shown at session start |
+| `dumb_search` | One-call lookup by title overlap |
+| `get_tool_uses` | Raw tool input/output for selected ids |
+| `build_corpus`, `list_corpora`, `prime_corpus`, `query_corpus`, `rebuild_corpus`, `reprime_corpus` | Knowledge corpora |
 
 ### Share memory across Claude Code and OpenCode
 
@@ -106,52 +133,75 @@ add this to `~/.claude-mem/settings.json` (it also applies to Claude Code's sess
 ### Verify
 
 ```bash
-opencode plugin list   # claude-mem  local  ~/.config/opencode/plugins/claude-mem.js
-opencode mcp list      # ✓ claude-mem connected
+opencode plugin list   # opencode-claude-mem  0.7.1  @ephemushroom/opencode-claude-mem
 ```
 
 Open a session: the sidebar shows `▶ Memory (online, …)`, and new observations carry
 canonical tool names (`Read`, `Edit`, `Bash`) with `files_modified` filled in.
 
-## Migrating from v0.6.x
+### Where files go
 
-v0.6.x registered `@ephemushroom/opencode-claude-mem` as a **server** plugin. Its capture,
-`mem-*` tools, file-history enrichment and semantic injection are gone:
+`~/.cache/opencode-claude-mem/` (or `$XDG_CACHE_HOME/opencode-claude-mem/`): the official
+files under `official/<version>/` (about 1.5 MB per claude-mem version; earlier versions are
+kept, because another OpenCode process may still run from them) and `status/`, which carries
+the server part's state to the sidebar. Deleting the directory while OpenCode is closed is
+safe.
 
-| v0.6.x | Now |
-|---|---|
-| `mem-search` / `mem-timeline` / `mem-get-observations` | `claude_mem_search` / `claude_mem_timeline` / `claude_mem_get_observations` (official plugin) and the MCP `search` / `timeline` / `get_observations` |
-| `mem-save` | MCP `save_memory` |
-| Read-file history appended to `read` output | Not available |
-| Opt-in semantic injection | Not available |
+## Migrating
+
+**From v0.7.0's manual setup.** Remove what the manual steps installed, then follow Setup:
+
+- delete `~/.config/opencode/plugins/claude-mem.js`. While that file exists it keeps
+  capturing, this package does not load a second copy, and that file is not kept up to date;
+- delete the `claude-mem` entry under `mcp.servers` in `opencode.json`, unless you want
+  the MCP server; in that case use `options.mcp` instead.
+
+**From v0.6.x.** Its own capture adapter is gone; capture is the official plugin's.
+`mem-search` / `mem-timeline` / `mem-get-observations` are now `claude_mem_search` /
+`claude_mem_timeline` / `claude_mem_get_observations`, and `mem-save` is `save_memory`.
+Read-file history and opt-in semantic injection are not available.
 
-Follow steps 2–5 above, then keep the bare name in `cli.json` (and `tui.json` for V1).
+**OpenCode 1.** The server part needs OpenCode 2. On OpenCode 1 use
+`npx claude-mem install --ide opencode`; the sidebar still loads from `tui.json`.
 
 ## Troubleshooting
 
-- **`(offline)`**: the Worker is not running. Start Claude Code, or `bunx claude-mem start`.
+- **`(offline)`**: the Worker is not running and could not be started. Run
+  `npx claude-mem start`; if that command is missing, `npx claude-mem install`.
+- **`(capture off)`**: nothing records this OpenCode's sessions. Expand the sidebar: the
+  first row says why (claude-mem not installed, the Worker did not start, the download
+  failed, or a `plugins/claude-mem.js` file that OpenCode has not loaded) and what to do.
+  The package looks again every minute.
 - **Sidebar missing**: check `~/.config/opencode/cli.json` lists the package; the sidebar
   needs OpenCode's `@opentui/solid` runtime and is skipped silently without it.
-- **Duplicate observations**: two capture integrations are active. Remove this package from
-  `opencode.json` `plugins`, and disable any Claude Code compatibility bridge for claude-mem.
-- **MCP not listed in an open session**: run `/reload`; already-open locations may keep the
-  previous MCP set until they reload.
+- **Duplicate observations**: two capture integrations are active. Remove
+  `~/.config/opencode/plugins/claude-mem.js` or this package, and disable any Claude Code
+  compatibility bridge for claude-mem. In Code Mode one call is recorded as `execute` plus
+  the tool it ran; that is one call, not a duplicate.
+- **Behind a registry mirror**: the download uses `CLAUDE_MEM_NPM_REGISTRY`, then
+  `npm_config_registry`, then `https://registry.npmjs.org`. The mirror must be HTTPS (or on
+  this machine): it names both the tarball and its checksum, so it is trusted like the
+  registry itself.
 
 ## Development
 
 ```bash
 bun install
-bun run build          # sidebar adapters + TUI bridge + declarations
+bun run build          # server part + sidebar adapters + TUI bridge + declarations
 bun test               # build first: export tests import dist artifacts
 bun run typecheck && bun run lint && bun run fmt:check
+bun src/test-fixtures/server-runtime.ts        # installed opencode: download, capture, tools
+bun src/test-fixtures/server-runtime.ts mcp    # options.mcp registers the MCP server
+bun src/test-fixtures/server-runtime.ts start  # no Worker: the launcher is run (macOS/Linux)
+bun src/test-fixtures/server-runtime.ts standalone  # plugins/claude-mem.js present: one capture
 bun src/test-fixtures/tui-runtime.ts           # installed opencode: real PTY, render + mouse toggle
 bun src/test-fixtures/tui-runtime.ts offline   # offline state renders and toggles
 bun --conditions=browser src/test-fixtures/cli-driver.ts render   # OpenTUI component driver
 ```
 
-The PTY check packs the current build, serves it from a temporary local registry, and runs
-the installed `opencode` in an isolated home with a fake Worker. It never touches your config
-or memory database and never calls a model. Set `MEM_TUI_EVIDENCE_DIR` to keep the captured
+The runtime checks pack the current build, serve it from a temporary local registry, and run
+the installed `opencode` in an isolated home with a fake Worker and model. They never touch
+your config or memory database. The server check downloads the real `claude-mem` release. Set `MEM_TUI_EVIDENCE_DIR` to keep the captured
 collapsed, expanded, detail-dialog and re-collapsed frames.
 
 ## License

package/dist/capture-status.d.ts

@@ -0,0 +1,26 @@
+export interface CaptureStatus {
+    /** `problem`: nothing is capturing this checkout's sessions. */
+    readonly state: 'ok' | 'problem';
+    /** Empty when there is nothing to tell the user. */
+    readonly message: string;
+}
+/** Holds the official claude-mem files this package downloads, and the status files. */
+export declare function cacheDirectory(env?: Record<string, string | undefined>, home?: string): string;
+/** Names the status files of one checkout, however its path was spelled. */
+export declare function statusKey(directory: string): string;
+/**
+ * The newest status a running server part wrote for this checkout, preferring one from
+ * this process. Null when none is running: a status left by a package that was since
+ * removed from `opencode.json`, or by a process that exited, must not stay on screen.
+ */
+export declare function readCaptureStatus(directory: string, dir?: string): CaptureStatus | null;
+export interface CaptureStatusWriter {
+    readonly write: (status: CaptureStatus) => void;
+    /** Called when the server part is unloaded for the checkout while the host keeps running. */
+    readonly clear: () => void;
+}
+/**
+ * The status file of one `setup` call. Each has its own, so two servers on one checkout,
+ * or a reload that sets up before the old instance is disposed, never remove each other's.
+ */
+export declare function captureStatusWriter(directory: string, dir?: string): CaptureStatusWriter;

package/dist/cli.js

@@ -1,12 +1,82 @@
 // @bun
-// src/worker-client.ts
-import { existsSync, readFileSync } from "fs";
+// src/capture-status.ts
+import { createHash, randomUUID } from "crypto";
+import { join, resolve } from "path";
+import {
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
 import { homedir } from "os";
-import { join } from "path";
+function cacheDirectory(env = process.env, home = homedir()) {
+  return join(env["XDG_CACHE_HOME"]?.trim() || join(home, ".cache"), "opencode-claude-mem");
+}
+function statusKey(directory) {
+  let resolved = resolve(directory);
+  try {
+    resolved = realpathSync(directory);
+  } catch {}
+  return createHash("sha256").update(resolved).digest("hex").slice(0, 16);
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseStatus(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const { state, message, pid } = parsed;
+    return (state === "ok" || state === "problem") && typeof message === "string" && typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? { state, message, pid } : null;
+  } catch {
+    return null;
+  }
+}
+function readCaptureStatus(directory, dir = cacheDirectory()) {
+  const folder = join(dir, "status");
+  const prefix = `${statusKey(directory)}.`;
+  let names = [];
+  try {
+    names = readdirSync(folder).filter((name) => name.startsWith(prefix) && name.endsWith(".json"));
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const name of names) {
+    const file = join(folder, name);
+    const parsed = parseStatus(file);
+    if (!parsed || !isAlive(parsed.pid)) {
+      rmSync(file, { force: true });
+    } else {
+      const own = parsed.pid === process.pid;
+      const at = statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+      if (!best || own && !best.own || own === best.own && at > best.at) {
+        best = { status: { state: parsed.state, message: parsed.message }, own, at };
+      }
+    }
+  }
+  return best?.status ?? null;
+}
+
+// src/worker-client.ts
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join as join2, resolve as resolve2, win32 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { homedir as homedir2 } from "os";
 var DEFAULT_WORKER_HOST = "127.0.0.1";
-var DEFAULT_WORKER_PORT = 37777;
-var SETTINGS_FILE = join(homedir(), ".claude-mem", "settings.json");
-var LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+var WORKER_PORT_BASE = 37700;
+var TOKEN_HEADER = "x-claude-mem-token";
 var PROJECT_COUNTS_SQL = `SELECT
   (SELECT COUNT(*) FROM observations
     WHERE project = ?1 COLLATE NOCASE OR merged_into_project = ?1 COLLATE NOCASE) AS observations,
@@ -36,25 +106,62 @@ function parseSettings(rawSettings) {
     return {};
   }
   try {
-    const parsed = JSON.parse(rawSettings);
-    return isRecord(parsed) ? parsed : {};
+    const parsed = JSON.parse(rawSettings.replace(/^\uFEFF/, ""));
+    if (!isRecord(parsed)) {
+      return {};
+    }
+    const nested = parsed["env"];
+    const source = isRecord(nested) && Object.keys(nested).some((key) => key.startsWith("CLAUDE_MEM_")) ? nested : parsed;
+    return Object.fromEntries(Object.entries(source).map(([key, value]) => [
+      key,
+      typeof value === "number" || typeof value === "boolean" ? String(value) : value
+    ]));
   } catch {
     return {};
   }
 }
-function parseWorkerEndpoint(env, rawSettings) {
+function dataDirectory(env, home) {
+  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? join2(home, ".claude-mem");
+  return dir.replace(/^~(?=$|[\\/])/, home);
+}
+function defaultWorkerPort(dataDir, platform = process.platform, uid = typeof process.getuid === "function" ? process.getuid() : null) {
+  if (uid !== null) {
+    return WORKER_PORT_BASE + (uid % 100 + 100) % 100;
+  }
+  const normalized = platform === "win32" ? win32.resolve(dataDir).toLowerCase() : resolve2(dataDir);
+  const digest = createHash2("sha256").update(normalized, "utf8").digest();
+  return WORKER_PORT_BASE + digest.readUInt32BE(0) % 100;
+}
+function parseWorkerEndpoint(env, rawSettings, fallbackPort = defaultWorkerPort(dataDirectory(env, homedir2()))) {
   const settings = parseSettings(rawSettings);
-  const host = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
-  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? DEFAULT_WORKER_PORT;
+  const configured = readString(env["CLAUDE_MEM_WORKER_HOST"]) ?? readString(settings["CLAUDE_MEM_WORKER_HOST"]) ?? DEFAULT_WORKER_HOST;
+  const host = configured === "localhost" ? DEFAULT_WORKER_HOST : configured;
+  const port = readPort(env["CLAUDE_MEM_WORKER_PORT"]) ?? readPort(settings["CLAUDE_MEM_WORKER_PORT"]) ?? fallbackPort;
   return { host, port };
 }
+function isLoopbackHost(host) {
+  const name = host.toLowerCase().replace(/^\[|\]$/g, "");
+  return name === "localhost" || name.endsWith(".localhost") || name === "::1" || /^127(?:\.\d{1,3}){1,3}$/.test(name);
+}
+function workerUrl(endpoint) {
+  const host = endpoint.host.includes(":") && !endpoint.host.startsWith("[") ? `[${endpoint.host}]` : endpoint.host;
+  return `http://${host}:${endpoint.port}`;
+}
+function tokenHeaders(baseUrl, rawSettings) {
+  const token = readString(parseSettings(rawSettings)["CLAUDE_MEM_LOCAL_API_TOKEN"]);
+  try {
+    return token && isLoopbackHost(new URL(baseUrl).hostname) ? { [TOKEN_HEADER]: token } : {};
+  } catch {
+    return {};
+  }
+}
 function resolveDatabasePath(env, rawSettings, home) {
-  if (!LOOPBACK_HOSTS.has(parseWorkerEndpoint(env, rawSettings).host)) {
+  if (!isLoopbackHost(parseWorkerEndpoint(env, rawSettings).host)) {
     return null;
   }
   const settings = parseSettings(rawSettings);
-  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? readString(settings["CLAUDE_MEM_DATA_DIR"]) ?? join(home, ".claude-mem");
-  return join(dir.replace(/^~(?=$|[\\/])/, home), "claude-mem.db");
+  const dir = readString(env["CLAUDE_MEM_DATA_DIR"]) ?? readString(settings["CLAUDE_MEM_DATA_DIR"]) ?? join2(home, ".claude-mem");
+  return join2(dir.replace(/^~(?=$|[\\/])/, home), "claude-mem.db");
 }
 function readCount(value) {
   return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : null;
@@ -88,27 +195,45 @@ function readEpoch(item) {
 }
 function readSettingsRaw() {
   try {
-    return readFileSync(SETTINGS_FILE, "utf8");
+    return readFileSync2(join2(dataDirectory(process.env, homedir2()), "settings.json"), "utf8");
   } catch {
     return null;
   }
 }
+function readWorkerSetting(key) {
+  return readString(process.env[key]) ?? readString(parseSettings(readSettingsRaw())[key]);
+}
+function getWorkerEndpoint() {
+  return parseWorkerEndpoint(process.env, readSettingsRaw());
+}
 function getWorkerBaseUrl() {
-  const endpoint = parseWorkerEndpoint(process.env, readSettingsRaw());
-  return `http://${endpoint.host}:${endpoint.port}`;
+  return workerUrl(getWorkerEndpoint());
+}
+function workerHeaders(baseUrl = getWorkerBaseUrl()) {
+  return tokenHeaders(baseUrl, readSettingsRaw());
 }
 
 class WorkerClient {
   static BASE_URL = getWorkerBaseUrl();
-  static DATABASE_PATH = resolveDatabasePath(process.env, readSettingsRaw(), homedir());
+  static SUPPORTED = !readWorkerSetting("CLAUDE_MEM_WORKER_URL");
+  static DATABASE_PATH = resolveDatabasePath(process.env, readSettingsRaw(), homedir2());
+  static get(path) {
+    if (!this.SUPPORTED) {
+      return Promise.reject(new Error("CLAUDE_MEM_WORKER_URL is not supported"));
+    }
+    return fetch(`${this.BASE_URL}${path}`, {
+      headers: workerHeaders(this.BASE_URL),
+      redirect: "error"
+    });
+  }
   static getProjectCounts(project) {
-    return this.DATABASE_PATH ? readProjectCounts(this.DATABASE_PATH, project) : Promise.resolve(null);
+    return this.DATABASE_PATH && this.SUPPORTED ? readProjectCounts(this.DATABASE_PATH, project) : Promise.resolve(null);
   }
   static async getStats() {
     try {
       const [statsRes, processingRes] = await Promise.all([
-        fetch(`${this.BASE_URL}/api/stats`),
-        fetch(`${this.BASE_URL}/api/processing-status`)
+        this.get(`/api/stats`),
+        this.get(`/api/processing-status`)
       ]);
       if (!statsRes.ok) {
         return null;
@@ -123,7 +248,7 @@ class WorkerClient {
   static async getRecentSummaries(project, limit) {
     try {
       const params = new URLSearchParams({ project, limit: String(limit) });
-      const response = await fetch(`${this.BASE_URL}/api/summaries?${params.toString()}`);
+      const response = await this.get(`/api/summaries?${params.toString()}`);
       if (!response.ok) {
         return [];
       }
@@ -145,7 +270,7 @@ class WorkerClient {
   static async getRecentObservations(project, limit) {
     try {
       const params = new URLSearchParams({ project, limit: String(limit) });
-      const response = await fetch(`${this.BASE_URL}/api/observations?${params.toString()}`);
+      const response = await this.get(`/api/observations?${params.toString()}`);
       if (!response.ok) {
         return [];
       }
@@ -168,7 +293,7 @@ class WorkerClient {
   static async getDetail(kind, id) {
     try {
       const path = kind === "observation" ? "observation" : "session";
-      const response = await fetch(`${this.BASE_URL}/api/${path}/${id}`);
+      const response = await this.get(`/api/${path}/${id}`);
       if (!response.ok) {
         return null;
       }
@@ -252,6 +377,9 @@ function summaryLine(view) {
   if (!view.healthy) {
     return { label: "(offline)", tone: "err" };
   }
+  if (view.capture?.state === "problem") {
+    return { label: "(capture off)", tone: "err" };
+  }
   if (view.isProcessing || (view.queueDepth ?? 0) > 0) {
     return { label: `(queue ${view.queueDepth ?? 0})`, tone: "warn" };
   }
@@ -279,11 +407,21 @@ function recentRow(icon, iconColor, title, age, theme, onSelect) {
   ]);
 }
 function expandedRows(view, theme, onSelect) {
+  const notice = view.capture?.message ? [
+    box({ flexDirection: "row", gap: 1 }, [
+      text({ fg: theme.warning, flexShrink: 0 }, "!"),
+      text({
+        fg: view.capture.state === "problem" ? theme.error : theme.warning,
+        wrapMode: "word"
+      }, view.capture.message)
+    ])
+  ] : [];
   if (!view.healthy) {
-    return [bulletRow("\u2022", theme.error, "worker offline", theme)];
+    return [bulletRow("\u2022", theme.error, "worker offline", theme), ...notice];
   }
   const counts = `obs ${formatCount(view.observations)} \xB7 sum ${formatCount(view.summaries)} \xB7 ses ${formatCount(view.sessions)}`;
   const rows = [
+    ...notice,
     bulletRow("\u2022", theme.success, view.scope === "all" ? `all \xB7 ${counts}` : counts, theme)
   ];
   if (view.scope === "project") {
@@ -330,14 +468,16 @@ function viewKey(view) {
 function readCount2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
-async function readMemView(project, collapsed) {
+async function readMemView(project, collapsed, directory = "") {
   const [stats, counts] = await Promise.all([
     WorkerClient.getStats(),
     WorkerClient.getProjectCounts(project)
   ]);
+  const capture = directory ? readCaptureStatus(directory) : null;
   if (!stats) {
     return {
       healthy: false,
+      capture,
       project,
       scope: "all",
       totalObservations: null,
@@ -358,6 +498,7 @@ async function readMemView(project, collapsed) {
   const totalObservations = readCount2(stats.database?.observations);
   return {
     healthy: true,
+    capture,
     project,
     scope: counts ? "project" : "all",
     totalObservations,
@@ -446,6 +587,7 @@ var REFRESH_EVENTS = ["session.created", "session.execution.succeeded"];
 function emptyView(project) {
   return {
     healthy: false,
+    capture: null,
     project,
     scope: "all",
     totalObservations: null,
@@ -466,7 +608,8 @@ var cli_default = define({
     if (!solid) {
       return;
     }
-    const project = String(ctx.location?.directory ?? process.cwd()).split(/[\\/]/).filter(Boolean).findLast(Boolean) ?? "unknown-project";
+    const directory = String(ctx.location?.directory ?? process.cwd());
+    const project = directory.split(/[\\/]/).filter(Boolean).findLast(Boolean) ?? "unknown-project";
     const [state, setState] = ctx.storage.memory("claude-mem.sidebar", {
       initial: { collapsed: true, view: emptyView(project) }
     });
@@ -487,7 +630,7 @@ var cli_default = define({
         do {
           refreshPending = false;
           const { collapsed } = state;
-          const next = await readMemView(project, collapsed);
+          const next = await readMemView(project, collapsed, directory);
           if (disposed) {
             return;
           }

package/dist/official-sync.d.ts

@@ -0,0 +1,29 @@
+export interface OfficialFiles {
+    readonly version: string;
+    /** The official OpenCode plugin: default export `{ id, server, setup }`. */
+    readonly plugin: string;
+    readonly mcpServer: string;
+}
+export type SyncResult = {
+    readonly ok: true;
+    readonly files: OfficialFiles;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export interface SyncOptions {
+    /** Directory holding one sub-directory per version. */
+    readonly root?: string;
+    readonly registry?: string;
+}
+export declare function officialRoot(): string;
+/** `CLAUDE_MEM_NPM_REGISTRY`, then npm's own registry setting, then the public registry. */
+export declare function npmRegistry(env?: Record<string, string | undefined>): string;
+/**
+ * Reads the named regular files out of a gzipped tar. npm tarballs are ustar; a path longer
+ * than the name field uses the prefix field, and anything else (pax records, directories)
+ * is skipped by its size. No `tar` binary is needed, which Windows may not have on PATH.
+ */
+export declare function extractTarFiles(archive: Uint8Array, members: readonly string[]): Map<string, Uint8Array>;
+/** The official files for `version`, downloading them once when they are not on disk. */
+export declare function syncOfficial(version: string, options?: SyncOptions): Promise<SyncResult>;