@xmoon76/dsh-pi-tui 0.4.9 → 0.5.1

package/dist/index.d.mts

@@ -1,107 +1,20 @@
-import { H as TuiAction } from "./public-types-YbB5Rhku.mjs";
-import z from "@deepseek-ai/schemastery";
-import { Agent, ModelSelectionRef } from "@deepseek-ai/dsh-agent";
-import { ContentBlock } from "@deepseek-ai/dsh-llm";
+import { H as TuiAction } from "./public-types-BEjj7FEb.mjs";
 import { SessionId } from "@deepseek-ai/dsh-session";
+import { ContentBlock } from "@deepseek-ai/dsh-llm";
 import { Context, Volatile } from "@deepseek-ai/cordis";
-//#region src/image/admission.d.ts
-/** Structural subset of `ImageAttachmentRef`. */
-interface ImageAttachmentRefLike {
-  readonly attachmentId: string;
-  readonly mediaType: ImageMediaType;
-  readonly bytes: number;
-  readonly width: number;
-  readonly height: number;
-  readonly name?: string;
-}
-//#endregion
-//#region src/image/types.d.ts
-/**
- * Image draft vocabulary for the TUI input pipeline (plan M1).
- *
- * The draft layer is TUI-owned: it stages clipboard/file bytes until a
- * submission turns them into durable `ImageAttachmentRef`s through the dsh
- * attachment service. Nothing in this module persists; the durable boundary
- * is the harness's `ctx.attachments.saveImages()`.
- *
- * The media-type union mirrors `@deepseek-ai/dsh-attachment`'s
- * `ImageMediaType` structurally, so drafts flow into the harness without a
- * runtime dependency on the attachment package (AGENTS.md decision 7:
- * structural typing for dsh services).
- * @module @xmoon76/dsh-pi-tui/image/types
- */
-/** Raster media types accepted by the TUI image intake. */
-type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
-/** Per-TUI draft image identity; only meaningful inside one TUI run. */
-type DraftImageId = number;
-/** Where a staged image's bytes came from. */
-type DraftImageSource = {
-  readonly type: 'clipboard';
-} | {
-  readonly type: 'path';
-  readonly path: string;
-}
-/** The image was pulled back from a queued message: its bytes are ALREADY
- * durable with the harness (the recalled ref) — the draft holds no local
- * copy and re-submitting reuses the ref instead of re-uploading. */
-| {
-  readonly type: 'recalled';
-};
-/**
- * One image staged in the editor draft. The draft holds the raw bytes so
- * clipboard and path entries share one shape and a submit never depends on
- * the source file still existing (plan §5.1). A RECALLED draft (pulled
- * back from the queue) instead carries the durable `ImageAttachmentRef`
- * and NO local bytes — the bytes stay in harness storage and re-submitting
- * reuses the ref.
- */
-interface DraftImage {
-  /** Per-TUI draft identity (the `#N` of the placeholder). */
-  readonly id: DraftImageId;
-  readonly kind: 'image';
-  readonly source: DraftImageSource;
-  /** Exact encoded bytes, held only for the draft lifetime. Empty for a
-   * recalled draft (its bytes live in harness storage). */
-  readonly bytes: Uint8Array;
-  readonly mediaType: ImageMediaType;
-  /** Intrinsic encoded width in pixels. */
-  readonly width: number;
-  /** Intrinsic encoded height in pixels. */
-  readonly height: number;
-  /** Exact encoded byte length (`bytes.byteLength` for local drafts; the
-   * durable ref's recorded `bytes` for recalled drafts). */
-  readonly byteLength: number;
-  /** Optional display name (basename for path sources), never a path. */
-  readonly name?: string;
-  /** The canonical editor placeholder text for this draft. */
-  readonly placeholder: string;
-  /** The durable ref this draft reuses on submit; present ONLY for
-   * recalled drafts (already-durable images are never re-uploaded). */
-  readonly recalledRef?: ImageAttachmentRefLike;
-}
-/** The store surface the placeholder expansion needs (structural). */
-interface DraftImageStoreLike {
-  values(): readonly DraftImage[];
+import { Agent, ModelSelectionRef } from "@deepseek-ai/dsh-agent";
+import z from "@deepseek-ai/schemastery";
+//#region src/domain/communication/policy.d.ts
+type ProgressUpdates = 'off' | 'milestones' | 'frequent';
+type ResponseStyle = 'default' | 'concise' | 'explanatory';
+interface ProgressUpdatesState {
+  mode: ProgressUpdates;
 }
-//#endregion
-//#region src/display-preset.d.ts
-/**
- * Canonical transcript display presets and their layered disclosure policy.
- *
- * DisplayPreset is the one runtime vocabulary for presentation state. Every
- * preset whose projection exists in this build is available; the availability
- * gate exists so a future preset can never be claimed by another preset's
- * renderer before its own projection ships.
- * @module @xmoon76/dsh-pi-tui/display-preset
- */
-/** The complete display vocabulary. */
-type DisplayPreset = 'focus' | 'compact' | 'full';
-/** The shared mutable display authority passed between the runner, prompt and UI. */
-interface DisplayState {
-  preset: DisplayPreset;
+interface ResponseStyleState {
+  style: ResponseStyle;
 }
 //#endregion
-//#region src/diag.d.ts
+//#region src/runtime/process/diagnostics.d.ts
 interface Diag {
   debug(message: string, fields?: Record<string, unknown>): void;
   info(message: string, fields?: Record<string, unknown>): void;
@@ -111,38 +24,18 @@ interface Diag {
   dispose(): void;
 }
 //#endregion
-//#region src/communication-policy.d.ts
-type ProgressUpdates = 'off' | 'milestones' | 'frequent';
-type ResponseStyle = 'default' | 'concise' | 'explanatory';
-interface ProgressUpdatesState {
-  mode: ProgressUpdates;
-}
-interface ResponseStyleState {
-  style: ResponseStyle;
-}
-//#endregion
-//#region src/skill-catalog.d.ts
+//#region src/domain/catalog/skill.d.ts
 /**
- * The standing-scope skill catalog adapter: the SINGLE narrow seam between
- * the TUI and the dsh skill services (the non-public-API isolation
- * contract, plan appendix B).
+ * Neutral skill catalog vocabulary (TS8-E): the human-facing skill summary
+ * shape, the detached catalog (with its completeness flag) and the official
+ * user-invocation policy guard.
  *
- * Everything the TUI knows about dsh-skill and agent-presets lives here:
- * - structural service types (never upstream classes) with OPTIONAL
- *   capability members — `snapshot` and `standingKeyFor` are detected at
- *   call time, so an upstream change degrades instead of breaking;
- * - `readHumanSkillCatalog()`: snapshot-first collector (list() fallback),
- *   official `isUserInvocable` filter, field validation, stable sort,
- *   deep freeze, distinct abort propagation;
- * - `resolveColdSkillTarget()`: capability-gated cold target selection
- *   (standing scope → rosterless global → degraded global with a notice);
- * - `resolveLiveSkillTarget()`: the agent's own registry + agent scope.
- *
- * Failure contract: ordinary provider/composition failures surface as
- * degraded targets or rethrown errors for the coordinator to classify;
- * aborts ALWAYS propagate as aborts. No failure may hang or crash the TUI —
- * the worst outcome is "the corresponding commands are missing".
- * @module @xmoon76/dsh-pi-tui/skill-catalog
+ * This module is the transport/UI-neutral semantic owner: it consumes only the
+ * official `@deepseek-ai/dsh-skill` policy helper. It never resolves ctx
+ * services, acquires standing scopes, holds revision leases, reads a live
+ * Agent, or imports a Direct/Remote adapter — the structural Direct Host read
+ * lives in `runtime/direct/skill-catalog.ts`.
+ * @module @xmoon76/dsh-pi-tui/domain/catalog/skill
  */
 /** The human-facing slice of one skill: display fields only. */
 interface HumanSkillSummary {
@@ -160,44 +53,7 @@ interface HumanSkillCatalog {
   readonly complete: boolean;
 }
 //#endregion
-//#region src/tui-app.d.ts
-/** The compaction lifecycle phase the working row advertises: idle (no
- * compaction), summarizing (compaction/start seen, the summary is being
- * generated), or applying (the summary landed, the compacted surface is
- * being committed). Derived by the runner from compaction/start →
- * compaction/summary → compaction/end (foldCompactionEvent). */
-type CompactionPhase = 'idle' | 'summarizing' | 'applying';
-/**
- * The WEB composer submit gestures (DSH `ComposerSubmitGesture`): plain
- * Enter, or the Cmd/Ctrl-accelerated chord. The busy-Enter policy resolves
- * each to a delivery mode — plain Enter to the preferred mode, the
- * accelerated chord to its OPPOSITE — so the chord is never a fixed mode.
- */
-type ComposerSubmitGesture = 'enter' | 'accelerated';
-/** One semantic queued pending-input row for the queue pane. */
-interface QueueItem {
-  /** The pending message id (agent inbox identity), or a local request id. */
-  id: string;
-  /** The message text, single-line display form. */
-  text: string;
-  /** next-turn followup vs next-step steer. */
-  mode: 'followup' | 'steer';
-  /** The correlation identity (authoritative rpc id or local request id). */
-  rpcId?: string;
-  /** A client-local echo not yet backed by an authoritative occurrence. */
-  local?: boolean;
-}
-//#endregion
-//#region src/surface-catalog.d.ts
-/** Minimal live-agent face consumed by the effective catalog readers. */
-interface SurfaceCatalogAgent {
-  readonly ctx: object;
-  readonly session: {
-    readonly header: {
-      readonly cwd?: string;
-    };
-  };
-}
+//#region src/domain/catalog/surface.d.ts
 /** Local structural command face, compatible with both npm and Source Mode DSH.
  * The optional identity is part of the official 0.1.6 descriptor; an older
  * runtime's descriptor may omit it. */
@@ -245,53 +101,42 @@ interface SurfaceCatalogSnapshot {
   readonly skills: readonly HumanSkillSummary[];
   readonly issues: readonly SurfaceCatalogIssue[];
 }
+/** The pre-mount catalog resolution result: the resume prefetch snapshot or
+ * the cold standing-scope skill catalog, plus an optional degradation notice. */
+interface InitialCatalogResolution {
+  /** The resume prefetch snapshot to install at mount. */
+  readonly snapshot?: SurfaceCatalogSnapshot;
+  /** The cold standing-scope human skill catalog (deferred start). */
+  readonly skills?: HumanSkillCatalog;
+  /** A user-facing notice when the prefetch/standing read degraded. */
+  readonly notice?: string;
+}
+//#endregion
+//#region src/runtime/direct/surface-catalog.d.ts
+/** Minimal live-agent face consumed by the effective catalog readers — and by
+ * {@link import('../../app/direct/initial-catalog.ts').SurfaceCatalogResolutionOptions}, so the
+ * published option type stays structural instead of inlining the Host Agent. */
+interface SurfaceCatalogAgent {
+  readonly ctx: object;
+  readonly session: {
+    readonly header: {
+      readonly cwd?: string;
+    };
+  };
+}
 /** The commands-service surface the collector reads. */
 interface SurfaceCommandsService {
   list(agent: SurfaceCatalogAgent): readonly SurfaceCommandDescriptor[];
 }
 /** The narrow context surface {@link readSurfaceCatalog} consumes. The
  * SKILL services are NOT reached here: every dsh skill/agent-presets
- * access goes through `src/skill-catalog.ts` (the single-point adapter,
- * plan appendix B.1). */
+ * access goes through `runtime/direct/skill-catalog.ts` (the single-point
+ * adapter, plan appendix B.1). */
 interface SurfaceCatalogContext {
   get(name: 'commands'): SurfaceCommandsService | undefined;
 }
 //#endregion
-//#region src/commands.d.ts
-/**
- * The effective mode ONE submission resolved at the submit boundary: whether
- * an agent-facing delivery steers into the running turn or queues behind it
- * (web `ComposerSubmissionPolicy` parity — an idle agent queues, plain Enter
- * takes the preference, and the accelerated chord takes its OPPOSITE).
- *
- * It is a property of the GESTURE, not of the persisted settings: a one-shot
- * gesture exists only inside the dispatch that resolved it, so every
- * downstream consumer (the TUI skill delivery) accepts this value instead of
- * re-deriving the mode from `busyEnter`.
- */
-type SubmitDelivery = 'steer' | 'queue';
-/**
- * The CURRENT host catalog's view of ONE parsed line (the DSH client
- * `CommandUiRuntime.matchEnter` decision table): whether the host CLAIMS the
- * line, and — for a claimed line — the claiming descriptor's attachment
- * declaration, so the dispatch can never consult two different catalog views
- * for the claim and the declaration.
- */
-type HostCommandClaim = {
-  readonly claimed: true;
-  /** The claiming descriptor's `input.attachments`
-   * (DSH `CommandInputDescriptor.attachments`): only a declaring command
-   * may be invoked with composer attachments. */
-  readonly attachments: boolean;
-} | {
-  readonly claimed: false;
-};
-//#endregion
-//#region src/index.d.ts
-/** Stable Cordis plugin name. */
-declare const name = "tui-runner";
-/** Core services required before the TUI can mount. */
-declare const inject: string[];
+//#region src/app/config/schema.d.ts
 /** Plugin config: the session to resume, resolved from the startup service,
  * plus the DSH 0.1.7 profile-owned live TUI preferences. Every preference
  * field is a schemastery `.volatile()` reference (PR A): the `tui-app`
@@ -335,7 +180,7 @@ interface Config {
   /** Busy-Enter delivery for plain Enter while the agent runs: 'queue'
    * (default) or 'steer'. */
   readonly busyEnter: Volatile<string>;
-  /** Local-shell sandbox for user-typed `!`/`!!` commands: 'bypass'
+  /** User-shell sandbox policy for user-typed `!`/`!!` commands: 'bypass'
    * (default) runs them outside the dsh sandbox, 'sandbox' routes them
    * through the dsh shell capability's policy. */
   readonly localShellSandbox: Volatile<string>;
@@ -346,16 +191,22 @@ interface Config {
   readonly displayPreset: Volatile<string>;
   /** Mid-turn progress-update cadence (off | milestones | frequent). */
   readonly progressUpdates: Volatile<string>;
+  /** Git attribution guidance mode (off | product | product-model). */
+  readonly gitAttribution: Volatile<string>;
   /** Visible-answer density guidance (default | concise | explanatory). */
   readonly responseStyle: Volatile<string>;
   /** Completion-notification mode ('unfocused' | 'always' | 'off'). */
   readonly notificationMode: Volatile<string>;
   /** Completion-notification method ('auto' | 'osc9' | 'osc777' | 'bell'). */
   readonly notificationMethod: Volatile<string>;
+  /** Terminal-progress protocol selection ('off' | '9;4' | '7501' |
+   * '9;4+7501'): which native terminal status protocols the TUI reports.
+   * Defaults to the dual protocol. */
+  readonly terminalProgress: Volatile<string>;
   /** Fullscreen mouse-wheel step ('1' | '2' | '3' | '5' | '8'). */
   readonly wheelScrollLines: Volatile<string>;
   /** The user keybinding overrides as a whole-value RAW field. The
-   * keybindings parser (src/keybindings/config.ts) is the only
+   * keybindings parser (src/tui/keybindings/config.ts) is the only
    * validation/parsing authority — the keybinding business schema
    * deliberately stays out of the plugin Config. */
   readonly keybindings: Volatile<unknown>;
@@ -365,6 +216,27 @@ interface Config {
   readonly legacySettingsMigrationVersion: Volatile<number>;
 }
 declare const Config: z<Config>;
+//#endregion
+//#region src/domain/command/policy.d.ts
+/**
+ * The transport/UI-neutral command-line policy (plan §27 / TS8-F3): which slash
+ * lines the TUI owns locally, which need no session, which lines are local for
+ * attachment purposes, and the ONE semantic line classification every dispatch
+ * gate consumes.
+ *
+ * Pure and Host-free (structural inputs plus DSH's own `parseCommand`), so the
+ * dispatch gates are testable headless and the presentation/submission paths
+ * share ONE classification. The application/submission-facing half (the
+ * image-rejection gate and the delivery resolver) lives in
+ * `app/submission/command-policy.ts`; the destructive-shell predicate lives in
+ * `domain/shell/danger.ts`.
+ *
+ * The AUTHORITATIVE Host-name fact stays an explicit input
+ * ({@link CommandLineClassificationFacts.hostOriginClaim}); this domain never
+ * derives Host authority from the effective claim union (which also carries the
+ * Client's own TUI registrations).
+ * @module @xmoon76/dsh-pi-tui/domain/command/policy
+ */
 /**
  * Slash commands that need no session: before the first user message
  * (deferred start) they run locally without creating one. Everything else
@@ -377,38 +249,29 @@ declare const Config: z<Config>;
  */
 declare const SESSIONLESS_COMMANDS: Set<string>;
 /**
- * The LOCAL-execute command set: TUI-owned UI/control commands AND core
- * control commands the TUI does not itself register (e.g. /kill) that
- * must ALWAYS run locally through the commands service, never steered,
- * regardless of the busyEnter preference. Everything NOT in this set —
- * plain prompts AND non-local commands (the per-skill slash commands like
- * /grilling or /matrix-cli) — flows through the busy-Enter submission
- * policy while the agent is running: web parity, where a skill invocation
- * is a plain `session.prompt` whose leading `/name` line the host's
- * pre-step listener (dsh-tool-skill) resolves into the injected skill
- * body — there is no command-execution wire for skills.
+ * The LOCAL-execute command set (PR5 v2 §1C-6 narrows its semantic role):
+ * TUI-owned UI/control names AND core control names the TUI dispatches but
+ * does not register (/kill). It remains the STATIC policy surface —
+ * reserved-name validation, the extension collision catalog
+ * (HOST_COMMAND_CATALOG), and the fallback term of the line classifier
+ * when no LIVE Client-registry test was supplied. It is NOT by itself an
+ * answer to "who owns this production line": ownership comes from the
+ * live sources (the genuine Host-origin descriptors, the Client registry,
+ * the extension registry, the skill-wrapper state) through
+ * {@link classifyCommandLine}.
+ *
+ * `/kill` is the explicit example of the rule and its DISPOSITION is
+ * deliberate: it has NO live Client registration (and no handler anywhere in
+ * this surface), so it is NOT a TUI-owned line and this set must never be
+ * consulted to decide ownership. What actually happens to a typed `/kill ...`
+ * follows the ordinary precedence, in this order: a genuine Host claim decides
+ * per that descriptor; a genuine Host NAME that resolves while its exact line
+ * is NOT claimed makes the line an ordinary submission; and only a name
+ * nothing owns keeps the command plane's resolution chance (the final,
+ * session-scoped catalog may still provide it). It stays in this set for
+ * reserved-name validation and the extension collision catalog only.
  */
 declare const LOCAL_COMMANDS: Set<string>;
-/**
- * Command semantics matrix (plan §19.3/M12): a LOCAL command line carrying a
- * staged image placeholder is REJECTED — local commands are pure UI
- * controls, never LLM prompts. AGENT-FACING input (plain prompts AND
- * per-skill slash invocations like `/grilling`) SUPPORTS images: the skill
- * wrapper builds its message through the same prepared-input path, so an
- * image-bearing skill line is a real multimodal prompt (review finding 4).
- * There is never a silent drop.
- * @param parsed - the parsed slash command, undefined for a plain prompt.
- * @param text - the submission text.
- * @param store - the live draft store.
- * @param isLocal - whether THIS LINE is a LOCAL (TUI-owned/UI) command; skill
- *   names answer false. Never derived from the name alone: a host command's
- *   input KIND decides which line it claims (see
- *   {@link commandIsLocalForAttachments}).
- */
-declare function commandRejectsImages(parsed: {
-  name: string;
-  rawInput?: string;
-} | undefined, text: string, store: DraftImageStoreLike, isLocal: boolean): boolean;
 /**
  * The STATIC host-owned command catalog (P1-04): the ownership sets
  * (LOCAL_COMMANDS and SESSIONLESS_COMMANDS — the TUI's own local/UI command
@@ -431,15 +294,17 @@ declare const HOST_COMMAND_CATALOG: ReadonlySet<string>;
  * @param name - the slash name.
  * @param isSkillWrapper - the live skill-wrapper test (absent = none).
  * @param isDynamicLocal - the live client-contribution test (absent = none).
- * @param hostView - the host catalog's view of THIS LINE (`undefined` = the
- *   catalog does not resolve the name at all; see {@link HostCommandClaim}).
- *   A name the catalog RESOLVES is never a client-local line: when the
- *   catalog claims the line the host's own `input.attachments` declaration
- *   decides, and when it does not (an argued line of an execute-kind
- *   command) the line is an ordinary submission — never a same-named client
- *   contribution's.
+ * @param hostResolvesName - whether the AUTHORITATIVE HOST CATALOG resolves
+ *   the NAME (PR5 supplement: derived from `hostCatalogResolves`, NEVER from
+ *   the effective line claim — the claim-set union also carries this
+ *   Client's own TUI registrations, so a self-claim must not disqualify the
+ *   TUI's own local commands). A Host-resolved name is never a client-local
+ *   line: when the catalog claims the line the host's own
+ *   `input.attachments` declaration decides, and when it does not (an argued
+ *   line of an execute-kind command) the line is an ordinary submission —
+ *   never a same-named client contribution's.
  */
-declare function isLocalCommandLine(name: string, isSkillWrapper: ((name: string) => boolean) | undefined, isDynamicLocal: ((name: string) => boolean) | undefined, hostView?: HostCommandClaim | undefined): boolean;
+declare function isLocalCommandLine(name: string, isSkillWrapper: ((name: string) => boolean) | undefined, isDynamicLocal: ((name: string) => boolean) | undefined, hostResolvesName: boolean): boolean;
 /**
  * Whether one parsed line is the BARE slash token (DSH `matchEnter`'s `bare`:
  * no input follows the name — trailing whitespace is not input). It is the
@@ -473,30 +338,16 @@ declare function isBareCommandLine(parsed: {
  * @param parsed - the parsed slash command (undefined = plain prompt).
  * @param isSkillWrapper - the live skill-wrapper test (absent = none).
  * @param isDynamicLocal - the live client-contribution test (absent = none).
- * @param hostClaim - the live HOST-catalog view of THIS LINE (absent = none).
+ * @param hostResolvesName - whether the AUTHORITATIVE HOST CATALOG resolves
+ *   the name (`hostCatalogResolves` — PR5 supplement: never derived from the
+ *   effective line claim, whose union carries the Client's own TUI
+ *   registrations).
  * @returns whether the line is a local command line.
  */
 declare function commandIsLocalForAttachments(parsed: {
   name: string;
   rawInput?: string;
-} | undefined, isSkillWrapper: ((name: string) => boolean) | undefined, isDynamicLocal: ((name: string) => boolean) | undefined, hostClaim?: ((parsed: {
-  name: string;
-  rawInput?: string;
-}) => HostCommandClaim | undefined) | undefined): boolean;
-/**
- * The TUI dispatch boundary's delivery resolution: the WEB composer policy
- * ({@link resolveComposerDelivery}) applied to agent-facing input, with the
- * TUI's own ownership terms on top. Pure so the dispatch gate (inside the
- * runner closure) is testable headless.
- * @param parsed - the parsed slash command, undefined for a plain prompt.
- * @param running - whether the live agent reports running.
- * @param gesture - the composer gesture that raised the submission.
- * @param busyEnter - the persisted preference value (''/undefined = queue).
- */
-declare function resolveSubmitDelivery(parsed: {
-  name: string;
-  rawInput?: string;
-} | undefined, running: boolean, gesture: ComposerSubmitGesture, busyEnter: string | undefined): SubmitDelivery;
+} | undefined, isSkillWrapper: ((name: string) => boolean) | undefined, isDynamicLocal: ((name: string) => boolean) | undefined, hostResolvesName: boolean): boolean;
 /**
  * Normalize an explicit `/skill <name> <args>` invocation to the skill's
  * own slash line `/<name> <args>` (review finding 2). The harness's
@@ -529,61 +380,388 @@ declare function normalizeSkillInvocation(text: string): string | undefined;
 declare function shouldConsumeAdvertisedMiss(execution: {
   readonly result: unknown;
 } | undefined, wasAdvertised: boolean): boolean;
-/** Public settlement shape for the interrupt helper. Kept local so the
- * entry-point declaration does not expose the internal runtime port module. */
-type InterruptWriteOutcome = {
-  readonly kind: 'committed';
-  readonly value: undefined;
-} | {
-  readonly kind: 'rejected';
-  readonly error: {
-    readonly code: string;
-    readonly message: string;
-    readonly details?: Readonly<Record<string, unknown>>;
-  };
-} | {
-  readonly kind: 'cancelled';
-} | {
-  readonly kind: 'indeterminate';
-  readonly error: {
-    readonly code: string;
-    readonly message: string;
-    readonly details?: Readonly<Record<string, unknown>>;
-  };
-} | {
-  readonly kind: 'unsupported';
-  readonly reason: string;
-};
-/** The live-agent surface {@link interruptAgent} needs (structural — the
- * TUI never imports the agent runtime for this call). */
-interface InterruptAgentLike {
-  readonly session: {
-    readonly id: string;
-  };
-  readonly status: string;
-  cancel(cause: {
-    kind: 'user';
-  }, options?: {
-    keepInbox?: boolean;
-  }): void;
-}
-/** The writer surface {@link interruptAgent} needs (structural — a LOCAL
- * type so the public declaration never inlines internal runtime modules;
- * the runner's SessionWriter satisfies it). */
-interface InterruptWriterLike {
-  cancel(sessionId: string): Promise<InterruptWriteOutcome>;
-}
 /**
- * Interrupt the live agent (web Stop parity): abort the current
- * turn/tool run while PRESERVING the pending queue. dsh's DEFAULT
- * `cancel()` clears queued AND steering input, so a bare cancel would
- * destroy everything the user queued with Ctrl+S / queue-mode Enter —
- * the Esc-interrupt semantic is "stop the current thinking", never
- * "drop the queue". `keepInbox: true` parks the preserved work; dsh's
- * cancel is a documented no-op when nothing is active, so an idle
- * interrupt (double-Esc while idle) is harmless and still aborts a
- * local shell / maintenance task through the caller.
- *
+ * Whether a plain submitted draft is the quit word: exactly `exit` (trimmed,
+ * lowercase). The runner intercepts this BEFORE any session creation or
+ * submission (shell muscle memory); anything else — `exit!`, `Exit`, or a
+ * draft with a recalled entry still in it — is an ordinary message.
+ * @param text - the submitted draft.
+ */
+declare function isPlainExitPrompt(text: string): boolean;
+//#endregion
+//#region src/domain/shell/danger.d.ts
+/**
+ * The destructive-shell predicate the approval dialog uses (kimi-inspired).
+ * Transport/UI-neutral: it answers exactly one question — whether one shell
+ * command matches a known destructive pattern — and owns nothing else.
+ * @module @xmoon76/dsh-pi-tui/domain/shell/danger
+ */
+/**
+ * Whether a shell command matches a destructive pattern. `rm` is treated
+ * specially: any spelling of recursive + force flags (`rm -rf`, `rm -r -f`,
+ * `rm -rf /`) is dangerous; the remaining patterns are verbatim matches.
+ */
+declare function dangerCommand(command: string): boolean;
+//#endregion
+//#region src/domain/media/types.d.ts
+/**
+ * Neutral media vocabulary shared by Client-local media capability, Direct
+ * application preparation, the transport-neutral prepared prompt and TUI
+ * presentation (TS8-C).
+ *
+ * Every shape here is a DETACHED structural fact — the accepted raster media
+ * types, one durable attachment reference and one deployment's image policy —
+ * that crosses several layers without carrying service, `Context`, `Agent` or
+ * Session authority. They deliberately mirror the `@deepseek-ai/dsh-attachment`
+ * shapes structurally, so no module needs a runtime dependency on that package
+ * (AGENTS.md decision 7).
+ *
+ * Host service interfaces (`saveImages`, `saveFileStream`, `resolveModelInfo`)
+ * MUST NOT enter this module: those are injected at the composition root and
+ * owned by the Direct application preparation.
+ * @module @xmoon76/dsh-pi-tui/domain/media/types
+ */
+/** Raster media types accepted by the TUI image intake. */
+type ImageMediaType = 'image/png' | 'image/jpeg' | 'image/webp' | 'image/gif';
+/** Structural subset of `ImageAttachmentRef`. */
+interface ImageAttachmentRefLike {
+  readonly attachmentId: string;
+  readonly mediaType: ImageMediaType;
+  readonly bytes: number;
+  readonly width: number;
+  readonly height: number;
+  readonly name?: string;
+}
+//#endregion
+//#region src/client/media/image/types.d.ts
+/** Per-TUI draft image identity; only meaningful inside one TUI run. */
+type DraftImageId = number;
+/** Where a staged image's bytes came from. */
+type DraftImageSource = {
+  readonly type: 'clipboard';
+} | {
+  readonly type: 'path';
+  readonly path: string;
+}
+/** The image was pulled back from a queued message: its bytes are ALREADY
+ * durable with the harness (the recalled ref) — the draft holds no local
+ * copy and re-submitting reuses the ref instead of re-uploading. */
+| {
+  readonly type: 'recalled';
+};
+/**
+ * One image staged in the editor draft. The draft holds the raw bytes so
+ * clipboard and path entries share one shape and a submit never depends on
+ * the source file still existing (plan §5.1). A RECALLED draft (pulled
+ * back from the queue) instead carries the durable `ImageAttachmentRef`
+ * and NO local bytes — the bytes stay in harness storage and re-submitting
+ * reuses the ref.
+ */
+interface DraftImage {
+  /** Per-TUI draft identity (the `#N` of the placeholder). */
+  readonly id: DraftImageId;
+  readonly kind: 'image';
+  readonly source: DraftImageSource;
+  /** Exact encoded bytes, held only for the draft lifetime. Empty for a
+   * recalled draft (its bytes live in harness storage). */
+  readonly bytes: Uint8Array;
+  readonly mediaType: ImageMediaType;
+  /** Intrinsic encoded width in pixels. */
+  readonly width: number;
+  /** Intrinsic encoded height in pixels. */
+  readonly height: number;
+  /** Exact encoded byte length (`bytes.byteLength` for local drafts; the
+   * durable ref's recorded `bytes` for recalled drafts). */
+  readonly byteLength: number;
+  /** Optional display name (basename for path sources), never a path. */
+  readonly name?: string;
+  /** The canonical editor placeholder text for this draft. */
+  readonly placeholder: string;
+  /** The durable ref this draft reuses on submit; present ONLY for
+   * recalled drafts (already-durable images are never re-uploaded). */
+  readonly recalledRef?: ImageAttachmentRefLike;
+}
+/** The store surface the placeholder expansion needs (structural). */
+interface DraftImageStoreLike {
+  values(): readonly DraftImage[];
+}
+//#endregion
+//#region src/app/surface/task-presentation.d.ts
+declare function subagentJobTranscriptId(snapshot: unknown): string | undefined;
+/**
+ * The Task Center row-selection disposition (plan §4.3/§4.4). A subagent
+ * transcript opens a session/viewer surface that REPLACES the browser; a
+ * Job row's detail keeps it mounted (the caller passes {@link openJobView}'s
+ * disposition). An UNKNOWN row — a stale panel selection after a live
+ * re-projection — also keeps the parent usable instead of dismissing it.
+ */
+declare function taskRowSelectionDisposition(row: {
+  readonly kind: 'job' | 'subagent';
+} | undefined, jobDetail: 'close' | 'keep-open'): 'close' | 'keep-open';
+/** Viewer body for a subagent job with no uniquely matched child. */
+declare function subagentJobViewHint(status: string, detail: string | undefined): string;
+//#endregion
+//#region src/app/surface/compaction-presentation.d.ts
+/**
+ * The compaction/context presentation module (A4-7, plan §16/§27): the pure
+ * compaction/context presentation folds consumed by the surface routing.
+ *
+ * These are the PURE presentation folds the `session/event` routing applies:
+ * compaction lifecycle pairing, the matched-settle surface effects, the
+ * turn-boundary busy rule, the context re-measure classification, and the
+ * resumed-session-log bootstrap folds (`workingFromLog`, `compactingFromLog`).
+ * They read no Host identity and no persistence, so they are an application-owned
+ * surface presentation module under `app/surface/**` (TS8-F5 moved them out of
+ * the top-level root).
+ *
+ * `src/index.ts` re-exports them unchanged to keep the public entry point
+ * byte-compatible (the published package and the regression suites import them
+ * from the package root).
+ *
+ * @module @xmoon76/dsh-pi-tui/app/surface/compaction-presentation
+ */
+/** The canonical compaction phase the mounted surface renders (TS8-F5 moved
+ * the union out of the tui-app.ts stable root; the root type-re-exports it). */
+type CompactionPhase = 'idle' | 'summarizing' | 'applying';
+/** One fold of a compaction lifecycle event over the in-flight compaction
+ * state. Pure (the routing applies the returned surface effects):
+ * dsh-compaction is not a peer, so the event is read structurally. */
+interface CompactionFold {
+  /** The updated in-flight compaction id (the newest start wins). */
+  id: string | undefined;
+  /** compaction/start: the compacting flag turns ON (footer/working row). */
+  active: boolean;
+  /** A MATCHED compaction/end: the compacting flag turns OFF and busy is
+   * re-derived from the turn log (a stale end never clears a newer
+   * compaction's state). */
+  clear: boolean;
+  /** The compaction phase the event implies: compaction/start →
+   * 'summarizing', a MATCHED compaction/summary → 'applying'. Undefined
+   * when the event does not advance the phase (a stale summary, any
+   * compaction/end — the settle clears via {@link clear}). */
+  phase?: Exclude<CompactionPhase, 'idle'>;
+  /** The settle notification for compaction/end, when one fires. */
+  notify: {
+    text: string;
+    kind: 'info' | 'error';
+  } | undefined;
+}
+/** Fold one compaction lifecycle event over the in-flight state. */
+declare function foldCompactionEvent(state: {
+  id: string | undefined;
+}, event: {
+  type: string;
+  data: {
+    compactionId?: unknown;
+    error?: unknown;
+  };
+}): CompactionFold;
+/** The minimal compaction-settle surface the routing passes in — STRUCTURAL
+ * on purpose: referencing the full {@link TuiApp} class from a public
+ * export would inline the whole surface (and its internal registry/
+ * presentation dependencies) into the published declaration bundle. The
+ * settle contract only needs the three phase/busy/working setters. */
+interface CompactionSettleSurface {
+  setCompactionPhase(phase: 'idle'): void;
+  setBusy(busy: boolean): void;
+  setWorking(busy: boolean): void;
+}
+/** The UI side effects of a MATCHED compaction settle: clear the phase,
+ * hand the working row back to the turn state, and re-measure the session
+ * surface so the footer context reflects the compacted log IMMEDIATELY —
+ * the next step/start or turn/end would otherwise delay the refresh.
+ * Exported as a seam so the settle contract is testable without a full
+ * runner driver (the firehose closure is not). */
+declare function settleCompactionSurface(app: CompactionSettleSurface, refreshStatus: () => void, busyNow: boolean): void;
+/** The busy flag after a turn-boundary event: a turn end must NOT clear
+ * the busy state while a compaction is still in flight — an interrupted
+ * turn can close (turn/end) before its compaction settles, and the
+ * single-Esc cancel must stay armed until compaction/end. */
+declare function busyAfterTurnBoundary(eventType: 'turn/start' | 'turn/end', compacting: boolean): boolean;
+/** PR D2 test seam: whether a session event type marks the model-visible
+ * context dirty (re-measure through the SessionReader port) or only
+ * repaints cheaply (cached measurement). The firehose routes every event
+ * through this classification — the single source of truth for the
+ * status/measurement split. `compaction/end` is classified 'measure' but
+ * the firehose deliberately SKIPS it here: a matched compaction settle
+ * re-measures through the fold-outcome path (settleCompactionSurface), so
+ * a STALE compaction/end can never trigger a measurement. */
+declare function contextRefreshKind(eventType: string): 'measure' | 'cheap';
+/**
+ * The in-flight compaction state a resumed session log implies: the newest
+ * compaction bracket decides. A `session/end-seed` boundary makes any
+ * EARLIER unmatched `compaction/start` STALE — the upstream invariant
+ * (inheritedOrphanStartSeqs) treats seed compactions that never settled
+ * inside the seed as abandoned, so they must not re-arm the compacting
+ * surface on resume.
+ */
+declare function compactingFromLog(events: readonly {
+  type: unknown;
+  data?: unknown;
+}[]): {
+  active: boolean;
+  id: string | undefined;
+};
+//#endregion
+//#region src/app/submission/pending-input.d.ts
+/** One semantic pending-input item as the queue mirror sees it. */
+interface QueueInboxMessage {
+  readonly id: string;
+  readonly content: readonly ContentBlock[];
+}
+//#endregion
+//#region src/app/surface/pending-presentation.d.ts
+/** One semantic queued pending-input row for the queue pane. */
+interface QueueItem {
+  /** The pending message id (agent inbox identity), or a local request id. */
+  id: string;
+  /** The message text, single-line display form. */
+  text: string;
+  /** next-turn followup vs next-step steer. */
+  mode: 'followup' | 'steer';
+  /** The correlation identity (authoritative rpc id or local request id). */
+  rpcId?: string;
+  /** A client-local echo not yet backed by an authoritative occurrence. */
+  local?: boolean;
+}
+/** The queue-pane rows for one semantic pending-input batch. */
+interface QueueFoldResult {
+  readonly rows: QueueItem[];
+}
+/** Build queue-pane rows from semantic pending-input occurrences, preserving
+ * their order and content without inspecting backend-specific metadata. */
+declare function foldQueueRows(messages: readonly QueueInboxMessage[], mode: 'followup' | 'steer'): QueueFoldResult;
+//#endregion
+//#region src/tui-app.d.ts
+/**
+ * The WEB composer submit gestures (DSH `ComposerSubmitGesture`): plain
+ * Enter, or the Cmd/Ctrl-accelerated chord. The busy-Enter policy resolves
+ * each to a delivery mode — plain Enter to the preferred mode, the
+ * accelerated chord to its OPPOSITE — so the chord is never a fixed mode.
+ */
+type ComposerSubmitGesture = 'enter' | 'accelerated';
+//#endregion
+//#region src/commands.d.ts
+/**
+ * The effective mode ONE submission resolved at the submit boundary: whether
+ * an agent-facing delivery steers into the running turn or queues behind it
+ * (web `ComposerSubmissionPolicy` parity — an idle agent queues, plain Enter
+ * takes the preference, and the accelerated chord takes its OPPOSITE).
+ *
+ * It is a property of the GESTURE, not of the persisted settings: a one-shot
+ * gesture exists only inside the dispatch that resolved it, so every
+ * downstream consumer (the TUI skill delivery) accepts this value instead of
+ * re-deriving the mode from `busyEnter`.
+ */
+type SubmitDelivery = 'steer' | 'queue';
+//#endregion
+//#region src/app/submission/command-policy.d.ts
+/**
+ * Command semantics matrix (plan §19.3/M12): a LOCAL command line carrying a
+ * staged image placeholder is REJECTED — local commands are pure UI
+ * controls, never LLM prompts. AGENT-FACING input (plain prompts AND
+ * per-skill slash invocations like `/grilling`) SUPPORTS images: the skill
+ * wrapper builds its message through the same prepared-input path, so an
+ * image-bearing skill line is a real multimodal prompt (review finding 4).
+ * There is never a silent drop.
+ * @param parsed - the parsed slash command, undefined for a plain prompt.
+ * @param text - the submission text.
+ * @param store - the live draft store.
+ * @param isLocal - whether THIS LINE is a LOCAL (TUI-owned/UI) command; skill
+ *   names answer false. Never derived from the name alone: a host command's
+ *   input KIND decides which line it claims (see
+ *   {@link commandIsLocalForAttachments}).
+ */
+declare function commandRejectsImages(parsed: {
+  name: string;
+  rawInput?: string;
+} | undefined, text: string, store: DraftImageStoreLike, isLocal: boolean): boolean;
+/**
+ * The TUI dispatch boundary's delivery resolution: the WEB composer policy
+ * ({@link resolveComposerDelivery}) applied to agent-facing input, with the
+ * TUI's own ownership terms on top. Pure so the dispatch gate (inside the
+ * runner closure) is testable headless.
+ * @param parsed - the parsed slash command, undefined for a plain prompt.
+ * @param running - whether the live agent reports running.
+ * @param gesture - the composer gesture that raised the submission.
+ * @param busyEnter - the persisted preference value (''/undefined = queue).
+ * @param isTuiLocalLine - whether the line is a TUI-LOCAL command line by
+ *   the §D3 line authority ({@link isLocalCommandLine}'s order: a
+ *   HOST-RESOLVED name — claimed or merely resolved — is never local). The
+ *   caller derives it once and shares it with every gate, so an argued
+ *   `/export foo` of an execute-kind Host command follows the ORDINARY
+ *   queue/steer busy policy instead of a local-command placeholder.
+ *   Absent = fall back to the legacy LOCAL_COMMANDS set (callers that have
+ *   no host view yet, e.g. the pre-parse echo path).
+ */
+declare function resolveSubmitDelivery(parsed: {
+  name: string;
+  rawInput?: string;
+} | undefined, running: boolean, gesture: ComposerSubmitGesture, busyEnter: string | undefined, isTuiLocalLine?: boolean): SubmitDelivery;
+//#endregion
+//#region src/app/session/interrupt.d.ts
+/**
+ * The live-turn interrupt helper (web Stop parity): abort the current
+ * turn/tool run while PRESERVING the pending queue. Kept out of the
+ * composition root so the rule is testable headless, and its structural
+ * faces keep the internal runtime port module out of the published entry.
+ * @module @xmoon76/dsh-pi-tui/app/session/interrupt
+ */
+/** Public settlement shape for the interrupt helper. Kept local so the
+ * entry-point declaration does not expose the internal runtime port module. */
+type InterruptWriteOutcome = {
+  readonly kind: 'committed';
+  readonly value: undefined;
+} | {
+  readonly kind: 'rejected';
+  readonly error: {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+  };
+} | {
+  readonly kind: 'cancelled';
+} | {
+  readonly kind: 'indeterminate';
+  readonly error: {
+    readonly code: string;
+    readonly message: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+  };
+} | {
+  readonly kind: 'unsupported';
+  readonly reason: string;
+};
+/** The live-agent surface {@link interruptAgent} needs (structural — the
+ * TUI never imports the agent runtime for this call). */
+interface InterruptAgentLike {
+  readonly session: {
+    readonly id: string;
+  };
+  readonly status: string;
+  cancel(cause: {
+    kind: 'user';
+  }, options?: {
+    keepInbox?: boolean;
+  }): void;
+}
+/** The writer surface {@link interruptAgent} needs (structural — a LOCAL
+ * type so the public declaration never inlines internal runtime modules;
+ * the runner's SessionWriter satisfies it). */
+interface InterruptWriterLike {
+  cancel(sessionId: string): Promise<InterruptWriteOutcome>;
+}
+/**
+ * Interrupt the live agent (web Stop parity): abort the current
+ * turn/tool run while PRESERVING the pending queue. dsh's DEFAULT
+ * `cancel()` clears queued AND steering input, so a bare cancel would
+ * destroy everything the user queued with Ctrl+S / queue-mode Enter —
+ * the Esc-interrupt semantic is "stop the current thinking", never
+ * "drop the queue". `keepInbox: true` parks the preserved work; dsh's
+ * cancel is a documented no-op when nothing is active, so an idle
+ * interrupt (double-Esc while idle) is harmless and still aborts a
+ * local shell / maintenance task through the caller.
+ *
  * NOTE (upstream dependency): dsh currently PARKS the preserved queue
  * after an abort — the "Esc with a queue continues immediately" UX
  * needs an upstream `wakePending`/`continueInbox` capability (not yet
@@ -593,6 +771,8 @@ interface InterruptWriterLike {
  * agreed web-parity behavior until upstream lands the capability.
  */
 declare function interruptAgent(agent: InterruptAgentLike | undefined, writer: InterruptWriterLike): Promise<InterruptWriteOutcome>;
+//#endregion
+//#region src/app/surface/viewer-policy.d.ts
 /** One unsettled subagent delegation, in tool/call order. */
 interface PendingSubagentCall {
   readonly callId: string;
@@ -664,218 +844,117 @@ declare function viewerActionCapability(action: TuiAction, viewer: {
  * @returns the matched call, or undefined when nothing matches.
  */
 declare function matchPendingSubagentCall(pending: PendingSubagentCall[], label: string | undefined): PendingSubagentCall | undefined;
+//#endregion
+//#region src/client/launcher/profile.d.ts
 /**
- * The pre-mount surface catalog resolution:
- * - an explicit `--session` start PREFETCHES the resumed agent's effective
- *   catalog (a live read emits no session events);
- * - the deferred start (no `--session`) reads the cold HUMAN SKILL catalog
- *   through the preset's STANDING SCOPE — no Agent, no session, no turn —
- *   so the first input sees human-invocable skills without any durable
- *   side effect (the mechanism that avoids the probe dead end: host
- *   `session/created` observers write durable knob events into every fresh
- *   session).
+ * The Client-local DSH launcher PROFILE reads: the `--profile` argv scrape and
+ * the interactive-quit resume hint.
  *
- * The snapshot (resume) or the skill catalog (cold) installs synchronously
- * after mount (the ready barrier).
- *
- * Failure taxonomy (plan appendix B):
- * - lifecycle cancellation: nothing installed, no notice;
- * - a prefetch/standing read failure degrades to a one-shot notice (the
- *   TUI mounts with the global view and built-in commands);
- * - a missing/unknown preset or a broken standing mount degrades the cold
- *   target to the global layer with a one-shot notice — never a probe
- *   Agent, never a startup failure;
- * - an ordinary provider read failure never rejects here: it becomes an
- *   empty field + detached issue inside the catalog.
- * @param options - injected dependencies (see {@link ResolveInitialCatalogOptions}).
- * @returns the snapshot / skill catalog to install and an optional notice.
- */
-interface InitialCatalogResolution {
-  /** The resume prefetch snapshot to install at mount. */
-  readonly snapshot?: SurfaceCatalogSnapshot;
-  /** The cold standing-scope human skill catalog (deferred start). */
-  readonly skills?: HumanSkillCatalog;
-  /** A user-facing notice when the prefetch/standing read degraded. */
-  readonly notice?: string;
-}
-/** Options for {@link resolveInitialCatalog}. */
-interface ResolveInitialCatalogOptions {
-  /** The resumed live agent, if any (prefetch path). */
-  readonly liveAgent?: Agent;
-  /** The effective preset id for the cold standing read (undefined = the
-   * deployment default; only consulted for the deferred start). */
-  readonly presetId?: string;
-  readonly signal: AbortSignal;
-  /** The context surface the collectors read services from. */
-  readonly ctx: SurfaceCatalogContext;
-  readonly diag: Diag;
-  /** Suspend the pre-mount startup status before an ordinary log write
-   * (the status owns the current terminal line; a TTY shares one cursor
-   * between stdout and stderr). Called right before every diag.warn this
-   * function may emit. */
-  readonly onLog?: () => void;
-}
-declare function resolveInitialCatalog(options: ResolveInitialCatalogOptions): Promise<InitialCatalogResolution>;
-declare function subagentJobTranscriptId(snapshot: unknown): string | undefined;
-/**
- * The Task Center row-selection disposition (plan §4.3/§4.4). A subagent
- * transcript opens a session/viewer surface that REPLACES the browser; a
- * Job row's detail keeps it mounted (the caller passes {@link openJobView}'s
- * disposition). An UNKNOWN row — a stale panel selection after a live
- * re-projection — also keeps the parent usable instead of dismissing it.
- */
-declare function taskRowSelectionDisposition(row: {
-  readonly kind: 'job' | 'subagent';
-} | undefined, jobDetail: 'close' | 'keep-open'): 'close' | 'keep-open';
-/** Viewer body for a subagent job with no uniquely matched child. */
-declare function subagentJobViewHint(status: string, detail: string | undefined): string;
-/**
- * Whether a plain submitted draft is the quit word: exactly `exit` (trimmed,
- * lowercase). The runner intercepts this BEFORE any session creation or
- * submission (shell muscle memory); anything else — `exit!`, `Exit`, or a
- * draft with a recalled entry still in it — is an ordinary message.
- * @param text - the submitted draft.
- */
-declare function isPlainExitPrompt(text: string): boolean;
-/** One semantic pending-input item as the queue mirror sees it. */
-interface QueueInboxMessage {
-  readonly id: string;
-  readonly content: readonly ContentBlock[];
-}
-/** The queue-pane rows for one semantic pending-input batch. */
-interface QueueFoldResult {
-  readonly rows: QueueItem[];
-}
-/** Build queue-pane rows from semantic pending-input occurrences, preserving
- * their order and content without inspecting backend-specific metadata. */
-declare function foldQueueRows(messages: readonly QueueInboxMessage[], mode: 'followup' | 'steer'): QueueFoldResult;
-/**
- * Whether a shell command matches a destructive pattern. `rm` is treated
- * specially: any spelling of recursive + force flags (`rm -rf`, `rm -r -f`,
- * `rm -rf /`) is dangerous; the remaining patterns are verbatim matches.
+ * Deliberately NOT part of `src/startup.ts`: the startup row is a
+ * zero-dependency island that must not share a bundle chunk with the runner,
+ * so these runner-side helpers live in their own module. The authoritative
+ * Host profile identity (`hostRunningProfile`) is application bootstrap
+ * ownership (`app/bootstrap/profile.ts`) and consumes this argv fallback.
+ * @module @xmoon76/dsh-pi-tui/client/launcher/profile
  */
-declare function dangerCommand(command: string): boolean;
 /**
  * The dsh profile named by the `--profile` flag in `argv`, in both spellings.
  * This is the ARGV-ONLY fallback: it cannot see the positional `dsh <name>`
  * launch form, because the launcher consumes that bare name by synthesizing
  * `['--profile', ...argv]` for its OWN commander parse and leaves
- * `process.argv` untouched. Prefer {@link hostRunningProfile}, which reads the
- * Host's profile identity instead of scraping the command line.
+ * `process.argv` untouched. Prefer `hostRunningProfile`, which reads the Host's
+ * profile identity instead of scraping the command line.
  * @param argv - the process argument vector.
  * @param fallback - the default profile.
  */
 declare function runningProfile(argv?: readonly string[], fallback?: string): string;
+/**
+ * The interactive-quit resume hint (pi parity): `dsh --profile <p>
+ * --session <id>`, printed after the terminal restores so the user can
+ * re-enter the session later. Returns undefined when there is no session
+ * to resume (deferred start never created one).
+ * @param profile - the running profile (`hostRunningProfile`).
+ * @param sessionId - the live session id.
+ * @returns the resume command line, or undefined without a session.
+ */
+declare function resumeCommand(profile: string, sessionId: string): string | undefined;
+//#endregion
+//#region src/app/bootstrap/profile.d.ts
+/**
+ * The authoritative running-profile read for this process — the official Host
+ * `profileContext.name` when it is composed, else the Client-local argv scrape
+ * (`client/launcher/profile.ts`).
+ *
+ * `profileContext.name` is the launcher's own profile identity, so it is
+ * correct for EVERY launch form: `--profile <name>`, `--profile=<name>`, the
+ * positional `dsh <name>`, and `--from-default-profile <name>`. The argv scrape
+ * only knows the flag form, which is why it is the fallback for a profile-less
+ * mount (tests, an embedded surface) rather than the primary source. Bootstrap
+ * composition ownership: it reads one Host context service and nothing else.
+ * @module @xmoon76/dsh-pi-tui/app/bootstrap/profile
+ */
 /** The one context read {@link hostRunningProfile} needs (a cordis Context satisfies it). */
 interface ProfileContextReadLike {
   get(name: string): unknown;
 }
 /**
- * The profile this process actually runs — the official Host
- * `profileContext.name` when it is composed, else {@link runningProfile}'s
- * argv scrape.
- *
- * `profileContext.name` is the launcher's own profile identity, so it is
- * correct for EVERY launch form: `--profile <name>`, `--profile=<name>`, the
- * positional `dsh <name>`, and `--from-default-profile <name>`. The argv
- * scrape only knows the flag form, which is why it is the fallback for a
- * profile-less mount (tests, an embedded surface) rather than the primary
- * source.
+ * The profile this process actually runs.
  * @param ctx - the plugin context (or any structural `get`-only stand-in).
  * @param argv - the process argument vector for the fallback path.
  * @param fallback - the default profile for the fallback path.
  * @returns the running profile name.
  */
 declare function hostRunningProfile(ctx: ProfileContextReadLike, argv?: readonly string[], fallback?: string): string;
+//#endregion
+//#region src/index.d.ts
+/** Stable Cordis plugin name. */
+declare const name = "tui-runner";
+/** Core services required before the TUI can mount. */
+declare const inject: string[];
 /**
- * The interactive-quit resume hint (pi parity): `dsh --profile <p>
- * --session <id>`, printed after the terminal restores so the user can
- * re-enter the session later. Returns undefined when there is no session
- * to resume (deferred start never created one).
- * @param profile - the running profile ({@link hostRunningProfile}).
- * @param sessionId - the live session id.
- * @returns the resume command line, or undefined without a session.
+ * Options for {@link resolveInitialCatalog}.
+ *
+ * The public declaration stays here (A5a review P1): `liveAgent` keeps the Host
+ * `Agent` type it has always had, so consumers that READ the property keep
+ * compiling. The implementation consumes the structural
+ * `SurfaceCatalogResolutionOptions` in `app/direct/initial-catalog.ts`.
  */
-declare function resumeCommand(profile: string, sessionId: string): string | undefined;
-/** One fold of a compaction lifecycle event over the runner's in-flight
- * compaction state. Pure (the firehose applies the returned surface
- * effects): dsh-compaction is not a peer, so the event is read
- * structurally. */
-interface CompactionFold {
-  /** The updated in-flight compaction id (the newest start wins). */
-  id: string | undefined;
-  /** compaction/start: the compacting flag turns ON (footer/working row). */
-  active: boolean;
-  /** A MATCHED compaction/end: the compacting flag turns OFF and busy is
-   * re-derived from the turn log (a stale end never clears a newer
-   * compaction's state). */
-  clear: boolean;
-  /** The compaction phase the event implies: compaction/start →
-   * 'summarizing', a MATCHED compaction/summary → 'applying'. Undefined
-   * when the event does not advance the phase (a stale summary, any
-   * compaction/end — the settle clears via {@link clear}). */
-  phase?: Exclude<CompactionPhase, 'idle'>;
-  /** The settle notification for compaction/end, when one fires. */
-  notify: {
-    text: string;
-    kind: 'info' | 'error';
-  } | undefined;
-}
-/** Fold one compaction lifecycle event over the in-flight state. */
-declare function foldCompactionEvent(state: {
-  id: string | undefined;
-}, event: {
-  type: string;
-  data: {
-    compactionId?: unknown;
-    error?: unknown;
-  };
-}): CompactionFold;
-/** The minimal compaction-settle surface the runner passes in — STRUCTURAL
- * on purpose: referencing the full {@link TuiApp} class from a public
- * export would inline the whole surface (and its internal registry/
- * presentation dependencies) into the published declaration bundle. The
- * settle contract only needs the three phase/busy/working setters. */
-interface CompactionSettleSurface {
-  setCompactionPhase(phase: 'idle'): void;
-  setBusy(busy: boolean): void;
-  setWorking(busy: boolean): void;
+interface ResolveInitialCatalogOptions {
+  /** The resumed live agent, if any (prefetch path). */
+  readonly liveAgent?: Agent;
+  /** The effective preset id for the cold standing read (undefined = the
+   * deployment default; only consulted for the deferred start). */
+  readonly presetId?: string;
+  readonly signal: AbortSignal;
+  /** The context surface the collectors read services from. */
+  readonly ctx: SurfaceCatalogContext;
+  readonly diag: Diag;
+  /** Suspend the pre-mount startup status before an ordinary log write
+   * (the status owns the current terminal line; a TTY shares one cursor
+   * between stdout and stderr). Called right before every diag.warn this
+   * function may emit. */
+  readonly onLog?: () => void;
 }
-/** The UI side effects of a MATCHED compaction settle: clear the phase,
- * hand the working row back to the turn state, and re-measure the session
- * surface so the footer context reflects the compacted log IMMEDIATELY —
- * the next step/start or turn/end would otherwise delay the refresh.
- * Exported as a seam so the settle contract is testable without a full
- * runner driver (the firehose closure is not). */
-declare function settleCompactionSurface(app: CompactionSettleSurface, refreshStatus: () => void, busyNow: boolean): void;
-/** The busy flag after a turn-boundary event: a turn end must NOT clear
- * the busy state while a compaction is still in flight — an interrupted
- * turn can close (turn/end) before its compaction settles, and the
- * single-Esc cancel must stay armed until compaction/end. */
-declare function busyAfterTurnBoundary(eventType: 'turn/start' | 'turn/end', compacting: boolean): boolean;
-/** PR D2 test seam: whether a session event type marks the model-visible
- * context dirty (re-measure through the SessionReader port) or only
- * repaints cheaply (cached measurement). The firehose routes every event
- * through this classification — the single source of truth for the
- * status/measurement split. `compaction/end` is classified 'measure' but
- * the firehose deliberately SKIPS it here: a matched compaction settle
- * re-measures through the fold-outcome path (settleCompactionSurface), so
- * a STALE compaction/end can never trigger a measurement. */
-declare function contextRefreshKind(eventType: string): 'measure' | 'cheap';
 /**
- * The in-flight compaction state a resumed session log implies: the newest
- * compaction bracket decides. A `session/end-seed` boundary makes any
- * EARLIER unmatched `compaction/start` STALE — the upstream invariant
- * (inheritedOrphanStartSeqs) treats seed compactions that never settled
- * inside the seed as abandoned, so they must not re-arm the compacting
- * surface on resume.
+ * The pre-mount surface catalog resolution (plan §27): the published entry for
+ * {@link ResolveInitialCatalogOptions}. An explicit `--session` start
+ * prefetches the resumed agent's effective catalog; the deferred start reads the
+ * cold HUMAN SKILL catalog through the preset's STANDING SCOPE — no Agent, no
+ * session, no turn — so the first input sees human-invocable skills without any
+ * durable side effect. The implementation and its pre-mount failure taxonomy
+ * live in `app/direct/initial-catalog.ts`.
+ * @param options - injected dependencies (see {@link ResolveInitialCatalogOptions}).
+ * @returns the snapshot / skill catalog to install and an optional notice.
  */
-declare function compactingFromLog(events: readonly {
-  type: unknown;
-  data?: unknown;
-}[]): {
-  active: boolean;
-  id: string | undefined;
+declare function resolveInitialCatalog(options: ResolveInitialCatalogOptions): Promise<InitialCatalogResolution>;
+/**
+ * The PUBLIC structural shape of the shared mutable display authority. The
+ * canonical owner is `src/domain/display/preset.ts` (`DisplayState`); the
+ * published `composeAgent` signature stays STRUCTURAL so the internal source
+ * path never leaks into the declaration bundle (TS8-D).
+ */
+type DisplayState = {
+  preset: 'focus' | 'compact' | 'full';
 };
 /** One agent's preset composition: the id to record and the setup that installs it. */
 interface AgentComposition {
@@ -945,4 +1024,4 @@ declare function recordedPreset(ctx: Context, sessionId: string): Promise<string
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { AgentComposition, CompactionFold, CompactionSettleSurface, Config, HOST_COMMAND_CATALOG, InitialCatalogResolution, InterruptAgentLike, InterruptWriteOutcome, InterruptWriterLike, LOCAL_COMMANDS, PendingSubagentCall, ProfileContextReadLike, QueueFoldResult, QueueInboxMessage, ResolveInitialCatalogOptions, SESSIONLESS_COMMANDS, ViewerOpenToken, apply, busyAfterTurnBoundary, commandIsLocalForAttachments, commandRejectsImages, compactingFromLog, composeAgent, contextRefreshKind, createViewerOpenToken, dangerCommand, foldCompactionEvent, foldQueueRows, hostRunningProfile, inject, interruptAgent, isBareCommandLine, isLocalCommandLine, isPlainExitPrompt, matchPendingSubagentCall, name, normalizeSkillInvocation, recordedPreset, resolveInitialCatalog, resolveSubmitDelivery, resumeCommand, runningProfile, settleCompactionSurface, shouldConsumeAdvertisedMiss, subagentJobTranscriptId, subagentJobViewHint, taskRowSelectionDisposition, teardownViewerForSessionSwap, viewerActionCapability };
+export { AgentComposition, type CompactionFold, type CompactionSettleSurface, Config, HOST_COMMAND_CATALOG, type InitialCatalogResolution, type InterruptAgentLike, type InterruptWriteOutcome, type InterruptWriterLike, LOCAL_COMMANDS, type PendingSubagentCall, type ProfileContextReadLike, type QueueFoldResult, type QueueInboxMessage, ResolveInitialCatalogOptions, SESSIONLESS_COMMANDS, type ViewerOpenToken, apply, busyAfterTurnBoundary, commandIsLocalForAttachments, commandRejectsImages, compactingFromLog, composeAgent, contextRefreshKind, createViewerOpenToken, dangerCommand, foldCompactionEvent, foldQueueRows, hostRunningProfile, inject, interruptAgent, isBareCommandLine, isLocalCommandLine, isPlainExitPrompt, matchPendingSubagentCall, name, normalizeSkillInvocation, recordedPreset, resolveInitialCatalog, resolveSubmitDelivery, resumeCommand, runningProfile, settleCompactionSurface, shouldConsumeAdvertisedMiss, subagentJobTranscriptId, subagentJobViewHint, taskRowSelectionDisposition, teardownViewerForSessionSwap, viewerActionCapability };