@cesarus777/opencode-cgp 0.4.1 → 0.4.3

package/dist/tui.js

@@ -1178,7 +1178,7 @@ function performanceLines(row2, width) {
     return [];
   const value = (n) => n === undefined ? "?" : n.toFixed(1);
   return [
-    ...wrap(`TPS ${p.status === "waiting" ? "waiting" : `${p.status === "streaming" ? "~" : ""}${value(p.liveTps)}`} \xB7 ${p.status}${p.partial ? " \xB7 partial" : ""}`, width),
+    ...wrap(`Live TPS ${p.status === "waiting" ? "waiting" : `${p.status === "streaming" ? "~" : ""}${value(p.liveTps)}`} \xB7 ${p.status}${p.partial ? " \xB7 partial" : ""}`, width),
     ...wrap(`Avg model ${value(p.averageModelTps)} \xB7 Avg session ${value(p.averageSessionTps)}`, width),
     ...wrap(`TTFT ${p.ttftMs === undefined ? "?" : `~${(p.ttftMs / 1000).toFixed(2)}s`}${p.latestRequestTps === undefined ? "" : ` \xB7 Last ${value(p.latestRequestTps)} t/s`}`, width)
   ];
@@ -1242,6 +1242,7 @@ function panelRowLines(row2, width, selected) {
     `${pad(identity, Math.max(1, width - status.length - 1))} ${status}`,
     clip(`${percent} context \xB7 ${distance}`, width)
   ];
+  lines.push(...performanceLines(row2, width));
   const exception = [
     freshnessLabel(row2),
     compactionLabel(row2),
@@ -2010,6 +2011,7 @@ function mainSections(row2, width, age) {
       lines: columns(row2.freshness === "stale" ? "Last measured" : "Context", `${m?.confidence === "approximate" && valid2 ? "~" : ""}${tokens(measured)} / ${tokens(s?.capacityTokens)}`, width)
     },
     { tone: "measurement", lines: [progress(ratio, width)] },
+    { tone: "base", lines: performanceLines(row2, width) },
     {
       tone: "pressure",
       lines: [
@@ -2070,7 +2072,9 @@ function agentLines(row2, width) {
   const short = `${row2.freshness === "stale" ? "Last measured" : "Ctx"} ${estimate}${percent} \xB7 ${pressure === "Below threshold" ? "Threshold below" : pressure}`;
   const lifecycle = compactionLabel(row2);
   return [
+    progress(valid2 && row2.utilizationPercent !== undefined ? row2.utilizationPercent / 100 : undefined, width),
     ...wrap(cells(full) <= width ? full : short, width),
+    ...performanceLines(row2, width),
     ...row2.node.status === "failed" || row2.node.status === "unknown" ? wrap(row2.node.status.toUpperCase(), width) : [],
     ...row2.freshness !== "fresh" ? wrap(freshnessLabel(row2) ?? "", width) : [],
     ...row2.node.interrupted ? wrap("Interrupted", width) : [],
@@ -2184,12 +2188,12 @@ function CompactSidebar(props) {
   const width = () => Math.max(1, Math.min(props.width, measuredWidth()) - 4);
   const [collapsed, setCollapsed] = createSignal2(new Set);
   const [hideCompleted, setHideCompleted] = createSignal2(true);
-  const [showHistory, setShowHistory] = createSignal2(false);
+  const [showHistory, setShowHistory] = createSignal2(true);
   const [byPressure, setByPressure] = createSignal2(true);
   createEffect(() => {
     props.sessionID;
     setCollapsed(new Set);
-    setShowHistory(false);
+    setShowHistory(true);
   });
   const current = createMemo(() => props.rows.find((r) => r.node.sessionId === props.sessionID));
   const trace = createMemo(() => props.state.contextTrace(current()));

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;

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;
@@ -27,6 +30,9 @@ export declare class TerminalShell {
     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

@@ -3,6 +3,8 @@ 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"];

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

@@ -79,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cesarus777/opencode-cgp",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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",