@pellux/goodvibes-tui 1.1.0 → 1.7.0

package/src/input/commands/workstream-runtime.ts

@@ -0,0 +1,338 @@
+// ---------------------------------------------------------------------------
+// workstream-runtime.ts — /workstream
+//
+// UX over the OrchestrationEngine (@pellux/goodvibes-sdk/platform/orchestration,
+// wo701/W4.1) via its command-facing facade wired onto RuntimeServices as
+// `workstreamCommands` (src/runtime/workstream-services.ts) and threaded
+// through CommandContext.session.workstreamEngine exactly like wrfcController
+// already is (bootstrap-command-context.ts).
+//
+// Render precedent: TRANSCRIPT + subcommand approve (like /plan approve,
+// planning-runtime.ts), NOT a panel — a multi-phase proposal is too rich for
+// a one-line confirm overlay, and Pillar-3 doctrine keeps work visible in the
+// transcript. create -> approve -> launch is a real three-step flow (edit and
+// cancel apply to the pending proposal too): the engine's own createWorkstream
+// immediately materializes a real, ticking-eligible Workstream with no
+// pre-creation "draft" concept, so approval happens on a TUI-held draft
+// (workstream-services.ts's WorkstreamDraft) before anything is created in
+// the engine at all — see that module's header doc for the full reality-wins
+// divergence from the wo703 design brief.
+// ---------------------------------------------------------------------------
+
+import { AdaptivePlanner } from '@pellux/goodvibes-sdk/platform/core';
+import type { PhaseKind, PhaseRole, WorkItemState, Workstream } from '@pellux/goodvibes-sdk/platform/orchestration';
+import type { WorkstreamCommandService, WorkstreamDraft } from '../../runtime/workstream-services.ts';
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function shortId(id: string): string {
+  return id.length > 12 ? id.slice(0, 12) : id;
+}
+
+/**
+ * The engine's ONLY two terminal work-item states (mirrors the SDK's own
+ * internal TERMINAL_ITEM_STATES in platform/runtime/fleet/adapters/
+ * orchestration.ts and engine.ts's kill() guard — neither is exported, so
+ * this is kept in lockstep by hand). Deriving "active" as NOT-terminal
+ * instead of enumerating the non-terminal states means a state this module
+ * doesn't know about yet (as 'blocked-budget' once was here) is still
+ * correctly treated as in-flight rather than silently falling through the
+ * cancel path.
+ */
+const TERMINAL_ITEM_STATES = new Set<WorkItemState>(['passed', 'failed']);
+
+function isActiveItemState(state: WorkItemState): boolean {
+  return !TERMINAL_ITEM_STATES.has(state);
+}
+
+/** Mirrors the engine's templateForPhase (phase-runner.ts): only 'review'/'gate' phases run the general template — everything else, INCLUDING 'custom', runs the engineer template regardless of phase.role's text. */
+function templateForPhaseKind(kind: PhaseKind): string {
+  return kind === 'review' || kind === 'gate' ? 'general' : 'engineer';
+}
+
+/**
+ * phase.role for a 'custom' phase is the free-text description passed to
+ * `/workstream insert-phase` — it is purely COSMETIC. Neither
+ * templateForPhase nor buildPhaseTask (phase-runner.ts, engine-side) ever
+ * reads it: a custom phase always runs the engineer template against the
+ * work item's own task text. Rendering it as `<kind> — <role>` like a real
+ * role would falsely imply the description drives what the phase does, so
+ * custom phases get an explicit "this is a description, not a role" label
+ * instead.
+ */
+function formatPhaseLabel(phase: { readonly kind: PhaseKind; readonly role: PhaseRole }): string {
+  if (phase.kind === 'custom') {
+    return `custom: "${phase.role}" (runs the ${templateForPhaseKind(phase.kind)} template)`;
+  }
+  return `${phase.kind} — ${phase.role}`;
+}
+
+function summarizeItemStates(ws: Workstream): string {
+  const counts = new Map<string, number>();
+  for (const item of ws.items) counts.set(item.state, (counts.get(item.state) ?? 0) + 1);
+  return Array.from(counts.entries()).map(([state, n]) => `${n} ${state}`).join(', ') || 'no items';
+}
+
+/** The engine's own PlanProposal is deliberately not rendered — see workstream-services.ts's buildSpec doc. This renders the REAL launchable spec instead, so the proposal and the launch are always the same plan. */
+function renderDraftProposal(draft: WorkstreamDraft): string {
+  const lines: string[] = [];
+  lines.push(`Workstream proposal ${draft.id} — "${draft.task}"`);
+  lines.push(
+    `Planner: strategy=${draft.gate.strategy} (${draft.gate.reasonCode}) — ${AdaptivePlanner.explainReasonCode(draft.gate.reasonCode)}`,
+  );
+  lines.push('Phases:');
+  draft.spec.phases.forEach((phase, i) => {
+    lines.push(`  ${i + 1}. ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
+  });
+  lines.push('Work items:');
+  for (const item of draft.spec.items) {
+    lines.push(`  - ${item.title}`);
+  }
+  lines.push(
+    draft.approved
+      ? `Approved. Launch with: /workstream launch ${draft.id}`
+      : `Approve with: /workstream approve ${draft.id}`,
+  );
+  lines.push(`Edit the task: /workstream edit ${draft.id} <new task...>   Discard: /workstream cancel ${draft.id}`);
+  // Honest limitation (see workstream-services.ts's REALITY-WINS doc): the
+  // engine has no pre-creation draft concept, so this proposal is
+  // process-lifetime, in-memory state only — never journaled like a launched
+  // Workstream is. State that plainly, the same way an unsent chat draft
+  // would be, rather than letting a restart silently make it vanish.
+  lines.push('Note: not saved — lost if the TUI restarts before launch.');
+  return lines.join('\n');
+}
+
+function renderWorkstreamStatus(ws: Workstream): string {
+  const lines: string[] = [];
+  lines.push(`Workstream ${ws.id} — "${ws.title}"`);
+  lines.push('Phases:');
+  for (const phase of ws.phases) {
+    lines.push(`  [${phase.ordinal}] ${formatPhaseLabel(phase)} (capacity ${phase.capacity})`);
+  }
+  lines.push('Items:');
+  for (const item of ws.items) {
+    lines.push(`  ${shortId(item.id)}  [${item.state}]  ${item.title}  — phase: ${item.currentPhaseId ?? '—'}`);
+  }
+  return lines.join('\n');
+}
+
+function renderWorkstreamList(service: WorkstreamCommandService): string {
+  const drafts = service.listDrafts();
+  const live = service.engine.listWorkstreams();
+  if (drafts.length === 0 && live.length === 0) {
+    return 'No workstreams yet. Use /workstream create <task...> to propose one.';
+  }
+  const sections: string[] = [];
+  if (drafts.length > 0) {
+    const rows = drafts.map((d) => `  ${d.id}  ${d.approved ? '[approved]' : '[draft]  '}  "${d.task}"`);
+    sections.push([`Pending proposals (${drafts.length}, not yet launched):`, ...rows].join('\n'));
+  }
+  if (live.length > 0) {
+    const rows = live.map((ws) => `  ${shortId(ws.id)}  "${ws.title}"  (${ws.phases.length} phases, ${summarizeItemStates(ws)})`);
+    sections.push([`Workstreams (${live.length}):`, ...rows].join('\n'));
+  }
+  return sections.join('\n\n');
+}
+
+function resolveWorkstream(service: WorkstreamCommandService, ref: string): Workstream | undefined {
+  const exact = service.engine.getWorkstream(ref);
+  if (exact) return exact;
+  return service.engine.listWorkstreams().find((ws) => ws.id.startsWith(ref));
+}
+
+/**
+ * approve/edit/launch all fail this way when `id` doesn't resolve to a held
+ * draft. A bare "No pending proposal found" reads like a typo'd id even when
+ * the real cause is that drafts are process-lifetime, in-memory-only state
+ * (see renderDraftProposal's note and workstream-services.ts's REALITY-WINS
+ * doc) and a TUI restart wiped every one of them. Only hint at that when the
+ * service is holding zero drafts at all — with other drafts present, a typo
+ * or stale id is the more honest guess and the plain message stays.
+ */
+function draftNotFoundMessage(service: WorkstreamCommandService, id: string): string {
+  const base = `No pending proposal found: ${id}`;
+  if (service.listDrafts().length > 0) return base;
+  return `${base} (proposals aren't saved — a TUI restart since you created it would explain this; recreate it with /workstream create)`;
+}
+
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+
+export function registerWorkstreamRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'workstream',
+    description: 'Author and oversee multi-phase agent workstreams (orchestration engine)',
+    usage: 'create <task...> | list | status [id] | insert-phase <id> <description...> | approve <id> | edit <id> <task...> | launch <id> | cancel <id>',
+    argsHint: 'create <task> | list | status [id] | approve | edit | launch | cancel',
+    handler: async (args, ctx: CommandContext) => {
+      const service = ctx.session.workstreamEngine;
+      if (!service) {
+        ctx.print('Workstreams are not available in this session.');
+        return;
+      }
+
+      const sub = args[0];
+
+      if (!sub || sub === 'list') {
+        ctx.print(renderWorkstreamList(service));
+        return;
+      }
+
+      if (sub === 'create') {
+        const task = args.slice(1).join(' ').trim();
+        if (!task) {
+          ctx.print('Usage: /workstream create <task...>');
+          return;
+        }
+        const draft = service.proposeDraft(task);
+        ctx.print(renderDraftProposal(draft));
+        return;
+      }
+
+      if (sub === 'status') {
+        const ref = args[1];
+        const live = service.engine.listWorkstreams();
+        const target = ref ? resolveWorkstream(service, ref) : (live.length === 1 ? live[0] : undefined);
+        if (!target) {
+          if (!ref && live.length > 1) {
+            ctx.print(`Multiple workstreams running — specify one: ${live.map((ws) => shortId(ws.id)).join(', ')}`);
+            return;
+          }
+          ctx.print(ref ? `No workstream found: ${ref}` : 'No workstreams running. Use /workstream list to see pending proposals.');
+          return;
+        }
+        ctx.print(renderWorkstreamStatus(target));
+        return;
+      }
+
+      if (sub === 'insert-phase') {
+        const id = args[1];
+        const description = args.slice(2).join(' ').trim();
+        if (!id || !description) {
+          ctx.print('Usage: /workstream insert-phase <id> <description...>');
+          return;
+        }
+        const ws = resolveWorkstream(service, id);
+        if (!ws) {
+          ctx.print(`No workstream found: ${id}`);
+          return;
+        }
+        const lastOrdinal = ws.phases.reduce((max, phase) => Math.max(max, phase.ordinal), 0);
+        const templateGate = ws.phases.at(-1)?.gate ?? { scope: 'scoped' as const, gates: [] };
+        const inserted = service.engine.insertPhase(ws.id, lastOrdinal, {
+          role: description,
+          capacity: 1,
+          kind: 'custom',
+          gate: templateGate,
+        });
+        if (!inserted) {
+          ctx.print(`Could not insert phase — is "${id}" still an active workstream?`);
+          return;
+        }
+        ctx.print(`Inserted phase "${description}" into ${shortId(ws.id)} after ordinal ${lastOrdinal} (new ordinal ${inserted.ordinal}).`);
+        return;
+      }
+
+      if (sub === 'approve') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream approve <id>');
+          return;
+        }
+        const draft = service.approveDraft(id);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        ctx.print(`Approved ${id}. Launch with: /workstream launch ${id}`);
+        return;
+      }
+
+      if (sub === 'edit') {
+        const id = args[1];
+        const task = args.slice(2).join(' ').trim();
+        if (!id || !task) {
+          ctx.print('Usage: /workstream edit <id> <new task...>');
+          return;
+        }
+        const draft = service.editDraft(id, task);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        ctx.print(renderDraftProposal(draft));
+        return;
+      }
+
+      if (sub === 'launch') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream launch <id>');
+          return;
+        }
+        const draft = service.getDraft(id);
+        if (!draft) {
+          ctx.print(draftNotFoundMessage(service, id));
+          return;
+        }
+        if (!draft.approved) {
+          ctx.print(`Proposal ${id} is not approved yet. Run /workstream approve ${id} first.`);
+          return;
+        }
+        const result = service.launchDraft(id);
+        if (!result) {
+          ctx.print(`Could not launch ${id}.`);
+          return;
+        }
+        ctx.print(`Launched workstream ${result.workstreamId} — track it with /workstream status ${result.workstreamId} or the Fleet panel.`);
+        return;
+      }
+
+      if (sub === 'cancel') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /workstream cancel <id>');
+          return;
+        }
+        if (service.getDraft(id)) {
+          service.removeDraft(id);
+          ctx.print(`Discarded pending proposal ${id}.`);
+          return;
+        }
+        const ws = resolveWorkstream(service, id);
+        if (!ws) {
+          ctx.print(`No workstream or pending proposal found: ${id}`);
+          return;
+        }
+        const active = ws.items.filter((item) => isActiveItemState(item.state));
+        let killedCount = 0;
+        for (const item of active) {
+          if (service.engine.kill(item.id)) killedCount++;
+        }
+        ctx.print(
+          killedCount > 0
+            ? `Cancelled ${killedCount} of ${active.length} in-flight work item(s) in ${shortId(ws.id)}.`
+            : `${shortId(ws.id)} has no in-flight work items to cancel.`,
+        );
+        return;
+      }
+
+      ctx.print(
+        'Usage:\n'
+        + '  /workstream create <task...>\n'
+        + '  /workstream list\n'
+        + '  /workstream status [id]\n'
+        + '  /workstream insert-phase <id> <description...>\n'
+        + '  /workstream approve <id>\n'
+        + '  /workstream edit <id> <new task...>\n'
+        + '  /workstream launch <id>\n'
+        + '  /workstream cancel <id>',
+      );
+    },
+  });
+}

package/src/input/commands.ts

@@ -15,6 +15,7 @@ import { registerOperatorRuntimeCommands } from './commands/operator-runtime.ts'
 import { registerPluginRuntimeCommands } from './commands/plugin-runtime.ts';
 import { registerDiffRuntimeCommands } from './commands/diff-runtime.ts';
 import { registerGitRuntimeCommands } from './commands/git-runtime.ts';
+import { registerTestRuntimeCommands } from './commands/test-runtime.ts';
 import { registerNotifyRuntimeCommands } from './commands/notify-runtime.ts';
 import { registerReplayRuntimeCommands } from './commands/replay-runtime.ts';
 import { registerShareRuntimeCommands } from './commands/share-runtime.ts';
@@ -36,6 +37,9 @@ import { registerHooksRuntimeCommands } from './commands/hooks-runtime.ts';
 import { registerControlRoomRuntimeCommands } from './commands/control-room-runtime.ts';
 import { registerMcpRuntimeCommands } from './commands/mcp-runtime.ts';
 import { registerSessionContentCommands } from './commands/session-content.ts';
+import { registerCheckpointRuntimeCommands } from './commands/checkpoint-runtime.ts';
+import { registerWorkstreamRuntimeCommands } from './commands/workstream-runtime.ts';
+import { registerCodebaseRuntimeCommands } from './commands/codebase-runtime.ts';
 import { registerLocalRuntimeCommands } from './commands/local-runtime.ts';
 import { registerExperienceRuntimeCommands } from './commands/experience-runtime.ts';
 import { registerIncidentRuntimeCommands } from './commands/incident-runtime.ts';
@@ -57,6 +61,8 @@ import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
 import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
 import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 import { registerCostRuntimeCommands } from './commands/cost-runtime.ts';
+import { registerWebSearchRuntimeCommands } from './commands/websearch-runtime.ts';
+import { registerImageRuntimeCommands } from './commands/image-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -69,6 +75,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerPluginRuntimeCommands(registry);
   registerDiffRuntimeCommands(registry);
   registerGitRuntimeCommands(registry);
+  registerTestRuntimeCommands(registry);
   registerNotifyRuntimeCommands(registry);
   registerReplayRuntimeCommands(registry);
   registerShareRuntimeCommands(registry);
@@ -115,6 +122,11 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerScheduleRuntimeCommands(registry);
   registerBranchRuntimeCommands(registry);
   registerSessionContentCommands(registry);
+  registerCheckpointRuntimeCommands(registry);
+  registerWorkstreamRuntimeCommands(registry);
+  registerCodebaseRuntimeCommands(registry);
+  registerWebSearchRuntimeCommands(registry);
+  registerImageRuntimeCommands(registry);
 
   // ── /policy ───────────────────────────────────────────────────────────────
   registry.register(policyCommand);

package/src/input/config-modal-types.ts

@@ -0,0 +1,161 @@
+import type { ModalSectionStyle } from '../renderer/modal-factory.ts';
+
+/**
+ * Config-modal host — the shared seam every W6.1 MIGRATE-TO-MODAL surface
+ * (provider-health, services, subscription, remote, local-auth, settings-sync,
+ * sandbox, and the WO-B ecosystem/governance set) is expressed through.
+ *
+ * A surface is PURE DATA + ACTIONS: it hands the host a `buildView()` that maps
+ * live read-models to a tabbed, list-structured view, plus a declarative action
+ * table. The host owns all key routing (tab switch, list nav, Esc, confirm) and
+ * the stable-layout liveness contract — the surface never touches the input
+ * system directly (the charter's "do not invent a parallel input system").
+ *
+ * Liveness doctrine (charter: "live data, stable layout"): `buildView()` is
+ * called every render tick so values (latency, status, counts) update in place,
+ * but the host renders against the row/tab STRUCTURE captured at the last
+ * interaction boundary (open, or a key press). Rows never reflow under the
+ * cursor mid-interaction; a structural change (a row appears/disappears) is
+ * deferred until the next key press. See ConfigModal for the mechanism.
+ */
+
+/** A single row within a tab. Identity is `id` (structural); `label` is live. */
+export interface ConfigModalRow {
+  /**
+   * Stable identity across live-refresh ticks. The liveness contract keys
+   * structural stability off this: two builds with the same ordered id set are
+   * "structurally identical" and repaint values in place; a differing id set is
+   * a structural change, deferred to the next interaction boundary.
+   */
+  readonly id: string;
+  /** Display label. MAY embed live value fields (latency, status dot, counts). */
+  readonly label: string;
+  /** Optional per-row style (e.g. bad/warn tone for an errored row). */
+  readonly style?: ModalSectionStyle;
+  /**
+   * Non-selectable informational row (sub-header, spacer text). Skipped by
+   * up/down navigation and never receives an action. Defaults to selectable.
+   */
+  readonly selectable?: boolean;
+}
+
+/** One tab (section) of a surface. Tabs are switched with left/right or Tab. */
+export interface ConfigModalTab {
+  /** Stable id — preserves the active tab across refresh + re-open. */
+  readonly id: string;
+  /** Tab-strip label. */
+  readonly label: string;
+  /** Live status/posture lines rendered above the list (non-selectable). */
+  readonly header?: readonly string[];
+  /** Selectable/informational rows. */
+  readonly rows: readonly ConfigModalRow[];
+  /** Honest empty-state text shown when `rows` is empty. */
+  readonly emptyText?: string;
+  /** Footer hints specific to this tab, appended after the surface hints. */
+  readonly hints?: readonly string[];
+}
+
+/** The whole surface view for one render tick. */
+export interface ConfigModalView {
+  /** Live title (may change tick-to-tick; not structural). */
+  readonly title: string;
+  readonly tabs: readonly ConfigModalTab[];
+  /**
+   * Non-null when the read-model is unavailable/degraded — the host renders a
+   * banner and still shows whatever tabs/rows are present (honest degraded
+   * state rather than a blank or a throw).
+   */
+  readonly degraded?: string;
+  /** Base footer hints (Esc close is always appended by the host). */
+  readonly hints?: readonly string[];
+}
+
+/** Context handed to a surface's action handler when an action key fires. */
+export interface ConfigModalActionContext {
+  /** The selected row the action targets (null when the active tab has none). */
+  readonly row: ConfigModalRow | null;
+  /** The active tab's id. */
+  readonly tabId: string;
+  /** Print a line to the conversation transcript. */
+  readonly print: (message: string) => void;
+  /**
+   * Execute a slash command — the same seam panels used via
+   * `PanelIntegrationContext.executeCommand`. This is how a migrated action
+   * preserves parity: the mutation still runs through its existing, tested
+   * command (e.g. `/settings-sync resolve`, `/local-auth delete-user`).
+   */
+  readonly executeCommand?: (name: string, args: string[]) => Promise<unknown>;
+  /** Open another named modal surface (cross-surface navigation, e.g. the
+   *  services surface jumping to the subscription surface). Swaps the active
+   *  surface in place — the same seam ctx.openModal uses. */
+  readonly openModal?: (name: string) => void;
+  /** Request a re-render. */
+  readonly requestRender: () => void;
+  /** Set the modal's transient status line (e.g. a result or error message). */
+  readonly setStatus: (message: string) => void;
+  /** Close the modal (focus returns to whatever opened it). */
+  readonly close: () => void;
+}
+
+/** A declarative action bound to a key. */
+export interface ConfigModalAction {
+  /**
+   * Trigger key: a single printable char ('r', 'd') or a named key ('enter').
+   * Must not collide with the host-reserved nav keys (up/down/left/right/tab/
+   * j/k/escape) — those are consumed by the host before actions are consulted.
+   */
+  readonly key: string;
+  /** Action id passed to `onAction`. */
+  readonly id: string;
+  /** Short verb for the footer hint (e.g. "refresh", "delete user"). */
+  readonly label: string;
+  /**
+   * Destructive: require an explicit second press of the same key to fire
+   * (the host shows "press <key> again to <label>" between presses). Matches
+   * the session-picker delete-confirm precedent.
+   */
+  readonly confirm?: boolean;
+  /**
+   * When set, the action is only offered while the selected row's id satisfies
+   * this predicate (e.g. sandbox "stop" only on a session row). Rows failing
+   * the predicate neither show the hint nor fire the action.
+   */
+  readonly enabledFor?: (row: ConfigModalRow | null, tabId: string) => boolean;
+}
+
+/**
+ * A named config-modal surface. Pure seam — the host knows nothing about the
+ * surface's data. Built once (closing over its read-models) and registered on
+ * PanelManager via `registerModalSurface`; opened by name from a panel-id
+ * redirect hit or `ctx.openModal(name)`.
+ */
+export interface ConfigModalSurface {
+  /** Modal name — the key `registerModalRedirect` / `ctx.openModal` use. */
+  readonly name: string;
+  /** Fallback title (buildView().title wins per tick). */
+  readonly title: string;
+  /**
+   * Build the current view from live read-models. Called on open, on every
+   * interaction boundary, AND on every render tick. MUST be pure and cheap —
+   * snapshot reads only, no async, no mutation.
+   */
+  buildView(): ConfigModalView;
+  /** Declarative action table (optional — a read-only surface has none). */
+  readonly actions?: readonly ConfigModalAction[];
+  /** Handle an action fired by its key. */
+  onAction?(actionId: string, ctx: ConfigModalActionContext): void;
+  /**
+   * Optional lifecycle: called when the modal opens this surface and when it
+   * closes. A live surface uses `onOpen` to subscribe to its read-model/events
+   * (calling the provided `requestRender` on change so live values refresh
+   * between key presses) and `onClose` to unsubscribe. The host guarantees
+   * `onClose` runs exactly once per `onOpen`.
+   */
+  onOpen?(requestRender: () => void): void;
+  onClose?(): void;
+}
+
+/** Read-only registry the host consults to resolve a modal name to a surface. */
+export interface ConfigModalSurfaceRegistry {
+  getModalSurface(name: string): ConfigModalSurface | undefined;
+}