@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/channel/side-prompts.js

@@ -0,0 +1,127 @@
+/**
+ * The backend-neutral prompt contracts of the TUI's side calls (`/btw`,
+ * `/recap`): what one tool-less, single-answer auxiliary call is asked, and
+ * how a recap answer is read back. Every backend's side call uses the same
+ * words: DSH sends them over its own derived history (`dsh-adapter/
+ * sideQuestion.ts`, `recap.ts`), Claude over a throwaway fork of the
+ * conversation (`backends/claude/side-query.ts`).
+ *
+ * Pure text: no I/O, no vendor types.
+ */
+/**
+ * Describe the auxiliary call's scope: one answer from existing context,
+ * with no tools, follow-up actions, or interruption of the main session.
+ * `running` names the main task's in-flight work, one line each (the
+ * caller formats them), when the context the call sees ends mid-step.
+ */
+export function sideQuestionPrompt(question, running = []) {
+    const pending = running.length === 0 ? '' : `
+The main task is still executing these tool calls; their results are not available yet:
+${running.map(line => `- ${line}`).join('\n')}`;
+    return `<side-question-context>
+Give one concise answer to the question below using the conversation already provided.
+This auxiliary call runs alongside the main session. The main task continues independently;
+do not describe it as interrupted, resumed, or as work performed by this call.
+No tools are available here: do not claim to inspect files, execute commands, browse,
+or carry out future actions. There will be no follow-up turn for this call.
+When the available context is insufficient, state what is unknown without promising research.${pending}
+</side-question-context>
+
+${question}`;
+}
+/**
+ * Carry the recent turns of a side thread into the next single-turn ask:
+ * the pairs travel as explicit quoted context inside the question payload,
+ * so every backend's one-shot side call keeps its own contract unchanged
+ * (the wrapper still sees "one question, one answer, no tools"). The result
+ * is what the caller passes to `sideQuery.ask` as the question, not a
+ * second conversation: nothing here writes a session record anywhere.
+ *
+ * `omittedOlder` is the count of completed pairs the budget dropped from
+ * the front of the thread (turn-window or character budget); the note lets
+ * the model know earlier turns existed instead of silently forgetting.
+ */
+export function sideThreadQuestion(question, prior = [], omittedOlder = 0) {
+    if (prior.length === 0 && omittedOlder === 0)
+        return question;
+    const omitted = omittedOlder > 0
+        ? `
+${omittedOlder} earlier pair(s) of this thread are omitted here to stay within the context budget.`
+        : '';
+    const pairs = prior
+        .map((turn, index) => `<side-thread-pair n="${index + 1}">
+Q: ${turn.question}
+A: ${turn.answer}
+</side-thread-pair>`)
+        .join('\n');
+    return `<side-thread-context>
+The quoted pairs below are the recent history of this side thread: quick
+questions the user asked alongside the main session, with the answers given
+at the time. Treat them as shared context for the new question at the end.
+They are not turns of the main conversation and carry no tool results.${omitted}
+</side-thread-context>
+
+${pairs}
+
+${question}`;
+}
+/** The recap answer contract (one JSON object: title + one-line summary). */
+const RECAP_CONTRACT = `Use the user's language and describe the work and its current outcome accurately.
+Return one JSON object with two string fields:
+- "title": a descriptive title of about 2-6 words.
+- "summary": one line of about 10-20 words covering the most recent progress.
+Do not include Markdown fences or any text outside the JSON object.`;
+/**
+ * Wrap a recent-activity excerpt with the single-response, JSON-only recap
+ * contract (a call that does not see the conversation itself).
+ */
+export function wrapRecapPrompt(activity) {
+    return `Create a compact session recap from the activity excerpt below.
+${RECAP_CONTRACT}
+
+Activity excerpt:
+${activity}`;
+}
+/**
+ * The recap request for a call that runs over the conversation itself (a
+ * fork of it): the same contract, about the conversation so far, with an
+ * emphasis on its recent part.
+ */
+export function conversationRecapPrompt() {
+    return `<side-question-context>
+This auxiliary call runs alongside the main session; no tools are available and there is no follow-up turn.
+</side-question-context>
+
+Create a compact session recap of the conversation so far, focused on its most recent activity.
+${RECAP_CONTRACT}`;
+}
+/**
+ * Parse the model's recap response: extract the JSON object (tolerating
+ * stray prose around it); on failure the whole text becomes the summary
+ * and no title is proposed.
+ */
+export function parseRecapResponse(raw) {
+    const start = raw.indexOf('{');
+    const end = raw.lastIndexOf('}');
+    if (start !== -1 && end > start) {
+        try {
+            const parsed = JSON.parse(raw.slice(start, end + 1));
+            if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                const record = parsed;
+                const summary = typeof record['summary'] === 'string' && record['summary'].trim() !== ''
+                    ? record['summary'].trim()
+                    : undefined;
+                const title = typeof record['title'] === 'string' && record['title'].trim() !== ''
+                    ? record['title'].trim()
+                    : undefined;
+                if (summary !== undefined) {
+                    return title === undefined ? { summary } : { summary, title };
+                }
+            }
+        }
+        catch {
+            // Fall through to the raw-text fallback below.
+        }
+    }
+    return { summary: raw.trim() };
+}

package/lib/types/channel/transcript.d.ts

@@ -0,0 +1,17 @@
+/** Backend-neutral transcript limits and text helpers shared by the projector,
+ *  the fold pass and the local-output paths. */
+export declare const ARGS_PREVIEW_LIMIT = 160;
+export declare const RESULT_PREVIEW_LIMIT = 240;
+/** Local `!`-command output cap (mirrors the result preview limit). */
+export declare const LOCAL_OUTPUT_LIMIT = 240;
+/**
+ * In-memory transcript window cap. Older rows beyond this count are folded:
+ * their full-text fields (assistant/reasoning text, tool args/results) are
+ * dropped and only the preview/status metadata kept, so a long merge/deploy
+ * turn cannot grow the TUI's RAM without bound. The session log still holds
+ * everything (`/export` reads it, `/resume` replays it); the
+ * folded row keeps its kind/id so scrolling and selection stay stable.
+ */
+export declare const MAX_ROWS = 600;
+export declare function preview(text: string, limit: number): string;
+//# sourceMappingURL=transcript.d.ts.map

package/lib/types/channel/transcript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcript.d.ts","sourceRoot":"","sources":["../../../src/channel/transcript.ts"],"names":[],"mappings":"AAAA;gDACgD;AAEhD,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,uEAAuE;AACvE,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,MAAM,CAAA;AAE3B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG3D"}

package/lib/types/channel/transcript.js

@@ -0,0 +1,19 @@
+/** Backend-neutral transcript limits and text helpers shared by the projector,
+ *  the fold pass and the local-output paths. */
+export const ARGS_PREVIEW_LIMIT = 160;
+export const RESULT_PREVIEW_LIMIT = 240;
+/** Local `!`-command output cap (mirrors the result preview limit). */
+export const LOCAL_OUTPUT_LIMIT = 240;
+/**
+ * In-memory transcript window cap. Older rows beyond this count are folded:
+ * their full-text fields (assistant/reasoning text, tool args/results) are
+ * dropped and only the preview/status metadata kept, so a long merge/deploy
+ * turn cannot grow the TUI's RAM without bound. The session log still holds
+ * everything (`/export` reads it, `/resume` replays it); the
+ * folded row keeps its kind/id so scrolling and selection stay stable.
+ */
+export const MAX_ROWS = 600;
+export function preview(text, limit) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= limit ? flat : `${flat.slice(0, limit)}…`;
+}

package/lib/types/channel/usage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Backend-neutral token accounting helpers for the shared projector. Pricing
+ * policy (which rate window a request ran in, what a token costs) is not here:
+ * the projector receives the window as an injected `pricingWindow` and only
+ * buckets counts; pricing tables stay with their backend.
+ */
+import type { CostTokenBuckets, TokenBucket, TokenUsage } from '../adapter/ports/channel-view.js';
+import type { UsageDelta } from '../agent/events.js';
+/** Rate window a usage is bucketed under (`peak`/`idle` price separately). */
+export type PricingWindow = 'peak' | 'idle';
+/** 全零 token 累计（新会话 / 复位用）。 */
+export declare function emptyTokenUsage(): TokenUsage;
+/** Empty peak/idle buckets for one model's cost accumulation. */
+export declare function emptyCostBuckets(): CostTokenBuckets;
+/** Add one usage to the bucket of its rate window (in place). */
+export declare function addUsageToBucket(bucket: TokenBucket, usage: UsageDelta): void;
+/**
+ * Context-bar token estimate for model-visible text: a per-code-point weighted
+ * count by script class (see the rates above), rounded up.
+ *
+ * Pure and deterministic: non-negative, zero only for the empty string, and
+ * monotonic — appending characters never lowers the result. A single call on
+ * pure ASCII input is exactly `ceil(length / 4)` (there is an explicit fast
+ * path). Rounding happens per call, so summing this estimator over messages
+ * can differ from rounding the summed characters once by at most one token
+ * per call (ASCII-only sums included). ANSI escapes are not stripped: they
+ * are ASCII, and the provider tokenizes the literal message bytes rather than
+ * the rendered cells.
+ *
+ * @param text - Model-visible text (a prompt, an assistant block, a tool
+ *   result); widths are irrelevant here, this counts characters, not cells.
+ * @returns The estimated token count (0 for empty input).
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * The same script-weighted estimate as estimateTokens, WITHOUT the per-call
+ * rounding: a fractional token count that is exactly additive over fragments.
+ * The live tps path accumulates this over stream deltas and rounds ONCE at
+ * the read -- per-delta ceil would inflate a stream of 2-3 character deltas
+ * to one token each (4x for ASCII), and the old chars/4 fallback under-
+ * counted CJK ~3x (one ideograph is ~0.7-1 token, not 0.25).
+ * @param text - Any text fragment (a stream delta).
+ * @returns the fractional token estimate (0 for empty input).
+ */
+export declare function estimateTokensFraction(text: string): number;
+/** Reported output count when usable; durable imports may predate strict validation. */
+export declare function usageOutputTokens(usage: UsageDelta | undefined): number | undefined;
+//# sourceMappingURL=usage.d.ts.map

package/lib/types/channel/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../src/channel/usage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAA;AACjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AAEpD,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,CAAA;AAE3C,8BAA8B;AAC9B,wBAAgB,eAAe,IAAI,UAAU,CAS5C;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,IAAI,gBAAgB,CAKnD;AAED,iEAAiE;AACjE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAK7E;AA+DD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB3D;AAED,wFAAwF;AACxF,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAKnF"}

package/lib/types/channel/usage.js

@@ -0,0 +1,143 @@
+/** 全零 token 累计（新会话 / 复位用）。 */
+export function emptyTokenUsage() {
+    return {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        peak: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        idle: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    };
+}
+/** Empty peak/idle buckets for one model's cost accumulation. */
+export function emptyCostBuckets() {
+    return {
+        peak: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        idle: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    };
+}
+/** Add one usage to the bucket of its rate window (in place). */
+export function addUsageToBucket(bucket, usage) {
+    bucket.input += usage.input ?? 0;
+    bucket.output += usage.output ?? 0;
+    bucket.cacheRead += usage.cacheRead ?? 0;
+    bucket.cacheWrite += usage.cacheWrite ?? 0;
+}
+/*
+ * Script-class rates for the context bar's local token estimate.
+ *
+ * pi-nano-context's original `text.length / 4` is an English heuristic: BPE
+ * vocabularies pack roughly four ASCII characters into one token, but CJK text
+ * runs ~1–1.5 characters per token (one ideograph is one or two tokens), so the
+ * English rate under-counted Chinese/Korean/Japanese sessions by ~3x — the
+ * segmented bar, its hover breakdown and everything derived from these numbers
+ * were squeezed flat against the real occupancy reading (issue #1170).
+ *
+ * These are ESTIMATES, not metering: no tokenizer is consulted, and the guess
+ * cannot see the provider vocabulary, the request envelope (role markers, tool
+ * JSON, image blocks) or a cached prefix that the next request will not resend
+ * in full. The authoritative occupancy is the backend's own reading (DSH: the
+ * harness `contextPressure` projection, `projectedTokens ?? pressureTokens`, see
+ * `dsh-adapter/context-occupancy.ts`); these numbers only describe what the
+ * segmented bar is made of and must never be summed into that total.
+ */
+/** ASCII, including control bytes and ANSI escapes: ~4 characters per token. */
+const CHARS_PER_TOKEN_ASCII = 4;
+/** CJK ideographs, kana, Hangul, Bopomofo, Yi, CJK punctuation and full-width
+ *  forms: ~1.4 characters per token (the midpoint of the measured 1–1.5 band). */
+const CHARS_PER_TOKEN_CJK = 1.4;
+/** Everything else — accented Latin, Cyrillic, Greek, Arabic, Hebrew, Thai,
+ *  Devanagari, emoji — deliberately conservative at 2 characters per token:
+ *  denser scripts (Thai, Devanagari) and multi-token emoji clusters still come
+ *  out low, while lighter ones are over-counted rather than under-counted. */
+const CHARS_PER_TOKEN_OTHER = 2;
+/** Cheapest possible "does this text need script classification at all" test. */
+const NON_ASCII_RE = /[^\x00-\x7f]/;
+/**
+ * Whether one code point belongs to a script BPE vocabularies pack at roughly
+ * one token per character or two. Emoji are deliberately excluded (they land in
+ * the `OTHER` rate): they are not East Asian wide *text*, and a ZWJ cluster is
+ * several code points the tokenizer may charge several tokens for.
+ */
+function isDenseScript(codePoint) {
+    return ((codePoint >= 0x1100 && codePoint <= 0x11ff) // Hangul Jamo
+        || (codePoint >= 0x2e80 && codePoint <= 0x303f) // CJK radicals … CJK symbols and punctuation
+        || (codePoint >= 0x3040 && codePoint <= 0x33ff) // kana, Bopomofo, Hangul compat jamo, enclosed/compat CJK
+        || (codePoint >= 0x3400 && codePoint <= 0x4dbf) // CJK unified ideographs extension A
+        || (codePoint >= 0x4e00 && codePoint <= 0x9fff) // CJK unified ideographs
+        || (codePoint >= 0xa000 && codePoint <= 0xa4cf) // Yi syllables and radicals
+        || (codePoint >= 0xa960 && codePoint <= 0xa97f) // Hangul Jamo Extended-A
+        || (codePoint >= 0xac00 && codePoint <= 0xd7af) // Hangul syllables
+        || (codePoint >= 0xd7b0 && codePoint <= 0xd7ff) // Hangul Jamo Extended-B
+        || (codePoint >= 0xf900 && codePoint <= 0xfaff) // CJK compatibility ideographs
+        || (codePoint >= 0xfe30 && codePoint <= 0xfe4f) // CJK compatibility forms
+        || (codePoint >= 0xfe50 && codePoint <= 0xfe6f) // small form variants (CJK punctuation variants)
+        || (codePoint >= 0xff00 && codePoint <= 0xff60) // full-width forms
+        || (codePoint >= 0xff61 && codePoint <= 0xffdc) // half-width kana, half-width Hangul, half-width CJK punctuation
+        || (codePoint >= 0xffe0 && codePoint <= 0xffe6) // full-width signs
+        || (codePoint >= 0x1f200 && codePoint <= 0x1f2ff) // enclosed ideographic supplement
+        || (codePoint >= 0x20000 && codePoint <= 0x3fffd) // CJK extensions B–G
+    );
+}
+/**
+ * Context-bar token estimate for model-visible text: a per-code-point weighted
+ * count by script class (see the rates above), rounded up.
+ *
+ * Pure and deterministic: non-negative, zero only for the empty string, and
+ * monotonic — appending characters never lowers the result. A single call on
+ * pure ASCII input is exactly `ceil(length / 4)` (there is an explicit fast
+ * path). Rounding happens per call, so summing this estimator over messages
+ * can differ from rounding the summed characters once by at most one token
+ * per call (ASCII-only sums included). ANSI escapes are not stripped: they
+ * are ASCII, and the provider tokenizes the literal message bytes rather than
+ * the rendered cells.
+ *
+ * @param text - Model-visible text (a prompt, an assistant block, a tool
+ *   result); widths are irrelevant here, this counts characters, not cells.
+ * @returns The estimated token count (0 for empty input).
+ */
+export function estimateTokens(text) {
+    return Math.ceil(estimateTokensFraction(text));
+}
+/**
+ * The same script-weighted estimate as estimateTokens, WITHOUT the per-call
+ * rounding: a fractional token count that is exactly additive over fragments.
+ * The live tps path accumulates this over stream deltas and rounds ONCE at
+ * the read -- per-delta ceil would inflate a stream of 2-3 character deltas
+ * to one token each (4x for ASCII), and the old chars/4 fallback under-
+ * counted CJK ~3x (one ideograph is ~0.7-1 token, not 0.25).
+ * @param text - Any text fragment (a stream delta).
+ * @returns the fractional token estimate (0 for empty input).
+ */
+export function estimateTokensFraction(text) {
+    if (text === '')
+        return 0;
+    // Fast path: ASCII-only text is exactly the legacy rate, and the regex scan
+    // keeps the overwhelmingly common English case cheaper than a code-point walk.
+    if (!NON_ASCII_RE.test(text))
+        return text.length / CHARS_PER_TOKEN_ASCII;
+    let ascii = 0;
+    let dense = 0;
+    let other = 0;
+    for (const character of text) {
+        // `for…of` walks code points, so a surrogate pair (emoji, CJK extension B+)
+        // counts once instead of twice.
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (codePoint < 0x80)
+            ascii += 1;
+        else if (isDenseScript(codePoint))
+            dense += 1;
+        else
+            other += 1;
+    }
+    return (ascii / CHARS_PER_TOKEN_ASCII
+        + dense / CHARS_PER_TOKEN_CJK
+        + other / CHARS_PER_TOKEN_OTHER);
+}
+/** Reported output count when usable; durable imports may predate strict validation. */
+export function usageOutputTokens(usage) {
+    const value = usage?.output;
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0
+        ? value
+        : undefined;
+}

package/lib/types/commands.d.ts

@@ -22,6 +22,70 @@ export declare function isCommandCompletionToken(value: string): boolean;
  * commands merge in at runtime; locals win on name collisions.
  */
 export declare const LOCAL_COMMANDS: LocalCommand[];
+/**
+ * `/permission` as a modes-capable backend serves it. Deliberately NOT a
+ * LOCAL_COMMANDS entry: DSH's own /permission comes from the permission-
+ * presets registry row, and a local entry would shadow it in the merged
+ * list (locals win collisions), flipping the external-command route the
+ * DSH pipeline depends on. The backend capability snapshot appends this
+ * shape instead (channel/capabilities.ts → session-controls), so a session
+ * with the typed `modes` capability offers the same command surface
+ * without touching DSH's.
+ */
+export declare const BACKEND_PERMISSION_COMMAND: LocalCommand;
+/**
+ * `/channel` as a channels-capable backend serves it (the Claude backend's
+ * relay channel profiles, backends/claude/channels.ts). Like /permission,
+ * deliberately NOT a LOCAL_COMMANDS entry: the command must appear only on a
+ * backend that declares the typed `channels` capability — a DSH session
+ * (every built-in) and other backends never list it, so typing `/channel`
+ * there keeps today's not-a-command behavior. The capability snapshot
+ * appends the name (channel/capabilities.ts) and session-controls rides it
+ * here.
+ */
+export declare const BACKEND_CHANNEL_COMMAND: LocalCommand;
+/**
+ * `/goal` as a goals-capable backend serves it (the typed `goals`
+ * capability; the channel core's `backendGoals` host). Like /permission,
+ * deliberately NOT a LOCAL_COMMANDS entry: DSH's own /goal is the
+ * `dsh-command-goal` registry row, and a local entry would shadow it. The
+ * capability snapshot appends the name (channel/capabilities.ts) and
+ * session-controls rides it here. On a backend without the capability the
+ * typed command is refused as unavailable (`isUnavailableLocalCommand`).
+ */
+export declare const BACKEND_GOAL_COMMAND: LocalCommand;
+/**
+ * What a built-in command needs from the bound backend session: `any` works
+ * on every backend (UI-only, or served by the channel's backend-neutral
+ * core); a capability name needs that session capability; `dsh` needs the
+ * DSH-only specialists. Commands not listed here default
+ * to `dsh`, so a new built-in never silently appears on a backend that
+ * cannot serve it.
+ */
+export type LocalCommandRequirement = 'any' | 'dsh' | 'models' | 'effort' | 'compact' | 'rewind' | 'fork' | 'resume' | 'subagents' | 'tasks' | 'mcp' | 'context' | 'login' | 'sideQuery' | 'rename' | 'color' | 'init';
+/** The requirement of one built-in command name (unlisted → `dsh`). */
+export declare function localCommandRequirement(name: string): LocalCommandRequirement;
+/**
+ * Names of the built-in commands a backend supports, in catalog order. A DSH
+ * session supports every built-in (today's list, unchanged); any other
+ * session supports the `any` commands plus those whose capability it has.
+ */
+export declare function supportedLocalCommandNames(backend: {
+    readonly dsh: boolean;
+    readonly has: (capability: Exclude<LocalCommandRequirement, 'any' | 'dsh'>) => boolean;
+}): readonly string[];
+/**
+ * Whether a typed name is a built-in command the bound backend lacks. Such a
+ * line must neither run nor reach the model: the caller shows
+ * `cmd-unavailable-backend`. An absent snapshot (a partial embedder channel)
+ * means everything is supported. `/goal` counts as one when the snapshot
+ * says goals are not served (a backend without the `goals` capability; a
+ * snapshot without the flag predates it and serves everything).
+ */
+export declare function isUnavailableLocalCommand(name: string, capabilities: {
+    readonly commands: readonly string[];
+    readonly goals?: boolean;
+} | undefined): boolean;
 /**
  * Hidden slash commands: intentionally not exposed in the `/` suggestion
  * menu or Help, but still recognized as local commands when typed. They are
@@ -47,6 +111,89 @@ export declare function isHiddenCommandName(input: string): boolean;
 export declare function localizedDescription(command: LocalCommand & {
     descriptionKey?: string;
 }): string;
+/**
+ * Commands the channel REFUSES to run while a turn is streaming, mapped to the
+ * i18n key of the refusal notice. This table is the single source of truth for
+ * what a gate SAYS and for the `/` suggestion overlay that sinks the rows
+ * affecting the running conversation — so the refusal text and the overlay
+ * annotation can never drift. WHETHER a command is refused still lives in each
+ * gate's own `state.working` / `channel.working` branch — the 11 bail-outs under
+ * `src/dsh-adapter/` plus the UI-side gates that share the same refusals — so
+ * a new gate means a new entry here: `scripts/verify-command-hold.ts` fails when
+ * a `working` bail-out under `src/dsh-adapter/` notifies with a literal key of
+ * its own, and when a new name joins this dictionary without a conscious edit
+ * there. A `t(...)` call in a gate pins the key type, so removing an entry from
+ * the dict fails the build.
+ */
+export declare const WORKING_GATE_NOTICES: {
+    readonly new: "new-session-while-working";
+    readonly compact: "compact-while-working";
+    readonly fork: "fork-while-working";
+    readonly model: "model-switch-while-working";
+    readonly preset: "preset-agent-running";
+    readonly workspace: "workspace-switch-working";
+    readonly update: "update-working";
+    readonly restart: "update-working";
+    readonly resume: "resume-while-working";
+    readonly rewind: "rewind-while-working";
+    readonly kernel: "kernel-switch-while-working";
+    readonly channel: "channel-switch-while-working";
+};
+/**
+ * Commands that DO have a mid-turn refusal notice of their own, yet whose ROW
+ * stays in the overlay's normal region: the command only OPENS a browser, and
+ * the refusals belong to the separate, separately confirmed actions INSIDE it.
+ *
+ * `/resume` opens the session manager (`Chat.tsx` `setSupervisorOpen`); the
+ * per-row switch is a separate action that PARKS the outgoing session and lets
+ * its turn keep running (`session-resume.ts`), so neither the command nor the
+ * switch interrupts the running turn — the same reason `/tree` is in the normal
+ * region. Its key stays in {@link WORKING_GATE_NOTICES} because the core's own
+ * session-switch transaction still refuses mid-turn on a backend that gets no
+ * DSH extension (Claude, `core/session-switch.ts`), and `resumeFailureText`
+ * reports that reason with it.
+ */
+export declare const GRAY_ZONE_EXEMPT_COMMANDS: readonly string[];
+/**
+ * Commands that MAY run while a turn is streaming but act ON the conversation
+ * itself rather than on the running turn: `clear` empties the visible view (the
+ * running turn keeps writing into it, `local-actions.ts`), and `exit` (with its
+ * `quit`/`q` aliases) tears the process — and the running turn — down.
+ *
+ * `/rewind` used to live here, because it cancels only once a target is
+ * CONFIRMED (`session-rewind.ts`) and replacing the conversation is its whole
+ * purpose. It moved to {@link WORKING_GATE_NOTICES} when the session-switch
+ * transaction grew its own mid-turn refusal: under DSH the extension still
+ * cancels and re-arms, but the core's rewind path REFUSES, and one command
+ * cannot be both. `/tree` deliberately stays out of both families: it only
+ * opens the family-tree browser (`Chat.tsx` `setTreeOpen(true)`) and leaves the
+ * running turn untouched — its per-node rewind/fork/adopt are separate,
+ * separately confirmed actions (`session-tree-actions.ts`), and browsing the
+ * tree is inspection, not impact (issue #1072 review: measured on a real turn —
+ * `/tree` does not interrupt). `/resume` belongs to that same normal region for
+ * the same reason, even though it does own a notice key for the core's refusal:
+ * see {@link GRAY_ZONE_EXEMPT_COMMANDS}.
+ */
+export declare const WORKING_CONVERSATION_COMMANDS: readonly string[];
+/**
+ * How a command affects the RUNNING conversation:
+ * - `gated` — refused by the channel while a turn runs (see
+ *   {@link WORKING_GATE_NOTICES});
+ * - `conversation` — allowed, but ends the current conversation (process exit);
+ * - `inject` — steers a line into the current turn (skills).
+ * `undefined` means the normal region: message-like commands, or commands that
+ * leave the running conversation alone.
+ */
+export type WorkingHold = 'gated' | 'conversation' | 'inject';
+/**
+ * Classify a command by its impact on the running conversation.
+ * @param name Bare command name or a completion path (`model deepseek-chat`);
+ *   only the first token is classified, so every child of a gated command
+ *   (`/model <id>`, `/workspace rename <t>`) inherits the parent's hold.
+ * @param skill Whether the entry is a user-invocable skill.
+ * @returns The hold, or `undefined` for the normal region.
+ */
+export declare function workingHoldOf(name: string, skill?: boolean): WorkingHold | undefined;
 /**
  * Parse a slash-command line into its name and the verbatim input following
  * the name (separator whitespace included) — the same split the DSH command

package/lib/types/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AAChH,YAAY,EAAE,YAAY,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAA;AAiBhH,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAC3B,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,CAAC,EAAE,qBAAqB,CAAA;IACpC,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,sEAAsE;IACtE,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,aAAa,EAAE,SAAS,MAAM,EAAE,KAAK,SAAS,qBAAqB,EAAE,CAAA;AAEpG;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,YAAY,EAoExC,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,YAAY,EAElD,CAAA;AAED,0DAA0D;AAC1D,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAEpD,CAAA;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAG1D;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAIhG;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,GACX;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAIhD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,SAAS,YAAY,EAAmB,GAC7C,OAAO,CAKT;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,SAAS,YAAY,EAAmB,GAC7C,YAAY,EAAE,CAKhB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,SAAS,YAAY,EAAmB,EAC/C,QAAQ,GAAE,eAA0B,GACnC,iBAAiB,EAAE,CAuCrB"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/commands.ts"],"names":[],"mappings":"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"}