dsh-ssh-tui 0.8.1 → 0.8.2

package/lib/types/representation.d.ts

@@ -0,0 +1,498 @@
+/**
+ * Representation policy: the one place that decides what a transcript line *is*.
+ *
+ * AD-10 in `docs/decisions/b2-architecture-decisions.md` froze the shape —
+ * `Event / Command → Representation Policy → Representation → Renderer` — and this
+ * module is the policy. A renderer never decides whether something exists, and a
+ * creation site never decides whether its line is history or an echo: it names its
+ * *source*, and the table below says what that source means.
+ *
+ * The boundary is enforced by the type system rather than by review:
+ *
+ * - `pushRow` takes a `Representation`, not a `Row`, so a line cannot reach the
+ *   transcript without passing through `represent()` — a bare row is a type error;
+ * - `RepresentationSource` is `keyof` the policy table, so naming a source that has
+ *   no policy is also a type error: adding a creation site *requires* adding its
+ *   policy, and there is no default to fall back on;
+ * - anything that arrives anyway (a JavaScript caller, a test fixture) is pushed
+ *   with no metadata and counted as **unclassified** by `auditRepresentations`,
+ *   which the suite asserts is zero. Nothing is silently assumed durable.
+ *
+ * Three durabilities (B2.3a):
+ *
+ * - `durable` — rebuilt from the authoritative session log by replaying it, so it
+ *   is there again after a resume;
+ * - `display` — lives only for this Host/display's lifetime; its absence after a
+ *   resume is correct, not a loss;
+ * - `live` — a runtime projection, recomputed every tick. **It must never be a
+ *   source row at all** (B2.2 moved the streaming text and the wait card out); a
+ *   `live` row in the transcript is a bug, and the audit reports it as one.
+ *
+ * The A/B/C/D classes are orthogonal and describe the *form* of the
+ * representation, not its importance:
+ *
+ * - **A** persistent transcript entry — an ordinary row;
+ * - **B** ephemeral transient — never a source row (the live tail, a Surface);
+ * - **C** summary entry — a row that summarizes an exchange (`question` cards);
+ * - **D** artifact reference — a row that points at an object (plans, later).
+ *
+ * "Important" is not the same as "durable": a quota alert matters and is still
+ * `display`, because no replay can bring it back.
+ */
+import type { Row } from './transcript-types.js';
+/** Where a line can come from after a resume. */
+export type Durability = 'durable' | 'display' | 'live';
+/**
+ * Where a representation is *shown* (B2.3b's routing boundary).
+ *
+ * Classification says what a line is; routing says where it goes. The policy owns
+ * both, so a control-plane confirmation cannot be a transcript row at one call site
+ * and a footer echo at the next: the source decides, once.
+ *
+ * - `transcript` — a real line in the log's view (narrative, a durable summary, a
+ *   Screen's line-mode echo, or a local record with causal value);
+ * - `echo` — a Host-local footer chip: the confirmation of something the reader just
+ *   did. Replaced by the next echo, cleared by the next submit, never in the log;
+ * - `notice` — a one-row Host-local notice above the composer, for feedback that
+ *   needs to be read now but is not history (a failed command, an operational
+ *   warning). Same lifetime rules as the echo, more room for the message.
+ *
+ * The rule behind the split is AD-13: narrative and causal facts go to the
+ * transcript, runtime state belongs to the footer's own facts, and immediate action
+ * feedback is an echo or a notice.
+ */
+export type Destination = 'transcript' | 'echo' | 'notice';
+/** The form of the representation (see the module comment). */
+export type RepresentationClass = 'A' | 'B' | 'C' | 'D';
+/**
+ * Every place that may put a line into the transcript.
+ *
+ * Adding an entry here is what makes a new creation site possible, and the entry
+ * states what the line *is*. The ids name the producer, not the wording: one id
+ * covers a family of messages whose answer to "is this history?" is the same.
+ */
+export declare const REPRESENTATION_POLICY: {
+    readonly 'user-message': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'assistant-message': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'reasoning-message': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'tool-call': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'turn-error': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** Notices the log itself carries: reminders, context snapshots, interrupted streams. */
+    readonly 'session-notice': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly compaction: {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly goal: {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'prompt-injection': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'plan-row': {
+        readonly durability: "durable";
+        readonly class: "D";
+        readonly destination: "transcript";
+    };
+    readonly 'subagent-card': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'command-event': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'retry-notice': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'session-route': {
+        readonly durability: "durable";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** The question card: one row summarizing an exchange, rebuilt from the projection. */
+    readonly 'question-card': {
+        readonly durability: "durable";
+        readonly class: "C";
+        readonly destination: "transcript";
+    };
+    readonly boot: {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** A confirmation of something the reader just did: a footer echo. */
+    readonly 'command-feedback': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    /**
+     * A command that *reports* state rather than changing it (`/retryauth` with no
+     * argument, `/notify` showing its target).
+     *
+     * A report is information, not an acknowledgement: the reader may need to read it
+     * twice, or compare it with something they scrolled past, so it stays in the
+     * transcript. The policy draws that line, not the call site.
+     */
+    readonly 'command-status': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** The outcome of a repair that edited the install (`/mode fix`). */
+    readonly 'repair-result': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * A local command that failed.
+     *
+     * Kept in the transcript: the message is usually an error chain the reader has to
+     * be able to scroll back to, and re-running the command is not the same as reading
+     * what it said. (A command that was simply *misused* is the notice below.)
+     */
+    readonly 'command-error': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * A command that could not be understood at all: a mistyped name, a missing
+     * argument, a value outside the table. Immediate feedback, and nothing to keep —
+     * the reader fixes the line and moves on.
+     */
+    readonly 'command-misuse': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    /** How to use a command: the reader asked for it, and it is not history. */
+    readonly 'command-usage': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    readonly 'auth-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly onboarding: {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * An auto approval the TUI *refused*. The transient notice, not a row (B2.4).
+     *
+     * The durable trace of a refusal is the tool card it guarded — its `approval`
+     * field, rebuilt from the Harness's own `approval/asked` + `approval/decided`
+     * pair — so a second, permanent sentence saying "rejected" would be a second
+     * representation of the same event (and one nothing can rebuild). What the notice
+     * adds is *now*: the reader sees why the model changed course while it happens.
+     */
+    readonly 'approval-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    /**
+     * An auto approval the TUI *granted*.
+     *
+     * Routed to the footer chip rather than the notice row: an allow is an
+     * acknowledgement, and it happens far more often than a refusal — the identity
+     * row is for the one the reader must not miss.
+     */
+    readonly 'approval-allowance': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    readonly 'doctor-result': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** Preset wizard/list feedback and its failures. */
+    readonly 'preset-feedback': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    readonly 'preset-error': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** The self-update path: progress is an echo, a failure is a notice. */
+    readonly 'update-feedback': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    readonly 'update-error': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    /** A quota or balance reading the reader asked for. */
+    readonly 'quota-report': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    /** The context window filling up: operational, and worth reading now. */
+    readonly 'runtime-warning': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** An approval the TUI could not resolve on its own. */
+    readonly 'approval-warning': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** A question the Session still holds but cannot answer any more. */
+    readonly 'question-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * A child agent starting or ending.
+     *
+     * Left in the transcript on purpose: it is narrative about work that happened, and
+     * the durable child *card* is what a reader scrolls back to.
+     */
+    readonly 'subagent-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * What happened while the display was away.
+     *
+     * AD-13's causal exception: a gap in the work is exactly what a later reader needs
+     * explained, so this one stays in the transcript rather than becoming an echo.
+     */
+    readonly 'away-summary': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'attach-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'find-feedback': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    readonly 'copy-feedback': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    /**
+     * The caveat that a terminal cannot take an OSC 52 write, so the copy may not have
+     * landed.
+     *
+     * An operational warning (AD-13), not an acknowledgement: it goes to the notice row
+     * where it can be read, and stays out of the footer chip that says "copied" — the
+     * two would otherwise overwrite each other.
+     */
+    readonly 'copy-caveat': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    readonly 'plan-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "echo";
+    };
+    /**
+     * A plan artifact's lifecycle in the transcript: created, a review's answer, the
+     * mode left. The *reference* the reader scrolls back to (`plan-row` points at the
+     * same artifact), and the only representation of a transition — the plan body lives
+     * with the artifact, not in a second copy.
+     */
+    readonly 'plan-lifecycle': {
+        readonly durability: "durable";
+        readonly class: "D";
+        readonly destination: "transcript";
+    };
+    /**
+     * A message the reader submitted while a turn was running.
+     *
+     * The record of it is the `user/message` the Harness appends when the next step
+     * claims it — that row is the durable representation. This one is the
+     * acknowledgement ("accepted, applies at the next step"), which has to be seen
+     * the moment it happens and is worth no geometry.
+     */
+    readonly 'steer-notice': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    readonly 'error-surface': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "notice";
+    };
+    /** Line mode's echo of a Screen / Surface — there is no frame there to show it. */
+    readonly 'report-echo': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    readonly 'surface-echo': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /**
+     * The workspace-changes card.
+     *
+     * The canonical `display` case (B2.3a): it *looks* like history — a card about a
+     * turn that happened — but the summary is not in the session log and a restarted
+     * Host cannot reopen it, so it must not pretend to survive a resume.
+     */
+    readonly 'changes-card': {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+    /** Rows a test fixture puts in, so the suite does not have to fabricate a policy. */
+    readonly fixture: {
+        readonly durability: "display";
+        readonly class: "A";
+        readonly destination: "transcript";
+    };
+};
+/** A source id that has a policy. Its type *is* the table's keys. */
+export type RepresentationSource = keyof typeof REPRESENTATION_POLICY;
+/** What a row carries once it has been through the policy. */
+export interface RepresentationMeta {
+    source: RepresentationSource;
+    durability: Durability;
+    representationClass: RepresentationClass;
+    /** Where this representation is shown — a transcript row, an echo or a notice. */
+    destination: Destination;
+}
+/** A row plus the policy that produced it. The only thing `pushRow` accepts. */
+export interface Representation {
+    readonly meta: RepresentationMeta;
+    readonly row: Row;
+}
+/**
+ * Classify one row.
+ *
+ * The only constructor of a `Representation`: it looks the source up in the table,
+ * so the durability and class can never disagree with the policy, and a source with
+ * no entry cannot be named (the parameter's type is the table's keys).
+ */
+export declare function represent(source: RepresentationSource, row: Row): Representation;
+/** Whether a value really is a classified representation (a runtime guard for JS callers). */
+export declare function isRepresentation(value: unknown): value is Representation;
+export interface RepresentationAudit {
+    /** Rows carrying a policy, by durability. */
+    counts: Record<Durability, number>;
+    /** Rows with no `representation` at all: must be 0. */
+    unclassified: number;
+    /**
+     * Rows claiming `live`: must be 0 — a live projection is not a source row.
+     *
+     * Counted from the row's own metadata, so a row whose source is not even in the
+     * table (and is therefore also `unclassified`) still reports the live violation.
+     */
+    liveRows: number;
+    /** Per source: durability, class, destination and how many rows carry it. */
+    sources: {
+        source: string;
+        durability: Durability;
+        representationClass: RepresentationClass;
+        destination: Destination;
+        rows: number;
+    }[];
+    /** Rows by destination. `unknown` must be 0: every source has a route. */
+    destinations: Record<Destination, number>;
+    /** Sources with no destination — impossible by construction, and asserted anyway. */
+    unknownDestination: number;
+    /**
+     * Sources the policy knows, with no rows in this transcript. Named so a caller can
+     * see the *whole* policy rather than only the part that happened to be exercised.
+     */
+    unusedSources: string[];
+}
+/**
+ * Read a transcript's representations back.
+ *
+ * This is the audit artifact: it answers, for a real transcript, how many lines are
+ * history, how many are this Host's own voice, and how many nobody classified. The
+ * `live` and `unclassified` numbers are the two that must be zero, and the suite
+ * asserts exactly that rather than trusting the policy table alone.
+ */
+export declare function auditRepresentations(rows: readonly unknown[]): RepresentationAudit;
+/** The audit as text: what `scripts/representation-audit.mjs` prints. */
+/**
+ * One semantic question, one primary representation — counted from real rows
+ * (B2.4).
+ *
+ * The success criterion of the ask/approval round is a *count*, so it is audited
+ * like one: an ordinary `ask_user_question` call is represented by its question
+ * card, and a generic tool row for the same call would be a second primary for one
+ * semantic event. The tool's name is not read off the row's title but off `name`,
+ * because that is the field the policy suppresses.
+ * @param rows - the transcript rows to audit.
+ * @returns the counts, with the call ids that broke the invariant.
+ */
+export declare function auditQuestionPrimaries(rows: readonly {
+    kind?: string;
+    callId?: string;
+    name?: string;
+}[]): {
+    questionRows: number;
+    genericToolRows: number;
+    calls: number;
+    duplicateCalls: string[];
+};
+export declare function formatRepresentationAudit(audit: RepresentationAudit): string;

package/lib/types/screen.d.ts

@@ -0,0 +1,126 @@
+/**
+ * The Screen contract: a whole-view surface with its own navigation state.
+ *
+ * A **Surface** (ask-user, a picker) borrows a few rows of the workspace and gives
+ * them back when the action is done: the transcript behind it never moves, and
+ * the reader returns to the same place. A **Screen** is the other thing entirely —
+ * it replaces the workspace, owns its own scrolling, and must be able to redraw
+ * itself from its state alone (a reattach after an SSH drop is a normal event, not
+ * an edge case). See `docs/decisions/b2-architecture-decisions.md` (AD-1 … AD-3).
+ *
+ * Depth is exactly one: a Screen may hold tabs, sections and detail modes of its
+ * own, but it never pushes another Screen. Nothing here allocates a stack, and
+ * nothing here renders — this module is the contract, `tui.ts` is the renderer.
+ */
+import type { Dialog, InspectDialog } from './dialogs.js';
+import type { DiffDisplayLine } from './tool-present.js';
+/**
+ * Which Screen is up. Adding one here is the only way to add one at all.
+ *
+ * `setup` is the odd one: it draws no body of its own — the wizard's rows are built
+ * from its state machine every frame — but it is a Screen in every other sense. It
+ * owns the whole view, it owns its input, it never enters the dialog queue, and it is
+ * rebuilt from state after a reattach (B2.6).
+ */
+export type ScreenKind = 'inspect' | 'report' | 'setup';
+/** The report a `report` Screen is showing. */
+export type ReportKind = 'status' | 'usage' | 'diag' | 'doctor' | 'help' | 'subagents';
+/**
+ * A Screen's whole state.
+ *
+ * Everything the renderer needs is here on purpose: nothing about the picture
+ * lives only in the paint loop, which is what makes a reattach able to rebuild the
+ * same screen, and what makes the screen testable without a terminal. `offset` is
+ * the first visible body row — the Screen's own scroll position, unrelated to the
+ * transcript's `scrollOffset` behind it.
+ */
+export interface ScreenState {
+    kind: ScreenKind;
+    /** Title row. */
+    title: string;
+    /** Body, already rendered for the width it will be shown at. */
+    lines: readonly DiffDisplayLine[];
+    /** First visible body row. */
+    offset: number;
+    /** Which report this is, when `kind === 'report'`. */
+    report?: ReportKind;
+    /** What the copy key takes while this screen is up. */
+    copyText?: string;
+    /**
+     * A confirmation line shown in place of the navigation hint.
+     *
+     * Used by an in-screen copy ("copied 412 chars") and by a Screen's own action
+     * (the doctor repair result): the row the action would otherwise push is behind
+     * this screen, and silence after an action reads as a failure.
+     */
+    notice?: string;
+    /** Child session whose live log refreshes this screen in place. */
+    subagentSessionId?: string;
+    /** `/find` already scrolled to its hit here; later repaints keep the offset. */
+    searchRevealed?: boolean;
+}
+/**
+ * The one judgement: is this dialog a Screen?
+ *
+ * A Screen is *not* a dialog — it never enters `dialogQueue`, is never replaced by
+ * a Surface and never blocks one. This function exists so that no future call site
+ * has to remember that: a screen-shaped dialog handed to the dialog path is
+ * converted here and handed to the Screen path instead, and a test pins it.
+ *
+ * Returns `undefined` for the surfaces that genuinely are dialogs (questions,
+ * confirms, the onboarding wizard).
+ */
+export declare function screenFromDialog(dialog: Dialog | InspectDialog): ScreenState | undefined;
+/**
+ * The row kind a report falls back to where there is no frame to draw on.
+ *
+ * Line mode has no Screen (and no way to dismiss one), so `/diag` and `/doctor`
+ * keep their own copyable `diag` rows there — which is also where they are read
+ * from in a transcript (`/copy error` looks for `error` or `diag`).
+ */
+export declare function reportRowKind(report: ReportKind): 'diag' | 'system';
+/** The rows a Screen lays out, top to bottom. */
+export interface ScreenLayout {
+    /** 1 when the title row is drawn. */
+    titleRows: number;
+    /** 1 when the rule under the title is drawn. */
+    dividerRows: number;
+    /** Rows available to the body; may be 0 on a terminal that short. */
+    bodyRows: number;
+    /** 1 when the navigation hint row is drawn. */
+    hintRows: number;
+    /** 1 when the compact runtime strip is drawn. */
+    stripRows: number;
+    /** 0-based index of the first body row in the painted frame. */
+    contentTop: number;
+    /** 0-based index of the hint row, or -1 when it is not drawn. */
+    hintTop: number;
+    /** 0-based index of the strip row, or -1 when it is not drawn. */
+    stripTop: number;
+}
+/**
+ * Lay a Screen out for the height the terminal has.
+ *
+ * The strip is the one row that never goes: a Screen is a place the reader can be
+ * *while the agent keeps working*, and "is it still running, is anything waiting,
+ * is the link alive" has to be answerable without leaving. After that the order
+ * gives up the least load-bearing row first — the rule under the title, then the
+ * title, then body rows — and the navigation hint goes only when there is nothing
+ * left to navigate. Measured at 8 / 12 / 20 rows in the Screen contract tests.
+ */
+export declare function screenLayout(height: number): ScreenLayout;
+/**
+ * Clamp a Screen's scroll offset to its body.
+ *
+ * The body can be shorter than the last offset the reader scrolled to (a resize, a
+ * shorter report, a live subagent log that was replaced), and an offset past the
+ * end paints an empty screen with a position readout that lies.
+ */
+export declare function clampScreenOffset(offset: number, lineCount: number, bodyRows: number): number;
+/**
+ * `1–18/64`, the position readout a Screen's footer shows.
+ *
+ * Zero lines reads `0/0` rather than `1–0/0`: the second looks like a bug in the
+ * readout instead of an empty report.
+ */
+export declare function screenPositionText(offset: number, lineCount: number, bodyRows: number): string;

package/lib/types/startup.d.ts

@@ -38,6 +38,30 @@ declare module '@deepseek-ai/cordis' {
 }
 export declare const name = "ssh-tui-startup";
 export declare const inject: string[];
+/**
+ * Whether another application already owns this profile's command line.
+ *
+ * `@deepseek-ai/dsh-cmdline` has **no arbitration between apps**: every app plugin is
+ * handed the same argv and parses it with its own grammar, and an unknown flag is
+ * `program.error`, which exits the process. A profile that hosts two apps therefore
+ * requires the second one to understand the first one's flags — and the desktop
+ * application passes `--no-open` (the web app's own flag) to its host, so this row's
+ * grammar rejected it: the host exited 1, the application reported
+ * `dsh desktop host exited with 1: error: unknown option '--no-open'` and died. Only
+ * the *startup* row did that; the TUI row never ran, which is why 0.8.1's inert-when-
+ * headless fix could not have caught it.
+ *
+ * The signals are two, and they overlap on purpose:
+ *
+ * - the launcher facts (`desktopLauncher`): an Electron host, `DeepSeek Harness.exe`,
+ *   or `app.asar` in argv — true whatever the profile's row order is;
+ * - `webStartup`: the web app provides it as soon as it has parsed, and a `web`
+ *   profile is not a terminal profile in any case.
+ *
+ * Stepping aside is not a degraded mode: the TUI row `inject`s `sshTuiStartup`, so
+ * nothing of this plugin activates and the host keeps its own grammar and its own app.
+ */
+export declare function anotherAppOwnsCommandLine(ctx: Context): boolean;
 /**
  * Build the TUI command grammar and provide the session identity for the
  * agent-loop row plus the {@link SshTuiStartup} service. On `--help` or a