@cesarus777/opencode-cgp 0.4.0 → 0.4.2

package/dist/types/archive.d.ts

@@ -0,0 +1,40 @@
+import { type HistoryFilter, type HistoryMetadata, type HistoryRecord, type ScanOptions } from "./history.js";
+export interface ArchiveSnapshot {
+    revision: string;
+    metadata: HistoryMetadata;
+    records: HistoryRecord[];
+    iterateRecords?: () => Iterable<HistoryRecord>;
+}
+interface ArchiveOptions extends ScanOptions {
+    maxCacheBytes?: number;
+    maxCacheRecords?: number;
+    maxCacheSegments?: number;
+}
+/** Location-owned cache. Metadata validation assumes external writers do not restore timestamps. */
+export declare class PerformanceArchive {
+    readonly path: string;
+    private readonly options;
+    private entries;
+    private generation;
+    private stopped;
+    private dirty;
+    private forcedGeneration;
+    private job;
+    readonly stats: {
+        readBytes: number;
+        parsedRecords: number;
+        cacheBytes: number;
+        cacheRecords: number;
+    };
+    constructor(path: string, options?: ArchiveOptions);
+    /** Writer notifications invalidate even metadata-invisible mutations. */
+    invalidate(name?: string): void;
+    dispose(): void;
+    private account;
+    private retain;
+    private validCapture;
+    private scan;
+    read(filter?: HistoryFilter): Promise<ArchiveSnapshot>;
+    private wait;
+}
+export {};

package/dist/types/core.d.ts

@@ -8,5 +8,5 @@ export * from "./snapshot.js";
 export * from "./family.js";
 export * from "./performance.js";
 export * from "./charts.js";
-export * from "./modelanalytics.js";
+export { analyzeModelRequests, aggregateModels, summarizeModelRequests, type ModelAnalyticsOptions, type AnalyticsRequest, type ModelSummary, type ModelAnalyticsResult, type CompletedAnalyticsRequest, } from "./modelanalytics.js";
 export * from "./modelseries.js";

package/dist/types/dashboard/controller.d.ts

@@ -11,6 +11,7 @@ export interface DashboardControllerOptions {
 }
 /** Shared application state; subscribers never acquire additional upstream streams. */
 export declare class DashboardController {
+    private readonly snapshots;
     private readonly locations;
     private readonly cache;
     private readonly listeners;
@@ -29,6 +30,7 @@ export declare class DashboardController {
     private pendingHistory;
     private historyAbort;
     private historyBusy;
+    private historyReason;
     private historyStatus;
     private refreshTimer;
     private ageTimer;

package/dist/types/dashboard/inventory.d.ts

@@ -14,4 +14,4 @@ export interface DashboardInventory {
 export declare const inventoryLimits: InventoryLimits;
 export declare function validateInventoryLimits(limits: InventoryLimits): void;
 /** Bounded breadth-first discovery of a whole location, without transcript reads. */
-export declare function discoverInventory(port: Pick<DashboardPort, "location" | "listSessions">, signal: AbortSignal, limits?: InventoryLimits): Promise<DashboardInventory>;
+export declare function discoverInventory(port: Pick<DashboardPort, "location" | "listSessions">, signal: AbortSignal, limits?: InventoryLimits, progress?: (inventory: DashboardInventory) => void): Promise<DashboardInventory>;

package/dist/types/dashboard/terminal.d.ts

@@ -12,6 +12,9 @@ export interface TerminalKey {
 export declare class TerminalShell {
     readonly controller: DashboardController;
     private readonly quit;
+    readonly work: {
+        formattedOverviewRows: number;
+    };
     scroll: number;
     metric: number;
     sample: number;
@@ -25,6 +28,11 @@ export declare class TerminalShell {
     input: string;
     notice: string;
     private rowOffset;
+    private overviewScope;
+    private overviewPage;
+    private labelKey;
+    private labels;
+    private layouts;
     private historyIdentity;
     constructor(controller: DashboardController, quit: () => void);
     private task;

package/dist/types/dashboard/terminalview.d.ts

@@ -1,5 +1,12 @@
 import type { DashboardRow, DashboardView } from "./view.js";
-export declare function overviewRow(row: DashboardRow): string;
+export declare function diagnosticRow(row: DashboardRow): string;
+export declare function overviewHeading(width: number): string[];
+/** Stable ID suffixes when unique; position is the bounded fallback. */
+export declare function overviewLabels(rows: readonly DashboardRow[]): string[];
+/** Lightweight line count; identity clipping and exception text are viewport work. */
+export declare function overviewRowHeight(row: DashboardRow, width: number, maxLines: number): number;
+/** Each row is already cell-bounded; overview cards never wrap diagnostics. */
+export declare function overviewRowLines(row: DashboardRow, width: number, selected: boolean, label: string, position: number, maxLines?: number): string[];
 export declare const snapshotFields: readonly ["sessionId", "parentId", "agent", "model", "revision", "observedAt", "measurement.tokens", "measurement.at", "measurement.model", "measurement.provenance", "measurement.scope", "measurement.confidence", "measurement.requestId", "limits.input", "limits.context", "limits.output", "capacityTokens", "outputReserveTokens", "peakTokens", "policy.id", "policy.configured.type", "policy.configured.value", "policy.triggerTokens", "policy.comparison", "policy.reason", "policy.crossed", "compaction.phase", "compaction.count", "compaction.armed", "compaction.blockedReason", "compaction.lastAttempt", "compaction.lastCompleted", "compaction.cooldownUntil", "cumulativeScope", "cumulative.input", "cumulative.output", "cumulative.reasoning", "cumulative.cache.read", "cumulative.cache.write", "lastObservedActive", "performance.sessionCreatedAt", "performance.sessionOutputTokens", "performance.observedSince", "performance.at", "performance.status", "performance.partial", "performance.liveTps", "performance.averageModelTps", "performance.averageSessionTps", "performance.ttftMs", "performance.latestRequestTps", "performance.requestId", "performance.requestAgent", "performance.requestModel", "performance.requestOutputTokens", "performance.requestStartedAt", "performance.firstOutputAt", "performance.streamEndedAt", "performance.estimatedOutputTokens", "performance.modelOutputTokens", "performance.modelDurationMs", "performance.completedRequests", "performance.tokenSource"];
 export declare function terminalDetail(row: DashboardRow | undefined): string[];
 interface Observation {
@@ -11,5 +18,5 @@ export declare function historyObservations(view: DashboardView, metricIndex: nu
 export declare function terminalHistory(view: DashboardView, width: number, metricIndex: number, sample: number): string[];
 export declare const terminalHelp: string[];
 export declare function wrapped(lines: readonly string[], width: number): string[];
-export declare function headerLines(view: DashboardView, width: number): string[];
+export declare function headerLines(view: DashboardView, width: number, height?: number): string[];
 export {};

package/dist/types/dashboard/view.d.ts

@@ -1,3 +1,4 @@
+import type { HistoryFailureReason } from "../historyclient.js";
 import type { GuardRow } from "../family.js";
 import type { MonitorHealth } from "../snapshot.js";
 import type { HistoryChartResult } from "../historycharts.js";
@@ -32,6 +33,8 @@ export interface HistorySummary {
     readonly averageModelTps?: number;
 }
 export interface DashboardHistory {
+    readonly reason?: HistoryFailureReason;
+    readonly loadedAt?: number;
     readonly status: "idle" | "loading" | "ready" | "disabled" | "unavailable";
     readonly windowMs: HistoryWindow;
     readonly maxWindowMs: 604800000;
@@ -76,7 +79,7 @@ export type DashboardView = Immutable<{
     models: DashboardModels;
     notices: readonly string[];
 }>;
-/** Clone before freezing so transport-owned objects never become UI-owned state. */
+/** Copy transport objects once; already-owned immutable subtrees can be shared. */
 export declare function immutableView<T>(value: T): T;
 export declare function projectHistory(result: HistoryChartResult, filters: DashboardFilters): {
     result: HistoryChartResult;

package/dist/types/history.d.ts

@@ -1,3 +1,5 @@
+import type { Stats } from "node:fs";
+import { open } from "node:fs/promises";
 import type { Identity, Config } from "./types.js";
 import type { PerformanceSnapshot } from "./performance.js";
 export interface HistoryRecord extends Identity {
@@ -9,12 +11,47 @@ export interface HistoryRecord extends Identity {
     event?: string;
     droppedRecords?: number;
 }
+export declare function segments(directory: string): Promise<{
+    bytes: number;
+    dev: number;
+    ino: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    name: string;
+    time: number;
+}[]>;
+export declare function fileIdentity(info: Stats): {
+    bytes: number;
+    dev: number;
+    ino: number;
+    mtimeMs: number;
+    ctimeMs: number;
+};
+export interface ScanOptions {
+    now?: () => number;
+    yield?: () => Promise<void>;
+    chunkBytes?: number;
+    onRead?: (bytes: number) => void;
+    onParse?: () => void;
+}
+/** Cooperative scheduling is independent of cancellation. */
+export declare function scanScheduler(signal?: AbortSignal, options?: ScanOptions): () => Promise<void> | undefined;
+export declare function matchesHistory(value: HistoryRecord, filter: HistoryFilter): boolean;
+/** Reads captured bytes only. Byte boundaries retain UTF-8 exactly, including tails. */
+export declare function scanHistorySegment(handle: Awaited<ReturnType<typeof open>>, size: number, filter?: HistoryFilter, options?: ScanOptions, start?: number): Promise<{
+    records: HistoryRecord[];
+    malformedRecords: number;
+    boundary: number;
+    completeRecords: number;
+    completeMalformed: number;
+}>;
 /** Separate bounded journal; the API accepts only projected scalar measurements. */
 export declare class PerformanceHistory {
     readonly path: string;
     private readonly config;
     private readonly now;
     private readonly report;
+    private readonly changed;
     private pending;
     private working;
     private active;
@@ -23,7 +60,7 @@ export declare class PerformanceHistory {
     private disabled;
     private dropped;
     private droppedTotal;
-    constructor(path: string, config: Config["history"], now?: () => number, report?: (event: string) => void);
+    constructor(path: string, config: Config["history"], now?: () => number, report?: (event: string) => void, changed?: (name: string) => void);
     emit(record: HistoryRecord): void;
     private kick;
     private prune;
@@ -54,7 +91,7 @@ export interface HistoryMetadata {
     malformedRecords: number;
     completeness: string;
 }
-export declare function readPerformanceHistory(directory: string, filter?: HistoryFilter): Promise<{
+export declare function readPerformanceHistory(directory: string, filter?: HistoryFilter, options?: ScanOptions): Promise<{
     metadata: HistoryMetadata;
     records: HistoryRecord[];
 }>;

package/dist/types/historyclient.d.ts

@@ -0,0 +1,15 @@
+import type { HistoryChartResult } from "./historycharts.js";
+export type HistoryFailureReason = "unsupported" | "timeout" | "incompatible" | "rejected" | "unavailable";
+/** Only approved codes cross the presentation boundary, never server messages. */
+export declare class HistoryFailure extends Error {
+    readonly reason: HistoryFailureReason;
+    constructor(reason: HistoryFailureReason);
+}
+export declare function historyFailure(error: unknown, signal?: AbortSignal): HistoryFailure;
+export declare function checkedHistory(value: unknown, sessionId: string): HistoryChartResult;
+export declare function historyStatusLines(input: {
+    status: "idle" | "loading" | "ready" | "disabled" | "unavailable";
+    reason?: HistoryFailureReason;
+    stale?: boolean;
+    loadedAt?: number;
+}): string[];

package/dist/types/historyserver.d.ts

@@ -1,7 +1,8 @@
+import { readPerformanceHistory } from "./history.js";
 import { historyRpc } from "./rpc.js";
 import type { RpcHandlers, RpcRegistration } from "@opencode/plugin/promise/rpc";
 export interface HistoryRpcPort {
     register(definition: typeof historyRpc, handlers: RpcHandlers<typeof historyRpc>): Promise<Pick<RpcRegistration<typeof historyRpc>, "dispose">>;
 }
 /** Read-only archive service. Clients can select an ID/time range, never a filesystem path. */
-export declare function serveHistory(rpc: HistoryRpcPort | undefined, path: string, enabled: boolean, now?: () => number, authorize?: (sessionId: string, signal: AbortSignal) => Promise<boolean>): Promise<() => void>;
+export declare function serveHistory(rpc: HistoryRpcPort | undefined, path: string, enabled: boolean, now?: () => number, authorize?: (sessionId: string, signal: AbortSignal) => Promise<boolean>, reader?: typeof readPerformanceHistory): Promise<() => void>;

package/dist/types/modelanalytics.d.ts

@@ -60,9 +60,20 @@ export interface ModelAnalyticsResult {
 export declare function analyzeModelRequests(records: readonly HistoryRecord[], options: ModelAnalyticsOptions): ModelAnalyticsResult & {
     requests: CompletedAnalyticsRequest[];
 };
+/** Canonical reconciliation state, shared by full and proven-prefix append paths. */
+export declare function createModelAccumulator(options: ModelAnalyticsOptions): {
+    append: (records: readonly HistoryRecord[]) => void;
+    steps: () => Generator<void, ModelAnalyticsResult & {
+        requests: CompletedAnalyticsRequest[];
+    }>;
+    result: () => ModelAnalyticsResult & {
+        requests: CompletedAnalyticsRequest[];
+    };
+};
 export interface CompletedAnalyticsRequest extends AnalyticsRequest {
     completedAt: number;
 }
 /** Summarize already reconciled requests, including independent metric eligibility. */
 export declare function summarizeModelRequests(requests: readonly CompletedAnalyticsRequest[]): ModelSummary[];
+export declare function summarizeModelRequestSteps(requests: readonly CompletedAnalyticsRequest[]): Generator<void, ModelSummary[]>;
 export declare function aggregateModels(records: readonly HistoryRecord[], options: ModelAnalyticsOptions): ModelAnalyticsResult;

package/dist/types/modelanalyticsserver.d.ts

@@ -9,8 +9,9 @@ export interface AnalyticsRpcPort {
 export declare function createAnalyticsService(path: string, location: string, enabled: boolean, options?: {
     now?: () => number;
     read?: typeof readPerformanceHistory;
+    revisioned?: boolean;
 }): {
     read(input: AnalyticsRead, signal: AbortSignal): Promise<AnalyticsResult>;
     dispose(): void;
 };
-export declare function serveModelAnalytics(port: AnalyticsRpcPort | undefined, path: string, location: string, enabled: boolean): Promise<() => void>;
+export declare function serveModelAnalytics(port: AnalyticsRpcPort | undefined, path: string, location: string, enabled: boolean, options?: Parameters<typeof createAnalyticsService>[3]): Promise<() => void>;

package/dist/types/tui/charts.d.ts

@@ -1,11 +1,10 @@
 import type { Plugin } from "@opencode/plugin/tui";
-import type { GuardState } from "./state.js";
+import type { HistoryView } from "./historystate.js";
 export declare function HistoryCharts(props: {
     sessionId: string;
     windowMs: number;
     metricIndex: number;
-    refresh: number;
     width: number;
-    state: GuardState;
+    view: HistoryView;
     context: Plugin.Context;
 }): import("solid-js").JSX.Element;

package/dist/types/tui/compactformat.d.ts

@@ -1,6 +1,6 @@
 import { type ContextSample, type ContextChartSegment } from "./contextchart.js";
 import type { GuardRow } from "../family.js";
-export declare function tokens(value: number | undefined): string;
+export { tokens } from "./quantity.js";
 export declare function columns(left: string, right: string, width: number): string[];
 export declare function progress(ratio: number | undefined, width: number): string;
 export interface MainSection {
@@ -8,7 +8,8 @@ export interface MainSection {
     readonly lines: readonly string[];
     readonly segments?: readonly ContextChartSegment[];
 }
-export declare function mainSections(row: GuardRow | undefined, width: number, age: number, samples?: readonly ContextSample[], chartCapacity?: number): MainSection[];
+export declare function mainSections(row: GuardRow | undefined, width: number, age: number): MainSection[];
+export declare function historySections(row: GuardRow | undefined, width: number, age: number, samples: readonly ContextSample[], chartCapacity?: number): MainSection[];
 export declare function mainLines(row: GuardRow | undefined, width: number, age: number): string[];
 export declare const statusSymbol: {
     readonly running: "●";
@@ -19,12 +20,20 @@ export declare const statusSymbol: {
 };
 export declare function agentHeading(row: GuardRow, width: number): string;
 export declare function agentLines(row: GuardRow, width: number): string[];
-export declare function subagentTree(rows: readonly GuardRow[], sessionID: string, collapsed: ReadonlySet<string>, hideCompleted: boolean, byPressure: boolean): {
+export declare function subagentTree(rows: readonly GuardRow[], sessionID: string, collapsed: ReadonlySet<string>, hideCompleted: boolean, byPressure: boolean, trustworthy?: boolean): {
     all: GuardRow[];
     visible: {
         row: GuardRow;
         depth: number;
         hasChildren: boolean;
+        hidden: number;
+        attention: boolean;
     }[];
+    grouped: number;
+    complete: boolean;
+};
+export declare function routeFamily(rows: readonly GuardRow[], sessionID: string): {
+    rows: GuardRow[];
+    complete: boolean;
 };
 export declare function statistics(rows: readonly GuardRow[], sessionID: string, complete: boolean, width: number): string[];

package/dist/types/tui/historystate.d.ts

@@ -0,0 +1,49 @@
+import type { HistoryChartResult } from "../historycharts.js";
+import { type HistoryFailureReason } from "../historyclient.js";
+interface Query {
+    readonly location: string;
+    readonly sessionId: string;
+    readonly windowMs: number;
+}
+export interface HistoryView {
+    readonly status: "idle" | "loading" | "ready" | "disabled" | "unavailable";
+    readonly reason?: HistoryFailureReason;
+    readonly result?: HistoryChartResult;
+    readonly from?: number;
+    readonly to?: number;
+    readonly loadedAt?: number;
+    readonly stale: boolean;
+}
+interface Options {
+    read(id: string, from: number, to: number, signal: AbortSignal): Promise<HistoryChartResult>;
+    changed(view: HistoryView): void;
+    now?: () => number;
+    schedule?: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
+    cancel?: (timer: ReturnType<typeof setTimeout>) => void;
+    deadline?: () => AbortSignal;
+}
+/** One mounted chart, one retained query, one in-flight read and one queued retry. */
+export declare class HistoryState {
+    private readonly options;
+    private query;
+    private generation;
+    private active;
+    private pending;
+    private stopped;
+    private paused;
+    private timer;
+    private view;
+    private readonly now;
+    private readonly schedule;
+    private readonly cancel;
+    constructor(options: Options);
+    setQuery(query: Query): void;
+    pause(): void;
+    resume(): void;
+    refresh(): void;
+    dispose(): void;
+    private clearTimer;
+    private publish;
+    private pump;
+}
+export {};

package/dist/types/tui/inventory.d.ts

@@ -14,5 +14,17 @@ export interface Inventory {
     readonly scanned: ReadonlySet<string>;
     readonly damaged: boolean;
 }
+export interface InventoryStatus {
+    readonly discovered: number;
+    readonly limit: number;
+    readonly scanning: boolean;
+    readonly failed: boolean;
+    readonly damaged: boolean;
+    readonly pending: number;
+    readonly pages: number;
+    readonly complete: boolean;
+    readonly canLoadMore: boolean;
+}
+export declare function inventoryStatus(inventory: Inventory | undefined, limit: number, scanning: boolean, failed: boolean): InventoryStatus;
 export declare function discoverFamily(client: Pick<OpenCodeClient, "session">, currentId: string, signal: AbortSignal, cached: (id: string) => SessionInfo | undefined, maxNodes?: number, previous?: Inventory): Promise<Inventory>;
 export {};

package/dist/types/tui/panelcontrols.d.ts

@@ -0,0 +1,8 @@
+import type { InventoryStatus } from "./inventory.js";
+export declare function inventoryMessages(status: InventoryStatus): string[];
+export interface PanelAction {
+    readonly id: string;
+    readonly label: string;
+    readonly run: () => void;
+}
+export declare function footerActions(essential: readonly PanelAction[], optional: readonly PanelAction[], width: number): PanelAction[];

package/dist/types/tui/panelformat.d.ts

@@ -0,0 +1,12 @@
+import type { GuardRow } from "../family.js";
+export { compactionLabel, thresholdDistance, panelStatus, } from "./statusformat.js";
+export declare const panelStatuses: {
+    readonly running: "RUNNING";
+    readonly idle: "IDLE";
+    readonly completed: "DONE";
+    readonly failed: "FAILED";
+    readonly unknown: "UNKNOWN";
+};
+export declare function panelSummary(row: GuardRow | undefined, width: number, age: number, compact?: boolean): string[];
+export declare function panelRowHeading(label: string, width: number): string;
+export declare function panelRowLines(row: GuardRow, width: number, selected: boolean): string[];

package/dist/types/tui/panelview.d.ts

@@ -0,0 +1,22 @@
+import type { Plugin } from "@opencode/plugin/tui";
+import type { GuardRow } from "../family.js";
+import type { ContextTrace } from "./contextchart.js";
+export declare function PanelOverview(props: {
+    rows: readonly GuardRow[];
+    selectedId: string | undefined;
+    width: number;
+    context: Plugin.Context;
+    open: (row: GuardRow) => void;
+}): import("solid-js").JSX.Element;
+export declare function PanelDetails(props: {
+    row: GuardRow | undefined;
+    rows: readonly GuardRow[];
+    routeID: string;
+    familyRows: readonly GuardRow[];
+    familyComplete: boolean;
+    trace: ContextTrace;
+    width: number;
+    age: number;
+    context: Plugin.Context;
+    reasons: readonly string[];
+}): import("solid-js").JSX.Element;

package/dist/types/tui/quantity.d.ts

@@ -0,0 +1 @@
+export declare function tokens(value: number | undefined): string;

package/dist/types/tui/sidebar.d.ts

@@ -1,13 +1,8 @@
 import type { Plugin } from "@opencode/plugin/tui";
 import type { GuardState } from "./state.js";
-import type { GuardRow } from "../family.js";
 export declare function GuardView(props: {
     sessionID: string;
     state: GuardState;
     context: Plugin.Context;
     width: number;
-    expanded?: boolean;
-    family?: readonly GuardRow[];
-    selectedId?: string;
-    inspectId?: string | undefined;
 }): import("solid-js").JSX.Element;

package/dist/types/tui/state.d.ts

@@ -6,14 +6,16 @@ export declare function createGuardState(context: Plugin.Context): {
         update(next: string): void;
         release(): void;
     };
+    historyLocation(id: string): string;
     history(id: string, from: number, to: number, signal: AbortSignal): Promise<import("../historycharts.js").HistoryChartResult>;
     rows: (stableOrder?: readonly string[], allDescendants?: boolean) => GuardRow[];
     contextTrace: (row: GuardRow | undefined) => import("./contextchart.js").ContextTrace;
     dispose(): void;
     age(id: string): number;
     health(): import("../snapshot.js").MonitorHealth | undefined;
-    connection(): "unavailable" | "loading" | "live" | "reconnecting" | "incompatible";
+    connection(): "unavailable" | "incompatible" | "loading" | "live" | "reconnecting";
     complete(): boolean;
+    inventoryStatus(): import("./inventory.js").InventoryStatus;
     refresh(): void;
     loadMore(): void;
     expand(id: string): void;

package/dist/types/tui/statusformat.d.ts

@@ -0,0 +1,19 @@
+import type { GuardRow } from "../family.js";
+import type { MonitorHealth } from "../snapshot.js";
+import type { Connection } from "./transport.js";
+/** A stored reading's confidence is independent of its freshness and scope. */
+export declare function freshnessLabel(row: GuardRow | undefined): string | undefined;
+export declare function measurementLabel(row: GuardRow | undefined, ageMs?: number): string;
+export declare function measurementExplanation(row: GuardRow): readonly string[];
+export declare function compactionLabel(row: GuardRow | undefined, compact?: boolean): string | undefined;
+/** Only translate reasons with established semantics; unknown codes stay in diagnostics. */
+export declare function reasonExplanation(reason: string): string;
+export declare const contextHistoryLegend: readonly ["Recent samples → now · ┄ threshold", "Dim = last known context"];
+export declare function pressureLabel(row: GuardRow | undefined): string;
+export declare function thresholdDistance(row: GuardRow | undefined, compact?: boolean): string;
+export declare function guardStatusLines(health: MonitorHealth | undefined, compact?: boolean): readonly string[];
+export declare function panelStatus(health: MonitorHealth | undefined): string;
+export declare function connectionLabel(connection: Connection, compact?: boolean): string;
+/** A client connection loss is not evidence that server enforcement stopped. */
+export declare function connectionNotice(connection: Connection, retainedMeasurements: boolean, compact?: boolean): string | undefined;
+export declare function monitorStatusLines(connection: Connection, health: MonitorHealth | undefined, retainedMeasurements: boolean, compact?: boolean): readonly string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cesarus777/opencode-cgp",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "exports": {
     ".": {
@@ -38,6 +38,7 @@
     "format:check": "prettier --check src tests scripts docs README.md examples package.json tsconfig.json server.ts tui.tsx rpc.ts tsconfig.build.json .github AGENTS.md",
     "test:tui-live": "bun scripts/tui-live.ts",
     "bench:tui": "bun scripts/tui-bench.ts",
+    "bench:dashboard": "bun scripts/dashboard-bench.ts",
     "build": "bun scripts/build.ts",
     "prepack": "bun run build",
     "prepare": "bun run build",