@pellux/goodvibes-agent 0.1.0

package/src/panels/knowledge-panel.ts

@@ -0,0 +1,345 @@
+import type { Line } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
+import type { MemoryClass, MemoryRecord, MemoryRegistry, MemoryReviewState } from '@pellux/goodvibes-sdk/platform/state';
+import {
+  buildBodyText,
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+} from './polish.ts';
+
+function summarize(records: MemoryRecord[], cls: MemoryClass): MemoryRecord[] {
+  return records.filter((record) => record.cls === cls).slice(0, 3);
+}
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#94a3b8',
+  headerBg: '#1e293b',
+} as const;
+
+function reviewStateColor(state: MemoryReviewState): string {
+  switch (state) {
+    case 'reviewed':
+      return C.good;
+    case 'stale':
+      return C.warn;
+    case 'contradicted':
+      return C.bad;
+    case 'fresh':
+    default:
+      return C.info;
+  }
+}
+
+function formatConfidence(confidence: number): string {
+  return `${confidence.toString().padStart(3, ' ')}%`;
+}
+
+export class KnowledgePanel extends ScrollableListPanel<MemoryRecord> {
+  private readonly registry: MemoryRegistry;
+  private unsubscribe?: () => void;
+  private records: MemoryRecord[] = [];
+  // I1: confirm for destructive review-state mutations
+  private confirm: ConfirmState<{ id: string; action: 'stale' | 'contradicted' }> | null = null;
+
+  public constructor(registry: MemoryRegistry) {
+    super('knowledge', 'Knowledge', 'K', 'agent');
+    this.registry = registry;
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    this.refresh();
+    this.unsubscribe = this.registry.subscribe(() => {
+      this.refresh();
+      this.markDirty();
+    });
+  }
+
+  public override onDeactivate(): void {
+    super.onDeactivate();
+  }
+
+  public override onDestroy(): void {
+    this.unsubscribe?.();
+    this.unsubscribe = undefined;
+  }
+
+  // ---------------------------------------------------------------------------
+  // ScrollableListPanel implementation
+  // ---------------------------------------------------------------------------
+
+  protected getItems(): readonly MemoryRecord[] {
+    return this.records;
+  }
+
+  protected renderItem(record: MemoryRecord, index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    return buildPanelLine(width, [
+      ['  ', C.label, bg],
+      [record.reviewState.padEnd(13), reviewStateColor(record.reviewState), bg],
+      [` ${formatConfidence(record.confidence)} `, C.value, bg],
+      [record.summary.slice(0, Math.max(0, width - 26)), C.value, bg],
+    ]);
+  }
+
+  protected override getPalette() { return C; }
+  protected override getEmptyStateMessage() { return 'No durable project knowledge'; }
+  protected override getEmptyStateActions() {
+    return [
+      { command: '/recall add fact <summary>', summary: 'capture a durable fact directly' },
+      { command: '/recall capture incident latest', summary: 'promote the latest incident into project memory' },
+      { command: '/recall capture policy', summary: 'store the current policy posture as durable evidence' },
+    ];
+  }
+
+  // ---------------------------------------------------------------------------
+  // Input
+  // ---------------------------------------------------------------------------
+
+  public handleInput(key: string): boolean {
+    // I1: y/n confirm for stale/contradict
+    if (this.confirm) {
+      const result = handleConfirmInput(this.confirm, key);
+      if (result === 'confirmed') {
+        const { id, action } = this.confirm.subject;
+        this.confirm = null;
+        const selected = this.records.find((r) => r.id === id);
+        if (selected) {
+          try {
+            if (action === 'stale') {
+              this.registry.review(id, {
+                state: 'stale',
+                confidence: Math.min(selected.confidence, 40),
+                reviewedBy: 'operator',
+                staleReason: 'marked stale from the knowledge panel',
+              });
+            } else {
+              this.registry.review(id, {
+                state: 'contradicted',
+                confidence: 0,
+                reviewedBy: 'operator',
+                staleReason: 'marked contradicted from the knowledge panel',
+              });
+            }
+          } catch (e) {
+            // I2: surface async failure
+            this.setError(`Review update failed: ${e instanceof Error ? e.message : String(e)}`);
+          }
+        }
+        this.refresh();
+        this.markDirty();
+        return true;
+      }
+      if (result === 'cancelled') {
+        this.confirm = null;
+        this.markDirty();
+        return true;
+      }
+      if (result === 'absorbed') return true;
+    }
+
+    // I2: auto-clear error on next keypress (inherited via super.handleInput)
+    if (this.records.length === 0) return super.handleInput(key);
+
+    const selected = this.records[this.selectedIndex];
+
+    if (key === 'Enter' || key === 'return' || key === 'r') {
+      if (!selected) return false;
+      this.registry.review(selected.id, {
+        state: 'reviewed',
+        confidence: Math.max(selected.confidence, 85),
+        reviewedBy: 'operator',
+      });
+      this.refresh();
+      this.markDirty();
+      return true;
+    }
+    if (key === 's') {
+      if (!selected) return false;
+      // I1: prompt confirm before marking stale
+      this.confirm = { subject: { id: selected.id, action: 'stale' }, label: selected.summary.slice(0, 40) };
+      this.markDirty();
+      return true;
+    }
+    if (key === 'c') {
+      if (!selected) return false;
+      // I1: prompt confirm before marking contradicted
+      this.confirm = { subject: { id: selected.id, action: 'contradicted' }, label: selected.summary.slice(0, 40) };
+      this.markDirty();
+      return true;
+    }
+    if (key === 'f') {
+      if (!selected) return false;
+      this.registry.review(selected.id, {
+        state: 'fresh',
+        confidence: Math.max(selected.confidence, 60),
+        reviewedBy: 'operator',
+      });
+      this.refresh();
+      this.markDirty();
+      return true;
+    }
+
+    // Normalize arrow keys to base class format
+    if (key === 'ArrowUp') return super.handleInput('up');
+    if (key === 'ArrowDown') return super.handleInput('down');
+    return super.handleInput(key);
+  }
+
+  private refresh(): void {
+    const queue = this.registry.reviewQueue(24);
+    this.records = queue.length > 0 ? queue : this.registry.search({ limit: 24 });
+    this.clampSelection();
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.clampSelection();
+
+    // I1: show confirm dialog in place of normal content
+    if (this.confirm) {
+      return buildPanelWorkspace(width, height, {
+        title: 'Knowledge Control Room',
+        intro: '',
+        sections: [{ title: 'Confirmation', lines: renderConfirmLines(width, this.confirm) }],
+        footerLines: [buildPanelLine(width, [['  y confirm  n / Esc cancel', C.dim]])],
+        palette: C,
+      });
+    }
+
+    if (this.records.length === 0) this.refresh();
+
+    const intro = 'Typed project knowledge, reviewed evidence, and operator-governed memory across session, project, and team scopes.';
+    const records = this.registry.search({ limit: 200 });
+
+    if (records.length === 0) {
+      return this.renderList(width, height, {
+        title: 'Knowledge Control Room',
+        footer: [buildPanelLine(width, [[' Review keys: Up/Down move  r/Enter review  s stale  c contradicted  f fresh', C.dim]])],
+      });
+    }
+
+    const queue = this.registry.reviewQueue(24);
+    const byClass = new Map<MemoryClass, number>();
+    const byReview = new Map<MemoryReviewState, number>();
+    const byScope = new Map<string, number>();
+    for (const record of records) {
+      byClass.set(record.cls, (byClass.get(record.cls) ?? 0) + 1);
+      byReview.set(record.reviewState, (byReview.get(record.reviewState) ?? 0) + 1);
+      byScope.set(record.scope, (byScope.get(record.scope) ?? 0) + 1);
+    }
+
+    const classLines: Line[] = [
+      buildPanelLine(width, [
+        [' facts ', C.label], [String(byClass.get('fact') ?? 0), C.good],
+        ['  risks ', C.label], [String(byClass.get('risk') ?? 0), (byClass.get('risk') ?? 0) > 0 ? C.warn : C.good],
+        ['  runbooks ', C.label], [String(byClass.get('runbook') ?? 0), C.info],
+        ['  architecture ', C.label], [String(byClass.get('architecture') ?? 0), C.info],
+        ['  incidents ', C.label], [String(byClass.get('incident') ?? 0), (byClass.get('incident') ?? 0) > 0 ? C.bad : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' decisions ', C.label], [String(byClass.get('decision') ?? 0), C.value],
+        ['  constraints ', C.label], [String(byClass.get('constraint') ?? 0), C.value],
+        ['  ownership ', C.label], [String(byClass.get('ownership') ?? 0), C.value],
+        ['  patterns ', C.label], [String(byClass.get('pattern') ?? 0), C.value],
+        ['  total ', C.label], [String(records.length), C.value],
+      ]),
+    ];
+
+    const reviewLines: Line[] = [
+      buildPanelLine(width, [
+        [' reviewed ', C.label], [String(byReview.get('reviewed') ?? 0), C.good],
+        ['  fresh ', C.label], [String(byReview.get('fresh') ?? 0), C.info],
+        ['  stale ', C.label], [String(byReview.get('stale') ?? 0), C.warn],
+        ['  contradicted ', C.label], [String(byReview.get('contradicted') ?? 0), C.bad],
+        ['  Review Queue ', C.label], [String(queue.length), queue.length > 0 ? C.warn : C.good],
+      ]),
+      buildPanelLine(width, [
+        [' session ', C.label], [String(byScope.get('session') ?? 0), C.info],
+        ['  project ', C.label], [String(byScope.get('project') ?? 0), C.value],
+        ['  team ', C.label], [String(byScope.get('team') ?? 0), C.good],
+      ]),
+      buildGuidanceLine(width, '/recall review', 'work the stale and contradicted queue from the command surface', C),
+    ];
+
+    const recentSummaryLines: Line[] = [];
+    for (const [title, items, color] of [
+      ['Recent Risks', summarize(records, 'risk'), C.warn],
+      ['Runbooks', summarize(records, 'runbook'), C.info],
+      ['Architecture Notes', summarize(records, 'architecture'), C.info],
+      ['Recent Incidents', summarize(records, 'incident'), C.bad],
+    ] as const) {
+      if (recentSummaryLines.length > 0) {
+        recentSummaryLines.push(buildPanelLine(width, [['', C.dim]]));
+      }
+      recentSummaryLines.push(buildPanelLine(width, [[` ${title}`, C.label]]));
+      if (items.length === 0) {
+        recentSummaryLines.push(buildPanelLine(width, [['  none recorded', C.dim]]));
+        continue;
+      }
+      for (const item of items) {
+        recentSummaryLines.push(buildPanelLine(width, [
+          ['  ', C.label],
+          [item.summary.slice(0, Math.max(0, width - 2)), color],
+        ]));
+      }
+    }
+
+    const selectedRecord = this.records[this.selectedIndex];
+    const selectedLines: Line[] = [];
+    if (selectedRecord) {
+      selectedLines.push(buildPanelLine(width, [['  Selected', C.label]]));
+      selectedLines.push(buildKeyValueLine(width, [
+        { label: 'Class', value: selectedRecord.cls, valueColor: C.value },
+        { label: 'Scope', value: selectedRecord.scope, valueColor: C.info },
+        { label: 'Review', value: selectedRecord.reviewState, valueColor: reviewStateColor(selectedRecord.reviewState) },
+        { label: 'Confidence', value: formatConfidence(selectedRecord.confidence), valueColor: C.value },
+      ], C));
+      selectedLines.push(...buildBodyText(width, `Summary: ${selectedRecord.summary}`, C, C.value));
+      if (selectedRecord.detail) selectedLines.push(...buildBodyText(width, `Detail: ${selectedRecord.detail}`, C, C.dim));
+      if (selectedRecord.provenance.length) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Provenance: ${selectedRecord.provenance.map((p) => `${p.kind}:${p.ref}`).join(', ')}`,
+          C,
+          C.dim,
+        ));
+      }
+      if (selectedRecord.staleReason) {
+        selectedLines.push(...buildBodyText(
+          width,
+          `Stale reason: ${selectedRecord.staleReason}`,
+          C,
+          selectedRecord.reviewState === 'contradicted' ? C.bad : C.warn,
+        ));
+      }
+      if (selectedRecord.reviewedAt) {
+        selectedLines.push(buildPanelLine(width, [
+          ['  Reviewed: ', C.label],
+          [new Date(selectedRecord.reviewedAt).toLocaleString(), C.dim],
+        ]));
+        if (selectedRecord.reviewedBy) {
+          selectedLines.push(buildPanelLine(width, [
+            ['  Reviewer: ', C.label],
+            [selectedRecord.reviewedBy, C.dim],
+          ]));
+        }
+      }
+    }
+
+    return this.renderList(width, height, {
+      title: 'Knowledge Control Room',
+      header: [...classLines, ...reviewLines],
+      footer: [
+        ...(selectedLines.length > 0 ? selectedLines : []),
+        ...recentSummaryLines,
+        buildPanelLine(width, [['  Up/Down move  r/Enter reviewed  s stale  c contradicted  f fresh', C.dim]]),
+      ],
+    });
+  }
+}

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

@@ -0,0 +1,130 @@
+import type { Line } from '../types/grid.ts';
+import { createEmptyLine } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildDetailBlock,
+  buildGuidanceLine,
+  buildPanelListRow,
+  buildPanelLine,
+  buildSummaryBlock,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  type PanelPalette,
+} from './polish.ts';
+import type { LocalAuthSnapshot } from '@pellux/goodvibes-sdk/platform/security';
+import type { LocalAuthInspectionQuery } from '../runtime/ui-service-queries.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  info: '#38bdf8',
+  warn: '#eab308',
+  error: '#ef4444',
+  selectBg: '#1e293b',
+} as const;
+
+function formatRoles(roles: readonly string[]): string {
+  return roles.length > 0 ? roles.join(', ') : '(none)';
+}
+
+type LocalAuthUser = LocalAuthSnapshot['users'][number];
+
+export class LocalAuthPanel extends ScrollableListPanel<LocalAuthUser> {
+  private readonly authManager: LocalAuthInspectionQuery;
+
+  public constructor(authManager: LocalAuthInspectionQuery) {
+    super('local-auth', 'Local Auth', 'U', 'monitoring');
+    this.showSelectionGutter = true; // I5: non-color selection affordance
+    this.authManager = authManager;
+  }
+
+  protected override getPalette(): PanelPalette {
+    return C;
+  }
+
+  protected getItems(): readonly LocalAuthUser[] {
+    return this.authManager.inspect().users;
+  }
+
+  protected renderItem(user: LocalAuthUser, _index: number, selected: boolean, width: number): Line {
+    return buildPanelListRow(width, [
+      { text: user.username.padEnd(20), fg: C.value },
+      { text: ` roles=${formatRoles(user.roles)}`.slice(0, Math.max(0, width - 24)), fg: C.info },
+    ], C, { selected });
+  }
+
+  protected override getEmptyStateMessage(): string {
+    return ' No local auth users configured.';
+  }
+
+  public render(width: number, height: number): Line[] {
+    const intro = 'Manage local daemon and HTTP-listener auth users, bootstrap state, and active sessions.';
+    const snapshot = this.authManager.inspect();
+    const users = this.getItems();
+
+    const issueMessages: string[] = [];
+    if (snapshot.bootstrapCredentialPresent) issueMessages.push('Bootstrap credential file still exists and should be cleared after password rotation.');
+    if (snapshot.userCount <= 1) issueMessages.push('Only one local auth user is configured.');
+    if (snapshot.sessionCount === 0) issueMessages.push('No active local auth sessions are currently tracked.');
+
+    const headerLines: Line[] = [
+      ...buildSummaryBlock(width, 'Local auth posture', [
+        buildPanelLine(width, [
+          [' users ', C.label],
+          [String(snapshot.userCount), C.value],
+          ['  sessions ', C.label],
+          [String(snapshot.sessionCount), snapshot.sessionCount > 0 ? C.info : C.dim],
+          ['  bootstrap ', C.label],
+          [snapshot.bootstrapCredentialPresent ? 'present' : 'cleared', snapshot.bootstrapCredentialPresent ? C.warn : C.good],
+        ]),
+        buildPanelLine(width, [[' user store ', C.label], [snapshot.userStorePath.slice(0, Math.max(0, width - 13)), C.dim]]),
+        buildPanelLine(width, [[' bootstrap file ', C.label], [snapshot.bootstrapCredentialPath.slice(0, Math.max(0, width - 18)), C.dim]]),
+        ...(issueMessages.length > 0
+          ? issueMessages.map((issue) => buildPanelLine(width, [[` issue: ${issue}`.slice(0, Math.max(0, width)), C.warn]]))
+          : [buildPanelLine(width, [[' local auth posture looks healthy.', C.good]])]),
+        buildGuidanceLine(width, '/auth local rotate-password <user> <password>', 'rotate bootstrap/default credentials and revoke older sessions as needed', C),
+      ], C),
+    ];
+
+    if (users.length === 0) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Local Auth Control Room',
+        intro,
+        sections: [{ lines: headerLines }],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    this.clampSelection();
+    const selected = users[this.selectedIndex];
+
+    const footerLines: Line[] = [];
+    if (selected) {
+      footerLines.push(
+        ...buildDetailBlock(width, 'Selected user', [
+          buildPanelLine(width, [[' username ', C.label], [selected.username, C.value], ['  roles ', C.label], [formatRoles(selected.roles).slice(0, Math.max(0, width - 23)), C.info]]),
+          buildPanelLine(width, [[` next: /auth local rotate-password ${selected.username} <password>`.slice(0, Math.max(0, width)), C.dim]]),
+          buildPanelLine(width, [[` next: /auth local delete-user ${selected.username}`.slice(0, Math.max(0, width)), C.dim]]),
+        ], C),
+      );
+    }
+
+    if (snapshot.sessions.length > 0) {
+      footerLines.push(
+        ...snapshot.sessions.slice(0, 8).map((session) => buildPanelLine(width, [
+          [' ', C.label],
+          [session.username.padEnd(18), C.value],
+          [` expires ${new Date(session.expiresAt).toLocaleString()}`.slice(0, Math.max(0, width - 20)), C.dim],
+        ])),
+      );
+    }
+    footerLines.push(buildPanelLine(width, [[' /auth local review  /auth local add-user  /auth local rotate-password  /auth local revoke-session ', C.dim]]));
+
+    return this.renderList(width, height, {
+      title: 'Local Auth Control Room',
+      header: headerLines,
+      footer: footerLines,
+    });
+  }
+}

package/src/panels/marketplace-panel.ts

@@ -0,0 +1,212 @@
+import type { Line } from '../types/grid.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import {
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+import {
+  type EcosystemCatalogPathOptions,
+  listInstalledEcosystemEntries,
+  loadEcosystemCatalog,
+  reviewEcosystemCatalogEntry,
+  type EcosystemCatalogEntry,
+  type EcosystemEntryKind,
+} from '@/runtime/index.ts';
+import type { UiMarketplaceSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#e2e8f0',
+  headerBg: '#1f2937',
+} as const;
+
+type MarketplaceRow = {
+  kind: EcosystemEntryKind;
+  entry: EcosystemCatalogEntry;
+  installed: boolean;
+};
+
+function statusColor(installed: boolean): string {
+  return installed ? C.good : C.dim;
+}
+
+export class MarketplacePanel extends ScrollableListPanel<MarketplaceRow> {
+  private rows: MarketplaceRow[] = [];
+  private readonly unsub: (() => void) | null;
+
+  public constructor(
+    private readonly readModel?: UiReadModel<UiMarketplaceSnapshot>,
+    private readonly ecosystemPaths?: EcosystemCatalogPathOptions,
+  ) {
+    super('marketplace', 'Marketplace', 'M', 'monitoring');
+    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  public override onActivate(): void {
+    super.onActivate();
+    this.refresh();
+  }
+
+  // ---------------------------------------------------------------------------
+  // ScrollableListPanel implementation
+  // ---------------------------------------------------------------------------
+
+  protected getItems(): readonly MarketplaceRow[] {
+    return this.rows;
+  }
+
+  protected renderItem(row: MarketplaceRow, index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    const provenance = row.entry.provenance ?? 'local';
+    return buildPanelLine(width, [
+      ['  ', C.label, bg],
+      [row.kind.padEnd(11), C.info, bg],
+      [row.entry.name.slice(0, 20).padEnd(20), C.value, bg],
+      [` ${provenance.slice(0, 16).padEnd(16)}`, provenance === 'local' ? C.dim : C.info, bg],
+      [` ${(row.installed ? 'INSTALLED' : 'CURATED').padEnd(9)} `, statusColor(row.installed), bg],
+      [` ${row.entry.version ?? 'n/a'}`, C.dim, bg],
+    ]);
+  }
+
+  protected override getPalette() { return C; }
+  protected override getEmptyStateMessage() {
+    return this.ecosystemPaths
+      ? ' No curated marketplace entries found yet.'
+      : ' Marketplace catalog paths are not wired into this panel yet.';
+  }
+  protected override getEmptyStateActions() {
+    return [
+      { command: '/marketplace bundle import <path>', summary: 'import a curated marketplace bundle' },
+      { command: '/marketplace catalog review', summary: 'inspect the current local catalog posture' },
+      { command: '/marketplace publish <kind> <path>', summary: 'publish local ecosystem entries back into the curated catalog' },
+    ];
+  }
+
+  private refresh(): void {
+    if (!this.ecosystemPaths) {
+      this.rows = [];
+      this.clampSelection();
+      return;
+    }
+    try {
+      const installedPlugins = new Set(listInstalledEcosystemEntries('plugin', this.ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedSkills = new Set(listInstalledEcosystemEntries('skill', this.ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedHookPacks = new Set(listInstalledEcosystemEntries('hook-pack', this.ecosystemPaths).map((receipt) => receipt.entry.id));
+      const installedPolicyPacks = new Set(listInstalledEcosystemEntries('policy-pack', this.ecosystemPaths).map((receipt) => receipt.entry.id));
+      const rows: MarketplaceRow[] = [
+        ...loadEcosystemCatalog('plugin', this.ecosystemPaths).map((entry) => ({ kind: 'plugin' as const, entry, installed: installedPlugins.has(entry.id) })),
+        ...loadEcosystemCatalog('skill', this.ecosystemPaths).map((entry) => ({ kind: 'skill' as const, entry, installed: installedSkills.has(entry.id) })),
+        ...loadEcosystemCatalog('hook-pack', this.ecosystemPaths).map((entry) => ({ kind: 'hook-pack' as const, entry, installed: installedHookPacks.has(entry.id) })),
+        ...loadEcosystemCatalog('policy-pack', this.ecosystemPaths).map((entry) => ({ kind: 'policy-pack' as const, entry, installed: installedPolicyPacks.has(entry.id) })),
+      ];
+      this.rows = rows.sort((a, b) => a.entry.name.localeCompare(b.entry.name));
+      this.clampSelection();
+      // I2: clear any previous catalog load error on successful refresh
+      this.clearError();
+    } catch (e) {
+      // I2: surface catalog load failure
+      this.setError(`Catalog load failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.clampSelection();
+    this.refresh();
+
+    const intro = 'Curated local-first ecosystem with provenance, compatibility, rollback history, and receipt-aware lifecycle review.';
+    const installedCount = this.rows.filter((row) => row.installed).length;
+    const snapshot = this.readModel?.getSnapshot();
+    const recommendations = snapshot?.recommendations ?? [];
+    const startupIssues = snapshot?.startupIssues ?? [];
+
+    if (this.rows.length === 0) {
+      return buildPanelWorkspace(width, height, {
+        title: 'Marketplace Control Room',
+        intro,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            this.ecosystemPaths ? ' No curated marketplace entries found yet.' : ' Marketplace catalog paths are not wired into this panel yet.',
+            this.ecosystemPaths
+              ? 'The marketplace is ready, but no plugin, skill, hook-pack, or policy-pack catalogs are available in this workspace.'
+              : 'The shell needs explicit marketplace catalog roots before this panel can inspect curated plugin, skill, hook-pack, or policy-pack entries.',
+            [
+              { command: '/marketplace bundle import <path>', summary: 'import a curated marketplace bundle' },
+              { command: '/marketplace catalog review', summary: 'inspect the current local catalog posture' },
+              { command: '/marketplace publish <kind> <path>', summary: 'publish local ecosystem entries back into the curated catalog' },
+            ],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+    }
+
+    const postureLines = [
+      buildKeyValueLine(width, [
+        { label: 'curated', value: String(this.rows.length), valueColor: C.value },
+        { label: 'installed', value: String(installedCount), valueColor: installedCount > 0 ? C.good : C.dim },
+        { label: 'plugins', value: String(this.rows.filter((row) => row.kind === 'plugin').length), valueColor: C.info },
+        { label: 'skills', value: String(this.rows.filter((row) => row.kind === 'skill').length), valueColor: C.info },
+        { label: 'hooks', value: String(this.rows.filter((row) => row.kind === 'hook-pack').length), valueColor: C.info },
+        { label: 'policies', value: String(this.rows.filter((row) => row.kind === 'policy-pack').length), valueColor: C.info },
+      ], C),
+      buildGuidanceLine(width, '/marketplace open', 'browse curated entries and inspect compatibility, provenance, and receipts', C),
+    ];
+
+    const recommendationLines = recommendations.length > 0
+      ? recommendations.slice(0, 4).map((recommendation) => buildPanelLine(width, [
+          ['  ', C.label],
+          [`${recommendation.kind} ${recommendation.entry.id}`.slice(0, 28).padEnd(28), C.info],
+          [` ${recommendation.title}`.slice(0, Math.max(0, width - 31)), C.dim],
+        ]))
+      : [buildPanelLine(width, [['  No contextual marketplace recommendations right now.', C.dim]])];
+
+    const startupIssueLines = startupIssues.length > 0
+      ? startupIssues.slice(0, 4).map((issue) => buildPanelLine(width, [['  ', C.label], [issue.slice(0, Math.max(0, width - 2)), C.warn]]))
+      : [buildPanelLine(width, [['  No startup or lifecycle issues are currently pushing marketplace repair recommendations.', C.dim]])];
+
+    const selectedRow = this.rows[this.selectedIndex];
+    const selectedLines: Line[] = [];
+    if (selectedRow) {
+      const review = reviewEcosystemCatalogEntry(selectedRow.entry, this.ecosystemPaths!);
+      selectedLines.push(buildPanelLine(width, [
+        ['  Provenance: ', C.label],
+        [(selectedRow.entry.provenance ?? '(none)').slice(0, Math.max(0, width - 15)), selectedRow.entry.provenance ? C.info : C.dim],
+      ]));
+      selectedLines.push(buildPanelLine(width, [
+        ['  Source: ', C.label],
+        [selectedRow.entry.source.slice(0, Math.max(0, width - 11)), C.value],
+      ]));
+      selectedLines.push(buildKeyValueLine(width, [
+        { label: 'Compatibility', value: review.compatibility.status, valueColor: review.compatibility.status === 'supported' ? C.good : C.warn },
+        { label: 'Risk', value: review.riskLevel, valueColor: review.riskLevel === 'low' ? C.good : C.warn },
+        { label: 'State', value: selectedRow.installed ? 'installed' : 'curated', valueColor: statusColor(selectedRow.installed) },
+      ], C));
+      selectedLines.push(buildGuidanceLine(width, '/marketplace review <id>', 'inspect full compatibility and receipt detail for the selected entry', C));
+    }
+
+    const postureSection: PanelWorkspaceSection = { title: 'Marketplace posture', lines: postureLines };
+    const startupIssuesSection: PanelWorkspaceSection = { title: 'Startup Issues', lines: startupIssueLines };
+    const recommendationsSection: PanelWorkspaceSection = { title: 'Recommendations', lines: recommendationLines };
+
+    return this.renderList(width, height, {
+      title: 'Marketplace Control Room',
+      header: [
+        ...postureLines,
+        ...startupIssueLines,
+        ...recommendationLines,
+      ],
+      footer: selectedLines.length > 0 && height >= 20 ? selectedLines : [],
+    });
+  }
+}