@xmoon76/dsh-pi-tui 0.1.8 → 0.2.0

package/dist/extension/advanced.mjs

@@ -0,0 +1,46 @@
+//#region src/extension/advanced-types.ts
+/** API level of the advanced tier. Bumped only on advanced breaking changes. */
+const ADVANCED_API_LEVEL = 1;
+//#endregion
+//#region src/extension/advanced.ts
+/**
+* Build the ADVANCED facade over the shared `piTuiExtensions` service
+* (plan §4). The facade is a thin capability view: every resource it
+* creates is caller-fiber-owned and surface-generation-scoped through the
+* service's shared Extension Runtime — never a second plugin system.
+*
+* The facade is safe to call before any surface exists: registrations
+* (input captures) are service-lifetime and attach later; leases
+* (interactive overlays) and the editor controls are inert until a
+* surface is live.
+*
+* The parameter is the structural {@link AdvancedServiceHost}: a plain
+* `PiTuiExtensionService` value is accepted (the seam members are optional
+* in the type), and the facade throws loudly when the host does not
+* implement the seam (a host/plugin version mismatch).
+* @param service - the `piTuiExtensions` service (from `ctx.get(...)`).
+* @returns the Advanced facade.
+*/
+function advanced(service) {
+	const host = service;
+	if (host._advancedCaptureInput === void 0 || host._advancedShowInteractiveOverlay === void 0 || host._advancedEditorControls === void 0 || host._advancedUiSelect === void 0 || host._advancedUiConfirm === void 0 || host._advancedUiInput === void 0 || host._advancedUiNotify === void 0 || host._advancedUiCustom === void 0 || host._advancedHostState === void 0) throw new Error("this piTuiExtensions host does not implement the advanced seam (host/plugin version mismatch? upgrade the host bundle)");
+	return {
+		input: { capture: (spec) => host._advancedCaptureInput(spec) },
+		ui: {
+			showInteractiveOverlay: (component, options) => host._advancedShowInteractiveOverlay(component, options),
+			select: (options) => host._advancedUiSelect(options),
+			confirm: (options) => host._advancedUiConfirm(options),
+			input: (options) => host._advancedUiInput(options),
+			notify: (message, options) => host._advancedUiNotify(message, options),
+			custom: (factory, options) => host._advancedUiCustom(factory, options)
+		},
+		get editor() {
+			return host._advancedEditorControls();
+		},
+		get host() {
+			return host._advancedHostState();
+		}
+	};
+}
+//#endregion
+export { ADVANCED_API_LEVEL, advanced };

package/dist/extension/unstable.d.mts

@@ -0,0 +1,206 @@
+import { E as PiTuiApiInfo, _ as ExtensionTier, at as TuiOverlayOptions } from "../public-types-2omeXG8d.mjs";
+
+//#region src/extension/unstable-types.d.ts
+/** API level of the unstable tier. Bumped only on unstable breaking changes. */
+declare const UNSTABLE_API_LEVEL: 1;
+/**
+ * One raw terminal input chunk (plan §5). The plugin receives the RAW
+ * bytes exactly as the terminal delivered them — no decoding, no
+ * sanitization. `surfaceId` identifies the surface generation the chunk
+ * arrived on.
+ */
+interface UnstableRawInputEvent {
+  /** The raw terminal data (a chunk, not necessarily one key). */
+  readonly data: string;
+  /** The surface generation the chunk arrived on. */
+  readonly surfaceId: string;
+}
+/** The outcome of one raw interception (plan §5). */
+type UnstableRawInputResult = /** Pass the chunk through unchanged (the Host continues processing). */{
+  readonly action: 'pass';
+} /** Consume the chunk (the Host does nothing further with it). */ | {
+  readonly action: 'consume';
+}
+/** Rewrite the chunk: the Host decodes the REPLACEMENT data instead.
+ * Each terminal chunk passes the interception chain at most once — the
+ * replacement goes straight to the Host decoder, never re-entering the
+ * chain (no recursion). */
+| {
+  readonly action: 'rewrite';
+  readonly data: string;
+};
+/** The raw capture modes (plan §5). */
+type UnstableRawCaptureMode = 'observe' | 'capture' | 'exclusive';
+/**
+ * One raw input capture registration (plan §5/§8). The capture is
+ * consulted by the Host BEFORE terminal protocol decoding — it can see,
+ * consume or rewrite ANY raw chunk, including Enter, Esc, Ctrl+C, paste,
+ * CSI-u sequences and terminal-specific protocols. This is the Unstable
+ * contract: a broken capture can make Host shortcuts stop working. The
+ * ONLY Host-owned recovery is the emergency fail-safe (triple-Esc), which
+ * the Unstable API cannot rewrite.
+ *
+ * Modes:
+ * - `observe` — never consumes or rewrites; a pure observer.
+ * - `capture` — may consume or rewrite.
+ * - `exclusive` — the SOLE capture consumer while live: capture-mode
+ *   captures are not consulted (observers still run). A second exclusive
+ *   registration is an explicit error, never a load-order winner.
+ *
+ * Ordering is deterministic: `priority` ASC, then `id` ASC. A throwing
+ * handler is isolated (health ledger) and FAILS OPEN — the chunk passes
+ * through, so a broken capture can never stall the TUI.
+ */
+interface UnstableRawInputSpec {
+  /** Stable diagnostic identity, unique per owner. */
+  readonly id: string;
+  /** Deterministic ordering: priority ASC, then id ASC. */
+  readonly priority?: number;
+  /** observe | capture | exclusive (default: capture). */
+  readonly mode?: UnstableRawCaptureMode;
+  /** Optional gate: the capture is consulted only while this returns true.
+   * A throwing gate is treated as false (the capture is skipped). */
+  readonly when?: () => boolean;
+  /**
+   * The raw handler. Return {@link UnstableRawInputResult} to
+   * pass/consume/rewrite; return void/undefined to pass. A throwing
+   * handler is isolated and fails open.
+   */
+  handle(event: UnstableRawInputEvent): UnstableRawInputResult | void;
+}
+/** A live handle on one raw input capture. */
+interface UnstableRawInputHandle {
+  readonly id: string;
+  /** Remove the capture. Idempotent; owner unload also disposes it. */
+  dispose(): void;
+}
+/**
+ * A low-level mounted component (plan §9, option A): the plugin renders RAW
+ * lines (no Host sanitization — the Unstable contract) and receives RAW
+ * input. The Host owns the physical mount, focus and teardown; the plugin
+ * owns the rendering and input semantics.
+ */
+interface UnstableMountedComponent {
+  /** Render the current state as raw terminal lines at the given width. */
+  render(width: number): string[];
+  /** Receive one raw input chunk while this component owns focus. */
+  handleInput?(raw: string): void;
+  /** The component was disposed (mount closed / surface died). */
+  dispose?(): void;
+}
+/**
+ * A live lease on one low-level mount (plan §9/§10). The lease is
+ * caller-fiber-owned: owner unload closes the mount; a stale lease
+ * (surface disposed) is inert.
+ */
+interface UnstableMountLease {
+  /** The lease identity (stable diagnostic id). */
+  readonly id: string;
+  /** Whether the mount is still live (false after close/dispose). */
+  readonly active: boolean;
+  /** Whether the mount currently owns keyboard focus. */
+  readonly focused: boolean;
+  /** Request focus for the mount (also shows it if hidden). */
+  focus(): void;
+  /** Release focus. */
+  blur(): void;
+  /** Request a repaint of the mount. */
+  invalidate(): void;
+  /** Close the mount (idempotent; the surface's dispose also closes it). */
+  close(): void;
+  /** Temporarily hide (the lease stays live). */
+  hide(): void;
+  /** Show again after hide(). */
+  show(): void;
+}
+/**
+ * The low-level surface handle (plan §10): a SELECTED set of Host surface
+ * capabilities for low-level plugins. It NEVER exposes `TuiApp`,
+ * `TuiMainScreen`, `TuiAltScreen` or the terminal object — only the
+ * capabilities a low-level plugin genuinely needs. A stale handle
+ * (surface disposed) is inert.
+ */
+interface UnstableSurfaceHandle {
+  /** The attached surface generation's id. */
+  readonly surfaceId: string;
+  /** The surface generation (stable across start/stop/fullscreen). */
+  readonly generation: number;
+  /** The current terminal width in cells. */
+  readonly width: number;
+  /** The current terminal height in rows. */
+  readonly height: number;
+  /** Request a repaint of the active screen. */
+  requestRender(): void;
+  /**
+   * Mount a low-level component (plan §9 option A) as a capturing overlay.
+   * The plugin renders RAW lines and receives RAW input; the Host owns
+   * the physical mount, focus, stacking, fullscreen migration and
+   * teardown. Caller-fiber-owned lease.
+   */
+  mountComponent(component: UnstableMountedComponent, options?: TuiOverlayOptions): UnstableMountLease;
+}
+/** The unstable input facade (plan §5). */
+interface UnstableInputFacade {
+  /**
+   * Register a raw input capture. Caller-fiber-owned: owner unload
+   * removes it. A duplicate id or a second exclusive capture is an
+   * explicit error.
+   */
+  captureRaw(spec: UnstableRawInputSpec): UnstableRawInputHandle;
+}
+/** The unstable surface facade (plan §10). */
+interface UnstableSurfaceFacade {
+  /** The CURRENT surface's low-level handle (a getter — the handle
+   * follows the live surface attachment; inert when no surface is
+   * live). */
+  readonly handle: UnstableSurfaceHandle;
+}
+/** The full unstable facade (plan §4: `unstable(service)`). */
+interface UnstableFacade {
+  /** Raw input interception. */
+  readonly input: UnstableInputFacade;
+  /** The low-level surface seam. */
+  readonly surface: UnstableSurfaceFacade;
+}
+/**
+ * The minimal service surface the unstable facade consumes (plan §4:
+ * `unstable(service)`). STRUCTURAL and defined here so the packed
+ * unstable declarations never reference the internal service module —
+ * the concrete `piTuiExtensions` service implements these members, but
+ * the public `PiTuiExtensionService` interface does not declare them.
+ *
+ * `api` is the structural anchor: a plain `PiTuiExtensionService` value
+ * satisfies the facade's parameter (the seam members are optional in the
+ * type), and the facade throws loudly when the host does not implement
+ * the seam (a host/plugin version mismatch).
+ */
+interface UnstableServiceHost {
+  /** The public api() surface (the structural anchor — the facade does
+   * not consume it; it makes a plain `PiTuiExtensionService` value
+   * assignable to the parameter). */
+  readonly api: () => PiTuiApiInfo;
+  /** The service's internal unstable seam: register a raw input capture
+   * (caller-fiber-owned). */
+  _unstableCaptureRaw?(spec: UnstableRawInputSpec): UnstableRawInputHandle;
+  /** The service's internal unstable seam: the current surface's
+   * low-level handle (inert when stale). */
+  _unstableSurfaceHandle?(): UnstableSurfaceHandle;
+}
+//#endregion
+//#region src/extension/unstable.d.ts
+/**
+ * Build the UNSTABLE facade over the shared `piTuiExtensions` service
+ * (plan §4). The facade is a thin capability view: every resource it
+ * creates is caller-fiber-owned and surface-generation-scoped through the
+ * service's shared Extension Runtime — never a second plugin system.
+ *
+ * The parameter is the structural {@link UnstableServiceHost}: a plain
+ * `PiTuiExtensionService` value is accepted (the seam members are
+ * optional in the type), and the facade throws loudly when the host does
+ * not implement the seam (a host/plugin version mismatch).
+ * @param service - the `piTuiExtensions` service (from `ctx.get(...)`).
+ * @returns the Unstable facade.
+ */
+declare function unstable(service: UnstableServiceHost): UnstableFacade;
+//#endregion
+export { type ExtensionTier, UNSTABLE_API_LEVEL, type UnstableFacade, type UnstableInputFacade, type UnstableMountLease, type UnstableMountedComponent, type UnstableRawCaptureMode, type UnstableRawInputEvent, type UnstableRawInputHandle, type UnstableRawInputResult, type UnstableRawInputSpec, type UnstableServiceHost, type UnstableSurfaceFacade, type UnstableSurfaceHandle, unstable };

package/dist/extension/unstable.mjs

@@ -0,0 +1,30 @@
+//#region src/extension/unstable-types.ts
+/** API level of the unstable tier. Bumped only on unstable breaking changes. */
+const UNSTABLE_API_LEVEL = 1;
+//#endregion
+//#region src/extension/unstable.ts
+/**
+* Build the UNSTABLE facade over the shared `piTuiExtensions` service
+* (plan §4). The facade is a thin capability view: every resource it
+* creates is caller-fiber-owned and surface-generation-scoped through the
+* service's shared Extension Runtime — never a second plugin system.
+*
+* The parameter is the structural {@link UnstableServiceHost}: a plain
+* `PiTuiExtensionService` value is accepted (the seam members are
+* optional in the type), and the facade throws loudly when the host does
+* not implement the seam (a host/plugin version mismatch).
+* @param service - the `piTuiExtensions` service (from `ctx.get(...)`).
+* @returns the Unstable facade.
+*/
+function unstable(service) {
+	const host = service;
+	if (host._unstableCaptureRaw === void 0 || host._unstableSurfaceHandle === void 0) throw new Error("this piTuiExtensions host does not implement the unstable seam (host/plugin version mismatch? upgrade the host bundle)");
+	return {
+		input: { captureRaw: (spec) => host._unstableCaptureRaw(spec) },
+		surface: { get handle() {
+			return host._unstableSurfaceHandle();
+		} }
+	};
+}
+//#endregion
+export { UNSTABLE_API_LEVEL, unstable };

package/dist/extensions.d.mts

@@ -0,0 +1,132 @@
+import { $ as TuiKeybindingHandle, A as RegistrationHandle, B as ToolPresentationSnapshot, C as MarkdownView, D as PiTuiCapability, E as PiTuiApiInfo, F as StackView, G as TuiAutocompleteRegistryView, H as TuiAutocompleteItem, I as StyledSpan, J as TuiCommandBridgeSnapshot, K as TuiAutocompleteSuggestions, L as SurfaceSnapshot, M as RowsView, N as SessionSnapshot, O as PiTuiSlotName, P as SpacerView, Q as TuiKeybindingContribution, R as SurfaceStateValues, S as InputWidget, T as NormalizedKey, U as TuiAutocompleteProvider, V as TuiAction, W as TuiAutocompleteQuery, X as TuiCommandContribution, Y as TuiCommandBridgeView, Z as TuiCommandHandle, _t as TuiThemeRegistryView, a as ContributionHealth, at as TuiOverlayOptions, b as FrameView, c as DockItem, ct as TuiRendererRegistryView, d as EditorHost, dt as TuiSettingsRegistrySnapshot, et as TuiKeybindingRegistrySnapshot, f as EditorHostAction, ft as TuiSettingsRegistryView, g as ExtensionEditor, gt as TuiThemeRegistrySnapshot, h as EditorSnapshot, ht as TuiThemeHandle, i as AutocompleteProviderContribution, it as TuiOverlayHandle, j as RegistrationSpec, k as PiTuiSlotSemantic, l as EditorContribution, lt as TuiSettingContribution, m as EditorInputEvent, mt as TuiThemeContribution, n as ActivitySnapshot, nt as TuiLocalCommandHandler, o as ContributionRecord, ot as TuiRendererHandle, p as EditorHostActionResult, pt as TuiSizeValue, q as TuiColorPalette, r as AutocompleteHandle, rt as TuiMessageRendererContribution, s as ContributionState, st as TuiRendererRegistrySnapshot, t as API_VERSION, tt as TuiKeybindingRegistryView, u as EditorHandle, ut as TuiSettingHandle, v as ExtensionView, vt as TuiToolRendererContribution, w as MessagePresentationSnapshot, x as HeaderBadge, y as FooterSegment, yt as describeKey, z as TextView } from "./public-types-2omeXG8d.mjs";
+import { Context, Service } from "@deepseek-ai/cordis";
+
+//#region src/extension/service.d.ts
+/** The service name plugins inject (`piTuiExtensions` in cordis.patch.yml). */
+declare const PI_TUI_EXTENSIONS_SERVICE = "piTuiExtensions";
+/** The public service surface plugins consume. */
+interface PiTuiExtensionService {
+  /** Host identity: version + capability set (feature-detect, never parse versions). */
+  readonly api: () => PiTuiApiInfo;
+  /**
+   * Register one contribution under a slot. The registration is owned by the
+   * CALLING fiber: it is disposed automatically when that fiber unloads.
+   * @param slot - one of the known slot names.
+   * @param spec - registration identity + ordering metadata.
+   * @param contribution - the contribution value (typed per slot contract).
+   */
+  register<T>(slot: string, spec: RegistrationSpec, contribution: T): RegistrationHandle<T>;
+  /** The semantic of one slot ('list' | 'single'), or undefined when unknown. */
+  slotSemantics(slot: string): string | undefined;
+  /**
+   * Subscribe to the live surface state snapshots (first-party builtins and
+   * state-driven contributions). Fires once synchronously with the current
+   * state, then on every change (batched). Returns a disposer.
+   * @param listener - receives the immutable snapshot values.
+   */
+  subscribeState(listener: (state: SurfaceStateValues) => void): () => void;
+  /**
+   * Register a TUI command contribution (M5): execution ownership metadata
+   * over an existing command. The bridge does NOT execute — actual
+   * execution stays in the commands service. Owned by the calling fiber.
+   * @param contribution - the command contribution.
+   */
+  registerCommand(contribution: TuiCommandContribution): TuiCommandHandle;
+  /**
+   * Register a named theme palette (M5): selectable from the host's theme
+   * picker; owner unload removes it (a selected plugin theme falls back to
+   * the built-in palette). Owned by the calling fiber.
+   * @param contribution - the theme contribution.
+   */
+  registerTheme(contribution: TuiThemeContribution): TuiThemeHandle;
+  /**
+   * Register an autocomplete provider (M5): consulted after the host's own
+   * provider returns null, in registration order. Owned by the calling
+   * fiber.
+   * @param contribution - the provider contribution.
+   */
+  registerAutocomplete(contribution: AutocompleteProviderContribution): AutocompleteHandle;
+  /**
+   * Register a settings row (M5): appended to the host's /settings panel.
+   * Owned by the calling fiber.
+   * @param contribution - the row contribution.
+   */
+  registerSetting(contribution: TuiSettingContribution): TuiSettingHandle;
+  /**
+   * Register a keybinding (M5, metadata only): normalized key → semantic
+   * action. Routing is Host-owned (the InputRouter lands in M6); until
+   * then the binding is recorded and reported. Reserved host keys are
+   * rejected. Owned by the calling fiber.
+   * @param contribution - the binding contribution.
+   */
+  registerKeybinding(contribution: TuiKeybindingContribution): TuiKeybindingHandle;
+  /**
+   * Register a transcript MESSAGE renderer (M7, chain slot): receives a
+   * semantic snapshot; returns an ExtensionView or undefined (abdicate →
+   * next renderer → host fallback). A throwing renderer is isolated.
+   * Owned by the calling fiber.
+   */
+  registerMessageRenderer(contribution: TuiMessageRendererContribution): TuiRendererHandle;
+  /**
+   * Register a TOOL renderer (M7, keyed slot): presents the tool card for
+   * ONE tool name; undefined abdicates. Priority ties on the same tool
+   * name are an explicit error. Owned by the calling fiber.
+   */
+  registerToolRenderer(contribution: TuiToolRendererContribution): TuiRendererHandle;
+  /**
+   * Open a MANAGED OVERLAY (M8, plan §13.3): the plugin supplies an
+   * ExtensionView + sizing hints; the host mounts it through its overlay
+   * broker (modal stacking, focus, fullscreen migration, teardown). The
+   * returned lease is generation-scoped (a stale surface's lease closes
+   * with the surface) and its close() is idempotent. The overlay content
+   * is the M4 component kit — a plugin can never mount a raw component
+   * or steal focus.
+   * @param view - the ExtensionView to present.
+   * @param options - sizing/positioning hints.
+   * @returns the overlay lease.
+   */
+  showOverlay(view: ExtensionView, options?: TuiOverlayOptions): TuiOverlayHandle;
+  /** M5 registries, exposed for the runner's dispatch/pickers (narrow
+   * read-side views — the concrete classes are host-internal, so the
+   * public declarations stay free of internal modules). */
+  readonly commands: TuiCommandBridgeView;
+  readonly themes: TuiThemeRegistryView;
+  readonly autocomplete: TuiAutocompleteRegistryView;
+  readonly settings: TuiSettingsRegistryView;
+  readonly keybindings: TuiKeybindingRegistryView;
+  /** M7: the transcript/tool renderer registry (the runner wires it into
+   * the surface's message cache; the narrow read-side view keeps the
+   * public declarations free of internal modules). */
+  readonly renderers: TuiRendererRegistryView;
+  /** Runner-only: wire the host's managed-overlay mount seam (M8). The
+   * seam is SURFACE-scoped (P1-4): it binds to the CURRENT attachment's
+   * surfaceId — a later attach replaces it, and a stale old-generation
+   * detach never unbinds a newer surface's seam (the detachSurface lease). */
+  setOverlayMount(surfaceId: string, mount: (view: ExtensionView, options?: TuiOverlayOptions) => TuiOverlayHandle): void;
+  /**
+   * Register an EDITOR contribution (M9, plan §14): single-winner by
+   * priority; a tie is an explicit error. The winner occupies the editor
+   * seat through the host's atomic handoff; the host default editor is
+   * the fallback (never a competing registration). Creation is atomic —
+   * a throw keeps the current editor working. Owned by the calling fiber.
+   */
+  registerEditor(contribution: EditorContribution): EditorHandle;
+}
+//#endregion
+//#region src/extensions.d.ts
+/** Stable Cordis plugin name for the extension host row. */
+declare const name = "pi-tui-extension-host";
+/** The host mounts only when the TUI startup flags were parsed (same gate
+ * as the runner row: `dsh --profile pi-tui --help` provides nothing, so no
+ * extension host mounts either). */
+declare const inject: string[];
+/**
+ * Provide the extension service. The Service base class registers the
+ * instance on `ctx` under `piTuiExtensions` and unregisters it when this
+ * provider fiber unloads; invalidations coalesce into render requests
+ * (until the SurfaceHost attaches in M2 the sink is a no-op).
+ * @param ctx - the provider's plugin context.
+ */
+declare function apply(ctx: Context): void;
+//#endregion
+export { API_VERSION, type ActivitySnapshot, type AutocompleteHandle, type AutocompleteProviderContribution, type ContributionHealth, type ContributionRecord, type ContributionState, type DockItem, type EditorContribution, type EditorHandle, type EditorHost, type EditorHostAction, type EditorHostActionResult, type EditorInputEvent, type EditorSnapshot, type ExtensionEditor, type ExtensionView, type FooterSegment, type FrameView, type HeaderBadge, type InputWidget, type MarkdownView, type MessagePresentationSnapshot, type NormalizedKey, PI_TUI_EXTENSIONS_SERVICE, type PiTuiApiInfo, type PiTuiCapability, type PiTuiExtensionService, type PiTuiSlotName, type PiTuiSlotSemantic, type RegistrationHandle, type RegistrationSpec, type RowsView, type SessionSnapshot, type SpacerView, type StackView, type StyledSpan, type SurfaceSnapshot, type SurfaceStateValues, type TextView, type ToolPresentationSnapshot, type TuiAction, type TuiAutocompleteItem, type TuiAutocompleteProvider, type TuiAutocompleteQuery, type TuiAutocompleteRegistryView, type TuiAutocompleteSuggestions, type TuiColorPalette, type TuiCommandBridgeSnapshot, type TuiCommandBridgeView, type TuiCommandContribution, type TuiCommandHandle, type TuiKeybindingContribution, type TuiKeybindingHandle, type TuiKeybindingRegistrySnapshot, type TuiKeybindingRegistryView, type TuiLocalCommandHandler, type TuiMessageRendererContribution, type TuiOverlayHandle, type TuiOverlayOptions, type TuiRendererHandle, type TuiRendererRegistrySnapshot, type TuiSettingContribution, type TuiSettingHandle, type TuiSettingsRegistrySnapshot, type TuiSettingsRegistryView, type TuiSizeValue, type TuiThemeContribution, type TuiThemeHandle, type TuiThemeRegistrySnapshot, type TuiThemeRegistryView, type TuiToolRendererContribution, apply, describeKey, inject, name };

package/dist/extensions.mjs

@@ -0,0 +1,3 @@
+import "./startup.mjs";
+import { A as inject, M as PI_TUI_EXTENSIONS_SERVICE, N as API_VERSION, P as describeKey, j as name, k as apply } from "./src-AgdnRnGA.mjs";
+export { API_VERSION, PI_TUI_EXTENSIONS_SERVICE, apply, describeKey, inject, name };

package/dist/index.d.mts

@@ -3,7 +3,6 @@ import { Agent, ModelSelectionRef } from "@deepseek-ai/dsh-agent";
 import { ContentBlock } from "@deepseek-ai/dsh-llm";
 import { SessionEvent, SessionId } from "@deepseek-ai/dsh-session";
 import { CommandDescriptor } from "@deepseek-ai/dsh-commands";
-import { EventEmitter } from "events";
 import { Context } from "@deepseek-ai/cordis";
 //#region src/diag.d.ts
 interface Diag {
@@ -150,6 +149,16 @@ declare const SESSIONLESS_COMMANDS: Set<string>;
  * body — there is no command-execution wire for skills.
  */
 declare const LOCAL_COMMANDS: Set<string>;
+/**
+ * The AUTHORITATIVE host-owned command catalog (P1-04): every command name
+ * the TUI registers itself (registerTuiCommands in commands.ts) plus the
+ * ownership sets (LOCAL_COMMANDS and SESSIONLESS_COMMANDS — /kill and
+ * other core commands the TUI does not register but dispatches locally).
+ * A plugin command contribution is validated against this catalog at
+ * register time: an exact or near-synonym collision is rejected loudly,
+ * so a plugin can never shadow a built-in command.
+ */
+declare const HOST_COMMAND_CATALOG: ReadonlySet<string>;
 /**
  * Whether one submission steers under the busy-Enter preference: NOT a
  * force-queued chord, NOT a TUI-owned local command, and the agent is
@@ -159,10 +168,12 @@ declare const LOCAL_COMMANDS: Set<string>;
  * @param running - whether the live agent reports running.
  * @param busyEnter - the persisted preference value (''/undefined = queue).
  * @param forceQueue - the Ctrl+Enter chord: always queue, never steer.
+ * @param isDynamicLocal - M5: the CommandBridge's effective-local check for
+ *   plugin-declared local commands (absent = static set only).
  */
 declare function shouldSteerOnEnter(parsed: {
   name: string;
-} | undefined, running: boolean, busyEnter: string | undefined, forceQueue: boolean): boolean;
+} | undefined, running: boolean, busyEnter: string | undefined, forceQueue: boolean, isDynamicLocal?: (name: string) => boolean): boolean;
 /**
  * The advertised-claim miss decision (pure, exported for the headless
  * suite): a slash input whose name was advertised by the completion list at
@@ -348,6 +359,55 @@ declare function resumeCommand(profile: string, sessionId: string): string | und
 declare class SessionLockRefusedError extends Error {
   constructor(message: string);
 }
+/** 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 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 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;
+/**
+ * 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;
+};
 /** 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. */
@@ -423,4 +483,4 @@ declare function recomposeBlank(ctx: Context, agent: {
  */
 declare function apply(ctx: Context, config: Config): void;
 //#endregion
-export { AgentComposition, Config, InitialCatalogResolution, LOCAL_COMMANDS, PendingSubagentCall, QueueFoldResult, QueueInboxMessage, QueueNoticeSource, RecomposableSession, RecomposeOutcome, ResolveInitialCatalogOptions, SESSIONLESS_COMMANDS, SessionLockRefusedError, apply, composeAgent, dangerCommand, foldQueueRows, forkSeed, inject, isPlainExitPrompt, isSubagentSettlementNotice, matchPendingSubagentCall, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint, subagentNoticeIsFailure };
+export { AgentComposition, CompactionFold, Config, HOST_COMMAND_CATALOG, InitialCatalogResolution, LOCAL_COMMANDS, PendingSubagentCall, QueueFoldResult, QueueInboxMessage, QueueNoticeSource, RecomposableSession, RecomposeOutcome, ResolveInitialCatalogOptions, SESSIONLESS_COMMANDS, SessionLockRefusedError, apply, busyAfterTurnBoundary, compactingFromLog, composeAgent, dangerCommand, foldCompactionEvent, foldQueueRows, forkSeed, inject, isPlainExitPrompt, isSubagentSettlementNotice, matchPendingSubagentCall, name, recomposeBlank, recordedPreset, resolveInitialCatalog, resumeCommand, runningProfile, shouldConsumeAdvertisedMiss, shouldSteerOnEnter, subagentJobTranscriptId, subagentJobViewHint, subagentNoticeIsFailure };