@cesarus777/opencode-cgp 0.0.0-stage → 0.2.1

package/dist/tui.js

@@ -0,0 +1,2286 @@
+// @bun
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+var count = {
+  type: "integer",
+  minimum: 0,
+  maximum: Number.MAX_SAFE_INTEGER
+};
+var text = { type: "string", minLength: 1, maxLength: 512 };
+var enumeration = (...values) => ({ type: "string", enum: values });
+var object = (properties, required = Object.keys(properties)) => ({
+  type: "object",
+  properties,
+  required,
+  additionalProperties: false
+});
+var array = (items, maxItems = 128) => ({
+  type: "array",
+  items,
+  maxItems
+});
+var measurement = object({
+  tokens: count,
+  at: count,
+  model: text,
+  requestId: text,
+  provenance: enumeration("provider-normalized", "serialized-estimate"),
+  confidence: enumeration("reported", "approximate"),
+  scope: enumeration("completed-request", "prepared-request")
+}, ["tokens", "at", "model", "provenance", "confidence", "scope"]);
+var row = object({
+  sessionId: text,
+  revision: count,
+  observedAt: count,
+  parentId: text,
+  agent: text,
+  model: text,
+  measurement,
+  limits: object({ context: count, input: count, output: count }, [
+    "context",
+    "output"
+  ]),
+  capacityTokens: count,
+  outputReserveTokens: count,
+  peakTokens: count,
+  policy: object({
+    id: text,
+    configured: object({
+      type: enumeration("tokens", "ratio", "remaining"),
+      value: { type: "number", minimum: 0 }
+    }),
+    triggerTokens: { type: "number" },
+    comparison: enumeration(">=", ">"),
+    reason: enumeration("missing-usage", "model-changed", "invalid-usage", "stale-usage", "missing-model-budget", "incompatible-model-budget", "threshold-crossed", "below-threshold"),
+    crossed: { type: "boolean" }
+  }, ["id", "configured", "comparison", "reason", "crossed"]),
+  compaction: object({
+    phase: enumeration("idle", "requesting", "accepted", "running", "awaiting-measurement", "blocked", "uncertain"),
+    count,
+    armed: { type: "boolean" },
+    blockedReason: enumeration("session-removed", "compaction-failed", "reclaim-unverifiable", "insufficient-reclaim", "completion-event-timeout", "admission-outcome-unknown", "restart-needs-lifecycle-evidence"),
+    lastAttempt: count,
+    lastCompleted: count,
+    cooldownUntil: count
+  }, ["phase", "armed"]),
+  cumulative: object({
+    input: count,
+    output: count,
+    reasoning: count,
+    cache: object({ read: count, write: count })
+  }),
+  cumulativeScope: enumeration("session", "unknown"),
+  lastObservedActive: { type: "boolean" }
+}, [
+  "sessionId",
+  "revision",
+  "observedAt",
+  "policy",
+  "compaction",
+  "cumulativeScope",
+  "lastObservedActive"
+]);
+var batchFields = {
+  schemaVersion: { const: 1 },
+  epoch: text,
+  sequence: count,
+  generatedAt: count,
+  health: object({
+    enabled: { type: "boolean" },
+    mode: enumeration("observe", "enforce"),
+    enforcement: enumeration("observing", "available", "suspended", "disabled"),
+    reasons: array(enumeration("event-stream-gap", "persistence-unavailable", "capacity-exceeded", "model-metadata-unavailable"), 8),
+    staleMs: count,
+    maxSessions: count
+  }),
+  upserts: array(row),
+  removed: array(object({
+    sessionId: text,
+    revision: count,
+    reason: enumeration("deleted", "evicted")
+  }))
+};
+var readSchema = object({
+  schemaVersion: { const: 1 },
+  sessionIds: { ...array(text), uniqueItems: true }
+});
+var batchSchema = object(batchFields);
+var resultSchema = object({
+  ...batchFields,
+  unavailable: array(object({ sessionId: text, reason: enumeration("not-monitored") }))
+});
+var monitorRpc = Rpc.define({
+  id: "context-guard.monitor.v1",
+  methods: { read: { input: readSchema, output: resultSchema } },
+  events: { changed: { schema: batchSchema } }
+});
+var nonnegative = { type: "number", minimum: 0 };
+var performanceSchema = object({
+  observedSince: count,
+  at: count,
+  sessionCreatedAt: count,
+  sessionOutputTokens: count,
+  status: enumeration("waiting", "streaming", "idle", "unavailable"),
+  partial: { type: "boolean" },
+  liveTps: nonnegative,
+  averageModelTps: nonnegative,
+  averageSessionTps: nonnegative,
+  ttftMs: nonnegative,
+  latestRequestTps: nonnegative,
+  requestId: text,
+  requestAgent: text,
+  requestModel: text,
+  requestOutputTokens: count,
+  requestStartedAt: count,
+  firstOutputAt: count,
+  streamEndedAt: count,
+  estimatedOutputTokens: nonnegative,
+  modelOutputTokens: nonnegative,
+  modelDurationMs: nonnegative,
+  completedRequests: count,
+  tokenSource: enumeration("estimated", "reported", "unavailable")
+}, [
+  "sessionCreatedAt",
+  "observedSince",
+  "at",
+  "status",
+  "partial",
+  "estimatedOutputTokens",
+  "modelOutputTokens",
+  "modelDurationMs",
+  "completedRequests",
+  "tokenSource"
+]);
+var performanceRow = {
+  ...row,
+  properties: { ...row.properties, performance: performanceSchema }
+};
+var performanceBatchSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow)
+});
+var performanceResultSchema = object({
+  ...batchFields,
+  upserts: array(performanceRow),
+  unavailable: resultSchema.properties.unavailable ?? {}
+});
+var performanceRpc = Rpc.define({
+  id: "context-guard.monitor.v2",
+  methods: { read: { input: readSchema, output: performanceResultSchema } },
+  events: { changed: { schema: performanceBatchSchema } }
+});
+function isPerformanceBatch(value) {
+  return valid(value, performanceBatchSchema) && uniqueRows(value);
+}
+function isPerformanceResult(value) {
+  return valid(value, performanceResultSchema) && uniqueRows(value);
+}
+function isPerformanceSnapshot(value) {
+  return valid(value, performanceSchema);
+}
+var chartPointSchema = object({
+  time: count,
+  agent: text,
+  model: text,
+  breakBefore: { type: "boolean" },
+  partial: { type: "boolean" },
+  liveTps: nonnegative,
+  averageModelTps: nonnegative,
+  averageSessionTps: nonnegative,
+  sessionOutputTokens: count
+}, ["time", "breakBefore", "partial"]);
+var chartRequestSchema = object({
+  time: count,
+  requestId: text,
+  started: count,
+  agent: text,
+  model: text,
+  ttftMs: nonnegative,
+  outputTokens: count,
+  durationMs: nonnegative,
+  tps: nonnegative,
+  partial: { type: "boolean" }
+}, ["time", "requestId", "started", "partial"]);
+var historyReadSchema = object({
+  schemaVersion: { const: 1 },
+  sessionId: text,
+  from: count,
+  to: count,
+  maxPoints: { type: "integer", minimum: 16, maximum: 500 }
+});
+var historyResultSchema = object({
+  schemaVersion: { const: 1 },
+  generatedAt: count,
+  enabled: { type: "boolean" },
+  truncated: { type: "boolean" },
+  metadata: object({
+    schema: { const: 1 },
+    retainedFrom: count,
+    retainedBytes: count,
+    skippedBytes: count,
+    malformedRecords: count,
+    completeness: enumeration("bounded-retention")
+  }, [
+    "schema",
+    "retainedBytes",
+    "skippedBytes",
+    "malformedRecords",
+    "completeness"
+  ]),
+  data: object({
+    schema: { const: 1 },
+    omittedSessions: count,
+    omittedGaps: count,
+    maxPoints: count,
+    gaps: array(object({ time: count, sessionId: text, reason: text }), 128),
+    series: array(object({
+      sessionId: text,
+      parentId: text,
+      agents: array(text, 1024),
+      models: array(text, 1024),
+      points: array(chartPointSchema, 500),
+      requests: array(chartRequestSchema, 500),
+      originalPoints: count
+    }, [
+      "sessionId",
+      "agents",
+      "models",
+      "points",
+      "requests",
+      "originalPoints"
+    ]), 1)
+  }, ["schema", "omittedSessions", "maxPoints", "gaps", "series"])
+});
+var historyRpc = Rpc.define({
+  id: "context-guard.history.v1",
+  methods: { read: { input: historyReadSchema, output: historyResultSchema } },
+  events: {}
+});
+function isHistoryRead(value) {
+  return valid(value, historyReadSchema) && record(value) && typeof value.from === "number" && typeof value.to === "number" && value.from <= value.to && value.to - value.from <= 7 * 86400000;
+}
+function isHistoryResult(value) {
+  return valid(value, historyResultSchema);
+}
+function record(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function matches(value, schema) {
+  if (!record(schema))
+    return false;
+  if ("const" in schema && value !== schema.const)
+    return false;
+  if (Array.isArray(schema.enum) && !schema.enum.includes(value))
+    return false;
+  if (schema.type === "number" || schema.type === "integer")
+    return typeof value === "number" && Number.isFinite(value) && (schema.type !== "integer" || Number.isSafeInteger(value)) && (typeof schema.minimum !== "number" || value >= schema.minimum) && (typeof schema.maximum !== "number" || value <= schema.maximum);
+  if (schema.type === "string")
+    return typeof value === "string" && value.length > 0 && value.length <= 512;
+  if (schema.type === "boolean")
+    return typeof value === "boolean";
+  if (schema.type === "array")
+    return Array.isArray(value) && value.length <= Number(schema.maxItems) && (!schema.uniqueItems || new Set(value).size === value.length) && value.every((v) => matches(v, schema.items));
+  if (schema.type === "object") {
+    if (!record(value) || !record(schema.properties) || !Array.isArray(schema.required))
+      return false;
+    const properties = schema.properties;
+    return schema.required.every((k) => typeof k === "string" && (k in value)) && Object.keys(value).every((k) => (k in properties) && matches(value[k], properties[k]));
+  }
+  return "const" in schema;
+}
+function valid(value, schema) {
+  try {
+    return JSON.stringify(value).length <= 524288 && matches(value, schema);
+  } catch {
+    return false;
+  }
+}
+function isRead(value) {
+  return valid(value, readSchema);
+}
+function isBatch(value) {
+  return valid(value, batchSchema) && uniqueRows(value);
+}
+function isResult(value) {
+  return valid(value, resultSchema) && uniqueRows(value);
+}
+function uniqueRows(value) {
+  if (!record(value) || !Array.isArray(value.upserts) || !Array.isArray(value.removed))
+    return false;
+  const ids = [...value.upserts, ...value.removed].map((v) => record(v) ? v.sessionId : undefined);
+  return ids.length <= 128 && new Set(ids).size === ids.length;
+}
+
+// src/tui.tsx
+import { effect as _$effect5 } from "@opentui/solid";
+import { createTextNode as _$createTextNode4 } from "@opentui/solid";
+import { insertNode as _$insertNode4 } from "@opentui/solid";
+import { setProp as _$setProp5 } from "@opentui/solid";
+import { createElement as _$createElement5 } from "@opentui/solid";
+import { createComponent as _$createComponent5 } from "@opentui/solid";
+import { Plugin } from "@opencode/plugin/tui";
+import { Show as Show4 } from "solid-js";
+
+// src/tui/state.ts
+import { createSignal } from "solid-js";
+
+// src/family.ts
+function metric(snapshot, now, staleMs) {
+  const m = snapshot?.measurement;
+  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 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 } : {},
+    ...valid2 && t !== undefined ? { triggerDeltaTokens: t - m.tokens } : {}
+  };
+}
+function familyRows(nodes, snapshots, current, now, staleMs, expanded = new Set, limit = 1024, timing, stableOrder = []) {
+  const byId = new Map(nodes.map((n) => [n.sessionId, n]));
+  const children = new Map;
+  for (const n of byId.values()) {
+    const parent = n.parentId && byId.has(n.parentId) ? n.parentId : "";
+    const list = children.get(parent) ?? [];
+    list.push(n);
+    children.set(parent, list);
+  }
+  const metrics = new Map([...byId.keys()].map((id) => [
+    id,
+    metric(snapshots.get(id), timing?.(id).now ?? now, timing?.(id).staleMs ?? staleMs)
+  ]));
+  const protectedIds = new Set;
+  let ancestor = byId.get(current);
+  while (ancestor && !protectedIds.has(ancestor.sessionId)) {
+    protectedIds.add(ancestor.sessionId);
+    ancestor = ancestor.parentId ? byId.get(ancestor.parentId) : undefined;
+  }
+  const scores = new Map, sensitive = new Map, sizes = new Map;
+  const calculate = (n, seen) => {
+    if (seen.has(n.sessionId))
+      return -1;
+    if (scores.has(n.sessionId))
+      return scores.get(n.sessionId) ?? -1;
+    const path = new Set(seen).add(n.sessionId), m = metrics.get(n.sessionId);
+    let score = m?.pressureRatio ?? -1, size = 1;
+    let keep = protectedIds.has(n.sessionId) || n.status === "running" || m?.pressure === "crossed" || ["blocked", "uncertain"].includes(snapshots.get(n.sessionId)?.compaction.phase ?? "");
+    for (const child of children.get(n.sessionId) ?? []) {
+      score = Math.max(score, calculate(child, path));
+      size += sizes.get(child.sessionId) ?? 0;
+      keep ||= sensitive.get(child.sessionId) ?? false;
+    }
+    scores.set(n.sessionId, score);
+    sizes.set(n.sessionId, size);
+    sensitive.set(n.sessionId, keep);
+    return score;
+  };
+  for (const n of byId.values())
+    calculate(n, new Set);
+  const visited = new Set, rows = [];
+  const visit = (n, depth) => {
+    if (visited.has(n.sessionId) || rows.length >= limit || depth > 64)
+      return;
+    visited.add(n.sessionId);
+    const snapshot = snapshots.get(n.sessionId), m = metrics.get(n.sessionId) ?? metric(undefined, now, staleMs);
+    const collapsed = n.status === "completed" && !sensitive.get(n.sessionId) && !expanded.has(n.sessionId);
+    rows.push({
+      node: n,
+      ...snapshot ? { snapshot } : {},
+      depth,
+      current: n.sessionId === current,
+      ...m,
+      hidden: collapsed ? (sizes.get(n.sessionId) ?? 1) - 1 : 0
+    });
+    if (collapsed) {
+      const pending = [...children.get(n.sessionId) ?? []];
+      while (pending.length) {
+        const child = pending.pop();
+        if (!child || visited.has(child.sessionId))
+          continue;
+        visited.add(child.sessionId);
+        pending.push(...children.get(child.sessionId) ?? []);
+      }
+    }
+    if (!collapsed)
+      for (const child of sorted(children.get(n.sessionId) ?? []))
+        visit(child, depth + 1);
+  };
+  const ranks = new Map(stableOrder.map((id, i) => [id, i]));
+  const sorted = (items) => [...items].sort((a, b) => (stableOrder.length ? (ranks.get(a.sessionId) ?? Infinity) - (ranks.get(b.sessionId) ?? Infinity) : 0) || (scores.get(b.sessionId) ?? -1) - (scores.get(a.sessionId) ?? -1) || a.sessionId.localeCompare(b.sessionId));
+  for (const n of sorted(children.get("") ?? []))
+    visit(n, 0);
+  for (const n of byId.values())
+    if (!visited.has(n.sessionId) && rows.length < limit)
+      visit(n, 0);
+  return rows;
+}
+function executionStatus(known, nativeRunning, evidence) {
+  if (nativeRunning || evidence.startedAt !== undefined && evidence.startedAt > (evidence.terminalAt ?? -1))
+    return "running";
+  if (evidence.outcome && (evidence.terminalAt ?? -1) >= (evidence.startedAt ?? -1))
+    return evidence.outcome === "succeeded" ? "completed" : evidence.outcome === "failed" ? "failed" : "unknown";
+  return known ? "idle" : "unknown";
+}
+
+// src/tui/transport.ts
+class SnapshotClient {
+  transport;
+  changed;
+  elapsed;
+  rows = new Map;
+  health;
+  connection = "loading";
+  epoch;
+  sequence = -1;
+  revisions = new Map;
+  baselines = new Map;
+  controller;
+  generation = 0;
+  ids = [];
+  location = "";
+  refreshTimer;
+  reading;
+  buffered = [];
+  overflow = false;
+  retryTimer;
+  failures = 0;
+  serverAt = 0;
+  receivedAt = 0;
+  refreshAgain = false;
+  subscriptionActive = false;
+  constructor(transport, changed, elapsed = () => performance.now()) {
+    this.transport = transport;
+    this.changed = changed;
+    this.elapsed = elapsed;
+  }
+  now() {
+    return this.serverAt + Math.max(0, this.elapsed() - this.receivedAt);
+  }
+  setIds(ids) {
+    const next = [...new Set(ids)].slice(0, 2048);
+    if (JSON.stringify(next) === JSON.stringify(this.ids))
+      return;
+    this.ids = next;
+    const selected = new Set(next);
+    for (const id of new Set([
+      ...this.revisions.keys(),
+      ...this.baselines.keys()
+    ]))
+      if (!selected.has(id)) {
+        this.revisions.delete(id);
+        this.baselines.delete(id);
+        this.rows.delete(id);
+      }
+    if (this.reading)
+      this.refreshAgain = true;
+    else
+      this.refresh();
+  }
+  start(location, ids) {
+    this.stop();
+    this.location = location;
+    this.ids = [...new Set(ids)].slice(0, 2048);
+    this.rows.clear();
+    this.revisions.clear();
+    this.baselines.clear();
+    this.health = undefined;
+    this.epoch = undefined;
+    this.sequence = -1;
+    this.failures = 0;
+    this.connection = "loading";
+    const controller = new AbortController;
+    this.controller = controller;
+    const generation = ++this.generation;
+    this.supervise(generation, controller.signal);
+    this.refreshTimer = setInterval(() => {
+      this.refresh();
+    }, 15000);
+    this.refresh();
+  }
+  merge(batch, baseline = false, requested = []) {
+    if (this.epoch !== batch.epoch) {
+      if (!baseline) {
+        this.connection = "reconnecting";
+        this.refreshAgain = true;
+        return;
+      }
+      this.rows.clear();
+      this.revisions.clear();
+      this.baselines.clear();
+      this.epoch = batch.epoch;
+      this.sequence = -1;
+    }
+    if (!baseline && batch.sequence > this.sequence + 1) {
+      this.connection = "reconnecting";
+      this.refreshAgain = true;
+    }
+    if (batch.sequence >= this.sequence) {
+      this.sequence = batch.sequence;
+      this.health = batch.health;
+      this.serverAt = batch.generatedAt;
+      this.receivedAt = this.elapsed();
+    }
+    const selected = new Set(baseline ? requested.filter((id) => this.ids.includes(id)) : this.ids);
+    for (const row2 of batch.upserts)
+      if (selected.has(row2.sessionId) && (baseline || batch.sequence > (this.baselines.get(row2.sessionId) ?? -1)) && row2.revision > (this.revisions.get(row2.sessionId) ?? -1)) {
+        this.rows.set(row2.sessionId, row2);
+        this.revisions.set(row2.sessionId, row2.revision);
+      }
+    for (const row2 of batch.removed)
+      if (selected.has(row2.sessionId) && (baseline || batch.sequence > (this.baselines.get(row2.sessionId) ?? -1)) && row2.revision > (this.revisions.get(row2.sessionId) ?? -1)) {
+        this.rows.delete(row2.sessionId);
+        this.revisions.set(row2.sessionId, row2.revision);
+      }
+    this.changed();
+  }
+  refresh() {
+    if (this.reading)
+      return this.reading;
+    const controller = this.controller, generation = this.generation, location = this.location;
+    if (!controller)
+      return Promise.resolve();
+    clearTimeout(this.retryTimer);
+    const requestedIds = [...this.ids];
+    this.reading = (async () => {
+      const signal = AbortSignal.any([
+        controller.signal,
+        AbortSignal.timeout(5000)
+      ]);
+      const chunks = [];
+      for (let i = 0;i < requestedIds.length; i += 128)
+        chunks.push(requestedIds.slice(i, i + 128));
+      if (!chunks.length)
+        chunks.push([]);
+      const results = [];
+      for (let i = 0;i < chunks.length; i += 2) {
+        const reads = await Promise.all(chunks.slice(i, i + 2).map(async (ids) => {
+          const value = await abortable(this.transport.read(location, ids, signal), signal);
+          if (generation !== this.generation)
+            throw new Error("Obsolete read");
+          if (!isPerformanceResult(value)) {
+            this.connection = "incompatible";
+            throw new Error("Incompatible snapshot");
+          }
+          const answered = [
+            ...value.upserts.map((row2) => row2.sessionId),
+            ...value.unavailable.map((row2) => row2.sessionId)
+          ];
+          if (value.removed.length || answered.length !== ids.length || new Set(answered).size !== ids.length || answered.some((id) => !ids.includes(id)))
+            throw new Error("Incomplete snapshot read");
+          return { ids, result: value };
+        }));
+        results.push(...reads);
+      }
+      if (generation !== this.generation || signal.aborted)
+        return;
+      if (new Set(results.map((r) => r.result.epoch)).size !== 1)
+        throw new Error("Epoch changed during read");
+      for (const { ids, result } of results) {
+        this.merge(result, true, ids);
+        for (const missing of result.unavailable)
+          if (this.ids.includes(missing.sessionId))
+            this.rows.delete(missing.sessionId);
+        for (const id of ids)
+          if (this.ids.includes(id))
+            this.baselines.set(id, result.sequence);
+      }
+      const buffered = this.buffered;
+      this.buffered = [];
+      if (buffered.some((b) => b.epoch !== this.epoch) || this.overflow) {
+        this.overflow = false;
+        throw new Error("Stream changed during read");
+      }
+      for (const batch of buffered)
+        this.merge(batch);
+      this.failures = 0;
+      this.connection = this.refreshAgain || !this.subscriptionActive ? "reconnecting" : "live";
+      this.changed();
+    })().catch(() => {
+      if (generation === this.generation && !controller.signal.aborted) {
+        this.buffered = [];
+        this.overflow = false;
+        if (this.connection !== "incompatible")
+          this.connection = this.rows.size ? "reconnecting" : "unavailable";
+        this.changed();
+        this.retryTimer = setTimeout(() => {
+          this.refresh();
+        }, Math.min(30000, 1000 * 2 ** Math.min(this.failures++, 5)));
+      }
+    }).finally(() => {
+      if (generation === this.generation) {
+        this.reading = undefined;
+        if (this.refreshAgain) {
+          this.refreshAgain = false;
+          this.refresh();
+        }
+      }
+    });
+    return this.reading;
+  }
+  async supervise(generation, signal) {
+    let retry = 0;
+    while (!signal.aborted && generation === this.generation) {
+      try {
+        this.subscriptionActive = true;
+        if (retry)
+          queueMicrotask(() => {
+            if (generation === this.generation && !signal.aborted)
+              this.refresh();
+          });
+        for await (const value of this.transport.subscribe(this.location, signal)) {
+          if (signal.aborted || generation !== this.generation)
+            return;
+          if (!isPerformanceBatch(value)) {
+            this.connection = "incompatible";
+            this.changed();
+            continue;
+          }
+          if (this.reading || !this.epoch) {
+            if (this.buffered.length < 256)
+              this.buffered.push(value);
+            else
+              this.overflow = true;
+          } else {
+            this.merge(value);
+            if (this.refreshAgain) {
+              this.refreshAgain = false;
+              this.refresh();
+            }
+          }
+          retry = 0;
+        }
+      } catch {
+      }
+      if (signal.aborted || generation !== this.generation)
+        return;
+      this.subscriptionActive = false;
+      this.connection = "reconnecting";
+      this.changed();
+      await this.refresh();
+      await new Promise((resolve) => {
+        const finish = () => {
+          clearTimeout(timer);
+          signal.removeEventListener("abort", finish);
+          resolve();
+        };
+        const timer = setTimeout(finish, Math.min(30000, 1000 * 2 ** Math.min(retry++, 5)));
+        signal.addEventListener("abort", finish, { once: true });
+        if (signal.aborted)
+          finish();
+      });
+    }
+  }
+  stop() {
+    this.generation++;
+    this.controller?.abort();
+    this.controller = undefined;
+    clearInterval(this.refreshTimer);
+    clearTimeout(this.retryTimer);
+    this.reading = undefined;
+    this.buffered = [];
+    this.overflow = false;
+    this.refreshAgain = false;
+  }
+}
+function abortable(promise, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => reject(new Error("Snapshot request cancelled"));
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    signal.addEventListener("abort", abort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+  });
+}
+
+// src/tui/inventory.ts
+async function discoverFamily(client, currentId, signal, cached, maxNodes = 1024, previous) {
+  const sessions = new Map(previous?.sessions);
+  let damaged = previous?.damaged ?? false, pages = 0, rootId = previous?.rootId ?? currentId;
+  const get = async (id) => cached(id) ?? client.session.get({ sessionID: id }, { signal });
+  if (!previous) {
+    let current = await get(currentId);
+    for (let depth = 0;depth <= 64; depth++) {
+      if (signal.aborted)
+        throw signal.reason;
+      if (sessions.has(current.id) || sessions.size >= maxNodes) {
+        damaged = true;
+        break;
+      }
+      sessions.set(current.id, current);
+      rootId = current.id;
+      if (!current.parentID)
+        break;
+      if (depth === 64) {
+        damaged = true;
+        break;
+      }
+      try {
+        current = await get(current.parentID);
+      } catch {
+        if (signal.aborted)
+          throw signal.reason;
+        damaged = true;
+        break;
+      }
+    }
+  }
+  const queue = previous ? [...previous.pending] : [{ id: rootId, depth: 0, cursors: [] }];
+  const scanned = new Set(previous?.scanned);
+  while (queue.length && pages < 100) {
+    const next = queue.shift();
+    if (!next)
+      break;
+    if (!next.cursor && scanned.has(next.id)) {
+      damaged = true;
+      continue;
+    }
+    if (signal.aborted)
+      throw signal.reason;
+    try {
+      pages++;
+      const response = await client.session.list({
+        parentID: next.id,
+        limit: 100,
+        order: "desc",
+        ...next.cursor ? { cursor: next.cursor } : {}
+      }, { signal });
+      let capped = false;
+      for (const child of response.data) {
+        if (child.parentID !== next.id || child.id === next.id) {
+          damaged = true;
+          continue;
+        }
+        if (!sessions.has(child.id) && sessions.size >= maxNodes) {
+          capped = true;
+          break;
+        }
+        sessions.set(child.id, child);
+        if (!scanned.has(child.id) && !queue.some((branch) => branch.id === child.id)) {
+          if (next.depth < 64)
+            queue.push({ id: child.id, depth: next.depth + 1, cursors: [] });
+          else
+            damaged = true;
+        }
+      }
+      if (capped) {
+        queue.unshift(next);
+        break;
+      }
+      const cursor = response.cursor?.next;
+      if (cursor) {
+        if (next.cursors.includes(cursor) || cursor === next.cursor)
+          damaged = true;
+        else
+          queue.unshift({
+            ...next,
+            cursor,
+            cursors: [...next.cursors, cursor]
+          });
+      } else
+        scanned.add(next.id);
+    } catch {
+      if (signal.aborted)
+        throw signal.reason;
+      damaged = true;
+    }
+  }
+  return {
+    sessions,
+    complete: !damaged && !queue.length,
+    rootId,
+    pages: (previous?.pages ?? 0) + pages,
+    pending: queue,
+    scanned,
+    damaged
+  };
+}
+
+// src/tui/state.ts
+function createGuardState(context) {
+  const [version, setVersion] = createSignal(0);
+  const notify = () => {
+    setVersion((n) => n + 1);
+    scheduleExpiry();
+  };
+  const rpc = context.client.rpc(monitorRpc);
+  const liveRpc = context.client.rpc(performanceRpc);
+  const clients = new Map;
+  let inventory, currentId = "", controller;
+  let scanGeneration = 0, scanning = false, maxNodes = 1024;
+  let scanFailed = false;
+  const consumers = new Map;
+  const [preferences, savePreferences] = context.storage.store("context-guard.ui.v1", { initial: { expanded: [] } });
+  const expanded = new Set(Array.isArray(preferences.expanded) ? preferences.expanded.filter((id) => typeof id === "string" && id.length <= 512).slice(0, 1024) : []);
+  const evidence = new Map;
+  let expiryTimer;
+  function scheduleExpiry() {
+    clearTimeout(expiryTimer);
+    if (!consumers.size)
+      return;
+    let delay = Infinity;
+    for (const client of clients.values())
+      for (const row2 of client.rows.values()) {
+        if (!row2.measurement || !client.health)
+          continue;
+        const remaining = row2.measurement.at + client.health.staleMs + 1 - client.now();
+        if (remaining > 0)
+          delay = Math.min(delay, remaining);
+      }
+    if (Number.isFinite(delay))
+      expiryTimer = setTimeout(notify, Math.min(2147483647, Math.ceil(delay)));
+  }
+  let ageTimer, scanTimer, eventTimer;
+  let unlisten;
+  function select() {
+    const id = [...consumers.values()].at(-1);
+    if (!id || id === currentId)
+      return;
+    controller?.abort();
+    scanGeneration++;
+    scanning = false;
+    for (const c of clients.values())
+      c.stop();
+    clients.clear();
+    currentId = id;
+    inventory = undefined;
+    evidence.clear();
+    maxNodes = 1024;
+    let scanFailed2 = false;
+    notify();
+    scan();
+  }
+  async function scan(more = false) {
+    if (scanning || !currentId || !consumers.size)
+      return;
+    scanning = true;
+    const generation = ++scanGeneration;
+    controller?.abort();
+    controller = new AbortController;
+    const signal = AbortSignal.any([
+      controller.signal,
+      AbortSignal.timeout(15000)
+    ]);
+    try {
+      const next = await discoverFamily(context.client, currentId, signal, (id) => context.data.session.get(id), maxNodes, more ? inventory : undefined);
+      if (signal.aborted || generation !== scanGeneration)
+        return;
+      inventory = next;
+      scanFailed = false;
+      for (const id of evidence.keys())
+        if (!next.sessions.has(id))
+          evidence.delete(id);
+      const groups = new Map;
+      for (const s of next.sessions.values()) {
+        const key = locationKey(s.location), group = groups.get(key) ?? { ids: [] };
+        group.ids.push(s.id);
+        groups.set(key, group);
+      }
+      for (const [key, c] of clients)
+        if (!groups.has(key)) {
+          c.stop();
+          clients.delete(key);
+        }
+      for (const [key, group] of groups) {
+        const sample = next.sessions.get(group.ids[0] ?? "");
+        if (!sample)
+          continue;
+        let c = clients.get(key);
+        if (!c) {
+          const location = sample.location;
+          let selectedRpc = rpc;
+          try {
+            const probe = await liveRpc.read({ schemaVersion: 1, sessionIds: [] }, { location, signal });
+            if (isPerformanceResult(probe))
+              selectedRpc = liveRpc;
+          } catch {
+          }
+          if (signal.aborted || generation !== scanGeneration)
+            return;
+          const source = selectedRpc;
+          c = new SnapshotClient({
+            read: (_key, ids, requestSignal) => source.read({ schemaVersion: 1, sessionIds: ids }, { location, signal: requestSignal }),
+            subscribe: async function* (_key, requestSignal) {
+              for await (const event of source.events.subscribe("changed", {
+                signal: requestSignal
+              })) {
+                if (event.location && sameLocation(event.location, location))
+                  yield event.data;
+              }
+            }
+          }, notify);
+          clients.set(key, c);
+          c.start(key, group.ids);
+        } else
+          c.setIds(group.ids);
+      }
+      notify();
+    } catch {
+      if (generation === scanGeneration && !controller?.signal.aborted) {
+        scanFailed = true;
+        notify();
+      }
+    } finally {
+      if (generation === scanGeneration)
+        scanning = false;
+    }
+  }
+  function acquire(id) {
+    const token = Symbol();
+    consumers.set(token, id);
+    if (consumers.size === 1) {
+      ageTimer = setInterval(notify, 1000);
+      scanTimer = setInterval(() => {
+        scan();
+      }, 30000);
+      unlisten = context.data.listen(({ details: event }) => {
+        if (!("sessionID" in event.data) || !inventory?.sessions.has(event.data.sessionID)) {
+          if (event.type !== "session.created")
+            return;
+        }
+        if ("created" in event && "sessionID" in event.data && event.type.startsWith("session.execution.")) {
+          const id2 = event.data.sessionID, previous = evidence.get(id2) ?? {};
+          if (event.type === "session.execution.started")
+            evidence.set(id2, {
+              ...previous,
+              startedAt: Math.max(previous.startedAt ?? 0, event.created)
+            });
+          if ([
+            "session.execution.succeeded",
+            "session.execution.failed",
+            "session.execution.interrupted"
+          ].includes(event.type) && event.created >= (previous.terminalAt ?? 0)) {
+            const outcome = event.type === "session.execution.succeeded" ? "succeeded" : event.type === "session.execution.failed" ? "failed" : "interrupted";
+            evidence.set(id2, {
+              ...previous,
+              terminalAt: event.created,
+              outcome
+            });
+          }
+          notify();
+        }
+        if ([
+          "session.created",
+          "session.deleted",
+          "session.model.selected",
+          "session.agent.selected"
+        ].includes(event.type)) {
+          clearTimeout(eventTimer);
+          eventTimer = setTimeout(() => {
+            scan();
+          }, 100);
+        }
+      });
+    }
+    select();
+    return {
+      update(next) {
+        consumers.set(token, next);
+        select();
+      },
+      release() {
+        consumers.delete(token);
+        if (consumers.size)
+          select();
+        else
+          stop();
+      }
+    };
+  }
+  function stop() {
+    controller?.abort();
+    scanGeneration++;
+    scanning = false;
+    for (const c of clients.values())
+      c.stop();
+    clients.clear();
+    clearTimeout(expiryTimer);
+    clearInterval(ageTimer);
+    clearInterval(scanTimer);
+    clearTimeout(eventTimer);
+    unlisten?.();
+    unlisten = undefined;
+    inventory = undefined;
+    evidence.clear();
+    currentId = "";
+  }
+  function rows(stableOrder = [], allDescendants = false) {
+    version();
+    const snapshots = new Map([...clients.values()].flatMap((c2) => [...c2.rows]));
+    const nodes = [...inventory?.sessions.values() ?? []].map((original) => {
+      const s = context.data.session.get(original.id) ?? original;
+      const observed = evidence.get(s.id) ?? {};
+      const metadataAt = s.time.idle ?? 0;
+      const e = s.outcome && metadataAt >= (observed.terminalAt ?? 0) ? { ...observed, outcome: s.outcome, terminalAt: metadataAt } : observed;
+      return {
+        sessionId: s.id,
+        ...s.parentID ? { parentId: s.parentID } : {},
+        ...s.agent ? { agent: s.agent } : {},
+        ...s.model ? { model: `${s.model.providerID}/${s.model.id}` } : {},
+        ...e.outcome === "interrupted" ? { interrupted: true } : {},
+        status: executionStatus(true, context.data.session.status(s.id) === "running", e)
+      };
+    });
+    const c = [...clients.values()].find((c2) => c2.rows.has(currentId)) ?? clients.values().next().value;
+    return familyRows(nodes, snapshots, currentId, c?.now() ?? Date.now(), c?.health?.staleMs ?? 300000, allDescendants ? new Set(nodes.map((node) => node.sessionId)) : expanded, maxNodes, (id) => {
+      const session = inventory?.sessions.get(id);
+      const client = session ? clients.get(locationKey(session.location)) : undefined;
+      return {
+        now: client?.now() ?? Date.now(),
+        staleMs: client?.health?.staleMs ?? 300000
+      };
+    }, stableOrder);
+  }
+  return {
+    version,
+    acquire,
+    async history(id, from, to, signal) {
+      const info = inventory?.sessions.get(id);
+      if (!info)
+        throw new Error("Session location unavailable");
+      const result = await context.client.rpc(historyRpc).read({ schemaVersion: 1, sessionId: id, from, to, maxPoints: 240 }, { location: info.location, signal });
+      if (!isHistoryResult(result))
+        throw new Error("Incompatible history service");
+      return result;
+    },
+    rows,
+    dispose: stop,
+    age(id) {
+      version();
+      const c = [...clients.values()].find((c2) => c2.rows.has(id));
+      const m = c?.rows.get(id)?.measurement;
+      return c && m ? c.now() - m.at : 0;
+    },
+    health() {
+      version();
+      return [...clients.values()].find((c) => c.rows.has(currentId))?.health ?? clients.values().next().value?.health;
+    },
+    connection() {
+      version();
+      return clients.size ? [...clients.values()].map((c) => c.connection).find((c) => c !== "live") ?? "live" : scanFailed ? "unavailable" : "loading";
+    },
+    complete() {
+      version();
+      return inventory?.complete ?? false;
+    },
+    refresh() {
+      scan();
+      for (const c of clients.values())
+        c.refresh();
+    },
+    loadMore() {
+      maxNodes = Math.min(2048, maxNodes + 1024);
+      scan(true);
+    },
+    expand(id) {
+      if (expanded.has(id))
+        expanded.delete(id);
+      else if (expanded.size < 1024)
+        expanded.add(id);
+      savePreferences((draft) => {
+        draft.expanded = [...expanded];
+      }).catch(() => {
+      });
+      notify();
+    }
+  };
+}
+function locationKey(location) {
+  return JSON.stringify([location.directory, location.workspaceID ?? null]);
+}
+function sameLocation(a, b) {
+  if (a.workspaceID && b.workspaceID)
+    return a.workspaceID === b.workspaceID;
+  return a.directory === b.directory;
+}
+
+// src/tui/sidebar.tsx
+import { effect as _$effect2 } from "@opentui/solid";
+import { createComponent as _$createComponent2 } from "@opentui/solid";
+import { insert as _$insert2 } from "@opentui/solid";
+import { createTextNode as _$createTextNode2 } from "@opentui/solid";
+import { insertNode as _$insertNode2 } from "@opentui/solid";
+import { memo as _$memo2 } from "@opentui/solid";
+import { setProp as _$setProp2 } from "@opentui/solid";
+import { createElement as _$createElement2 } from "@opentui/solid";
+import { For as For2, createEffect as createEffect2, createMemo as createMemo2, onCleanup, Show as Show2 } from "solid-js";
+
+// src/tui/format.ts
+function quantity(n) {
+  return n === undefined || !Number.isFinite(n) ? "?" : Math.abs(n) >= 1e6 ? `${(n / 1e6).toFixed(1)}m` : Math.abs(n) >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+var segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+function cells(value) {
+  return [...segmenter.segment(value)].reduce((n, { segment }) => n + graphemeWidth(segment), 0);
+}
+function graphemeWidth(s) {
+  const cp = s.codePointAt(0) ?? 0;
+  if (/^[\p{Mark}\u200d\ufe0f]+$/u.test(s))
+    return 0;
+  return /[\p{Extended_Pictographic}\p{Regional_Indicator}\u20e3]/u.test(s) || cp >= 4352 && (cp <= 4447 || cp >= 9001 && cp <= 9002 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65040 && cp <= 65135 || cp >= 65281 && cp <= 65376 || cp >= 131072) ? 2 : 1;
+}
+function clip(value, width) {
+  const clean = sanitize(value);
+  if (cells(clean) <= width)
+    return clean;
+  let result = "", used = 0;
+  for (const { segment } of segmenter.segment(clean)) {
+    const size = graphemeWidth(segment);
+    if (used + size > Math.max(0, width - 3))
+      break;
+    result += segment;
+    used += size;
+  }
+  return width < 3 ? ".".repeat(Math.max(0, width)) : result + "...";
+}
+var statuses = {
+  running: "RUN",
+  idle: "IDLE",
+  completed: "DONE",
+  failed: "FAIL",
+  unknown: "?"
+};
+function rowLines(row2, width) {
+  const s = row2.snapshot, m = s?.measurement;
+  const prefix = row2.current ? "* " : row2.depth > 5 ? ".../" : " ".repeat(Math.min(row2.depth, 5)) + "|-";
+  const percent = row2.utilizationPercent === undefined ? "?" : `${row2.utilizationPercent.toFixed(1)}%`;
+  const warning = row2.freshness === "stale" ? " STALE" : row2.pressure === "crossed" ? " !! crossed" : row2.pressure === "near" ? " ! near" : "";
+  const suffix = ` ${statuses[row2.node.status]} ${m?.confidence === "approximate" ? "~" : ""}${percent}${warning}`;
+  const label = clip(`${prefix}${row2.node.agent ?? row2.node.sessionId}`, Math.max(1, width - cells(suffix)));
+  return [
+    clip(`${label}${suffix}`, width),
+    ...performanceLines(row2, width),
+    ...wrap(`${quantity(m?.tokens)}/${quantity(s?.capacityTokens)} input; to ${quantity(row2.triggerDeltaTokens)}`, width),
+    ...s && s.compaction.phase !== "idle" ? wrap(`compact: ${s.compaction.phase}`, width) : [],
+    ...row2.node.interrupted ? [clip("interrupted", width)] : [],
+    ...row2.hidden ? wrap(`+ ${row2.hidden} completed descendants`, width) : []
+  ];
+}
+function detailLines(row2, width, expanded = false, ageMs = 0) {
+  const s = row2?.snapshot, m = s?.measurement;
+  if (!row2)
+    return wrap("Loading session family...", width);
+  if (!s)
+    return [
+      ...wrap(`${row2.node.agent ?? row2.node.sessionId} / ${row2.node.model ?? "?"}`, width),
+      ...wrap("Guard: not monitored / unavailable", width)
+    ];
+  const threshold = s.policy.configured;
+  const headroom = row2.triggerDeltaTokens;
+  const lines = [
+    `${s.agent ?? "?"} / ${s.model ?? "?"}`,
+    ...performanceLines(row2, width),
+    `${m?.confidence === "approximate" ? "~" : ""}${quantity(m?.tokens)} / ${quantity(s.capacityTokens)} input`,
+    `${row2.utilizationPercent?.toFixed(1) ?? "?"}% ${row2.pressure === "crossed" ? "!! crossed" : row2.pressure === "near" ? "! near" : row2.freshness.toUpperCase()}`,
+    `Trigger ${threshold.type === "ratio" ? `${threshold.value * 100}%` : `${threshold.value} ${threshold.type}`} (${s.policy.comparison})`,
+    `Resolved trigger ${s.policy.triggerTokens ?? "?"}`,
+    `Until trigger ${quantity(headroom)}`,
+    `Compact: ${s.compaction.phase}`,
+    `${s.compaction.armed ? "armed" : "disarmed"}${s.compaction.blockedReason ? ` / ${s.compaction.blockedReason}` : ""}`,
+    m ? `${m.confidence} ${m.scope}` : "measurement unknown",
+    m ? `${Math.floor(Math.max(0, ageMs) / 1000)}s ago; ${row2.freshness}` : ""
+  ];
+  if (expanded)
+    lines.push(`Policy ${s.policy.id}: ${s.policy.reason}`, `Limits in/context/out ${quantity(s.limits?.input)}/${quantity(s.limits?.context)}/${quantity(s.limits?.output)}`, `Output reserve ${quantity(s.outputReserveTokens)}`, `Provenance ${m?.provenance ?? "?"}`, `Cooldown until ${s.compaction.cooldownUntil ?? "?"}`, `Cumulative (${s.cumulativeScope})`, `Input ${quantity(s.cumulative?.input)} output ${quantity(s.cumulative?.output)}`, `Reasoning ${quantity(s.cumulative?.reasoning)}`, `Cache read ${quantity(s.cumulative?.cache.read)} write ${quantity(s.cumulative?.cache.write)}`);
+  return lines.filter(Boolean).flatMap((line) => wrap(line, width));
+}
+function sanitize(value) {
+  return value.replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "");
+}
+function wrap(value, width) {
+  const result = [];
+  let part = "";
+  for (const word of sanitize(value).split(" ")) {
+    if (part && cells(part + " " + word) > width) {
+      result.push(part);
+      part = "";
+    }
+    for (const { segment } of segmenter.segment((part ? " " : "") + word)) {
+      if (part && cells(part + segment) > width) {
+        result.push(part);
+        part = "";
+      }
+      part += cells(segment) <= width ? segment : "?";
+    }
+  }
+  if (part)
+    result.push(part);
+  return result;
+}
+function performanceLines(row2, width) {
+  const p = row2.snapshot?.performance;
+  if (!p)
+    return [];
+  const value = (n) => n === undefined ? "?" : n.toFixed(1);
+  return [
+    ...wrap(`TPS ${p.status === "waiting" ? "waiting" : `${p.status === "streaming" ? "~" : ""}${value(p.liveTps)}`} \xB7 ${p.status}${p.partial ? " \xB7 partial" : ""}`, width),
+    ...wrap(`Avg model ${value(p.averageModelTps)} \xB7 Avg session ${value(p.averageSessionTps)}`, width),
+    ...wrap(`TTFT ${p.ttftMs === undefined ? "?" : `~${(p.ttftMs / 1000).toFixed(2)}s`}${p.latestRequestTps === undefined ? "" : ` \xB7 Last ${value(p.latestRequestTps)} t/s`}`, width)
+  ];
+}
+
+// src/tui/compact.tsx
+import { createTextNode as _$createTextNode } from "@opentui/solid";
+import { insertNode as _$insertNode } from "@opentui/solid";
+import { setProp as _$setProp } from "@opentui/solid";
+import { effect as _$effect } from "@opentui/solid";
+import { insert as _$insert } from "@opentui/solid";
+import { memo as _$memo } from "@opentui/solid";
+import { createElement as _$createElement } from "@opentui/solid";
+import { createComponent as _$createComponent } from "@opentui/solid";
+import { For, Index, Show, createEffect, createMemo, createSignal as createSignal2 } from "solid-js";
+
+// src/tui/compactformat.ts
+function tokens(value) {
+  if (value === undefined || !Number.isFinite(value))
+    return "?";
+  const magnitude = Math.abs(value);
+  if (magnitude >= 1e6)
+    return `${+(value / 1e6).toFixed(1)}M`;
+  if (magnitude >= 1000)
+    return `${+(value / 1000).toFixed(1)}K`;
+  return String(value);
+}
+function columns(left, right, width) {
+  if (cells(left) + cells(right) + 1 > width)
+    return [...wrap(left, width), ...wrap(right, width)];
+  return [left + " ".repeat(width - cells(left) - cells(right)) + right];
+}
+function progress(ratio, width) {
+  const valid2 = ratio !== undefined && Number.isFinite(ratio) && ratio >= 0;
+  const label = valid2 ? `${Math.round(ratio * 100)}%` : "?%";
+  const size = Math.max(1, width - cells(label) - 1);
+  const filled = valid2 ? Math.round(Math.min(1, ratio) * size) : 0;
+  return clip("\u2588".repeat(filled) + "\u2591".repeat(size - filled) + " " + label, width);
+}
+function mainSections(row2, width, age) {
+  if (!row2)
+    return [{ tone: "base", lines: wrap("Loading session family...", width) }];
+  const s = row2.snapshot, m = s?.measurement;
+  const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
+  const measured = valid2 ? m?.tokens : undefined;
+  const ratio = (total) => measured !== undefined && total !== undefined && total > 0 ? measured / total : undefined;
+  const remaining = measured !== undefined && s?.policy.triggerTokens !== undefined ? s.policy.triggerTokens - measured : undefined;
+  return [
+    ...row2.snapshot?.performance ? [{ tone: "base", lines: performanceLines(row2, width) }] : [],
+    {
+      tone: "execution",
+      lines: columns(`${row2.node.agent ?? s?.agent ?? "Main"} \xB7 ${row2.node.model ?? s?.model ?? "?"}`, row2.node.status.toUpperCase(), width)
+    },
+    {
+      tone: "base",
+      lines: [
+        "",
+        ...columns("Context", `${tokens(measured)} / ${tokens(s?.capacityTokens)}`, width)
+      ]
+    },
+    { tone: "pressure", lines: [progress(ratio(s?.capacityTokens), width)] },
+    {
+      tone: "base",
+      lines: [
+        "",
+        ...columns("Compact threshold", `${tokens(measured)} / ${tokens(s?.policy.triggerTokens)}`, width)
+      ]
+    },
+    {
+      tone: "pressure",
+      lines: [
+        progress(ratio(s?.policy.triggerTokens), width),
+        ...wrap(remaining === undefined ? "Compaction distance unknown" : remaining < 0 ? `${tokens(-remaining)} tokens over threshold` : `${tokens(remaining)} tokens until compaction`, width)
+      ]
+    },
+    {
+      tone: "measurement",
+      lines: [
+        "",
+        ...wrap(`Measurement: ${m?.confidence ?? "unknown"}${m ? ` \xB7 ${Math.floor(Math.max(0, age) / 1000)}s ago` : ""}${row2.freshness !== "fresh" ? ` \xB7 ${row2.freshness.toUpperCase()}` : ""}`, width)
+      ]
+    },
+    {
+      tone: "base",
+      lines: [
+        ...s && s.compaction.phase !== "idle" ? wrap(`Compact: ${s.compaction.phase}`, width) : [],
+        ...!s ? wrap("Guard: not monitored / unavailable", width) : []
+      ]
+    }
+  ];
+}
+var statusSymbol = {
+  running: "\u25CF",
+  idle: "\u25CC",
+  unknown: "\u25CC",
+  completed: "\u2713",
+  failed: "\u2715"
+};
+function agentHeading(row2, width) {
+  const name = `${statusSymbol[row2.node.status]} ${row2.node.agent ?? row2.node.sessionId}`;
+  const percent = row2.utilizationPercent === undefined ? "?%" : `${Math.round(row2.utilizationPercent)}%`;
+  return cells(name) + cells(percent) + 1 <= width ? columns(name, percent, width)[0] ?? "" : clip(name, width);
+}
+function agentLines(row2, width) {
+  const valid2 = row2.freshness === "fresh" || row2.freshness === "stale";
+  const measured = valid2 ? row2.snapshot?.measurement?.tokens : undefined;
+  const capacity = row2.snapshot?.capacityTokens;
+  const pressure = row2.pressure === "crossed" ? "CRITICAL" : row2.pressure === "near" ? "WARNING" : "";
+  return [
+    ...performanceLines(row2, width),
+    progress(measured !== undefined && capacity !== undefined && capacity > 0 ? measured / capacity : undefined, width),
+    ...wrap(`${tokens(measured)} / ${tokens(capacity)}${pressure ? ` \xB7 ${pressure}` : ""}`, width),
+    ...wrap(`${row2.node.status.toUpperCase()}${row2.freshness !== "fresh" ? ` \xB7 ${row2.freshness.toUpperCase()}` : ""}${row2.node.interrupted ? " \xB7 interrupted" : ""}`, width),
+    ...row2.snapshot && row2.snapshot.compaction.phase !== "idle" ? wrap(`Compact: ${row2.snapshot.compaction.phase}`, width) : []
+  ];
+}
+function subagentTree(rows, sessionID, collapsed, hideCompleted, byPressure) {
+  const children = new Map;
+  for (const row2 of rows) {
+    if (!row2.node.parentId || row2.node.sessionId === sessionID)
+      continue;
+    const list = children.get(row2.node.parentId) ?? [];
+    list.push(row2);
+    children.set(row2.node.parentId, list);
+  }
+  const seen = new Set([sessionID]);
+  const all = [];
+  const build = (id, depth) => {
+    if (depth > 64)
+      return [];
+    const branches2 = [];
+    for (const row2 of children.get(id) ?? []) {
+      if (seen.has(row2.node.sessionId))
+        continue;
+      seen.add(row2.node.sessionId);
+      all.push(row2);
+      const nested = build(row2.node.sessionId, depth + 1);
+      if (hideCompleted && row2.node.status === "completed" && !nested.length)
+        continue;
+      branches2.push({
+        row: row2,
+        children: nested,
+        active: row2.node.status === "running" || nested.some((b) => b.active),
+        pressure: Math.max(row2.pressureRatio ?? -1, ...nested.map((b) => b.pressure))
+      });
+    }
+    return branches2.sort((a, b) => Number(b.active) - Number(a.active) || (byPressure ? b.pressure - a.pressure : 0));
+  };
+  const branches = build(sessionID, 0);
+  const visible = [];
+  const visit = (items, depth) => {
+    for (const item of items) {
+      visible.push({
+        row: item.row,
+        depth,
+        hasChildren: !!item.children.length
+      });
+      if (!collapsed.has(item.row.node.sessionId))
+        visit(item.children, depth + 1);
+    }
+  };
+  visit(branches, 0);
+  return { all, visible };
+}
+function statistics(rows, sessionID, complete, width) {
+  const sum = (value) => {
+    const values = rows.map(value);
+    return complete && values.length && values.every((n) => n !== undefined) ? values.reduce((total, n) => total + (n ?? 0), 0) : undefined;
+  };
+  return [
+    ...columns("Compactions", tokens(sum((r) => r.snapshot?.compaction.count)), width),
+    ...columns("Active subagents", String(rows.filter((r) => r.node.sessionId !== sessionID && r.node.status === "running").length), width),
+    ...columns("Family peaks (sum)", tokens(sum((r) => r.snapshot?.peakTokens)), width),
+    ...wrap("Observed \xB7 separate windows", width)
+  ];
+}
+
+// src/tui/compact.tsx
+function CompactSidebar(props) {
+  const [measuredWidth, setMeasuredWidth] = createSignal2(props.width);
+  const width = () => Math.max(1, Math.min(props.width, measuredWidth()) - 4);
+  const [collapsed, setCollapsed] = createSignal2(new Set);
+  const [hideCompleted, setHideCompleted] = createSignal2(false);
+  const [byPressure, setByPressure] = createSignal2(true);
+  createEffect(() => {
+    props.sessionID;
+    setCollapsed(new Set);
+  });
+  const current = createMemo(() => props.rows.find((r) => r.node.sessionId === props.sessionID));
+  const tree = createMemo(() => subagentTree(props.rows, props.sessionID, collapsed(), hideCompleted(), byPressure()));
+  const entries = createMemo(() => new Map(tree().visible.map((entry) => [entry.row.node.sessionId, entry])));
+  const toggle = (id) => setCollapsed((previous) => {
+    const next = new Set(previous);
+    if (next.has(id))
+      next.delete(id);
+    else
+      next.add(id);
+    return next;
+  });
+  const toggleCompleted = () => setHideCompleted((value) => !value);
+  const toggleSort = () => setByPressure((value) => !value);
+  const toggleGroups = () => setCollapsed((previous) => previous.size ? new Set : new Set(tree().all.map((r) => r.node.sessionId)));
+  props.context.keymap.layer(() => ({
+    mode: "global",
+    commands: [{
+      id: "context-guard.completed",
+      title: "Toggle completed subagents",
+      group: "Context Guard",
+      palette: true,
+      bind: false,
+      run: () => {
+        toggleCompleted();
+      }
+    }, {
+      id: "context-guard.sort",
+      title: "Toggle subagent pressure sorting",
+      group: "Context Guard",
+      palette: true,
+      bind: false,
+      run: () => {
+        toggleSort();
+      }
+    }, {
+      id: "context-guard.groups",
+      title: "Collapse or expand subagent groups",
+      group: "Context Guard",
+      palette: true,
+      bind: false,
+      run: () => {
+        toggleGroups();
+      }
+    }]
+  }));
+  const colors = () => props.context.theme.text;
+  const executionColor = (row2) => row2?.node.status === "running" ? colors().feedback.success.base : row2?.node.status === "failed" ? colors().feedback.error.base : colors().muted;
+  const pressureColor = (row2) => row2?.freshness !== "fresh" || row2.pressure === "unknown" ? colors().muted : row2.pressure === "crossed" ? colors().feedback.error.base : row2.pressure === "near" ? colors().feedback.warning.base : colors().feedback.success.base;
+  const rowColor = (row2) => row2.node.status === "failed" ? colors().feedback.error.base : row2.node.status === "completed" && row2.pressure === "normal" ? colors().muted : pressureColor(row2);
+  function Lines(input) {
+    return _$createComponent(Index, {
+      get each() {
+        return input.lines;
+      },
+      children: (line) => (() => {
+        var _el$ = _$createElement("text");
+        _$insert(_el$, () => line() || " ");
+        _$effect((_$p) => _$setProp(_el$, "fg", colors().base, _$p));
+        return _el$;
+      })()
+    });
+  }
+  const section = (title) => {
+    const head = cells(`\u2500\u2500 ${title} `) > width() ? title : `\u2500\u2500 ${title} `;
+    return clip(head, width()) + "\u2500".repeat(Math.max(0, width() - cells(head)));
+  };
+  const notices = createMemo(() => [...props.context.app.version !== "2.0.29" ? wrap(`Runtime ${props.context.app.version}: unverified`, width()) : [], ...props.state.connection() !== "live" ? wrap(`Connection: ${props.state.connection()}`, width()) : [], ...props.state.health()?.mode === "observe" ? ["Observe mode"] : [], ...props.state.health()?.enforcement === "disabled" || props.state.health()?.enforcement === "suspended" ? wrap(`Guard: ${props.state.health()?.enforcement}`, width()) : [], ...(props.state.health()?.reasons ?? []).flatMap((reason) => wrap(reason, width()))]);
+  return (() => {
+    var _el$2 = _$createElement("box"), _el$3 = _$createElement("text"), _el$5 = _$createElement("text"), _el$6 = _$createElement("text"), _el$8 = _$createElement("text"), _el$9 = _$createElement("text"), _el$0 = _$createElement("text"), _el$1 = _$createElement("text"), _el$11 = _$createElement("text"), _el$12 = _$createElement("text");
+    _$insertNode(_el$2, _el$3);
+    _$insertNode(_el$2, _el$5);
+    _$insertNode(_el$2, _el$6);
+    _$insertNode(_el$2, _el$8);
+    _$insertNode(_el$2, _el$9);
+    _$insertNode(_el$2, _el$0);
+    _$insertNode(_el$2, _el$1);
+    _$insertNode(_el$2, _el$11);
+    _$insertNode(_el$2, _el$12);
+    _$setProp(_el$2, "width", "100%");
+    _$setProp(_el$2, "flexShrink", 0);
+    _$setProp(_el$2, "border", true);
+    _$setProp(_el$2, "borderStyle", "rounded");
+    _$setProp(_el$2, "title", " CONTEXT GUARD ");
+    _$setProp(_el$2, "paddingX", 1);
+    _$setProp(_el$2, "flexDirection", "column");
+    _$setProp(_el$2, "onSizeChange", function() {
+      setMeasuredWidth(this.width);
+    });
+    _$insert(_el$2, _$createComponent(Index, {
+      get each() {
+        return mainSections(current(), width(), props.state.age(props.sessionID));
+      },
+      children: (section2) => _$createComponent(Index, {
+        get each() {
+          return section2().lines;
+        },
+        children: (line) => (() => {
+          var _el$13 = _$createElement("text");
+          _$insert(_el$13, () => line() || " ");
+          _$effect((_$p) => _$setProp(_el$13, "fg", section2().tone === "execution" ? executionColor(current()) : section2().tone === "pressure" ? pressureColor(current()) : section2().tone === "measurement" ? current()?.freshness === "fresh" ? colors().muted : colors().feedback.warning.base : colors().base, _$p));
+          return _el$13;
+        })()
+      })
+    }), _el$3);
+    _$insert(_el$2, _$createComponent(Index, {
+      get each() {
+        return notices();
+      },
+      children: (line) => (() => {
+        var _el$14 = _$createElement("text");
+        _$insert(_el$14, line);
+        _$effect((_$p) => _$setProp(_el$14, "fg", colors().feedback.warning.base, _$p));
+        return _el$14;
+      })()
+    }), _el$3);
+    _$insertNode(_el$3, _$createTextNode(` `));
+    _$insert(_el$5, () => section(`SUBAGENTS (${tree().all.length})`));
+    _$insert(_el$2, _$createComponent(Lines, {
+      get lines() {
+        return wrap(`${tree().all.filter((r) => r.node.status === "running").length} running \xB7 ${tree().all.filter((r) => r.node.status === "completed").length} completed${props.state.complete() ? "" : " \xB7 partial"}`, width());
+      }
+    }), _el$6);
+    _$insertNode(_el$6, _$createTextNode(` `));
+    _$insert(_el$2, _$createComponent(For, {
+      get each() {
+        return tree().visible.map((entry) => entry.row.node.sessionId);
+      },
+      children: (id) => {
+        const entry = () => entries().get(id);
+        const row2 = () => entry()?.row;
+        const indent = () => " ".repeat(Math.min(entry()?.depth ?? 0, Math.floor(width() / 6)) * 2);
+        const prefix = () => `${indent()}${entry()?.depth ? "\u2514\u2500 " : ""}${entry()?.hasChildren ? collapsed().has(id) ? "\u25B8 " : "\u25BE " : ""}`;
+        const nameWidth = () => Math.max(1, width() - cells(prefix()));
+        return _$createComponent(Show, {
+          get when() {
+            return row2();
+          },
+          children: (item) => (() => {
+            var _el$15 = _$createElement("box"), _el$16 = _$createElement("box"), _el$18 = _$createElement("text"), _el$19 = _$createElement("span"), _el$20 = _$createElement("span"), _el$21 = _$createElement("text");
+            _$insertNode(_el$15, _el$16);
+            _$insertNode(_el$15, _el$21);
+            _$setProp(_el$15, "flexDirection", "column");
+            _$setProp(_el$15, "flexShrink", 0);
+            _$insertNode(_el$16, _el$18);
+            _$setProp(_el$16, "flexDirection", "row");
+            _$setProp(_el$16, "flexShrink", 0);
+            _$insert(_el$16, _$createComponent(Show, {
+              get when() {
+                return prefix();
+              },
+              get children() {
+                var _el$17 = _$createElement("text");
+                _$setProp(_el$17, "onMouseDown", () => toggle(id));
+                _$insert(_el$17, prefix);
+                _$effect((_$p) => _$setProp(_el$17, "fg", colors().muted, _$p));
+                return _el$17;
+              }
+            }), _el$18);
+            _$insertNode(_el$18, _el$19);
+            _$insertNode(_el$18, _el$20);
+            _$setProp(_el$18, "onMouseDown", () => props.context.ui.router.navigate({
+              type: "session",
+              sessionID: id
+            }));
+            _$insert(_el$19, () => agentHeading(item(), nameWidth()).slice(0, 1));
+            _$insert(_el$20, () => agentHeading(item(), nameWidth()).slice(1));
+            _$insert(_el$15, _$createComponent(Index, {
+              get each() {
+                return agentLines(item(), Math.max(1, width() - cells(indent()) - 2));
+              },
+              children: (line) => (() => {
+                var _el$23 = _$createElement("text"), _el$24 = _$createTextNode(` `);
+                _$insertNode(_el$23, _el$24);
+                _$insert(_el$23, indent, _el$24);
+                _$insert(_el$23, line, null);
+                _$effect((_$p) => _$setProp(_el$23, "fg", rowColor(item()), _$p));
+                return _el$23;
+              })()
+            }), _el$21);
+            _$insertNode(_el$21, _$createTextNode(` `));
+            _$effect((_p$) => {
+              var _v$0 = rowColor(item()), _v$1 = {
+                fg: executionColor(item())
+              };
+              _v$0 !== _p$.e && (_p$.e = _$setProp(_el$18, "fg", _v$0, _p$.e));
+              _v$1 !== _p$.t && (_p$.t = _$setProp(_el$19, "style", _v$1, _p$.t));
+              return _p$;
+            }, {
+              e: undefined,
+              t: undefined
+            });
+            return _el$15;
+          })()
+        });
+      }
+    }), _el$8);
+    _$setProp(_el$8, "onMouseDown", toggleCompleted);
+    _$insert(_el$8, () => clip(hideCompleted() ? "Show completed" : "Hide completed", width()));
+    _$setProp(_el$9, "onMouseDown", toggleSort);
+    _$insert(_el$9, () => clip(byPressure() ? "Sort: pressure" : "Sort: activity", width()));
+    _$setProp(_el$0, "onMouseDown", toggleGroups);
+    _$insert(_el$0, () => clip(collapsed().size ? "Expand groups" : "Collapse groups", width()));
+    _$insertNode(_el$1, _$createTextNode(` `));
+    _$insert(_el$11, () => section("STATISTICS"));
+    _$insert(_el$2, _$createComponent(Lines, {
+      get lines() {
+        return statistics(props.rows.filter((r) => r.node.sessionId === props.sessionID).concat(tree().all), props.sessionID, props.state.complete(), width());
+      }
+    }), _el$12);
+    _$setProp(_el$12, "onMouseDown", () => props.context.ui.panel.open("context-guard.monitor"));
+    _$insert(_el$12, () => clip("Open: /context-guard", width()));
+    _$effect((_p$) => {
+      var _v$ = props.width, _v$2 = colors().muted, _v$3 = colors().base, _v$4 = colors().muted, _v$5 = colors().muted, _v$6 = colors().muted, _v$7 = colors().muted, _v$8 = colors().muted, _v$9 = colors().muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp(_el$2, "maxWidth", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp(_el$2, "borderColor", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp(_el$2, "titleColor", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = _$setProp(_el$5, "fg", _v$4, _p$.o));
+      _v$5 !== _p$.i && (_p$.i = _$setProp(_el$8, "fg", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = _$setProp(_el$9, "fg", _v$6, _p$.n));
+      _v$7 !== _p$.s && (_p$.s = _$setProp(_el$0, "fg", _v$7, _p$.s));
+      _v$8 !== _p$.h && (_p$.h = _$setProp(_el$11, "fg", _v$8, _p$.h));
+      _v$9 !== _p$.r && (_p$.r = _$setProp(_el$12, "fg", _v$9, _p$.r));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined,
+      n: undefined,
+      s: undefined,
+      h: undefined,
+      r: undefined
+    });
+    return _el$2;
+  })();
+}
+
+// src/tui/sidebar.tsx
+function GuardView(props) {
+  const consumer = props.state.acquire(props.sessionID);
+  createEffect2(() => consumer.update(props.sessionID));
+  onCleanup(() => consumer.release());
+  const rows = createMemo2(() => props.family ?? props.state.rows([], !props.expanded));
+  const current = createMemo2(() => rows().find((row2) => row2.node.sessionId === props.sessionID));
+  const detail = createMemo2(() => {
+    const lines = detailLines(current(), props.width, props.expanded, props.state.age(props.sessionID));
+    if (props.expanded) {
+      const byId = new Map(rows().map((row2) => [row2.node.sessionId, row2.node]));
+      const ancestry = [], seen = new Set;
+      let node = byId.get(props.sessionID);
+      while (node && !seen.has(node.sessionId)) {
+        seen.add(node.sessionId);
+        ancestry.unshift(node.agent ?? node.sessionId);
+        node = node.parentId ? byId.get(node.parentId) : undefined;
+      }
+      lines.push(...wrap(`Ancestry: ${ancestry.join(" / ")}`, props.width));
+    }
+    if (props.inspectId && props.inspectId !== props.sessionID) {
+      const inspected = rows().find((row2) => row2.node.sessionId === props.inspectId);
+      lines.push(...wrap(`Inspect: ${props.inspectId}`, props.width), ...detailLines(inspected, props.width, true, props.state.age(props.inspectId)));
+    }
+    return lines;
+  });
+  const visible = createMemo2(() => {
+    if (!props.expanded)
+      return rows().slice(0, 7);
+    const index = Math.max(0, rows().findIndex((row2) => row2.node.sessionId === props.selectedId));
+    return rows().slice(Math.max(0, index - 10), Math.max(0, index - 10) + 25);
+  });
+  return _$createComponent2(Show2, {
+    get when() {
+      return props.expanded;
+    },
+    get fallback() {
+      return _$createComponent2(CompactSidebar, {
+        get sessionID() {
+          return props.sessionID;
+        },
+        get state() {
+          return props.state;
+        },
+        get context() {
+          return props.context;
+        },
+        get rows() {
+          return rows();
+        },
+        get width() {
+          return props.width;
+        }
+      });
+    },
+    get children() {
+      var _el$ = _$createElement2("box"), _el$2 = _$createElement2("text"), _el$3 = _$createTextNode2(`Context Guard / `), _el$4 = _$createElement2("text"), _el$5 = _$createElement2("text"), _el$6 = _$createElement2("text"), _el$7 = _$createElement2("text"), _el$8 = _$createTextNode2(`Family (`), _el$9 = _$createTextNode2(`)`), _el$0 = _$createElement2("text");
+      _$insertNode2(_el$, _el$2);
+      _$insertNode2(_el$, _el$4);
+      _$insertNode2(_el$, _el$5);
+      _$insertNode2(_el$, _el$6);
+      _$insertNode2(_el$, _el$7);
+      _$insertNode2(_el$, _el$0);
+      _$setProp2(_el$, "flexDirection", "column");
+      _$setProp2(_el$, "gap", 0);
+      _$insertNode2(_el$2, _el$3);
+      _$insert2(_el$2, () => props.state.health()?.mode ?? "?", null);
+      _$insert2(_el$4, (() => {
+        var _c$ = _$memo2(() => props.context.app.version === "2.0.29");
+        return () => _c$() ? "" : clip(`Runtime ${props.context.app.version}: unverified (2.0.29 target)`, props.width);
+      })());
+      _$insert2(_el$5, () => clip(`${props.state.connection()} / ${props.state.health()?.enforcement ?? "?"}`, props.width));
+      _$insert2(_el$, _$createComponent2(For2, {
+        get each() {
+          return detail();
+        },
+        children: (line) => (() => {
+          var _el$1 = _$createElement2("text");
+          _$insert2(_el$1, line);
+          _$effect2((_$p) => _$setProp2(_el$1, "fg", props.context.theme.text.base, _$p));
+          return _el$1;
+        })()
+      }), _el$6);
+      _$insert2(_el$, _$createComponent2(For2, {
+        get each() {
+          return props.state.health()?.reasons ?? [];
+        },
+        children: (reason) => (() => {
+          var _el$10 = _$createElement2("text");
+          _$insert2(_el$10, () => clip(reason, props.width));
+          _$effect2((_$p) => _$setProp2(_el$10, "fg", props.context.theme.text.feedback.warning.base, _$p));
+          return _el$10;
+        })()
+      }), _el$6);
+      _$insert2(_el$6, (() => {
+        var _c$2 = _$memo2(() => props.state.health()?.mode === "observe");
+        return () => _c$2() ? current()?.pressure === "crossed" ? "Observe: would compact" : "Observe: no admission" : "";
+      })());
+      _$insertNode2(_el$7, _el$8);
+      _$insertNode2(_el$7, _el$9);
+      _$insert2(_el$7, () => rows().length, _el$9);
+      _$insert2(_el$7, () => props.state.complete() ? "" : " partial", null);
+      _$insert2(_el$, _$createComponent2(For2, {
+        get each() {
+          return visible();
+        },
+        children: (row2) => (() => {
+          var _el$11 = _$createElement2("box");
+          _$setProp2(_el$11, "flexDirection", "column");
+          _$setProp2(_el$11, "onMouseDown", () => {
+            if (row2.hidden)
+              props.state.expand(row2.node.sessionId);
+            else {
+              if (props.expanded)
+                props.context.ui.panel.close();
+              props.context.ui.router.navigate({
+                type: "session",
+                sessionID: row2.node.sessionId
+              });
+            }
+          });
+          _$insert2(_el$11, _$createComponent2(For2, {
+            get each() {
+              return rowLines(row2, Math.max(1, props.width - (props.expanded ? 2 : 0))).map((line) => props.expanded ? `${row2.node.sessionId === props.selectedId ? ">" : " "} ${line}` : line);
+            },
+            children: (line) => (() => {
+              var _el$12 = _$createElement2("text");
+              _$insert2(_el$12, line);
+              _$effect2((_$p) => _$setProp2(_el$12, "fg", row2.pressure === "crossed" ? props.context.theme.text.feedback.error.base : row2.pressure === "near" ? props.context.theme.text.feedback.warning.base : props.context.theme.text.base, _$p));
+              return _el$12;
+            })()
+          }));
+          _$effect2((_$p) => _$setProp2(_el$11, "id", `context-guard.row.${row2.node.sessionId}`, _$p));
+          return _el$11;
+        })()
+      }), _el$0);
+      _$setProp2(_el$0, "onMouseDown", () => props.context.ui.panel.open("context-guard.monitor"));
+      _$insert2(_el$0, (() => {
+        var _c$3 = _$memo2(() => rows().length > visible().length);
+        return () => _c$3() ? `+ ${rows().length - visible().length} rows; open panel` : "Open: /context-guard";
+      })());
+      _$effect2((_p$) => {
+        var _v$ = props.context.theme.text.base, _v$2 = props.context.theme.text.muted, _v$3 = props.context.theme.text.muted, _v$4 = props.context.theme.text.muted, _v$5 = props.context.theme.text.base, _v$6 = props.context.theme.text.muted;
+        _v$ !== _p$.e && (_p$.e = _$setProp2(_el$2, "fg", _v$, _p$.e));
+        _v$2 !== _p$.t && (_p$.t = _$setProp2(_el$4, "fg", _v$2, _p$.t));
+        _v$3 !== _p$.a && (_p$.a = _$setProp2(_el$5, "fg", _v$3, _p$.a));
+        _v$4 !== _p$.o && (_p$.o = _$setProp2(_el$6, "fg", _v$4, _p$.o));
+        _v$5 !== _p$.i && (_p$.i = _$setProp2(_el$7, "fg", _v$5, _p$.i));
+        _v$6 !== _p$.n && (_p$.n = _$setProp2(_el$0, "fg", _v$6, _p$.n));
+        return _p$;
+      }, {
+        e: undefined,
+        t: undefined,
+        a: undefined,
+        o: undefined,
+        i: undefined,
+        n: undefined
+      });
+      return _el$;
+    }
+  });
+}
+
+// src/tui/panel.tsx
+import { effect as _$effect4 } from "@opentui/solid";
+import { createTextNode as _$createTextNode3 } from "@opentui/solid";
+import { insertNode as _$insertNode3 } from "@opentui/solid";
+import { memo as _$memo3 } from "@opentui/solid";
+import { insert as _$insert4 } from "@opentui/solid";
+import { createComponent as _$createComponent4 } from "@opentui/solid";
+import { setProp as _$setProp4 } from "@opentui/solid";
+import { use as _$use } from "@opentui/solid";
+import { createElement as _$createElement4 } from "@opentui/solid";
+import { createSignal as createSignal4, createMemo as createMemo3, createEffect as createEffect4, onCleanup as onCleanup3, Show as Show3 } from "solid-js";
+
+// src/tui/charts.tsx
+import { effect as _$effect3 } from "@opentui/solid";
+import { insert as _$insert3 } from "@opentui/solid";
+import { createComponent as _$createComponent3 } from "@opentui/solid";
+import { setProp as _$setProp3 } from "@opentui/solid";
+import { createElement as _$createElement3 } from "@opentui/solid";
+import { createEffect as createEffect3, createSignal as createSignal3, onCleanup as onCleanup2, For as For3 } from "solid-js";
+
+// src/tui/chartformat.ts
+function sparkline(points, from, to, width, gaps = []) {
+  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))));
+  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)
+      continue;
+    min = Math.min(min, point.value);
+    max = Math.max(max, point.value);
+    const i = column(point.time);
+    values[i] = Math.max(values[i] ?? -Infinity, point.value);
+  }
+  const bars = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  const chars = values.map((v) => v === undefined ? " " : bars[Math.min(7, Math.floor(v / Math.max(1, max) * 7))] ?? "\u2581");
+  for (const time of gaps)
+    if (time >= from && time <= to)
+      chars[column(time)] = "\u2506";
+  return { line: chars.join(""), ...min === Infinity ? {} : { min, max } };
+}
+function historyChartLines(result, width, from, to) {
+  if (!result.enabled)
+    return wrap("History recording is disabled on this server.", width);
+  const series = result.data.series[0];
+  if (!series)
+    return wrap("No retained measurements in this window.", width);
+  const gaps = result.data.gaps.map((g) => g.time);
+  const chart = (label, unit, points) => {
+    const plotted = sparkline(points, from, to, width - 2, gaps);
+    return [
+      ...wrap(`${label}${plotted.min === undefined ? ": unavailable" : ` \xB7 ${plotted.min.toFixed(1)}\u2013${plotted.max?.toFixed(1)} ${unit}`}`, width),
+      `\u2502${plotted.line}\u2502`
+    ];
+  };
+  const observations = (key) => series.points.map((p) => ({
+    time: p.time,
+    ...p[key] === undefined ? {} : { value: p[key] }
+  }));
+  const requests = (key) => series.requests.map((p) => ({
+    time: p.time,
+    ...p[key] === undefined ? {} : { value: key === "ttftMs" ? p[key] / 1000 : p[key] }
+  }));
+  return [
+    ...chart("Live TPS ~", "t/s", observations("liveTps")),
+    "",
+    ...chart("Avg model", "t/s", observations("averageModelTps")),
+    "",
+    ...chart("Avg session", "t/s", observations("averageSessionTps")),
+    "",
+    ...chart("TTFT ~", "s", requests("ttftMs")),
+    "",
+    ...chart("Request throughput", "t/s", requests("tps")),
+    "",
+    ...chart("Cumulative output", "tokens", observations("sessionOutputTokens")),
+    "",
+    ...wrap("UTC time \u2192 \xB7 observed peaks per column \xB7 blank = no sample \xB7 \u2506 = gap", width),
+    ...wrap(`${new Date(from).toISOString()} \u2192 ${new Date(to).toISOString()}`, width),
+    ...series.points.some((p) => p.partial) ? wrap("Partial timing coverage; averages include only matched model durations.", width) : [],
+    ...result.truncated ? wrap("Downsampled/bounded history; some older requests or gap markers may be omitted.", width) : [],
+    ...result.metadata.malformedRecords ? wrap(`${result.metadata.malformedRecords} malformed/partial records skipped.`, width) : []
+  ];
+}
+
+// src/tui/charts.tsx
+function HistoryCharts(props) {
+  const [result, setResult] = createSignal3();
+  const [status, setStatus] = createSignal3("Loading retained history...");
+  const [range, setRange] = createSignal3({
+    from: 0,
+    to: 0
+  });
+  createEffect3(() => {
+    const { sessionId: id, windowMs } = props;
+    props.refresh;
+    let pending = false, disposed = false;
+    let controller;
+    setResult(undefined);
+    async function read() {
+      if (pending || disposed)
+        return;
+      pending = true;
+      controller = new AbortController;
+      const to = Date.now(), from = Math.max(0, to - windowMs);
+      try {
+        const next = await props.state.history(id, from, to, AbortSignal.any([controller.signal, AbortSignal.timeout(5000)]));
+        if (!disposed) {
+          setResult(next);
+          setRange({
+            from,
+            to
+          });
+          setStatus("");
+        }
+      } catch {
+        if (!disposed)
+          setStatus("History unavailable. The owning server must support chart history RPC. Press r to retry.");
+      } finally {
+        pending = false;
+      }
+    }
+    read();
+    const timer = setInterval(() => {
+      read();
+    }, 5000);
+    onCleanup2(() => {
+      disposed = true;
+      controller?.abort();
+      clearInterval(timer);
+    });
+  });
+  const lines = () => {
+    const current = result();
+    return current ? historyChartLines(current, Math.max(4, props.width), range().from, range().to) : [];
+  };
+  return (() => {
+    var _el$ = _$createElement3("box");
+    _$setProp3(_el$, "flexDirection", "column");
+    _$insert3(_el$, _$createComponent3(For3, {
+      get each() {
+        return wrap(`Performance charts \xB7 ${props.sessionId}`, props.width);
+      },
+      children: (line) => (() => {
+        var _el$2 = _$createElement3("text");
+        _$insert3(_el$2, line);
+        _$effect3((_$p) => _$setProp3(_el$2, "fg", props.context.theme.text.base, _$p));
+        return _el$2;
+      })()
+    }), null);
+    _$insert3(_el$, _$createComponent3(For3, {
+      get each() {
+        return wrap(status(), props.width);
+      },
+      children: (line) => (() => {
+        var _el$3 = _$createElement3("text");
+        _$insert3(_el$3, line);
+        _$effect3((_$p) => _$setProp3(_el$3, "fg", props.context.theme.text.muted, _$p));
+        return _el$3;
+      })()
+    }), null);
+    _$insert3(_el$, _$createComponent3(For3, {
+      get each() {
+        return lines();
+      },
+      children: (line) => (() => {
+        var _el$4 = _$createElement3("text");
+        _$insert3(_el$4, line || " ");
+        _$effect3((_$p) => _$setProp3(_el$4, "fg", props.context.theme.text.base, _$p));
+        return _el$4;
+      })()
+    }), null);
+    return _el$;
+  })();
+}
+
+// src/tui/panel.tsx
+function GuardPanel(props) {
+  const [showCharts, setShowCharts] = createSignal4(false);
+  const windows = [300000, 3600000, 86400000, 7 * 86400000];
+  const [windowIndex, setWindowIndex] = createSignal4(1);
+  const [chartRefresh, setChartRefresh] = createSignal4(0);
+  const [inspectId, setInspectId] = createSignal4();
+  const [selected, setSelected] = createSignal4(props.input.sessionID);
+  const [order, setOrder] = createSignal4([]);
+  const rows = createMemo3(() => props.state.rows(order()));
+  const offset = () => Math.max(0, rows().findIndex((row2) => row2.node.sessionId === selected()));
+  createEffect4(() => {
+    if (!props.input.focused)
+      setOrder([]);
+  });
+  createEffect4(() => {
+    setSelected(props.input.sessionID);
+    setOrder([]);
+  });
+  let scroll;
+  let follow;
+  function revealSelection() {
+    if (follow)
+      props.context.renderer.removeFrameCallback(follow);
+    let frames = 0;
+    follow = async () => {
+      scroll?.scrollChildIntoView(`context-guard.row.${selected()}`);
+      if (++frames >= 2 && follow) {
+        props.context.renderer.removeFrameCallback(follow);
+        follow = undefined;
+      } else
+        props.context.renderer.requestRender();
+    };
+    props.context.renderer.setFrameCallback(follow);
+    props.context.renderer.requestRender();
+  }
+  onCleanup3(() => {
+    if (follow)
+      props.context.renderer.removeFrameCallback(follow);
+  });
+  function move(delta) {
+    setOrder(rows().map((row3) => row3.node.sessionId));
+    const row2 = rows()[Math.max(0, Math.min(rows().length - 1, offset() + delta))];
+    if (row2) {
+      setSelected(row2.node.sessionId);
+      if (!showCharts())
+        revealSelection();
+    }
+  }
+  props.context.keymap.layer(() => ({
+    enabled: () => props.input.focused,
+    commands: [{
+      id: "context-guard.charts",
+      title: "Toggle performance charts",
+      bind: "c",
+      run: () => setShowCharts((v) => !v)
+    }, {
+      id: "context-guard.chart-shorter",
+      title: "Shorter chart window",
+      bind: "[",
+      run: () => {
+        if (showCharts())
+          setWindowIndex((i) => Math.max(0, i - 1));
+      }
+    }, {
+      id: "context-guard.chart-longer",
+      title: "Longer chart window",
+      bind: "]",
+      run: () => {
+        if (showCharts())
+          setWindowIndex((i) => Math.min(windows.length - 1, i + 1));
+      }
+    }, {
+      id: "context-guard.inspect",
+      title: "Inspect selected session",
+      bind: "i",
+      run: () => setInspectId(inspectId() === selected() ? undefined : selected())
+    }, {
+      id: "context-guard.refresh",
+      title: "Refresh Context Guard",
+      bind: "r",
+      run: () => {
+        setOrder([]);
+        props.state.refresh();
+        setChartRefresh((n) => n + 1);
+      }
+    }, {
+      id: "context-guard.load-more",
+      title: "Load more family",
+      bind: "l",
+      run: () => props.state.loadMore()
+    }, {
+      id: "context-guard.next",
+      bind: "down",
+      run: () => move(1)
+    }, {
+      id: "context-guard.previous",
+      bind: "up",
+      run: () => move(-1)
+    }, {
+      id: "context-guard.expand",
+      bind: "space",
+      run: () => {
+        const row2 = rows()[offset()];
+        if (row2)
+          props.state.expand(row2.node.sessionId);
+      }
+    }, {
+      id: "context-guard.open",
+      bind: "return",
+      run: () => {
+        const row2 = rows()[offset()];
+        if (row2) {
+          props.input.close();
+          props.context.ui.router.navigate({
+            type: "session",
+            sessionID: row2.node.sessionId
+          });
+        }
+      }
+    }]
+  }));
+  return (() => {
+    var _el$ = _$createElement4("scrollbox"), _el$2 = _$createElement4("box"), _el$6 = _$createElement4("text"), _el$8 = _$createElement4("text"), _el$9 = _$createTextNode3(`up/down select `), _el$0 = _$createTextNode3(`; Enter open`), _el$1 = _$createElement4("text"), _el$11 = _$createElement4("text"), _el$13 = _$createElement4("text");
+    _$insertNode3(_el$, _el$2);
+    _$insertNode3(_el$, _el$6);
+    _$insertNode3(_el$, _el$8);
+    _$insertNode3(_el$, _el$1);
+    _$insertNode3(_el$, _el$11);
+    _$insertNode3(_el$, _el$13);
+    _$use((value) => {
+      scroll = value;
+    }, _el$);
+    _$setProp4(_el$, "flexGrow", 1);
+    _$setProp4(_el$2, "flexDirection", "column");
+    _$insert4(_el$2, _$createComponent4(GuardView, {
+      get sessionID() {
+        return props.input.sessionID;
+      },
+      get state() {
+        return props.state;
+      },
+      get context() {
+        return props.context;
+      },
+      get width() {
+        return Math.max(10, props.input.width - 4);
+      },
+      expanded: true,
+      get family() {
+        return rows();
+      },
+      get selectedId() {
+        return selected();
+      },
+      get inspectId() {
+        return inspectId();
+      }
+    }));
+    _$insert4(_el$, _$createComponent4(Show3, {
+      get when() {
+        return showCharts();
+      },
+      get children() {
+        return [_$createComponent4(HistoryCharts, {
+          get sessionId() {
+            return selected();
+          },
+          get windowMs() {
+            return windows[windowIndex()] ?? 3600000;
+          },
+          get refresh() {
+            return chartRefresh();
+          },
+          get width() {
+            return Math.max(4, props.input.width - 6);
+          },
+          get state() {
+            return props.state;
+          },
+          get context() {
+            return props.context;
+          }
+        }), (() => {
+          var _el$3 = _$createElement4("text"), _el$4 = _$createTextNode3(`[ / ] window \xB7 `);
+          _$insertNode3(_el$3, _el$4);
+          _$insert4(_el$3, () => ["5 minutes", "1 hour", "24 hours", "7 days"][windowIndex()], null);
+          _$effect4((_$p) => _$setProp4(_el$3, "fg", props.context.theme.text.muted, _$p));
+          return _el$3;
+        })()];
+      }
+    }), _el$6);
+    _$insertNode3(_el$6, _$createTextNode3(`r refresh / l load more`));
+    _$insertNode3(_el$8, _el$9);
+    _$insertNode3(_el$8, _el$0);
+    _$insert4(_el$8, () => offset() + 1, _el$0);
+    _$insertNode3(_el$1, _$createTextNode3(`space expand / i inspect selected / c charts`));
+    _$insertNode3(_el$11, _$createTextNode3(`Guard input = prompt + caches.`));
+    _$insertNode3(_el$13, _$createTextNode3(`Native Context uses different totals.`));
+    _$effect4((_p$) => {
+      var _v$ = !showCharts(), _v$2 = props.context.theme.text.muted, _v$3 = props.context.theme.text.muted, _v$4 = props.context.theme.text.muted, _v$5 = props.context.theme.text.muted, _v$6 = props.context.theme.text.muted;
+      _v$ !== _p$.e && (_p$.e = _$setProp4(_el$2, "visible", _v$, _p$.e));
+      _v$2 !== _p$.t && (_p$.t = _$setProp4(_el$6, "fg", _v$2, _p$.t));
+      _v$3 !== _p$.a && (_p$.a = _$setProp4(_el$8, "fg", _v$3, _p$.a));
+      _v$4 !== _p$.o && (_p$.o = _$setProp4(_el$1, "fg", _v$4, _p$.o));
+      _v$5 !== _p$.i && (_p$.i = _$setProp4(_el$11, "fg", _v$5, _p$.i));
+      _v$6 !== _p$.n && (_p$.n = _$setProp4(_el$13, "fg", _v$6, _p$.n));
+      return _p$;
+    }, {
+      e: undefined,
+      t: undefined,
+      a: undefined,
+      o: undefined,
+      i: undefined,
+      n: undefined
+    });
+    return _el$;
+  })();
+}
+
+// src/tui.tsx
+var tui_default = Plugin.define({
+  id: "context-guard",
+  setup(context) {
+    if (typeof context.client?.rpc !== "function" || typeof context.ui?.slot !== "function" || typeof context.ui?.panel?.open !== "function" || typeof context.keymap?.layer !== "function") {
+      throw new Error("Context Guard TUI requires OpenCode 2.0.29 public RPC and panel APIs; use the Guard inspect CLI on unsupported hosts.");
+    }
+    const state = createGuardState(context), unregister = [];
+    try {
+      unregister.push(context.ui.slot({
+        append: "sidebar.content",
+        render: (input) => _$createComponent5(GuardView, {
+          get sessionID() {
+            return input.sessionID;
+          },
+          state,
+          context,
+          width: 35
+        })
+      }));
+      unregister.push(context.ui.slot({
+        append: "session.panel",
+        render: (input) => _$createComponent5(Show4, {
+          get when() {
+            return input.name === "context-guard.monitor";
+          },
+          get children() {
+            return _$createComponent5(GuardPanel, {
+              input,
+              state,
+              context
+            });
+          }
+        })
+      }));
+      unregister.push(context.ui.slot({
+        append: "session.composer.top",
+        render: (input) => _$createComponent5(Show4, {
+          get when() {
+            return context.data.session.get(input.sessionID)?.parentID;
+          },
+          get children() {
+            var _el$ = _$createElement5("text");
+            _$insertNode4(_el$, _$createTextNode4(`Context Guard: open panel`));
+            _$setProp5(_el$, "onMouseDown", () => context.ui.panel.open("context-guard.monitor"));
+            _$effect5((_$p) => _$setProp5(_el$, "fg", context.theme.text.muted, _$p));
+            return _el$;
+          }
+        })
+      }));
+      context.keymap.layer(() => ({
+        mode: "global",
+        commands: [{
+          id: "context-guard.show",
+          title: "Open Context Guard",
+          group: "Context Guard",
+          palette: true,
+          bind: false,
+          slash: {
+            name: "context-guard"
+          },
+          run: () => {
+            context.ui.panel.open("context-guard.monitor");
+          }
+        }]
+      }));
+    } catch (error) {
+      for (const dispose of unregister.reverse())
+        dispose();
+      state.dispose();
+      throw error;
+    }
+    return () => {
+      for (const dispose of unregister.reverse())
+        dispose();
+      state.dispose();
+    };
+  }
+});
+export {
+  tui_default as default
+};