@cesarus777/opencode-cgp 0.3.1 → 0.4.1

package/dist/types/adapter.d.ts

@@ -1,10 +1,12 @@
 import { type HistoryRpcPort } from "./historyserver.js";
+import { type AnalyticsRpcPort } from "./modelanalyticsserver.js";
 import { type SnapshotRpcPort } from "./snapshotserver.js";
 import type { Plugin } from "@opencode/plugin";
 import type { TelemetrySink } from "./types.js";
 export interface Host {
     rpc?: SnapshotRpcPort;
     historyRpc?: HistoryRpcPort;
+    analyticsRpc?: AnalyticsRpcPort;
     app: {
         version: string;
     };

package/dist/types/core.d.ts

@@ -9,3 +9,4 @@ export * from "./family.js";
 export * from "./performance.js";
 export * from "./charts.js";
 export * from "./modelanalytics.js";
+export * from "./modelseries.js";

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

@@ -1,5 +1,5 @@
 import type { DashboardConnectionOptions } from "./connection.js";
-export declare const dashboardHelp = "Usage: context-guard dashboard tui [options]\nOpen a read-only live terminal dashboard for an existing OpenCode server.\n\nStart here\n  1. Keep an OpenCode server running with Context Guard registered.\n  2. Close OpenCode's native TUI before opening the standalone dashboard.\n  3. In the owning project directory, run: context-guard dashboard tui\n\nOptions\n  --directory PATH   Owning project directory (local default: current directory)\n  --server URL       Connect to an explicit server; requires --directory with\n                     an absolute server-side project path. Use HTTPS except\n                     on loopback. Credentials in URLs are rejected.\n  -h, --help         Show this help\n\nExamples\n  context-guard dashboard tui\n  context-guard dashboard tui --directory /absolute/project\n  context-guard dashboard tui --server https://server.example --directory /server/project\n\nRequirements\n  Interactive terminal and Bun >=1.3.0. The OpenTUI renderer is installed\n  automatically with CGP. This command never starts a server.\n\nAuthentication (explicit servers)\n  CONTEXT_GUARD_PASSWORD   Server password\n  CONTEXT_GUARD_USERNAME   Server username (default: opencode)\n\nKeys\n  1/2/3 overview/detail/history; arrows or j/k move; / search; f filters;\n  l location; w history window; r refresh; ? help; q or Ctrl+C quit.";
+export declare const dashboardHelp = "Usage: context-guard dashboard tui [options]\nOpen a read-only live terminal dashboard for an existing OpenCode server.\n\nStart here\n  1. Keep an OpenCode server running with Context Guard registered.\n  2. Open a separate terminal tab, window or pane for the dashboard.\n  3. In the same project directory, run: context-guard dashboard tui\n  Keep working in OpenCode; the dashboard reads live updates from its server.\n\nOptions\n  --directory PATH   Owning project directory (local default: current directory)\n  --server URL       Connect to an explicit server; requires --directory with\n                     an absolute server-side project path. Use HTTPS except\n                     on loopback. Credentials in URLs are rejected.\n  -h, --help         Show this help\n\nExamples\n  context-guard dashboard tui\n  context-guard dashboard tui --directory /absolute/project\n  context-guard dashboard tui --server https://server.example --directory /server/project\n\nRequirements\n  Interactive terminal and Bun >=1.3.0. The OpenTUI renderer is installed\n  automatically with CGP. This command never starts a server.\n\nAuthentication (explicit servers)\n  CONTEXT_GUARD_PASSWORD   Server password\n  CONTEXT_GUARD_USERNAME   Server username (default: opencode)\n\nKeys\n  1/2/3/4 overview/detail/history/models; arrows or j/k move; Enter detail/chart;\n  Models: Left/Right metric, [/] bucket, d requests, n/p pages, s sort;\n  / session search; f filters (Models: agent); l location; w time window;\n  r refresh; ? help; q or Ctrl+C quit.";
 export declare function parseDashboardArgs(args: readonly string[], cwd: string, env: Readonly<Record<string, string | undefined>>): DashboardConnectionOptions | "help";
 export declare function checkTerminalRuntime(version: string, interactive: boolean): void;
 export declare function loadTerminalRenderer(): Promise<typeof import("@opentui/core")>;

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

@@ -2,6 +2,7 @@ import { Service } from "@opencode/client/service";
 import type { HistoryChartRead } from "../historycharts.js";
 import type { SnapshotTransport } from "../tui/transport.js";
 import type { DashboardPort, SessionPageInput } from "./port.js";
+import type { AnalyticsRead } from "../modelseries.js";
 export interface DashboardConnectionOptions {
     readonly directory: string;
     readonly server?: string;
@@ -32,5 +33,6 @@ export declare function connectDashboard(options: DashboardConnectionOptions, di
         readonly transport: SnapshotTransport;
     }>;
     history(input: HistoryChartRead, signal: AbortSignal): Promise<import("../historycharts.js").HistoryChartResult>;
+    analytics?(input: AnalyticsRead, signal: AbortSignal): Promise<import("../modelseries.js").AnalyticsResult>;
 }>;
 export type DashboardConnection = Awaited<ReturnType<typeof connectDashboard>>;

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

@@ -1,5 +1,6 @@
 import { type InventoryLimits } from "./inventory.js";
 import type { DashboardPort } from "./port.js";
+import { ModelsController } from "./models.js";
 import { type DashboardView, type DashboardScreen, type DashboardFilters, type HistoryWindow } from "./view.js";
 export interface DashboardControllerOptions {
     readonly limits?: InventoryLimits;
@@ -28,10 +29,12 @@ export declare class DashboardController {
     private pendingHistory;
     private historyAbort;
     private historyBusy;
+    private historyReason;
     private historyStatus;
     private refreshTimer;
     private ageTimer;
     private view;
+    readonly models: ModelsController;
     constructor(port: DashboardPort, options?: DashboardControllerOptions);
     private createLocation;
     getView(): DashboardView;
@@ -44,6 +47,7 @@ export declare class DashboardController {
     setScreen(screen: DashboardScreen): void;
     setWindow(windowMs: HistoryWindow): void;
     setFilters(filters: Partial<DashboardFilters>): void;
+    private configureModels;
     refresh(): Promise<void>;
     private current;
     private scan;

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

@@ -0,0 +1,42 @@
+import type { AnalyticsRead, AnalyticsResult } from "../modelseries.js";
+import { type DashboardPort } from "./port.js";
+import type { HistoryWindow } from "./view.js";
+export interface DashboardModels {
+    status: "idle" | "loading" | "ready" | "disabled" | "unsupported" | "unavailable";
+    stale: boolean;
+    sort: NonNullable<AnalyticsRead["sort"]>;
+    windowMs: HistoryWindow;
+    modelPage: number;
+    requestPage: number;
+    result?: AnalyticsResult;
+}
+/** Location-scoped request state; it never opens a monitor/event subscription. */
+export declare class ModelsController {
+    private readonly changed;
+    private port;
+    private active;
+    private key;
+    private agent;
+    private seedModel;
+    private selection;
+    private resolution;
+    private from;
+    private to;
+    private generation;
+    private abort;
+    private pending;
+    private modelPages;
+    private requestPages;
+    private state;
+    constructor(changed: () => void);
+    getView(): DashboardModels;
+    configure(port: DashboardPort, active: boolean, windowMs: HistoryWindow, agent: string, seedModel: string, now: number): void;
+    cancel(): void;
+    stop(): void;
+    refresh(now: number): Promise<void>;
+    setWidth(width: number): void;
+    select(model: string): void;
+    sort(): void;
+    page(kind: "models" | "requests", direction: -1 | 1): void;
+    private query;
+}

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

@@ -0,0 +1,30 @@
+import type { ModelSummary } from "../modelanalytics.js";
+import type { DashboardView } from "./view.js";
+export declare const modelMetrics: readonly [{
+    readonly key: "averageTps";
+    readonly label: "Weighted request TPS";
+    readonly unit: "t/s";
+    readonly divisor: 1;
+}, {
+    readonly key: "medianTtftMs";
+    readonly label: "TTFT median ~";
+    readonly unit: "s";
+    readonly divisor: 1000;
+}, {
+    readonly key: "p95TtftMs";
+    readonly label: "TTFT p95 ~";
+    readonly unit: "s";
+    readonly divisor: 1000;
+}, {
+    readonly key: "completedRequests";
+    readonly label: "Completed requests";
+    readonly unit: "requests";
+    readonly divisor: 1;
+}, {
+    readonly key: "outputTokens";
+    readonly label: "Reported output";
+    readonly unit: "tokens";
+    readonly divisor: 1;
+}];
+export declare function terminalModelRow(model: Readonly<ModelSummary>, focused: boolean): string[];
+export declare function terminalModels(view: DashboardView, width: number, detail: boolean, metricIndex: number, sample: number, focus: number, requests: boolean): string[];

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

@@ -1,6 +1,11 @@
 import type { ExecutionStatus } from "../family.js";
 import type { HistoryChartRead, HistoryChartResult } from "../historycharts.js";
 import type { SnapshotTransport } from "../tui/transport.js";
+import type { AnalyticsRead, AnalyticsResult } from "../modelseries.js";
+export declare class AnalyticsUnavailable extends Error {
+    readonly reason: "unsupported" | "unavailable";
+    constructor(reason: "unsupported" | "unavailable");
+}
 /** The inventory boundary deliberately excludes titles, metadata, and content. */
 export interface DashboardSession {
     readonly sessionId: string;
@@ -34,6 +39,7 @@ export interface DashboardPort {
         readonly transport: SnapshotTransport;
     }>;
     history(input: HistoryChartRead, signal: AbortSignal): Promise<HistoryChartResult>;
+    analytics?(input: AnalyticsRead, signal: AbortSignal): Promise<AnalyticsResult>;
 }
 export interface InventoryNode extends DashboardSession {
     readonly status: ExecutionStatus;

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

@@ -15,11 +15,18 @@ export declare class TerminalShell {
     scroll: number;
     metric: number;
     sample: number;
+    modelDetail: boolean;
+    modelRequests: boolean;
+    modelFocus: number;
+    private modelFocusId;
+    private modelViewport;
     help: boolean;
     editor: Editor | undefined;
     input: string;
     notice: string;
     private rowOffset;
+    private overviewScope;
+    private overviewPage;
     private historyIdentity;
     constructor(controller: DashboardController, quit: () => void);
     private task;

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

@@ -1,5 +1,10 @@
 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[];
+/** 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 +16,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,14 +1,16 @@
+import type { HistoryFailureReason } from "../historyclient.js";
 import type { GuardRow } from "../family.js";
 import type { MonitorHealth } from "../snapshot.js";
 import type { HistoryChartResult } from "../historycharts.js";
 import type { Connection } from "../tui/transport.js";
 import type { InventoryNotice } from "./inventory.js";
+import type { DashboardModels } from "./models.js";
 export type Immutable<T> = T extends object ? {
     readonly [K in keyof T]: Immutable<T[K]>;
 } : T;
 export declare const historyWindows: readonly [300000, 3600000, 86400000, 604800000];
 export type HistoryWindow = (typeof historyWindows)[number];
-export type DashboardScreen = "overview" | "detail" | "history";
+export type DashboardScreen = "overview" | "detail" | "history" | "models";
 export interface DashboardFilters {
     readonly search: string;
     readonly agent: string;
@@ -31,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;
@@ -72,6 +76,7 @@ export type DashboardView = Immutable<{
     selectedSessionId?: string;
     selected?: DashboardRow;
     history: DashboardHistory;
+    models: DashboardModels;
     notices: readonly string[];
 }>;
 /** Clone before freezing so transport-owned objects never become UI-owned state. */

package/dist/types/history.d.ts

@@ -38,6 +38,7 @@ export declare class PerformanceHistory {
 }
 export declare function scalarPerformance(p: PerformanceSnapshot): PerformanceSnapshot;
 export interface HistoryFilter {
+    signal?: AbortSignal;
     sessionId?: string;
     agent?: string;
     model?: string;

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/modelanalytics.d.ts

@@ -57,4 +57,12 @@ export interface ModelAnalyticsResult {
     };
 }
 /** Aggregate raw request records before any chart downsampling or session limits. */
+export declare function analyzeModelRequests(records: readonly HistoryRecord[], options: ModelAnalyticsOptions): 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 aggregateModels(records: readonly HistoryRecord[], options: ModelAnalyticsOptions): ModelAnalyticsResult;

package/dist/types/modelanalyticsserver.d.ts

@@ -0,0 +1,16 @@
+import type { RpcHandlers, RpcRegistration } from "@opencode/plugin/promise/rpc";
+import { readPerformanceHistory } from "./history.js";
+import { type AnalyticsRead, type AnalyticsResult } from "./modelseries.js";
+import { analyticsRpc } from "./rpc.js";
+export interface AnalyticsRpcPort {
+    register(definition: typeof analyticsRpc, handlers: RpcHandlers<typeof analyticsRpc>): Promise<Pick<RpcRegistration<typeof analyticsRpc>, "dispose">>;
+}
+/** One instance owns exactly one server-selected location/archive; no client paths. */
+export declare function createAnalyticsService(path: string, location: string, enabled: boolean, options?: {
+    now?: () => number;
+    read?: typeof readPerformanceHistory;
+}): {
+    read(input: AnalyticsRead, signal: AbortSignal): Promise<AnalyticsResult>;
+    dispose(): void;
+};
+export declare function serveModelAnalytics(port: AnalyticsRpcPort | undefined, path: string, location: string, enabled: boolean): Promise<() => void>;

package/dist/types/modelseries.d.ts

@@ -0,0 +1,43 @@
+import { type CompletedAnalyticsRequest, type ModelAnalyticsResult, type ModelSummary } from "./modelanalytics.js";
+import type { HistoryMetadata } from "./history.js";
+export interface ModelBucket {
+    from: number;
+    to: number;
+    summary?: ModelSummary;
+}
+export interface AnalyticsRead {
+    schemaVersion: 1;
+    from: number;
+    to: number;
+    buckets: number;
+    agent?: string;
+    model?: string;
+    unknownModel?: boolean;
+    sort?: "requests" | "tps" | "ttft" | "identity";
+    snapshotId?: string;
+    modelCursor?: string;
+    requestCursor?: string;
+}
+export interface AnalyticsResult {
+    schemaVersion: 1;
+    generatedAt: number;
+    expiresAt: number;
+    snapshotId: string;
+    enabled: boolean;
+    from: number;
+    to: number;
+    agent?: string;
+    models: ModelSummary[];
+    totalModels: number;
+    nextModelsCursor?: string;
+    selected?: ModelSummary;
+    buckets: ModelBucket[];
+    requests: CompletedAnalyticsRequest[];
+    nextRequestsCursor?: string;
+    coverage: ModelAnalyticsResult["coverage"];
+    metadata: HistoryMetadata;
+    gaps: number[];
+    omittedGaps: number;
+}
+/** Requests belong to half-open completion buckets; rates never average rates. */
+export declare function bucketModelRequests(requests: readonly CompletedAnalyticsRequest[], from: number, to: number, count: number): ModelBucket[];

package/dist/types/rpc.d.ts

@@ -124,6 +124,34 @@ export declare const historyRpc: {
 };
 export declare function isHistoryRead(value: unknown): value is import("./historycharts.js").HistoryChartRead;
 export declare function isHistoryResult(value: unknown): value is import("./historycharts.js").HistoryChartResult;
+export declare const analyticsReadSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const analyticsRpc: {
+    readonly id: "context-guard.analytics.v1";
+    readonly methods: {
+        readonly read: {
+            readonly input: {
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: boolean;
+            };
+            readonly output: {
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+    readonly events: {};
+};
+export declare function isAnalyticsRead(value: unknown): value is import("./modelseries.js").AnalyticsRead;
+export declare function isAnalyticsResult(value: unknown): value is import("./modelseries.js").AnalyticsResult;
 export declare function isRead(value: unknown): value is SnapshotRead;
 export declare function isBatch(value: unknown): value is SnapshotBatch;
 export declare function isResult(value: unknown): value is SnapshotReadResult;

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

@@ -42,5 +42,5 @@ export declare const chartMetrics: readonly [{
 export declare function metricPlot(points: readonly {
     time: number;
     value?: number;
-}[], from: number, to: number, width: number, gaps?: readonly number[]): string[];
+}[], from: number, to: number, width: number, gaps?: readonly number[], halfOpen?: boolean): string[];
 export declare function historyChartLines(result: HistoryChartResult, width: number, from: number, to: number, metricIndex?: number): string[];

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.3.1",
+  "version": "0.4.1",
   "type": "module",
   "exports": {
     ".": {