dsh-trivium 0.4.8 → 0.4.10

package/README.md

@@ -6,9 +6,9 @@
 
 In-process graph memory for DeepSeek Harness. One `.tdb` per workspace. No extra server.
 
-DSH 进程内图记忆 · 按节点和边记 · 默认少注入
+The kernel stays close to DSH: no extra process, no extra nav by default. Pin memory fragments with optional chip inject; the plot canvas is an optional extra, loaded from Settings.
 
-> **Quick install**: `dsh plugin --profile web add dsh-trivium` → restart **dsh web** → open a workspace (Settings shows **Trivium memory**; the conversation title bar shows **Session graph**). Details in [Installation](#installation).
+> **Quick install**: `dsh plugin --profile web add dsh-trivium` → restart **dsh web** → open a workspace (Settings shows **Trivium memory**; the **Chips** tab stays off until you turn it on). Details in [Installation](#installation).
 
 [**English**](README.md) | [中文版](README.zh-CN.md)
 
@@ -47,14 +47,48 @@ dsh plugin --profile web add dsh-trivium
 
 Restart **dsh web**. For a source checkout, `git pull` then run `node scripts/link-dsh.mjs` again.
 
+## Uninstall
+
+Stop **dsh web** first so the `.tdb` is not locked, then:
+
+```sh
+dsh plugin --profile web remove dsh-trivium
+```
+
+`remove` deletes this plugin’s files: `~/.dsh/trivium.json`, and in every workspace the plugin has opened, `.dsh/trivium.tdb` plus `trivium-pending.json`. Other files under `.dsh/` stay. Updating with `dsh plugin add dsh-trivium` does **not** wipe memory.
+
+Restart **dsh web** afterward: Settings no longer shows **Trivium memory**, the title bar no longer shows **Chips**, and the four tools are unregistered.
+
+Workspaces never opened after this version may still have an old `.tdb`; delete that file by hand if you find one. Disable without uninstall (data stays): in that profile’s `cordis.patch.yml` add:
+
+```yaml
+- id: dsh-trivium
+  disabled: true
+```
+
+Then restart `dsh web`.
+
+## Permissions and data
+
+The plugin loads inside the `dsh web` process. It does not open its own port or extra service.
+
+| Access | Default | Notes |
+|---|---|---|
+| Workspace `.dsh/trivium.tdb` | read/write | Memory store. Do not open the same file from two Node processes at once |
+| `~/.dsh/trivium.json` | read/write | Settings and chip pins; may contain an embedding API key you typed |
+| `.dsh/trivium-pending.json` | read/write | Local queue when extract fails |
+| Network | off | Chat text is not sent out. Embedding outbound happens only if you turn it on and fill a URL. Settings **Check for updates** fetches the npm registry (version only, no transcript) |
+| Transcript | stays local | Extract and search run on this machine; with embedding on, retrieved text is sent to the URL you filled |
+
+The official DeepSeek chat API has no embeddings endpoint. Keyword + graph walk still work without it. Restart `dsh web` after changing settings or embedding.
+
 ## AI-era installation
 
 Copy this to your assistant:
 
 ```text
 On DeepSeek Harness, run: dsh plugin --profile web add dsh-trivium
-Then restart dsh web. Settings will show "Trivium memory", and the session title bar
-will show "Session graph" next to Conversation / Trajectory (use "Create checkpoint" to split a box by hand).
+Then restart dsh web. Settings will show "Trivium memory". The Chips tab is off by default; turn it on under Settings → Trivium memory if you want to pin fragments into the next turn.
 ```
 
 ---
@@ -64,8 +98,8 @@ will show "Session graph" next to Conversation / Trajectory (use "Create checkpo
 Trivium is a memory kernel, not a journal, calendar, or chat companion. It stores **nodes and edges**, injects as little as possible, and lets you correct mistakes.
 
 - **Cross-session graph** — session A stores “auth goes in header X”; session B calls `ctx_find("auth")` and gets the hit plus who it links to (`about` / `decided` / `broke` / `fixed`).
-- **Default quiet** — a new session injects one short map (≤400 tokens). The model calls tools when it needs more. Nothing is dumped every step.
-- **Session graph** — each successful compaction becomes a box; “Create checkpoint” splits a box without compressing the model window; fork from a checkpoint. Optional memory chips pin facts into the next turn.
+- **Default quiet** — a new session injects one short map (≤400 tokens). The model calls tools when it needs more. Nothing is dumped every step. No extra title-bar tab until you turn **Chips** on.
+- **Chips (off by default)** — Settings → Trivium memory. When on, the title bar shows **Chips**; checked items pin into the next turn (L0, ≤300 tokens). Under it, **Session layer** (also off) draws compaction / forks as boxes.
 - **Human-editable** — chips can add, archive, or delete; Settings search, rename, merge, import/export, and global switches.
 - **Strict extraction** — chitchat, one-off file edits, and secrets are **not** auto-written from the transcript. Chip “Add” stores exactly what you typed (one paste = one node), still through the write hygiene gate.
 - **Write hygiene** — `ctx_remember`, chip add, extract, and external import refuse mojibake, stutter loops, JSON envelopes, base64 residue, and secrets. Dirty nodes already in `.tdb` stay visible in Settings so you can archive them; they are hidden from find / short map / chips.
@@ -74,11 +108,11 @@ Trivium is a memory kernel, not a journal, calendar, or chat companion. It store
 ### Under the hood
 
 - **In-process, one file** — TriviumDB (vectors + JSON payload + directed weighted graph) opens with the DSH process. No sidecar HTTP/Python service.
-- **Four tools only** — `ctx_find` / `ctx_read` / `ctx_remember` / `ctx_link`. The session graph does not add a fifth.
+- **Four tools only** — `ctx_find` / `ctx_read` / `ctx_remember` / `ctx_link`. Chips / session layer do not add a fifth.
 - **Injection via `agent.inject()`** — not the system prompt, so `persona.complete: true` cannot silently drop the map.
 - **Recall carries paths** — every hit says which node it came from and along which edge.
 - **Failures never block the agent** — store / embedding / extract errors are logged; the main loop continues.
-- **UI follows the host language** — Settings and the session graph switch with DSH `locale/change` (`zh` / `en`).
+- **UI follows the host language** — Settings and the Chips tab switch with DSH `locale/change` (`zh` / `en`).
 - **First-turn map** — the short map is injected once per session. If `session-start` loses a race with the first model step, `pre-step` fills it in; it is not rewritten every step (prefix-cache friendly).
 
 ## Features
@@ -89,32 +123,11 @@ Nodes are `entity` / `preference` / `decision` / `experience`. Business edges ar
 
 `ctx_find` returns L0 summaries plus edge paths (incoming as `<-label-id`). If the query names an existing entity, unexpired `about` / `decided` / `broke` / `fixed` neighbors come along even when the neighbor text does not contain the query. Decisions with `until` stay hidden after they expire, unless the query itself is asking about that deadline (e.g. “Friday”).
 
-### Session graph
-
-Entry: current session title bar **Conversation / Trajectory / Session graph**. This is a plot of compaction and forks, not the memory editor. Rename, merge, and global switches stay on the Settings page. The chip strip can add, archive, and delete.
-
-**Boxes**
-
-- Never compacted: one “Next” box.
-- After a successful compaction: historical checkpoints on the left (summaries from DSH), “Next” still on the right.
-- **Create checkpoint**: fold the current “Next” into a left box; the right side stays “Next”. Plot only — **does not** compact the model window. Clicking again in the same turn does not double-write.
-- Sessions that compacted or forked before the plugin was installed: **Update checkpoints** backfills boxes from compression markers in the transcript and sidebar forks (safe to click again). No compaction still means only “Next” — a long session with many tools is not the same as DSH having compacted (auto-compact is around 80% of the window). To compact context, type `/compact` in the conversation.
-- Boxes themselves do not summarize. Quality comes from summaries DSH already wrote; fork does not re-summarize.
-- “Rename” changes the box title only. Click a box to jump to that checkpoint in the conversation, or open Trajectory.
-
-**Forks**
-
-The fork icon on a box opens “Fork as new session”. That name appears in the left session list (default: source title plus `(1)`).
-
-Confirm runs the host `session.fork`: the child shows up in the sidebar, prefix (including already-compacted summaries) is copied by DSH. With a checkpoint, the cut is at that checkpoint; with only “Next”, the edge leaves the box you clicked.
-
-Forks created from the conversation page also show up on the session graph. Archive a child in the sidebar and its fork box disappears; unarchive brings it back.
+### Chips (optional)
 
-Canvas: drag empty space to pan, scroll to zoom.
+Off by default. Turn on **Chips tab** in Settings, then restart `dsh web`. The title bar shows **Conversation / Trajectory / Chips**. This is a pin strip, not the memory editor. Rename, merge, and global switches stay on the Settings page.
 
-### Memory chips
-
-Expand the strip at the top of the session graph. Lists unarchived preference / decision / entity (experience stays out, to keep noise down).
+Lists unarchived preference / decision / entity (experience stays out). Check to pin into the next turn (L0, ≤300 tokens). Add / archive / delete on the strip.
 
 | Action | When it takes effect |
 |---|---|
@@ -125,12 +138,16 @@ Expand the strip at the top of the session graph. Lists unarchived preference /
 | Select → Delete | Removed from `.tdb`, not recoverable |
 | Turns already sent | Not rewritten |
 
-Chips are per session. New sessions and forked children start unchecked. Inherit pins in the fork dialog, or check them again on the child. The short map still arrives at session-start and does not use a chip slot.
+Chips are per session. New sessions and forked children start unchecked. Inherit pins when the session layer fork dialog is on, or check them again on the child. The short map still arrives at session-start and does not use a chip slot.
+
+**Session layer** is a nested switch, also off. When on, the same tab draws compaction / fork boxes (Create checkpoint, Update checkpoints, fork from a box). Episode nodes are not recalled by `ctx_find`. Turning the layer off stops writing episodes; existing `.tdb` nodes stay.
 
 ### Settings (Trivium memory)
 
-Settings → **Trivium memory** manages the store. It does not replace the session graph.
+Settings → **Trivium memory** manages the store and the two optional surfaces.
 
+- **Chips tab (default off)** — title-bar **Chips** + pin inject. Restart `dsh web` after save.
+- **Session layer (default off, under Chips)** — plot canvas. Requires the Chips tab.
 - **Injection (pick one, default off)** — Off: short map at start only. autoRecall: at most 3 L0 hits when the step has user text. Entity-name middle path: 1-hop business neighbors only when the utterance names an existing entity. Checked chips share the budget and win first.
 - **Extraction** — default after `compaction/end` and a short idle; failures go to pending and replay on the next session-start. Per batch: body ≤3000 chars, at most 24 items.
 - **Entries** — search, filter by type, expand business-edge neighbors, “only nodes hanging on this one”, hide expired decisions by default. Rename / edit body / aliases / until, merge same type, archive or delete.
@@ -147,7 +164,7 @@ Settings → **Trivium memory** manages the store. It does not replace the sessi
 | `ctx_remember` | Manual write |
 | `ctx_link` | Directed edge between two nodes |
 
-The kernel is still these four. The session graph does not add a fifth tool.
+The kernel is still these four. Chips / session layer do not add a fifth tool.
 
 ---
 
@@ -173,11 +190,11 @@ Session-start injects the short map; the model calls `ctx_find` and hits “auth
 
 <img width="560" alt="Entry list" src="docs/screenshots/05-settings-list.png">
 
-### Session graph — third tab next to Conversation / Trajectory
+### Chips tab — optional, next to Conversation / Trajectory
 
-<img width="560" alt="Session graph" src="docs/screenshots/06-session-map.png">
+<img width="560" alt="Chips / session layer" src="docs/screenshots/06-session-map.png">
 
-The title bar shows **Session graph**. A session that has never compacted has one “Next” box; memory chips sit on top (unchecked by default). **Create checkpoint** folds “Next” into a left box. After compaction or `/compact`, historical boxes appear on the left; forks leave a box toward a child session.
+Off by default. After you turn **Chips** on in Settings and restart, the title bar shows **Chips**. With **Session layer** also on, a never-compacted session has one “Next” box; chips sit on top (unchecked by default). **Create checkpoint** folds “Next” into a left box. After compaction or `/compact`, historical boxes appear on the left; forks leave a box toward a child session.
 
 ---
 
@@ -187,7 +204,7 @@ The title bar shows **Session graph**. A session that has never compacted has on
 - Extraction misses things; dirty data can be archived / deleted on the chip strip or edited / merged in Settings.
 - Do not open the same `.tdb` from two Node processes at once (one `dsh web` is enough).
 - Markdown export is for humans; it cannot be parsed back. External import (WorkBuddy / Claude Code / Codex) is one-shot, not two-way sync, and does not ingest session jsonl dumps.
-- The session graph projects compaction and fork by default; it does not split boxes by message count. If the window has not reached DSH’s compact line, **Update checkpoints** will not invent history boxes — use **Create checkpoint**.
+- The session layer (when on) projects compaction and fork; it does not split boxes by message count. If the window has not reached DSH’s compact line, **Update checkpoints** will not invent history boxes — use **Create checkpoint**.
 - Plugin setting changes need a `dsh web` restart.
 - After the host moved to rc.8, DSH’s own older session store may not open (official SQLite format change). The workspace `.tdb` graph is still there; leftover boxes on unmatched old sessions are plot residue and do not affect `ctx_find`.
 
@@ -195,6 +212,10 @@ The title bar shows **Session graph**. A session that has never compacted has on
 
 ## Changelog
 
+**0.4.10** — `dsh plugin remove` deletes known workspace `.tdb` files and `~/.dsh/trivium.json`. Plugin update does not wipe. Disable-in-place still keeps data.
+
+**0.4.9** — Chips tab and session-layer canvas are both off by default. Title bar shows **Chips** only after the Settings switch; session boxes sit under that switch. Kernel (four tools, short map, in-process `.tdb`) unchanged.
+
 **0.4.8** — Write + inject hygiene gate (secrets, mojibake, stutter, JSON envelopes, base64 residue). Settings / session graph follow DSH language. Settings can check npm for updates. One-shot strict import also discovers Claude Code `CLAUDE.md` and Codex `AGENTS.md`. First-turn short map is guaranteed if `session-start` races the first step.
 
 **0.4.7** — Storage bump to `triviumdb@0.7.6` (`searchExact` / `searchBatch` on the engine). find / session graph behavior unchanged.
@@ -213,12 +234,29 @@ The title bar shows **Session graph**. A session that has never compacted has on
 
 **0.4.0** — Session graph, memory chips, fork from a checkpoint.
 
+## Troubleshooting
+
+| Symptom | What to do |
+|---|---|
+| Settings has no **Trivium memory** | Confirm the **web** profile, then **restart** `dsh web` and open a workspace. Reloading the browser is not enough. |
+| Title bar has no **Chips** | Expected. Turn on **Chips tab** in Settings, save, then restart `dsh web`. |
+| Injection / extract / embedding / chip tab changes have no effect | Restart `dsh web` as well. |
+| Session layer shows only a **Next** box | Expected when the nested session layer is on. Boxes follow DSH compaction; a long session is not the same as already compacted (auto-compact is around 80% of the window). To split: `/compact` in the conversation, or **Create checkpoint** (plot only, does not compact the window). Older sessions can use **Update checkpoints** to backfill past compaction / forks. |
+| `ctx_find` returns nothing | A new session injects the short map only; the model must call the tool. You can also **Add** on the chip strip or tell the model “remember: …”. Chitchat and one-off file edits are not auto-written. |
+| `.tdb` is locked / will not open | Run one `dsh web`. Do not run two Node processes that both linked this plugin. |
+| Embedding is filled but search is no more accurate | Failures fall back to keyword + graph. Check that `~/.dsh/trivium.json` has an OpenAI-compatible URL (the `/v1` kind). Restart after changing it. |
+| Memory still there after uninstall | Stop `dsh web` before `dsh plugin remove`. Leftover `.tdb` is a workspace never opened on 0.4.10+; delete `.dsh/trivium.tdb` in that folder. Disable-in-place does not wipe. |
+| Check for updates fails | That request only hits the npm registry for the latest version. Memory is unaffected; try again later. |
+| Old conversations will not open after rc.8 | That is DSH’s own session-store format change, not a broken `.tdb`. Graph memory still works via `ctx_find`; leftover boxes on unmatched old sessions are plot residue. |
+
+Local source checkout: `npm install`, then `node scripts/link-dsh.mjs`, then restart `dsh web`. `triviumdb` is a native module; if it will not install, check Node against `package.json` `engines` (`^22.19.0 || >=24`).
+
 ---
 
 ## Release info
 
 - GitHub: https://github.com/QWQcool/dsh-trivium
-- npm: [`dsh-trivium@0.4.8`](https://www.npmjs.com/package/dsh-trivium)
+- npm: [`dsh-trivium@0.4.10`](https://www.npmjs.com/package/dsh-trivium)
 - Tested host: `@deepseek-ai/dsh@0.1.1-rc.2` (also `0.1.0-rc.8`)
 - License: MIT (depends on [TriviumDB](https://github.com/YoKONCy/TriviumDB), Apache-2.0)
 

package/README.zh-CN.md

@@ -4,9 +4,9 @@
   <img width="820" alt="dsh-trivium 封面" src="docs/cover.png">
 </p>
 
-DeepSeek Harness 的跨会话图记忆插件：按节点和边记，默认少注入，设置页可改可归档。会话标题栏多一个 **会话图**：compaction 收成方框，可从检查点 fork，可选记忆芯片钉进下一轮。每个工作区一个 `.dsh/trivium.tdb`，不另起服务。
+DeepSeek Harness 的进程内图记忆插件：按节点和边记，默认少注入，设置页可改可归档。内核贴近 DSH：不另起进程、默认不加导航。要钉住某些记忆片段，再在设置里打开 **芯片** 注入；情节画布是可选的自嗨层，嵌在芯片开关下。每个工作区一个 `.dsh/trivium.tdb`，不另起服务。
 
-> **快速安装**：`dsh plugin --profile web add dsh-trivium` → 重启 **dsh web** → 打开工作区（设置里出现「Trivium 记忆」，对话旁出现「会话图」）。完整步骤见 [安装](#安装)。
+> **快速安装**：`dsh plugin --profile web add dsh-trivium` → 重启 **dsh web** → 打开工作区（设置里出现「Trivium 记忆」；**芯片**标签默认关）。完整步骤见 [安装](#安装)。
 
 [**English**](README.md) | [中文版](README.zh-CN.md)
 
@@ -45,13 +45,48 @@ dsh plugin --profile web add dsh-trivium
 
 装完重启 **dsh web**。源码联调则在仓库里 `git pull` 后再跑一次 `node scripts/link-dsh.mjs`。
 
+## 卸载
+
+先停掉 **dsh web**，避免 `.tdb` 被占用，然后：
+
+```sh
+dsh plugin --profile web remove dsh-trivium
+```
+
+`remove` 会删掉本插件的文件：`~/.dsh/trivium.json`，以及它打开过的每个工作区里的 `.dsh/trivium.tdb` 和 `trivium-pending.json`。`.dsh/` 下其它文件不动。用 `dsh plugin add dsh-trivium` 升级**不会**清记忆。
+
+然后再重启 **dsh web**：设置里不再有「Trivium 记忆」，标题栏不再有「芯片」，四个工具不再注册。
+
+从未用本版打开过的工作区，可能还留着旧 `.tdb`；看到就手动删那个文件。只想停用、不卸载（数据还在）：在该 profile 的 `cordis.patch.yml` 里加：
+
+```yaml
+- id: dsh-trivium
+  disabled: true
+```
+
+再重启 `dsh web`。
+
+## 权限与数据
+
+插件随 `dsh web` 进程加载，不另起端口、不另起服务。
+
+| 访问 | 默认 | 说明 |
+|---|---|---|
+| 工作区 `.dsh/trivium.tdb` | 读写 | 记忆库。同一文件不要两个 Node 进程同时打开 |
+| `~/.dsh/trivium.json` | 读写 | 设置和芯片钉选；可含你手填的 embedding API key |
+| `.dsh/trivium-pending.json` | 读写 | 抽取失败时的本地队列 |
+| 网络 | 关 | 对话不外发。打开 embedding 并填了 URL 才会把被检索文本发到你填的地址。设置页点「检查更新」会请求 npm registry（只拿版本号，不含对话） |
+| 对话原文 | 不外发 | 抽取和检索都在本机；embedding 开启后，被检索的文本会发到你填的地址 |
+
+官方 DeepSeek 对话接口没有 embeddings。不开 embedding 也能用：关键词 + 图遍历。改完设置或 embedding 后需重启 `dsh web`。
+
 ## AI 时代安装
 
 把下面这句话复制给助手即可：
 
 ```text
 请在 DeepSeek Harness 上执行：dsh plugin --profile web add dsh-trivium
-然后重启 dsh web。设置里会出现「Trivium 记忆」，会话标题栏「对话 / 轨迹」旁会出现「会话图」（可「生成检查点」手切方框）。
+然后重启 dsh web。设置里会出现「Trivium 记忆」。芯片标签默认关；若要钉住某些记忆片段，在设置「Trivium 记忆」里打开「芯片标签」后再重启。
 ```
 
 ---
@@ -61,9 +96,9 @@ dsh plugin --profile web add dsh-trivium
 Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点和边**记，默认少注入，记错了人能改。
 
 - **跨会话** — 会话 A 记下「鉴权走 header X」，会话 B 调用 `ctx_find("鉴权")` 命中，并带上它连着谁（`about` / `decided` / `broke` / `fixed`）。
-- **默认安静** — 新会话只注入一张短地图（≤400 token）。模型要用再调工具，不会每一步灌满。
-- **会话图** — compaction 切一段就收成一个方框；没压过可点「生成检查点」手切一格（不压缩模型窗口）；旧会话可点「更新检查点」补已经发生过的压缩 / 分叉；勾选的记忆芯片从当前这段的下一轮注入。
-- **人能改错** — 会话图芯片条可新增、归档、删除；设置页管搜、改名 / 正文、合并、导入导出、全局开关。
+- **默认安静** — 新会话只注入一张短地图（≤400 token）。模型要用再调工具，不会每一步灌满。标题栏默认也不加第三标签。
+- **芯片（默认关）** — 设置里打开后，标题栏出现 **芯片**；勾选的条目从下一轮注入（L0，≤300 token）。其下还有 **会话层**（也默认关）：把 compaction / 分叉画成方框。
+- **人能改错** — 芯片条可新增、归档、删除；设置页管搜、改名 / 正文、合并、导入导出、全局开关。
 - **抽取偏严** — 闲聊、一次性改文件、密钥**不会从对话自动入库**。芯片「新增」按你写的存（点一次整段一条），同样过写入卫生闸门。
 - **写入卫生** — `ctx_remember`、芯片新增、抽取、外部导入会拒绝乱码、复读、JSON envelope、base64 残骸和密钥。已经进 `.tdb` 的脏节点仍可在设置里看见以便归档；find / 短地图 / 芯片不再带它们。
 - **可选 embedding** — 默认关。官方 DeepSeek 对话接口没有 embeddings；可填 OpenAI 兼容地址。不开也能用：关键词 + 图遍历。
@@ -71,11 +106,11 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 ### 底层工程
 
 - **进程内、一个文件** — TriviumDB（向量 + JSON payload + 有向带权图）随 DSH 进程打开。不另起 HTTP / Python 服务。
-- **只有四个工具** — `ctx_find` / `ctx_read` / `ctx_remember` / `ctx_link`。会话图不加第五个。
+- **只有四个工具** — `ctx_find` / `ctx_read` / `ctx_remember` / `ctx_link`。芯片 / 会话层不加第五个。
 - **注入走 `agent.inject()`** — 不写 system prompt，避免 `persona.complete: true` 把地图静默丢掉。
 - **召回带路径** — 每条命中都说明从哪个节点、沿哪条边过来。
 - **失败不挡主循环** — 存储 / embedding / 抽取出错只记日志，Agent 继续。
-- **界面跟随宿主语言** — 设置页和会话图随 DSH `locale/change` 切换（`zh` / `en`）。
+- **界面跟随宿主语言** — 设置页和芯片标签随 DSH `locale/change` 切换（`zh` / `en`）。
 - **首轮短地图** — 每个会话只注入一次。若 `session-start` 和第一步赛跑输了，`pre-step` 会补上；不会每步重写（前缀缓存友好）。
 
 ## 功能
@@ -86,32 +121,11 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 
 `ctx_find` 返回 L0 摘要和图路径（入边写成 `<-label-id`）。查询点到已有实体名时，还会带上未过期的 about/decided/broke/fixed 邻居，即使邻居正文不含查询词。带 `until` 的过期决策默认不出现，除非查询本身在问期限（如「周五」）。
 
-### 会话图
+### 芯片（可选）
 
-入口：当前会话标题栏 **对话 / 轨迹 / 会话图**。这是情节图，不是记忆编辑器；改名、合并、全局开关仍走设置页。芯片条上可以直接新增、归档、删除。
+默认关。在设置里打开 **芯片标签**，然后重启 `dsh web`。标题栏出现 **对话 / 轨迹 / 芯片**。这是钉选条，不是记忆编辑器；改名、合并、全局开关仍走设置页。
 
-**方框**
-
-- 没压过上下文：只有一个「后续」方框。
-- 一次成功的 compaction 之后：左边历史检查点（摘要来自 DSH），右边仍是「后续」。
-- 点「生成检查点」：把当前「后续」收成左边一格，右边继续当后续。只切情节图，**不**压缩模型窗口。同一轮次再点不会双写。
-- 装插件之前已经压过 / 分过叉的旧会话：点「更新检查点」，从当前对话里的压缩标记和侧边栏分叉补方框（可重复点，不会双写）。没压过就仍只有「后续」——会话长、工具多不等于 DSH 已经压缩（默认约窗口 80% 才自动压）。要压上下文请在对话里输入 `/compact`。
-- 方框自己不压缩。质量来自 DSH 已经做的摘要替换；fork 时不会再总结一遍。
-- 「改名」只改方框标题，不动 DSH 摘要。点方框可跳回对话里对应的检查点，或打开轨迹。
-
-**分叉**
-
-点方框上的分叉图标，会弹出「分叉为新会话」。这个名字会出现在左侧会话列表里（默认是源标题加 `(1)`）。
-
-确认后走宿主的 `session.fork`：子会话出现在侧边栏，前缀（含当时已经压过的摘要）由 DSH 拷过去。有检查点时从那个检查点切开；只有「后续」时就从你点的那个方框连出去。
-
-对话页里用 DSH 自带 fork，切回会话图也能看到对应分支。侧边栏归档一个子会话后，图上的分叉方框会跟着消失；取消归档会再出现。
-
-画布：空白处拖动平移，滚轮缩放。
-
-### 记忆芯片
-
-会话图顶部可展开勾选。列出未归档的 preference / decision / entity（experience 不进芯片，避免太吵）。
+列出未归档的 preference / decision / entity（experience 不进芯片）。勾选后从下一轮注入（L0，≤300 token）。条上可新增、归档、删除。
 
 | 操作 | 生效时机 |
 |---|---|
@@ -122,12 +136,16 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 | 选择 → 删除 | 从 `.tdb` 去掉，不可恢复 |
 | 已经发出去的轮次 | 不回写 |
 
-芯片按会话隔离。新开会话、fork 出的子会话默认都不勾；需要的话在分叉对话框旁打开「分叉时继承钉选」，或到子会话里重新勾。短地图仍在 session-start 自动带，不占芯片位。
+芯片按会话隔离。新开会话、fork 出的子会话默认都不勾。短地图仍在 session-start 自动带，不占芯片位。
+
+其下 **会话层** 也默认关。打开后，同一标签里画出 compaction / 分叉方框（生成检查点、更新检查点、从方框 fork）。`episode` 不进 `ctx_find`。关掉会话层就停止写检查点，已有节点仍在 `.tdb`。
 
 ### 设置页（Trivium 记忆）
 
-设置里的「Trivium 记忆」管库，不替代会话图。
+设置里的「Trivium 记忆」管库，也管这两层可选表面。
 
+- **芯片标签（默认关）** — 标题栏「芯片」+ 钉选注入。保存后重启 `dsh web`。
+- **会话层（默认关，挂在芯片下）** — 情节画布。要先打开芯片标签。
 - **注入策略（三选一，默认关）** — 关：只有开场短地图。autoRecall：本步含用户文本时最多灌 3 条 L0。实体名折中：话里点到已有实体才灌 1 跳业务边邻居。芯片钉选与此并存，优先占预算。
 - **抽取** — 默认在 `compaction/end` 和空闲后再抽；失败进 pending，下次 session-start 重放。每批正文 ≤3000 字、最多 24 条。
 - **条目** — 可搜、按类型筛、展开业务边邻居、「只看挂在这上面的」、默认隐藏过期决策。可改名 / 改正文 / 别名 / until，同类型合并，归档或删除。
@@ -144,7 +162,7 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 | `ctx_remember` | 手动写入 |
 | `ctx_link` | 两点之间建有向边 |
 
-内核仍是这四个。会话图不加第五个工具。
+内核仍是这四个。芯片 / 会话层不加第五个工具。
 
 ---
 
@@ -170,11 +188,11 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 
 <img width="560" alt="条目列表" src="docs/screenshots/05-settings-list.png">
 
-### 会话图 — 对话 / 轨迹旁的第三标签
+### 芯片标签 — 可选，在对话 / 轨迹旁
 
-<img width="560" alt="会话图" src="docs/screenshots/06-session-map.png">
+<img width="560" alt="芯片 / 会话层" src="docs/screenshots/06-session-map.png">
 
-标题栏出现「会话图」。没压过的会话只有一个「后续」方框；顶部是记忆芯片（默认不勾）。可点「生成检查点」把后续收成左边一格。compaction 或 `/compact` 之后左边也会出现历史方框，分叉从方框连到子会话。
+默认关。设置里打开 **芯片** 并重启后，标题栏出现「芯片」。若同时打开 **会话层**，没压过的会话只有一个「后续」方框；顶部是记忆芯片（默认不勾）。可点「生成检查点」把后续收成左边一格。compaction 或 `/compact` 之后左边也会出现历史方框，分叉从方框连到子会话。
 
 ---
 
@@ -184,7 +202,7 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 - 抽取会漏；脏数据可在芯片条归档 / 删除，或到设置里改、合并。
 - 同一个 `.tdb` 不要两个 Node 进程同时打开（正常只开一个 `dsh web` 即可）。
 - Markdown 导出是给人看的，不能再解析回去。外部导入（WorkBuddy / Claude Code / Codex）是一次性，不是双向同步，也不会吃会话 jsonl。
-- 会话图默认只投影 compaction 与 fork，不会按消息条数自己切方框。窗口没到 DSH 压缩线时，「更新检查点」也补不出历史方框；要分段请点「生成检查点」。
+- 会话层打开时只投影 compaction 与 fork，不会按消息条数自己切方框。窗口没到 DSH 压缩线时，「更新检查点」也补不出历史方框；要分段请点「生成检查点」。
 - 改插件设置后需要重启 `dsh web`。
 - 宿主升到 rc.8 后，DSH 自己的旧会话库可能打不开（官方 SQLite 格式不兼容）。工作区里的 `.tdb` 图记忆还在；对不上号的旧会话图方框可以当情节残留，不影响 `ctx_find`。
 
@@ -192,6 +210,10 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 
 ## 更新说明
 
+**0.4.10** — `dsh plugin remove` 会删掉已知工作区的 `.tdb` 和 `~/.dsh/trivium.json`。升级安装不清记忆。配置里 disabled 仍保留数据。
+
+**0.4.9** — 芯片标签和会话层画布都默认关。设置里打开芯片后标题栏才出现「芯片」；情节方框嵌在其下。内核（四工具、短地图、进程内 `.tdb`）不变。
+
 **0.4.8** — 写入 + 注入卫生闸门（密钥、乱码、复读、JSON envelope、base64 残骸）。设置页 / 会话图跟随 DSH 语言。设置页可检查 npm 更新。一次性严导入同时发现 Claude Code `CLAUDE.md` 与 Codex `AGENTS.md`。若 `session-start` 和第一步赛跑，首轮短地图仍会补上。
 
 **0.4.7** — 存储升到 `triviumdb@0.7.6`（引擎侧 `searchExact` / `searchBatch`）。find / 会话图行为不变。
@@ -210,12 +232,29 @@ Trivium 是记忆内核，不是日记、日历或聊天伴侣。它按**节点
 
 **0.4.0** — 会话图、记忆芯片、从检查点 fork。
 
+## 排障
+
+| 现象 | 处理 |
+|---|---|
+| 设置里没有「Trivium 记忆」 | 确认装的是 web profile，然后**重启** `dsh web`，再打开一个工作区。只刷新浏览器不够。 |
+| 标题栏没有「芯片」 | 正常。默认关。在设置里打开「芯片标签」，保存后重启 `dsh web`。 |
+| 改了注入 / 抽取 / embedding / 芯片开关没生效 | 同样要重启 `dsh web`。 |
+| 会话层只有一个「后续」方框 | 正常（在会话层已打开时）。方框跟 DSH 压缩走，会话长不等于已经压过（默认约窗口 80% 才自动压）。要分段：对话里 `/compact`，或点「生成检查点」（只切图，不压窗口）。旧会话可点「更新检查点」补已经发生过的压缩 / 分叉。 |
+| `ctx_find` 什么都没有 | 新会话默认只注入短地图，模型要自己调工具。也可以在芯片条「新增」或对模型说「记住：…」。闲聊和一次性改文件不会自动入库。 |
+| 报 `.tdb` 被占用 / 打不开 | 只开一个 `dsh web`。不要同时跑两份链接了本插件的 Node 进程。 |
+| embedding 填了但检索没变准 | 失败会退回关键词 + 图。看 `~/.dsh/trivium.json` 里 URL 是否 OpenAI 兼容（含 `/v1` 那种）。改完重启。 |
+| 卸载后记忆还在 | 先停 `dsh web` 再 `dsh plugin remove`。剩下的 `.tdb` 是从未用 0.4.10 打开过的工作区，到该文件夹删 `.dsh/trivium.tdb`。只在配置里 disabled 不会清文件。 |
+| 检查更新失败 | 只请求 npm registry 拿最新版本号，不影响记忆；过一会儿再点即可。 |
+| rc.8 之后旧对话打不开 | 那是 DSH 自己的会话库格式变了，不是 `.tdb` 坏了。图记忆仍可 `ctx_find`；对不上号的旧方框可当情节残留。 |
+
+本地联调：仓库里 `npm install` 后 `node scripts/link-dsh.mjs`，再重启 `dsh web`。`triviumdb` 是原生模块，装不上时先看 Node 是否满足 `package.json` 的 `engines`（`^22.19.0 || >=24`）。
+
 ---
 
 ## 发布信息
 
 - GitHub: https://github.com/QWQcool/dsh-trivium
-- npm: [`dsh-trivium@0.4.8`](https://www.npmjs.com/package/dsh-trivium)
+- npm: [`dsh-trivium@0.4.10`](https://www.npmjs.com/package/dsh-trivium)
 - 测试宿主：`@deepseek-ai/dsh@0.1.1-rc.2`（兼 `0.1.0-rc.8`）
 - License: MIT（依赖 [TriviumDB](https://github.com/YoKONCy/TriviumDB) 为 Apache-2.0）
 

package/lib/client.js

@@ -28,6 +28,11 @@ window.__ModuleLoader__.load({
         recallAnchorHint: "用户文本命中已有 entity 的 name/aliases 时，注入该实体 1 跳 about/decided/broke/fixed 邻居（≤300 token）。",
         extract: "compaction/end 抽取",
         extractHint: "规则 + 一次小 prompt；失败只记日志。turn 结束后约 12 秒空闲会再抽一次，下次 session-start 也会重放 pending。每轮写入正文合计 ≤3000 字、最多 24 条。",
+        chipTab: "芯片",
+        chipsSetting: "芯片标签（默认关）",
+        chipsSettingHint: "打开后，标题栏「对话 / 轨迹」旁出现「芯片」。勾选的条目从下一轮注入（L0，≤300 token）。节点仍在 .tdb，关开关不删记忆。改完保存后重启 dsh web，标签才会出现或消失。",
+        sessionLayer: "会话层（情节画布）",
+        sessionLayerHint: "可选。把 compaction / 分叉画成方框，可生成检查点。关着不记 episode，不影响 ctx_find。需先打开芯片标签。",
         markdown: "Markdown 投影",
         markdownHint: "只读导出，带边（- 鉴权走 header X —about→ AuthGateway）。给编辑器和 git 看。改完回写用 JSON 导入或本页编辑，不解析自由散文。",
         exportMd: "导出 Markdown",
@@ -133,7 +138,8 @@ window.__ModuleLoader__.load({
         cancelSelect: "取消选择",
         chipSelectHint: "点芯片多选。归档：软删除，find / 短地图 / 芯片不再出现，节点还在库里。删除：从 .tdb 去掉，不可恢复。",
         chipClipped: "已截到预算（≤300 token）",
-        chipPinHint: "勾选后从当前这段的下一轮注入。空白处拖动画布，滚轮缩放。",
+        chipPinHint: "勾选后从当前这段的下一轮注入。",
+        chipPinHintMap: "勾选后从当前这段的下一轮注入。空白处拖动画布，滚轮缩放。",
         chipDraftPh: "粘贴或输入要记住的内容。点一次写入，整段就是一条芯片。",
         writePin: "写入并钉选",
         suggested: "建议",
@@ -164,6 +170,11 @@ window.__ModuleLoader__.load({
         recallAnchorHint: "When user text names an existing entity, inject 1-hop about/decided/broke/fixed neighbors (≤300 tokens).",
         extract: "Extract on compaction/end",
         extractHint: "Rules + one small prompt; failures are logged. Idle ~12s after turn/end also extracts; pending replays on next session-start. Per batch: body ≤3000 chars, at most 24 items.",
+        chipTab: "Chips",
+        chipsSetting: "Chips tab (off by default)",
+        chipsSettingHint: "When on, the title bar shows Chips next to Conversation / Trajectory. Checked items inject from the next turn (L0, ≤300 tokens). Nodes stay in .tdb; turning this off does not delete memory. Restart dsh web after save for the tab to appear or disappear.",
+        sessionLayer: "Session layer (plot canvas)",
+        sessionLayerHint: "Optional. Draws compaction / forks as boxes; Create checkpoint lives here. Off means no episode writes; ctx_find is unchanged. Requires the Chips tab first.",
         markdown: "Markdown projection",
         markdownHint: "Read-only export with edges (e.g. - auth in header X —about→ AuthGateway). For editors and git. Write back with JSON import or this page, not free prose.",
         exportMd: "Export Markdown",
@@ -269,7 +280,8 @@ window.__ModuleLoader__.load({
         cancelSelect: "Cancel select",
         chipSelectHint: "Click chips to multi-select. Archive: soft delete, gone from find / short map / chips, node stays in .tdb. Delete: removed from .tdb, not recoverable.",
         chipClipped: "Clipped to budget (≤300 tokens)",
-        chipPinHint: "Checked chips inject from the next turn of this segment. Drag empty canvas to pan, scroll to zoom.",
+        chipPinHint: "Checked chips inject from the next turn of this segment.",
+        chipPinHintMap: "Checked chips inject from the next turn of this segment. Drag empty canvas to pan, scroll to zoom.",
         chipDraftPh: "Paste or type a fact. One click writes one chip; a whole paste is still one node.",
         writePin: "Write and pin",
         suggested: "suggested",
@@ -408,6 +420,8 @@ window.__ModuleLoader__.load({
       const [saved, setSaved] = react.useState(false);
       const [recallMode, setRecallMode] = react.useState("off");
       const [extractEnabled, setExtractEnabled] = react.useState(true);
+      const [chipsEnabled, setChipsEnabled] = react.useState(false);
+      const [sessionLayerEnabled, setSessionLayerEnabled] = react.useState(false);
       const [embeddingEnabled, setEmbeddingEnabled] = react.useState(false);
       const [embeddingUrl, setEmbeddingUrl] = react.useState("");
       const [embeddingModel, setEmbeddingModel] = react.useState("text-embedding-3-small");
@@ -428,6 +442,8 @@ window.__ModuleLoader__.load({
           setStatus(st);
           setRecallMode(st.recallMode || (st.autoRecall ? "auto" : st.anchorRecall ? "anchor" : "off"));
           setExtractEnabled(st.extractEnabled !== false);
+          setChipsEnabled(!!st.chipsEnabled);
+          setSessionLayerEnabled(!!st.sessionLayerEnabled);
           setEmbeddingEnabled(!!st.embeddingEnabled);
           setEmbeddingUrl(st.embeddingUrl || "");
           setEmbeddingModel(st.embeddingModel || "text-embedding-3-small");
@@ -466,6 +482,8 @@ window.__ModuleLoader__.load({
           const body = {
             recallMode,
             extractEnabled,
+            chipsEnabled,
+            sessionLayerEnabled,
             embeddingEnabled,
             embeddingUrl,
             embeddingModel,
@@ -801,6 +819,36 @@ window.__ModuleLoader__.load({
               jsx("div", { style: ui.hint, children: L.extractHint }),
             ],
           }),
+          jsxs("div", {
+            style: ui.card,
+            children: [
+              jsxs("label", {
+                style: ui.switch,
+                children: [
+                  jsx("input", {
+                    type: "checkbox",
+                    checked: chipsEnabled,
+                    onChange: (e) => setChipsEnabled(e.target.checked),
+                  }),
+                  jsx("span", { children: L.chipsSetting }),
+                ],
+              }),
+              jsx("div", { style: ui.hint, children: L.chipsSettingHint }),
+              jsxs("label", {
+                style: { ...ui.switch, fontWeight: 500, paddingLeft: 22, opacity: chipsEnabled ? 1 : 0.5 },
+                children: [
+                  jsx("input", {
+                    type: "checkbox",
+                    checked: sessionLayerEnabled,
+                    disabled: !chipsEnabled,
+                    onChange: (e) => setSessionLayerEnabled(e.target.checked),
+                  }),
+                  jsx("span", { children: L.sessionLayer }),
+                ],
+              }),
+              jsx("div", { style: { ...ui.hint, paddingLeft: 22 }, children: L.sessionLayerHint }),
+            ],
+          }),
           jsxs("div", {
             style: ui.card,
             children: [
@@ -2102,7 +2150,8 @@ window.__ModuleLoader__.load({
       const [pan, setPan] = react.useState({ x: 0, y: 0 });
       const [chipQuery, setChipQuery] = react.useState("");
       const [inheritPins, setInheritPins] = react.useState(false);
-      const [chipsOpen, setChipsOpen] = react.useState(false);
+      const [chipsOpen, setChipsOpen] = react.useState(true);
+      const [sessionLayer, setSessionLayer] = react.useState(false);
       const [chipSelect, setChipSelect] = react.useState(false);
       const [pickedIds, setPickedIds] = react.useState([]);
       const [draftOpen, setDraftOpen] = react.useState(false);
@@ -2151,9 +2200,18 @@ window.__ModuleLoader__.load({
       const load = react.useCallback(async () => {
         if (!sessionId) return { nodes: [], edges: [] };
         try {
-          const map = await api("/api/dsh-trivium/map" + qs);
-          setNodes(map.nodes || []);
-          setEdges(map.edges || []);
+          const st = await api("/api/dsh-trivium/status");
+          const layer = !!st.sessionLayerEnabled;
+          setSessionLayer(layer);
+          let map = { nodes: [], edges: [] };
+          if (layer) {
+            map = await api("/api/dsh-trivium/map" + qs);
+            setNodes(map.nodes || []);
+            setEdges(map.edges || []);
+          } else {
+            setNodes([]);
+            setEdges([]);
+          }
           const chipResp = await api("/api/dsh-trivium/chips" + qs);
           setChips(chipResp.chips || []);
           const pinResp = await api("/api/dsh-trivium/pins" + qs);
@@ -2511,6 +2569,8 @@ window.__ModuleLoader__.load({
         livePreview: lastUserPreview(chat),
       };
 
+      const showChips = !sessionLayer || chipsOpen;
+
       return jsxs("div", {
         "data-map-build": "sessions-inject",
         style: mapUi.root,
@@ -2528,33 +2588,39 @@ window.__ModuleLoader__.load({
               jsxs("div", {
                 style: mapUi.chipsActions,
                 children: [
-                  jsx("button", {
-                    type: "button",
-                    style: mapUi.actionBtn,
-                    disabled: busy,
-                    title: t("cutTitle"),
-                    onClick: cutCheckpoint,
-                    children: busy ? t("cutting") : t("cutBtn"),
-                  }),
-                  jsx("button", {
-                    type: "button",
-                    style: mapUi.actionBtn,
-                    disabled: busy,
-                    title: t("updateTitle"),
-                    onClick: syncCheckpoints,
-                    children: busy ? t("updating") : t("updateBtn"),
-                  }),
-                  jsx("button", {
-                    type: "button",
-                    style: mapUi.actionBtn,
-                    onClick: () => setChipsOpen((v) => !v),
-                    children: chipsOpen ? t("collapse") : t("expand"),
-                  }),
+                  sessionLayer
+                    ? jsx("button", {
+                        type: "button",
+                        style: mapUi.actionBtn,
+                        disabled: busy,
+                        title: t("cutTitle"),
+                        onClick: cutCheckpoint,
+                        children: busy ? t("cutting") : t("cutBtn"),
+                      })
+                    : null,
+                  sessionLayer
+                    ? jsx("button", {
+                        type: "button",
+                        style: mapUi.actionBtn,
+                        disabled: busy,
+                        title: t("updateTitle"),
+                        onClick: syncCheckpoints,
+                        children: busy ? t("updating") : t("updateBtn"),
+                      })
+                    : null,
+                  sessionLayer
+                    ? jsx("button", {
+                        type: "button",
+                        style: mapUi.actionBtn,
+                        onClick: () => setChipsOpen((v) => !v),
+                        children: chipsOpen ? t("collapse") : t("expand"),
+                      })
+                    : null,
                 ],
               }),
             ],
           }),
-          chipsOpen
+          showChips
             ? jsxs("div", {
                 style: { display: "flex", flexDirection: "column", gap: 8 },
                 children: [
@@ -2568,17 +2634,19 @@ window.__ModuleLoader__.load({
                         onChange: (e) => setChipQuery(e.target.value),
                         style: mapUi.search,
                       }),
-                      jsxs("label", {
-                        style: mapUi.inherit,
-                        children: [
-                          jsx("input", {
-                            type: "checkbox",
-                            checked: inheritPins,
-                            onChange: (e) => setInheritPins(e.target.checked),
-                          }),
-                          t("inheritPins"),
-                        ],
-                      }),
+                      sessionLayer
+                        ? jsxs("label", {
+                            style: mapUi.inherit,
+                            children: [
+                              jsx("input", {
+                                type: "checkbox",
+                                checked: inheritPins,
+                                onChange: (e) => setInheritPins(e.target.checked),
+                              }),
+                              t("inheritPins"),
+                            ],
+                          })
+                        : null,
                       jsxs("div", {
                         style: mapUi.chipsActions,
                         children: [
@@ -2630,7 +2698,9 @@ window.__ModuleLoader__.load({
                       ? t("chipSelectHint")
                       : clipped
                         ? t("chipClipped")
-                        : t("chipPinHint"),
+                        : sessionLayer
+                          ? t("chipPinHintMap")
+                          : t("chipPinHint"),
                   }),
                   draftOpen
                     ? jsxs("div", {
@@ -2707,7 +2777,8 @@ window.__ModuleLoader__.load({
               })
             : null,
           error ? jsx("div", { style: mapUi.error, children: error }) : null,
-          jsx("div", {
+          sessionLayer
+            ? jsx("div", {
             ref: canvasRef,
             style: mapUi.canvas,
             onPointerDown,
@@ -2810,7 +2881,8 @@ window.__ModuleLoader__.load({
                       );
                     }),
             }),
-          }),
+          })
+            : null,
           forkDraft
             ? jsx("div", {
                 style: mapUi.overlay,
@@ -2859,37 +2931,7 @@ window.__ModuleLoader__.load({
       });
     }
 
-    function apply(ctx) {
-      workspacesList = ctx.workspaces?.list || null;
-      const sessions = ctx.sessions;
-      try {
-        const snap = ctx.locale && typeof ctx.locale.getLocale === "function" ? ctx.locale.getLocale() : null;
-        if (snap && snap.active) setUiLocale(snap.active);
-      } catch {
-        // host may not expose locale
-      }
-      try {
-        ctx.on("locale/change", (snap) => {
-          if (snap && snap.active) setUiLocale(snap.active);
-        });
-      } catch {
-        // ignore
-      }
-      ctx.slots.inject(
-        "settings.section",
-        () =>
-          ctx.slots.register(
-            {
-              name: "settings.section",
-              id: "dsh-trivium",
-              order: 62,
-              label: () => L.nav,
-              inject: () => ({}),
-            },
-            TriviumCard,
-          ),
-        "dsh-trivium: settings section",
-      );
+    function registerChipView(ctx, sessions) {
       ctx.slots.inject(
         "conversation.view",
         () => {
@@ -2897,9 +2939,9 @@ window.__ModuleLoader__.load({
           return ctx.slots.register(
             {
               name: "conversation.view",
-              id: "session-map",
+              id: "chips",
               order: 20,
-              label: () => t("sessionMap"),
+              label: () => t("chipTab"),
               ...(chatStore ? { store: chatStore } : {}),
               inject: () => ({
                 fork: (opts) => sessions.fork(opts),
@@ -2930,8 +2972,49 @@ window.__ModuleLoader__.load({
             SessionMapView,
           );
         },
-        "dsh-trivium: session map",
+        "dsh-trivium: chips",
+      );
+    }
+
+    function apply(ctx) {
+      workspacesList = ctx.workspaces?.list || null;
+      const sessions = ctx.sessions;
+      try {
+        const snap = ctx.locale && typeof ctx.locale.getLocale === "function" ? ctx.locale.getLocale() : null;
+        if (snap && snap.active) setUiLocale(snap.active);
+      } catch {
+        // host may not expose locale
+      }
+      try {
+        ctx.on("locale/change", (snap) => {
+          if (snap && snap.active) setUiLocale(snap.active);
+        });
+      } catch {
+        // ignore
+      }
+      ctx.slots.inject(
+        "settings.section",
+        () =>
+          ctx.slots.register(
+            {
+              name: "settings.section",
+              id: "dsh-trivium",
+              order: 62,
+              label: () => L.nav,
+              inject: () => ({}),
+            },
+            TriviumCard,
+          ),
+        "dsh-trivium: settings section",
       );
+      fetch("/api/dsh-trivium/status")
+        .then((resp) => (resp && resp.ok ? resp.json() : null))
+        .then((st) => {
+          if (st && st.chipsEnabled === true) registerChipView(ctx, sessions);
+        })
+        .catch(() => {
+          // default off: no title-bar tab
+        });
     }
 
     exports.apply = apply;

package/lib/index.js

@@ -20,7 +20,7 @@ import {
   textFromContent,
 } from "./extract.js";
 import { readUiSettings, registerMemoryApi } from "./server.js";
-import { applyRecallMode, recallModeOf } from "./settings.js";
+import { applyRecallMode, chipsEnabledOf, recallModeOf, sessionLayerEnabledOf } from "./settings.js";
 import { configureEmbedding } from "./embed.js";
 import { recordCheckpoint, ensureTail, syncForkLineage } from "./episode.js";
 import { buildPinInject } from "./pins.js";
@@ -33,6 +33,8 @@ const DEFAULTS = {
   anchorRecall: false,
   recallMode: "off",
   extractEnabled: true,
+  chipsEnabled: false,
+  sessionLayerEnabled: false,
   writeApproval: false,
   mapTokenBudget: 400,
   expandDepth: 1,
@@ -283,7 +285,7 @@ export function apply(ctx, config = {}) {
       try {
         const session = agent.session;
         const sessionId = sessionKey(session);
-        if (sessionId) {
+        if (sessionId && sessionLayerEnabledOf(optionsOf())) {
           const seedLen = session?.header?.seedLength;
           ensureTail(db, sessionId, {
             atSeq: Number.isFinite(Number(seedLen)) && seedLen > 0 ? seedLen - 1 : 0,
@@ -334,7 +336,7 @@ export function apply(ctx, config = {}) {
         }).catch((err) => log.warn?.(`[dsh-trivium] compaction extract: ${err.message}`));
         const cwd = buf.cwd || session.header?.cwd;
         const sessionId = buf.sessionId || session.id;
-        if (cwd && sessionId) {
+        if (cwd && sessionId && sessionLayerEnabledOf(optionsOf())) {
           const summary =
             buf.compactionSummary?.id === event.data?.compactionId && buf.compactionSummary.text
               ? buf.compactionSummary.text
@@ -361,7 +363,13 @@ export function apply(ctx, config = {}) {
         const bufEnd = bufOf(session);
         const lastUser = [...(bufEnd.turns || [])].reverse().find((t) => t.role === "user");
         const preview = String(lastUser?.text || "").trim();
-        if (bufEnd.cwd && bufEnd.sessionId && preview && !preview.startsWith("/")) {
+        if (
+          bufEnd.cwd &&
+          bufEnd.sessionId &&
+          preview &&
+          !preview.startsWith("/") &&
+          sessionLayerEnabledOf(optionsOf())
+        ) {
           openWorkspaceDb(bufEnd.cwd)
             .then((db) => {
               ensureTail(db, bufEnd.sessionId, {
@@ -409,24 +417,26 @@ export function apply(ctx, config = {}) {
       const extra = [];
       const db = await openWorkspaceDb(cwdOf(agent));
       const sessionId = sessionKey(agent.session);
-      try {
-        const pin = buildPinInject(db, sessionId, 300);
-        if (pin.text) {
-          extra.push(
-            createUserMessage({
-              content: [{ type: "text", text: pin.text }],
-              source: {
-                kind: "plugin",
-                plugin: "dsh-trivium",
-                form: "pins",
-              },
-            }),
-          );
+      const options = optionsOf();
+      if (chipsEnabledOf(options)) {
+        try {
+          const pin = buildPinInject(db, sessionId, 300);
+          if (pin.text) {
+            extra.push(
+              createUserMessage({
+                content: [{ type: "text", text: pin.text }],
+                source: {
+                  kind: "plugin",
+                  plugin: "dsh-trivium",
+                  form: "pins",
+                },
+              }),
+            );
+          }
+        } catch (err) {
+          log.warn?.(`[dsh-trivium] pre-step pins skipped: ${err.message}`);
         }
-      } catch (err) {
-        log.warn?.(`[dsh-trivium] pre-step pins skipped: ${err.message}`);
       }
-      const options = optionsOf();
       const mode = recallModeOf(options);
       if (mode !== "off") {
         const proposed = [...(decision.messages || []), ...(messages || [])];

package/lib/purge.js

@@ -0,0 +1,116 @@
+/** Wipe plugin files on real uninstall. Never run this on dsh web restart. */
+
+import { existsSync, readdirSync, unlinkSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { listedWorkspaces, settingsFilePath } from "./settings.js";
+import { closeAll, listOpenWorkspaces } from "./store.js";
+
+export function isTriviumArtifactName(name) {
+  const n = String(name || "");
+  return n === "trivium-pending.json" || n === "trivium.tdb" || n.startsWith("trivium.tdb");
+}
+
+/**
+ * `dsh plugin remove` / `pnpm remove` should wipe.
+ * `pnpm add` / update / ci reinstall the same package and must keep memory.
+ */
+export function shouldWipeOnUninstall(env = process.env, argv = process.argv) {
+  if (argv.includes("--force-purge")) return true;
+  const event = String(env.npm_lifecycle_event || "").toLowerCase();
+  if (event && event !== "preuninstall" && event !== "uninstall") return false;
+
+  const cmd = String(env.npm_command || "").toLowerCase();
+  if (cmd === "remove" || cmd === "uninstall") return true;
+  if (cmd === "install" || cmd === "add" || cmd === "update" || cmd === "upgrade" || cmd === "ci" || cmd === "dedupe") {
+    return false;
+  }
+
+  const cooked = String(env.npm_config_argv || "").toLowerCase();
+  if (/\b(remove|uninstall)\b/.test(cooked) && !/\b(install|add|update|upgrade)\b/.test(cooked)) return true;
+  if (/\b(install|add|update|upgrade|ci)\b/.test(cooked)) return false;
+
+  // Unknown command: keep memory. Upgrades must never delete the store.
+  return false;
+}
+
+export function collectPurgeCwds(extraCwds = []) {
+  const seen = new Set();
+  const out = [];
+  const add = (cwd) => {
+    const key = String(cwd || "").trim();
+    if (!key) return;
+    const resolved = resolve(key);
+    if (seen.has(resolved)) return;
+    seen.add(resolved);
+    out.push(resolved);
+  };
+  for (const cwd of listedWorkspaces()) add(cwd);
+  for (const row of listOpenWorkspaces()) add(row.cwd);
+  for (const cwd of extraCwds) add(cwd);
+  return out;
+}
+
+function unlinkQuiet(path, files, errors) {
+  try {
+    unlinkSync(path);
+    files.push(path);
+  } catch (err) {
+    if (err && err.code !== "ENOENT") errors.push({ path, message: String(err.message || err) });
+  }
+}
+
+export function purgeWorkspaceArtifacts(cwd, files, errors) {
+  const dir = join(resolve(cwd), ".dsh");
+  if (!existsSync(dir)) return;
+  let names = [];
+  try {
+    names = readdirSync(dir);
+  } catch (err) {
+    errors.push({ path: dir, message: String(err.message || err) });
+    return;
+  }
+  for (const name of names) {
+    if (!isTriviumArtifactName(name)) continue;
+    unlinkQuiet(join(dir, name), files, errors);
+  }
+}
+
+/** Delete known workspace traces and ~/.dsh/trivium.json. Leaves other .dsh files alone. */
+export function purgeAllTraces({ extraCwds = [], close = closeAll } = {}) {
+  const settingsFile = settingsFilePath();
+  const workspaces = collectPurgeCwds(extraCwds);
+  try {
+    close();
+  } catch {
+    // ignore
+  }
+  const files = [];
+  const errors = [];
+  for (const cwd of workspaces) purgeWorkspaceArtifacts(cwd, files, errors);
+  unlinkQuiet(settingsFile, files, errors);
+  return { ok: errors.length === 0, workspaces, files, errors, settingsFile };
+}
+
+function shouldRunCli() {
+  return basename(String(process.argv[1] || "")) === "purge.js";
+}
+
+export function runUninstallPurge(env = process.env, argv = process.argv, log = console) {
+  if (!shouldWipeOnUninstall(env, argv)) {
+    log.info?.("[dsh-trivium] skip data wipe (install/update, not remove)");
+    return { skipped: true };
+  }
+  const result = purgeAllTraces();
+  const n = result.files.length;
+  log.info?.(`[dsh-trivium] removed ${n} plugin file${n === 1 ? "" : "s"} from ${result.workspaces.length} workspace(s)`);
+  if (result.errors.length) {
+    log.warn?.("[dsh-trivium] some files could not be deleted (stop dsh web and delete leftovers):");
+    for (const err of result.errors) log.warn?.(`  ${err.path}: ${err.message}`);
+  }
+  return result;
+}
+
+if (shouldRunCli()) {
+  const result = runUninstallPurge();
+  if (result?.errors?.length) process.exitCode = 1;
+}

package/lib/server.js

@@ -15,7 +15,7 @@ import {
   updateNode,
 } from "./store.js";
 import { embeddingPublicStatus } from "./embed.js";
-import { recallModeOf, writeUiSettings } from "./settings.js";
+import { chipsEnabledOf, recallModeOf, sessionLayerEnabledOf, writeUiSettings } from "./settings.js";
 import { discoverWorkbuddyFiles, discoverExternalFiles, exportMarkdown, importWorkbuddy, importExternal } from "./markdown.js";
 import { checkNpmUpdate, installedVersion } from "./update.js";
 import { writeGateMessage } from "./hygiene.js";
@@ -114,6 +114,8 @@ async function handle(req, res, { liveOptions, status }) {
       autoRecall: mode === "auto",
       anchorRecall: mode === "anchor",
       extractEnabled: opts.extractEnabled !== false,
+      chipsEnabled: chipsEnabledOf(opts),
+      sessionLayerEnabled: opts.sessionLayerEnabled === true,
       writeApproval: !!opts.writeApproval,
       mapTokenBudget: opts.mapTokenBudget || 400,
       workspaces: listOpenWorkspaces(),
@@ -309,6 +311,10 @@ async function handle(req, res, { liveOptions, status }) {
   }
 
   if (path === "/api/dsh-trivium/map/backfill" && method === "POST") {
+    if (!sessionLayerEnabledOf(liveOptions())) {
+      sendJson(res, 400, { ok: false, message: "session layer off" });
+      return;
+    }
     const { cwd, db } = await dbForRequest(url);
     if (!db) {
       sendJson(res, 400, { ok: false, message: "no workspace" });
@@ -326,6 +332,10 @@ async function handle(req, res, { liveOptions, status }) {
   }
 
   if (path === "/api/dsh-trivium/map/cut" && method === "POST") {
+    if (!sessionLayerEnabledOf(liveOptions())) {
+      sendJson(res, 400, { ok: false, message: "session layer off" });
+      return;
+    }
     const { cwd, db } = await dbForRequest(url);
     if (!db) {
       sendJson(res, 400, { ok: false, message: "no workspace" });

package/lib/settings.js

@@ -1,19 +1,68 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { looksHttpUrl } from "./embed.js";
 
 export const SETTINGS_FILE = join(homedir(), ".dsh", "trivium.json");
 
+/** Tests may set DSH_TRIVIUM_SETTINGS to a temp file so we never touch the live home config. */
+export function settingsFilePath() {
+  const override = String(process.env.DSH_TRIVIUM_SETTINGS || "").trim();
+  return override ? resolve(override) : SETTINGS_FILE;
+}
+
+function persistSettings(next) {
+  const file = settingsFilePath();
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(next, null, 2), "utf8");
+  return next;
+}
+
 export function readUiSettings() {
   try {
-    const raw = JSON.parse(readFileSync(SETTINGS_FILE, "utf8"));
+    const raw = JSON.parse(readFileSync(settingsFilePath(), "utf8"));
     return raw && typeof raw === "object" ? raw : {};
   } catch {
     return {};
   }
 }
 
+export function listedWorkspaces() {
+  const raw = readUiSettings().workspaces;
+  if (!Array.isArray(raw)) return [];
+  const seen = new Set();
+  const out = [];
+  for (const item of raw) {
+    const cwd = String(item || "").trim();
+    if (!cwd) continue;
+    const key = resolve(cwd);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
+
+function isInsideDir(parent, child) {
+  const rel = relative(resolve(parent), resolve(child));
+  return rel === "" || (rel !== ".." && !rel.startsWith(".." + sep));
+}
+
+/** Remember a workspace so uninstall can delete its .tdb. No-op if already listed. */
+export function rememberWorkspace(cwd) {
+  const key = String(cwd || "").trim();
+  if (!key) return listedWorkspaces();
+  const resolved = resolve(key);
+  if (!process.env.DSH_TRIVIUM_SETTINGS && isInsideDir(tmpdir(), resolved)) {
+    return listedWorkspaces();
+  }
+  const prev = readUiSettings();
+  const workspaces = listedWorkspaces();
+  if (workspaces.includes(resolved)) return workspaces;
+  persistSettings({ ...prev, workspaces: [...workspaces, resolved] });
+  return [...workspaces, resolved];
+}
+
 export function recallModeOf(opts = {}) {
   const mode = opts.recallMode;
   if (mode === "auto" || mode === "anchor" || mode === "off") return mode;
@@ -23,6 +72,16 @@ export function recallModeOf(opts = {}) {
   return "off";
 }
 
+/** Title-bar Chips tab + pin inject. Missing key = off. */
+export function chipsEnabledOf(opts = {}) {
+  return opts.chipsEnabled === true;
+}
+
+/** Checkpoint canvas. Nested under chips; missing key = off. */
+export function sessionLayerEnabledOf(opts = {}) {
+  return chipsEnabledOf(opts) && opts.sessionLayerEnabled === true;
+}
+
 export function applyRecallMode(target, mode) {
   const next = mode === "auto" || mode === "anchor" ? mode : "off";
   target.recallMode = next;
@@ -32,7 +91,6 @@ export function applyRecallMode(target, mode) {
 }
 
 export function writeUiSettings(patch) {
-  mkdirSync(join(homedir(), ".dsh"), { recursive: true });
   const prev = readUiSettings();
   const next = { ...prev };
   let mode = recallModeOf(prev);
@@ -50,6 +108,8 @@ export function writeUiSettings(patch) {
   }
   applyRecallMode(next, mode);
   if (typeof patch.extractEnabled === "boolean") next.extractEnabled = patch.extractEnabled;
+  if (typeof patch.chipsEnabled === "boolean") next.chipsEnabled = patch.chipsEnabled;
+  if (typeof patch.sessionLayerEnabled === "boolean") next.sessionLayerEnabled = patch.sessionLayerEnabled;
   if (typeof patch.embeddingEnabled === "boolean") next.embeddingEnabled = patch.embeddingEnabled;
   if (typeof patch.embeddingUrl === "string") {
     const url = patch.embeddingUrl.trim();
@@ -64,8 +124,9 @@ export function writeUiSettings(patch) {
   } else if (prev.pinsBySession && typeof prev.pinsBySession === "object") {
     next.pinsBySession = prev.pinsBySession;
   }
-  writeFileSync(SETTINGS_FILE, JSON.stringify(next, null, 2), "utf8");
-  return next;
+  if (Array.isArray(patch.workspaces)) next.workspaces = patch.workspaces;
+  else if (Array.isArray(prev.workspaces)) next.workspaces = prev.workspaces;
+  return persistSettings(next);
 }
 
 export function pinsOf(sessionId) {
@@ -84,11 +145,10 @@ export function writePins(sessionId, ids) {
   if (!key) return nextIds;
   if (!nextIds.length) delete pinsBySession[key];
   else pinsBySession[key] = nextIds;
-  mkdirSync(join(homedir(), ".dsh"), { recursive: true });
-  writeFileSync(SETTINGS_FILE, JSON.stringify({ ...prev, pinsBySession }, null, 2), "utf8");
+  persistSettings({ ...prev, pinsBySession });
   return nextIds;
 }
 
 export function settingsFileExists() {
-  return existsSync(SETTINGS_FILE);
+  return existsSync(settingsFilePath());
 }

package/lib/store.js

@@ -2,6 +2,7 @@ import { mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { rememberWorkspace } from "./settings.js";
 import { DIM, EDGE_LABELS, BUSINESS_EDGES, NODE_TYPES, indexTextFor, nowIso, weightOf, zeroVector } from "./schema.js";
 import { clipToTokenBudget, estimateTokens } from "./tokens.js";
 import { isStalePayload, parseUntilFromText, queryMentionsUntil, resolveUntilAt } from "./until.js";
@@ -78,6 +79,11 @@ export async function openWorkspaceDb(cwd) {
   ensureWorkspaceRoot(db, cwd);
   rebuildTextIndex(db);
   dbs.set(key, db);
+  try {
+    rememberWorkspace(key);
+  } catch {
+    // listing is best-effort; opening the store still succeeds
+  }
   return db;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-trivium",
-  "version": "0.4.8",
-  "description": "In-process graph memory and session map for DeepSeek Harness, backed by TriviumDB.",
+  "version": "0.4.10",
+  "description": "In-process graph memory for DeepSeek Harness, backed by TriviumDB.",
   "license": "MIT",
   "type": "module",
   "main": "lib/index.js",
@@ -42,6 +42,8 @@
     "smoke-p7": "node scripts/smoke-p7.mjs",
     "smoke-p8": "node scripts/smoke-p8.mjs",
     "smoke-p10": "node scripts/smoke-p10.mjs",
+    "smoke-p11": "node scripts/smoke-p11.mjs",
+    "preuninstall": "node ./lib/purge.js",
     "verify-live-p2": "node scripts/verify-live-p2.mjs"
   },
   "engines": {