@cesarus777/opencode-cgp 0.2.2 → 0.2.3

package/README.md

@@ -41,7 +41,7 @@ Global configuration is `~/.config/opencode/opencode.jsonc` (or the OpenCode con
 
 Restart/reload OpenCode and look for `context-guard: observe; diagnostics ...`. Observe mode records policy decisions and never requests compaction; OpenCode's own automatic compaction remains active. Inspect diagnostics first, then set `mode` to `enforce` to admit native compaction at runtime step boundaries. The complete [example](examples/opencode.jsonc) includes model, role, and agent policies. **Last matching rule wins**; selectors within a rule are ANDed.
 
-Pin the exact published version in the existing entry's `package` field or use the manager. Version `0.2.2` adds live context-capacity charts, single-metric performance chart navigation, panel padding, and persistent close controls.
+Pin the exact published version in the existing entry's `package` field or use the manager. Version `0.2.3` restores context usage for existing sessions when the plugin is enabled and keeps stale occupancy visible.
 
 ```sh
 opencode plugin add @cesarus777/opencode-cgp@0.2.1
@@ -100,6 +100,8 @@ Open `/context-guard` or **Open Context Guard** in the command palette for curre
 
 The TUI reads bounded snapshots over public OpenCode RPC, including when telemetry is disabled. Remote clients also need a client-side package registration in `cli.json`; see [the example](examples/cli.jsonc) and [controls, installation and bounds](docs/configuration.md#native-context-guard-view). It targets the inspected 2.0.29 API. The actual local host passes wide root, child and narrow grandchild panel checks. Use **Context Guard: open panel** above a child composer, where the host hides its usual prompt and palette shortcut. tmux, Neovim and cross-machine remote validation remain open.
 
+Enabling Context Guard after work has already started also shows the last reported prompt usage for idle sessions and subagents. Opening the sidebar or panel restores it from the public session context, preserving its original age and **STALE** label. Stale usage still shows tokens and occupancy percentage. Restoration respects model changes, reverts and completed compactions; unavailable provider usage stays unknown. These reads never request compaction, and transcript content is never retained or sent through the plugin RPC.
+
 Per-session live TPS, average model throughput, average session throughput and observed TTFT appear in the selected session and child rows. Live TPS and TTFT use `~` to mark estimates; completed rates use provider totals. Configurable local history defaults to seven days with a 64 MiB total cap, independently of diagnostic telemetry. See [metric definitions and history exports](docs/configuration.md#live-performance-and-retained-history).
 
 Press **c** in the Context Guard panel for retained-history terminal charts. View one metric at a time with **Left / Right**, change the time window with **[ / ]**, and select an agent instance with **Up / Down**. Press **c** to return or **q** to close the panel; controls stay visible below the scrollable content. Generate a self-contained interactive browser report with `bun run charts /absolute/history-directory --output report.html`. It includes filters, UTC timestamp tooltips, request statistics and SVG export. Installed packages expose the same command as `context-guard charts ...` (Bun required). See [chart controls and limits](docs/configuration.md#performance-charts).

package/dist/core.js

@@ -748,13 +748,14 @@ function metric(snapshot, now, staleMs) {
   const freshness = !m ? "missing" : m.model !== snapshot?.model || m.at > now ? "invalid" : now - m.at > staleMs ? "stale" : "fresh";
   const t = snapshot?.policy.triggerTokens;
   const valid = freshness === "fresh" && m !== undefined;
+  const displayable = valid || freshness === "stale" && m !== undefined;
   const pressureRatio = valid && t !== undefined && t > 0 ? m.tokens / t : undefined;
   const crossed = valid && t !== undefined && t > 0 && (snapshot?.policy.comparison === ">" ? m.tokens > t : m.tokens >= t);
   return {
     freshness,
     pressure: pressureRatio === undefined ? "unknown" : crossed ? "crossed" : pressureRatio >= 0.9 ? "near" : "normal",
     ...pressureRatio === undefined ? {} : { pressureRatio },
-    ...valid && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
+    ...displayable && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
     ...valid && t !== undefined ? { triggerDeltaTokens: t - m.tokens } : {}
   };
 }

package/dist/index.js

@@ -1330,7 +1330,7 @@ function freezeSnapshot(row2) {
 }
 
 // src/snapshotserver.ts
-async function serveSnapshots(rpc, store, performance = false) {
+async function serveSnapshots(rpc, store, performance = false, prepareRead) {
   if (!rpc)
     return () => {
     };
@@ -1341,9 +1341,10 @@ async function serveSnapshots(rpc, store, performance = false) {
   const batchValid = performance ? isPerformanceBatch : isBatch;
   const resultValid = performance ? isPerformanceResult : isResult;
   const registration = await rpc.register(performance ? performanceRpc : monitorRpc, {
-    read: async (input) => {
+    read: async (input, context) => {
       if (!isRead(input))
         throw new Error("Invalid snapshot request");
+      await prepareRead?.(input.sessionIds, context.signal);
       const raw = store.read(input);
       const result = performance ? raw : stripPerformance(raw);
       if (!resultValid(result))
@@ -2053,7 +2054,10 @@ async function setup(ctx, injectedSink) {
       diagnostics.emit(event);
     }
   };
-  const stopV1 = await serveSnapshots(ctx.rpc, store).catch(() => {
+  let prepareRead = async (_ids, _signal) => {
+  };
+  const onRead = (ids, signal) => prepareRead(ids, signal);
+  const stopV1 = await serveSnapshots(ctx.rpc, store, false, onRead).catch(() => {
     diagnostics.emit({
       time: Date.now(),
       type: "snapshot-service-unavailable"
@@ -2061,7 +2065,7 @@ async function setup(ctx, injectedSink) {
     return () => {
     };
   });
-  const stopV2 = await serveSnapshots(ctx.rpc, store, true).catch(() => {
+  const stopV2 = await serveSnapshots(ctx.rpc, store, true, onRead).catch(() => {
     diagnostics.emit({
       time: Date.now(),
       type: "performance-service-unavailable"
@@ -2179,8 +2183,73 @@ async function setup(ctx, injectedSink) {
   }, sink);
   monitor = new ContextMonitor(config, scheduler, sink);
   const activeMonitor = monitor;
+  const usageReads = new Map;
+  prepareRead = (ids, signal) => serialized(async () => {
+    if (stopped || signal.aborted || !ctx.session.context || !ids.length)
+      return;
+    const readSignal = AbortSignal.any([
+      signal,
+      controller.signal,
+      AbortSignal.timeout(5000)
+    ]);
+    for (const id of ids) {
+      if (readSignal.aborted)
+        break;
+      const existing = activeMonitor.sessions.get(id);
+      if (existing?.usage.current || existing?.active || (existing?.usage.modelRequests ?? 0) > 0 || recoveries.has(id))
+        continue;
+      if (existing && (existing.compaction.phase !== "idle" || existing.compaction.lastAttempt !== undefined || existing.compaction.lastCompleted !== undefined || existing.compaction.failures > 0))
+        continue;
+      if (Date.now() - (usageReads.get(id) ?? 0) < 30000)
+        continue;
+      if (usageReads.size >= config.safety.maxSessions) {
+        const oldest = usageReads.keys().next().value;
+        if (oldest !== undefined)
+          usageReads.delete(oldest);
+      }
+      usageReads.set(id, Date.now());
+      try {
+        const info = await ctx.session.get({ sessionID: id }, { signal: readSignal });
+        if (info.location.directory !== ctx.location.directory)
+          continue;
+        const messages = await ctx.session.context({ sessionID: id }, { signal: readSignal });
+        const boundary = info.revert?.messageID;
+        const end = boundary ? messages.findIndex((m) => m.id === boundary) : messages.length;
+        if (end < 0)
+          continue;
+        const compacted = messages.findLastIndex((m, index) => index < end && m.type === "compaction" && m.status === "completed");
+        const message = messages.findLast((m, index) => index > compacted && index < end && m.type === "assistant" && m.tokens !== undefined);
+        if (message?.type !== "assistant" || !message.tokens)
+          continue;
+        const tokens = promptTokens(message.tokens);
+        const model = `${message.model.providerID}/${message.model.id}`;
+        const at = message.time.completed ?? message.time.streamed;
+        if (tokens === undefined || at === undefined || !Number.isFinite(at) || at < 0 || at > Date.now())
+          continue;
+        if (info.model && model !== `${info.model.providerID}/${info.model.id}`)
+          continue;
+        await refreshModels(!models.has(model), readSignal);
+        const s = await discover(id, readSignal);
+        if (!s || s.model && s.model !== model || s.usage.current || readSignal.aborted)
+          continue;
+        activeMonitor.touch({ sessionId: id, model }, models.get(model));
+        s.usage.current = {
+          tokens,
+          at,
+          model,
+          provenance: "provider-normalized",
+          confidence: "reported",
+          scope: "completed-request",
+          requestId: message.id
+        };
+        s.usage.peak = Math.max(s.usage.peak, tokens);
+        store.mark(id);
+      } catch {
+      }
+    }
+  });
   let models = new Map, modelAt = 0, modelRetryAt = 0, modelRetryMs = 1000;
-  async function refreshModels(retryMissing = false) {
+  async function refreshModels(retryMissing = false, signal = controller.signal) {
     const now = Date.now();
     if (now - modelAt < 60000 && (!retryMissing || now < modelRetryAt))
       return;
@@ -2188,7 +2257,10 @@ async function setup(ctx, injectedSink) {
     modelRetryAt = now + modelRetryMs;
     modelRetryMs = Math.min(60000, modelRetryMs * 2);
     try {
-      models = new Map((await ctx.model.list(undefined, { signal: controller.signal })).data.map((m) => [`${m.providerID}/${m.id}`, { ...m.limit }]));
+      models = new Map((await ctx.model.list(undefined, { signal })).data.map((m) => [
+        `${m.providerID}/${m.id}`,
+        { ...m.limit }
+      ]));
       let missing = false;
       for (const s of activeMonitor.sessions.values()) {
         const limits = s.model ? models.get(s.model) : undefined;
@@ -2212,8 +2284,8 @@ async function setup(ctx, injectedSink) {
       sink.emit({ time: Date.now(), type: "model-metadata-unavailable" });
     }
   }
-  async function discover(sessionId) {
-    const info = await ctx.session.get({ sessionID: sessionId }, { signal: controller.signal });
+  async function discover(sessionId, signal = controller.signal) {
+    const info = await ctx.session.get({ sessionID: sessionId }, { signal });
     if (info.location.directory !== ctx.location.directory)
       return;
     const identity = {

package/dist/tui.js

@@ -330,13 +330,14 @@ function metric(snapshot, now, staleMs) {
   const freshness = !m ? "missing" : m.model !== snapshot?.model || m.at > now ? "invalid" : now - m.at > staleMs ? "stale" : "fresh";
   const t = snapshot?.policy.triggerTokens;
   const valid2 = freshness === "fresh" && m !== undefined;
+  const displayable = valid2 || freshness === "stale" && m !== undefined;
   const pressureRatio = valid2 && t !== undefined && t > 0 ? m.tokens / t : undefined;
   const crossed = valid2 && t !== undefined && t > 0 && (snapshot?.policy.comparison === ">" ? m.tokens > t : m.tokens >= t);
   return {
     freshness,
     pressure: pressureRatio === undefined ? "unknown" : crossed ? "crossed" : pressureRatio >= 0.9 ? "near" : "normal",
     ...pressureRatio === undefined ? {} : { pressureRatio },
-    ...valid2 && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
+    ...displayable && snapshot?.capacityTokens && snapshot.capacityTokens > 0 ? { utilizationPercent: m.tokens / snapshot.capacityTokens * 100 } : {},
     ...valid2 && t !== undefined ? { triggerDeltaTokens: t - m.tokens } : {}
   };
 }

package/dist/types/adapter.d.ts

@@ -12,7 +12,7 @@ export interface Host {
     location: {
         directory: string;
     };
-    session: Pick<Plugin.Context["session"], "get" | "compact" | "hook">;
+    session: Pick<Plugin.Context["session"], "get" | "compact" | "hook"> & Partial<Pick<Plugin.Context["session"], "context">>;
     model: Pick<Plugin.Context["model"], "list">;
     event: Plugin.Context["event"];
     storage: Pick<Plugin.Context["storage"], "get" | "set">;

package/dist/types/snapshotserver.d.ts

@@ -4,4 +4,4 @@ export interface SnapshotRpcPort {
 }
 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>;
+export declare function serveSnapshots(rpc: SnapshotRpcPort | undefined, store: SnapshotStore, performance?: boolean, prepareRead?: (ids: readonly string[], signal: AbortSignal) => Promise<void>): Promise<() => void>;

package/package.json

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