@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.34

package/docs/memory.md

@@ -0,0 +1,121 @@
+# DSCODE global memory
+
+Global cross-session memory was added in DSCODE 0.2.0.
+
+Memory is stored across projects and sessions and shared within one DSCODE state directory. The workspace path and the source session are kept; project experience is not automatically promoted to other projects. It works separately from resume (restoring a full session), compaction (compressing the current context) and project instruction files.
+
+## Usage
+
+Reading and background generation are on by default. A new root session schedules history consolidation when it first produces a model request configuration, and from then on it tries once every 30 minutes; it never holds the user's reply back waiting for consolidation. Exiting the process cancels the background task and the next run continues it. Having no history memory on first use is normal.
+
+| Command | Behaviour |
+|---|---|
+| `/memories` or `/memories status` | Path, switches, background state, entry count, memory model calls and token usage |
+| `/memories off` / `on` | Disables / enables reading and further contribution for the current session; survives a session resume |
+| `/memories global-off` / `global-on` | Persistently turns global reading and generation off / on; a disable in the configuration file still wins |
+| `/memories run` | Schedules one background consolidation immediately, still under the idle, count and age limits |
+| `/memories note answer in Chinese` | Adds an explicit preference or correction for the next consolidation; text is added, never executed |
+| `/memories clear` | Clears the global generated results and the input memory; sessions created before the clear are no longer used for regeneration |
+
+`off` does not erase experience that was already consolidated; use `clear` to delete all old memory. Toggling a switch does not delete what is already in the current conversation either, so complete isolation needs a new session. `/clear` still clears the conversation, which is not the same as clearing global memory.
+
+The model automatically receives only a summary of at most 6000 characters. When historical experience is needed, use `memory_search` to find entries, procedures and source-session summaries; it returns session IDs, workspaces and original message sequence numbers. Simple tasks skip retrieval. Memory is not proof of the current code state.
+
+## Experimental Desktop package
+
+The [combined Desktop package](browser-use.md#install-the-experimental-combined-desktop-package)
+includes this memory service. It uses the same `/memories` commands and
+`memory_search` tool; there is no separate memory settings panel. Only DSCODE
+agents receive the summary and retrieval tool. Native Standard sessions cannot
+change memory through `/memories`; their history and child-agent history are
+excluded from extraction. A child DSCODE agent also respects its parent's
+session reading opt-out.
+
+Desktop stores memory under its own state directory by default, usually separate
+from the terminal installation. Sharing credentials does not share memory.
+Setting the same `DSCODE_MEMORY_HOME` shares the memory database, including global
+switches, notes and cleanup, between those installations. Extraction still reads
+the current Host's session history.
+
+Session and global switches, consolidated memory and source evidence survive a
+Host restart. Unloading the memory plugin cancels an in-flight generation,
+releases its leases and removes its tool and prompt from open agents. The files
+remain on disk, and reloading restores access for open DSCODE agents. Removing
+the whole package takes effect after quitting and restarting the application;
+use `/memories clear` first if you also want to delete generated memory.
+
+The packed service was checked on `0.2.1-alpha.1` and the signed macOS
+`0.2.0-rc.2` Electron Desktop Host with deterministic local inference. These
+checks cover generation, source evidence, parent opt-out, restart, cancellation,
+live-plugin reload and cost attribution across interleaved sessions. They do not establish live-model memory quality or
+renderer interaction with the slash commands.
+
+## Two-stage implementation
+
+1. Read the historical JSONL from the existing `sessionPersistence` service. Child agents, non-dscode sessions, active sessions, sessions with contribution switched off and oversized logs are skipped. Only original user messages and visible assistant text are extracted: thinking, tool payloads and injected system information are not read.
+2. An independent model request extracts `raw_memory`, `rollout_summary` and evidence message sequence numbers. JSON, field lengths and source ranges are validated, and common secret formats in the input and output are redacted. With no usable experience it may return an empty result. A failure records exponential backoff; a success records the matching source version.
+3. Retained experience is selected by use count and recency, explicit user notes are added, and a second independent model request merges entries and reusable procedures. The model call is skipped when no input changed.
+4. After the source IDs referenced by the output are validated, a SQLite snapshot is published and a readable Markdown file is generated. Retrieval and summarisation use the database snapshot; an interrupted file generation can be repaired by the next consolidation.
+
+A SQLite lease coordinates multiple processes and the background holds a heartbeat; a source session under recovery, an expired lease and a clear operation all stop an old result from committing. The consolidation model has no shell, MCP, file-write or delegation tools, and file paths are determined by the plugin.
+
+Directory resolution order: plugin `root` → `DSCODE_MEMORY_HOME` → the native Harness home plus `memories`. Harness resolves a nonblank `DSH_HOME` (including supported tilde paths), otherwise `~/.dsh`. A source launch normally sets the project's `.runtime` as that home; the npm launcher maps its `DSCODE_HOME` into `DSH_HOME`. To share memory between installations, set the same `DSCODE_MEMORY_HOME` explicitly. Version 0.7.34 does not automatically move memory left in an earlier fallback directory.
+
+```text
+memories/
+  state.sqlite             # job version, lease, switches, notes, authoritative snapshot and usage
+  memory_summary.md        # condensed summary
+  MEMORY.md                # experience handbook with sources
+  raw_memories.md           # currently retained per-session extraction results
+  rollout_summaries/*.md    # session summaries, with message sequence numbers
+  skills/*/SKILL.md         # consolidated reusable procedures, retrieved on demand
+```
+
+These Markdown files are generated artifacts and manual edits are overwritten; submit corrections through `/memories note`. The generation flow returns to the agent as text and is never installed automatically as a skill with execution permission.
+
+## Configuration and cost
+
+A source install overrides the existing plugin configuration in `config/harness.local.yml`; a released package can override the same entry ID through a DSH profile overlay:
+
+```yaml
+- id: dscode-memory
+  config:
+    generate: true
+    use: true
+    minIdleHours: 6
+    maxAgeDays: 30
+    maxPerRun: 16
+    maxCandidates: 32
+    maxUnusedDays: 30
+    extractEffort: low
+    consolidationEffort: high
+    timeoutMs: 90000
+    # optional, and both are required together; otherwise the triggering session's provider/model is used.
+    # provider: deepseek-official
+    # model: deepseek-flash
+```
+
+Extraction and consolidation efforts are set independently, and neither inherits ultra. Each run does at most 16 per-session requests and 1 consolidation request, executed in order; input and output are both length-bounded, and a single model request has a 90-second default timeout. A missing usable provider, an unsupported configured effort or a network failure never affects the foreground; the background keeps the failure state and retries.
+
+Background generation incurs extra API usage. `/memories` reports its aggregate
+usage, and the initiating session's cost ledger records each call with purpose
+`memory`. Automatic work belongs to the root session that scheduled it; manual
+`run` and `note` belong to their invoking session, even before its first model
+request. A run keeps that owner and model route through extraction and
+consolidation. Starting another session or closing the owner does not transfer
+in-flight costs. Periodic work uses the latest scheduled route and attributes a
+new run only when that remembered session is still live. A request arriving while
+the worker is busy updates the preference for a later run; it does not start a
+second worker or change the current run's attribution. These auxiliary requests
+do not carry the foreground session ID to the model provider.
+
+This is DSCODE's implementation of the two-stage architecture borrowed from Codex, not a line-by-line port: an input fingerprint replaces the Git diff, and a tool-free structured model request replaces the consolidation agent that can edit a directory. There is currently no Codex-style provider remaining-quota gate, and redaction covers only common secret formats; what reaches the model is filtered historical session content. Generation can be switched off globally while reading existing memory is kept.
+
+## Verification
+
+```sh
+node --test tests/memory.test.mjs
+node scripts/verify-memory.mjs
+```
+
+The first covers source filtering, evidence validation, the lease, backoff, clear races and the reading switch. The second loads a real Harness in a temporary profile and uses real JSONL storage plus the local deterministic LLM adapter to check the full two-stage flow and prompt injection. It does not reach a remote model and is not an acceptance of real-model extraction quality or billing.

package/docs/opencode-go.md

@@ -0,0 +1,61 @@
+# OpenCode Go
+
+DSCODE can run a session on an [OpenCode Go](https://opencode.ai/docs/go/) subscription: $10 a month for open coding models. You sign in with your OpenCode account; there is no API key to paste. The route is `opencode-go`, next to DeepSeek, OpenRouter and Grok.
+
+## Setting it up
+
+1. Enter `/opencode login`. DSCODE shows a code and opens the OpenCode console in your browser.
+2. Approve the code there. The page names the **OpenCode CLI**: DSCODE signs in through the OpenCode CLI's login client, so this is expected. The command answers at once and keeps waiting in the background for up to ten minutes; `/opencode` shows how it ended.
+3. Enter `/provider opencode-go`. `/model` picks among the Go models and `/effort` sets their reasoning.
+
+`/provider opencode-go` (or `/provider opencode`) before signing in, and `/login opencode-go`, point you to `/opencode login` instead of asking for a key.
+
+**Upgrading from 0.7.31**, which used a console API key: that key is no longer read. Run `/opencode login` once. The stored `OPENCODE_API_KEY` stays in `~/.dscode/credentials.yaml` unused until you remove it.
+
+## The account login
+
+```
+/opencode           status: who is signed in, or how the last attempt ended
+/opencode login     show a code, open the browser, and sign in in the background
+/opencode cancel    stop waiting for the current code
+/opencode logout    remove the login from this machine
+```
+
+- DSCODE keeps its own login, stored as `OPENCODE_OAUTH` in `~/.dscode/credentials.yaml`. It is separate from any `opencode auth login` on the same machine, and signing in or out of one does not affect the other.
+- The login picks the first organisation (by name) with a Go subscription. Requests go to the inference endpoint the OpenCode console names for that organisation. The public `zen/go/v1` endpoint accepts only console API keys, not the login.
+- The access token lasts 30 days and renews itself before it expires. Each renewal replaces the refresh token, and the new one is written back at once. Several DSCODE sessions share the login: when one has renewed first, the others pick up its token instead of failing.
+- If the login is revoked or cannot be renewed, requests fail with a message asking for `/opencode login` again.
+- `/opencode logout` only removes the local copy. The token stays valid on OpenCode until it expires; revoke it in the OpenCode console to end it immediately.
+- The login client belongs to OpenCode, not DSCODE, so OpenCode can restrict it at any time. If it does, this route stops working until DSCODE supports another way in.
+
+## The models
+
+Go serves each model over the protocol of the lab that made it. This release speaks the OpenAI chat-completions protocol, which covers these models:
+
+| Family | Models | Reasoning efforts | Images |
+|---|---|---|---|
+| DeepSeek | `deepseek-v4-pro`, `deepseek-v4-flash`, `deepseek-v4.1-flash`, `deepseek-v4-flash-vision-exp` | high, max, Ultra | V4.1 Flash and Vision Exp |
+| GLM | `glm-5.3`, `glm-5.3-flash`, `glm-5.2`, `glm-5.1` | low, high, max, Ultra (thinking cannot be switched off) | `glm-5.3-flash` |
+| Kimi | `kimi-k3`, `kimi-k2.6` | off, low, high, max, Ultra | yes |
+| Kimi | `kimi-k2.7-code` | low, high, max, Ultra | yes |
+| MiMo | `mimo-v2.6-pro`, `mimo-v2.6-flash` | off, low, high | yes |
+| MiMo | `mimo-v2.5-pro`, `mimo-v2.5` | off, low, high, max, Ultra | `mimo-v2.5` |
+| LongCat | `longcat-2.0` | low, high, max, Ultra | no |
+| Hy | `hy4-preview`, `hy3` | off, low, high, max, Ultra | no |
+| Space Bunny | `space-bunny-free` | low, high, max, Ultra | yes |
+
+The default is `kimi-k3` at high effort. Switching from DeepSeek or OpenRouter lands on the same model when Go serves it, and keeps the effort when that model offers it.
+
+**Not yet available**: Qwen and MiniMax (Go serves them over the Anthropic messages protocol) and Grok, GPT Luna and Muse Spark (the OpenAI responses protocol). Naming one of them, for example with `dscode exec --model`, fails before any request with a message saying so.
+
+## What to know
+
+- **DeepSeek needs the Global region.** Go serves its DeepSeek models only to workspaces set to Global. Until then a request fails with "This Go model requires Global regions"; change it under your workspace's Privacy settings in the OpenCode console.
+- **Usage in the footer.** Go caps the subscription per rolling five hours, per week and per month. On this route the footer's money slot shows how much of each is used, read from the account's usage endpoint once a minute: `Go · 5h 12% · 7d 3% · 30d 1%`. An exhausted window is marked `!`, and the slot then says when requests work again (`limited until 09-25 14:45`). Before the first read, or if the usage cannot be read, it shows `Go` alone. There is no dollar cost: a subscription has no per-call price for DSCODE to add up.
+- **Limits are Go's.** A request past a cap fails with Go's own error.
+- **Web search** goes through [Exa](https://exa.ai)'s hosted search, as OpenCode's own client does, because Go has no search endpoint. It needs no key. Set `EXA_API_KEY` (in the environment or the credential store) to run the searches on your own Exa account. The keyless tier is Exa's free offer with no published limits, so a busy session can be rate-limited. Only Go sessions use Exa; the other routes search as before.
+- **Session identity.** Each request carries the session id in `x-opencode-session` and a `dscode/<version>` user agent, as Go asks of third-party clients.
+
+## Configuration
+
+The route's settings live in the `dscode-opencode-go` profile entry: `streamIdleTimeoutMs`, `maxRequestImageBytes` and `retryPolicy`. The endpoint is not a setting: the login names it.

package/docs/plugin-hub.md

@@ -0,0 +1,68 @@
+# Plugin Hub in Harness Desktop
+
+The DSCODE Desktop plugin includes **Settings → Plugin Hub**, backed by
+[DSH Plugin Hub](https://dshpluginhub.ai). It uses the same public catalog as
+the Hub website and CLI. No Hub login is required to browse.
+
+## Find and inspect plugins
+
+Enter a package name or describe a capability, optionally choose a category,
+and select **Search**. **Load more plugins** continues the current search.
+Open **View details** to read the description, repository, license, weekly
+downloads, publisher indicators, reported security checks and declared
+compatibility. The website link opens the corresponding Hub listing.
+
+Publisher verification and a passing scan do not guarantee safety. Missing,
+failed and incomplete scans remain visible. Compatibility declarations come
+from the catalog; the official installer also checks the actual package.
+
+In a DSCODE conversation, ask the agent to find a plugin. The read-only
+`plugin_hub_search` and `plugin_hub_info` tools use the same catalog and Desktop
+compatibility checks. These tools do not install plugins, change the Profile
+or expose account credentials. Catalog descriptions are third-party data.
+The native Standard preset does not receive these tools.
+
+## Install and enable
+
+1. Open the package details and choose **Review installation**.
+2. Review the exact npm package, version and registry returned by the official
+   plugin manager, alongside the Hub's scan and compatibility information.
+3. Choose **Confirm installation**. The official manager downloads the package
+   and dependencies. **Cancel installation** requests cancellation through that
+   manager; the displayed outcome determines whether it completed in time.
+4. Select **Manage installed plugin**, then enable and configure it in the
+   official **Settings → Plugins** page.
+
+Installation leaves the plugin disabled. Enabling third-party plugins runs
+their code in the Host. Build-script approvals, enable/disable, configuration
+and removal remain with the official plugin manager. When it reports a failure,
+cancellation, override or restart requirement, the Hub preserves that outcome.
+It does not report every completed package command as successful activation.
+
+An installation preview expires after five minutes. Reopen the preview if it
+expires. Closing and reopening the Hub page recovers the latest operation while
+the same Host remains running. After a Host restart, check **Plugins** before
+retrying; the Hub's operation history is not persisted.
+
+## Current boundaries
+
+- The first integration installs the catalog's latest exact npm version. It
+  checks DSH and Node ranges, platform, interface support, withdrawal and
+  deprecation. Git/tarball-only entries remain discoverable but are not installed
+  through this integration.
+- Already available bundles link to official management. This page does not
+  replace them, select older versions, check for updates or roll back a Profile.
+- Searches cover the community catalog, including packages for other Harness
+  interfaces. Details explain when a package does not fit this Desktop.
+- The DSCODE terminal package and Desktop package are separate entries. A
+  terminal-only package is not made Desktop-compatible by appearing in search.
+- Search queries and package lookups go to `api.dshpluginhub.ai`. Provider keys,
+  conversation text, workspace files and local credentials are not sent by this
+  catalog client. The agent may include task terms in a query you ask it to make.
+- The Desktop plugin is published as `@toddzheng024/dscode-desktop@0.7.34`
+  on npm, with the `preview` tag. Official Add plugin installation, Hub installation with
+  handoff to official management, and migration from the legacy probe name
+  have passed on macOS Desktop 0.2.0-rc.2.
+
+See [Desktop installation](browser-use.md#install-the-experimental-combined-desktop-package)
+and [distribution](hub-distribution.md) for package setup and release status.

package/docs/releases/0.2.0.md

@@ -0,0 +1,28 @@
+# DSCODE 0.2.0
+
+This update connects the TUI, CLI, scripts and other agents to one session runtime, and offers a clearer terminal status display.
+
+- Session communication: built-in `list_sessions`, `read_session`, `send_session` and `reply_session`; queue / steer / defer, a persisted mailbox, retry de-duplication, cancellation and a finite communication budget. Only a loaded root session in the same state directory is reachable, and an offline session is never started automatically.
+- Descriptive cards: project, workspace and recent user topics; task conclusions are never recorded.
+- Global memory: background extraction, consolidation and retrieval with source tracking, plus global and per-session switches. Background extraction causes extra model calls; see the memory documentation.
+- Input and resume: `!` shell, Shift+Enter newline, `dscode resume`, a resume hint on exit, and CJK input cursor positioning.
+- TUI: a compact header, a unified run status, a sub-agent activity overview and de-emphasised cost/context/cache figures; thinking and tool-call history are hidden by default.
+- Ultra: keeps native max reasoning and delegates as the task needs; a parent agent can choose a separate effort for each child.
+- Compatibility: the recommended Harness composition is pinned; the npm launcher only prints a warning for another composition and keeps starting.
+
+## Install and upgrade
+
+```sh
+npm install -g @toddzheng024/dscode@0.2.0
+dscode
+```
+
+A user who already has an npm/Hub profile has to run `dscode update 0.2.0` separately. Exit running processes before upgrading; `dscode history` and `dscode rollback` manage profile revisions. A program rollback is not a data-format rollback.
+
+The recommended Harness is still `0.1.5-rc.1` and the upstream TUI is `dsh-code@1.0.6`. macOS 14+, Node 22.19+ (22.x) or 24+ are supported.
+
+## Verification scope
+
+70 regression tests; the real Ink dark and light themes rendered at 32/48/80/120 columns; an isolated TUI launch, CJK text and Shift+Enter; the native session write lock, reads and crash recovery. Before release, a temporary install of the npm tarball separately verified the agent, session communication, cards, memory, a failed upgrade and rollback.
+
+The model integration checks use a deterministic local adapter. Remote model quality, the human experience of the system input-method candidate window, and real browser and desktop control are outside this verification scope. A claimed message cannot be guaranteed recalled.

package/docs/releases/0.3.0.md

@@ -0,0 +1,21 @@
+# DSCODE 0.3.0
+
+This release covers the login, terminal interaction and runtime improvements made after 0.2.0.
+
+- `/login` saves a local DeepSeek key through a hidden input, loads it at startup and can reload it for the current session; an environment variable takes precedence.
+- A horizontal effort bar with the Ultra animation, and a welcome box showing the version, model and project path.
+- The composer is pinned to the bottom of the terminal and a long conversation uses an in-screen viewport; the full content stays viewable and exportable.
+- A blank launch shows the composer first, and Chrome MCP connects when an agent session is created.
+- Fixed `apply_patch` path handling inside a Git subdirectory.
+- Hardened the startup and version-management locks and session message handling, and added the compaction evaluation tooling and an isolated test flow.
+
+Upgrade:
+
+```sh
+npm install -g @toddzheng024/dscode@0.3.0
+dscode update 0.3.0
+```
+
+Release verification covers local deterministic tests, TUI rendering, packaging and the Hub install lifecycle. A real remote model, a browser and desktop control are not part of this release's acceptance; the CJK candidate-window position still needs confirmation in the user's terminal.
+
+Known display issue: the welcome box may still show `v0.2.0`, because the build reused the already-patched welcome component. The installed version is authoritative through `dscode --version` and `dscode doctor`; both the npm package and the Hub profile here are `0.3.0`.

package/docs/releases/0.4.0.md

@@ -0,0 +1,20 @@
+# DSCODE 0.4.0
+
+Adds the Agent email system, which lets email add context to the current coding task.
+
+- `/email` shows the local inbox shared by all sessions, ordered by update time, with CJK previews and narrow-window support.
+- A Gmail app password connects IMAP and receives new mail whose subject starts with `[ToAgent]` after the first connection; an optional OAuth interface is retained.
+- Pressing Enter on a selected message injects it into the current session whether it is idle or running. The JSON structure states explicitly that the user chose it and that it is supplementary context only.
+- `send_email` sends plain text through Gmail SMTP, adds `[ToAgent]` automatically, reuses the existing approval and local credentials, and records the send result to prevent a duplicate send.
+- Contact aliases are shared across sessions and can be managed by the agent or by `dscode email alias`; the approval shows the real address.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.4.0
+dscode update 0.4.0
+```
+
+Inside `/email`, press `i` to configure the Gmail address and app password. Details are in [Email](../email.md). The mailbox and contacts are stored in `~/.dscode/email` and are never put into a release package.
+
+Verification covers deterministic tests, the real local TLS IMAP/SMTP protocol, the TUI and the package install lifecycle. No mail was sent through a real Gmail account; an SMTP accepted means the server accepted it and does not guarantee the recipient received or read it. Sending currently supports only a Gmail app-password connection, with no attachments and no automatic replies.

package/docs/releases/0.5.0.md

@@ -0,0 +1,19 @@
+# DSCODE 0.5.0
+
+This release focuses on the coding agent's collaboration boundaries, code review and terminal interaction.
+
+- The Ultra main agent can choose `worktree: true` in `subagent` or `subagent_fork`, so a child agent that needs to edit independently starts an isolated checkout from a clean Git `HEAD`. Sharing the directory remains the default; an isolated launch is refused while the main directory has uncommitted changes. A child agent never delegates to another child agent.
+- `/review` and the agent's `review` tool start an independent, read-only model review of a named Git diff. After a code change passes its relevant checks the agent reviews once before ending and fixes concrete findings first. The staging area, a base branch, a single commit and a path range are optional; a repeated review of the same diff reuses its result.
+- The TUI supports scrolling up through history. The first Ctrl+C during a run interrupts the agent immediately, and a second exits; a long paste collapses to a marker in the composer and expands fully in the conversation after submitting. A pasted image shows a marker such as `[Image 1]`, and several images are supported. A user message is presented with its own background, and turns are separated by a divider.
+- An ordinary DeepSeek Flash agent request gets short task-proportional guidance: answer a simple question directly, and for a bounded code change finish the relevant checks and stop. Low, high and max reasoning do not start a child agent; only Ultra can start or wake one.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.5.0
+dscode update 0.5.0
+```
+
+`dscode-0.5.0.tar.gz` can also be downloaded from GitHub Releases to install the standalone source package. The two installation forms use different data directories and never migrate sessions or credentials automatically.
+
+Verification covers unit, integration, TUI, package build, a real local Harness launch and Hub install/rollback. No paid model is called; review quality and image clipboard compatibility across terminals still need testing in real use.

package/docs/releases/0.6.0.md

@@ -0,0 +1,20 @@
+# DSCODE 0.6.0
+
+This release focuses on unattended runs, a readable identity for child agents, and the release experience.
+
+- `dscode exec "prompt"` runs a complete dscode agent turn without opening the TUI: the same preset, tools, skills, MCP and memory. The reply streams to stdout, tool activity and the session id go to stderr, and the exit code reflects the turn's result. It supports a stdin prompt, `--json`, `--resume`, `--effort`, `--model`, `--permission`, `--approve-all` and `--timeout`. An approval request that would fall back to a human is denied by default when nobody is present.
+- A parent agent must name every child agent (1 to 10 characters of letters, digits or underscores, starting and ending with a letter). A child agent shows as `/name · description` in the agents line and `/agents`; `send_message` and `interrupt_agent` accept `/name`, a child refers to its parent as `/`, and live children of one parent cannot share a name.
+- The welcome box became a three-shade pixel snowflake, 24×24 on terminals of 26 rows or more and 22×22 on 24 to 25 rows; while the agent works the bottom activity line is a snowflake orbit animation; the turn divider spans the full line.
+- Prompt tuning: the persona gained rules for reply language, the boundary between judging and asking, complete delivery and honest reporting; the shell policy keeps only a delegation summary and leaves the detail to the Ultra request policy; the email guidance no longer embeds real contacts.
+- The publish script can read a granular npm token from the macOS keychain and hand it to npm through a one-off temporary config, with no login and no one-time code; `npm run publish:token store|check|remove` manages that token.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.6.0
+dscode update 0.6.0
+```
+
+`dscode-0.6.0.tar.gz` can also be downloaded from GitHub Releases to install the standalone source package. The two installation forms use different data directories and never migrate sessions or credentials automatically.
+
+Verification covers unit, integration (including an end-to-end exec probe with a fake model), TUI, package build, a real local Harness launch and Hub install/rollback. `dscode exec` was only smoke-tested against a real model with a single sentence; child-agent naming survives only for display in an old session after a restart, and `/name` addressing needs a child created in the same process.

package/docs/releases/0.7.0.md

@@ -0,0 +1,22 @@
+# DSCODE 0.7.0
+
+This release focuses on the everyday feel inside the terminal: language, copying, a visible thinking process, accurate rates, and a steadier review.
+
+- `/language` switches the interface language: English (default), Simplified Chinese, Traditional Chinese, Japanese, Korean, Spanish. With no argument it opens an up/down selection panel, and with an argument it sets the language directly, accepting codes, names and common aliases. The choice is saved in `~/.dsh/dsh-code/language.json`, and `DSCODE_LANGUAGE` overrides it temporarily. The activity line, the agents line, welcome-box labels, footer telemetry labels, the composer placeholder, the various hints and the doctor report are all translated with it.
+- Mouse capture is off by default, so the terminal can drag-select and copy directly and PageUp/PageDown scrolls the conversation; `/mouse` turns wheel scrolling on, with the choice saved on this machine.
+- `/verbose` (or Ctrl/Alt+R) shows each step's `· Thinking:`, `· Tool Call:` and `Output:` in a dim colour with a blank line between blocks; thinking shows at most 8 lines and hints at Ctrl+O for the full history; the switch is saved on this machine.
+- While the agent works the conversation area no longer reserves a fixed third for history: the live content takes only the lines it actually needs and history gets the rest. The busy line is a two-dot comet orbiting a snowflake that breathes with the orbit; the welcome box's pixel snowflake has an inward-to-outward ripple, following the `/animation` setting.
+- The footer's `current` is computed from the generation time the window actually covers, so the first second after a tool call is a real rate, and it is calibrated with the exact outputTokens from each settled request; `average` became output tokens / total LLM call time, excluding tool execution and idle time. TPS colouring recognises labels in any language.
+- The review tool returns `no_repository` in a non-Git workspace and no longer injects the review guidance; when a model finishes with a reason other than stop it retries once and then reports the provider's reason if it still fails; hitting the output ceiling returns partial rather than a failure, and the ceiling is raised to 8192; a review request no longer counts towards the live TPS.
+- Release chain: the dsh-hub CLI is upgraded to 0.3.0 and calls the Hub's sync interface before a profile publish to pull the npm package immediately; the npm publish token is stored in the keychain through `pbpaste | npm run publish:token store`.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.0
+dscode update 0.7.0
+```
+
+`dscode-0.7.0.tar.gz` can also be downloaded from GitHub Releases to install the standalone source package. The two installation forms use different data directories and never migrate sessions or credentials automatically.
+
+Verification covers unit, integration, TUI, package build, a real local Harness launch and Hub install/rollback. The interface translations were proofread by hand for English and Chinese; the other four languages have not been reviewed by native speakers.

package/docs/releases/0.7.1.md

@@ -0,0 +1,20 @@
+# DSCODE 0.7.1
+
+This release fixes TUI wheel scrolling and makes the scroll feel finer.
+
+- Fixed the wheel doing nothing: 0.7.0 disabled mouse capture by default, while the TUI redraws in place and clears the terminal scrollback, so with capture off the wheel produced no event and there was no terminal content to scroll; only `/mouse` turned it on. Capture is now on by default and the wheel works out of the box; `/mouse` can still turn it off to drag-select and copy directly.
+- One wheel notch now scrolls 1 line (was 3), and wheel events landing in the same 16ms frame are merged into one redraw: a continuous trackpad slide is smoother and fast scrolling no longer drops events.
+- The wheel listener registers once and reads the latest state through a ref, cutting the re-render cost per event; PageUp/PageDown behaviour is unchanged.
+- The `/mouse` hint now prefers Shift (in terminals such as Ghostty, Shift-drag is the local selection by default), with Option for iTerm2 and Fn for Terminal.
+- A bundle that already carries the old patch upgrades in place to the new implementation. The README became English-first with `README.zh-CN.md` retained, and `docs/CHANGELOG.md` was added to record the release history from 0.1.0.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.1
+dscode update 0.7.1
+```
+
+`dscode-0.7.1.tar.gz` can also be downloaded from GitHub Releases to install the standalone source package. The two installation forms use different data directories and never migrate sessions or credentials automatically.
+
+Verification covers unit, integration, TUI, package build, a real local Harness launch and Hub install/rollback. The TUI end-to-end verification gained assertions for "one wheel notch moves one line" and "three scrolls in the same frame move three lines".

package/docs/releases/0.7.10.md

@@ -0,0 +1,10 @@
+# DSCODE 0.7.10
+
+This release fixes the version printed by `dscode --version` on tar and source installations.
+
+- `dscode --version` (and `-v`) now prints DSCODE's own version number. These two flags used to be passed through to the DSH CLI, printing the runtime version `0.1.5-rc.1` instead, which has nothing to do with this version number and easily misleads troubleshooting. The npm/Hub launcher already printed the launcher version correctly.
+- The README's command examples gained `dscode --version` along the way.
+
+This release does not upgrade the upstream DSH dependencies and does not change install or upgrade behaviour.
+
+Verification: `npm run check` passes (244 unit tests, 44 evaluation tests; integration, the real Ink UI and the package checks pass).

package/docs/releases/0.7.11.md

@@ -0,0 +1,17 @@
+# DSCODE 0.7.11
+
+This release moves the built-in TUI from `dsh-code` 1.0.6 to **1.2.0** and ships several earlier changes with it.
+
+- **TUI moved to dsh-code 1.2.0**: all 25 DSCODE patches were re-aligned. This upstream version changed a great deal — the local command catalogue moved to i18n `descriptionKey`, the `Header` component was rewritten, the input layer was restructured, and `/language` and `/review` became upstream features. Our approach: inject a fallback branch into upstream's `t()` for the catalogue (without changing upstream message tables, to avoid type conflicts when merging source later), and deliberately take over `/language` and `/review` as a whole.
+- **DSH pinned to `0.1.5-rc.2`**: the dependency graph and the runtime-patch gate moved together, and all 9 runtime patches were re-verified against rc.2 (including the macOS stdin probe).
+- **`dscode update` upgrades the whole installation in one step**: the npm/Hub path replaces the launcher itself with npm first and then upgrades the profile; the tar path downloads the release tarball, verifies its sha256, swaps the directory in place and migrates `.runtime`/`.env`/the local config; a source checkout refuses and asks for a git pull. There is also an in-TUI `/update`: a detached helper completes the upgrade after you exit.
+- **Startup version check**: the TUI reads the npm registry once at startup (8-second timeout, silent on failure) and suggests `/update` when there is a newer version; `DSCODE_UPDATE_CHECK=off` disables it.
+- **Update notices in seven languages** (en/zh-CN/zh-TW/ja/ko/es): the startup notice uses the TUI language runtime and `/update` follows the saved language.
+- **`/model` lists only the current provider's models, sorted alphabetically by display name** (numbers in natural order, GLM 5.2 before 5.3); the search only filters rows, never reorders them.
+- **Code review is more reliable**: the output budget went from 8k to 32k (reasoning tokens included), and an attempt that burns the budget without writing a report is retried with a doubled budget up to 64k; it starts at the lowest reasoning level the model supports; `DSCODE_REVIEW_MODEL=provider/model` and `DSCODE_REVIEW_EFFORT=<level>` are supported (aligned with Codex's `review_model`); a failure carries each attempt's budget and usage diagnostics.
+- **Error display**: an unexpected stop the user did not cancel (a hook block, a restart interruption, blocked) now uses the error colour instead of a dim turn marker.
+- **New tooling**: `npm run probe:tui [directory]` quantifies the blast radius of the TUI patches in 30 seconds before an upgrade (this migration was driven by it).
+
+This release upgrades no external dependency other than DSH (`@anionex/dsh-computer-use`, `chrome-devtools-mcp` and `node-addon-system` are already at their latest versions).
+
+Verification: `npm run check` passes (258 unit tests, 44 evaluation tests; lint, dependency integration, 4 real Ink UI verifications — TUI rendering/scrollback replay/effort bar/model search — and the package checks all pass). During the migration three classes of verification problem caused by upstream behaviour changes were found and fixed: `time-context` injection, the new `view.pending` field, and the new `recordHistory` prop.

package/docs/releases/0.7.12.md

@@ -0,0 +1,11 @@
+# DSCODE 0.7.12
+
+This release turns `!cmd` shell mode into a real mode (rounded border, `!` flush left, Esc to leave, with the command and its redacted output returning to the agent context), moves the submit default back to steer, and fixes two problems: "the composer drifting up and down on every loop" and "cache hit always showing --".
+
+- Shell mode: when the draft starts with `!` the composer switches to a brand-coloured rounded border (outline only, no fill), `!` sits flush left, and Esc leaves the mode while keeping the command text; outside the box a new `! shell mode · esc exits` hint appears (in 6 languages). After `!cmd` runs, the command and its redacted output return to the agent as context.
+- Submit mode is steer again: submitting while a turn runs inserts into the current turn, and while idle it sends normally; Tab now switches to queue (dsh-code 1.2.0 changed the default to queue).
+- Frame geometry: Ink's frame redraw is anchored to the bottom — when the live area shrinks, the freed lines stay as blank space above instead of being reclaimed, the redraw block height only grows, and the composer is only pushed down by new output; the persistent activity line and the compaction panel also count against the live-area budget, so the frame cannot reach the terminal height (where Ink clears the screen every frame and wipes the scrollback). `scripts/verify-tui-scroll.mjs` (an ANSI screen simulation) was added as a regression test.
+- Cache-hit telemetry is no longer wiped by "an auxiliary call with no usage" (memory, review, an interrupted timeout stream): a missing usage is recorded as unaccounted and only a malformed usage counts as unknown. Of 1707 `end` rows in the local ledger, 49 had no usage, and after the fix that session shows 98.4%.
+- IME cursor following is delegated to dsh-code 1.2.0's native anchor (the previous three-line drift is gone); the footer's cache figure is kept from 80 columns (it used to need 130).
+
+Verification: `npm run check` passes (258 unit tests, 44 evaluation tests; integration, the real Ink UI (6 probes, including the new scroll regression) and the package checks pass).

package/docs/releases/0.7.13.md

@@ -0,0 +1,12 @@
+# DSCODE 0.7.13
+
+This release replaces "text-patching upstream build output" with **vendor takeover**: `packages/tui` carries `dsh-code` 1.2.0's TypeScript source directly, and all 27 DSCODE changes live as source rather than patch text; it also fixes three problems: the extra exclamation mark in shell mode, the footer width counting a variation selector as a column, and the SQLite experimental notice printed at startup.
+
+- **Vendor takeover**: the upstream source lives in `packages/tui` (61 files under `src`), the repository root depends on it through `file:packages/tui`, and `node_modules/dsh-code` is only a symlink, so an everyday change needs **no build** and takes effect immediately. The 27 patch scripts, 6 UI verification scripts and `probe:tui` all retired, taking `scripts/patch-*.mjs` from 32 down to 6 (only the host-side runtime/Ink/stdin/compaction patches remain).
+- **The release shape became compiled**: Node refuses to strip types from a file under `node_modules`, so packaging uses `scripts/build-tui.mjs` to transpile `src` into `lib` file by file (no bundling, no minification), and both the npm bundle and the `.dshprofile` carry the compiled output; a repository checkout still runs the source directly.
+- **Shell mode hides the exclamation mark**: a `!cmd` draft already has the brand-coloured rounded border and the `! shell mode · esc exits` hint, so the editor no longer draws that routing prefix and the cursor moves one column left; submit routing, the paste-collapse marker, command completion and the line budget still read the real draft.
+- **Width fix**: `displayWidth` counted zero-width characters (combining marks, variation selectors) as one column, so `❄️` (U+2744 + U+FE0F) counted as 3 — the footer's provider budget therefore swung by one column with DeepSeek's peak/off-peak periods, and that assertion failed at random off-peak. Zero-width characters now count 0, and the footer budget no longer swings with the period.
+- **Quiet startup**: every DSH child the harness starts now carries `--disable-warning=ExperimentalWarning` (prepended ahead of the node arguments the caller passes), so the `node:sqlite` experimental notice is no longer printed at startup; the `exec` path no longer passes the same flag twice.
+- **Test infrastructure**: the test fixture now symlinks `node_modules/dsh-code` to `packages/tui` (matching the repository and the resolution path of a real run), where the integration suite had been failing entirely because of the type-stripping restriction; the coverage inventory excludes `packages/tui/lib`, the compiled output, taking the first-party inventory back to 8,094 lines.
+
+Verification: `npm run check` is green — 246 unit tests (82.98% first-party line coverage), 7 integration probes (session bridge, messaging, runtime foundations, session cards, memory, login runtime, exec), the package checks and 44 evaluation tests. Real-TTY interaction is still unverified (this environment has no pty, which is also why `EXEC_PROBE` skips the cases that block a terminal).

package/docs/releases/0.7.14.md

@@ -0,0 +1,11 @@
+# DSCODE 0.7.14
+
+This release connects the **Grok subscription** as a provider, turns automatic compaction into **pre-compaction** (at the threshold it no longer compacts on the spot but waits for a summary already running in the background), and fixes the code review **thinking budget**: the DeepSeek reviewer used to spend 25k–56k tokens of thought inside the 90-second deadline and write not one word of a report, so every review ended in a timeout.
+
+- **Grok subscription**: `grok` is connected as a subscription provider. The adapter only reads the `grok` CLI's login (`~/.grok/auth.json`, which DSCODE never writes back, so it cannot knock the CLI offline by racing its refresh-token rotation), talks to `api.x.ai/v1`, and supports structured tool calls and reasoning; the model list — context window, output limit and the `low/medium/high/xhigh` bands — comes from the CLI proxy's `/v1/models`. The footer shows the subscription allowance instead of cost: the used percentage of the weekly window from `/v1/billing?format=credits` plus the local reset time, and "no usage reported" rather than a made-up number when it is unavailable.
+- **Pre-compaction**: one band below the priced threshold (70% of the default 80% threshold) a background thread summarises the oldest compactable region first, **without touching disk and without a lock**; when the threshold is really reached it opens `compaction/start` and reuses that summary to commit, so the wait at the threshold is "waiting for something already running", and content added between 70% and 80% **stays verbatim after the checkpoint** instead of being folded into the summary. A summary invalidated by a manual compaction or a surface rewrite is dropped silently and the step summarises again.
+- **Agent-line timestamps**: a tool card, folded thinking and a reply each start with the local `HH:MM:SS` of that line's event in a dim colour, with the block wrapping to the remaining columns.
+- **Code review turns thinking off**: a review now requests `off` by default (the only band that really disables thinking). `minimal` used to land on `low` for DeepSeek, which is still a thinking mode, measuring 24k–56k reasoning tokens per call and almost certainly being cut off by the 90-second deadline; with it off the output is just the report. A model without an `off` band keeps its own default, and `DSCODE_REVIEW_EFFORT` can still override.
+- **Fixes**: the `credentials` provider is mounted again in a source checkout (upstream matches the row by `name` while the patch only changed the config key, so it had only worked in the npm bundle); the composer no longer floats up after a `<Static>` flush; a running shell command keeps its own output window and poll no longer overwrites accumulated text with the current viewport (another session or a background task in the same terminal can no longer make it report "beginning dropped" wrongly).
+
+Verification: `npm run check` is green — 262 unit tests (7,595/9,257 first-party lines, 82.05%), the integration probes (session bridge, messaging, runtime foundations, session cards, memory, login runtime, exec), the package checks and 46 evaluation tests; this environment cannot allocate a PTY, so the case that blocks a terminal in the exec probe is skipped by the existing convention. Whether the code-review change takes effect is **not confirmed on a real machine**: this session's process had loaded the old plugin module before the file changed, so `review` still ended in a 90-second timeout; the new code was verified offline to resolve to `off` on the real DeepSeek adapter (→ wire `thinking: disabled`), and on the same route a forced-disabled `session-title` call history shows 28/30 calls with 0 reasoning tokens.

package/docs/releases/0.7.15.md

@@ -0,0 +1,11 @@
+# DSCODE 0.7.15
+
+This release really connects project-level extensions: hooks merge in layers from the project directory, skills and `AGENTS.md`/`CLAUDE.md` can come from directories above the project root; it also stops mounting Chrome MCP by default and lets TypeSafe Jev replace one model call in automatic permission review with one structured decision (including automatic denial).
+
+- **Jev review (new)**: with `dscode-jev` mounted, automatic review first asks Jev (OpenRouter's alpha Decisions endpoint `POST /api/alpha/decisions`) four typed questions — `allow`/`ask`/`deny` with per-option probabilities, whether the retained instructions clearly authorise this action, how hard it is to roll back if it goes wrong, and whether credentials are involved — then decides in code against asymmetric thresholds: an allow requires a high-confidence allow with no credential or hard-to-undo signal; a denial takes effect when "confidence and `P(deny)` are both high" or "confidence is a little lower but the risk score corroborates and is over the line", and an authorisation veto (`authorized ≥ 0.6`) turns it into a hand-to-human. When Jev is unconfigured, disabled, times out or errors it returns "no verdict" and automatic review falls back to the original reviewer model, behaving as before. The decision signals (`choice`/`confidence`/`denyProbability`/`authorized`/`destructive`/`credentialRisk`) are written to `.runtime/auto-review/*.jsonl` for later threshold tuning.
+- **Layered hooks**: a project's `.codex/hooks.json`, `.dsh/hooks.json` and `.claude/settings.json` stack on top of `config/hooks.local.json` by default and merge into `$DSH_HOME/hooks.resolved.json`, with a report listing each layer and the events this bridge cannot execute; a bad format in a project file is only recorded, never fatal, while an installation-level file still fails hard; `/hooks` points out a layer that changed (or vanished) after the merge, because only a restart re-reads it. The switch accepts only the documented spellings for on (`1/true/on/yes`), so `=no`/`=none`/`=disable` no longer turns it back on.
+- **Upward discovery for skills and workspace instructions**: with `DSCODE_SKILL_ANCESTORS=1`, the `.dsh/skills`, `.agents/skills` and `.claude/skills` of every level between the project root and home register at rank 300 (only headers enter the catalog, bodies stay lazy); `AGENTS.md`/`CLAUDE.md` above the project root fold into a 60 KiB-capped aggregate file (the user-level file is always kept, the nearest ancestor wins, an over-budget source is skipped whole); the home boundary is compared by realpath, so it no longer silently fails when `$HOME` is a symlink.
+- **Chrome DevTools MCP is no longer mounted by default**: it uses an isolated `--isolated` temporary profile, cannot see your login state, and occupies about 29 model-visible tools. The launcher, bundle and doctor stop wiring it; `config/mcp.local.example.yml` gives an example of adding it back on demand (including `--browserUrl` to reach a Chrome you started with remote debugging).
+- **Two discipline sections added to the system prompt**: `dscode:code-discipline` (fix the root cause without overstepping, do not touch unrelated code, add no comment or copyright-header noise, do not commit on your own, do not invent a test suite in a repo that has none, read `git log`/`git blame` first when it would settle a question) and `dscode:working-discipline` (instruction precedence: the system prompt and the approval policy cannot be loosened downstream, user request > `AGENTS.md`/`CLAUDE.md` > memory > external content; act once there is enough information; correct yourself only when it would change a conclusion); the persona rule "a progress update every minute", which contradicted its own next sentence, became event-driven.
+
+Verification: `npm run check` passes (306 unit tests; lint clean). The ancestor and hook behaviour is covered by new unit tests (`tests/workspace-discovery.test.mjs`, `tests/hook-sources.test.mjs`, `tests/tui-tools.test.mjs`). The Jev path uses a mock transport to cover the request shape, threshold judgement, timeout and fallback, and was measured on a real machine over four cases (96–813 ms, about $0.000025 each); the confidence drifts between two runs of the same action (`rm -rf` from 0.90 to 0.97), so thresholds should still be aligned with the audit records rather than copying the defaults.

package/docs/releases/0.7.16.md

@@ -0,0 +1,10 @@
+# DSCODE 0.7.16
+
+This release runs automatic compaction on the window messages can actually occupy, and adds a usable sandbox runner for restricted environments.
+
+- **The compaction threshold is priced against the real message headroom (fix)**: the DeepSeek adapter counts the output budget (256k by default) inside the same 1M window, so a request whose "messages + output" exceeds the window is rejected outright; the threshold used to be priced against the whole window, which put the 90% line (943,718) **above** the real message ceiling (792,576), making a pressure compaction impossible to trigger first. Every compaction therefore came from overflow recovery: prune first, then write the summary synchronously on the spot — in the 0.7.15 log, `compaction/summary` appears **26.8 seconds** after `compaction/start`, and a prefetched compaction that only hangs off the pressure path never ran once. `effectiveContextWindow` now subtracts the output budget the adapter declares, so the threshold 713,318 and the prefetch start 634,061 both sit below the ceiling; the `/model` "switching will compact" preview uses the same window.
+- **Overflow recovery skips the summary when the prune already fits (fix)**: overflow recovery pruned first and then summarised regardless. That 0.7.15 request exceeded the limit by only 125 tokens while the prune freed 87,018, so the summary was pure waste. After pruning it now re-checks with `fitsInWindow` (messages + output budget ≤ window): when it fits, it returns so the caller retries (the prune itself replaced the surface with `surfaceOp: replace`, so the retry condition holds), and only compacts when it does not; and a skip is allowed **only when a surface replacement really happened**, or the caller would not retry and the original error would be thrown at the user.
+- **Sandbox runner (new, enabled by hand)**: `plugins/tui-tools/sandbox-runner.mjs` adds one `(allow file-write* (literal "/dev/ptmx"))` to the existing write policy — without it a confined command cannot allocate a PTY (`posix_openpt: Operation not permitted`), breaking a nested harness, tmux, expect and node-pty tests; inside an already confined process it **inherits** the outer profile instead of nesting another. Copy `config/harness.local.example.yml` to `config/harness.local.yml` to enable it, after which `npm run doctor`, `make release`, and "open another dscode inside a dscode session" all work.
+- **The runner's notices are no longer mistaken for a failure (fix)**: the provider judges "non-zero exit + stderr matching `runnerFailureSignatures`" as a sandbox failure. The runner printed notices such as "inheriting the outer profile" with the same prefix, so inside a nested session any failing command was reported as a broken sandbox. A real failure now goes through `fatal:` and a notice through `notice:`, and the signatures in the example config match only the former.
+
+Verification: `npm run check` passes (lint clean, all 315 unit tests green). The compaction fixes come with real contract tests — calling the DeepSeek adapter's `modelInfoFor` directly to confirm `defaultMaxTokens` is a top-level field and `effectiveContextWindow` yields 792,576 — plus engine-level regressions: the pressure path really triggers with an output budget; a prune that fits skips the summary while an unreplaced surface does not skip it; and the upgrade path is covered for pristine / v1-only / v2-only old engine states. The sandbox runner's apply path is covered by a shim that records the profile, and the inheritance path was measured on a real machine.

package/docs/releases/0.7.17.md

@@ -0,0 +1,12 @@
+# DSCODE 0.7.17
+
+This release replaces the compaction engine's "build-time rewrite of upstream source" with a "subclass override", restores all six languages in `/language`, and re-aims the compaction evaluation at the production engine.
+
+- **The compaction engine became a subclass override (refactor, behaviour unchanged)**: automatic compaction used to be written into `@deepseek-ai/dsh-compaction-basic`'s source by four `replaceOnce` patches, which could break on any upstream upgrade. The policy now lives in our own `plugins/compaction/engine.mjs`: `DscodeCompactionEngine` extends the upstream engine and overrides only `compactIfNeeded` (threshold pricing, completion budget, prefetch, prune-on-overflow first) and `summarize` (the injection point for a prefetched summary); the durable transaction, the `compaction/start|end` markers and the stability check stay with upstream `compactRegion`. Distribution no longer vendors that package, and nothing rewrites its source at install time.
+- **`/language` regained all six languages (fix)**: after our own terminal took over, `/language` fell back to the upstream implementation with only en/zh, while DSCODE's own message tables had always supported `en`, `zh-CN`, `zh-TW`, `ja`, `ko` and `es` — yet the panel listed two entries and `/language ja` was silently stored as English. The list, the argument parsing and the `language.json` persistence now all follow `plugins/i18n`: `zh`, `jp` and `繁體中文` resolve through the alias table, and a stored `zh` upgrades to `zh-CN`. The terminal's own skeleton copy still has only English and Simplified Chinese, so under another language the skeleton is English and DSCODE's own copy uses the chosen language — exactly the semantics `/language` always promised.
+- **The compaction evaluation re-aimed at the production engine (fix)**: after the subclassing the evaluation harness still mounted the unpatched upstream engine, which meant it no longer tested the production configuration; it now mounts `DscodeCompactionEngine` and records the engine source hash, and the judge model is decoupled from the model under test.
+- **The evaluation window on OpenRouter routes (fix)**: `OpenRouterAdapter` reported the 1M window from the live listing, lifting the threshold above any replayed history so compaction never triggered; a new window wrapper reports the window the harness actually executes with.
+- **Judge parsing tolerance (fix)**: if the judge wrote one sentence before the JSON object or wrapped it in a fence, a whole batch of verdicts was recorded as "unscored", failing the calibration (10/14, 6/14 and 4/14 across three models). The parser now extracts the outermost object, and the calibration passes 14/14.
+- **A prefetch wait no longer swallows the compaction indicator (fix)**: submitting a compaction while a prefetch was still running used to wait for the summary before entering the transaction, and the TUI showed no compaction indicator during that wait. The wait now happens after the transaction's open marker, so the indicator shows as usual; a failed prefetch or a rewritten span falls back to a just-in-time summary instead of failing the transaction.
+
+Verification: `npm run check` passes (lint clean; unit, integration, packaging and evaluation all green). The evaluation fixes come with real contract tests — the harness mounts the production engine, the evaluation window follows what the harness executes, and the judge parsing tolerates noise — plus engine-level regressions: threshold pricing and the completion budget still apply on the pressure path, an overflow the prune already covers skips the summary, and a prefetch commits after the marker opens and falls back when rewritten. The `/language` side gained terminal assertions: the six-language list matches DSCODE's message table item by item, alias resolution works, an old `zh` normalises to `zh-CN`, and the skeleton copy falls back to English under the other languages.

package/docs/releases/0.7.18.md

@@ -0,0 +1,13 @@
+# DSCODE 0.7.18
+
+This release adds three things that let the compaction evaluation guide decisions — deterministic context fidelity, a pre-screen of discriminating cases, and separating a format failure from a model failure — and completes the first summary A/B.
+
+- **Context fidelity (new, evaluation)**: on the context the model really saw, `retention` counts at token boundaries whether each probe's original sentence evidence (`evidence.quote`) and the words inside it are still present, writes it into `scores.jsonl`, and the report carries an `Evidence kept` column. It calls neither the model under test nor the judge, so it has no sampling variance and can be recorded on every run. On LongMemEval tier1 it explained the source of compaction loss directly: with the evidence sentence still present the pass rate is close to no compaction, while a sentence swallowed by the summary leaves only 4%–6% — and word-level retention is still 89%–92%: a summary keeps the words and loses the restatable fact.
+- **Pre-screen of discriminating cases (new, evaluation)**: `--baseline <run> [--baseline-policy full]` keeps only cases where that policy was fully correct in every repeat of the baseline run with no infrastructure error; the filtered dataset is written to the new run's `dataset.json` and `manifest.json`'s `selection` records the source and the counts. Of these 100 cases, 47 were selected, saving half the non-discriminating probes in later policy comparisons.
+- **A summary A/B without changing the product (new, evaluation)**: a policy may carry a `summaryInstruction`, which the evaluation-side `EvalCompactionEngine` inserts into the compaction request before the upstream summarisation instruction; without it the behaviour matches the product exactly. The first comparison (`compact-80` vs `compact-80-keepfacts`, 47 cases × 3 repeats) was a **negative result**: asking to "keep the quotable fact sentences" changed neither fidelity nor the pass rate (10 better, 11 worse) and cost slightly more. The conclusion and how to reproduce it are recorded in `eval/experiments/2026-09-longmemeval-tier1-summary-ab.md`.
+- **Probe protocol retry (fix, evaluation)**: when a reply is not a single valid JSON, or the stream is cut off before the JSON closes, it retries once with a corrective hint and records it in `answerRetries` (counting towards the call ceiling); a rejected reply never enters the session, so later checkpoints are unaffected. Another run had zero of these format errors (423 checkpoints), showing that the earlier 15 `invalid-answer-json` came from the backend and model snapshot of the time rather than a general runner defect.
+- **Word boundaries in evidence quoting (fix, evaluation)**: LongMemEval samples used to be hard-cut at 160 characters, leaving 87/100 evidence quotes split mid-word, which a token-boundary match then judged "not retained" (even without compaction only 55% survived). The cut is now at a word boundary, and after the fix the no-compaction policy is back to 100%; the corrected dataset is written to `eval/private/longmemeval/tier1-wordboundary.json` without overwriting the original file, and the hash check of historical runs stays valid.
+- **Prebuilt release packages (new)**: `dscode-<version>-darwin-arm64.tar.gz` and `-darwin-x64.tar.gz` are source trees with the locked `node_modules` already installed, and the `curl | sh` installer and `dscode update` prefer the one for the local platform, so installing and upgrading only reaches GitHub and needs neither npm nor the npm registry — a corporate registry proxy can no longer block `npm ci`. A platform without a prebuilt package falls back to the source tarball, and `DSCODE_INSTALL_SOURCE=1` forces the choice. `npm run dist` builds all three (`DSCODE_PREBUILT_ARCHS` can narrow or skip the prebuilt packages), and the release workflow and `make attach` upload them.
+- **The launching directory's `.env` no longer affects the launch (fix)**: upstream reads the launching directory's `.env` as a project layer, so a workspace file could inject variables into the agent process, and one of the names reserved for bootstrap (any `DSH_*`, `NODE_OPTIONS`, a CA path) would abort the launch with "only the launching environment may set". A pinned `dsh-app-boot` patch now drops that layer in a repository and a tar installation; the installation's own `.env` is still loaded by the launcher.
+
+Verification: `npm run check` passes (lint, coverage, integration, packaging and evaluation all green). The new evaluation tests cover token-boundary matching for fidelity and the evidence loss after compaction, the `--baseline` selection (including across repeats and with partial evidence), and that the protocol retry only changes the compaction request's prompt while a rejected reply never enters the session; the `summaryInstruction` test confirms it appears only in the compaction request.

package/docs/releases/0.7.19.md

@@ -0,0 +1,8 @@
+# DSCODE 0.7.19
+
+This release stops an escalation the user already asked for from interrupting a human every time — the second model in automatic review decides it instead; and it fixes the chain that made an agent calling a CLI with its own credentials look "not signed in".
+
+- **An authorised escalation goes to a deeper model review (change, automatic review)**: Jev has four guards on the allow direction — credential risk ≥ 0.5, hard to undo (`score ≥ 2`), a `choice` other than `allow`, and confidence < 0.85. They used to go to a human every time and **ignored whether the instructions had already authorised the action**: a build verification that has to leave the sandbox inside a "commit and release" task therefore prompted for approval every time. Now, as long as `authorized ≥ authorizedVeto`(0.6) — the retained instructions appear to ask for it — those four guards return `defer` instead, leaving it to the reviewer model that can see the full pending arguments and the instructions. Jev's scores are coarse by nature, and this deployment's policy already allows ordinary network access and lets a CLI use credentials it stored itself, so these guards should not veto on their own. **The deny direction is unchanged**: a decisive denial, and "the instructions appear to veto this denial", still work as before. A `defer` is never treated as an allow (`applyVerdict` only accepts an explicit `allow`), and a reviewer ruling of `human` still consults a human; one `defer` leaves two rows in the audit — Jev's verdict and risk scores, and the final ruling.
+- **Hub login aligned to the state directory (new, launcher)**: `dsh-hub login` writes `$DSH_HOME/.hub/auth.json`, but a user who logged in outside DSCODE wrote `~/.dsh/.hub/auth.json`. When DSH_HOME points elsewhere, the CLI inside the agent reports "Not signed in" — and at release time that is exactly the chain that sends people off to "export a token", which is then judged a credential risk and routed to a human again. The launcher now copies that login into this session's `$DSH_HOME` (when the target does not exist): the directory is normalised to `0700` and the file to `0600`, an existing copy always wins (a fresh token the CLI refreshed is never overwritten by the old file), and any read/write failure is ignored silently — a convenience copy must never make the launch fail. The copy lands in the state directory, which also lets the CLI refresh its own session without leaving the sandbox.
+
+Verification: `npm run check` passes (lint, coverage, integration, packaging and evaluation all green). New tests cover "the four guards return `defer` when authorized", "below `authorizedVeto` it is still `human`", "an authorised decisive denial still goes to a human", "a `defer` goes to the reviewer model and spends no human", "a reviewer ruling of `human` still finds the user", and for the credential alignment "no action without a login / copied once / an existing copy wins / a loose directory is tightened to 0700 / an unreadable source does not throw".