@pellux/goodvibes-tui 0.18.4

package/src/panels/approval-panel.ts

@@ -0,0 +1,169 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { createEmptyLine } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { BasePanel } from './base-panel.ts';
+import {
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  resolvePrimaryScrollableSection,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+import type { PolicyRuntimeState } from '../runtime/permissions/policy-runtime.ts';
+import { buildPermissionRuleSuggestions } from '../runtime/permissions/rule-suggestions.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  headerBg: '#111827',
+} as const;
+
+const APPROVAL_ROWS = [
+  ['shell', 'why prompted: side effects, destructive ops, secret exposure, escalation', 'review via /security and /policy preflight'],
+  ['file', 'why prompted: config mutation, notebook edits, secret-bearing paths', 'review via /approval review file'],
+  ['network', 'why prompted: external hosts, fetch scope, egress policy', 'review via /approval review network'],
+  ['delegate', 'why prompted: recursive agents, spawn ceilings, write-set inheritance', 'review via /approval review delegate'],
+  ['mcp', 'why prompted: trust escalation, host scope, path scope, coherence mismatch', 'review via /mcp trust and /security'],
+  ['remote', 'why prompted: runner trust, remote write scope, artifact requirements', 'review via /remote and /sandbox'],
+  ['hook', 'why prompted: deny/mutate authority, blocking behavior, runner provenance', 'review via /hooks and /security'],
+  ['plugin', 'why prompted: install/update lifecycle, provenance, capability grants', 'review via /marketplace and /security'],
+  ['sandbox', 'why prompted: WSL/VM isolation changes alter host risk posture', 'review via /sandbox preset and /sandbox review'],
+] as const;
+
+export class ApprovalPanel extends BasePanel {
+  private selectedIndex = 0;
+  private scrollOffset = 0;
+  private readonly policyRuntimeState: Pick<PolicyRuntimeState, 'getSnapshot'>;
+
+  public constructor(policyRuntimeState: Pick<PolicyRuntimeState, 'getSnapshot'>) {
+    super('approval', 'Approval', 'A', 'monitoring');
+    this.policyRuntimeState = policyRuntimeState;
+  }
+
+  public handleInput(key: string): boolean {
+    if (key === 'up' || key === 'k') {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'down' || key === 'j') {
+      this.selectedIndex = Math.min(APPROVAL_ROWS.length - 1, this.selectedIndex + 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'home') {
+      this.selectedIndex = 0;
+      this.markDirty();
+      return true;
+    }
+    if (key === 'end') {
+      this.selectedIndex = APPROVAL_ROWS.length - 1;
+      this.markDirty();
+      return true;
+    }
+    if (key === 'enter' || key === 'return') {
+      return true;
+    }
+    return false;
+  }
+
+  public getSelectedCommand(): string | null {
+    const selected = APPROVAL_ROWS[this.selectedIndex] ?? null;
+    return selected ? selected[2].replace('review via ', '').trim() : null;
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    const policySnapshot = this.policyRuntimeState.getSnapshot();
+    const postureLines = [
+      buildKeyValueLine(width, [
+        { label: 'why prompted', value: 'risk summary', valueColor: C.value },
+        { label: 'what-if', value: '/policy simulate + preflight', valueColor: C.info },
+        { label: 'operator', value: '/security + /cockpit', valueColor: C.good },
+      ], C),
+      buildKeyValueLine(width, [
+        { label: 'recent approvals', value: String(policySnapshot.recentPermissionAudit.filter((entry) => entry.approved === true).length), valueColor: C.good },
+        { label: 'recent denials', value: String(policySnapshot.recentPermissionAudit.filter((entry) => entry.approved === false).length), valueColor: C.bad },
+        { label: 'pending', value: String(policySnapshot.recentPermissionAudit.filter((entry) => entry.approved === undefined).length), valueColor: C.info },
+      ], C),
+      buildGuidanceLine(width, '/approval review shell', 'inspect the highest-risk approval lane and refine scoped review posture', C),
+    ];
+    const footerLines = [buildPanelLine(width, [[`  Up/Down move  Home/End jump  selected lane opens the next command path`, C.dim]])];
+    const selected = APPROVAL_ROWS[this.selectedIndex] ?? null;
+    const detailLines: Line[] = [];
+    if (selected) {
+      detailLines.push(buildKeyValueLine(width, [
+        { label: 'lane', value: selected[0], valueColor: C.info },
+        { label: 'next review', value: selected[2], valueColor: C.dim },
+      ], C));
+      detailLines.push(buildPanelLine(width, [[` ${selected[1]}`, C.value]]));
+      detailLines.push(buildGuidanceLine(width, selected[2].replace('review via ', ''), `open the ${selected[0]} review path`, C));
+    }
+    const recentAuditLines: Line[] = [];
+    for (const entry of policySnapshot.recentPermissionAudit.slice(0, 5)) {
+      const decision = entry.approved === undefined ? 'pending' : entry.approved ? 'approved' : 'denied';
+      const decisionColor = entry.approved === undefined ? C.info : entry.approved ? C.good : C.bad;
+      recentAuditLines.push(buildPanelLine(width, [
+        [`  ${decision.padEnd(8)}`, decisionColor],
+        [`${entry.tool}`.padEnd(14), C.label],
+        [entry.summary.slice(0, Math.max(0, width - 28)), C.value],
+      ]));
+      if (entry.reasons[0]) {
+        recentAuditLines.push(buildPanelLine(width, [[`    ${entry.reasons[0]}`, C.dim]]));
+      }
+    }
+    if (recentAuditLines.length === 0) {
+      recentAuditLines.push(buildPanelLine(width, [[`  No recent approval pressure. Live requests and decisions will appear here.`, C.dim]]));
+    }
+    const ruleSuggestionLines: Line[] = [];
+    for (const suggestion of buildPermissionRuleSuggestions(policySnapshot.recentPermissionAudit).slice(0, 3)) {
+      ruleSuggestionLines.push(buildPanelLine(width, [[`  ${suggestion.summary}`, C.info]]));
+      ruleSuggestionLines.push(buildGuidanceLine(width, suggestion.command, suggestion.reason, C));
+    }
+    if (ruleSuggestionLines.length === 0) {
+      ruleSuggestionLines.push(buildPanelLine(width, [[`  No repeated denials currently suggest a durable rule.`, C.dim]]));
+    }
+    const postureSection: PanelWorkspaceSection = { title: 'Approval posture', lines: postureLines };
+    const selectedSection: PanelWorkspaceSection = { title: 'Selected Lane', lines: detailLines };
+    const pressureSection: PanelWorkspaceSection = { title: 'Recent Pressure', lines: recentAuditLines };
+    const rulesSection: PanelWorkspaceSection = { title: 'Rule Suggestions', lines: ruleSuggestionLines };
+    const resolvedLanesSection = resolvePrimaryScrollableSection(width, height, {
+      intro: 'Action-specific review lanes for approvals, denials, escalations, and preflight guidance.',
+      footerLines,
+      palette: C,
+      beforeSections: [postureSection, selectedSection, pressureSection, rulesSection],
+      section: {
+        title: 'Review Lanes',
+        scrollableLines: APPROVAL_ROWS.map((row, absolute) => {
+          const bg = absolute === this.selectedIndex ? C.selectBg : undefined;
+          return buildPanelLine(width, [
+            ['  ', C.label],
+            [row[0].padEnd(10), C.info, bg],
+            [row[1].slice(0, Math.max(0, width - 18)), C.value, bg],
+          ]);
+        }),
+        selectedIndex: this.selectedIndex,
+        scrollOffset: this.scrollOffset,
+        guardRows: 1,
+        minRows: 4,
+        appendWindowSummary: { dimColor: C.dim },
+      },
+    });
+    this.scrollOffset = resolvedLanesSection.scrollOffset;
+    const lines = buildPanelWorkspace(width, height, {
+      title: 'Approval Control Room',
+      intro: 'Action-specific review lanes for approvals, denials, escalations, and preflight guidance.',
+      sections: [
+        postureSection,
+        selectedSection,
+        pressureSection,
+        rulesSection,
+        resolvedLanesSection.section,
+      ],
+      footerLines,
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}

package/src/panels/automation-control-panel.ts

@@ -0,0 +1,253 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { createEmptyLine } from '@pellux/goodvibes-sdk/platform/types/grid';
+import { BasePanel } from './base-panel.ts';
+import type { UiAutomationSnapshot, UiReadModel } from '../runtime/ui-read-models.ts';
+import { truncateDisplay } from '@pellux/goodvibes-sdk/platform/utils/terminal-width';
+import {
+  buildEmptyState,
+  buildGuidanceLine,
+  buildKeyValueLine,
+  buildPanelLine,
+  buildPanelWorkspace,
+  DEFAULT_PANEL_PALETTE,
+  resolvePrimaryScrollableSection,
+  type PanelWorkspaceSection,
+} from './polish.ts';
+
+const C = {
+  ...DEFAULT_PANEL_PALETTE,
+  header: '#94a3b8',
+  headerBg: '#1e293b',
+  ok: '#22c55e',
+  warn: '#eab308',
+  error: '#ef4444',
+  info: '#38bdf8',
+  selectBg: '#0f172a',
+} as const;
+
+function formatTime(value?: number): string {
+  if (!value) return 'n/a';
+  return new Date(value).toLocaleString();
+}
+
+function runStatusColor(status: string): string {
+  if (status === 'completed') return C.ok;
+  if (status === 'failed' || status === 'dead_lettered') return C.error;
+  if (status === 'cancelled') return C.warn;
+  return C.info;
+}
+
+export class AutomationControlPanel extends BasePanel {
+  private readonly readModel?: UiReadModel<UiAutomationSnapshot>;
+  private readonly unsub: (() => void) | null;
+  private selectedIndex = 0;
+  private scrollOffset = 0;
+
+  public constructor(readModel?: UiReadModel<UiAutomationSnapshot>) {
+    super('automation', 'Automation', 'M', 'monitoring');
+    this.readModel = readModel;
+    this.unsub = readModel ? readModel.subscribe(() => this.markDirty()) : null;
+  }
+
+  public override onDestroy(): void {
+    this.unsub?.();
+  }
+
+  public handleInput(key: string): boolean {
+    const runs = this.runs();
+    if (runs.length === 0) return false;
+    if (key === 'up' || key === 'k') {
+      this.selectedIndex = Math.max(0, this.selectedIndex - 1);
+      this.markDirty();
+      return true;
+    }
+    if (key === 'down' || key === 'j') {
+      this.selectedIndex = Math.min(runs.length - 1, this.selectedIndex + 1);
+      this.markDirty();
+      return true;
+    }
+    return false;
+  }
+
+  private runs() {
+    if (!this.readModel) return [];
+    return [...this.readModel.getSnapshot().runs];
+  }
+
+  public render(width: number, height: number): Line[] {
+    this.needsRender = false;
+    const intro = 'Automation jobs, active runs, deliveries, and failure posture across the shared control plane.';
+
+    if (!this.readModel) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Automation Control',
+        intro,
+        sections: [{
+          lines: buildEmptyState(
+            width,
+            ' Runtime store not wired.',
+            'This panel needs the shared runtime store to inspect automation jobs, runs, and deliveries.',
+            [{ command: '/schedule list', summary: 'review automation from the shell while the runtime wiring is restored' }],
+            C,
+          ),
+        }],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    const snapshot = this.readModel.getSnapshot();
+    const jobs = [...snapshot.jobs];
+    const runs = this.runs();
+
+    const summarySection: PanelWorkspaceSection = {
+      title: 'Posture',
+      lines: [
+        buildKeyValueLine(width, [
+          { label: 'jobs', value: String(snapshot.totalJobs), valueColor: snapshot.totalJobs > 0 ? C.info : C.dim },
+          { label: 'runs', value: String(snapshot.totalRuns), valueColor: snapshot.totalRuns > 0 ? C.value : C.dim },
+          { label: 'active', value: String(snapshot.activeRunIds.length), valueColor: snapshot.activeRunIds.length > 0 ? C.warn : C.dim },
+          { label: 'failed', value: String(snapshot.totalFailed), valueColor: snapshot.totalFailed > 0 ? C.error : C.dim },
+        ], C),
+        buildKeyValueLine(width, [
+          { label: 'deliveries ok', value: String(snapshot.deliveryTotals.succeeded), valueColor: snapshot.deliveryTotals.succeeded > 0 ? C.ok : C.dim },
+          { label: 'delivery fail', value: String(snapshot.deliveryTotals.failed), valueColor: snapshot.deliveryTotals.failed > 0 ? C.error : C.dim },
+          { label: 'dead letters', value: String(snapshot.deliveryTotals.deadLettered), valueColor: snapshot.deliveryTotals.deadLettered > 0 ? C.warn : C.dim },
+          { label: 'sources', value: String(snapshot.sourceCount), valueColor: snapshot.sourceCount > 0 ? C.info : C.dim },
+        ], C),
+        buildGuidanceLine(width, '/schedule list', 'manage jobs and use the web or surface controls for retries, delivery, and cross-surface sessions', C),
+      ],
+    };
+
+    if (jobs.length === 0 && runs.length === 0) {
+      const workspace = buildPanelWorkspace(width, height, {
+        title: 'Automation Control',
+        intro,
+        sections: [
+          summarySection,
+          {
+            lines: buildEmptyState(
+              width,
+              ' No automation activity recorded.',
+              'Create a job, run one manually, or let a watcher/surface trigger automation to populate this control room.',
+              [
+                { command: '/schedule add cron 0 * * * * repo sweep', summary: 'create a recurring automation job' },
+                { command: '/schedule list', summary: 'inspect jobs and run history from the shell' },
+              ],
+              C,
+            ),
+          },
+        ],
+        palette: C,
+      });
+      while (workspace.length < height) workspace.push(createEmptyLine(width));
+      return workspace;
+    }
+
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, runs.length - 1));
+    const selectedRun = runs[this.selectedIndex];
+    const jobName = selectedRun ? (jobs.find((job) => job.id === selectedRun.jobId)?.name ?? selectedRun.jobId) : 'n/a';
+
+    const jobSection: PanelWorkspaceSection = {
+      title: 'Jobs',
+      lines: jobs.slice(0, 6).map((job) => buildPanelLine(width, [
+        [' ', C.label],
+        [job.enabled ? 'ENABLED ' : 'PAUSED  ', job.enabled ? C.ok : C.warn],
+        [truncateDisplay(job.name, 24).padEnd(24), C.value],
+        [` next ${truncateDisplay(formatTime(job.nextRunAt), Math.max(0, width - 43))}`, C.dim],
+      ])),
+    };
+
+    const detailSection: PanelWorkspaceSection = selectedRun
+      ? {
+          title: 'Selected Run',
+          lines: [
+            buildPanelLine(width, [
+              ['  Run: ', C.label],
+              [selectedRun.id, C.value],
+              ['  Status: ', C.label],
+              [selectedRun.status, runStatusColor(selectedRun.status)],
+            ]),
+            buildPanelLine(width, [
+              ['  Job: ', C.label],
+              [jobName, C.value],
+              ['  Agent: ', C.label],
+              [selectedRun.agentId ?? 'n/a', C.info],
+            ]),
+            buildPanelLine(width, [
+              ['  Queue: ', C.label],
+              [formatTime(selectedRun.queuedAt), C.dim],
+              ['  End: ', C.label],
+              [formatTime(selectedRun.endedAt), C.dim],
+            ]),
+            buildPanelLine(width, [
+              ['  Trigger: ', C.label],
+              [selectedRun.triggeredBy.kind, C.info],
+              ['  Target: ', C.label],
+              [selectedRun.target.kind, C.value],
+            ]),
+            buildPanelLine(width, [
+              ['  Deliveries: ', C.label],
+              [String(selectedRun.deliveryIds.length), selectedRun.deliveryIds.length > 0 ? C.info : C.dim],
+              ['  Route: ', C.label],
+              [selectedRun.routeId ?? 'n/a', C.dim],
+            ]),
+            ...(selectedRun.error ? [
+              buildPanelLine(width, [
+                ['  Error: ', C.label],
+                [truncateDisplay(selectedRun.error, Math.max(0, width - 10)), C.error],
+              ]),
+            ] : []),
+          ],
+        }
+      : {
+          title: 'Selected Run',
+          lines: [buildPanelLine(width, [['  No run selected.', C.dim]])],
+        };
+
+    const resolvedRuns = resolvePrimaryScrollableSection(width, height, {
+      intro,
+      footerLines: [buildPanelLine(width, [['  Up/Down move through runs', C.dim]])],
+      palette: C,
+      beforeSections: [summarySection],
+      section: {
+        title: 'Recent Runs',
+        scrollableLines: runs.map((run, absolute) => {
+          const bg = absolute === this.selectedIndex ? C.selectBg : undefined;
+          const name = jobs.find((job) => job.id === run.jobId)?.name ?? run.jobId;
+          return buildPanelLine(width, [
+            [' ', C.label, bg],
+            [run.status.padEnd(11), runStatusColor(run.status), bg],
+            [` ${truncateDisplay(name, 22).padEnd(22)}`, C.value, bg],
+            [` ${truncateDisplay(run.target.kind, 12).padEnd(12)}`, C.info, bg],
+            [` ${truncateDisplay(formatTime(run.queuedAt), Math.max(0, width - 49))}`, C.dim, bg],
+          ]);
+        }),
+        selectedIndex: this.selectedIndex,
+        scrollOffset: this.scrollOffset,
+        guardRows: 1,
+        minRows: 5,
+        appendWindowSummary: { dimColor: C.dim },
+      },
+      afterSections: [detailSection, jobSection],
+    });
+    this.scrollOffset = resolvedRuns.scrollOffset;
+
+    const sections: PanelWorkspaceSection[] = [
+      summarySection,
+      resolvedRuns.section,
+      detailSection,
+      jobSection,
+    ];
+    const lines = buildPanelWorkspace(width, height, {
+      title: 'Automation Control',
+      intro,
+      sections,
+      footerLines: [buildPanelLine(width, [['  Up/Down move through runs', C.dim]])],
+      palette: C,
+    });
+    while (lines.length < height) lines.push(createEmptyLine(width));
+    return lines.slice(0, height);
+  }
+}

package/src/panels/base-panel.ts

@@ -0,0 +1,72 @@
+import type { Line } from '@pellux/goodvibes-sdk/platform/types/grid';
+import type { Panel, PanelCategory } from './types.ts';
+import type { PanelResourceContract, PanelHealthState } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-contracts';
+import type { PanelHealthMonitor } from '@pellux/goodvibes-sdk/platform/runtime/perf/panel-health-monitor';
+
+export abstract class BasePanel implements Panel {
+  public needsRender = true;
+  public isTransient = false;
+  public isPinned = false;
+  protected readonly panelHealthMonitor?: PanelHealthMonitor;
+
+  /**
+   * Optional resource contract for this panel.
+   * Override in subclasses to declare a custom contract; leave undefined
+   * to use the category default enforced by PanelHealthMonitor.
+   */
+  public resourceContract: Readonly<PanelResourceContract> | undefined = undefined;
+
+  /**
+   * Live health state populated by PanelHealthMonitor.
+   * Read-only from outside the monitor.
+   */
+  public get healthState(): Readonly<PanelHealthState> | undefined {
+    return this.panelHealthMonitor?.getHealth(this.id);
+  }
+
+  constructor(
+    public readonly id: string,
+    public readonly name: string,
+    public readonly icon: string,
+    public readonly category: PanelCategory,
+    panelHealthMonitor?: PanelHealthMonitor,
+  ) {
+    this.panelHealthMonitor = panelHealthMonitor;
+  }
+
+  onActivate(): void { this.needsRender = true; }
+  onDeactivate(): void {}
+  onDestroy(): void {}
+
+  abstract render(width: number, height: number): Line[];
+
+  protected markDirty(): void { this.needsRender = true; }
+
+  /**
+   * Check whether the panel is currently permitted to render.
+   *
+   * Consults the shared PanelHealthMonitor. Returns true if not registered
+   * (unthrottled) or if the monitor permits a render at this moment.
+   *
+   * Call this inside render() or before invoking render() to skip
+   * expensive work when throttled:
+   *
+   * ```ts
+   * render(width, height): Line[] {
+   *   if (!this.canRenderNow()) return this._lastLines ?? [];
+   *   // ... expensive render ...
+   * }
+   * ```
+   */
+  protected canRenderNow(now: number = Date.now()): boolean {
+    return this.panelHealthMonitor?.canRender(this.id, now) ?? true;
+  }
+
+  /**
+   * Report the duration of a completed render to the health monitor.
+   * Call this at the end of render() after measuring wall-clock cost.
+   */
+  protected reportRenderDuration(durationMs: number, now: number = Date.now()): void {
+    this.panelHealthMonitor?.recordRender(this.id, durationMs, now);
+  }
+}

package/src/panels/builtin/agent.ts

@@ -0,0 +1,88 @@
+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 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.getOrchestratorUsage,
+      deps.contextWindow,
+      requireUiServices(deps).readModels.session,
+    ),
+  });
+
+  manager.registerType({
+    id: 'agent-logs',
+    name: 'Agents',
+    icon: 'A',
+    category: 'agent',
+    description: 'View-only live session stream from running agents with per-agent switching',
+    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: 'schedule',
+    name: 'Schedule',
+    icon: 'Z',
+    category: 'agent',
+    description: 'Scheduled agent tasks: cron expressions, next run time, enable/disable, run history',
+    factory: () => new SchedulePanel(requireAutomationManager(deps)),
+  });
+}