@pellux/goodvibes-tui 1.1.0 → 1.9.0

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

@@ -0,0 +1,166 @@
+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') {
+      // DEBT-5 item 4: pass the tool name through as a deep-link target.
+      // Honest caveat (documented, not a bug to silently paper over): fleet's
+      // ProcessKind set has no 'tool' node — a docs Tools row names a static
+      // tool DEFINITION, not a live process, so FleetPanel.receiveDeepLink
+      // will not currently find a match and shows its honest "node no longer
+      // present" line. The plumbing is still worth wiring now (matches the
+      // work-plan agent/wrfc jumps' shape) — it starts resolving for free the
+      // day fleet grows a per-tool-call node (the retired DocsPanel's own
+      // comment already anticipated this: "no filter-by-tool equivalent
+      // there yet").
+      const toolName = ctx.row?.id.startsWith('tool:') ? ctx.row.id.slice('tool:'.length) : null;
+      void ctx.executeCommand?.('panel', toolName ? ['open', 'fleet', '--target', `${toolName}:tool`] : ['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);
+}