@pellux/goodvibes-tui 1.27.1 → 2.0.2

package/src/panels/hosted-session-feed.ts

@@ -0,0 +1,352 @@
+/**
+ * hosted-session-feed.ts — what this terminal knows about the daemon-hosted
+ * session it is attached to.
+ *
+ * One place holds it because two surfaces read it: the `/hosted` command family
+ * (which prints status and drives the verbs) and the Hosted Session panel
+ * (which renders the conversation). The same shared-feed shape
+ * notifications-feed.ts already uses in this repo — a module-level instance a
+ * command writes and a panel subscribes to — rather than threading a service
+ * through the command context and the panel deps for one feature.
+ *
+ * ── What is a fact here, and what is a rendering ──────────────────────────
+ *
+ * The RECORD is the daemon's, verbatim: status, attached clients, turn count,
+ * and `effectiveDetachPolicy` — what leaving would do right now. This feed
+ * never recomputes those; it stores the last record a verb or a lifecycle event
+ * handed it.
+ *
+ * The ROWS are this terminal's rendering of the transcript: the history
+ * `attach` backfilled, plus what the live `turn` and `tools` frames have said
+ * since. A row that is still being streamed is marked `streaming` so the panel
+ * can show it growing rather than waiting for the turn to end — the same thing
+ * a local turn does.
+ *
+ * ── Bounded, because it is a live buffer ──────────────────────────────────
+ *
+ * Rows are capped and the oldest are dropped with an honest note saying how
+ * many, rather than growing without limit for a session that runs for days. The
+ * daemon keeps the authoritative transcript; a reattach backfills it again.
+ */
+import type {
+  HostedSessionHistoryMessage,
+  HostedSessionRecord,
+} from '@pellux/goodvibes-sdk/platform/hosted-sessions';
+import type { HostedSessionStreamEvent } from '../runtime/client/hosted-session-stream.ts';
+
+/** How many transcript rows are kept before the oldest are dropped. */
+export const MAX_HOSTED_ROWS = 400;
+
+export type HostedRowKind = 'user' | 'assistant' | 'system' | 'tool' | 'error';
+
+/** One rendered line-group of the hosted conversation. */
+export interface HostedSessionRow {
+  readonly kind: HostedRowKind;
+  readonly text: string;
+  readonly at: number;
+  /** True while this row is still being appended to by a live stream. */
+  readonly streaming: boolean;
+  /** Set for tool rows: the call this row is about, so a cancel can name it. */
+  readonly callId?: string | undefined;
+}
+
+/** A tool call the stream says is running right now. */
+export interface HostedRunningToolCall {
+  readonly callId: string;
+  readonly tool: string;
+  readonly startedAt: number;
+}
+
+/** Everything the panel renders and the command reports. */
+export interface HostedSessionFeedState {
+  readonly record: HostedSessionRecord | null;
+  readonly rows: readonly HostedSessionRow[];
+  readonly runningToolCalls: readonly HostedRunningToolCall[];
+  /** True when a live event stream is open for this session. */
+  readonly streaming: boolean;
+  /** Why there is no live stream, when there is not one. Never a guess. */
+  readonly streamNote: string | null;
+  /** How many rows were dropped by the bound, for an honest header. */
+  readonly droppedRows: number;
+}
+
+const EMPTY_STATE: HostedSessionFeedState = {
+  record: null,
+  rows: [],
+  runningToolCalls: [],
+  streaming: false,
+  streamNote: null,
+  droppedRows: 0,
+};
+
+function historyRow(message: HostedSessionHistoryMessage): HostedSessionRow {
+  const kind: HostedRowKind = message.role === 'assistant'
+    ? 'assistant'
+    : message.role === 'user' ? 'user' : message.role === 'tool' ? 'tool' : 'system';
+  return { kind, text: message.content, at: message.at ?? 0, streaming: false };
+}
+
+function readString(payload: Record<string, unknown>, key: string): string {
+  const value = payload[key];
+  return typeof value === 'string' ? value : '';
+}
+
+/**
+ * The attached hosted session, as this terminal sees it.
+ *
+ * Deliberately a plain observable object rather than a store domain: nothing
+ * about a hosted session participates in the local conversation's state
+ * machine, and putting it there would make the local reducers answer for a
+ * conversation running in another process.
+ */
+export class HostedSessionFeed {
+  private state: HostedSessionFeedState = EMPTY_STATE;
+  private readonly listeners = new Set<() => void>();
+  /** The assistant row currently being streamed, by index into `rows`. */
+  private streamingRowIndex: number | null = null;
+  /**
+   * How to close the live subscription feeding this session, when one is open.
+   *
+   * Held here rather than in whichever module opened it because two unrelated
+   * callers have to be able to close it: the `/hosted detach` command, and the
+   * app's own exit path, which must leave the session cleanly before the
+   * process goes away.
+   */
+  private streamCloser: (() => void) | null = null;
+
+  getState(): HostedSessionFeedState {
+    return this.state;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => { this.listeners.delete(listener); };
+  }
+
+  /** True when this terminal is attached to a hosted session that has not ended. */
+  isAttached(): boolean {
+    return this.state.record !== null && this.state.record.status !== 'terminated';
+  }
+
+  /** Start rendering a session: the record the verb returned and its backfilled history. */
+  attach(record: HostedSessionRecord, history: readonly HostedSessionHistoryMessage[]): void {
+    this.streamingRowIndex = null;
+    this.state = {
+      record,
+      rows: history.map(historyRow).slice(-MAX_HOSTED_ROWS),
+      runningToolCalls: [],
+      streaming: false,
+      streamNote: null,
+      droppedRows: Math.max(0, history.length - MAX_HOSTED_ROWS),
+    };
+    this.emit();
+  }
+
+  /** Replace the record — every verb answer and every lifecycle notice lands here. */
+  setRecord(record: HostedSessionRecord): void {
+    if (this.state.record && this.state.record.id !== record.id) return;
+    this.state = { ...this.state, record };
+    this.emit();
+  }
+
+  /** Say whether a live stream is open, and why not when it is not. */
+  setStreaming(streaming: boolean, note: string | null = null): void {
+    this.state = { ...this.state, streaming, streamNote: note };
+    this.emit();
+  }
+
+  /** Hand over the live subscription so any owner of this feed can close it. */
+  bindStream(close: (() => void) | null): void {
+    this.streamCloser = close;
+  }
+
+  /** Close the live subscription, if one is open. Idempotent. */
+  closeStream(): void {
+    const close = this.streamCloser;
+    this.streamCloser = null;
+    close?.();
+  }
+
+  /** Append a note of this terminal's own — a detach, a refusal, a stream drop. */
+  note(text: string, kind: HostedRowKind = 'system'): void {
+    this.appendRow({ kind, text, at: Date.now(), streaming: false });
+  }
+
+  /** Forget the session entirely (detached, killed, or replaced). */
+  clear(): void {
+    this.closeStream();
+    this.streamingRowIndex = null;
+    this.state = EMPTY_STATE;
+    this.emit();
+  }
+
+  /**
+   * Fold one live frame into the transcript.
+   *
+   * Frames for another session never reach here (the stream filters on the id),
+   * but the guard stays because a feed that rendered another conversation's
+   * tokens would be indistinguishable from this one working.
+   */
+  apply(event: HostedSessionStreamEvent): void {
+    if (!this.state.record || event.sessionId !== this.state.record.id) return;
+    if (event.domain === 'turn') { this.applyTurnEvent(event); return; }
+    this.applyToolEvent(event);
+  }
+
+  private applyTurnEvent(event: HostedSessionStreamEvent): void {
+    switch (event.type) {
+      case 'TURN_SUBMITTED': {
+        const prompt = readString(event.payload, 'prompt');
+        if (prompt) this.appendRow({ kind: 'user', text: prompt, at: event.at, streaming: false });
+        return;
+      }
+      case 'STREAM_DELTA': {
+        // `accumulated` is the whole response so far, which is exactly what a
+        // row wants: a client that joined mid-turn renders the full text rather
+        // than the tail it happened to catch.
+        const accumulated = readString(event.payload, 'accumulated')
+          || readString(event.payload, 'content');
+        if (!accumulated) return;
+        this.updateStreamingRow(accumulated, event.at);
+        return;
+      }
+      case 'TURN_COMPLETED': {
+        const response = readString(event.payload, 'response');
+        if (response) this.updateStreamingRow(response, event.at);
+        this.settleStreamingRow();
+        return;
+      }
+      case 'TURN_ERROR': {
+        this.settleStreamingRow();
+        this.appendRow({
+          kind: 'error',
+          text: readString(event.payload, 'error') || 'the hosted turn ended with an error',
+          at: event.at,
+          streaming: false,
+        });
+        return;
+      }
+      case 'TURN_CANCEL': {
+        this.settleStreamingRow();
+        const reason = readString(event.payload, 'reason');
+        this.appendRow({
+          kind: 'system',
+          text: reason ? `turn cancelled — ${reason}` : 'turn cancelled',
+          at: event.at,
+          streaming: false,
+        });
+        return;
+      }
+      default:
+        return;
+    }
+  }
+
+  private applyToolEvent(event: HostedSessionStreamEvent): void {
+    const callId = readString(event.payload, 'callId');
+    const tool = readString(event.payload, 'tool');
+    if (!callId || !tool) return;
+    switch (event.type) {
+      case 'TOOL_EXECUTING': {
+        this.settleStreamingRow();
+        this.state = {
+          ...this.state,
+          runningToolCalls: [
+            ...this.state.runningToolCalls.filter((call) => call.callId !== callId),
+            { callId, tool, startedAt: event.at },
+          ],
+        };
+        this.appendRow({ kind: 'tool', text: `${tool} — running`, at: event.at, streaming: true, callId });
+        return;
+      }
+      case 'TOOL_SUCCEEDED':
+      case 'TOOL_FAILED':
+      case 'TOOL_CANCELLED': {
+        const outcome = event.type === 'TOOL_SUCCEEDED'
+          ? 'done'
+          : event.type === 'TOOL_FAILED'
+            ? `failed — ${readString(event.payload, 'error') || 'no reason reported'}`
+            : `cancelled${readString(event.payload, 'reason') ? ` — ${readString(event.payload, 'reason')}` : ''}`;
+        this.state = {
+          ...this.state,
+          runningToolCalls: this.state.runningToolCalls.filter((call) => call.callId !== callId),
+          rows: this.state.rows.map((row) => (
+            row.callId === callId && row.streaming
+              ? { ...row, text: `${tool} — ${outcome}`, streaming: false }
+              : row
+          )),
+        };
+        this.emit();
+        return;
+      }
+      default:
+        return;
+    }
+  }
+
+  /** Fold a hosted lifecycle transition in: the record, plus a line when it matters. */
+  applyLifecycle(update: { readonly event: string; readonly session: HostedSessionRecord; readonly detail?: string | undefined }): void {
+    this.setRecord(update.session);
+    if (update.event === 'hosted-session-terminated') {
+      this.settleStreamingRow();
+      const reason = update.session.terminatedReason ?? 'no reason recorded';
+      this.note(`this hosted session ended — ${reason}${update.detail ? ` (${update.detail})` : ''}`);
+    }
+  }
+
+  private updateStreamingRow(text: string, at: number): void {
+    if (this.streamingRowIndex === null) {
+      this.appendRow({ kind: 'assistant', text, at, streaming: true });
+      this.streamingRowIndex = this.state.rows.length - 1;
+      return;
+    }
+    const rows = [...this.state.rows];
+    const existing = rows[this.streamingRowIndex];
+    if (!existing) { this.streamingRowIndex = null; return; }
+    rows[this.streamingRowIndex] = { ...existing, text, at };
+    this.state = { ...this.state, rows };
+    this.emit();
+  }
+
+  private settleStreamingRow(): void {
+    if (this.streamingRowIndex === null) return;
+    const rows = [...this.state.rows];
+    const existing = rows[this.streamingRowIndex];
+    if (existing) rows[this.streamingRowIndex] = { ...existing, streaming: false };
+    this.streamingRowIndex = null;
+    this.state = { ...this.state, rows };
+    this.emit();
+  }
+
+  private appendRow(row: HostedSessionRow): void {
+    const rows = [...this.state.rows, row];
+    let dropped = this.state.droppedRows;
+    while (rows.length > MAX_HOSTED_ROWS) {
+      rows.shift();
+      dropped += 1;
+      if (this.streamingRowIndex !== null) this.streamingRowIndex -= 1;
+    }
+    if (this.streamingRowIndex !== null && this.streamingRowIndex < 0) this.streamingRowIndex = null;
+    this.state = { ...this.state, rows, droppedRows: dropped };
+    this.emit();
+  }
+
+  private emit(): void {
+    // Snapshot before iterating: a listener that unsubscribes during dispatch
+    // must not make the next listener be skipped.
+    for (const listener of [...this.listeners]) listener();
+  }
+}
+
+let sharedFeed: HostedSessionFeed | null = null;
+
+/** The one feed the `/hosted` command writes and the Hosted Session panel reads. */
+export function getSharedHostedSessionFeed(): HostedSessionFeed {
+  sharedFeed ??= new HostedSessionFeed();
+  return sharedFeed;
+}
+
+/** Tests build their own feed; this resets the shared one between them. */
+export function resetSharedHostedSessionFeed(): void {
+  sharedFeed = null;
+}

package/src/panels/hosted-session-panel.ts

@@ -0,0 +1,221 @@
+/**
+ * HostedSessionPanel — the conversation the daemon is running, rendered here.
+ *
+ * A hosted session's turn arrives on the same `turn` and `tools` event domains
+ * a local turn does, so what this panel shows is the same thing the transcript
+ * shows for a local conversation: what was said, what tool is running, and
+ * whether text is still streaming. The difference is where the loop lives, and
+ * the header says so plainly — including `effectiveDetachPolicy`, so a person
+ * about to quit knows whether that ends the work.
+ *
+ * The panel renders; it decides nothing. Every fact in the header is a field of
+ * the daemon's own record (hosted-session-feed.ts), and the rows are the
+ * backfilled history plus the live frames. When there is no stream open the
+ * panel says why rather than showing a still conversation that looks finished.
+ */
+import type { Line } from '@pellux/goodvibes-sdk/platform/types';
+import { BasePanel } from './base-panel.ts';
+import {
+  buildEmptyState,
+  buildKeyboardHints,
+  buildPanelWorkspace,
+  buildStyledPanelLine,
+  DEFAULT_PANEL_PALETTE,
+  resolveScrollablePanelSection,
+} from './polish.ts';
+import { wrapText } from '../utils/terminal-width.ts';
+import {
+  getSharedHostedSessionFeed,
+  type HostedSessionFeed,
+  type HostedSessionFeedState,
+  type HostedSessionRow,
+} from './hosted-session-feed.ts';
+
+const C = DEFAULT_PANEL_PALETTE;
+
+const INTRO = 'A conversation whose loop runs inside the daemon. Steer it with /hosted say, leave it with /hosted detach — the header says what leaving would do.';
+
+function rowColor(kind: HostedSessionRow['kind']): string {
+  switch (kind) {
+    case 'user': return C.accent;
+    case 'assistant': return C.value;
+    case 'tool': return C.info;
+    case 'error': return C.bad;
+    default: return C.dim;
+  }
+}
+
+function rowPrefix(kind: HostedSessionRow['kind']): string {
+  switch (kind) {
+    case 'user': return 'you';
+    case 'assistant': return 'hosted';
+    case 'tool': return 'tool';
+    case 'error': return 'error';
+    default: return '·';
+  }
+}
+
+/** Every line one transcript row needs. Text is wrapped in full, never clipped. */
+export function renderHostedRow(row: HostedSessionRow, width: number): Line[] {
+  const lines: Line[] = [];
+  const fg = rowColor(row.kind);
+  const marker = row.streaming ? ' …' : '';
+  const body = `${rowPrefix(row.kind)}: ${row.text}${marker}`;
+  const wrapWidth = Math.max(1, width - 1);
+  for (const [index, wrapped] of wrapText(body, wrapWidth).entries()) {
+    lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg, bold: index === 0 && row.kind === 'user' }]));
+  }
+  return lines;
+}
+
+/**
+ * The header block: who this session is, what it is doing, and what leaving it
+ * would do. Every value comes from the record; nothing is derived locally.
+ */
+export function buildHostedHeaderLines(state: HostedSessionFeedState, width: number): Line[] {
+  const record = state.record;
+  if (!record) return [];
+  const policyText = record.effectiveDetachPolicy === 'survive'
+    ? 'detaching keeps it running (survive)'
+    : 'detaching ends it (kill)';
+  const policySource = record.detachPolicy === null ? 'from the setting' : 'per-session override';
+  const rows: { text: string; fg: string }[] = [
+    { text: `${record.title.trim() || record.id} — ${record.status}`, fg: C.header },
+    { text: `id ${record.id}`, fg: C.dim },
+    { text: `workspace ${record.workspaceRoot}`, fg: C.dim },
+    {
+      text: `${policyText}, ${policySource}`,
+      fg: record.effectiveDetachPolicy === 'survive' ? C.good : C.warn,
+    },
+    {
+      text: `${record.turnCount} turn(s), ${record.messageCount} message(s); attached: ${record.attachedClients.length > 0 ? record.attachedClients.join(', ') : 'nobody'}`,
+      fg: C.label,
+    },
+  ];
+  if (record.status === 'terminated') {
+    rows.push({ text: `ended — ${record.terminatedReason ?? 'no reason recorded'}`, fg: C.bad });
+  }
+  if (record.restoredFromDisk) {
+    rows.push({ text: 'restored from disk after a daemon restart', fg: C.warn });
+  }
+  rows.push(state.streaming
+    ? { text: 'live event stream open', fg: C.good }
+    : { text: `no live stream — ${state.streamNote ?? 'not subscribed'}`, fg: C.warn });
+  if (state.runningToolCalls.length > 0) {
+    rows.push({
+      text: `running: ${state.runningToolCalls.map((call) => `${call.tool} (${call.callId})`).join(', ')}`,
+      fg: C.info,
+    });
+  }
+  if (state.droppedRows > 0) {
+    rows.push({ text: `${state.droppedRows} earlier row(s) dropped by this panel's buffer — reattach to backfill`, fg: C.dim });
+  }
+  const lines: Line[] = [];
+  for (const row of rows) {
+    for (const wrapped of wrapText(row.text, Math.max(1, width - 1))) {
+      lines.push(buildStyledPanelLine(width, [{ text: ` ${wrapped}`, fg: row.fg }]));
+    }
+  }
+  return lines;
+}
+
+export class HostedSessionPanel extends BasePanel {
+  private readonly unsubscribe: () => void;
+  private scrollOffset = 0;
+  /** Off until the user scrolls: a live conversation should follow its own tail. */
+  private pinnedToTail = true;
+
+  constructor(private readonly feed: HostedSessionFeed = getSharedHostedSessionFeed()) {
+    // '◈' verified free against the registered builtin panel icons.
+    super('hosted', 'Hosted Session', '◈', 'session');
+    this.unsubscribe = this.feed.subscribe(() => {
+      if (this.pinnedToTail) this.scrollOffset = Number.MAX_SAFE_INTEGER;
+      this.markDirty();
+    });
+  }
+
+  override onDestroy(): void {
+    this.unsubscribe();
+    super.onDestroy();
+  }
+
+  handleInput(key: string): boolean {
+    switch (key) {
+      case 'up': return this.scroll(-1);
+      case 'down': return this.scroll(1);
+      case 'pageup': return this.scroll(-10);
+      case 'pagedown': return this.scroll(10);
+      case 'end': {
+        this.pinnedToTail = true;
+        this.scrollOffset = Number.MAX_SAFE_INTEGER;
+        this.markDirty();
+        return true;
+      }
+      default: return false;
+    }
+  }
+
+  private scroll(delta: number): boolean {
+    const rows = this.feed.getState().rows;
+    if (rows.length === 0) return false;
+    // Scrolling up unpins; reaching the bottom re-pins, so a reader who catches
+    // up starts following again without a second key.
+    this.pinnedToTail = false;
+    this.scrollOffset = Math.max(0, this.scrollOffset + delta);
+    this.markDirty();
+    return true;
+  }
+
+  render(width: number, height: number): Line[] {
+    if (width <= 0 || height <= 0) return [];
+    const state = this.feed.getState();
+    const hintRow = buildKeyboardHints(width, [
+      { keys: 'Up/Down', label: 'scroll' },
+      { keys: 'PgUp/PgDn', label: 'page' },
+      { keys: 'End', label: 'follow' },
+    ], DEFAULT_PANEL_PALETTE);
+
+    if (!state.record) {
+      return buildPanelWorkspace(width, height, {
+        title: ' Hosted Session',
+        intro: INTRO,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' Not attached to a hosted session',
+            'A hosted session runs inside the daemon instead of this terminal, so it can outlive the window it was started from. Start one with /hosted new, or join one that already exists with /hosted list and /hosted attach <id>. Local sessions are unchanged and remain the default.',
+            [],
+            DEFAULT_PANEL_PALETTE,
+          ),
+        }],
+        footerLines: [hintRow],
+        palette: DEFAULT_PANEL_PALETTE,
+      });
+    }
+
+    const headerSection = { lines: buildHostedHeaderLines(state, width - 2) };
+    const scrollableLines = state.rows.flatMap((row) => renderHostedRow(row, width - 2));
+    const section = resolveScrollablePanelSection(width, height, {
+      intro: INTRO,
+      footerLines: [hintRow],
+      palette: DEFAULT_PANEL_PALETTE,
+      beforeSections: [headerSection],
+      section: {
+        title: `Transcript (${state.rows.length})`,
+        scrollableLines,
+        scrollOffset: this.scrollOffset,
+        minRows: 4,
+        appendWindowSummary: scrollableLines.length > 0 ? { dimColor: DEFAULT_PANEL_PALETTE.dim } : undefined,
+      },
+    });
+    this.scrollOffset = section.scrollOffset;
+
+    return buildPanelWorkspace(width, height, {
+      title: ' Hosted Session',
+      intro: INTRO,
+      sections: [headerSection, section.section],
+      footerLines: [hintRow],
+      palette: DEFAULT_PANEL_PALETTE,
+    });
+  }
+}

package/src/panels/local-auth-panel.ts

@@ -1,5 +1,5 @@
-import type { Line } from '../types/grid.ts';
-import { createEmptyLine } from '../types/grid.ts';
+import type { Line } from '@pellux/goodvibes-sdk/platform/types';
+import { createEmptyLine } from '@pellux/goodvibes-sdk/platform/types';
 import { fitDisplay, truncateDisplay } from '../utils/terminal-width.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
 import {
@@ -14,7 +14,7 @@ import {
   type PanelPalette,
 } from './polish.ts';
 import type { LocalAuthSnapshot, UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
-import type { LocalAuthInspectionQuery } from '../runtime/ui-service-queries.ts';
+import type { LocalAuthInspectionQuery } from '@/runtime/index.ts';
 import type { KeyName } from './types.ts';
 import { isTextBackspace } from '../input/delete-key-policy.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';

package/src/panels/modals/devices-modal.ts

@@ -7,7 +7,7 @@ import type {
   ConfigModalView,
 } from '../../input/config-modal-types.ts';
 import type { MintedPairingToken, PublicPairingToken } from '@pellux/goodvibes-sdk/platform/pairing';
-import { formatDeviceLine, shortTokenId } from '../../core/pairing-devices.ts';
+import { formatDeviceLine, shortTokenId } from '@pellux/goodvibes-sdk/platform/pairing';
 
 // ---------------------------------------------------------------------------
 // Paired Devices — the settings security-domain device/token management surface.

package/src/panels/modals/local-auth-modal.ts

@@ -1,5 +1,5 @@
 import type { ConfigModalAction, ConfigModalActionContext, ConfigModalRow, ConfigModalSurface, ConfigModalView } from '../../input/config-modal-types.ts';
-import type { LocalAuthInspectionQuery } from '../../runtime/ui-service-queries.ts';
+import type { LocalAuthInspectionQuery } from '@/runtime/index.ts';
 import type { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { postureLine, kv } from './modal-surface-helpers.ts';

package/src/panels/modals/pairing-modal.ts

@@ -7,7 +7,7 @@ import type {
   ConfigModalView,
 } from '../../input/config-modal-types.ts';
 import { describeOriginPosture, generateQrMatrix, renderQrToString, type OriginPosture, type PairingHandoffOfferKind } from '@pellux/goodvibes-sdk/platform/pairing';
-import { formatPairingOffers, formatPostureCapabilities, pairingPostureNotice } from '../../core/pairing-offers.ts';
+import { formatPairingOffers, formatPostureCapabilities, pairingPostureNotice } from '@pellux/goodvibes-sdk/platform/pairing';
 
 // ---------------------------------------------------------------------------
 // Device Pairing config-modal surface. Shows the web-app origin, the per-device

package/src/panels/modals/services-modal.ts

@@ -1,5 +1,5 @@
 import type { ConfigModalActionContext, ConfigModalSurface, ConfigModalView } from '../../input/config-modal-types.ts';
-import type { ServiceInspectionQuery, SubscriptionAccessQuery } from '../../runtime/ui-service-queries.ts';
+import type { ServiceInspectionQuery, SubscriptionAccessQuery } from '@/runtime/index.ts';
 import type { ServiceConfig, ServiceInspection, ServiceConnectionTestResult } from '@pellux/goodvibes-sdk/platform/config';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { toneStyle, statusGlyph, pad, postureLine, kv, type Tone } from './modal-surface-helpers.ts';

package/src/panels/modals/settings-sync-modal.ts

@@ -1,6 +1,6 @@
 import type { ConfigModalAction, ConfigModalActionContext, ConfigModalRow, ConfigModalSurface, ConfigModalView } from '../../input/config-modal-types.ts';
 import { getSettingsControlPlaneSnapshot } from '@/runtime/index.ts';
-import type { ConfigManager } from '../../config/index.ts';
+import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { toneStyle, pad, postureLine, kv, type Tone } from './modal-surface-helpers.ts';
 
 type Snapshot = ReturnType<typeof getSettingsControlPlaneSnapshot>;

package/src/panels/modals/subscription-modal.ts

@@ -1,5 +1,5 @@
 import type { ConfigModalActionContext, ConfigModalSurface, ConfigModalView } from '../../input/config-modal-types.ts';
-import type { ServiceInspectionQuery, SubscriptionAccessQuery } from '../../runtime/ui-service-queries.ts';
+import type { ServiceInspectionQuery, SubscriptionAccessQuery } from '@/runtime/index.ts';
 import type { ProviderSubscription, PendingSubscriptionLogin } from '@pellux/goodvibes-sdk/platform/config';
 import { listBuiltinSubscriptionProviders } from '@pellux/goodvibes-sdk/platform/config';
 import { formatElapsed } from '../../utils/format-elapsed.ts';

package/src/panels/modals/work-plan-modal.ts

@@ -4,7 +4,7 @@ import type {
   ConfigModalSurface,
   ConfigModalView,
 } from '../../input/config-modal-types.ts';
-import type { WorkPlanItemStatus } from '../../work-plans/work-plan-store.ts';
+import type { WorkPlanItemStatus } from '@pellux/goodvibes-sdk/platform/workflow';
 
 // ---------------------------------------------------------------------------
 // Work Plan → config-modal surface (group-B port). Lists the active

package/src/panels/notifications-panel.ts

@@ -8,7 +8,7 @@
  * the conversation. Descriptive text (titles, bodies, reason descriptions)
  * is always wrapped in full — never clipped to a column width.
  */
-import type { Line } from '../types/grid.ts';
+import type { Line } from '@pellux/goodvibes-sdk/platform/types';
 import type { RoutingDecision } from '@/runtime/index.ts';
 import { BasePanel } from './base-panel.ts';
 import {

package/src/panels/panel-confirm-overlay.ts

@@ -12,7 +12,7 @@
 // way don't each hand-roll the same field + dispatch + render wiring.
 // ---------------------------------------------------------------------------
 
-import type { Line } from '../types/grid.ts';
+import type { Line } from '@pellux/goodvibes-sdk/platform/types';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 
 export interface PanelConfirmOverlayHandlers {