@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/docs/releases/0.7.2.md

@@ -0,0 +1,19 @@
+# DSCODE 0.7.2
+
+This release gives the terminal back to the user (wheel, drag-select and copy are all native again), turns the footer into two lines, and fixes a command that waits for terminal input hanging on macOS.
+
+- **The terminal owns scrolling and selection again**: the 0.7.x in-place full-screen viewport cleared the scrollback and had to capture the mouse to scroll the wheel. A finished transcript is now printed once into the terminal scrollback through Ink `Static`, so the wheel, drag-select and copy are native terminal behaviour, and `/mouse`, in-app PageUp/PageDown and the wheel queue were removed with it; the welcome box becomes the first scrollback line and scrolls away with the session, and each turn ends with a divider. **An installation still carrying the old in-place viewport must refresh its dependencies first (`npm ci`)**, because the launcher refuses to patch that text in place.
+- **A two-line footer**: the first line is `● <session title> ｜ <permission>` (falling back to `model ｜ effort` while the session has no title), with the statusline toggle hint still pinned to the right; the second line starts with `provider: model @ effort` followed by the telemetry — `current | average | context | $cost / $balance 🔥 | cache hit`. When the width runs out it drops average first, then cache hit, then current, then the model head degrades to a bare `model @ effort`, then context goes, and only then the model head itself: the money stays to the end. The cache-hit rate is coloured by band (<90 red, 90–95 yellow, 95–98 green, ≥98 blue), money always has two decimals without a `~`, and the footer follows `/language` too (it used to be pinned to English).
+- **A command waiting for terminal input no longer hangs for 300 seconds on macOS**: the fixed inspector now decides "waiting for input" by reading the process table (`ps`, throttled) — a shell terminal's process group has to be sleeping with frozen CPU time and holding no socket — and the persistent shell interrupts it after five silent seconds with the reason. Note: this fix applies to a **repository installation**; the npm/Hub bundle still installs the registry copy of the inspector, and moving the probe into the already-vendored `dsh-terminal-bash` is a follow-up.
+- Other changes: the footer shows the DeepSeek account balance (`$cost / $balance` plus peak 🔥 / off-peak ❄️), a sandbox escalation request can be self-reviewed by the agent against a deterministic diagnostic allowlist, each turn leaves a blank line, verbose restores streaming thinking output, and a GitHub Actions release pipeline (pushing a `v*` tag publishes bundle → Hub profile → launcher in order, and a manual dispatch can build only, verify credentials only, or dry-run).
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.2
+dscode update 0.7.2
+```
+
+The `dscode` profile on the Hub jumps straight from 0.7.0 to 0.7.2 — 0.7.1 only ever shipped an npm bundle, with no Hub release and no launcher, so `dscode update 0.7.1` does not exist. `dscode-0.7.2.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/failed upgrade/rollback. New here: rendering assertions for the two footer lines (what each band drops from 32 to 120 columns), the cache colouring, the three outcomes of the macOS probe, and the read-only credential check of the release pipeline.

package/docs/releases/0.7.20.md

@@ -0,0 +1,10 @@
+# DSCODE 0.7.20
+
+This release fixes a defect that made automatic review "look busy while judging blind": Jev had never seen the user's instructions.
+
+- **Jev cannot see the user instructions (fix, automatic review)**: `contextFor` handed the retained user instructions out as `{ seq, text }`, while `approvalState` read `message.content[].text` — so the `userInstructions` sent for judgement were **always an empty string**, and Jev saw only an isolated tool call each time. The symptom was `authorized` sitting at 0.04–0.07: a release you had explicitly asked for looked like "nobody ever asked" to it, so every one went to a human. It also made the "hand the risk guards to the reviewer model when authorized" introduced in 0.7.19 meaningless — the threshold is `authorized ≥ 0.6`, and the value never passed 0.07. The state construction now accepts three shapes: `{ text }`, a string `content`, and an array of content blocks; a string `content` no longer throws the `TypeError` that silently disabled Jev.
+- **`authorized` is scored independently (change, automatic review)**: the score now measures **only** whether the instructions cover this action, separately from risk — a dangerous action the instructions asked for should score high, and a dangerous action nobody asked for should score low. Instructions almost never name a concrete command, so the question asks about the thing they asked for and the scoring anchors are written into the question: ≥0.9 asks for that step directly, [0.6,0.9) a necessary step of a stated task, [0.2,0.6) possibly part of the task but optional or unclear, <0.2 not covered. The bands do not overlap, so one judgement cannot swing between "hand it to the model" and "stop it". At the same time "publish something" in `verdict.deny` was narrowed to "a publish the instructions did not ask for", so a release the user asked for is not counted as a denial reason.
+
+Calibration (2026-09-19, `typesafe/jev-1.13-20260917`, four real calls): a "commit and release" instruction plus running `make release` outside the sandbox → `authorized` 0.68, `defer`; the same instruction naming `make release` → 0.86, `defer`; the same instruction plus `rm -rf ~/Documents/notes` → 0.07, `deny`; "look at the test coverage" plus the same `make release` → 0.11, `human`. Before the fix the first scenario scored only 0.06, forcing a hand-to-human.
+
+Verification: `npm run check` passes (lint, coverage, integration, packaging and evaluation all green). The new regression assertions require "a `{ seq, text }` shape must produce instructions", "a string `content` does not throw" and "mixed shapes concatenate in order" — the original test used only a content-block array, which is why this defect went unnoticed.

package/docs/releases/0.7.21.md

@@ -0,0 +1,9 @@
+# DSCODE 0.7.21
+
+This release makes the footer geometry follow the terminal width alone, adds hidden clock marks for arriving messages and turn boundaries, and adds `/btw`: answer a question in a side conversation immediately, without merging the answer into the main line.
+
+- **Footer geometry no longer moves with the values (fix)**: the permission badge is anchored to the right edge of the first line, the `shift+tab` hint keeps its columns (reserved even while it is not shown during a run), and every live figure (turn/step counts, the various durations, tps, tokens, cache hit, context reading) is right-aligned inside its own fixed column, with an empty reading rendered as a `--` placeholder instead of the whole group disappearing. Previously any value change made the badge drift sideways (measured on one screen from column 75 to column 56) and a group appear or disappear with a threshold; now only the terminal width decides the degradation order. The tps/context/cache figures inside the telemetry run are fixed-width too, reserving those 6 columns for their slots, so the fixed width does not squeeze out a figure that used to fit; the money pair (cost/balance) stays unfixed — measured, reserving columns for a number that crosses a digit boundary only a few times per session squeezes out per-second tps at common widths.
+- **Hidden clock marks (new `dscode-time-marks` plugin)**: every claimed message and every just-closed turn gains one line in the model context: `Time mark: 2026-09-19T01:58:34-07:00[America/Los_Angeles] — steer relay from session:abc arrived, waited 6m24s (composed ...)`. It is plugin-sourced context that the terminal does not render at all (reusing the existing hide-by-producer rule) and it rewrites no message body; it is injected only when an arrival or a turn end really happened, so a pure tool loop pays nothing. A relay message's `source` now carries `label`/`mode`/`composedAt`, so the queueing time has evidence to report.
+- **`/btw` side question (new)**: `/btw <question>` immediately creates a child session that inherits the main session's history (seeded to the most recent completed turn; with a prefix over 400 events, or no completed turn yet, it degrades to a background summary of at most 1200 characters), runs with the `read-only` permission preset at the lowest available effort, and streams the answer into the `/btw` panel (`esc` closes it, `←/→` switches between several, and the oldest finished run retires automatically). The side session carries `parentSession` and `origin: subagent`, so it generates no session card and is a read-only row in the session list; **its content never enters the main transcript or the main model context**. The child session is released when you switch session or exit.
+
+Verification: `npm run lint` clean; `npm run test:unit` 351/351; `npm run test:package` and `npm run test:integration` (seven probes) pass. The new and extended tests cover: the segment columns and the badge column staying put across early and late values at one width, no overflow frame by frame from 36 to 240 columns, a larger telemetry number not moving later segments, the clock-mark seed degradation and brief budget, and `/btw` panel rendering with `esc` closing it. The `/btw` kernel path (really creating a child session and streaming into the panel) has no automated end-to-end case yet and relies on a real-machine check.

package/docs/releases/0.7.22.md

@@ -0,0 +1,11 @@
+# DSCODE 0.7.22
+
+This release moves the Hub client to `@dsh-plugin-hub/cli` 0.5.0 and makes a failed launcher command explain itself: the whole cause chain, the network causes to check on a managed network, and a way out of a leftover profile directory.
+
+- **Hub client 0.5.0 (change)**: the launcher's profile install now runs through Hub CLI 0.5.0 (`@dsh-plugin-hub/schemas` 0.5.0 as well). The pinned DSH runtime is prepared and verified by the Hub CLI itself — it runs an exact-version `npm install @deepseek-ai/dsh@<version>` into `$DSCODE_HOME/.hub/runtimes/<version>`, checks the package identity and that the executable really lives inside the package directory, and then launches it with the current Node — instead of the launcher's per-bundle `npm exec`/`npx` wrapper, so an install no longer pays a separate registry round trip for every bundle and the runtime is cached across installs. Where the behaviour stops: `pnpm` is still required for the profile's dependency install, which is why the launcher keeps its pinned `pnpm` 10.15.1 on `PATH`, and its `npx` shim stays as the guard for a Hub release that still spawns a pinned-DSH `npx` command. The command surface the launcher uses (`profile apply|upgrade|rollback|history|doctor`), the state layout (`.hub/installations/dscode/current.json`, schema version 2) and the `DSH_HUB_MACHINE` non-interactive behaviour are unchanged, so `dscode update`, `dscode rollback` and `dscode history` keep working against an existing installation. Also bumped: imapflow 2.0.2 → 2.0.5, mailparser 3.9.26 → 3.9.28, nodemailer 10.0.9 → 10.0.10, fflate 0.8.2 → 0.8.3, `@modelcontextprotocol/sdk` 1.29.0 → 1.30.0, yaml 2.8.1 → 2.9.1 and eslint 10.10 → 10.11.
+- **A failed command keeps its reason (fix)**: `dscode` printed `error.message` alone, so the real cause of a fetch, lock or spawn failure — which `Error.cause` carries — never reached the terminal, and a machine that cannot reach the Hub printed a bare `fetch failed`. The launcher now prints the whole chain (`reason <- cause (CODE)`), once: a Hub or profile step attaches its hints to the error and the top-level reporter prints the message and the hints together instead of each printing its own copy. Chains deeper than five links truncate with `…`, links without a message are skipped, and a chain with nothing in it reads `Unknown error`.
+- **Hub failures name the network causes (fix)**: when a Hub, update or install step fails, the launcher lists what to check on a managed network — the step needs `api.dshpluginhub.ai` and an npm registry; the Hub call does not use `HTTP(S)_PROXY`, because the pinned client calls plain `fetch` (15- and 30-second timeouts, no proxy agent); an internal mirror goes in `DSH_HUB_API_URL` inside `$DSCODE_HOME/.env`; a TLS-inspecting proxy needs its root CA in `NODE_EXTRA_CA_CERTS`; and the prebuilt GitHub release installs without the Hub at all. The `HTTP(S)_PROXY` line appears only when a proxy variable is set, and the value is never echoed, so a credential inside a proxy URL cannot leak into a terminal or a log.
+- **The install step says what it is doing (fix)**: first launch printed one line and then stayed silent while npm fetched the pinned runtime and the plugin tree, which reads as a hang on a slow registry. It now also states that the step downloads the pinned Harness runtime and plugins with npm and can take several minutes.
+- **A leftover profile no longer dead-ends (fix)**: when `profiles/dscode` exists without the Hub state file, every command — including `install` and `rollback` — refused with `Existing unmanaged/incomplete dscode profile; inspect <path>`, and the only way forward was knowing to delete the directory. The error now names the directory, states that the launcher will not replace it automatically, and prints the `mv` that moves it aside, with both paths single-quoted for the shell.
+
+Verification: `npm run lint` clean, `node scripts/check-docs.mjs` clean, `npm run test:unit` 357/357, and `npm run test:package` passes (exact tarball integrity, exports, syntax, launcher lock dependency, and no local state or build paths). `npm run verify:hub` against the rebuilt candidates reaches `PASS real Hub install + DSH compose` — a real Hub CLI 0.5.0 install of the profile plus the real DSH composition — and then stops at its agent-loop probe on this machine, because the session's own sandbox refuses to apply a nested profile (`sandbox-exec: sandbox_apply: Operation not permitted`), the documented in-session limitation; that probe therefore runs in CI. Three new unit cases cover the failure formatting (chain, truncation, empty chain), the unmanaged-profile message, and a profile path containing a quote that must stay one shell argument. The failure output on a real corporate network, and the Hub 0.5.0 upgrade path for an installation that already exists, have no automated end-to-end case and rely on the next real-machine install.

package/docs/releases/0.7.23.md

@@ -0,0 +1,14 @@
+# DSCODE 0.7.23
+
+This release pins a session to one folder, makes cross-session traffic visible in the terminal, closes the per-turn cost loop, and removes the per-frame re-wrap that streaming paid for the whole live region.
+
+- **A session stays in the folder it was created in (change)**: the workspace, the durable log and the shell already followed the session header's `cwd`; what was missing was the second half of the rule. Resuming a session now runs in that folder whichever entry point asked for it — `--resume`, the `/resume` picker, `/search`, or a queued switch — and a resume that leaves the folder the terminal was launched in prints one warning notice naming both folders, so a window that silently changed project is visible. `--continue` keeps its current-directory scope. Where the behaviour stops: the folder is chosen at creation and no command moves an existing session, so `--cwd` only decides where a *new* session binds; reaching another project's context still means reading that session (or `dscode send`), not resuming it here. `dscode exec --resume` is outside this display path: it writes the session's log in its own folder while the one-shot process keeps the directory it was launched in, so a turn that must touch that folder is run from it.
+- **Cross-session communication is visible (change)**: while a `send_session`/`reply_session` call is in flight the activity line reads `⇄ sending to <peer>`, a request awaiting its answer reads `⇄ waiting for <peer>`, and a settled send or an inbound relay prints one notice line. Both surfaces paint with the `steered` violet and the `⇄`/`→`/`←` glyph family instead of the brand blue and `•` every other local notice uses, so another session's traffic never reads as this session's own output. `/tasks` lists this session's messages on demand with direction, peer, kind/mode, delivery state and a bounded body. The view is folded from the root log (`tool/call`, `tool/result`, and the bridge's relayed `user/message`), so a restarted session rebuilds its history and announces only new traffic. Where the behaviour stops: only an explicit `reply` clears an outstanding request (a progress notify does not), and a relay whose body does not carry the bridge's documented `[kind/mode]` header leaves the kind unknown and is therefore never counted as an answer.
+- **The last completed turn's cost, and a cost per turn (feature)**: the footer's money figure gains the turn it just finished (`$1.23 ❄️ · #12 $0.04`), and `/usage` gains a `cost` column pricing every turn from the same ledger, `+` marking a turn whose settled calls were not all priceable. Attribution charges a call to the turn that was running when it started, by binary search over the turn windows, so the once-a-second footer read falls from O(calls × turns) to O(calls × log turns) — measured 0.63 ms for 8000 calls across 300 turns. A call in the gap between two turns, or before the first one, is reported as unattributed rather than charged to a neighbour. Where the behaviour stops: a session older than the cost ledger shows `--` per turn, and the footer's turn figure drops before the session total on a narrow terminal.
+- **Streaming no longer re-wraps the whole live region every frame (fix)**: the live list was re-created for every event, so unchanged settled-but-unflushed entries were re-flowed on each frame while only the streaming text actually changed. Rows are now memoized by entry identity (the projection replaces an entry object whenever its content changes) under a per-width/verbose cache. Measured on 16 long entries: 3.12 ms/frame → 0.001 ms/frame. Where the behaviour stops: an entry whose object really changes still re-wraps, which is what correctness requires; the cache keys on the floored column count, so a fractional width wraps at the width it keyed.
+- **The status bar carries the loaded skill count (feature)**: a `skills` figure reads the live session catalog, so it follows a skill added mid-session or a session switched to another workspace, and `/statusline` toggles and reorders it. It stays `--` until the first catalog read settles.
+- **The footer is two balanced rows (change)**: row 1 names the session and the model with its effort (`○ title · deepseek-flash @ ultra`), row 2 carries the status figures and closes with the live metrics as one left-hand cluster (`~24.6 tps · 18.2 tps avg · 13% ctx · $0.42 · 87.3% cache`). Every figure reads value first with a short qualifier, and a balance the provider cannot report is dropped instead of parked as `$--`. The order in the cluster is current → average → context → spend → last turn → cache; `footer.current` is gone from the interface catalog and `footer.context` is the untranslated `ctx` abbreviation, like `tps`.
+- **Ancestor skill discovery is on by default (change)**: `.dsh/skills`, `.agents/skills` and `.claude/skills` from every directory between the working directory and home register at rank 300 with no configuration, nearest first, so a shared `~/Workspace/.dsh/skills` is visible to every project below it. `DSCODE_SKILL_ANCESTORS=0` (also `off`, `false`, `no`, `none`, `disable`) turns it off; an unrecognised value keeps the default on instead of reading as off, while `DSCODE_PROJECT_HOOKS` keeps its fail-closed enable spellings.
+- **The Ink repaint ledger no longer leaves a blank band (fix)**: it reserved the whole previous frame height after a static flush, so the live region a settled step freed stayed on screen as blank rows above the composer that the next stream had to refill — 28 rows in a model of one turn on a 40-row terminal. It now reserves only the rows the flush did not consume, which drops that band to what the flush left over (2 rows in the same model) while the composer still never rides up. `scripts/patch-ink.mjs` upgrades an already v2-patched `node_modules/ink` on the next `npm run setup` or launch.
+
+Verification: `npm run lint`, `node scripts/check-docs.mjs`, `npm run typecheck` and `npm run typecheck:strict` are clean. `npm run test:unit` runs 403 cases; 402 pass, and `tests/code-review.test.mjs` does not complete inside a DSCODE session — it spawns real `git` subprocesses in temporary directories and the run ends with `Promise resolution is still pending but the event loop has already resolved`, which AGENTS.md documents as the in-session sandbox limitation, so the suite's exit status is not a usable gate here and that file needs a normal terminal. New cases cover the folder comparison (same/different/prefix/symlink/Unicode normalization), the CLI resume resolver, the cross-session fold (send/reply/relay, reply-only clearing, bounded rows, namespaced ids, the `/tasks` text), the attribution windows and the binary lookup cross-checked against a linear scan, the `/usage` cost column, the live-region cache and the projection identity invariant, and the footer's drop order. The per-turn figures were not exercised against a real ledger on a paid session, and the cross-session display was not observed with two live sessions in a real TTY.

package/docs/releases/0.7.24.md

@@ -0,0 +1,11 @@
+# DSCODE 0.7.24
+
+This release lets an event start a session unattended, caps a goal's rounds from the command plane, adapts MiMo V2.6 on the OpenRouter route and trims that route's `/model` to a curated list.
+
+- **An event starts a session (feature)**: trigger definitions live in `<state>/triggers/` and `<workspace>/.dsh/triggers/` (a project file wins on the same id) with `interval`, `calendar`, `watch`, `poll` and `external` sources, an absolute workspace, a goal objective with a round cap and run limits. An event may carry only data — `source`, `title`, `text` and scalar `fields` under a required `eventId` — so nothing can smuggle a permission or a session into a run, and `ask` is refused because an unattended run can never answer an approval. `dscode trigger run <id>` takes a single-flight lock and refuses a disabled definition, a missing workspace, a repeated event (a scheduled firing is identified by its cadence window), a spent daily cap and a too-recent run, recording every outcome with its reason, exit code, session, cost and rounds in `triggers/runs.jsonl`. `fire`, `emit`, `list`, `show`, `log`, `log --failed`, `events`, `new`, `enable` and `disable` complete the CLI, which the published launcher routes like `exec`, and the terminal reads the definitions, records and spool through `/triggers`. Where the behaviour stops: nothing notifies on a failed run yet — the run log is the pipe a notifier will read.
+- **Unattended runs, and launchd carries the schedule (feature)**: the spawned Host replaces the terminal with the trigger overlay, creates its goal through the goal service (the model-facing tool requires a human turn), delivers the prompt with the event's values and stops on the goal's own end, a round or cost cap, a pause, the timeout or a needed approval — fail closed, marked `approval_required`. `dscode trigger install <id>` writes and loads a launchd LaunchAgent (`interval`/`poll` → `StartInterval`, a five-field `calendar` → `StartCalendarInterval`, `watch` → `WatchPaths`), refuses any cron shape launchd cannot express instead of approximating it and prints the crontab equivalent, while `poll` runs its `check` in the workspace and starts a session only on exit 0. Where the behaviour stops: this scheduling is macOS-only, and a `poll` whose `check` fails starts nothing and tells nobody.
+- **`/goal[20]` caps the rounds from the command plane (feature)**: `/goal[20] <objective>` creates the goal with a 20-round cap and `/goal[20]` re-caps the current goal, so an unattended task stops after the rounds the human allowed; a cap with no goal, or a control word after a cap, is refused with the usage. Where the behaviour stops: upstream's `/goal` remains the surface — a runtime patch (`dsh-command-goal`) adds only the shorthand.
+- **MiMo V2.6 drives the OpenRouter route (feature)**: `xiaomi/mimo-v2.6-pro`, `-flash` and `-pro-ultraspeed` join DeepSeek V4 and Kimi K2.6 in replaying `reasoning_content` on an assistant turn, because Xiaomi answers 400 Invalid Format when a thinking-mode multi-turn request does not pass the field back; the whole `xiaomi/mimo-v2.6` line is matched, so a new size in that family arrives covered. Context, prices and reasoning bands come from OpenRouter's listing unchanged (`off`/`low`/`medium`/`high`, default `high`; the endpoint is fp8, inside the route's quantization allow-list, so `require_parameters` keeps it routable). Where the behaviour stops: the ids, the listing fields and the request body were checked against the live listing, but no probe with a real OpenRouter key has run, so MiMo is not yet claimed as tuned and tested.
+- **The OpenRouter picker is curated (change)**: `/model` offered every tool-calling model in the live listing — 373 of them, in alphabetical order. The route keeps `LISTED_MODELS`, 28 ids: the current DeepSeek, GLM, Kimi, Qwen and MiMo models plus the flagship line of Anthropic, OpenAI, Google and xAI, each verified to exist and to call tools against the live listing. Only the picker narrows: `resolveModel` still serves every id the listing knows, so a session already on a trimmed model, `dscode exec --model` and a provider switch keep working. Where the behaviour stops: the list is edited by hand, so a new flagship and a retired id both need that edit; the Western flagships stay best-effort, and only the five tuned labs are covered by the probe script.
+
+Verification: `npm run check` — lint; typecheck and typecheck:strict; unit, integration, packaging and evaluation — is green on the code this release ships (`05e28ac`) on both Node 24 and 22.19.0 through the `Checks` workflow, `Linux e2e` is green, and the release build re-runs the same gate before publishing. New cases cover the curated picker (a listed flagship appears, a usable but unlisted model does not, and an off-list model still resolves so an existing session keeps running), the MiMo entries' listing shape and reasoning bands, and the family-wide `reasoning_content` replay; `scripts/verify-login-runtime.mjs` asserts the trimmed directory in a real Host. Live checks, none of them model calls: all 28 curated ids exist and can call tools in OpenRouter's listing, and the MiMo entries parse to their real context, prices and bands. No automated case covers: a real OpenRouter key call to MiMo (the 400 it guards against is documented by Xiaomi, not reproduced here), a launchd install on a real schedule, a trigger fired end to end without a terminal, or curated-list drift — a retired id is caught by reading the picker, not by a test. `tests/code-review.test.mjs` does not complete inside a DSCODE session, the documented in-session limitation (it spawns real `git` subprocesses and the run ends with `Promise resolution is still pending but the event loop has already resolved`); macOS-only paths such as TUI rendering, computer use and accessibility permissions have no automated case.

package/docs/releases/0.7.25.md

@@ -0,0 +1,8 @@
+# DSCODE 0.7.25
+
+This release lets a repeated install keep a tar installation current instead of refusing, and adds a Homebrew formula for the launcher.
+
+- **The installer upgrades instead of refusing (change)**: re-running `curl | sh` reads the version already installed and acts on it — equal or newer is reported and left alone with exit 0, older is handed to that installation's own `dscode update`, which downloads the release, verifies the publisher's sha256 digest, migrates `.runtime`, `.env` and the local config, and keeps the previous tree as `.dscode-backup-<version>`. Anything the installer did not create is still refused with the path it found — a directory that is not a DSCODE installation, or a `dscode` command belonging to another installation such as a source checkout — and that check now runs before the download instead of after it. Where the behaviour stops: the swap is the installed updater's work, so a tar installation older than `dscode update` is refused rather than replaced, an upgrade of the installation a session runs from still needs that session to exit, and a pre-release installation is superseded by its release.
+- **A Homebrew formula (feature)**: `brew tap qiz029/tap && brew trust qiz029/tap && brew install dscode` installs the published launcher tarball into the formula's `libexec` — so the pinned dependency graph stays npm's rather than the formula's — links `dscode`, and writes `.dscode-brew` beside `cli.mjs`. `brewManaged()` reads that marker, so on a formula installation `dscode update` moves only the Hub profile and leaves the launcher to `brew upgrade dscode`; an explicit version that would put the profile ahead of the launcher is refused. The tap carries its own workflow that follows `npm view @toddzheng024/dscode version` daily, recomputes the tarball's sha256 and commits the formula update. Where the behaviour stops: Homebrew 7 refuses to load a third-party tap's formula until the tap is trusted, so that step is part of the install; the formula claims `dscode` in the Homebrew prefix, so an `npm install -g` launcher already linked there has to be removed first; and the formula's own install has not run on a machine whose Command Line Tools Homebrew accepts.
+
+Verification: the release build runs `npm run check` on both Node 24 and 22.19.0, and `Linux e2e` is green. New cases cover the installer's version decision — an older installation handed to its own updater without any download, an equal or newer one left untouched, a pre-release not mistaken for the release it leads to, and a foreign command still refused with its symlink left in place — and the Homebrew marker the launcher reads. The installer's upgrade path was also run end to end against real releases: 0.7.23 installed into a scratch directory, the installer re-run to move it to 0.7.24 through its own updater with `.dscode-backup-0.7.23` left behind, and a third run reporting that nothing was changed. The formula was checked as far as this machine allows — `ruby -c` on it, `brew info` loading it, its pinned sha256 equal to the published tarball, and the npm global-prefix install with the marker read back by the new launcher code — but **no `brew install` completed here**: `brew doctor` reports this machine's Command Line Tools do not support macOS 26, which Homebrew refuses to install past, so the formula's install and test blocks have no automated or manual confirmation yet. `tests/code-review.test.mjs` does not complete inside a DSCODE session, the documented in-session limitation (it spawns real `git` subprocesses and the run ends with `Promise resolution is still pending but the event loop has already resolved`).

package/docs/releases/0.7.26.md

@@ -0,0 +1,18 @@
+# DSCODE 0.7.26
+
+Superseded by [0.7.27](0.7.27.md): post-publication verification found that Hub CLI 0.5.0 rejects the empty root file generated during fresh installation. Use 0.7.27 or newer for npm/Hub installs.
+
+This release adds durable trigger scheduling and script event sources, fixes model-effort and provider-error presentation, and reorganizes the footer around API-backed TPS and right-aligned finances.
+
+- **Trigger session modes (feature)**: an event can create a fresh session or resume a persistent session bound to the trigger id. Persistent events retain context while receiving independent goals and execution limits. Events serialize under the existing locks; missing bound sessions or workspace changes fail rather than silently discarding history.
+- **Cron and delay jobs (feature)**: calendar, interval and polling sources enqueue durable SQLite jobs, and one-shot jobs support delay/absolute-time scheduling and cancellation. The shared scheduler tracks cursors, time zones, misfires, overlap and pending reasons. Failed runs are not automatically retried, and unattended approval requirements stop a run for review. Installing and starting the background scheduler remains explicit.
+- **Agent and TUI management (feature)**: `trigger_manage`, `trigger_jobs`, `trigger_scheduler`, `trigger_source`, `/trigger` (alias `/triggers`) and the CLI share management state and workspace boundaries. The slash command runs without calling a model. Mutations retain approval checks; read-only/plan sessions, subagents and unattended runs cannot mutate schedules through these management tools.
+- **Script event sources (feature)**: finite polling scripts and supervised daemon loops can emit events through a scoped local ingress into the durable queue. Event identity, retry acknowledgements, conflict detection, queue backpressure and lifecycle logs make loop integration inspectable. Filesystem sandboxes and guardian processes restrict sources and clean up ordinary descendant process groups. Unsupported sandbox environments fail closed; detached-process evasion and arbitrary external services are outside the automated guarantees.
+- **DSCODE preset and effort selection (change/fix)**: the interactive preset stays fixed to DSCODE, with `/mode` hidden and other preset selections rejected. Legacy transcripts survive resume under DSCODE. Switching from MiMo `medium` to DeepSeek now opens its effort picker at the advertised default `high`; the footer no longer borrows an earlier model's effort. Supported selections are retained, and request-boundary validation remains in place.
+- **Content-policy failures (fix)**: OpenRouter's untyped content-filter 403 is classified as `CONTENT_POLICY`, with an explanation that the turn stopped, instead of being mistaken for an authentication problem. Ordinary credential failures keep their classification. This improves live and replayed error presentation; it cannot bypass a provider's policy or automatically retry a rejected request.
+- **API-backed smoothed TPS (change)**: completed main-agent requests contribute their reported output token count divided by measured full request duration, including first-token latency. Each valid request multiplies older sample weights by `0.5` before adding its own weight of one and normalizing. Idle time does not age the reading; aborted or missing-usage calls do not update it, and a new model/provider/effort request resets it. Byte-count estimates and the `~` prefix are removed. A separate request indicator animates without changing the number and respects the animation preference.
+- **Grouped footer (change)**: TPS, average, context and skills remain on the left; cost, DeepSeek balance, peak/off-peak, last-turn cost and cache align together on the right. Narrow terminals move finances to a third row, and the live viewport and IME cursor account for its height. Very narrow layouts can omit average TPS or last-turn cost and finally clip oversized financial text; unavailable balance data remains unavailable.
+
+Verification: `npm run check` passed locally, including 542 unit tests under coverage, both TUI type checks, lint, all isolated Harness integration probes, package integrity/exports checks, and 51 evaluation tests. The documentation checker also passed. Render cases cover 48, 60, 80 and 120 columns, stable numeric TPS during activity animation, and third-row viewport accounting. Deterministic fixtures cover provider errors, model switching, durable jobs, script ingress and trigger session modes without paid model requests. `npm run build:packages`, `npm run release:hub` and `npm run verify:hub` also passed: the candidate installed through the real Hub lifecycle, ran deterministic agent/shell/subagent, messaging, card and memory probes, and survived a failed upgrade, successful upgrade and rollback with state retained. This local check used a loopback registry, not public package discovery.
+
+Not covered by those checks: human acceptance in a live terminal/IME, Linux script sandbox execution on this macOS workstation, real provider inference or moderation behavior, and a newly installed persistent scheduler on the user's machine. The release does not install or start such a scheduler.

package/docs/releases/0.7.27.md

@@ -0,0 +1,8 @@
+# DSCODE 0.7.27
+
+This patch release repairs fresh npm/Hub installation and adds the native dependency-lock path to release verification.
+
+- **Fresh installation (fix)**: Harness composition creates an empty `cordis.yml` after Hub CLI 0.5.0 records installation inputs. The final receipt check previously rejected that generated file and discarded the staged profile. The launcher now carries a build-time vendored CLI that excludes only the exact generated file hash when no package-manager hooks are present. Custom root content, hook-bearing profiles, other configuration files and lockfiles remain checked. No recipient dependency files are patched at install time.
+- **Release verification (fix)**: candidate verification now runs the native locked installer, starts the installed launcher with `--dump-config`, and checks Hub doctor. Publication requires those results against the exact package hashes. Existing external-executor agent, failed-upgrade and rollback probes remain, but no longer stand in for native installation.
+
+Verification completed before tagging: `npm run check` passed (lint, both typechecks, 543 unit tests, 83.55% measured `.mjs` line coverage, isolated Harness integration probes, package checks and 51 evaluations); documentation links are clean. `npm run verify:hub` passed the native locked installation, launcher first start and Hub doctor, as well as installed-agent, failed-upgrade, replacement and rollback probes. The regression test accepts only the pinned generated root and rejects custom root content, package-manager hook cases, other input changes and lock changes. No paid provider request or human TUI interaction is part of this patch's installation proof.

package/docs/releases/0.7.28.md

@@ -0,0 +1,22 @@
+# DSCODE 0.7.28
+
+This release moves the whole `@deepseek-ai/dsh*` runtime from `0.1.5-rc.2` to `0.1.7-alpha.2` and carries DSCODE across the four upstream planes that release rewrote: configuration, agent presets, message attribution and the DeepSeek wire protocol.
+
+- **Runtime pin (upgrade)**: every `@deepseek-ai/dsh*` dependency and override is now `0.1.7-alpha.2`, with `@deepseek-ai/cordis` at `4.0.4`, `@deepseek-ai/cordis-plugin-loader` at `1.0.5` and `@deepseek-ai/schemastery` at `3.18.4`, the versions that release requires. Five packages disappeared upstream and are replaced by their successors: `dsh-agent-presets` → `dsh-agent-preset` plus `dsh-agent-preset-registry`, `dsh-code-runtime{,-worker-thread}` → `dsh-ptc-runtime{,-node}`, `dsh-workflow-worker-thread` → `dsh-workflow-ptc`, and `dsh-settings-file` → `dsh-config-editor`. The upgrade brings upstream's `run_code` sandbox escalation, durable image offload, the MCP client on `@modelcontextprotocol/client` 2.0.0, subagent permission inheritance and compaction retry recovery. `0.1.7-alpha.2` is upstream's `alpha` channel, not a release candidate: it is the line upstream is developing, and a later alpha may move these interfaces again.
+- **Configuration (breaking upstream API)**: DSH replaced settings sections with volatile configuration — a `.volatile()` field arrives as a reference the Settings form and a profile edit both write, and `settings.installSection` is gone. The OpenRouter and Grok routes now mark their editable fields volatile, read a snapshot per request, address their form by the profile entry id (`dscode-openrouter`, `dscode-grok`), and re-register the route from `loader/volatile-update` when the retry policy changes. `@anionex/dsh-computer-use` 0.3.2 still calls the older `ctx.settings.register`; DSCODE now mounts that bundle through its own `plugins/computer-use` row, which restores the method as a read-only view over the composition config before the provider's constructor runs. Nothing patches the installed package, so the repository and the npm bundle behave identically.
+- **Agent presets (breaking upstream API)**: the registry reads declaration rows and no longer discovers presets from directories, and the shipped `standard`/`ptc`/`minimal` rows live in the `dsh-web-app` bundle this profile does not carry. `presets/dscode/agent.cordis.yml` therefore travels as one `@deepseek-ai/dsh-agent-preset` row inside the profile patch — rendered by `scripts/preset.mjs`, which indents the file as text so its `!!js` expressions and comments survive — and `dscode` is the only declared preset and the deployment default. Setup no longer materialises `.runtime/agent-presets/dscode`, and the npm bundle no longer ships a `presets/` directory. DSCODE already locked its mode to `dscode`, so the roster is unchanged in practice; a session recorded under an upstream preset still resumes and migrates, which `verify-runtime-foundations` covers.
+- **Permission preset rename (breaking)**: DSH 0.1.7 reserves the name `auto` for its own Auto integration (full access with approval off) and refuses a configured preset of that name, so DSCODE's reviewed preset is now **`auto-review`** — the same `workspace-write` plus `approval: ask` bundle with the model reviewing eligible requests. Use `/permission auto-review`, `dscode exec --permission auto-review` and `permission: auto-review` in a trigger; the trigger gates still accept the old name for definitions written before this release. A session whose recorded preset is `auto` keeps its sandbox and approval values and shows as `custom` until it is switched.
+- **Message attribution (breaking upstream API)**: the shared `plugin` source kind is retired — every producer declares its own `kind`, and session format v4 refuses a message that still carries the wrapper. DSCODE's injecting plugins now name themselves (`dscode-session-bridge`, `dscode-time-marks`, `dscode-shell-exec`, …), and one helper, `plugins/message-source/kind.mjs`, resolves all three shapes durable history can hold: the current kind, the pre-upgrade `{ kind: 'plugin', plugin: '<producer>' }`, and the `plugin:<producer>` kind the v3-to-v4 session migration writes. The terminal's transcript keys its hidden snapshots, reminder rows and relay rendering off that helper, so a resumed older session still renders as before. The bridge also moves from the retired `agent/session-start` event to `agent/created`, which 0.1.7 awaits at the same point; without that change every turn in a bridged session ended with "Session communication owner is not ready".
+- **DeepSeek wire protocol (upgrade)**: the adapter now speaks the DeepSeek Messages API, where the system prompt is a request field and the effort rides in `output_config`. The Ultra patch was rewritten accordingly: Ultra is advertised in the model's effort catalog, normalised to the provider's `max` when the request is serialised, and the Ultra and Flash policies are appended to the `system` field by two new helpers in `plugins/ultra/policy.mjs` (the message-shaped pair stays for the OpenRouter and Grok adapters). Image offload follows upstream's new contract: a route reports how many oldest occurrences exceed its budget with `IMAGE_OFFLOAD_REQUIRED` and the `compaction-image-offload` executor records that choice durably, instead of each request dropping the oldest images on its own — DSCODE's OpenRouter adapter now does the same.
+- **Computer Use (known limitation)**: `@anionex/dsh-computer-use` 0.3.2 restores its execution tools on resume by reading the durable log for the loaded skill, and it looks for the pre-0.1.7 shape — a `tool-result` content block carrying `toolCallId` and `isError` — which session format v4 moved onto the message. Live activation is unaffected, because that path reads the execution result: loading the `computer-use` skill exposes `computer_observe` and the rest as before, and the native helper handshake passes. A **resumed** session keeps the `computer_use_activate` bootstrap but regains the execution tools only once the skill is loaded again. The pinned package has no newer release; the harness probe records the behaviour as `HARNESS_PROBE_NOTE` instead of asserting a restoration this dependency cannot perform.
+- **Pinned runtime patches (maintenance)**: `RUNTIME_VERSION` is `0.1.7-alpha.2`. Three of the nine patches needed new anchors — the subagent tool's recursion budget now comes from `subagents.resolveMaxDepth`, the bash tool's config schema is multi-line, and the DeepSeek adapter's ultra path was rewritten as described above — and all nine apply, parse and stay idempotent against the new tree.
+
+Verification completed before tagging: `npm run check` passed on macOS (lint, both typechecks, 543 unit tests at 83.32% measured `.mjs` line coverage, the nine native Harness integration probes, both package tarballs and 51 evaluations), and the patched runtime was additionally re-validated by applying every patch twice and parsing the result. `npm run doctor` also passed against a real profile boot on the new tree: both the shipped `standard` and the DSCODE preset composed, 51 tools with scoped Chrome MCP discovery, skill activation, file editing and shell execution, the compaction provider, a nonempty session resume, the full auto-review allow/deny/human path with its audit, child worktrees and effort selection, manual compaction, and a healthy native Computer Use helper (`ready: true`, accessibility granted). `npm run verify:hub` passed too, after the same preset gap surfaced there: the installed
+profile declares only DSCODE's preset, so the agent probe's `standard` mount failed until the
+verification's overlay declared it from the `dsh-web-app` copy the installation carries. It
+then verified the native locked Hub install, launcher first start, Hub doctor, the installed
+bundle's agent loop, shell, subagent worktrees, auto review, compaction and telemetry, its
+session messaging, cards and memory probes, and a failed upgrade with rollback. The
+documentation checker prints clean.
+
+What has no automated case here: the interactive TUI was not driven by hand for this release, so the terminal's own rendering of a 0.1.7 session is covered only by `tests/tui-render.test.mjs` and the typechecks; no paid provider request was made, so the Messages-API changes are proven against fixture streams rather than DeepSeek's live endpoint; and no desktop action was driven through Computer Use — its helper health and tool exposure are proven, its actual screen control is not.

package/docs/releases/0.7.29.md

@@ -0,0 +1,12 @@
+# DSCODE 0.7.29
+
+This release adds the account plane DSH 0.1.7 introduced — a browser sign-in that authenticates the DeepSeek route without an API key — and repairs two composition rows the 0.1.7 upgrade left misaligned.
+
+- **`/account` (new)**: sign the DeepSeek route in with a DeepSeek account through the system browser. `/account login` starts one attempt, `/account` reports whether a grant is stored plus the account identity, recharge wallets and — separately — bonus wallets and the platform's usage and top-up pages, `/account cancel` abandons an attempt in flight, and `/account logout` removes the grant from this machine. The flow is the upstream one: PKCE (S256), a `state` the provider compares in constant time, a one-time code exchange, and the grant committed to the same local credential store as the API keys. A signed-in machine needs no `DEEPSEEK_API_KEY`; a stored key stays the fallback, and a route pointed at a non-default base URL deliberately never receives the account token. The command's output carries no token — account state is the client-safe projection, and the token stays Host-only inside the LLM route. Every string is translated in all six interface languages. See [Account login](../account-login.md).
+- **Loopback callback server (new)**: the account provider registers `/oauth/callback` on the Host's HTTP server, so the TUI profile now composes `@deepseek-ai/dsh-host-webserver` on `127.0.0.1` with an OS-assigned port. It carries **no route except while a sign-in runs** — the callback appears when an attempt starts and is removed when it settles — and this profile mounts none of the Web shell's frontend or API rows, so anything else answers 404 and a callback without a valid `state` and `code` answers 400. `DSCODE_ACCOUNT_LOGIN=0` removes the listener entirely; `/account login` then refuses with that reason and the other subcommands keep working.
+- **Host-plane workflow engine (fix)**: DSH 0.1.7 renamed that row from `workflow-worker-thread` to `workflow-ptc`. A Loader patch addresses rows by id, so DSCODE's disable silently stopped landing and `workflowEngine` was published process-wide, exactly the leak the preset's entry-local realm exists to prevent. The disable now names the current id, and a new composition test checks **every** id DSCODE patches against the bundles this profile composes, so the next upstream rename fails in the suite instead of in a running session. The audit found no other stale target.
+- **Redundant PTC runtime row (cleanup)**: 0.1.7 ships the Node PTC runtime in the base composition, and DSCODE's own insert carried the same id, so it only re-patched that row rather than mounting a second one. The insert is gone; `ptcRuntime` still resolves from the base row.
+
+Verification completed before tagging: `npm run check` passed on macOS (lint, both typechecks, 558 unit tests at 83.87% measured `.mjs` line coverage, the nine native Harness integration probes, both package tarballs and 51 evaluations); `npm run doctor` booted a real profile; and `npm run verify:hub` passed the native locked install, launcher first start, Hub doctor, the installed bundle's agent, messaging, cards and memory probes, and a failed upgrade with rollback. The account flow was additionally exercised against the live platform without completing a login: `startSignIn` returned a real `platform.deepseek.com/dsh/authorize` URL, the loopback `/oauth/callback` route existed during the attempt and answered 400 without a valid `state` and `code`, and cancelling removed the route (404) and left the machine signed out. The twelve account unit tests drive the whole command with a service double, including the case that made the first implementation wrong: the authorize URL does not exist when `startSignIn` returns, so the browser is opened only after the URL is published. The composition test was mutation-checked by restoring the stale id, which fails it.
+
+What has no automated case here: completing a sign-in in the browser needs a real account, so the callback, code exchange and grant commit are proven only by the provider's own contract and the live attempt up to the browser step; no paid provider request was made; and the interactive TUI was not driven by hand, so `/account` is covered by its unit tests and the command registration probe rather than by a rendered session.

package/docs/releases/0.7.3.md

@@ -0,0 +1,23 @@
+# DSCODE 0.7.3
+
+This release adds OpenRouter: `/provider` switches the same set of DeepSeek models between the official DeepSeek API and OpenRouter; it also fixes several harness problems the evaluation exposed — a cost ledger with no elapsed time, model calls missing from the ledger, review skipping merged changes, and the npm launcher lacking `dscode exec`.
+
+- **`/provider [deepseek|openrouter]`**: with no argument it opens a picker showing each provider's key status. The first switch to OpenRouter declares pi-ai's `openrouter` route in the settings document (DeepSeek V4 Flash, V4 Pro, V4 Flash Vision Exp; an existing `openrouter` configuration is not overwritten and can be edited later in `/model` → `a`); when the key is missing it raises an input box and continues the switch after saving, landing on the corresponding model of the current one and keeping the current effort (the model default when the target does not support it). A running turn has to be stopped first.
+- **`/login [deepseek|openrouter]`**: saves either provider's key, targeting the current provider when called without an argument. `OPENROUTER_API_KEY` is stored in `~/.dscode/credentials.yaml` like `DEEPSEEK_API_KEY` (`0600`, shared across projects and versions), and an environment variable takes precedence. An argument that is not a provider name is refused outright and never echoed (so a key pasted by mistake is not printed).
+- **Ultra works on OpenRouter too**: the pi-ai adapter is patched and vendored with the bundle like the DeepSeek adapter. Ultra on OpenRouter sends `xhigh` with the collaboration policy, and below Ultra no delegation tools are offered. The OpenRouter route provides off/low/high/max like the official one, with `low` sent as `high` (DeepSeek handles low that way itself), so session cards and child-agent low requests work as usual and `/effort` keeps its band bar.
+- **The footer follows the current provider**: the balance shows that provider's (for OpenRouter, credits minus usage); an OpenRouter call is estimated from the fixed pi-ai catalogue prices (ledger `priceVersion` `openrouter-pi-ai-0.85.1`), and the 🔥/❄️ peak/off-peak marks are shown for DeepSeek only. `/status` states the actual wire effort of Ultra on each route; a missing-credential error now points at `/login`. Fix: when a model id carries a vendor segment (`openrouter/deepseek/deepseek-v4-flash`), `/effort` could not find the model.
+- **The ledger records the elapsed time of every model call**: an `end` row used to reuse the start's `time`, so a single call always took 0. An `end` row now carries `endTime` and `firstTokenTime` (the first text, reasoning or tool-argument increment), while `time` is still the start (used for pricing).
+- **Every model call made on behalf of a session enters the ledger**: the review tool and `/review`, memory extraction and consolidation, session cards and `/doctor` used to carry no `sessionId` and never reached the ledger. They now count towards their session with their own `purpose`; the attribution travels through async context rather than adding a `sessionId` to the request (which would also trigger session-log delivery, cache affinity and agent-only prompt rewriting). Compaction and session titles were already recorded.
+- **Review no longer skips committed or merged work**: with no uncommitted change, the default scope becomes the commits since this task began (the task's starting HEAD read from HEAD's reflog); `--commit` on a merge commit now diffs against its first parent instead of producing an empty combined diff.
+- **The npm launcher provides `dscode exec`**: it runs exec with the installed Hub profile, with the same options, stdin prompt and exit code as the source form; when it is not installed yet it installs first, with the install output on stderr so stdout stays pipeable.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.3
+dscode update 0.7.3
+```
+
+`dscode-0.7.3.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 and the coverage baseline. New here: Ink rendering tests for the `/provider` picker and `/login` arguments; in a real Host, declaring the OpenRouter route, saving and reloading both keys, and intercepting an OpenRouter request before it goes out to check the URL, key, effort, tools and Ultra policy; ledger elapsed-time and async-attribution tests, plus session-card calls counting towards the session ledger in a real Host; the review fallback in a no-ff merge repository; and the launcher `exec` exit code and argument passthrough. No real OpenRouter call was made.

package/docs/releases/0.7.30.md

@@ -0,0 +1,19 @@
+# DSCODE 0.7.30
+
+This release adds a coordinator mode: `/delegate` has the main agent plan a task on a board with priorities and dependencies, run the parts as child agents in isolated Git worktrees, verify each result and merge what it accepts. `/delegate-dashboard` shows that board as a kanban. It also raises the child cap and redraws the welcome snowflake.
+
+- **Child cap by effort (changed)**: a parent can now run five direct children at once below Ultra and twenty at Ultra, instead of three at every effort. The runtime reads the parent's effort each time it launches or wakes a child, so dropping out of Ultra brings the lower cap back at once. Admission reservations still stop concurrent launches from racing past the cap. One delegation level is unchanged. The below-Ultra shell policy still asks for one child at a time outside `/delegate`; only the runtime ceiling moved.
+- **`/delegate <task>` (new)**: the main agent becomes the coordinator. The command only checks that the session starts at a clean Git repository root and is not a child agent. It then queues the task with a fixed coordinator protocol. The transcript shows it as one `/delegate …` line, not the protocol text. Planning, dispatch, verification and merging are the model following that protocol. The runtime enforces what it can: the child cap, one delegation level, dependency order at launch, and the board itself. Children work only in their own worktree, leave their changes uncommitted, and ask the main agent with `send_message` to `/` when they are blocked.
+- **Delegate board (new)**: the `delegate_board` tool records each task with a title, its planned child name, a priority (`high`, `normal`, `low`) and the tasks it depends on. The board rejects dependency cycles. A pending task is ready once every dependency is complete, and launching a blocked task is refused before it takes a slot. Ready tasks are ordered by effective priority: a task's own priority or that of any open task waiting on it, whichever is higher. Work that unblocks a high-priority task therefore goes first. Launching a child under a planned name moves its task to running. Running and verifying come from the child's live status, not from what the model last reported. A task is completed only with the main agent's verification evidence. Dropping a task releases whatever waited on it. Children never see the tool. Boards are kept per session under `$DSH_HOME/delegate-boards/` and survive a restart. A new `/delegate` clears a board whose tasks are all finished.
+- **Board state as messages, not the system prompt (design)**: the coordinator receives the board and its free slots as a message ahead of its next step, and only when the board changed. Rewriting the system prompt on every change would have invalidated the provider's prompt cache for the whole conversation each time a child started, settled or asked a question. The terminal hides these messages.
+- **Dependencies across worktrees**: every worktree starts at `HEAD`, and merging waits until every task is complete. A dependent task's child therefore first applies its dependencies' verified diffs from the worktree paths the board recorded. It then commits them as a baseline on its detached HEAD, which never reaches a branch. At the end the main agent merges complete tasks in dependency order with `git apply --3way`, so each task contributes only its own changes. The result is left staged and uncommitted. Merging waits for the whole board because a new worktree needs a clean main workspace.
+- **`/delegate-dashboard` (new)**: a popup kanban with Pending, Running, Verifying and Complete columns, divided by vertical rules.
+  - Every task is its own bordered card in its column's colour, with a status glyph, id, child name and title. `▲` marks high priority and `▼` low.
+  - A blocked card is grey with a hollow `◌` and names what it waits on. A child waiting on the main agent has an amber card with a `?` badge and leads its column.
+  - The title row carries a child-slot meter and completion progress. It refreshes every second, and Esc or q closes it.
+  - On a short terminal every card folds to one line so more fit, and a narrow terminal stacks the columns. English and Chinese strings are included; other interface languages fall back to English.
+- **Welcome snowflake (redrawn)**: the header mark is now generated from snowflake geometry. Six arms sit 60° apart around a bright hexagonal crystal, each with one branch pair parallel to its neighbours. The 30° arms are smoothed so they read as single lines. Both sizes stay mirror-symmetric, and the core → arms → branches ripple is unchanged.
+
+Verification completed before tagging: `npm run check` passed on macOS (lint, both typechecks, 572 unit tests at 84.23% measured `.mjs` line coverage, the nine native Harness integration probes, both package tarballs and 51 evaluations). After that run, one sentence was added to the `/delegate` protocol text (the main agent tells a dependent child that its worktree-local baseline commit is authorised), and the affected suites and lint were rerun. The new behaviour has unit cases for the cap boundaries at both efforts, the `/delegate` preconditions and its notice-form message, and board transitions. They also cover persistence, dependency resolution, cycles, launch refusal, priority inheritance, released dependents, the injected board messages (including that an unchanged board is not re-sent) and the dashboard rendered through Ink at wide, short and narrow sizes. The worktree merge recipe, including a dependent task's baseline commit and dependency-order merging, was exercised against real Git repositories.
+
+What has no automated case here: no model was driven through `/delegate`, so whether a model follows the coordinator protocol end to end — planning dependencies, dispatching in order, verifying before completing, merging in order — is unverified. The interactive TUI was not driven by hand; the dashboard and the snowflake were checked as rendered frames rather than in a live terminal. The dashboard stays within the shared half-screen panel height.

package/docs/releases/0.7.31.md

@@ -0,0 +1,14 @@
+# DSCODE 0.7.31
+
+This release adds OpenCode Go as a fourth provider: `/provider opencode-go` runs a session on an OpenCode Go subscription, serving its chat-completions models with the reasoning efforts each one accepts, and searching the web through Exa as OpenCode itself does.
+
+- **`opencode-go` route (new)**: a new plugin, `plugins/opencode-go`, registers the route. `/provider opencode-go` (also `/provider opencode`) asks for the key from the OpenCode console and stores it in `~/.dscode/credentials.yaml` like the other provider keys. `OPENCODE_API_KEY` in the environment takes precedence. The key is sent as a bearer token to `https://opencode.ai/zen/go/v1/chat/completions`. The provider picker, `/login opencode-go` and `/model` pick it up from the provider catalog without terminal changes. Switching from DeepSeek or OpenRouter lands on the same model when Go serves it; otherwise the switch lands on `kimi-k3`.
+- **A catalog probed against the live gateway (design)**: Go's `/models` listing returns ids only. It gives no context size, image support or reasoning controls. Go also passes request fields through to each model's upstream, so what a request may contain differs by model. The catalog therefore records, per model, what the gateway accepted in September 2026. It covers the `reasoning_effort` values (GLM, Kimi K2.7 Code, LongCat and Space Bunny cannot switch thinking off, and MiMo V2.6 refuses `max`) and whether the model takes images (a text-only model answers an image with HTTP 404). Context windows follow each lab's published figure. The catalog has 19 models: DeepSeek V4 (4), GLM (4), Kimi (3), MiMo (4), LongCat, Hy (2) and Space Bunny Free. The DeepSeek rows follow DeepSeek's own API rather than a probe, because the test workspace was not set to Go's Global region.
+- **Request shape**: the body keeps to OpenAI fields: `reasoning_effort` (Off sends `none`, Ultra sends `max` plus the collaboration policy) and `stream_options.include_usage`. It omits OpenRouter's extensions (`reasoning: {effort}`, `provider`, `session_id`), which Go's upstreams reject with "Extra inputs are not permitted". Each request carries the session id in `x-opencode-session` and a `dscode/<version>` user agent, as Go asks of third-party clients. Reasoning goes back to the model that produced it as `reasoning_content`. DeepSeek gets an empty one after another model's turn, because it rejects a thinking-mode tool-call turn without one.
+- **Shared request loop (changed)**: the Go adapter extends the OpenRouter adapter instead of copying it. The request loop, image preparation, SSE parsing and stream translation are now parameterised by route. The route supplies its model lookup, body, headers, replay kind and the name used in error messages. OpenRouter's defaults are unchanged, and its tests pass unmodified.
+- **Web search through Exa (new)**: Go has no search endpoint. A Go session's `web_search` therefore calls `web_search_exa` on Exa's hosted MCP server (`https://mcp.exa.ai/mcp`), which is what OpenCode's own client does, and that server answers without a key. An `EXA_API_KEY` in the environment or the credential store moves the calls onto that account, and a key store that cannot be read falls back to the keyless endpoint. Exa's text answer is parsed into de-duplicated sources with title and snippet. A search times out after 25 seconds, and cancellation is honoured. Routing sends only `opencode-go` sessions to Exa, because the keyless tier is Exa's free offer with no published limit. DeepSeek, OpenRouter and Grok sessions search as before.
+- **Where it stops**: Go serves Qwen and MiniMax over the Anthropic messages protocol, and Grok 4.x, GPT Luna and Muse Spark over the OpenAI responses protocol. This release implements neither. Naming one of those models fails before any request with a message that names the endpoint. The footer shows no cost and no balance on this route, because Go publishes no allowance API. When the workspace is not in the Global region, Go refuses its DeepSeek models; the error now adds where to change that in the OpenCode console.
+
+Verification: `npm run check` passed on macOS. That covers lint, both typechecks, 581 unit tests at 84.54% measured `.mjs` line coverage (nine tests are new for this route), the nine native Harness integration probes, both package tarballs and 51 evaluations. The extended `scripts/verify-login-runtime.mjs` probe boots a real Harness Host twice and checks that the `opencode-go` row saves its key, keeps it across a restart, lists the catalog with the right efforts and sends the expected request shape. With a real Go key, the adapter completed a tool call followed by a replayed answer on all 15 non-DeepSeek chat models. The DeepSeek and Qwen rows failed with their intended explanations. A live keyless Exa search returned titled, de-duplicated sources, and a cancelled search reported `WEB_ABORTED`.
+
+What has no automated case: the DeepSeek rows were not exercised against Go, because the test workspace was not in the Global region. Image input was checked with direct gateway requests, not through the adapter's attachment path. The provider picker and `/login opencode-go` were not driven by hand in a live terminal. No model ran `web_search` inside a real Go session; routing to Exa is covered by unit cases only.

package/docs/releases/0.7.32.md

@@ -0,0 +1,14 @@
+# DSCODE 0.7.32
+
+This release makes an OpenCode account login the only way into OpenCode Go and shows the subscription's usage in the footer. `/opencode login` runs the OpenCode console's device login, and the console API key that 0.7.31 introduced is no longer read.
+
+- **`/opencode [login|cancel|logout]` (new)**: `login` asks the OpenCode console for a device code, opens the verification page in the browser, and answers at once with the code and the URL. It then keeps polling in the background, because a command settles with one result and cannot print while it waits. It handles `authorization_pending`, `slow_down` (five seconds more per answer) and transient gateway errors until the code expires, which is ten minutes. `/opencode` reports the stored login (account, organisation, days left), an attempt still waiting (its code and URL again), or how the last attempt ended. `cancel` stops the polling. `logout` removes the local login and the cached usage, and says plainly that the token stays valid on OpenCode until it expires or is revoked in the console. The strings are translated into all six interface languages.
+- **The OpenCode CLI's login client (design)**: the console answers the device flow for the public client `opencode-cli`, which is OpenCode's own CLI. DSCODE uses that client id, so the consent page names the OpenCode CLI. The command says so before the browser opens. The guide says OpenCode can restrict the client at any time, and that the route stops working if it does.
+- **The account's own endpoint**: the access token is refused on the public `zen/go/v1` endpoint (HTTP 401, with or without an org header). The console's `/api/config` names an inference endpoint for `opencode-go` per organisation, and that endpoint takes the token as a bearer plus `x-opencode-org-id`. At login DSCODE reads `/api/user` and `/api/orgs`, then takes the first organisation by name whose config carries `opencode-go`, and stores its endpoint with the grant. An account without Go in any organisation fails the login with that reason. The OpenRouter adapter's request loop gained a `resolveAuth` hook that returns the bearer, the base URL and extra headers; OpenRouter's own default is unchanged, and the Go adapter returns the login.
+- **API key route removed (changed)**: the Go route's credential reference is now the login itself (`OPENCODE_OAUTH`). The credential store describes it as read-only, so no key form is ever offered. The provider catalog marks the route with the command that sets it up. `/provider opencode-go` before signing in, and `/login opencode-go`, now show `OpenCode Go is not signed in; run /opencode login first` instead of opening a key field. The picker shows `signed in` or `not signed in · /opencode login`. A request made while signed out fails with the same instruction. An `OPENCODE_API_KEY` saved under 0.7.31 stays in `~/.dscode/credentials.yaml` but is no longer read, and the route's `apiKeyEnv` and `baseURL` settings are gone.
+- **Renewal with rotating refresh tokens**: tokens last 30 days, and a request made within five minutes of expiry refreshes first. Every refresh returns a new refresh token and voids the old one; the probe confirmed this, since reusing the old token answers `invalid_grant`. So the new pair is written back at once, and one process runs one refresh at a time. When a refresh is refused, the store is read again before giving up, because another DSCODE session sharing the store may have rotated it already. Only when nothing newer is stored does the request fail, as `AUTH` with a message asking for `/opencode login`. DSCODE keeps its own grant and never touches an OpenCode CLI login, which would have its refresh token voided the same way.
+- **Subscription usage in the footer (new)**: Go caps usage per rolling five hours, per week and per month. The console's own proxy maps the public `/zen/go/v1/usage` to `/go/v1/usage` on the inference service. There, the account token plus `x-opencode-org-id` answers all three windows, each with a used percentage, `ok` or `rate-limited`, and the reset time. Without the org header the endpoint answers 403. The plugin reads it once a minute while signed in, and right after a login. It keeps the last good snapshot through a failed read, and writes the snapshot to `DSH_HOME` for the terminal process, as the Grok window does. On this route the money slot shows `Go · 5h 12% · 7d 3% · 30d 1%`. An exhausted window is marked `!`, and the slot adds `limited until MM-DD HH:MM`, the latest reset among the exhausted windows. An unread snapshot shows `Go` alone. The endpoint is undocumented, so every field is optional and a changed shape reads as unavailable.
+
+Verification: `npm run check` passed on macOS. That covers lint, both typechecks, 586 unit tests at 85.08% measured `.mjs` line coverage, the nine native Harness integration probes, both package tarballs and 51 evaluations. The unit tests drive the device login against a fake console through pending, slow-down and gateway errors, organisation selection and the refusal paths. They cover the grant session's refresh near expiry, one shared refresh for concurrent requests, adopting another process's rotation, and a revoked login. They also cover the command's background sign-in, status, cancel and logout, and requests going to the login's endpoint with its org header. They check that the store describes the login as a read-only credential, and they exercise the usage URL, parsing, caching, file snapshot, sign-out clearing and the footer fact. `scripts/verify-login-runtime.mjs` checks, in a real Harness Host, that the Go row is a read-only credential and that a signed-out request names `/opencode login`. It then stores a synthetic login and checks that the row reads as signed in and that the next request goes to the login's endpoint with its bearer and org. Against the real console, DSCODE's login code signed in with a real account. It ran a kimi-k3 tool call and replay, then forced a refresh; both tokens changed and the next request answered. With a later login, the account token read the usage endpoint at `/inference/go/v1/usage` (200 with the org header, 403 without, 401 on the public endpoint).
+
+What has no automated case: `/opencode` was not typed into a live terminal; the command was driven through its handler. The footer was checked as a rendered string, not in a running terminal, and the usage refresh loop was not observed against the real endpoint inside the plugin; the endpoint itself was read by a probe. A refresh racing between two real processes was exercised only against the fake console. An account with several organisations holding Go was not available.

package/docs/releases/0.7.33.md

@@ -0,0 +1,30 @@
+# DSCODE 0.7.33
+
+This release candidate packages DSCODE for official Harness Desktop, adds community plugin discovery through our Plugin Hub, and establishes a separate Desktop publication path alongside the terminal release.
+
+- **Formal Desktop plugin:** `@toddzheng024/dscode-desktop` has an icon, English/Chinese display metadata, package-specific instructions and an exact Harness peer version. It adds coding, browser preview, collaboration, memory, email and opt-in scheduling to the official application. The qualified target is macOS Apple Silicon with Harness runtime `0.2.0-rc.2`. Other runtime candidates remain private. A standalone application, DMG and automatic Desktop updates are deferred.
+- **Plugin Hub:** native Settings and read-only conversation tools share the Hub API and schema. Search, categories, numbered pagination and details expose compatibility and reported security information. Installation requires an exact npm version, official inspection and explicit confirmation. New plugins remain disabled, and the UI opens official management for enabling, configuration and removal. Git-only entries remain visible without installation; Hub Profile application and rollback are outside this integration. A reported scan result is not a guarantee about plugin behavior.
+- **Installation and migration:** official Add plugin accepts the archive, followed by Enable now. Users of the earlier private probe remove its old package name before installing the formal package, because both register the same components. The migration check verifies preserved sessions, credentials, configuration and user patches; keep a backup for your own state. Ordinary same-name replacement, incompatible-update refusal, removal and reinstallation have separate lifecycle checks.
+- **Reproducible distribution steps:** an independent Desktop runtime builds a public candidate, then the exact archive is unpacked and exercised through native Host startup/restart and browser probes. Publication verifies its checksums, version, compatibility and qualification receipt, publishes with the npm `preview` tag, synchronizes the Hub and checks the served public bytes. GitHub assets include the archive, checksum, installation README and release notes. Public availability is established by successful publication and registry verification, not by a local build.
+- **Browser and model workflows:** this version includes the browser and custom-provider work accumulated since 0.7.32. Browser access uses site and Developer grants, document-bound WebMCP discovery, explicit handoff and retained tabs. Desktop previews keep annotation drafts across navigation and permission changes while rejecting expired or replaced documents. Custom services support Chat Completions, Responses and Anthropic Messages, optional images, manual model limits and cancellable discovery/tests. The detailed fixes and boundaries are recorded in the [changelog](../CHANGELOG.md).
+
+Verification: `npm run check` passed on the release implementation (1,067
+unit/component cases, 79.99% full-source line coverage, both TypeScript checks,
+native integration, package checks and 63 eval cases). The subsequent native
+installation gate has a separate six-case archive/receipt test suite, which
+also passed, along with documentation checks and lint. The public 0.7.33
+candidate passed independent Harness 0.2.0-rc.2 Host startup/restart, real Chrome
+screenshot/annotation and permission persistence checks. A fresh profile
+installed that archive through the native package manager, verified its locked
+integrity and booted the installed Host with a resolved DSCODE preset and
+working Hub RPC.
+
+The official macOS application separately installed and enabled the private
+formal archive, and its Hub installed `dsh-theme-plugin@0.3.3` disabled and
+opened official management. A native lifecycle check migrated the old probe
+name and preserved state. Those rendered GUI/migration observations used the
+private 0.7.32 candidate. Public npm publication and the post-publication
+installation check remain pending; the retained local receipts do not prove
+that users can already download this version from the registry.
+
+Unverified paths: real-model task quality, native Computer Use screenshot/input with macOS Accessibility permission, other OS/architecture/runtime combinations, and third-party plugin behavior after enabling. General remote HTTP MCP retains separate runtime compatibility/security work. Scripted model fixtures and browser probes do not establish live model quality. Demo preparation is deferred until distribution is ready.

package/docs/releases/0.7.4.md

@@ -0,0 +1,16 @@
+# DSCODE 0.7.4
+
+This release fixes an approval problem the evaluation exposed: under `danger-full-access` every MCP call needing approval was silently denied, and `dscode exec --approve-all` could not let it through either.
+
+- **MCP calls work again under `danger-full-access`**: automatic review turns every MCP call other than the read-only Chrome methods into one needing approval, regardless of the current permission preset. `danger-full-access` has the `never` approval strategy, and the approval service denies outright before any `approval/request` handler runs, so MCP calls in the TUI were silently denied and the allowance from `dscode exec --approve-all` never got its turn (in the evaluation the denial and the call landed in the same millisecond). A `never` strategy no longer intercepts MCP calls; presets with an `ask` strategy such as `auto` and `ask` still send MCP calls through review or a question as before.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.4
+dscode update 0.7.4
+```
+
+`dscode-0.7.4.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 and the coverage baseline. New here: unit tests that automatic review still requires approval for an MCP call under the `ask` strategy and allows it directly under `never`, with confirmation that the test fails once the fix is removed. An MCP call was not made inside a real `dscode exec --permission danger-full-access --approve-all` session.

package/docs/releases/0.7.5.md

@@ -0,0 +1,18 @@
+# DSCODE 0.7.5
+
+This release makes review work in a non-Git workspace. In the evaluation `/app` was not a Git repository, so the model never received a hint to call review, and the review tool there only returned `no_repository`.
+
+- **A non-Git workspace also gets the review hint and a diff**: before a task's first tool call, dscode snapshots the workspace into a tree inside a shadow bare repository under `DSH_HOME/review-baselines` (the workspace itself is untouched); at review time it snapshots again and diffs against the baseline for the independent review. The model can only change files through tools, so what is captured at that moment is the pre-task state. Such a workspace gets its own hint explaining that the review covers changes since the task began. `path` may narrow the range, while `staged`, `base` and `commit` still need Git.
+- **Snapshot scope and limits**: it skips `.git`, `node_modules`, virtual environments and cache directories, the sensitive files review skips anyway (`.env`, keys and so on) and files over 4 MiB, and the workspace's `.gitignore` applies too; a change to those files is not reviewed. A workspace over 20,000 files or 256 MiB is not snapshotted, and review returns `no_baseline` with a hint not to call it again.
+- **The baseline follows the task**: the baseline is one ref per session and survives a resume; starting a new task in the same session replaces the old baseline. Without a git executable the behaviour is unchanged: no hint is injected and review returns `no_repository`.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.5
+dscode update 0.7.5
+```
+
+`dscode-0.7.5.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 and the coverage baseline. New here: the snapshot diff includes modified and added files, excludes ignored directories/sensitive files/large files, narrows by `path`, errors on a Git scope, reads the baseline back through a new store instance, lets a new task replace the baseline, and returns `no_baseline` over the limits; plus an end-to-end test where the pre-tool-call hook establishes the baseline and the review tool then reviews the change. Whether a model follows the hint and calls review was not confirmed in a real model session.

package/docs/releases/0.7.6.md

@@ -0,0 +1,29 @@
+# DSCODE 0.7.6
+
+This release expands OpenRouter from three DeepSeek models to pi-ai's whole OpenRouter catalogue, and fixes several things that stopped a non-DeepSeek model from working or made it worse: effort hard-coded to the DeepSeek bands, delegation available only under Ultra, and cost and cache-hit rate that could not be computed. The review output ceiling is no longer squeezed so low either.
+
+- **OpenRouter lists the whole catalogue**: the configuration `/provider openrouter` writes no longer lists 3 DeepSeek models but every OpenRouter model in the pi-ai catalogue (366, including Anthropic, OpenAI, Google, Qwen, Kimi, GLM and more), without adding one by id by hand. The three DeepSeek models still use the official off/low/high/max bands and Ultra through `modelOverrides`, while the other models use their own reasoning bands and protocols (Claude goes through `anthropic-messages`). A narrow configuration written by 0.7.3–0.7.5 is replaced automatically when `/model` is opened or the provider is switched; a configuration the user edited is left alone.
+- **`/model` can search**: press `/` or Ctrl+F to start searching, and every word typed has to match a provider or a model name; while searching, `q`, `r` and `g` are only text, Esc exits and clears, and ↑↓ and Enter work as usual.
+- **OpenRouter cost is computed from live prices**: with an OpenRouter key configured, prices are read from OpenRouter's public model list (no key needed) and cached in the data directory for a day, including the cache-write price and the long-prompt tiers; a model without a separate cache read/write price is charged at the input price. A failed read keeps the previous prices, and the DeepSeek models still have a fixed price fallback.
+- **Fix: the cache-hit rate was always `--` on OpenRouter**: pi-ai reports that number only when there was a cache read, and one call without the field made the whole session's rate unknown; a missing value now counts as 0.
+- **Effort follows the model**: the configured default `high` falls back to the model's own default when unsupported, so a model without reasoning (such as qwen3-coder or kimi-k2) no longer errors every turn. Session cards, `/doctor`, memory and review under Ultra request the supported band closest to the wanted one and pass nothing when the model has no bands; the memory configuration accepts every standard band name. `dscode exec --effort` accepts `minimal`, `medium` and `xhigh` and validates them against the model before starting. A child agent's effort text is no longer hard-coded to low/high/max, and `/status` no longer shows xhigh for a non-DeepSeek model.
+- **Delegation at any effort**: `subagent` and `subagent_fork` are no longer available only under Ultra, so a model without a `max` band (and therefore without Ultra) can delegate too. Below Ultra the prompt controls it: do the work yourself by default, delegate only a larger independent part or a wide read-only investigation that would crowd the context, at most one child at a time, at the lowest suitable band the model supports. Ultra keeps its original collaboration policy; `workflow` and `ralph` remain unavailable, and the three-child concurrency cap applies at every effort.
+- **The review output ceiling is loosened**: it no longer caps at 8192 output tokens but uses the model route's default ceiling (256k for DeepSeek, the model's own in the OpenRouter catalogue); the timeout goes from 90 seconds to 10 minutes, and the report handed back to the agent keeps at most 64,000 characters.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.6
+dscode update 0.7.6
+```
+
+`dscode-0.7.6.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 and the coverage baseline. New here:
+- In a real Host, the OpenRouter route lists more than 300 models, the DeepSeek models keep the official bands and GPT-5 uses its own; the narrow configuration from 0.7.3–0.7.5 is read back in the shape the settings service actually returns, confirming it is recognised and replaced.
+- Requests are intercepted before they go out: qwen3-coder carries no reasoning parameters under the default `high`; a below-Ultra request carries `subagent`; `exec --effort medium` is rejected on DeepSeek Flash and lists the available bands.
+- The real Ink `/model` panel is rendered to verify search filtering, `q` not closing the panel while searching, Esc clearing, and Enter selecting.
+- Price parsing is checked against a real snapshot of the OpenRouter model list (442 priced models), with tests for tiered prices, cache writes, the one-day cache and an offline restart.
+- Patch upgrade tests: a dependency carrying the old patch migrates to the new delegation filtering and child-effort text, and applying it again produces no change.
+
+Not done: no non-DeepSeek model was called with a real OpenRouter key; the real effect of the below-Ultra delegation prompt has not been evaluated.

package/docs/releases/0.7.7.md

@@ -0,0 +1,36 @@
+# DSCODE 0.7.7
+
+This release replaces pi-ai with DSCODE's own adapter for OpenRouter and closes the gaps found after 0.7.6: an upstream error returned in the stream was not retried, the actual charge was computed inaccurately, web search could only go through DeepSeek, and session titles and automatic approval often failed on a reasoning model. It also improves the compaction display and thresholds and the `/provider` and `/model` interaction.
+
+- **OpenRouter gets its own adapter**: it calls OpenRouter's chat completions directly, and the model list, context windows, reasoning bands and prices all come from OpenRouter's live `/api/v1/models`, cached in the data directory for a day, so a new model needs no release; the first model query waits at most 10 seconds. DeepSeek, GLM, Kimi and Qwen are adapted and tested, and other tool-calling models work on a best-effort basis. Each model uses its own reasoning bands: DeepSeek V4 keeps the official off/low/high/max, a model supporting max additionally offers Ultra, and reasoning content is passed back verbatim through `reasoning_details`.
+- **Routing is left to OpenRouter**: every request carries `session_id`, so one session stays on one upstream as far as possible and keeps its cache; only providers that support all request parameters and are not fp4-quantised are chosen (Kimi's native INT4 is kept). Qwen gets explicit cache breakpoints on the system message and the latest user message.
+- **Errors follow OpenRouter's error codes**: an upstream error returned in the stream (such as 502) is retried, 429 reads `Retry-After`, 402 is recognised as insufficient credit, and an over-long context triggers a compaction and retry.
+- **Accounting follows the actual charge**: session cost uses the `usage.cost` OpenRouter returns (including BYOK fees and the different upstream prices), falling back to a price-table estimate only when it is unavailable.
+- **Web search follows the provider**: an OpenRouter session searches through OpenRouter's web plugin (Exa), while a DeepSeek session still uses DeepSeek; a user with only an OpenRouter key can search too.
+- **`/openrouter` account panel**: it shows the account balance, the current key's allowance and today's/this week's/this month's spend; with a management key configured it also shows the usage of every API key and the spend of the last 30 days by model and by actual provider. After `/provider openrouter` or `/login openrouter` saves an API key it offers an optional management-key step, validated against OpenRouter before saving and used for reading only. The footer balance reads the account balance and falls back to the key's remaining allowance when the key is refused.
+- **Compaction display and thresholds**: while compaction runs it shows a self-playing Tetris animation and "compacting the context, please wait" (following `/language`). The automatic compaction threshold is banded by the ratio of a model's cache-read price to its input price: below 0.1 it compacts at 90%, below 0.5 at 80%, otherwise at 60%; an unavailable price keeps 80%, and an explicitly configured threshold wins. Switching to a model in `/model` that would trigger a compaction asks for confirmation first.
+- **`/model` searches directly**: typing immediately after opening searches, every character re-ranks with BM25 (model name weighted highest, then id and provider), and the word being typed is matched as a prefix. A search change does not focus, Enter or an arrow key focuses the first result, and Enter while focused selects it; Esc clears the search first and then closes, Tab opens the provider settings, and retry moved to Ctrl+R.
+- **Slash menu**: pressing Enter on `/provider`, `/login` or `/openrouter` in the menu opens the matching panel directly, with no second press.
+- **Titles and automatic approval**: generating a title on OpenRouter uses the lowest reasoning strength the model supports, and the title output ceiling went from 64 to 1024; the automatic-approval self-check now requests low strength and its output ceiling went from 768 to 4096.
+- **Migration**: an OpenRouter configuration an older version wrote under `llm-pi-ai` is cleared automatically and the pi-ai route is no longer loaded; reasoning content in a session from the pi-ai era still passes back.
+
+Exit DSCODE sessions using the same data directory before upgrading:
+
+```sh
+npm install -g @toddzheng024/dscode@0.7.7
+dscode update 0.7.7
+```
+
+`dscode-0.7.7.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, the coverage baseline, eval, integration, TUI and package build. New here:
+- Real OpenRouter key calls to DeepSeek V4 Flash, GLM 5.3 Flash, Kimi K2.6, Qwen 3.8 27B, Muse Spark 1.3 and Muse Spark 1.3 Contributor: tool calls, a continued turn with reasoning content passed back, a cache hit on a repeated prefix, the actual charge, and a title request; GLM reasoning pass-back was verified pinned to Z.AI; plus the error for an invalid model and OpenRouter web search.
+- Real Ink rendering: the compaction animation at various widths, the model-switch confirmation, the `/openrouter` panel and management-key input, `/model` direct search and its focus rules, and the slash-menu Enter.
+- Real account reads: an ordinary key reads the account balance; an ordinary key is refused by management-key validation.
+- Offline login verification: in a real Host the OpenRouter route lists models from the cached model list with the correct bands, and the request body is intercepted before the network call.
+
+Not done / known limits:
+- The explicit cache breakpoints for Alibaba-hosted Qwen could not be measured (the account's zero-data-retention setting blocks those endpoints).
+- All-key usage and 30-day spend under a management key were verified with simulated data only, with no real management key.
+- Claude, GPT and Gemini are best-effort support, and Anthropic models no longer get automatic cache breakpoints the way pi-ai gave them.
+- A cache hit depends on the upstream provider OpenRouter picks for the session.

package/docs/releases/0.7.8.md

@@ -0,0 +1,14 @@
+# DSCODE 0.7.8
+
+This release fixes the experience of a long task reviewing repeatedly and expanding the work after its checks already passed, and tunes local session data handling.
+
+- Automatic code review is capped at two rounds per user task, 90 seconds per round, 8,192 output tokens per model request, at low reasoning effort. Changing path, failing, or resuming a session does not hand back the full budget; the second round focuses on the issues already fixed and their direct regressions. An unfinished review is never reported as passing, and the user can still run `/review` by hand.
+- The default agent rules ask for a statement before starting, an update on a key discovery, and, in a long task, ordinary prose progress roughly every minute. Non-verbose mode shows these too; a blocking tool can delay an update, and whether the model follows this still needs verification on real tasks.
+- State the task scope and acceptance criteria, verify a review finding before acting on it, and run the affected checks after a fix. Once the checks pass, move to delivery instead of expanding into optional optimization again.
+- Session metrics gained a bounded incremental read cache and a footer computation cache, and handle a final line without a newline correctly. Session cards reuse the content summary, and the memory job avoids large array spreads.
+- The mailbox gained historical retention and per-recipient event cleanup while keeping undelivered messages; tests use their own small limits instead of writing 50,000 rows.
+- OpenRouter empty SSE data is filtered and a corrupt cache re-read is throttled; plus build import-path validation, decoupling of the shared patch helpers, backoff for the macOS stdin probe and migration of older patches.
+
+This release does not upgrade the upstream DSH dependencies.
+
+Verification: `npm run check` passes (226 unit tests, 44 evaluation tests; 80.08% complete-source coverage; integration, the real Ink UI and the package checks pass). How a real model performs at progress communication and task convergence still needs validation in real use.

package/docs/releases/0.7.9.md

@@ -0,0 +1,15 @@
+# DSCODE 0.7.9
+
+This release makes `dscode update` update a whole installation in one step: a tar installation gains in-place self-upgrade, and the npm/Hub launcher replaces its own binary; it also adopts ESLint 10 and fixes a batch of problems in the review allowlist and error handling.
+
+- A tar installation gains `dscode update [exact version]`: it downloads the tarball from GitHub Releases and verifies it against the publisher's sha256 digest (a release without a digest is refused), migrates `.runtime`, `.env` and the local config (a newer default file shipped by the release is not overwritten by the old copy), and swaps the directory in place — the `dscode` command path does not change and needs no relinking; the old installation is kept as a sibling backup directory to switch back to or discard by hand. A source checkout refuses and asks for a git pull; a running session refuses the update, and the check is repeated before the directory swap.
+- For an npm/Hub installation, `dscode update` first replaces the global launcher itself with npm at the target version and only then moves the profile to the same version, so a failure in either step leaves no half-updated state; with no version it asks npm for the latest launcher and updates both when there is a newer one, falling back to the current launcher's recommended version when the registry is unreachable, never tracking latest implicitly.
+- The repository adopts `npm run lint` (ESLint 10 flat config), included in `npm run check`; template files serialised into the TUI such as `*-panel.mjs` are exempted the way they are bound.
+- The automatic-review escalation allowlist is tightened: `sysctl -w`, assignment-form keys, and `hostname`/`date` with an argument are no longer granted automatically, so a state-mutating diagnostic goes back to a human confirmation.
+- When code review collects untracked files, a file that vanished or is unreadable counts as omitted instead of failing the whole review; a corrupt line in the review audit file is skipped instead of breaking every later approval.
+- A failed session-bridge recovery now fails closed for that step only and is retried by the next step, instead of permanently wedging that session's reception.
+- The email store and the verification scripts no longer throw inside `finally` (a cleanup failure cannot hide a successful result or the original error); the checks report an integrity violation and a suite failure together; six `catch` blocks gained an error cause.
+
+This release does not upgrade the upstream DSH dependencies.
+
+Verification: `npm run check` passes (243 unit tests, 44 evaluation tests; 80.29% complete-source coverage; integration, the real Ink UI and the package checks pass). Tar self-upgrade ships with the package from this release; an older tar installation still needs one manual directory swap. The session race window during an update is narrowed to seconds but not eliminated (no kernel lock is shared with a running session).