@pellux/goodvibes-tui 1.1.0 → 1.7.0

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

@@ -0,0 +1,151 @@
+import { infoRow } from './modal-surface-helpers.ts';
+import type {
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalTab,
+  ConfigModalView,
+} from '../../input/config-modal-types.ts';
+import { KeybindingsManager } from '../../input/keybindings.ts';
+
+// ---------------------------------------------------------------------------
+// Docs + Shortcuts → 'keybindings' config-modal surface (W6.1 group-B port).
+// A MERGE of the retired DocsPanel (tools/models/shortcuts) and the
+// shortcuts-overlay reference. Three tabs: 'Tools', 'Models', and 'Shortcuts'
+// (the categorized keyboard reference — driven live off keybindingsManager so
+// user overrides show up — followed by an exhaustive 'All Bindings (live)'
+// table). Enter opens the tool-inspector successor ('fleet') or switches the
+// active model, both via the command path (fleet is a panel; /model is a
+// settings mutation). Selection-blind port: the panel's selected tool/model
+// detail is folded into each row label. The panel's live '/' filter is dropped
+// (the host has no query state).
+// ---------------------------------------------------------------------------
+
+export interface KeybindingsModalTool {
+  readonly definition: {
+    readonly name: string;
+    readonly description?: string;
+    readonly sideEffects?: readonly string[];
+    readonly concurrency?: string;
+    readonly supportsProgress?: boolean;
+    readonly supportsStreamingOutput?: boolean;
+  };
+}
+export interface KeybindingsModalToolRegistry { list(): readonly KeybindingsModalTool[]; }
+export interface KeybindingsModalModel { readonly id: string; readonly provider: string; readonly registryKey: string; readonly displayName: string; readonly contextWindow: number; readonly selectable: boolean; }
+export interface KeybindingsModalProviderRegistry { listModels(): readonly KeybindingsModalModel[]; getCurrentModel?(): { readonly registryKey: string } | undefined; }
+
+export interface KeybindingsModalDeps {
+  readonly toolRegistry?: KeybindingsModalToolRegistry;
+  readonly providerRegistry?: KeybindingsModalProviderRegistry;
+  readonly keybindingsManager?: KeybindingsManager;
+}
+
+class KeybindingsModalSurface implements ConfigModalSurface {
+  readonly name = 'keybindings-modal';
+  readonly title = 'Keybindings';
+
+  constructor(private readonly deps: KeybindingsModalDeps) {}
+
+  readonly actions = [
+    { key: 'enter', id: 'activate', label: 'activate', enabledFor: (row: ConfigModalRow | null, tabId: string) => (tabId === 'tools') || (tabId === 'models' && row !== null) },
+    { key: 'r', id: 'refresh', label: 'refresh' },
+  ];
+
+  private sortedModels(): readonly KeybindingsModalModel[] {
+    const models = this.deps.providerRegistry?.listModels() ?? [];
+    return [...models].sort((a, b) => a.provider.localeCompare(b.provider) || a.displayName.localeCompare(b.displayName));
+  }
+
+  private toolsTab(): ConfigModalTab {
+    if (!this.deps.toolRegistry) return { id: 'tools', label: 'Tools', rows: [infoRow('tools:none', 'Tool registry not wired into this session.', { dim: true })], emptyText: 'Tool registry not wired into this session.' };
+    const tools = this.deps.toolRegistry.list();
+    const rows: ConfigModalRow[] = tools.map((tool) => {
+      const d = tool.definition;
+      const meta: string[] = [];
+      if (d.sideEffects?.length) meta.push(`effects: ${d.sideEffects.join(', ')}`);
+      if (d.concurrency) meta.push(`concurrency: ${d.concurrency}`);
+      if (d.supportsProgress) meta.push('progress');
+      if (d.supportsStreamingOutput) meta.push('streaming');
+      const detail = [d.description, meta.join('  |  ') || null].filter((s): s is string => Boolean(s)).join(' · ');
+      return { id: `tool:${d.name}`, label: detail ? `${d.name.padEnd(22)} ${detail}` : d.name };
+    });
+    return { id: 'tools', label: 'Tools', rows, emptyText: 'No tools registered.', hints: ['enter open in fleet'] };
+  }
+
+  private modelsTab(): ConfigModalTab {
+    if (!this.deps.providerRegistry) return { id: 'models', label: 'Models', rows: [infoRow('models:none', 'Provider registry not wired into this session.', { dim: true })], emptyText: 'Provider registry not wired into this session.' };
+    const activeKey = this.deps.providerRegistry.getCurrentModel?.()?.registryKey;
+    const rows: ConfigModalRow[] = this.sortedModels().map((model) => {
+      const ctxK = model.contextWindow > 0 ? `${(model.contextWindow / 1000).toFixed(0)}k` : '?';
+      const isActive = model.registryKey === activeKey;
+      return { id: `model:${model.registryKey}`, label: `${model.provider.padEnd(14)} ${model.displayName.padEnd(24)} ctx:${ctxK}${isActive ? '  ACTIVE' : ''}  ${model.id}${model.selectable ? '' : '  (not selectable)'}` };
+    });
+    return { id: 'models', label: 'Models', rows, emptyText: 'No models registered.', hints: ['enter set active model'] };
+  }
+
+  private shortcutsTab(): ConfigModalTab {
+    const km = this.deps.keybindingsManager;
+    if (!km) return { id: 'shortcuts', label: 'Shortcuts', rows: [infoRow('sc:none', 'Keybindings manager not wired into this session.', { dim: true })], emptyText: 'Keybindings manager not wired into this session.' };
+    const kb = (action: Parameters<KeybindingsManager['getComboLabel']>[0]) => km.getComboLabel(action);
+    const rows: ConfigModalRow[] = [];
+    let n = 0;
+    const category = (title: string, entries: ReadonlyArray<readonly [string, string]>): void => {
+      rows.push(infoRow(`sc:t:${n++}`, title));
+      for (const [key, desc] of entries) rows.push(infoRow(`sc:${n++}`, `${key.padEnd(20)} ${desc}`));
+    };
+    category('Navigation', [['Up / Down', 'Scroll / history recall'], ['PageUp / PageDn', 'Scroll by full page'], ['Home / End', 'Jump to start / end of line'], [kb('search'), 'Search conversation'], ['n / N (search)', 'Next / previous match'], ['Mouse wheel', 'Scroll conversation or hovered panel']]);
+    category('Editing', [['Enter', 'Submit message'], ['Shift+Enter', 'Insert newline'], ['@', 'Open file picker'], ['/', 'Slash command mode'], [kb('paste'), 'Paste (image priority)'], [`${kb('undo')} / ${kb('redo')}`, 'Undo / redo'], [kb('clear-prompt'), 'Clear prompt'], [kb('delete-word'), 'Delete word backward'], [kb('kill-line'), 'Kill to end of line']]);
+    category('Actions', [['Tab', 'Collapse/expand block'], [kb('bookmark'), 'Bookmark block'], [kb('block-copy'), 'Copy block to clipboard'], [kb('block-save'), 'Save block to file'], [kb('copy-selection'), 'Copy selection'], ['F2', 'Process monitor'], ['?', 'Help overlay'], [`${kb('clear-cancel')} x2`, 'Exit']]);
+    category('Panels', [['Tab', 'Swap focus between input and panel workspace'], [kb('panel-picker'), 'Open / focus / hide panel workspace'], [kb('panel-tab-next'), 'Next workspace panel tab'], [kb('panel-tab-prev'), 'Previous workspace panel tab'], [`${kb('panel-tab-1')}...${kb('panel-tab-9')}`, 'Jump to workspace tab 1-9'], [kb('panel-focus-toggle'), 'Swap focus between top / bottom pane'], [kb('panel-close'), 'Close active panel'], [kb('panel-close-all'), 'Close all panels'], [kb('panel-ops'), 'Open the Ops Control panel']]);
+    category('In-Panel Controls', [['j / k', 'Move selection down / up'], ['g / G', 'Jump to top / bottom'], ['/', 'Filter the list']]);
+    const allBindings = km.getAll().map((entry) => [entry.combos.length > 0 ? entry.combos.map((combo) => km.formatCombo(combo)).join(', ') : '(unbound)', entry.description] as const);
+    category('All Bindings (live)', allBindings);
+    return { id: 'shortcuts', label: 'Shortcuts', rows, emptyText: 'No shortcuts recorded.' };
+  }
+
+  buildView(): ConfigModalView {
+    return { title: 'Keybindings', tabs: [this.toolsTab(), this.modelsTab(), this.shortcutsTab()] };
+  }
+
+  onAction(id: string, ctx: ConfigModalActionContext): void {
+    if (id === 'refresh') { ctx.setStatus('Docs & shortcuts are read live.'); ctx.requestRender(); return; }
+    if (id !== 'activate') return;
+    if (ctx.tabId === 'tools') { void ctx.executeCommand?.('panel', ['open', 'fleet']); ctx.setStatus('Opened the tool inspector (fleet).'); return; }
+    if (ctx.tabId === 'models') {
+      const key = ctx.row?.id.startsWith('model:') ? ctx.row.id.slice('model:'.length) : null;
+      if (!key) return;
+      const model = this.sortedModels().find((m) => m.registryKey === key);
+      if (!model || !model.selectable) { ctx.setStatus('This model is not selectable.'); return; }
+      void ctx.executeCommand?.('model', [model.registryKey]);
+      ctx.setStatus(`Dispatched /model ${model.registryKey}.`);
+    }
+  }
+}
+
+export function createKeybindingsModalSurface(deps: KeybindingsModalDeps): ConfigModalSurface {
+  return new KeybindingsModalSurface(deps);
+}
+
+/**
+ * Deterministic golden fixture. KeybindingsManager is pointed at a nonexistent
+ * config path so it always resolves to DEFAULT_KEYBINDINGS. Tool and model
+ * fixtures are frozen literals — no disk, no live registry.
+ */
+export function keybindingsModalGoldenSurface(): ConfigModalSurface {
+  const keybindingsManager = new KeybindingsManager({ configPath: '/nonexistent/golden-keybindings.json' });
+  const toolRegistry: KeybindingsModalToolRegistry = {
+    list: () => [
+      { definition: { name: 'read_file', description: 'Read a file from disk.', sideEffects: ['read_fs'], concurrency: 'parallel', supportsProgress: false, supportsStreamingOutput: false } },
+      { definition: { name: 'run_shell', description: 'Execute a shell command.', sideEffects: ['exec'], concurrency: 'serial', supportsProgress: true, supportsStreamingOutput: true } },
+    ],
+  };
+  const providerRegistry: KeybindingsModalProviderRegistry = {
+    listModels: () => [
+      { id: 'golden-a', provider: 'golden-provider', registryKey: 'golden-provider:golden-a', displayName: 'Golden Model A', contextWindow: 128000, selectable: true },
+      { id: 'golden-b', provider: 'golden-provider', registryKey: 'golden-provider:golden-b', displayName: 'Golden Model B', contextWindow: 32000, selectable: false },
+    ],
+    getCurrentModel: () => ({ registryKey: 'golden-provider:golden-a' }),
+  };
+  return createKeybindingsModalSurface({ toolRegistry, providerRegistry, keybindingsManager });
+}

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

@@ -0,0 +1,158 @@
+import { infoRow } from './modal-surface-helpers.ts';
+import type {
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalTab,
+  ConfigModalView,
+} from '../../input/config-modal-types.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+// ---------------------------------------------------------------------------
+// Knowledge (graph) → config-modal surface (W6.1 group-B port). Two tabs:
+// 'Browse' (sources/nodes/issues + schedules) and 'Review' (the open-issue
+// queue) — the panel's browse/review toggle, now host tabs. Issue review
+// mutations (accept/reject/resolve/reopen) route to the `/knowledge
+// review-issue` command. 'm' cross-opens the memory surface. Selection-blind
+// port: the panel's selected-row id/detail is folded into each row label.
+// refresh() is the only place this module touches the SDK.
+// ---------------------------------------------------------------------------
+
+interface KnowledgeNodeLike { readonly id: string; readonly kind: string; readonly title: string; readonly summary?: string | undefined; }
+interface KnowledgeSourceLike { readonly id: string; readonly sourceType: string; readonly status: string; readonly title?: string | undefined; readonly canonicalUri?: string | undefined; readonly sourceUri?: string | undefined; readonly summary?: string | undefined; }
+interface KnowledgeIssueLike { readonly id: string; readonly severity: 'info' | 'warning' | 'error'; readonly code: string; readonly message: string; readonly status: 'open' | 'resolved'; readonly sourceId?: string | undefined; readonly nodeId?: string | undefined; }
+interface KnowledgeScheduleLike { readonly id: string; readonly label: string; readonly enabled: boolean; }
+
+export interface KnowledgeModalDeps {
+  readonly knowledgeApi: {
+    readonly graph: {
+      readonly nodes: { list(limit?: number): readonly KnowledgeNodeLike[] };
+      readonly issues: { list(limit?: number): readonly KnowledgeIssueLike[] };
+    };
+    readonly sources: { list(limit?: number): readonly KnowledgeSourceLike[] };
+    readonly jobs: { schedules: { list(limit?: number): readonly KnowledgeScheduleLike[] } };
+  };
+}
+
+type BrowseKind = 'node' | 'source' | 'issue';
+interface BrowseRow { readonly kind: BrowseKind; readonly id: string; readonly title: string; readonly tag: string; readonly detail: string; readonly extra: string; }
+
+const LIST_LIMIT = 60;
+
+function cleanInline(value: string | undefined): string { return (value ?? '').replace(/\s+/g, ' ').trim(); }
+
+function nodeRow(node: KnowledgeNodeLike): BrowseRow {
+  return { kind: 'node', id: node.id, title: cleanInline(node.title) || 'untitled', tag: `node/${node.kind}`, detail: cleanInline(node.summary), extra: '' };
+}
+function sourceRow(source: KnowledgeSourceLike): BrowseRow {
+  return { kind: 'source', id: source.id, title: cleanInline(source.title) || cleanInline(source.canonicalUri) || cleanInline(source.sourceUri) || source.id, tag: `source/${source.status}`, detail: cleanInline(source.summary), extra: `type ${source.sourceType}` };
+}
+function issueRow(issue: KnowledgeIssueLike): BrowseRow {
+  const refs = [issue.sourceId ? `source ${issue.sourceId}` : null, issue.nodeId ? `node ${issue.nodeId}` : null].filter((ref): ref is string => ref !== null);
+  return { kind: 'issue', id: issue.id, title: issue.code, tag: `issue/${issue.severity}`, detail: cleanInline(issue.message), extra: refs.join('  ') };
+}
+
+class KnowledgeModalSurface implements ConfigModalSurface {
+  readonly name = 'knowledge-modal';
+  readonly title = 'Knowledge';
+  private browseRows: BrowseRow[] = [];
+  private reviewRows: BrowseRow[] = [];
+  private sourceCount = 0;
+  private nodeCount = 0;
+  private issueCount = 0;
+  private schedules: readonly KnowledgeScheduleLike[] = [];
+  private loadError: string | null = null;
+
+  constructor(private readonly deps: KnowledgeModalDeps) {}
+
+  private readonly issueGate = (row: ConfigModalRow | null, tabId: string): boolean => tabId === 'review' && (row?.id.startsWith('issue:') ?? false);
+
+  readonly actions = [
+    { key: 'a', id: 'accept', label: 'accept', enabledFor: this.issueGate },
+    { key: 'x', id: 'reject', label: 'reject', enabledFor: this.issueGate },
+    { key: 's', id: 'resolve', label: 'resolve', enabledFor: this.issueGate },
+    { key: 'o', id: 'reopen', label: 'reopen', enabledFor: this.issueGate },
+    { key: 'm', id: 'openMemory', label: 'memory' },
+    { key: 'r', id: 'refresh', label: 'refresh' },
+  ];
+
+  onOpen(): void { this.refresh(); }
+
+  private refresh(): void {
+    try {
+      const nodes = this.deps.knowledgeApi.graph.nodes.list(LIST_LIMIT);
+      const sources = this.deps.knowledgeApi.sources.list(LIST_LIMIT);
+      const issues = this.deps.knowledgeApi.graph.issues.list(LIST_LIMIT);
+      this.sourceCount = sources.length;
+      this.nodeCount = nodes.length;
+      this.issueCount = issues.length;
+      this.browseRows = [...sources.map(sourceRow), ...nodes.map(nodeRow), ...issues.map(issueRow)];
+      this.reviewRows = issues.filter((issue) => issue.status === 'open').map(issueRow);
+      this.schedules = this.deps.knowledgeApi.jobs.schedules.list(20);
+      this.loadError = null;
+    } catch (e) {
+      this.browseRows = []; this.reviewRows = []; this.schedules = [];
+      this.loadError = `Knowledge graph load failed: ${summarizeError(e)}`;
+    }
+  }
+
+  private rowFor(row: BrowseRow): ConfigModalRow {
+    return { id: `${row.kind}:${row.id}`, label: `${row.tag.padEnd(16)} ${row.title.padEnd(28)} ${row.detail}${row.extra ? `  · ${row.extra}` : ''}` };
+  }
+
+  private browseTab(): ConfigModalTab {
+    const readySources = this.sourceCount > 0 && this.nodeCount > 0;
+    const header = [
+      `sources ${this.sourceCount}  nodes ${this.nodeCount}  issues ${this.issueCount}  schedules ${this.schedules.length}`,
+      readySources ? 'retrieval ready (sources + nodes indexed)' : 'retrieval not ready (needs sources and nodes)',
+    ];
+    const rows: ConfigModalRow[] = this.browseRows.map((row) => this.rowFor(row));
+    if (this.schedules.length > 0) {
+      rows.push(infoRow('sched:title', 'Schedules'));
+      this.schedules.slice(0, 4).forEach((s, i) => rows.push(infoRow(`sched:${i}`, `${s.enabled ? 'on ' : 'off'}  ${s.label}`, s.enabled ? undefined : { dim: true })));
+    }
+    return { id: 'browse', label: 'Browse', header, rows, emptyText: 'No ingested knowledge yet.', hints: ['m memory'] };
+  }
+
+  private reviewTab(): ConfigModalTab {
+    return { id: 'review', label: 'Review', rows: this.reviewRows.map((row) => this.rowFor(row)), emptyText: 'No issues waiting for review.', hints: ['a accept', 'x reject', 's resolve', 'o reopen'] };
+  }
+
+  buildView(): ConfigModalView {
+    if (this.loadError) return { title: 'Knowledge', degraded: this.loadError, tabs: [{ id: 'browse', label: 'Browse', rows: [] }] };
+    return { title: 'Knowledge', tabs: [this.browseTab(), this.reviewTab()] };
+  }
+
+  onAction(id: string, ctx: ConfigModalActionContext): void {
+    if (id === 'refresh') { this.refresh(); ctx.setStatus('Reloaded knowledge graph.'); return; }
+    if (id === 'openMemory') { ctx.openModal?.('memory-modal'); return; }
+    const action = id === 'accept' ? 'accept' : id === 'reject' ? 'reject' : id === 'resolve' ? 'resolve' : id === 'reopen' ? 'reopen' : null;
+    if (!action) return;
+    const issueId = ctx.row?.id.startsWith('issue:') ? ctx.row.id.slice('issue:'.length) : null;
+    if (!issueId) return;
+    void ctx.executeCommand?.('knowledge', ['review-issue', issueId, action, '--reviewer', 'tui']);
+    ctx.setStatus(`Dispatched /knowledge review-issue ${issueId} ${action}.`);
+  }
+}
+
+export function createKnowledgeModalSurface(deps: KnowledgeModalDeps): ConfigModalSurface {
+  return new KnowledgeModalSurface(deps);
+}
+
+/**
+ * Deterministic golden fixture: fixed node/source/issue/schedule records —
+ * no live SDK calls, no random ids, no wall-clock reads.
+ */
+export function knowledgeModalGoldenSurface(): ConfigModalSurface {
+  const nodes: readonly KnowledgeNodeLike[] = [{ id: 'node-1', kind: 'topic', title: 'Release cadence', summary: 'Batched internal releases, no per-change tags.' }];
+  const sources: readonly KnowledgeSourceLike[] = [{ id: 'source-1', sourceType: 'repo', status: 'indexed', title: 'goodvibes-tui', canonicalUri: 'repo://goodvibes-tui', summary: 'Primary TUI repository.' }];
+  const issues: readonly KnowledgeIssueLike[] = [{ id: 'issue-1', severity: 'warning', code: 'stale-source', message: 'Source has not been recrawled in 30 days.', status: 'open', sourceId: 'source-1' }];
+  const schedules: readonly KnowledgeScheduleLike[] = [{ id: 'sched-1', label: 'Nightly reindex', enabled: true }];
+  return createKnowledgeModalSurface({
+    knowledgeApi: {
+      graph: { nodes: { list: () => nodes }, issues: { list: () => issues } },
+      sources: { list: () => sources },
+      jobs: { schedules: { list: () => schedules } },
+    },
+  });
+}

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

@@ -0,0 +1,132 @@
+import type { ConfigModalAction, ConfigModalActionContext, ConfigModalRow, ConfigModalSurface, ConfigModalView } from '../../input/config-modal-types.ts';
+import type { LocalAuthInspectionQuery } from '../../runtime/ui-service-queries.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';
+
+/** Mutation surface the surface needs to gate p/d/b on — a subset of UserAuthManager,
+ *  mirroring LocalAuthPanel's own `hasLocalAuthMutations` guard. */
+type LocalAuthMutations = Pick<UserAuthManager, 'addUser' | 'deleteUser' | 'rotatePassword' | 'clearBootstrapCredentialFile'>;
+
+function hasLocalAuthMutations(value: LocalAuthInspectionQuery): value is LocalAuthInspectionQuery & LocalAuthMutations {
+  const candidate = value as Partial<LocalAuthMutations>;
+  return typeof candidate.addUser === 'function'
+    && typeof candidate.deleteUser === 'function'
+    && typeof candidate.rotatePassword === 'function'
+    && typeof candidate.clearBootstrapCredentialFile === 'function';
+}
+
+function formatRoles(roles: readonly string[]): string {
+  return roles.length > 0 ? roles.join(', ') : '(none)';
+}
+
+function usernameOf(row: ConfigModalRow | null): string | null {
+  return row?.id.startsWith('user:') ? row.id.slice('user:'.length) : null;
+}
+
+/**
+ * Local-auth config-modal surface (migrated from the `local-auth` panel).
+ * `inspect()` is synchronous, so buildView reads it live every tick. All
+ * mutations (add-user, rotate-password, delete-user, clear-bootstrap-file)
+ * dispatch through the existing `/local-auth` command rather than touching
+ * the auth manager directly — the command opens masked password entry for
+ * add-user/rotate-password when no password argument is supplied, which is
+ * exactly how the retired panel kept plaintext out of history and the
+ * transcript. This surface never renders, accepts, or holds a password.
+ */
+class LocalAuthModalSurface implements ConfigModalSurface {
+  readonly name = 'local-auth-modal';
+  readonly title = 'Local Auth';
+  /** Cached from the last buildView() — read by the 'b' action's enabledFor,
+   *  set fresh every tick (buildView always runs before enabledFor is
+   *  consulted; see settings-sync-modal's `hasStaged` for the same idiom). */
+  private bootstrapPresent = false;
+
+  constructor(private readonly authManager: LocalAuthInspectionQuery) {}
+
+  readonly actions: ConfigModalAction[] = [
+    { key: 'a', id: 'add-user', label: 'add user' },
+    { key: 'p', id: 'rotate-pw', label: 'rotate password', enabledFor: (row) => usernameOf(row) !== null },
+    { key: 'd', id: 'delete', label: 'delete user', confirm: true, enabledFor: (row) => usernameOf(row) !== null },
+    { key: 'b', id: 'clear-bootstrap', label: 'clear bootstrap', enabledFor: () => this.bootstrapPresent },
+  ];
+
+  buildView(): ConfigModalView {
+    let mutationsUnavailable = false;
+    try {
+      mutationsUnavailable = !hasLocalAuthMutations(this.authManager);
+      const snapshot = this.authManager.inspect();
+      this.bootstrapPresent = snapshot.bootstrapCredentialPresent;
+
+      const header = [postureLine([
+        kv('users', snapshot.userCount),
+        kv('sessions', snapshot.sessionCount),
+        kv('bootstrap', snapshot.bootstrapCredentialPresent ? 'present' : 'cleared'),
+      ])];
+
+      const rows: ConfigModalRow[] = snapshot.users.map((user) => ({
+        id: `user:${user.username}`,
+        label: `${user.username}  ${formatRoles(user.roles)}`,
+      }));
+
+      return {
+        title: 'Local Auth',
+        degraded: mutationsUnavailable ? 'Local auth mutations are not available in this session.' : undefined,
+        tabs: [{
+          id: 'users',
+          label: 'Users',
+          header,
+          rows,
+          emptyText: 'No local auth users configured.',
+          hints: ['a add user'],
+        }],
+      };
+    } catch (error) {
+      this.bootstrapPresent = false;
+      return {
+        title: 'Local Auth',
+        degraded: `Local auth inspection failed: ${summarizeError(error)}`,
+        tabs: [{ id: 'users', label: 'Users', rows: [], emptyText: 'Local auth data unavailable.' }],
+      };
+    }
+  }
+
+  onAction(id: string, ctx: ConfigModalActionContext): void {
+    switch (id) {
+      // add-user / rotate-password require the masked password-entry sub-mode,
+      // which renders on the LocalAuthPanel and cannot draw or capture input
+      // underneath this fullscreen modal. Point the operator at the command
+      // (which opens masked entry) rather than dispatching it into a hidden
+      // surface — the secure flow stays a keystroke away, just not from here.
+      case 'add-user':
+        ctx.print('To add a user securely, run  /local-auth add-user <username>  (opens masked password entry).');
+        ctx.setStatus('Run /local-auth add-user <username> for masked entry.');
+        break;
+      case 'rotate-pw': {
+        const username = usernameOf(ctx.row);
+        if (!username) return;
+        ctx.print(`To rotate securely, run  /local-auth rotate-password ${username}  (opens masked password entry).`);
+        ctx.setStatus(`Run /local-auth rotate-password ${username} for masked entry.`);
+        break;
+      }
+      case 'delete': {
+        const username = usernameOf(ctx.row);
+        if (!username) return;
+        void ctx.executeCommand?.('local-auth', ['delete-user', username]);
+        ctx.setStatus(`Deleting ${username}…`);
+        break;
+      }
+      case 'clear-bootstrap':
+        void ctx.executeCommand?.('local-auth', ['clear-bootstrap-file']);
+        ctx.setStatus('Clearing bootstrap credential file…');
+        break;
+      default:
+        return;
+    }
+    ctx.requestRender();
+  }
+}
+
+export function createLocalAuthModalSurface(authManager: LocalAuthInspectionQuery): ConfigModalSurface {
+  return new LocalAuthModalSurface(authManager);
+}

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

@@ -0,0 +1,218 @@
+import type {
+  ConfigModalActionContext,
+  ConfigModalRow,
+  ConfigModalSurface,
+  ConfigModalView,
+} from '../../input/config-modal-types.ts';
+import { MODAL_TONES } from './modal-theme.ts';
+import { infoRow } from './modal-surface-helpers.ts';
+import {
+  loadEcosystemCatalog,
+  listInstalledEcosystemEntries,
+  reviewEcosystemCatalogEntry,
+  type EcosystemCatalogEntry,
+  type EcosystemCatalogPathOptions,
+  type EcosystemEntryKind,
+} from '@/runtime/index.ts';
+import type { UiMarketplaceSnapshot, UiReadModel } from '../../runtime/ui-read-models.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+/** Live deps the marketplace modal captures (mirrors the panel factory). */
+export interface MarketplaceModalDeps {
+  readonly readModel?: UiReadModel<UiMarketplaceSnapshot>;
+  readonly ecosystemPaths?: EcosystemCatalogPathOptions;
+}
+
+type MarketplaceReview = ReturnType<typeof reviewEcosystemCatalogEntry>;
+
+interface MarketplaceRow {
+  readonly kind: EcosystemEntryKind;
+  readonly entry: EcosystemCatalogEntry;
+  readonly installed: boolean;
+  readonly review: MarketplaceReview;
+}
+
+const KINDS: readonly EcosystemEntryKind[] = ['plugin', 'skill', 'hook-pack', 'policy-pack'];
+
+/**
+ * Marketplace → config-modal surface (W6.1 group-B port). Local-first
+ * publish/import catalog (NOT a remote store) with provenance, compatibility,
+ * and install posture. Disk catalog loads happen in refresh() (never in
+ * buildView), mirroring the panel's explicit render()/refresh() split.
+ * Install/uninstall route to the `/marketplace` command path (charter: no
+ * destructive confirm folded into a modal).
+ *
+ * B30 (honest empty-state): the panel's original "No curated marketplace
+ * entries found yet." copy implied a curated remote catalog. It isn't one —
+ * loadEcosystemCatalog only ever reads .goodvibes/ecosystem/<kind>s.json under
+ * the project/home, populated solely by `/marketplace publish` and
+ * `/marketplace bundle import`. The empty-state copy below (locked byte-for-byte
+ * in the golden) names that reality. Selection-blind port: the panel's
+ * selected-entry compatibility/risk/state detail is folded into each row label.
+ */
+class MarketplaceModalSurface implements ConfigModalSurface {
+  readonly name = 'marketplace-modal';
+  readonly title = 'Marketplace';
+  private rows: MarketplaceRow[] = [];
+  private loadError: string | null = null;
+  private requestRender: () => void = () => {};
+  private unsub: (() => void) | null = null;
+
+  constructor(private readonly deps: MarketplaceModalDeps) {}
+
+  readonly actions = [
+    { key: 'i', id: 'install', label: 'install', enabledFor: (row: ConfigModalRow | null) => this.canInstall(row) },
+    { key: 'u', id: 'uninstall', label: 'uninstall', enabledFor: (row: ConfigModalRow | null) => this.canUninstall(row) },
+    { key: 'r', id: 'refresh', label: 'refresh' },
+  ];
+
+  onOpen(requestRender: () => void): void {
+    this.requestRender = requestRender;
+    this.refresh();
+    if (this.deps.readModel && !this.unsub) this.unsub = this.deps.readModel.subscribe(() => this.requestRender());
+  }
+
+  onClose(): void {
+    this.unsub?.();
+    this.unsub = null;
+  }
+
+  private refresh(): void {
+    const paths = this.deps.ecosystemPaths;
+    if (!paths) { this.rows = []; this.loadError = null; return; }
+    try {
+      const built: MarketplaceRow[] = [];
+      for (const kind of KINDS) {
+        const installed = new Set(listInstalledEcosystemEntries(kind, paths).map((receipt) => receipt.entry.id));
+        for (const entry of loadEcosystemCatalog(kind, paths)) {
+          built.push({ kind, entry, installed: installed.has(entry.id), review: reviewEcosystemCatalogEntry(entry, paths) });
+        }
+      }
+      this.rows = built.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
+      this.loadError = null;
+    } catch (e) {
+      this.rows = [];
+      this.loadError = `Catalog load failed: ${summarizeError(e)}`;
+    }
+  }
+
+  private entryFor(row: ConfigModalRow | null): MarketplaceRow | undefined {
+    if (!row) return undefined;
+    return this.rows.find((r) => `${r.kind}:${r.entry.id}` === row.id);
+  }
+
+  private canInstall(row: ConfigModalRow | null): boolean {
+    const entry = this.entryFor(row);
+    return Boolean(entry && !entry.installed);
+  }
+
+  private canUninstall(row: ConfigModalRow | null): boolean {
+    const entry = this.entryFor(row);
+    return Boolean(entry && entry.installed);
+  }
+
+  buildView(): ConfigModalView {
+    const snapshot = this.deps.readModel?.getSnapshot();
+    const rows: ConfigModalRow[] = [];
+
+    // Honest empty / degraded state (B30). loadError → degraded banner.
+    if (this.loadError) {
+      return { title: 'Marketplace', degraded: this.loadError, tabs: [{ id: 'catalog', label: 'Catalog', rows: [] }] };
+    }
+    if (this.rows.length === 0) {
+      if (!this.deps.ecosystemPaths) {
+        rows.push(infoRow('empty:unwired', 'Marketplace catalog roots aren’t wired into this session, so there’s nothing to read yet.'));
+      } else {
+        rows.push(infoRow('empty:0', 'This is your local plugin, skill, hook-pack, and policy-pack catalog — not a remote store.'));
+        rows.push(infoRow('empty:1', 'It’s empty because nothing has been published or imported into this workspace yet. Entries appear here once you publish a local component or import a bundle.'));
+      }
+      rows.push(infoRow('empty:title', 'Populate it', { bold: true }));
+      rows.push(infoRow('empty:publish', '/marketplace publish <kind> <path>  — publish local plugins/skills into the catalog', { dim: true }));
+      rows.push(infoRow('empty:import', '/marketplace bundle import <path>   — import a catalog bundle from disk', { dim: true }));
+      rows.push(infoRow('empty:review', '/marketplace catalog review         — inspect the current local catalog posture', { dim: true }));
+      return {
+        title: 'Marketplace',
+        tabs: [{ id: 'catalog', label: 'Catalog', rows, emptyText: '' }],
+        hints: ['local publish/import catalog'],
+      };
+    }
+
+    // Posture summary header.
+    const installedCount = this.rows.filter((r) => r.installed).length;
+    const count = (k: EcosystemEntryKind): number => this.rows.filter((r) => r.kind === k).length;
+    const header = [
+      `catalog ${this.rows.length}  installed ${installedCount}  plugins ${count('plugin')}  skills ${count('skill')}  hooks ${count('hook-pack')}  policies ${count('policy-pack')}`,
+    ];
+
+    const startupIssues = snapshot?.startupIssues ?? [];
+    for (const [i, issue] of startupIssues.slice(0, 3).entries()) {
+      rows.push(infoRow(`issue:${i}`, `⚠ ${issue}`, { fg: MODAL_TONES.warn }));
+    }
+
+    // Catalog list — selection-blind: fold provenance/compat/risk/state into the label.
+    for (const row of this.rows) {
+      const review = row.review;
+      const provenance = row.entry.provenance ?? 'local';
+      rows.push({
+        id: `${row.kind}:${row.entry.id}`,
+        label: `${row.kind.padEnd(11)} ${row.entry.name.padEnd(22)} ${provenance.padEnd(14)} ${row.installed ? 'INSTALLED' : 'local    '} ${row.entry.version ?? 'n/a'} · compat ${review.compatibility.status} risk ${review.riskLevel}`,
+      });
+    }
+
+    // Recommendations (displayed with their command; digit-jump dropped).
+    const recommendations = snapshot?.recommendations ?? [];
+    if (recommendations.length > 0) {
+      rows.push(infoRow('rec:title', 'Recommended', { bold: true }));
+      for (const [i, rec] of recommendations.slice(0, 3).entries()) {
+        rows.push(infoRow(`rec:${i}`, `${rec.title} — ${rec.command}`, { dim: true }));
+      }
+    }
+
+    return {
+      title: 'Marketplace',
+      tabs: [{
+        id: 'catalog',
+        label: 'Catalog',
+        header,
+        rows,
+        hints: ['local publish/import catalog'],
+      }],
+    };
+  }
+
+  onAction(id: string, ctx: ConfigModalActionContext): void {
+    if (id === 'refresh') { this.refresh(); ctx.setStatus('Refreshing catalog…'); return; }
+    const entry = this.entryFor(ctx.row);
+    if (!entry) return;
+    if (id === 'install' && !entry.installed) {
+      void ctx.executeCommand?.('marketplace', ['install', entry.kind, entry.entry.id]);
+      ctx.setStatus(`Dispatched /marketplace install ${entry.kind} ${entry.entry.id} (see transcript).`);
+    } else if (id === 'uninstall' && entry.installed) {
+      void ctx.executeCommand?.('marketplace', ['uninstall', entry.kind, entry.entry.id]);
+      ctx.setStatus(`Dispatched /marketplace uninstall ${entry.kind} ${entry.entry.id} (see transcript).`);
+    }
+  }
+}
+
+export function createMarketplaceModalSurface(deps: MarketplaceModalDeps): ConfigModalSurface {
+  return new MarketplaceModalSurface(deps);
+}
+
+/**
+ * Deterministic golden fixture: catalog roots wired at a fresh tmp path that is
+ * removed immediately (loadEcosystemCatalog/listInstalledEcosystemEntries guard
+ * missing paths with existsSync → [], so refresh() finds nothing and renders the
+ * B30 honest empty-state copy). The random tmp path never appears in the
+ * rendered lines (the empty-state copy is static), so the golden is byte-stable.
+ */
+export function marketplaceModalGoldenSurface(): ConfigModalSurface {
+  const root = mkdtempSync(join(tmpdir(), 'gv-marketplace-golden-'));
+  const surface = createMarketplaceModalSurface({
+    ecosystemPaths: { cwd: root, homeDir: root, projectCatalogRoot: join(root, 'ecosystem') },
+  });
+  rmSync(root, { recursive: true, force: true });
+  return surface;
+}