@pellux/goodvibes-agent 0.1.0

package/src/panels/builtin/agent.ts

@@ -0,0 +1,117 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { AgentLogsPanel } from '../agent-logs-panel.ts';
+import { ContextVisualizerPanel } from '../context-visualizer-panel.ts';
+import { ThinkingPanel } from '../thinking-panel.ts';
+import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
+import { WrfcPanel } from '../wrfc-panel.ts';
+import { SchedulePanel } from '../schedule-panel.ts';
+import { ProjectPlanningPanel } from '../project-planning-panel.ts';
+import { WorkPlanPanel } from '../work-plan-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireAutomationManager, requireUiServices } from './shared.ts';
+
+export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  manager.registerType({
+    id: 'thinking',
+    name: 'Thinking',
+    icon: 'T',
+    category: 'ai',
+    description: 'Stream model reasoning tokens in real-time with collapsible blocks per turn',
+    preload: true,
+    factory: () => new ThinkingPanel(requireUiServices(deps).events.turns),
+  });
+
+  manager.registerType({
+    id: 'tools',
+    name: 'Tools',
+    icon: 'X',
+    category: 'ai',
+    description: 'Chronological tool call inspector with expandable args/results and filtering',
+    preload: true,
+    factory: () => {
+      const ui = requireUiServices(deps);
+      return new ToolInspectorPanel(ui.events.tools, ui.events.turns);
+    },
+  });
+
+  manager.registerType({
+    id: 'context',
+    name: 'Context',
+    icon: 'C',
+    category: 'ai',
+    description: 'Context window visualizer: stacked bar showing token usage per section',
+    preload: true,
+    factory: () => new ContextVisualizerPanel(
+      requireUiServices(deps).events.turns,
+      deps.sessionMemoryStore,
+      deps.configManager,
+      deps.getOrchestratorUsage,
+      deps.contextWindow,
+      requireUiServices(deps).readModels.session,
+    ),
+  });
+
+  manager.registerType({
+    id: 'agent-logs',
+    name: 'Agents',
+    icon: 'A',
+    category: 'agent',
+    description: 'View-only stream for explicit delegated build/review session records',
+    preload: true,
+    factory: () => {
+      const ui = requireUiServices(deps);
+      return new AgentLogsPanel(ui.events.agents, {
+        agentManager: ui.agents.agentManager,
+        workingDirectory: ui.environment.workingDirectory,
+      });
+    },
+  });
+
+  manager.registerType({
+    id: 'wrfc',
+    name: 'WRFC',
+    icon: 'W',
+    category: 'agent',
+    description: 'WRFC chain view: write, review, fix, and confirm cycle status',
+    preload: true,
+    factory: () => {
+      const ui = requireUiServices(deps);
+      return new WrfcPanel(ui.events.workflows, { controller: ui.agents.wrfcController });
+    },
+  });
+
+  manager.registerType({
+    id: 'work-plan',
+    name: 'Work Plan',
+    icon: 'L',
+    category: 'agent',
+    description: 'Persistent workspace checklist for multi-step work and cross-session task tracking',
+    preload: true,
+    factory: () => new WorkPlanPanel(deps.workPlanStore),
+  });
+
+  manager.registerType({
+    id: 'project-planning',
+    name: 'Planning',
+    icon: 'P',
+    category: 'agent',
+    description: 'Passive project planning artifacts: readiness, questions, decisions, language, task graph, and agent handoff metadata',
+    preload: true,
+    factory: () => new ProjectPlanningPanel({
+      service: deps.projectPlanningService,
+      projectId: deps.projectPlanningProjectId,
+      requestRender: deps.requestRender,
+      submitAnswer: deps.submitPlanningAnswer,
+      dismissPlanning: deps.dismissPlanning,
+    }),
+  });
+
+  manager.registerType({
+    id: 'schedule',
+    name: 'Schedule',
+    icon: 'Z',
+    category: 'agent',
+    description: 'Read-only schedule posture from the external daemon; local Agent schedule mutation is blocked',
+    factory: () => new SchedulePanel(requireAutomationManager(deps)),
+  });
+}

package/src/panels/builtin/development.ts

@@ -0,0 +1,31 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { PlanDashboardPanel } from '../plan-dashboard-panel.ts';
+import { CostTrackerPanel } from '../cost-tracker-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireUiServices } from './shared.ts';
+
+export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  manager.registerType({
+    id: 'plan',
+    name: 'Plan',
+    icon: 'P',
+    category: 'agent',
+    description: 'Active execution plan with phase progress and item status',
+    factory: () => new PlanDashboardPanel(deps.planManager),
+  });
+
+  if (deps.getOrchestratorUsage) {
+    const { getOrchestratorUsage, budgetThreshold } = deps;
+    manager.registerType({
+      id: 'cost',
+      name: 'Cost',
+      icon: '$',
+      category: 'monitoring',
+      description: 'Estimated costs per session, agent, and plan with budget alerts',
+      factory: () => {
+        const ui = requireUiServices(deps);
+        return new CostTrackerPanel(ui.events.turns, ui.events.agents, getOrchestratorUsage, { budgetThreshold });
+      },
+    });
+  }
+}

package/src/panels/builtin/knowledge.ts

@@ -0,0 +1,26 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { MemoryPanel } from '../memory-panel.ts';
+import { KnowledgePanel } from '../knowledge-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+
+export function registerKnowledgePanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  if (!deps.memoryRegistry) return;
+
+  const { memoryRegistry } = deps;
+  manager.registerType({
+    id: 'knowledge',
+    name: 'Knowledge',
+    icon: 'K',
+    category: 'agent',
+    description: 'Structured project knowledge: risks, runbooks, architecture notes, incidents, and durable facts',
+    factory: () => new KnowledgePanel(memoryRegistry),
+  });
+  manager.registerType({
+    id: 'memory',
+    name: 'Memory',
+    icon: 'M',
+    category: 'agent',
+    description: 'Project memory: decisions, constraints, incidents, and patterns with provenance links',
+    factory: () => new MemoryPanel(memoryRegistry),
+  });
+}

package/src/panels/builtin/operations.ts

@@ -0,0 +1,349 @@
+import type { PanelManager } from '../panel-manager.ts';
+import { CockpitPanel } from '../cockpit-panel.ts';
+import { ApprovalPanel } from '../approval-panel.ts';
+import { PluginsPanel } from '../plugins-panel.ts';
+import { SkillsPanel } from '../skills-panel.ts';
+import { ServicesPanel } from '../services-panel.ts';
+import { AutomationControlPanel } from '../automation-control-panel.ts';
+import { RoutesPanel } from '../routes-panel.ts';
+import { WatchersPanel } from '../watchers-panel.ts';
+import { ControlPlanePanel } from '../control-plane-panel.ts';
+import { SubscriptionPanel } from '../subscription-panel.ts';
+import { LocalAuthPanel } from '../local-auth-panel.ts';
+import { ProviderAccountsPanel } from '../provider-accounts-panel.ts';
+import { SettingsSyncPanel } from '../settings-sync-panel.ts';
+import { HooksPanel } from '../hooks-panel.ts';
+import { SecurityPanel } from '../security-panel.ts';
+import { MarketplacePanel } from '../marketplace-panel.ts';
+import { TasksPanel } from '../tasks-panel.ts';
+import { OrchestrationPanel } from '../orchestration-panel.ts';
+import { OpsStrategyPanel } from '../ops-strategy-panel.ts';
+import { CommunicationPanel } from '../communication-panel.ts';
+import { RemotePanel } from '../remote-panel.ts';
+import { ProviderStatsPanel } from '../provider-stats-panel.ts';
+import { ProviderHealthPanel } from '../provider-health-panel.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../../config/surface.ts';
+import { DebugPanel } from '../debug-panel.ts';
+import { IncidentReviewPanel } from '../incident-review-panel.ts';
+import { ForensicsPanel } from '../forensics-panel.ts';
+import { PolicyPanel } from '../policy-panel.ts';
+import { EvalPanel } from '../eval-panel.ts';
+import { createProviderAccountSnapshotQuery } from '../provider-account-snapshot.ts';
+import {
+  createEnvironmentVariableQuery,
+  createProviderRuntimeInspectionQuery,
+} from '../../runtime/ui-service-queries.ts';
+import { createRuntimeProviderApi } from '@/runtime/index.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireAutomationManager, requireControlPlanePanelDeps, requireHookPanelDeps, requirePluginManager, requireUiServices } from './shared.ts';
+
+export function registerOperationsPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  const ui = requireUiServices(deps);
+  const providerRuntime = createProviderRuntimeInspectionQuery(createRuntimeProviderApi({
+    benchmarkStore: ui.providers.benchmarkStore,
+    favoritesStore: ui.providers.favoritesStore,
+    providerRegistry: ui.providers.providerRegistry,
+  }));
+  const providerAccounts = createProviderAccountSnapshotQuery({
+    providerModels: deps.providerRegistry,
+    services: deps.serviceRegistry,
+    subscriptions: deps.subscriptionManager,
+    environment: createEnvironmentVariableQuery(process.env),
+  });
+
+  manager.registerType({
+    id: 'cockpit',
+    name: 'Cockpit',
+    icon: 'O',
+    category: 'monitoring',
+    description: 'Unified operator summary for orchestration, permissions, communication, MCP, plugins, and integrations',
+    factory: () => new CockpitPanel(ui.readModels.cockpit),
+  });
+
+  manager.registerType({
+    id: 'approval',
+    name: 'Approval',
+    icon: 'A',
+    category: 'monitoring',
+    description: 'Action-specific approval workspace for why-prompted, why-denied, and what-if review',
+    factory: () => new ApprovalPanel(deps.policyRuntimeState),
+  });
+
+  manager.registerType({
+    id: 'plugins',
+    name: 'Plugins',
+    icon: 'P',
+    category: 'monitoring',
+    description: 'Plugin trust, quarantine, capability, and activation status',
+    factory: () => new PluginsPanel(requirePluginManager(deps)),
+  });
+
+  manager.registerType({
+    id: 'skills',
+    name: 'Skills',
+    icon: 'K',
+    category: 'monitoring',
+    description: 'Project-local and global skill discovery with origin and dependency details',
+    factory: () => new SkillsPanel({
+      componentHealthMonitor: deps.componentHealthMonitor,
+      shellPaths: ui.environment.shellPaths,
+    }),
+  });
+
+  manager.registerType({
+    id: 'services',
+    name: 'Services',
+    icon: 'V',
+    category: 'monitoring',
+    description: 'Configured external services, credential presence, and connection health tests',
+    factory: () => new ServicesPanel(deps.serviceRegistry, deps.subscriptionManager),
+  });
+
+  manager.registerType({
+    id: 'automation',
+    name: 'Automation',
+    icon: 'M',
+    category: 'monitoring',
+    description: 'Automation jobs, runs, deliveries, and failure posture across the control plane',
+    factory: () => new AutomationControlPanel(ui.readModels.automation),
+  });
+
+  manager.registerType({
+    id: 'routes',
+    name: 'Routes',
+    icon: 'R',
+    category: 'monitoring',
+    description: 'Cross-surface route bindings and shared session attachment state',
+    factory: () => new RoutesPanel(ui.readModels.routes),
+  });
+
+  manager.registerType({
+    id: 'watchers',
+    name: 'Watchers',
+    icon: 'W',
+    category: 'monitoring',
+    description: 'Watcher health, lag, and degraded source state for automation inputs',
+    factory: () => new WatchersPanel(ui.readModels.watchers),
+  });
+
+  manager.registerType({
+    id: 'control-plane',
+    name: 'Control Plane',
+    icon: 'C',
+    category: 'monitoring',
+    description: 'Daemon control-plane state, clients, approvals, and recent operator activity',
+    factory: () => {
+      requireControlPlanePanelDeps(deps);
+      return new ControlPlanePanel(ui.readModels.controlPlane);
+    },
+  });
+
+  manager.registerType({
+    id: 'subscription',
+    name: 'Subscriptions',
+    icon: 'B',
+    category: 'monitoring',
+    description: 'OAuth-backed provider subscriptions and supported provider override posture',
+    factory: () => new SubscriptionPanel(deps.serviceRegistry, deps.subscriptionManager),
+  });
+
+  manager.registerType({
+    id: 'local-auth',
+    name: 'Local Auth',
+    icon: 'U',
+    category: 'monitoring',
+    description: 'Local daemon/listener auth users, bootstrap posture, and active sessions',
+    factory: () => new LocalAuthPanel(deps.localUserAuthManager),
+  });
+
+  manager.registerType({
+    id: 'accounts',
+    name: 'Accounts',
+    icon: 'Q',
+    category: 'monitoring',
+    description: 'Provider auth routes, subscription quota-window hints, and billing-path safety notes',
+    factory: () => new ProviderAccountsPanel({ providerAccounts }),
+  });
+
+  manager.registerType({
+    id: 'settings-sync',
+    name: 'Settings Sync',
+    icon: 'Y',
+    category: 'monitoring',
+    description: 'Local, synced, and managed settings posture with recent sync events and active locks',
+    factory: () => new SettingsSyncPanel(deps.configManager),
+  });
+
+  manager.registerType({
+    id: 'hooks',
+    name: 'Hooks',
+    icon: 'H',
+    category: 'monitoring',
+    description: 'Registered hooks, chains, contracts, and execution policy details',
+    factory: () => {
+      const hookDeps = requireHookPanelDeps(deps);
+      return new HooksPanel(hookDeps.hookDispatcher, hookDeps.hookWorkbench, hookDeps.hookActivityTracker);
+    },
+  });
+
+  manager.registerType({
+    id: 'security',
+    name: 'Security',
+    icon: 'U',
+    category: 'monitoring',
+    description: 'Security review workspace for token audit, policy posture, MCP quarantine, and incident pressure',
+    factory: () => new SecurityPanel(ui.readModels.security),
+  });
+
+  manager.registerType({
+    id: 'marketplace',
+    name: 'Marketplace',
+    icon: 'M',
+    category: 'monitoring',
+    description: 'Curated plugin and skill marketplace with provenance, compatibility, and install posture',
+    factory: () => {
+      return new MarketplacePanel(ui.readModels.marketplace, {
+        cwd: ui.environment.shellPaths.workingDirectory,
+        homeDir: ui.environment.shellPaths.homeDirectory,
+        projectCatalogRoot: ui.environment.shellPaths.resolveProjectPath(GOODVIBES_AGENT_SURFACE_ROOT, 'ecosystem'),
+        userCatalogRoot: ui.environment.shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'ecosystem'),
+      });
+    },
+  });
+
+  manager.registerType({
+    id: 'tasks',
+    name: 'Tasks',
+    icon: 'J',
+    category: 'monitoring',
+    description: 'Queued, running, blocked, failed, and completed task summaries from the runtime store',
+    factory: () => new TasksPanel(ui.readModels.tasks, ui.readModels.worktrees),
+  });
+
+  manager.registerType({
+    id: 'orchestration',
+    name: 'Orchestration',
+    icon: 'Q',
+    category: 'monitoring',
+    description: 'Task-graph status, node roles, and bounded recursion guard activity',
+    factory: () => new OrchestrationPanel(ui.readModels.orchestration),
+  });
+
+  manager.registerType({
+    id: 'ops',
+    name: 'Ops',
+    icon: 'O',
+    category: 'monitoring',
+    description: 'Adaptive planner strategy timeline, override posture, and recent execution-mode decisions',
+    factory: () => new OpsStrategyPanel(ui.events.planner, deps.adaptivePlanner),
+  });
+
+  manager.registerType({
+    id: 'communication',
+    name: 'Communication',
+    icon: 'Y',
+    category: 'monitoring',
+    description: 'Structured agent communication, blocked routes, and delivery status',
+    preload: true,
+    factory: () => new CommunicationPanel(ui.readModels.communication),
+  });
+
+  manager.registerType({
+    id: 'remote',
+    name: 'Remote',
+    icon: 'R',
+    category: 'monitoring',
+    description: 'Self-hosted daemon and ACP transport state with active remote connections',
+    factory: () => new RemotePanel(ui.readModels.remote),
+  });
+
+  manager.registerType({
+    id: 'providers',
+    name: 'Providers',
+    icon: 'R',
+    category: 'monitoring',
+    description: 'Per-provider performance metrics: latency, error rate, request count, sparkline trends',
+    factory: () => new ProviderStatsPanel(ui.events.turns, ui.events.providers, deps.requestRender, ui.readModels.providers),
+  });
+
+  manager.registerType({
+    id: 'provider-health',
+    name: 'Health',
+    icon: 'N',
+    category: 'monitoring',
+    description: 'Provider health dashboard: real-time status, latency, errors, and rate-limit cooldowns',
+    preload: true,
+    factory: () => new ProviderHealthPanel(
+      providerRuntime,
+      {
+        configManager: deps.configManager,
+        turnEvents: ui.events.turns,
+        providerEvents: ui.events.providers,
+        providers: ui.readModels.providers,
+        session: ui.readModels.session,
+        security: ui.readModels.security,
+        localAuth: ui.readModels.localAuth,
+        settings: ui.readModels.settings,
+        remote: ui.readModels.remote,
+        intelligence: ui.readModels.intelligence,
+        continuity: ui.readModels.continuity,
+        worktrees: ui.readModels.worktrees,
+      },
+      deps.requestRender,
+    ),
+  });
+
+  manager.registerType({
+    id: 'debug',
+    name: 'Debug',
+    icon: 'B',
+    category: 'monitoring',
+    description: 'API debug panel: per-call log with model, provider, tokens, latency, status, and error history',
+    factory: () => {
+      const panel = new DebugPanel(ui.events.turns, deps.requestRender);
+      if (deps.orchestrator) panel.wireOrchestrator(deps.orchestrator);
+      return panel;
+    },
+  });
+
+  if (deps.forensicsRegistry) {
+    const { forensicsRegistry } = deps;
+    manager.registerType({
+      id: 'incident',
+      name: 'Incident',
+      icon: 'N',
+      category: 'monitoring',
+      description: 'Incident workspace with root cause, permission, budget, and replay evidence',
+      factory: () => new IncidentReviewPanel(forensicsRegistry),
+    });
+    manager.registerType({
+      id: 'forensics',
+      name: 'Forensics',
+      icon: 'F',
+      category: 'monitoring',
+      description: 'Failure Forensics: auto-classified failure reports with causal chains, phase timings, and jump links',
+      factory: () => new ForensicsPanel(forensicsRegistry),
+    });
+  }
+
+  manager.registerType({
+    id: 'policy',
+    name: 'Policy',
+    icon: 'U',
+    category: 'monitoring',
+    description: 'Policy governance: active/candidate bundles, divergence gate, rollout history, and simulation evidence',
+    factory: () => new PolicyPanel(deps.policyRuntimeState),
+  });
+
+  if (deps.evalRegistry) {
+    const { evalRegistry } = deps;
+    manager.registerType({
+      id: 'eval',
+      name: 'Eval',
+      icon: 'Y',
+      category: 'monitoring',
+      description: 'Evaluation harness: benchmark suite results, scorecards, and regression gates',
+      factory: () => new EvalPanel(evalRegistry),
+    });
+  }
+}

package/src/panels/builtin/session.ts

@@ -0,0 +1,129 @@
+import { networkInterfaces } from 'node:os';
+import { readFileSync } from 'node:fs';
+import type { PanelManager } from '../panel-manager.ts';
+import { SessionBrowserPanel } from '../session-browser-panel.ts';
+import { QrPanel } from '../qr-panel.ts';
+import { DocsPanel } from '../docs-panel.ts';
+import { PanelListPanel } from '../panel-list-panel.ts';
+import { TokenBudgetPanel } from '../token-budget-panel.ts';
+import type { ResolvedBuiltinPanelDeps } from './shared.ts';
+import { requireUiServices } from './shared.ts';
+import {
+  getOrCreateCompanionToken,
+  regenerateCompanionToken,
+  buildCompanionConnectionInfo,
+} from '@pellux/goodvibes-sdk/platform/pairing';
+import { copyToClipboard } from '../../utils/clipboard.ts';
+
+function getLocalNetworkIp(): string {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (net.family === 'IPv4' && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return 'localhost';
+}
+
+function readBootstrapPassword(credentialPath: string): string | undefined {
+  try {
+    const content = readFileSync(credentialPath, 'utf-8');
+    for (const line of content.split('\n')) {
+      if (line.startsWith('password=')) {
+        return line.slice('password='.length).trim();
+      }
+    }
+  } catch {
+    // credential file may not exist yet
+  }
+  return undefined;
+}
+
+export function registerSessionPanels(manager: PanelManager, deps: ResolvedBuiltinPanelDeps): void {
+  manager.registerType({
+    id: 'qr-code',
+    name: 'QR Code',
+    icon: 'Q',
+    category: 'session',
+    description: 'QR code for companion app pairing — scan to connect a mobile or desktop companion',
+    factory: () => {
+      if (!deps.daemonHomeDir) throw new Error('daemonHomeDir must be provided to the session panel factory via BuiltinPanelDeps');
+      const daemonHomeDir = deps.daemonHomeDir;
+      const tokenRecord = getOrCreateCompanionToken('tui', { daemonHomeDir });
+      const daemonPort = deps.configManager.get('controlPlane.port');
+      const daemonHost = String(process.env['GOODVIBES_DAEMON_HOST'] ?? getLocalNetworkIp());
+      const daemonUrl = `http://${daemonHost}:${daemonPort}`;
+      const bootstrapPassword = readBootstrapPassword(deps.localUserAuthManager.getBootstrapCredentialPath());
+      const connectionInfo = buildCompanionConnectionInfo({
+        daemonUrl,
+        token: tokenRecord.token,
+        password: bootstrapPassword,
+        surface: 'tui',
+      });
+      const regenerate = (): typeof connectionInfo => {
+        const newRecord = regenerateCompanionToken({ daemonHomeDir });
+        return buildCompanionConnectionInfo({
+          daemonUrl,
+          token: newRecord.token,
+          password: bootstrapPassword,
+          surface: 'tui',
+        });
+      };
+      return new QrPanel(connectionInfo, regenerate, copyToClipboard);
+    },
+  });
+
+  manager.registerType({
+    id: 'sessions',
+    name: 'Sessions',
+    icon: 'H',
+    category: 'session',
+    description: 'Browse, search, and resume past conversation sessions',
+    factory: () => new SessionBrowserPanel(deps.sessionManager, deps.resumeSession),
+  });
+
+  manager.registerType({
+    id: 'docs',
+    name: 'Docs',
+    icon: '?',
+    category: 'session',
+    description: 'Tool list, model capabilities, and keyboard shortcut reference',
+    factory: () => new DocsPanel(deps.toolRegistry, deps.providerRegistry),
+  });
+
+  manager.registerType({
+    id: 'panel-list',
+    name: 'Panel List',
+    icon: 'L',
+    category: 'session',
+    description: 'Browse all registered panels grouped by category, with open/closed status and Enter-to-open',
+    factory: () => new PanelListPanel(manager, deps.componentHealthMonitor),
+  });
+
+  manager.registerType({
+    id: 'system-messages',
+    name: 'System Messages',
+    icon: 'J',
+    category: 'monitoring',
+    description: 'Operational system messages routed away from the main conversation (scans, discovery, plugin events, tool status)',
+    preload: true,
+    factory: () => deps.systemMessagesPanel,
+  });
+
+  manager.registerType({
+    id: 'tokens',
+    name: 'Tokens',
+    icon: 'K',
+    category: 'monitoring',
+    description: 'Token budget tracker: per-turn and cumulative usage with context window gauge',
+    factory: () => {
+      const panel = new TokenBudgetPanel(deps.sessionMemoryStore, deps.configManager);
+      if (deps.orchestrator && deps.getCtxWindow) {
+        panel.wire(deps.orchestrator, deps.getCtxWindow, requireUiServices(deps).readModels.session);
+      }
+      return panel;
+    },
+  });
+}