@cesarus777/opencode-cgp 0.3.1 → 0.4.1

package/dist/index.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/history.ts
@@ -528,6 +651,7 @@ function scalarPerformance(p) {
 async function readPerformanceHistory(directory, filter = {}) {
   const records = [];
   const files = await segments(directory);
+  filter.signal?.throwIfAborted();
   const maxBytes = filter.maxBytes ?? 64 * 1024 * 1024;
   let bytes = 0, skippedBytes = 0, malformedRecords = 0;
   const selected = [];
@@ -540,6 +664,7 @@ async function readPerformanceHistory(directory, filter = {}) {
     selected.unshift(file);
   }
   for (const file of selected) {
+    filter.signal?.throwIfAborted();
     const handle = await open(join(directory, file.name), "r");
     let source;
     try {
@@ -549,7 +674,12 @@ async function readPerformanceHistory(directory, filter = {}) {
     } finally {
       await handle.close();
     }
+    let scannedLines = 0;
     for (const line of source.split("\n")) {
+      if (filter.signal && ++scannedLines % 256 === 0) {
+        await new Promise((done) => setTimeout(done, 0));
+        filter.signal.throwIfAborted();
+      }
       if (!line)
         continue;
       try {
@@ -604,6 +734,205 @@ var init_history = __esm(() => {
   filename = /^([0-9]+)-[a-f0-9-]+\.jsonl$/;
 });
 
+// src/modelanalytics.ts
+function requestFact(record2) {
+  const p = record2.performance;
+  if (!p?.requestId || !record2.sessionId || !nonnegative2(p.requestStartedAt))
+    return;
+  const model = p.requestModel || record2.model;
+  const agent = p.requestAgent || record2.agent;
+  const ttft = p.ttftMs ?? (p.firstOutputAt === undefined ? undefined : p.firstOutputAt - p.requestStartedAt);
+  return {
+    location: "",
+    sessionId: record2.sessionId,
+    requestId: p.requestId,
+    startedAt: p.requestStartedAt,
+    ...p.streamEndedAt === undefined ? {} : { completedAt: p.streamEndedAt },
+    ...model ? { model } : {},
+    ...agent ? { agent } : {},
+    attribution: p.requestModel ? "request" : model ? "legacy-record" : "unknown",
+    partial: p.partial,
+    ...p.tokenSource === "reported" && nonnegative2(p.requestOutputTokens) ? { outputTokens: p.requestOutputTokens } : {},
+    ...ttft === undefined ? {} : { ttftMs: ttft }
+  };
+}
+function reconcile(a, b) {
+  for (const field of [
+    "completedAt",
+    "outputTokens",
+    "ttftMs",
+    "agent"
+  ])
+    if (a[field] !== undefined && b[field] !== undefined && a[field] !== b[field])
+      return;
+  if (a.model && b.model && a.model !== b.model)
+    return;
+  const rank = { unknown: 0, "legacy-record": 1, request: 2 };
+  const preferred = rank[b.attribution] > rank[a.attribution] ? b : a;
+  return {
+    ...a,
+    ...b,
+    ...preferred.model ? { model: preferred.model } : {},
+    attribution: preferred.attribution,
+    partial: a.partial || b.partial
+  };
+}
+function analyzeModelRequests(records, options) {
+  const maxRequests = options.maxRequests ?? 1e5;
+  if (!Number.isSafeInteger(maxRequests) || maxRequests < 1 || maxRequests > 1e6)
+    throw new Error("maxRequests must be an integer from 1 to 1000000");
+  if (!options.location)
+    throw new Error("Analytics requires a location identity");
+  for (const value of [options.from, options.to])
+    if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
+      throw new Error("Invalid analytics timestamp");
+  if (options.from !== undefined && options.to !== undefined && options.from > options.to)
+    throw new Error("--from must precede --to");
+  const coverage = {
+    source: "retained-request-records",
+    scannedRecords: 0,
+    unscannedRecords: 0,
+    duplicateRecords: 0,
+    conflictingRequests: 0,
+    missingIdentityRecords: 0,
+    incompleteRequests: 0,
+    invalidTimingRequests: 0,
+    gapRecords: 0,
+    maxRequests,
+    partial: false
+  };
+  const requests = new Map;
+  for (const record2 of records) {
+    coverage.scannedRecords++;
+    if (record2.type === "gap") {
+      coverage.gapRecords++;
+      continue;
+    }
+    if (record2.type !== "request")
+      continue;
+    const fact = requestFact(record2);
+    if (!fact) {
+      coverage.missingIdentityRecords++;
+      continue;
+    }
+    fact.location = options.location;
+    const key = JSON.stringify([
+      fact.sessionId,
+      fact.requestId,
+      fact.startedAt
+    ]);
+    const previous = requests.get(key);
+    if (previous) {
+      coverage.duplicateRecords++;
+      const merged = reconcile(previous.fact, fact);
+      if (!merged)
+        previous.conflict = true;
+      else
+        previous.fact = merged;
+    } else {
+      if (requests.size === maxRequests) {
+        coverage.scannedRecords--;
+        coverage.unscannedRecords = records.length - coverage.scannedRecords;
+        break;
+      }
+      requests.set(key, { fact, conflict: false });
+    }
+  }
+  const accepted = [];
+  for (const { fact: r, conflict } of requests.values()) {
+    if (conflict) {
+      coverage.conflictingRequests++;
+      continue;
+    }
+    if (r.completedAt === undefined) {
+      coverage.incompleteRequests++;
+      continue;
+    }
+    const duration = r.completedAt - r.startedAt;
+    if (!nonnegative2(r.completedAt) || !Number.isFinite(duration) || duration <= 0) {
+      coverage.invalidTimingRequests++;
+      continue;
+    }
+    if (options.from !== undefined && r.completedAt < options.from || options.to !== undefined && r.completedAt >= options.to || options.model !== undefined && r.model !== options.model || options.agent !== undefined && r.agent !== options.agent)
+      continue;
+    accepted.push({ ...r, completedAt: r.completedAt });
+  }
+  const models = summarizeModelRequests(accepted);
+  coverage.partial = coverage.unscannedRecords > 0 || coverage.conflictingRequests > 0 || coverage.missingIdentityRecords > 0 || coverage.incompleteRequests > 0 || coverage.invalidTimingRequests > 0 || coverage.gapRecords > 0 || models.some((s) => s.partialRequests > 0 || s.legacyAttributionRequests > 0 || s.excludedTpsRequests > 0 || s.excludedTtftRequests > 0 || !s.model);
+  return {
+    schemaVersion: 1,
+    location: options.location,
+    models,
+    coverage,
+    requests: accepted
+  };
+}
+function summarizeModelRequests(requests) {
+  const groups = new Map;
+  for (const r of requests) {
+    const duration = r.completedAt - r.startedAt;
+    let group = groups.get(r.model);
+    if (!group) {
+      group = {
+        summary: {
+          ...r.model ? { model: r.model } : {},
+          sessions: 0,
+          completedRequests: 0,
+          partialRequests: 0,
+          legacyAttributionRequests: 0,
+          tpsRequests: 0,
+          ttftRequests: 0,
+          excludedTpsRequests: 0,
+          excludedTtftRequests: 0,
+          outputTokens: 0,
+          durationMs: 0
+        },
+        sessions: new Set,
+        ttfts: []
+      };
+      groups.set(r.model, group);
+    }
+    const s = group.summary;
+    group.sessions.add(r.sessionId);
+    s.completedRequests++;
+    if (r.partial)
+      s.partialRequests++;
+    if (r.attribution === "legacy-record")
+      s.legacyAttributionRequests++;
+    if (r.outputTokens !== undefined) {
+      s.tpsRequests++;
+      s.outputTokens += r.outputTokens;
+      s.durationMs += duration;
+    } else
+      s.excludedTpsRequests++;
+    if (nonnegative2(r.ttftMs) && r.ttftMs <= duration)
+      group.ttfts.push(r.ttftMs);
+    else
+      s.excludedTtftRequests++;
+  }
+  const models = [...groups.values()].map(({ summary: s, sessions, ttfts }) => {
+    s.sessions = sessions.size;
+    s.ttftRequests = ttfts.length;
+    if (s.tpsRequests)
+      s.averageTps = s.outputTokens * 1000 / s.durationMs;
+    ttfts.sort((a, b) => a - b);
+    if (ttfts.length) {
+      s.meanTtftMs = ttfts.reduce((sum, n) => sum + n, 0) / ttfts.length;
+      s.medianTtftMs = ((ttfts[Math.floor((ttfts.length - 1) / 2)] ?? 0) + (ttfts[Math.floor(ttfts.length / 2)] ?? 0)) / 2;
+      const p95 = ttfts[Math.ceil(ttfts.length * 0.95) - 1];
+      if (p95 !== undefined)
+        s.p95TtftMs = p95;
+    }
+    return s;
+  }).sort((a, b) => (a.model ?? "").localeCompare(b.model ?? ""));
+  return models;
+}
+function aggregateModels(records, options) {
+  const { requests: _requests, ...result } = analyzeModelRequests(records, options);
+  return result;
+}
+var nonnegative2 = (n) => n !== undefined && Number.isFinite(n) && n >= 0;
+
 // src/index.ts
 import { Plugin } from "@opencode/plugin";
 
@@ -1056,6 +1385,229 @@ async function serveHistory(rpc, path, enabled, now = Date.now, authorize = asyn
   };
 }
 
+// src/modelanalyticsserver.ts
+init_history();
+import { createHash } from "crypto";
+
+// src/modelseries.ts
+function bucketModelRequests(requests, from, to, count2) {
+  if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 0 || from >= to || !Number.isSafeInteger(count2) || count2 < 1 || count2 > 240)
+    throw new Error("Invalid analytics buckets");
+  const groups = Array.from({ length: count2 }, () => []);
+  for (const request of requests) {
+    if (request.completedAt < from || request.completedAt >= to)
+      continue;
+    const index = Math.min(count2 - 1, Math.floor((request.completedAt - from) / (to - from) * count2));
+    groups[index]?.push(request);
+  }
+  return groups.map((group, index) => {
+    const summaries = summarizeModelRequests(group);
+    if (summaries.length > 1)
+      throw new Error("Select one model for buckets");
+    const summary = summaries[0];
+    return {
+      from: from + (to - from) * index / count2,
+      to: from + (to - from) * (index + 1) / count2,
+      ...summary ? { summary } : {}
+    };
+  });
+}
+
+// src/modelanalyticsserver.ts
+init_rpc();
+var metadata = {
+  schema: 1,
+  retainedBytes: 0,
+  skippedBytes: 0,
+  malformedRecords: 0,
+  completeness: "bounded-retention"
+};
+function createAnalyticsService(path, location, enabled, options = {}) {
+  const now = options.now ?? Date.now;
+  const reader = options.read ?? readPerformanceHistory;
+  const snapshots = new Map;
+  let stopped = false;
+  let archive;
+  let scan;
+  async function load(signal) {
+    if (archive && now() - archive.at < 30000)
+      return archive;
+    if (!scan || scan.controller.signal.aborted) {
+      const controller = new AbortController;
+      const job2 = {
+        controller,
+        waiters: 0,
+        promise: Promise.resolve().then(async () => {
+          const source = enabled ? await reader(path, { signal: controller.signal }) : { metadata, records: [] };
+          controller.signal.throwIfAborted();
+          if (stopped)
+            throw new Error("Analytics service stopped");
+          const analysis = analyzeModelRequests(source.records, { location });
+          const result = {
+            at: now(),
+            source: {
+              metadata: source.metadata,
+              records: source.records.filter((r) => r.type === "gap")
+            },
+            analysis
+          };
+          archive = result;
+          return result;
+        }).finally(() => {
+          if (scan === job2)
+            scan = undefined;
+        })
+      };
+      scan = job2;
+    }
+    const job = scan;
+    job.waiters++;
+    let onAbort = () => {
+    };
+    try {
+      return await Promise.race([
+        job.promise,
+        new Promise((_resolve, reject) => {
+          onAbort = () => reject(new Error("Analytics read cancelled"));
+          signal.addEventListener("abort", onAbort, { once: true });
+          if (signal.aborted)
+            onAbort();
+        })
+      ]);
+    } finally {
+      signal.removeEventListener("abort", onAbort);
+      if (--job.waiters === 0)
+        job.controller.abort();
+    }
+  }
+  const queryKey = (input) => JSON.stringify([input.from, input.to, input.agent ?? null]);
+  function pageOffset(cursor2, snapshot, kind, binding) {
+    if (!cursor2)
+      return 0;
+    try {
+      const parsed = JSON.parse(Buffer.from(cursor2, "base64url").toString());
+      if (Array.isArray(parsed) && parsed.length === 4 && parsed[0] === snapshot.id && parsed[1] === kind && parsed[3] === createHash("sha256").update(binding).digest("hex") && Number.isSafeInteger(parsed[2]) && parsed[2] >= 0 && parsed[2] % 50 === 0)
+        return Number(parsed[2]);
+    } catch {
+    }
+    throw new Error("Invalid analytics cursor; refresh Models");
+  }
+  const cursor = (snapshot, kind, offset, binding) => Buffer.from(JSON.stringify([
+    snapshot.id,
+    kind,
+    offset,
+    createHash("sha256").update(binding).digest("hex")
+  ])).toString("base64url");
+  return {
+    async read(input, signal) {
+      if (!isAnalyticsRead(input))
+        throw new Error("Invalid analytics request");
+      signal.throwIfAborted();
+      if (stopped)
+        throw new Error("Analytics service stopped");
+      for (const [id, item] of snapshots)
+        if (item.expiresAt <= now())
+          snapshots.delete(id);
+      let snapshot = input.snapshotId ? snapshots.get(input.snapshotId) : [...snapshots.values()].find((s) => s.key === queryKey(input) && now() - s.generatedAt < 30000);
+      if (input.snapshotId && (!snapshot || snapshot.key !== queryKey(input)))
+        throw new Error("Analytics snapshot expired; refresh Models");
+      if (!snapshot) {
+        const data = await load(signal);
+        signal.throwIfAborted();
+        const requests2 = data.analysis.requests.filter((r) => r.completedAt >= input.from && r.completedAt < input.to && (!input.agent || r.agent === input.agent));
+        requests2.sort((a, b) => b.completedAt - a.completedAt || a.sessionId.localeCompare(b.sessionId) || a.requestId.localeCompare(b.requestId) || a.startedAt - b.startedAt);
+        const gaps = data.source.records.filter((r) => r.time >= input.from && r.time < input.to).map((r) => r.time);
+        snapshot = {
+          id: crypto.randomUUID(),
+          key: queryKey(input),
+          generatedAt: data.at,
+          expiresAt: now() + 90000,
+          requests: requests2,
+          models: summarizeModelRequests(requests2),
+          coverage: data.analysis.coverage,
+          metadata: data.source.metadata,
+          gaps: gaps.slice(-128),
+          omittedGaps: Math.max(0, gaps.length - 128)
+        };
+        snapshots.set(snapshot.id, snapshot);
+        if (snapshots.size > 2) {
+          const oldest = snapshots.keys().next().value;
+          if (oldest)
+            snapshots.delete(oldest);
+        }
+      }
+      const sort = input.sort ?? "requests";
+      const models = [...snapshot.models].sort((a, b) => {
+        const key = sort === "tps" ? "averageTps" : sort === "ttft" ? "p95TtftMs" : "completedRequests";
+        return (sort === "identity" ? 0 : (b[key] ?? -Infinity) - (a[key] ?? -Infinity)) || (a.model ?? "").localeCompare(b.model ?? "");
+      });
+      const modelOffset = pageOffset(input.modelCursor, snapshot, "models", sort);
+      const selected = input.unknownModel ? models.find((m) => m.model === undefined) : input.model ? models.find((m) => m.model === input.model) : models[modelOffset];
+      const selection = selected?.model ?? "";
+      const requests = selected ? snapshot.requests.filter((r) => r.model === selected.model) : [];
+      const requestOffset = pageOffset(input.requestCursor, snapshot, "requests", selection);
+      const buckets = selected ? bucketModelRequests(requests, input.from, input.to, input.buckets) : [];
+      const result = {
+        schemaVersion: 1,
+        generatedAt: snapshot.generatedAt,
+        expiresAt: snapshot.expiresAt,
+        snapshotId: snapshot.id,
+        enabled,
+        from: input.from,
+        to: input.to,
+        ...input.agent ? { agent: input.agent } : {},
+        models: models.slice(modelOffset, modelOffset + 50).map((m) => ({ ...m })),
+        totalModels: models.length,
+        ...modelOffset + 50 < models.length ? {
+          nextModelsCursor: cursor(snapshot, "models", modelOffset + 50, sort)
+        } : {},
+        ...selected ? { selected: { ...selected } } : {},
+        buckets,
+        requests: requests.slice(requestOffset, requestOffset + 50).map((r) => {
+          const { ttftMs, ...fact } = r;
+          return {
+            ...fact,
+            ...ttftMs !== undefined && Number.isFinite(ttftMs) && ttftMs >= 0 && ttftMs <= r.completedAt - r.startedAt ? { ttftMs } : {}
+          };
+        }),
+        ...requestOffset + 50 < requests.length ? {
+          nextRequestsCursor: cursor(snapshot, "requests", requestOffset + 50, selection)
+        } : {},
+        coverage: { ...snapshot.coverage },
+        metadata: { ...snapshot.metadata },
+        gaps: [...snapshot.gaps],
+        omittedGaps: snapshot.omittedGaps
+      };
+      if (!isAnalyticsResult(result))
+        throw new Error("Analytics response exceeds supported bounds");
+      return result;
+    },
+    dispose() {
+      stopped = true;
+      scan?.controller.abort();
+      snapshots.clear();
+      archive = undefined;
+    }
+  };
+}
+async function serveModelAnalytics(port, path, location, enabled) {
+  if (!port)
+    return () => {
+    };
+  const service = createAnalyticsService(path, location, enabled);
+  const registration = await port.register(analyticsRpc, {
+    read: async (input, context) => {
+      if (!isAnalyticsRead(input))
+        throw new Error("Invalid analytics request");
+      return service.read(input, context.signal);
+    }
+  });
+  return async () => {
+    service.dispose();
+    await registration.dispose();
+  };
+}
+
 // src/adapter.ts
 init_history();
 
@@ -1888,7 +2440,7 @@ function estimate(value, maxChars = 2000000) {
 function record2(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
-function nonnegative2(v) {
+function nonnegative3(v) {
   return typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
 }
 function decodeRecovery(v, max) {
@@ -1899,7 +2451,7 @@ function decodeRecovery(v, max) {
     if (!record2(item) || typeof item.sessionId !== "string" || !record2(item.compaction))
       continue;
     const c = item.compaction;
-    if (!nonnegative2(c.count) || !nonnegative2(c.failures) || !nonnegative2(c.consecutiveFailures) || typeof c.armed !== "boolean")
+    if (!nonnegative3(c.count) || !nonnegative3(c.failures) || !nonnegative3(c.consecutiveFailures) || typeof c.armed !== "boolean")
       continue;
     const phase = c.phase === "idle" || c.phase === "blocked" ? c.phase : "uncertain";
     const compaction = {
@@ -1909,9 +2461,9 @@ function decodeRecovery(v, max) {
       failures: c.failures,
       consecutiveFailures: c.consecutiveFailures
     };
-    if (nonnegative2(c.lastAttempt))
+    if (nonnegative3(c.lastAttempt))
       compaction.lastAttempt = c.lastAttempt;
-    if (nonnegative2(c.lastCompleted))
+    if (nonnegative3(c.lastCompleted))
       compaction.lastCompleted = c.lastCompleted;
     if (typeof c.requestId === "string")
       compaction.requestId = c.requestId;
@@ -1922,7 +2474,7 @@ function decodeRecovery(v, max) {
     result.push({
       sessionId: item.sessionId,
       compaction,
-      ...nonnegative2(item.sequence) ? { sequence: item.sequence } : {}
+      ...nonnegative3(item.sequence) ? { sequence: item.sequence } : {}
     });
   }
   return result;
@@ -1949,9 +2501,9 @@ function encodeRecovery(rows) {
 import { mkdir as mkdir2, open as open2, rename, stat as stat2 } from "fs/promises";
 import { dirname, join as join2 } from "path";
 import { homedir } from "os";
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function defaultPath(directory) {
-  const key = createHash("sha256").update(directory).digest("hex").slice(0, 16);
+  const key = createHash2("sha256").update(directory).digest("hex").slice(0, 16);
   return join2(process.env.XDG_STATE_HOME || join2(homedir(), ".local/state"), "opencode-context-guard", `${key}.jsonl`);
 }
 
@@ -2118,7 +2670,16 @@ async function setup(ctx, injectedSink) {
     return () => {
     };
   });
+  const stopAnalytics = await serveModelAnalytics(ctx.analyticsRpc, config.history.path ?? `${defaultPath(ctx.location.directory)}.metrics`, ctx.location.directory, config.enabled && config.metrics.enabled && config.history.enabled).catch(() => {
+    diagnostics.emit({
+      time: Date.now(),
+      type: "analytics-service-unavailable"
+    });
+    return () => {
+    };
+  });
   const stopSnapshots = async () => {
+    await stopAnalytics();
     await stopHistory();
     await stopV2();
     await stopV1();
@@ -2667,7 +3228,7 @@ async function setup(ctx, injectedSink) {
 // src/index.ts
 var src_default = Plugin.define({
   id: "context-guard",
-  setup: (ctx, injectedSink) => setup({ ...ctx, historyRpc: ctx.rpc }, injectedSink)
+  setup: (ctx, injectedSink) => setup({ ...ctx, historyRpc: ctx.rpc, analyticsRpc: ctx.rpc }, injectedSink)
 });
 export {
   src_default as default