@cesarus777/opencode-cgp 0.0.0-stage → 0.2.1

package/dist/types/adapter.d.ts

@@ -0,0 +1,20 @@
+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;
+    };
+    options: unknown;
+    location: {
+        directory: string;
+    };
+    session: Pick<Plugin.Context["session"], "get" | "compact" | "hook">;
+    model: Pick<Plugin.Context["model"], "list">;
+    event: Plugin.Context["event"];
+    storage: Pick<Plugin.Context["storage"], "get" | "set">;
+}
+export declare function setup(ctx: Host, injectedSink?: TelemetrySink): Promise<() => Promise<void>>;

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

@@ -0,0 +1,2 @@
+import type { Config } from "./types.js";
+export declare function parseConfig(value?: unknown): Config;

package/dist/types/core.d.ts

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./policy.js";
+export * from "./monitor.js";
+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/estimate.d.ts

@@ -0,0 +1 @@
+export declare function estimate(value: unknown, maxChars?: number): number | undefined;

package/dist/types/family.d.ts

@@ -0,0 +1,39 @@
+import type { ContextSnapshot } from "./snapshot.js";
+export type ExecutionStatus = "running" | "idle" | "completed" | "failed" | "unknown";
+export interface SessionNode {
+    readonly sessionId: string;
+    readonly parentId?: string;
+    readonly agent?: string;
+    readonly model?: string;
+    readonly status: ExecutionStatus;
+    readonly interrupted?: boolean;
+}
+export interface GuardRow {
+    readonly node: SessionNode;
+    readonly snapshot?: ContextSnapshot;
+    readonly depth: number;
+    readonly current: boolean;
+    readonly freshness: "fresh" | "stale" | "missing" | "invalid";
+    readonly pressure: "normal" | "near" | "crossed" | "unknown";
+    readonly pressureRatio?: number;
+    readonly utilizationPercent?: number;
+    readonly triggerDeltaTokens?: number;
+    readonly hidden: number;
+}
+export declare function metric(snapshot: ContextSnapshot | undefined, now: number, staleMs: number): {
+    readonly triggerDeltaTokens?: number;
+    readonly utilizationPercent?: number;
+    readonly pressureRatio?: number;
+    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) => {
+    now: number;
+    staleMs: number;
+}, stableOrder?: readonly string[]): GuardRow[];
+export interface ExecutionEvidence {
+    readonly startedAt?: number;
+    readonly terminalAt?: number;
+    readonly outcome?: "succeeded" | "failed" | "interrupted";
+}
+export declare function executionStatus(known: boolean, nativeRunning: boolean, evidence: ExecutionEvidence): ExecutionStatus;

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

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode/plugin";
+declare const _default: Plugin.Plugin;
+export default _default;

package/dist/types/monitor.d.ts

@@ -0,0 +1,20 @@
+import { CompactionScheduler } from "./scheduler.js";
+import { type BudgetController, type Config, type ContextUsage, type ContextUsageProvider, type Identity, type Measurement, type ModelLimits, type SessionState, type TelemetrySink, type Tokens } from "./types.js";
+export declare function promptTokens(t: Tokens): number | undefined;
+export declare class ContextMonitor implements ContextUsageProvider {
+    private readonly config;
+    readonly scheduler: CompactionScheduler;
+    private readonly sink;
+    private readonly now;
+    private readonly budget;
+    readonly sessions: Map<string, SessionState>;
+    private readonly resolver;
+    constructor(config: Config, scheduler: CompactionScheduler, sink: TelemetrySink, now?: () => number, budget?: BudgetController);
+    touch(identity: Identity, limits?: ModelLimits): SessionState | undefined;
+    accept(s: SessionState, sequence: number): boolean;
+    measure(s: SessionState, measurement: Measurement, cumulative?: Tokens): void;
+    evaluate(s: SessionState): void;
+    remove(id: string): void;
+    cleanup(): void;
+    getUsage(id: string): Promise<ContextUsage>;
+}

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

@@ -0,0 +1,12 @@
+import type { Config, Identity, Measurement, ModelLimits, Threshold, Decision } from "./types.js";
+export declare function glob(pattern: string, text: string): boolean;
+export declare class PolicyResolver {
+    private readonly config;
+    constructor(config: Config);
+    resolve(identity: Identity): {
+        threshold: Threshold;
+        policy: string;
+    };
+}
+export declare function usableInput(limits?: ModelLimits, reserve?: number): number | undefined;
+export declare function evaluateThreshold(threshold: Threshold, measurement: Measurement | undefined, limits: ModelLimits | undefined, now: number, staleMs: number, model: string | undefined, policy: string, reserve?: number): Decision;

package/dist/types/recovery.d.ts

@@ -0,0 +1,22 @@
+import type { CompactionState } from "./types.js";
+export interface Recovery {
+    sessionId: string;
+    compaction: CompactionState;
+    sequence?: number;
+}
+export declare function decodeRecovery(v: unknown, max: number): Recovery[];
+export declare function encodeRecovery(rows: Recovery[]): {
+    sessionId: string;
+    sequence: number;
+    compaction: {
+        requestId: string | null;
+        phase: import("./types.js").CompactionPhase;
+        armed: boolean;
+        count: number;
+        failures: number;
+        consecutiveFailures: number;
+        lastAttempt: number | null;
+        lastCompleted: number | null;
+        blockedReason: string | null;
+    };
+}[];

package/dist/types/rpc.d.ts

@@ -0,0 +1,129 @@
+import type { SnapshotBatch, SnapshotRead, SnapshotReadResult } from "./snapshot.js";
+export declare const readSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const batchSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const resultSchema: {
+    type: "object";
+    properties: Record<string, object>;
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare const monitorRpc: {
+    readonly id: "context-guard.monitor.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: {
+        readonly changed: {
+            readonly schema: {
+                type: "object";
+                properties: Record<string, object>;
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+};
+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/scheduler.d.ts

@@ -0,0 +1,18 @@
+import type { CompactionPort, Config, SessionState, TelemetrySink } from "./types.js";
+export declare class CompactionScheduler {
+    private readonly config;
+    private readonly port;
+    private readonly sink;
+    private readonly now;
+    private readonly id;
+    private stopped;
+    private readonly jobs;
+    constructor(config: Config, port: CompactionPort, sink: TelemetrySink, now?: () => number, id?: () => string);
+    consider(s: SessionState): void;
+    lifecycle(s: SessionState, event: "started" | "ended" | "failed", at: number): void;
+    measured(s: SessionState): void;
+    tick(s: SessionState): void;
+    private emit;
+    flush(): Promise<void>;
+    stop(): void;
+}

package/dist/types/snapshot.d.ts

@@ -0,0 +1,98 @@
+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;
+    readonly parentId?: string;
+    readonly agent?: string;
+    readonly model?: string;
+    readonly measurement?: Readonly<Measurement>;
+    readonly limits?: Readonly<ModelLimits>;
+    readonly capacityTokens?: number;
+    readonly outputReserveTokens?: number;
+    /** Peak prompt tokens observed during monitor residency. */
+    readonly peakTokens?: number;
+    readonly policy: {
+        readonly id: string;
+        readonly configured: Readonly<Threshold>;
+        readonly triggerTokens?: number;
+        readonly comparison: ">=" | ">";
+        readonly reason: string;
+        readonly crossed: boolean;
+    };
+    readonly compaction: {
+        readonly phase: CompactionPhase;
+        /** Completed lifecycle events observed by the monitor, never admissions. */
+        readonly count?: number;
+        readonly armed: boolean;
+        readonly blockedReason?: string;
+        readonly lastAttempt?: number;
+        readonly lastCompleted?: number;
+        readonly cooldownUntil?: number;
+    };
+    readonly cumulative?: Readonly<Omit<Tokens, "cache">> & {
+        readonly cache: Readonly<Tokens["cache"]>;
+    };
+    readonly cumulativeScope: "session" | "unknown";
+    readonly lastObservedActive: boolean;
+}
+export interface MonitorHealth {
+    readonly enabled: boolean;
+    readonly mode: "observe" | "enforce";
+    readonly enforcement: "observing" | "available" | "suspended" | "disabled";
+    readonly reasons: readonly string[];
+    readonly staleMs: number;
+    readonly maxSessions: number;
+}
+export interface SnapshotBatch {
+    readonly schemaVersion: 1;
+    readonly epoch: string;
+    readonly sequence: number;
+    readonly generatedAt: number;
+    readonly health: MonitorHealth;
+    readonly upserts: readonly ContextSnapshot[];
+    readonly removed: readonly {
+        readonly sessionId: string;
+        readonly revision: number;
+        readonly reason: "deleted" | "evicted";
+    }[];
+}
+export interface SnapshotRead {
+    readonly schemaVersion: 1;
+    readonly sessionIds: readonly string[];
+}
+export interface SnapshotReadResult extends SnapshotBatch {
+    readonly unavailable: readonly {
+        readonly sessionId: string;
+        readonly reason: "not-monitored";
+    }[];
+}
+export declare function project(s: SessionState, config: Config, now: number, revision?: number): ContextSnapshot;
+export declare class SnapshotStore {
+    private readonly config;
+    private readonly sessions;
+    private readonly now;
+    private readonly performanceSnapshot?;
+    readonly epoch: string;
+    private sequence;
+    private revision;
+    private rows;
+    private deleted;
+    private dirty;
+    private listeners;
+    private healthKey;
+    private reasons;
+    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;
+    mark(id: string): void;
+    markAll(): void;
+    remove(id: string): void;
+    listen(fn: (batch: SnapshotBatch) => void): () => void;
+    private batch;
+    flush(): void;
+    read(input: SnapshotRead): SnapshotReadResult;
+}

package/dist/types/snapshotserver.d.ts

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

package/dist/types/telemetry.d.ts

@@ -0,0 +1,17 @@
+import type { Config, TelemetryEvent, TelemetrySink } from "./types.js";
+export declare function defaultPath(directory: string): string;
+export declare class JsonlTelemetrySink implements TelemetrySink {
+    readonly path: string;
+    private readonly config;
+    private pending;
+    private working;
+    private disabled;
+    private bytes;
+    private ready;
+    constructor(path: string, config: Config["telemetry"]);
+    emit(event: TelemetryEvent): void;
+    private kick;
+    private drain;
+    flush(): Promise<void>;
+}
+export declare function readJournal(path: string, maxBytes?: number): Promise<unknown[]>;

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

@@ -0,0 +1,10 @@
+import type { Plugin } from "@opencode/plugin/tui";
+import type { GuardRow } from "../family.js";
+import type { GuardState } from "./state.js";
+export declare function CompactSidebar(props: {
+    sessionID: string;
+    rows: readonly GuardRow[];
+    state: GuardState;
+    context: Plugin.Context;
+    width: number;
+}): import("solid-js").JSX.Element;