dexterm-cli 0.1.2 → 0.1.4

package/dist/packages/mcp/assets/kb/docs/docs-voice-the-voice-neural-by-default.md

@@ -0,0 +1,48 @@
+---
+id: docs-voice-the-voice-neural-by-default
+title: Jarvis voice mode › The voice: neural by default
+kind: docs
+page: voice
+page_title: Jarvis voice mode
+heading: The voice: neural by default
+anchor: the-voice-neural-by-default
+url: https://dexterm.xyz/docs/voice#the-voice-neural-by-default
+tags:
+  - docs
+  - voice
+  - neural
+  - default
+  - jarvis
+  - mode
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/voice.md
+date: 2026-10-16
+---
+
+dexterm speaks with a **neural British voice** (Piper, `en_GB-alan-medium`) — the one chosen as the default. It is free, local and keyless, and sounds markedly more natural than the built-in system voices. It is the default speaking voice everywhere it is installed, on macOS as well as Linux, with the system `say` voice as the fallback.
+
+On macOS, run `dexterm voice setup` once to install it. The prebuilt macOS Piper binary from upstream is broken (it needs a system library it does not bundle), so dexterm instead builds its own private Python environment under `~/.dexterm/piper/` and installs Piper into it, then downloads the ~61 MB voice from the official source and checks it against a pinned checksum. It asks before it does any of this, needs Python 3.9+ (the doctor prints the exact install line if it is missing), runs fully offline afterwards, and ships no key. `dexterm voice uninstall` removes the runtime and keeps the downloaded voice model (add `--purge-model` to delete that too); the fallback `say` voice takes over again. Off macOS, install the prebuilt Piper binary and run `dexterm voice download piper-voice`.
+
+```sh
+$ dexterm voice setup                    # macOS: private runtime + checksum-verified voice (asks first)
+$ dexterm voice status                   # which engines and models this machine has
+$ dexterm voice uninstall                # remove the runtime (add --purge-model to drop the voice too)
+```
+
+Once Piper is installed it is used automatically — no config change. The model is kept pre-warmed while voice is on, so the first word of a reply starts in about a fifth of a second. `voice.rate` still maps to its speaking speed; a `voice.pitch` setting does not apply to Piper (its pitch is fixed by the model) and is ignored.
+
+**The fallback chain.** dexterm picks the first engine that can speak on this machine, and never a novelty voice or the machine's own system voice:
+
+| platform | 1st | 2nd | then |
+| --- | --- | --- | --- |
+| macOS | Piper `en_GB-alan-medium` (after `dexterm voice setup`) | `say` with a deep British male voice (Eddy, then Daniel, then the next installed one on that list) | text only: the analyst still answers on screen |
+| Linux (beta) | Piper (prebuilt binary + `dexterm voice download piper-voice`) | `espeak-ng` with a British male voice | text only |
+
+Set `DEXTERM_VOICE_TTS` to `piper`, `say`, `espeak` or `none` to pin one engine. An explicit `say` never switches to Piper.
+
+**Speed and delivery.** `<` slows the spoken reply and `>` speeds it up, 15 words a minute per press between 120 and 320 (the default is 205). The new rate is saved to `voice.rate` in `config.json`. Numbers are read the way a trader says them: a sub-cent price is spoken as the coin's market cap when the line includes one, and otherwise as "a tiny price". Years and SOL amounts are read as written. On the screener, "this one", "this coin" or "it" means the highlighted row.

package/dist/packages/mcp/assets/kb/docs/docs-voice-what-it-can-never-do.md

@@ -0,0 +1,27 @@
+---
+id: docs-voice-what-it-can-never-do
+title: Jarvis voice mode › What it can never do
+kind: docs
+page: voice
+page_title: Jarvis voice mode
+heading: What it can never do
+anchor: what-it-can-never-do
+url: https://dexterm.xyz/docs/voice#what-it-can-never-do
+tags:
+  - docs
+  - voice
+  - can
+  - never
+  - jarvis
+  - mode
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/voice.md
+date: 2026-10-16
+---
+
+Voice creates proposals only. The ticket it opens is PAPER, in its editing phase, and the keypress gate stands: your `⏎` then `y` (plus the typed-back size above the threshold) is the only way to a fill. Spoken "confirm", "send it", "y", "sign it", "go live", "arm it", "raise my cap", "panic" and "/wallet …" are routed as questions or ignored; they cannot flip the ticket to LIVE, arm a plan, touch the signer's caps, run a wallet command or press anything. The router's output is a closed set of decision kinds, a guard rejects any decision that carries a mode, live, arm, caps, confirm, sign or send field, and an in-app test drives the real key loop with the executor, the confirm paths, the LIVE flip and the wallet commands booby-trapped: twenty-one hostile utterances, zero touches.

package/dist/packages/mcp/assets/kb/docs/docs-voice-what-you-can-say.md

@@ -0,0 +1,38 @@
+---
+id: docs-voice-what-you-can-say
+title: Jarvis voice mode › What you can say
+kind: docs
+page: voice
+page_title: Jarvis voice mode
+heading: What you can say
+anchor: what-you-can-say
+url: https://dexterm.xyz/docs/voice#what-you-can-say
+tags:
+  - docs
+  - voice
+  - can
+  - say
+  - jarvis
+  - mode
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/voice.md
+date: 2026-10-16
+---
+
+| you say | what happens | path |
+|---|---|---|
+| "show me the runners", "go to new pairs", "open my watchlist", "positions" | switches the screen | instant, no model |
+| "open bonk", "pull up wif" | opens that coin's token screen | instant |
+| "filter liquidity over 50k", "only show age under 10 minutes" | sets the screener filter | instant |
+| "watch this one", "add bonk to my watchlist" | adds to the watchlist | instant |
+| "show the chart", "close the chart" | opens or closes the chart popup for the open coin through the popup host | instant |
+| "buy bonk", "sell half of wif", "ape into this one" | opens a **PAPER ticket in its editing phase** for the spoken coin and says so | instant |
+| "is this a rug?", "what do you think about wif", "tell me about the holders" | asks the analyst; the first two sentences of the answer are read aloud | Claude |
+| "buy this if it dips to 300k, sell half at 600k, and leave a moon bag", "buy bonk if it drops to 250k, stop at 150k" | drafts an **order-plan proposal** (entry trigger, take-profit ladder, moon bag, stop) for the named or highlighted coin; it is inert until you arm it with a held keypress on the `O` screen or `dexterm plan arm` | instant, no model |
+
+`m` mutes the replies, `,` cycles the macOS `say` voice (the fallback; Piper itself has one fixed voice), `<` / `>` make it slower or faster, `esc` stops a reply or cancels the mic. Only the keyboard changes the voice: the analyst can explain these keys but has no action that sets them. Any other key pressed while the mic is live closes it first and then does its normal job, and the mic auto-closes after 15 s if you walk away. On the ticket screen the voice keys are off, so nothing spoken can reach the confirm gate.

package/dist/packages/mcp/assets/kb/docs/docs-voice.md

@@ -0,0 +1,25 @@
+---
+id: docs-voice
+title: Jarvis voice mode
+kind: docs
+page: voice
+page_title: Jarvis voice mode
+url: https://dexterm.xyz/docs/voice
+tags:
+  - docs
+  - voice
+  - jarvis
+  - mode
+confidence: high
+owner: maintainers
+origin: docs-generated
+reviewed_by: generated@2026-10-16
+generated_from: dexterm/site content/docs (task-1420)
+sources:
+  - site/content/docs/voice.md
+date: 2026-10-16
+---
+
+Push-to-talk on v, an instant local command path, Claude for analysis, spoken replies, popups. Voice only ever proposes; it can never confirm, sign, flip LIVE or raise a cap.
+
+`v` is push-to-talk. Press it once and the mic opens (a red `● LISTENING` badge sits on the band under the header the whole time it is live); say what you want; press `v` again to send. The first press enables voice for the run and asks macOS for Microphone and Speech permission. Everything is free and local: speech-out is the neural Piper voice once it is set up (otherwise the built-in `say`), speech-in is on-device Apple Speech (compiled once with `swiftc`) or a local whisper.cpp `base.en` model, and the only model in the loop is your own `claude` login, for analysis questions. No paid speech API exists in the code, no key is read, nothing is recorded to disk.

package/dist/packages/mcp/src/app-help.js

@@ -0,0 +1,258 @@
+// @dexterm/mcp — the app-help knowledge base (task-1413).
+//
+// A SECOND bundled KB set, separate from the 17 memecoin-risk entries, that teaches an agent how dexterm
+// ITSELF works: what each screen shows, the exact key for a task, the CLI subcommand/flag, and the MCP
+// tools. The entries in `assets/kb/app-help/*.md` are GENERATED from the app's own keymap / help overlay /
+// MCP tool list / CLI by `packages/cli/src/app-help-gen.ts` (committed, run in tests), so they cannot drift
+// from the real app. This module only LOADS and SEARCHES them — it is read-only and dependency-free.
+//
+// It is kept out of the main KB store on purpose: the memecoin KB's "exactly 17 bundled entries" invariant
+// stays true, and a "how do I …" search hits app-help first without the two sets diluting each other.
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadBundled } from "./user-content.js";
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+/** The shipped app-help KB directory (read-only; generated). */
+export const APP_HELP_DIR = path.resolve(HERE, '..', 'assets', 'kb', 'app-help');
+function list(v) {
+    return Array.isArray(v) ? v.map(String) : typeof v === 'string' && v ? [v] : [];
+}
+function toAppHelp(e) {
+    return {
+        id: e.id,
+        title: String(e.meta.title ?? e.id),
+        screen: String(e.meta.screen ?? 'all'),
+        tags: list(e.meta.tags),
+        keys: list(e.meta.keys),
+        actions: list(e.meta.actions),
+        commands: list(e.meta.commands),
+        flags: list(e.meta.flags),
+        tools: list(e.meta.tools),
+        feature: String(e.meta.feature ?? ''),
+        body: e.body,
+        bytes: e.bytes,
+    };
+}
+/** Load every app-help entry (bundled-only; deterministic order by id). */
+export function loadAppHelp(dir = APP_HELP_DIR) {
+    const entries = loadBundled([{ dir, layout: 'flat' }]).map(toAppHelp);
+    entries.sort((a, b) => a.id.localeCompare(b.id));
+    return entries;
+}
+// Generic words that carry no retrieval signal in a "how do I …" question — dropped before scoring so a
+// short noise word ('to', 'my') can't substring-match an unrelated entry and outrank the real one.
+const STOP = new Set([
+    'how', 'do', 'does', 'did', 'the', 'a', 'an', 'to', 'my', 'me', 'i', 'is', 'it', 'its', 'of', 'in', 'on',
+    'at', 'by', 'or', 'and', 'for', 'with', 'this', 'that', 'these', 'those', 'your', 'you', 'can', 'what',
+    'which', 'where', 'when', 'who', 'am', 'are', 'be', 'get', 'got', 'use', 'using', 'make', 'want', 'need',
+    'from', 'into', 'show', 'see', 'tell', 'about', 'some', 'any', 'all', 'up', 'out', 'off', 'on',
+    // generic action verbs — they appear in many entry titles ("Change…", "Switch…") and carry no signal.
+    'change', 'switch', 'set', 'setting', 'turn', 'open', 'close', 'enable', 'disable', 'add', 'remove',
+    'start', 'stop', 'run', 'cycle', 'pick', 'choose', 'save', 'view', 'check',
+]);
+function tokenise(s) {
+    return (s.toLowerCase().match(/[a-z0-9][a-z0-9-]+/g) ?? []).filter((t) => !STOP.has(t));
+}
+/** A short, deterministic how-to synonym map so natural phrasings land on the right entry. */
+const QUERY_SYNONYMS = {
+    paste: 'open', ca: 'open', 'contract-address': 'open', address: 'open', link: 'open',
+    screenshot: 'export', save: 'export', png: 'export', report: 'export', share: 'export',
+    speed: 'rate', faster: 'rate', slower: 'rate', wpm: 'rate',
+    speak: 'voice', talk: 'voice', jarvis: 'voice', mic: 'voice', microphone: 'voice',
+    notify: 'alert', notification: 'alerts', telegram: 'alerts', discord: 'alerts',
+    filtering: 'filter', query: 'filter',
+    marketcap: 'mcap', 'market-cap': 'mcap', cap: 'mcap',
+    honeypot: 'rug', safe: 'rug', scam: 'rug',
+    fake: 'larp', legit: 'larp', real: 'larp', website: 'larp', 'rug-pull': 'rug',
+    agent: 'mcp', agents: 'mcp', bot: 'mcp', claude: 'analyst',
+    helius: 'key', rpc: 'key', holders: 'key',
+    layout: 'workspace', workspaces: 'workspace',
+    keybind: 'keymap', keybinding: 'keymap', rebind: 'keymap', shortcut: 'keymap',
+    theme: 'theme', colour: 'theme', color: 'theme',
+    buy: 'paper', sell: 'paper', trade: 'paper', ticket: 'paper',
+    upgrade: 'update',
+    chart: 'popup', candles: 'popup',
+    bubbles: 'bubble', cluster: 'bubble', clusters: 'bubble',
+    scanner: 'scan', watcher: 'scan',
+    copy: 'follow', mirror: 'follow', unfollow: 'follow',
+};
+function expand(terms) {
+    const out = new Set(terms);
+    for (const t of terms) {
+        const s = QUERY_SYNONYMS[t];
+        if (s)
+            out.add(s);
+    }
+    return [...out];
+}
+/** Raw word tokens of a haystack (no stopword filtering), for exact word-boundary matching. */
+function words(s) {
+    return s.toLowerCase().match(/[a-z0-9][a-z0-9-]+/g) ?? [];
+}
+/**
+ * Deterministic keyword retrieval over the app-help set (no model). Matches on WORD BOUNDARIES (not
+ * substrings) so "screener" does not match the tag "dexscreener" and "token" does not match a tool name
+ * like "open_token". title/tags/screen/feature score strongest; the body is the weak tail.
+ */
+export function searchAppHelp(query, limit = 5, entries = loadAppHelp()) {
+    const terms = expand(tokenise(query));
+    // A query whose only meaningful word is a screen name ("what does the screener show") is a request for
+    // that screen's overview, not for a topic that happens to run there.
+    const soleScreen = terms.length === 1 ? terms[0] : null;
+    // An explicit "... screen ..." question ("what does the kol screen show") is a request for that screen's
+    // overview even when other words survive; boost the matching overview so it beats a topic that shares the name.
+    const asksScreen = words(query).includes('screen');
+    const scored = entries.map((e) => {
+        const overview = e.id.startsWith('screen-');
+        // Screen field matches only for an overview entry; on a topic it is just where the action happens.
+        const strong = new Set(words(`${e.title} ${e.tags.join(' ')} ${e.feature}${overview ? ' ' + e.screen : ''}`));
+        // An overview's body is the enumerated key list — it names every action word, so it is NOT scored
+        // (else "sort the screener" would match the screener overview's `s — sort` line over the sort topic).
+        const bodyWords = overview ? [] : words(e.body);
+        let score = 0;
+        for (const t of terms) {
+            if (strong.has(t))
+                score += 4;
+            let n = 0;
+            for (const w of bodyWords)
+                if (w === t)
+                    n++;
+            score += Math.min(n, 3);
+        }
+        if (overview && soleScreen && soleScreen === e.screen)
+            score += 6;
+        if (overview && asksScreen && terms.includes(e.screen))
+            score += 3;
+        return { e, score };
+    }).filter((x) => x.score > 0)
+        .sort((a, b) => (b.score - a.score) || a.e.id.localeCompare(b.e.id))
+        .slice(0, limit);
+    return scored.map(({ e, score }) => ({ ...e, score }));
+}
+/** Fetch one app-help entry by id. */
+export function getAppHelp(id, entries = loadAppHelp()) {
+    return entries.find((e) => e.id === id) ?? null;
+}
+// ---------------------------------------------------------------------------------------- docs (task-1420)
+// A THIRD bundled set: every page of the site docs (dexterm.xyz/docs), chunked by heading. GENERATED from the
+// site by `packages/cli/src/docs-kb-gen.ts` (committed; a regenerate-and-diff test runs when the site checkout
+// is present). The app-help entries stay the authority for an exact key or command; a docs entry carries the
+// explanation and the URL to cite, and NEVER structured keys/commands/flags/tools. Its text is reference DATA:
+// the app_help tool hands it to a model firewalled (`<untrusted kind="docs">`), so an instruction written into
+// a docs page reads as quoted text, never as an order.
+/** The shipped docs KB directory (read-only; generated from the site docs). */
+export const DOCS_KB_DIR = path.resolve(HERE, '..', 'assets', 'kb', 'docs');
+function toDocs(e) {
+    return {
+        id: e.id,
+        title: String(e.meta.title ?? e.id),
+        page: String(e.meta.page ?? ''),
+        pageTitle: String(e.meta.page_title ?? ''),
+        heading: String(e.meta.heading ?? ''),
+        anchor: String(e.meta.anchor ?? ''),
+        url: String(e.meta.url ?? ''),
+        tags: list(e.meta.tags),
+        body: e.body,
+        bytes: e.bytes,
+    };
+}
+/** Load every docs entry (bundled-only; deterministic order by id). */
+export function loadDocsKb(dir = DOCS_KB_DIR) {
+    const entries = loadBundled([{ dir, layout: 'flat' }]).map(toDocs);
+    entries.sort((a, b) => a.id.localeCompare(b.id));
+    return entries;
+}
+/**
+ * A light, deterministic stemmer for the docs set only (prose, unlike the app-help titles): "answers"/"answer",
+ * "cached"/"cache", "clarifies"/"clarify", "streaming"/"stream" meet. Short words are left alone.
+ */
+function stem(w) {
+    if (w.length < 4 || w.includes('-'))
+        return w;
+    let s = w;
+    if (s.endsWith('ies') && s.length > 4)
+        s = s.slice(0, -3) + 'y';
+    else if (s.endsWith('ing') && s.length > 5)
+        s = s.slice(0, -3);
+    else if (s.endsWith('ed') && s.length > 4)
+        s = s.slice(0, -2);
+    else if (/(?:ss|sh|ch|x|z)es$/.test(s))
+        s = s.slice(0, -2);
+    else if (s.endsWith('s') && !s.endsWith('ss'))
+        s = s.slice(0, -1);
+    if (s.endsWith('e') && s.length > 3)
+        s = s.slice(0, -1);
+    return s;
+}
+/**
+ * Deterministic keyword retrieval over the docs set (no model), same word-boundary matching as app-help.
+ * The section heading and tags score strongest, the page title less (every section of a page shares it),
+ * the body is the weak tail.
+ */
+export function searchDocs(query, limit = 5, entries = loadDocsKb()) {
+    const terms = [...new Set(expand(tokenise(query)).map(stem))];
+    const scored = entries.map((e) => {
+        const strong = new Set(words(`${e.heading} ${e.tags.filter((t) => t !== 'docs').join(' ')}`).map(stem));
+        const page = new Set(words(`${e.pageTitle} ${e.page}`).map(stem));
+        const bodyWords = words(e.body).map(stem);
+        let score = 0;
+        for (const t of terms) {
+            if (strong.has(t))
+                score += 4;
+            else if (page.has(t))
+                score += 2;
+            let n = 0;
+            for (const w of bodyWords)
+                if (w === t)
+                    n++;
+            score += Math.min(n, 3);
+        }
+        // A question that names a section's own heading words is about that section: +3 per heading word
+        // matched (+2 more when it names all of them), so "what is redacted in the spectator view" lands on "What is redacted",
+        // not on the page's other sections that merely share the page title.
+        const head = new Set(tokenise(e.heading).map(stem));
+        let hit = 0;
+        for (const w of head)
+            if (terms.includes(w))
+                hit++;
+        if (hit >= 1 && head.size > 0)
+            score += 3 * hit + (hit === head.size ? 2 : 0);
+        return { e, score };
+    }).filter((x) => x.score > 0)
+        .sort((a, b) => (b.score - a.score) || a.e.id.localeCompare(b.e.id))
+        .slice(0, limit);
+    return scored.map(({ e, score }) => ({ ...e, score }));
+}
+/** Fetch one docs entry by id. */
+export function getDocs(id, entries = loadDocsKb()) {
+    return entries.find((e) => e.id === id) ?? null;
+}
+/** Words that make a question about an exact key or command: app-help answers it. */
+const KEY_OR_COMMAND = /\b(?:key|keys|keybind\w*|press|pressing|shortcut|shortcuts|hotkey|hotkeys|command|commands|subcommand|subcommands|flag|flags|cli)\b/i;
+/** "how do I …" / "how to …": a how-to, answered by an app-help topic. */
+const HOW_TO = /^\s*how\s+(?:do|can|could|would|should)\s+(?:i|you|we)\b|^\s*how\s+to\b/i;
+/** A conceptual question opens with a question word ("what is …", "does it …", "how does …", "how long …"). */
+const CONCEPT = /^\s*(?:what|whats|what's|why|is|are|does|do|did|can|could|will|would|should|where|when|which|who|how)\b/i;
+/** About a screen ("what does the token screen show") or the coin on it ("is this coin a rug"): an app-help topic/tool. */
+const APP_SUBJECT = /\b(?:screen|screener)\b|\bthis\s+(?:[a-z-]+\s+){0,2}(?:coin|token|project)\b/i;
+/** The question's shape: 'key' (exact key/command, a how-to, an imperative, a screen/this-coin question) or 'concept'. */
+export function helpIntent(query) {
+    if (KEY_OR_COMMAND.test(query) || HOW_TO.test(query) || APP_SUBJECT.test(query))
+        return 'key';
+    return CONCEPT.test(query) ? 'concept' : 'key';
+}
+/**
+ * The analyst's help search (task-1420): app-help AND the docs, merged by the question's shape.
+ *  - a key/command question, a how-to or an imperative ("export the view", "how do I sort"): app-help ranks
+ *    first (it carries the exact key/command), the docs after it;
+ *  - a conceptual question ("what is redacted in the spectator view", "does voice work on linux"): the docs rank
+ *    first (nothing ranks above them), the app-help after.
+ * Either way the answer keeps both sets in view: up to 3 hits of the leading set, then up to 2 of the other,
+ * then the rest. A set with no hits simply yields to the other (a docs-only answer beats no answer).
+ */
+export function searchHelp(query, limit = 5, sets = {}) {
+    const app = searchAppHelp(query, limit, sets.appHelp ?? loadAppHelp()).map((e) => ({ ...e, origin: 'app-help' }));
+    const docs = searchDocs(query, limit, sets.docs ?? loadDocsKb()).map((e) => ({ ...e, origin: 'docs' }));
+    const [lead, other] = helpIntent(query) === 'concept' ? [docs, app] : [app, docs];
+    return [...lead.slice(0, 3), ...other.slice(0, 2), ...lead.slice(3), ...other.slice(2)].slice(0, limit);
+}

package/dist/packages/mcp/src/firewall.js

@@ -1,7 +1,7 @@
 // Prompt firewall (CL-06), spec'd in SPEC §5.3. Kept tiny and total. Every untrusted string — token text,
 // web pages, RugCheck risks, and (task-1377) user- or pack-edited KB entries and skills — passes through
-// here before a model sees it.
-export const LIMITS = { name: 64, symbol: 16, description: 512, risk: 160, kb: 4000, page: 1600, link: 40, skill: 8000 };
+// here before a model sees it. (task-1420) The generated docs KB sections pass through as kind `docs`.
+export const LIMITS = { name: 64, symbol: 16, description: 512, risk: 160, kb: 4000, page: 1600, link: 40, skill: 8000, docs: 6000 };
 export function firewall(text, source, kind = 'description', opts = {}) {
     if (text === null || text === undefined)
         return null;

package/dist/packages/mcp/src/index.js

@@ -1,9 +1,13 @@
 // @dexterm/mcp — read-only MCP server over stdio (SPEC §5, D-09 / task-1302).
 // Every tool is read-only and schema-described; nothing in this package may build,
 // sign or send a transaction (SPEC §5.2, §6.3).
-export { runStdioServer, selfTest, McpTools, TOOLS, READ_ONLY_TOOLS, firewall, listPrompts, getPrompt, resourceList, resourceRead, overlayCounts, userSkillPreamble, BUNDLED_KB_DIR, BUNDLED_SKILLS_DIR } from "./server.js";
+export { runStdioServer, selfTest, McpTools, TOOLS, READ_ONLY_TOOLS, appHelpAnswer, firewall, listPrompts, getPrompt, resourceList, resourceRead, overlayCounts, userSkillPreamble, BUNDLED_KB_DIR, BUNDLED_SKILLS_DIR } from "./server.js";
 export { OverlayStore, mergeOverlay, loadBundled, checkKb, checkSkill, moneyToolMentions, isMoneyToolName, parseFrontmatter, dextermHome, userKbDir, userSkillsDir, userDir, contentJournalPath, journalContent, writeOverlayFile, resetOverlayFile, templateFor, KB_LIMITS, SKILL_LIMITS, KB_ID, SKILL_NAME, KB_RULE, MONEY_TOOLS, } from "./user-content.js";
 export { buildDossier } from "./dossier.js";
+// task-1406 + task-1421: the spectator sink the tool-call path writes to when a spectator surface is open
+// (via DEXTERM_SPECTATOR_FILE, or the ~/.dexterm rendezvous an external `dexterm mcp` client uses).
+export { recordForToolCall, maxAgeSec, fileSpectatorSinkFromEnv, resolveSpectatorSink, rendezvousPath, MCP_SPECTATOR_RENDEZVOUS, } from "./spectator-sink.js";
+export { loadAppHelp, searchAppHelp, getAppHelp, APP_HELP_DIR, loadDocsKb, searchDocs, getDocs, searchHelp, DOCS_KB_DIR, helpIntent } from "./app-help.js";
 /** Tool names served in v1 (SPEC §5.2 core + the task-1293 KB/case tools + the task-1314 dossier). */
 export const PLANNED_TOOLS = [
     'screen_state',