@xmoon76/dsh-pi-tui 0.5.0 → 0.5.1

package/dist/index.d.mts

@@ -1,27 +1,20 @@
-import { H as TuiAction } from "./public-types-YbB5Rhku.mjs";
+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";
 import { Agent, ModelSelectionRef } from "@deepseek-ai/dsh-agent";
 import z from "@deepseek-ai/schemastery";
-//#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;
+//#region src/domain/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/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;
@@ -31,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 {
@@ -80,18 +53,7 @@ interface HumanSkillCatalog {
   readonly complete: boolean;
 }
 //#endregion
-//#region src/surface-catalog.d.ts
-/** Minimal live-agent face consumed by the effective catalog readers — and by
- * {@link ResolveInitialCatalogOptions}, 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;
-    };
-  };
-}
+//#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. */
@@ -139,27 +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;
 }
-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/tui-config.d.ts
+//#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`
@@ -203,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>;
@@ -214,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>;
@@ -234,160 +217,26 @@ interface Config {
 }
 declare const Config: z<Config>;
 //#endregion
-//#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
+//#region src/domain/command/policy.d.ts
 /**
- * Image draft vocabulary for the TUI input pipeline (plan M1).
+ * 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.
  *
- * 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[];
-}
-//#endregion
-//#region src/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/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/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).
+ * 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`.
  *
- * 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`.
+ * 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
  */
-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/command-policy.d.ts
 /**
  * Slash commands that need no session: before the first user message
  * (deferred start) they run locally without creating one. Everything else
@@ -400,38 +249,29 @@ type HostCommandClaim = {
  */
 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
@@ -454,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
@@ -496,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
@@ -560,6 +388,14 @@ declare function shouldConsumeAdvertisedMiss(execution: {
  * @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`,
@@ -567,37 +403,333 @@ declare function isPlainExitPrompt(text: string): boolean;
  */
 declare function dangerCommand(command: string): boolean;
 //#endregion
-//#region src/interrupt.d.ts
+//#region src/domain/media/types.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/interrupt
+ * 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
  */
-/** 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>>;
-  };
+/** 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 kind: 'unsupported';
+  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
@@ -640,7 +772,7 @@ interface InterruptWriterLike {
  */
 declare function interruptAgent(agent: InterruptAgentLike | undefined, writer: InterruptWriterLike): Promise<InterruptWriteOutcome>;
 //#endregion
-//#region src/subagent-viewer.d.ts
+//#region src/app/surface/viewer-policy.d.ts
 /** One unsettled subagent delegation, in tool/call order. */
 interface PendingSubagentCall {
   readonly callId: string;
@@ -713,153 +845,66 @@ declare function viewerActionCapability(action: TuiAction, viewer: {
  */
 declare function matchPendingSubagentCall(pending: PendingSubagentCall[], label: string | undefined): PendingSubagentCall | undefined;
 //#endregion
-//#region src/pending-presentation.d.ts
-/** 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;
-//#endregion
-//#region src/compaction-presentation.d.ts
-/** 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/dsh-profile.d.ts
+//#region src/client/launcher/profile.d.ts
 /**
- * The DSH launcher PROFILE identity and the resume hint (plan §27).
+ * The Client-local DSH launcher PROFILE reads: the `--profile` argv scrape and
+ * the interactive-quit resume hint.
  *
  * 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 and the entry
- * re-exports them unchanged.
- * @module @xmoon76/dsh-pi-tui/dsh-profile
+ * 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
  */
 /**
  * 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;
-/**
- * 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.
- */
-declare function resumeCommand(profile: string, sessionId: string): string | undefined;
 //#endregion
 //#region src/index.d.ts
 /** Stable Cordis plugin name. */
@@ -872,7 +917,7 @@ declare const inject: string[];
  * 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 `surface-catalog.ts`.
+ * `SurfaceCatalogResolutionOptions` in `app/direct/initial-catalog.ts`.
  */
 interface ResolveInitialCatalogOptions {
   /** The resumed live agent, if any (prefetch path). */
@@ -896,12 +941,21 @@ interface ResolveInitialCatalogOptions {
  * 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 failure taxonomy live in
- * `surface-catalog.ts`.
+ * 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 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 {
   /** Preset id for the session header, absent when the deployment composes no roster. */