@cesarus777/opencode-cgp 0.1.0 → 0.2.1

package/dist/types/adapter.d.ts

@@ -1,8 +1,10 @@
+import { type HistoryRpcPort } from "./historyserver.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;
     app: {
         version: string;
     };

package/dist/types/chartreport.d.ts

@@ -0,0 +1,14 @@
+import type { ChartData } from "./charts.js";
+import type { readPerformanceHistory } from "./history.js";
+type ReportMetadata = Awaited<ReturnType<typeof readPerformanceHistory>>["metadata"];
+interface ChartReport {
+    data: ChartData;
+    metadata: ReportMetadata;
+    agent?: string;
+    model?: string;
+    from?: number;
+    to?: number;
+}
+/** Offline, self-contained SVG report. Generated identities only enter text nodes or escaped JSON. */
+export declare function renderChartReport(report: ChartReport): string;
+export {};

package/dist/types/charts.d.ts

@@ -0,0 +1,54 @@
+import type { HistoryRecord } from "./history.js";
+export interface ChartPoint {
+    time: number;
+    agent?: string;
+    model?: string;
+    breakBefore: boolean;
+    partial: boolean;
+    liveTps?: number;
+    averageModelTps?: number;
+    averageSessionTps?: number;
+    sessionOutputTokens?: number;
+}
+export interface ChartRequest {
+    time: number;
+    requestId: string;
+    started: number;
+    agent?: string;
+    model?: string;
+    ttftMs?: number;
+    outputTokens?: number;
+    durationMs?: number;
+    tps?: number;
+    partial: boolean;
+}
+export interface ChartSeries {
+    sessionId: string;
+    parentId?: string;
+    agents: string[];
+    models: string[];
+    points: ChartPoint[];
+    requests: ChartRequest[];
+    originalPoints: number;
+}
+export interface ChartGap {
+    time: number;
+    sessionId: string;
+    reason: string;
+}
+export interface ChartData {
+    schema: 1;
+    series: ChartSeries[];
+    gaps: ChartGap[];
+    omittedSessions: number;
+    omittedGaps?: number;
+    maxPoints: number;
+}
+export interface ChartOptions {
+    sessionId?: string;
+    maxPoints?: number;
+    maxSessions?: number;
+}
+/** Preserve actual timestamps and extrema; never average a bucket's rates or bridge a gap. */
+export declare function downsamplePoints(points: readonly ChartPoint[], limit: number): ChartPoint[];
+export declare function buildChartData(records: readonly HistoryRecord[], options?: ChartOptions): ChartData;

package/dist/types/core.d.ts

@@ -6,3 +6,5 @@ export * from "./scheduler.js";
 export * from "./estimate.js";
 export * from "./snapshot.js";
 export * from "./family.js";
+export * from "./performance.js";
+export * from "./charts.js";

package/dist/types/family.d.ts

@@ -24,7 +24,7 @@ export declare function metric(snapshot: ContextSnapshot | undefined, now: numbe
     readonly triggerDeltaTokens?: number;
     readonly utilizationPercent?: number;
     readonly pressureRatio?: number;
-    readonly freshness: "fresh" | "stale" | "missing" | "invalid";
+    readonly freshness: "invalid" | "fresh" | "stale" | "missing";
     readonly pressure: "unknown" | "crossed" | "normal" | "near";
 };
 export declare function familyRows(nodes: readonly SessionNode[], snapshots: ReadonlyMap<string, ContextSnapshot>, current: string, now: number, staleMs: number, expanded?: ReadonlySet<string>, limit?: number, timing?: (id: string) => {

package/dist/types/history.d.ts

@@ -0,0 +1,59 @@
+import type { Identity, Config } from "./types.js";
+import type { PerformanceSnapshot } from "./performance.js";
+export interface HistoryRecord extends Identity {
+    schema: 1;
+    recordId: string;
+    time: number;
+    type: "sample" | "request" | "lifecycle" | "gap" | "terminal";
+    performance?: PerformanceSnapshot;
+    event?: string;
+    droppedRecords?: 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 pending;
+    private working;
+    private active;
+    private bytes;
+    private started;
+    private disabled;
+    private dropped;
+    private droppedTotal;
+    constructor(path: string, config: Config["history"], now?: () => number, report?: (event: string) => void);
+    emit(record: HistoryRecord): void;
+    private kick;
+    private prune;
+    private gapLine;
+    private drain;
+    health(): {
+        unavailable: boolean;
+        droppedRecords: number;
+    };
+    flush(): Promise<void>;
+    initialize(): Promise<void>;
+}
+export declare function scalarPerformance(p: PerformanceSnapshot): PerformanceSnapshot;
+export interface HistoryFilter {
+    sessionId?: string;
+    agent?: string;
+    model?: string;
+    from?: number;
+    to?: number;
+    maxBytes?: number;
+}
+export interface HistoryMetadata {
+    schema: number;
+    retainedFrom?: number;
+    retainedBytes: number;
+    skippedBytes: number;
+    malformedRecords: number;
+    completeness: string;
+}
+export declare function readPerformanceHistory(directory: string, filter?: HistoryFilter): Promise<{
+    metadata: HistoryMetadata;
+    records: HistoryRecord[];
+}>;

package/dist/types/historycharts.d.ts

@@ -0,0 +1,17 @@
+import type { ChartData } from "./charts.js";
+import type { readPerformanceHistory } from "./history.js";
+export interface HistoryChartRead {
+    schemaVersion: 1;
+    sessionId: string;
+    from: number;
+    to: number;
+    maxPoints: number;
+}
+export interface HistoryChartResult {
+    schemaVersion: 1;
+    generatedAt: number;
+    enabled: boolean;
+    truncated: boolean;
+    metadata: Awaited<ReturnType<typeof readPerformanceHistory>>["metadata"];
+    data: ChartData;
+}

package/dist/types/historyserver.d.ts

@@ -0,0 +1,7 @@
+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>;

package/dist/types/performance.d.ts

@@ -0,0 +1,57 @@
+import type { Tokens } from "./types.js";
+export interface PerformanceSnapshot {
+    readonly sessionCreatedAt: number;
+    readonly sessionOutputTokens?: number;
+    readonly observedSince: number;
+    readonly at: number;
+    readonly status: "waiting" | "streaming" | "idle" | "unavailable";
+    readonly partial: boolean;
+    readonly liveTps?: number;
+    readonly averageModelTps?: number;
+    readonly averageSessionTps?: number;
+    readonly ttftMs?: number;
+    readonly latestRequestTps?: number;
+    readonly requestId?: string;
+    readonly requestAgent?: string;
+    readonly requestModel?: string;
+    readonly requestOutputTokens?: number;
+    readonly requestStartedAt?: number;
+    readonly firstOutputAt?: number;
+    readonly streamEndedAt?: number;
+    readonly estimatedOutputTokens: number;
+    readonly modelOutputTokens: number;
+    readonly modelDurationMs: number;
+    readonly completedRequests: number;
+    readonly tokenSource: "estimated" | "reported" | "unavailable";
+}
+export interface PerformanceCheckpoint {
+    sessionId: string;
+    observedSince: number;
+    created: number;
+    output: number;
+    duration: number;
+    completed: number;
+    sequence: number;
+}
+export declare function outputTokens(tokens: Pick<Tokens, "output" | "reasoning">): number | undefined;
+/** Scalar-only collection. No harness types or generated content are retained. */
+export declare class PerformanceTracker {
+    private readonly maxSessions;
+    private readonly windowMs;
+    private readonly now;
+    private rows;
+    constructor(maxSessions: number, windowMs?: number, now?: () => number);
+    observe(id: string, created: number, cumulative: number | undefined): void;
+    accept(id: string, sequence: number): boolean;
+    start(id: string, requestId: string, agent: string, model: string, started: number): void;
+    delta(id: string, requestId: string, eventId: string, at: number, characters: number): void;
+    streamed(id: string, requestId: string, at: number): void;
+    settle(id: string, requestId: string, tokens: number | undefined): void;
+    gap(id?: string): void;
+    private prune;
+    snapshot(id: string): PerformanceSnapshot | undefined;
+    checkpoint(): PerformanceCheckpoint[];
+    restore(value: unknown): void;
+    remove(id: string): void;
+    ids(): MapIterator<string>;
+}

package/dist/types/rpc.d.ts

@@ -46,6 +46,84 @@ export declare const monitorRpc: {
         };
     };
 };
+export declare const performanceSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const performanceBatchSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const performanceResultSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const performanceRpc: {
+    readonly id: "context-guard.monitor.v2";
+    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: {
+        readonly changed: {
+            readonly schema: {
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+};
+export declare function isPerformanceBatch(value: unknown): value is SnapshotBatch;
+export declare function isPerformanceResult(value: unknown): value is SnapshotReadResult;
+export declare function isPerformanceSnapshot(value: unknown): value is import("./performance.js").PerformanceSnapshot;
+export declare const historyReadSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const historyRpc: {
+    readonly id: "context-guard.history.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 isHistoryRead(value: unknown): value is import("./historycharts.js").HistoryChartRead;
+export declare function isHistoryResult(value: unknown): value is import("./historycharts.js").HistoryChartResult;
 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/snapshot.d.ts

@@ -1,5 +1,7 @@
+import type { PerformanceSnapshot } from "./performance.js";
 import type { Config, SessionState, Measurement, ModelLimits, Threshold, Tokens, CompactionPhase } from "./types.js";
 export interface ContextSnapshot {
+    readonly performance?: PerformanceSnapshot;
     readonly sessionId: string;
     readonly revision: number;
     readonly observedAt: number;
@@ -72,6 +74,7 @@ export declare class SnapshotStore {
     private readonly config;
     private readonly sessions;
     private readonly now;
+    private readonly performanceSnapshot?;
     readonly epoch: string;
     private sequence;
     private revision;
@@ -81,7 +84,7 @@ export declare class SnapshotStore {
     private listeners;
     private healthKey;
     private reasons;
-    constructor(config: Config, sessions: () => ReadonlyMap<string, SessionState>, now?: () => number, epoch?: string);
+    constructor(config: Config, sessions: () => ReadonlyMap<string, SessionState>, now?: () => number, epoch?: string, performanceSnapshot?: ((id: string) => PerformanceSnapshot | undefined) | undefined);
     health(): MonitorHealth;
     degrade(reason: "event-stream-gap" | "persistence-unavailable" | "capacity-exceeded" | "model-metadata-unavailable"): void;
     recover(reason: "capacity-exceeded" | "model-metadata-unavailable"): void;

package/dist/types/snapshotserver.d.ts

@@ -1,7 +1,7 @@
 import type { RpcHandlers, RpcRegistration } from "@opencode/plugin/promise/rpc";
 export interface SnapshotRpcPort {
-    register(definition: typeof monitorRpc, handlers: RpcHandlers<typeof monitorRpc>): Promise<RpcRegistration<typeof monitorRpc>>;
+    register(definition: typeof monitorRpc | typeof performanceRpc, handlers: RpcHandlers<typeof monitorRpc>): Promise<RpcRegistration<typeof monitorRpc>>;
 }
-import { monitorRpc } from "./rpc.js";
+import { monitorRpc, performanceRpc } from "./rpc.js";
 import type { SnapshotStore } from "./snapshot.js";
-export declare function serveSnapshots(rpc: SnapshotRpcPort | undefined, store: SnapshotStore): Promise<() => void>;
+export declare function serveSnapshots(rpc: SnapshotRpcPort | undefined, store: SnapshotStore, performance?: boolean): Promise<() => void>;

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

@@ -0,0 +1,11 @@
+import type { HistoryChartResult } from "../historycharts.js";
+/** Each cell contains an observed peak, never an interpolated or invented zero. */
+export declare function sparkline(points: readonly {
+    time: number;
+    value?: number;
+}[], from: number, to: number, width: number, gaps?: readonly number[]): {
+    line: string;
+    min?: number;
+    max?: number;
+};
+export declare function historyChartLines(result: HistoryChartResult, width: number, from: number, to: number): string[];

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

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

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

@@ -5,3 +5,4 @@ export declare function clip(value: string, width: number): string;
 export declare function rowLines(row: GuardRow, width: number): string[];
 export declare function detailLines(row: GuardRow | undefined, width: number, expanded?: boolean, ageMs?: number): string[];
 export declare function wrap(value: string, width: number): string[];
+export declare function performanceLines(row: GuardRow, width: number): string[];

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

@@ -5,6 +5,7 @@ export declare function createGuardState(context: Plugin.Context): {
         update(next: string): void;
         release(): void;
     };
+    history(id: string, from: number, to: number, signal: AbortSignal): Promise<import("../historycharts.js").HistoryChartResult>;
     rows: (stableOrder?: readonly string[], allDescendants?: boolean) => import("../family.js").GuardRow[];
     dispose: () => void;
     age(id: string): number;

package/dist/types/types.d.ts

@@ -28,6 +28,17 @@ export interface Config {
         sessionTtlMs: number;
         outputReserveTokens?: number;
     };
+    metrics: {
+        enabled: boolean;
+        sampleIntervalMs: number;
+        rollingWindowMs: number;
+    };
+    history: {
+        enabled: boolean;
+        retentionDays: number;
+        maxBytes: number;
+        path?: string;
+    };
     telemetry: {
         enabled: boolean;
         jsonl: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cesarus777/opencode-cgp",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "exports": {
     ".": {
@@ -42,7 +42,10 @@
     "prepack": "bun run build",
     "prepare": "bun run build",
     "test:package": "bun scripts/package-smoke.ts",
-    "validate": "bun run format:check && bun run typecheck && bun test && bun run test:package"
+    "validate": "bun run format:check && bun run typecheck && bun test && bun run test:package",
+    "test:metrics-live": "bun scripts/metrics-live.ts",
+    "charts": "bun src/cli.ts charts",
+    "test:metrics-server-live": "bun scripts/metrics-server-live.ts"
   },
   "dependencies": {
     "@opencode/plugin": "2.0.29",
@@ -102,5 +105,8 @@
     "dist",
     "LICENSE",
     "README.md"
-  ]
+  ],
+  "bin": {
+    "context-guard": "./dist/cli.js"
+  }
 }