@cesarus777/opencode-cgp 0.3.1 → 0.4.0

package/dist/rpc.js

@@ -43,6 +43,12 @@ function isHistoryRead(value) {
 function isHistoryResult(value) {
   return valid(value, historyResultSchema);
 }
+function isAnalyticsRead(value) {
+  return valid(value, analyticsReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from < value.to && value.to - value.from <= 604800000 && !(value.model !== undefined && value.unknownModel === true) && (!(value.modelCursor || value.requestCursor) || typeof value.snapshotId === "string");
+}
+function isAnalyticsResult(value) {
+  return valid(value, analyticsResultSchema);
+}
 function record(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -100,7 +106,7 @@ var count, text, enumeration = (...values) => ({ type: "string", enum: values })
   type: "array",
   items,
   maxItems
-}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc;
+}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc, modelSummarySchema, analyticsReadSchema, analyticsResultSchema, analyticsRpc;
 var init_rpc = __esm(() => {
   count = {
     type: "integer",
@@ -336,6 +342,123 @@ var init_rpc = __esm(() => {
     methods: { read: { input: historyReadSchema, output: historyResultSchema } },
     events: {}
   });
+  modelSummarySchema = object({
+    model: text,
+    sessions: count,
+    completedRequests: count,
+    partialRequests: count,
+    legacyAttributionRequests: count,
+    tpsRequests: count,
+    ttftRequests: count,
+    excludedTpsRequests: count,
+    excludedTtftRequests: count,
+    outputTokens: nonnegative,
+    durationMs: nonnegative,
+    averageTps: nonnegative,
+    meanTtftMs: nonnegative,
+    medianTtftMs: nonnegative,
+    p95TtftMs: nonnegative
+  }, [
+    "sessions",
+    "completedRequests",
+    "partialRequests",
+    "legacyAttributionRequests",
+    "tpsRequests",
+    "ttftRequests",
+    "excludedTpsRequests",
+    "excludedTtftRequests",
+    "outputTokens",
+    "durationMs"
+  ]);
+  analyticsReadSchema = object({
+    schemaVersion: { const: 1 },
+    from: count,
+    to: count,
+    buckets: { type: "integer", minimum: 1, maximum: 240 },
+    agent: text,
+    model: text,
+    unknownModel: { type: "boolean" },
+    sort: enumeration("requests", "tps", "ttft", "identity"),
+    snapshotId: text,
+    modelCursor: text,
+    requestCursor: text
+  }, ["schemaVersion", "from", "to", "buckets"]);
+  analyticsResultSchema = object({
+    schemaVersion: { const: 1 },
+    generatedAt: count,
+    expiresAt: count,
+    snapshotId: text,
+    enabled: { type: "boolean" },
+    from: count,
+    to: count,
+    agent: text,
+    models: array(modelSummarySchema, 50),
+    totalModels: count,
+    nextModelsCursor: text,
+    selected: modelSummarySchema,
+    buckets: array(object({ from: nonnegative, to: nonnegative, summary: modelSummarySchema }, ["from", "to"]), 240),
+    requests: array(object({
+      location: text,
+      sessionId: text,
+      requestId: text,
+      startedAt: count,
+      completedAt: count,
+      model: text,
+      agent: text,
+      attribution: enumeration("request", "legacy-record", "unknown"),
+      partial: { type: "boolean" },
+      outputTokens: nonnegative,
+      ttftMs: nonnegative
+    }, [
+      "location",
+      "sessionId",
+      "requestId",
+      "startedAt",
+      "completedAt",
+      "attribution",
+      "partial"
+    ]), 50),
+    nextRequestsCursor: text,
+    coverage: object({
+      source: enumeration("retained-request-records"),
+      scannedRecords: count,
+      unscannedRecords: count,
+      duplicateRecords: count,
+      conflictingRequests: count,
+      missingIdentityRecords: count,
+      incompleteRequests: count,
+      invalidTimingRequests: count,
+      gapRecords: count,
+      maxRequests: count,
+      partial: { type: "boolean" }
+    }),
+    metadata: historyResultSchema.properties.metadata ?? {},
+    gaps: array(count, 128),
+    omittedGaps: count
+  }, [
+    "schemaVersion",
+    "generatedAt",
+    "expiresAt",
+    "snapshotId",
+    "enabled",
+    "from",
+    "to",
+    "models",
+    "totalModels",
+    "buckets",
+    "requests",
+    "coverage",
+    "metadata",
+    "gaps",
+    "omittedGaps"
+  ]);
+  analyticsRpc = Rpc.define({
+    id: "context-guard.analytics.v1",
+    methods: {
+      read: { input: analyticsReadSchema, output: analyticsResultSchema }
+    },
+    events: {}
+  });
 });
 init_rpc();
 
@@ -355,7 +478,11 @@ export {
   isHistoryResult,
   isHistoryRead,
   isBatch,
+  isAnalyticsResult,
+  isAnalyticsRead,
   historyRpc,
   historyReadSchema,
-  batchSchema
+  batchSchema,
+  analyticsRpc,
+  analyticsReadSchema
 };

package/dist/tui.js

@@ -43,6 +43,12 @@ function isHistoryRead(value) {
 function isHistoryResult(value) {
   return valid(value, historyResultSchema);
 }
+function isAnalyticsRead(value) {
+  return valid(value, analyticsReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from < value.to && value.to - value.from <= 604800000 && !(value.model !== undefined && value.unknownModel === true) && (!(value.modelCursor || value.requestCursor) || typeof value.snapshotId === "string");
+}
+function isAnalyticsResult(value) {
+  return valid(value, analyticsResultSchema);
+}
 function record(x) {
   return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -100,7 +106,7 @@ var count, text, enumeration = (...values) => ({ type: "string", enum: values })
   type: "array",
   items,
   maxItems
-}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc;
+}), measurement, row, batchFields, readSchema, batchSchema, resultSchema, monitorRpc, nonnegative, performanceSchema, performanceRow, performanceBatchSchema, performanceResultSchema, performanceRpc, chartPointSchema, chartRequestSchema, historyReadSchema, historyResultSchema, historyRpc, modelSummarySchema, analyticsReadSchema, analyticsResultSchema, analyticsRpc;
 var init_rpc = __esm(() => {
   count = {
     type: "integer",
@@ -336,6 +342,123 @@ var init_rpc = __esm(() => {
     methods: { read: { input: historyReadSchema, output: historyResultSchema } },
     events: {}
   });
+  modelSummarySchema = object({
+    model: text,
+    sessions: count,
+    completedRequests: count,
+    partialRequests: count,
+    legacyAttributionRequests: count,
+    tpsRequests: count,
+    ttftRequests: count,
+    excludedTpsRequests: count,
+    excludedTtftRequests: count,
+    outputTokens: nonnegative,
+    durationMs: nonnegative,
+    averageTps: nonnegative,
+    meanTtftMs: nonnegative,
+    medianTtftMs: nonnegative,
+    p95TtftMs: nonnegative
+  }, [
+    "sessions",
+    "completedRequests",
+    "partialRequests",
+    "legacyAttributionRequests",
+    "tpsRequests",
+    "ttftRequests",
+    "excludedTpsRequests",
+    "excludedTtftRequests",
+    "outputTokens",
+    "durationMs"
+  ]);
+  analyticsReadSchema = object({
+    schemaVersion: { const: 1 },
+    from: count,
+    to: count,
+    buckets: { type: "integer", minimum: 1, maximum: 240 },
+    agent: text,
+    model: text,
+    unknownModel: { type: "boolean" },
+    sort: enumeration("requests", "tps", "ttft", "identity"),
+    snapshotId: text,
+    modelCursor: text,
+    requestCursor: text
+  }, ["schemaVersion", "from", "to", "buckets"]);
+  analyticsResultSchema = object({
+    schemaVersion: { const: 1 },
+    generatedAt: count,
+    expiresAt: count,
+    snapshotId: text,
+    enabled: { type: "boolean" },
+    from: count,
+    to: count,
+    agent: text,
+    models: array(modelSummarySchema, 50),
+    totalModels: count,
+    nextModelsCursor: text,
+    selected: modelSummarySchema,
+    buckets: array(object({ from: nonnegative, to: nonnegative, summary: modelSummarySchema }, ["from", "to"]), 240),
+    requests: array(object({
+      location: text,
+      sessionId: text,
+      requestId: text,
+      startedAt: count,
+      completedAt: count,
+      model: text,
+      agent: text,
+      attribution: enumeration("request", "legacy-record", "unknown"),
+      partial: { type: "boolean" },
+      outputTokens: nonnegative,
+      ttftMs: nonnegative
+    }, [
+      "location",
+      "sessionId",
+      "requestId",
+      "startedAt",
+      "completedAt",
+      "attribution",
+      "partial"
+    ]), 50),
+    nextRequestsCursor: text,
+    coverage: object({
+      source: enumeration("retained-request-records"),
+      scannedRecords: count,
+      unscannedRecords: count,
+      duplicateRecords: count,
+      conflictingRequests: count,
+      missingIdentityRecords: count,
+      incompleteRequests: count,
+      invalidTimingRequests: count,
+      gapRecords: count,
+      maxRequests: count,
+      partial: { type: "boolean" }
+    }),
+    metadata: historyResultSchema.properties.metadata ?? {},
+    gaps: array(count, 128),
+    omittedGaps: count
+  }, [
+    "schemaVersion",
+    "generatedAt",
+    "expiresAt",
+    "snapshotId",
+    "enabled",
+    "from",
+    "to",
+    "models",
+    "totalModels",
+    "buckets",
+    "requests",
+    "coverage",
+    "metadata",
+    "gaps",
+    "omittedGaps"
+  ]);
+  analyticsRpc = Rpc.define({
+    id: "context-guard.analytics.v1",
+    methods: {
+      read: { input: analyticsReadSchema, output: analyticsResultSchema }
+    },
+    events: {}
+  });
 });
 
 // src/family.ts
@@ -834,9 +957,9 @@ var init_format = __esm(() => {
 });
 
 // src/tui/chartformat.ts
-function columns2(points, from, to, width, gaps = []) {
+function columns2(points, from, to, width, gaps = [], halfOpen = false) {
   const size = Math.max(1, Math.min(120, Math.floor(width))), values = Array.from({ length: size });
-  const column = (time) => Math.max(0, Math.min(size - 1, Math.floor((time - from) / Math.max(1, to - from) * (size - 1))));
+  const column = (time) => Math.max(0, Math.min(size - 1, Math.floor((time - from) / Math.max(1, to - from) * (halfOpen ? size : size - 1))));
   let min = Infinity, max = -Infinity;
   for (const point of points) {
     if (point.time < from || point.time > to || point.value === undefined || !Number.isFinite(point.value) || point.value < 0)
@@ -860,12 +983,12 @@ function sparkline(points, from, to, width, gaps = []) {
       chars[column(time)] = "\u2506";
   return { line: chars.join(""), ...min === Infinity ? {} : { min, max } };
 }
-function metricPlot(points, from, to, width, gaps = []) {
+function metricPlot(points, from, to, width, gaps = [], halfOpen = false) {
   const label = (value) => value >= 1e6 ? `${(value / 1e6).toFixed(1)}M` : value >= 1000 ? `${(value / 1000).toFixed(1)}k` : value.toFixed(1);
   const peak = Math.max(0, ...points.filter((p) => p.time >= from && p.time <= to && Number.isFinite(p.value)).map((p) => p.value ?? 0));
   const scale = Math.max(1, peak);
   const gutter = width >= 20 ? Math.max(label(scale).length, 3) : 0;
-  const { values, column } = columns2(points, from, to, Math.max(1, width - gutter - 2), gaps);
+  const { values, column } = columns2(points, from, to, Math.max(1, halfOpen ? Math.min(points.length, width - gutter - 2) : width - gutter - 2), gaps, halfOpen);
   const gapColumns = new Set(gaps.filter((time) => time >= from && time <= to).map(column));
   const height = 6;
   const blocks = " \u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";

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;
@@ -32,6 +33,7 @@ export declare class DashboardController {
     private refreshTimer;
     private ageTimer;
     private view;
+    readonly models: ModelsController;
     constructor(port: DashboardPort, options?: DashboardControllerOptions);
     private createLocation;
     getView(): DashboardView;
@@ -44,6 +46,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,6 +15,11 @@ 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;

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

@@ -3,12 +3,13 @@ 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;
@@ -72,6 +73,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cesarus777/opencode-cgp",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "exports": {
     ".": {