okengine 0.1.4

package/src/console/ui/overview/types.ts

@@ -0,0 +1,121 @@
+/**
+ * Overview panel domain types (console §9.16).
+ *
+ * Pure aggregator — every finding originates in another panel.
+ */
+
+import type { DiffCategory } from "../diff/types.ts";
+
+/** Panel that produced a finding. */
+export type FindingSource =
+  | "gates"
+  | "signals"
+  | "clock"
+  | "vault"
+  | "channels"
+  | "architecture"
+  | "plugins"
+  | "ai"
+  | "access";
+
+/**
+ * One ranked finding in the Overview union.
+ *
+ * Ranking keys: user harm → irreversibility → trend (higher = worse).
+ */
+export interface OverviewFinding {
+  readonly id: string;
+  readonly source: FindingSource;
+  readonly title: string;
+  readonly detail: string;
+  readonly href: string;
+  readonly userHarm: number;
+  readonly irreversibility: number;
+  readonly trend: number;
+}
+
+/** Flow- or journey-level SLO with live burn. */
+export interface SloBurn {
+  readonly id: string;
+  readonly kind: "flow" | "journey";
+  readonly name: string;
+  /** Declared availability string from the Manifest (e.g. `99.9%`). */
+  readonly availability: string;
+  /** Tolerable error rate derived from availability (never invented). */
+  readonly tolerableErrorRate: number;
+  /** Current error rate from real Runs. */
+  readonly currentErrorRate: number;
+  /** `currentErrorRate / tolerableErrorRate`. */
+  readonly burnRate: number;
+  /** Remaining error-budget fraction in the long window (0–1). */
+  readonly remainingBudgetFraction: number;
+  /** Projected ms until budget exhaustion, or null when not burning. */
+  readonly timeToExhaustionMs: number | null;
+  /** True when burn rate never reached 1× in the last 90 days. */
+  readonly ceremonial: boolean;
+  /** Last epoch-ms when burn rate ≥ 1, or null. */
+  readonly lastBurnAt: number | null;
+  readonly sampleCount: number;
+  readonly errorCount: number;
+}
+
+/** Cost budget in the same visual model as the error budget. */
+export interface CostBudget {
+  readonly id: string;
+  readonly name: string;
+  readonly kind: "flow" | "ai-prompt" | "ai-agent";
+  /** Declared budget (USD) for the window. */
+  readonly declaredBudget: number;
+  /** Actual spend in the window from Runs / AI. */
+  readonly spent: number;
+  /** Spend rate ÷ budget rate (1 = on pace to exhaust exactly at window end). */
+  readonly burnRate: number;
+  readonly remainingFraction: number;
+  readonly timeToExhaustionMs: number | null;
+  readonly windowMs: number;
+}
+
+/** Classic golden signals from the Runs store. */
+export interface GoldenSignals {
+  readonly latencyP99Ms: number;
+  readonly trafficPerMin: number;
+  readonly errorRate: number;
+  /** Fraction of recent runs with elevated replica lag or cache miss pressure. */
+  readonly saturation: number;
+  readonly sampleCount: number;
+  readonly windowMs: number;
+}
+
+/** Linked Manifest Diff summary — not recomputed. */
+export interface WhatChanged {
+  readonly hasBaseline: boolean;
+  readonly severity: DiffCategory | null;
+  readonly changeCount: number;
+  readonly line: string;
+  readonly href: string;
+}
+
+/** Day-one invitation when no SLOs are declared. */
+export interface FirstSloInvite {
+  readonly busiestFlow: string;
+  readonly runCount: number;
+  readonly href: string;
+}
+
+/** One-line plain-language health verdict. */
+export interface OverviewVerdict {
+  readonly line: string;
+  readonly tone: "ok" | "warn" | "critical" | "empty";
+}
+
+/** Fully composed Overview projection. */
+export interface OverviewView {
+  readonly verdict: OverviewVerdict;
+  readonly slos: readonly SloBurn[];
+  readonly costBudgets: readonly CostBudget[];
+  readonly whatChanged: WhatChanged;
+  readonly findings: readonly OverviewFinding[];
+  readonly golden: GoldenSignals;
+  readonly firstSloInvite: FirstSloInvite | null;
+  readonly hasDeclaredSlos: boolean;
+}

package/src/console/ui/overview/verdict.ts

@@ -0,0 +1,131 @@
+/**
+ * One-line plain-language Overview verdict (console §9.16).
+ */
+
+import type {
+  CostBudget,
+  OverviewFinding,
+  OverviewVerdict,
+  SloBurn,
+} from "./types.ts";
+
+/**
+ * Build the top verdict from SLO burn, cost budgets, and ranked findings.
+ *
+ * @param options - Live burn + findings
+ */
+export function composeVerdict(options: {
+  readonly hasDeclaredSlos: boolean;
+  readonly slos: readonly SloBurn[];
+  readonly costBudgets: readonly CostBudget[];
+  readonly findings: readonly OverviewFinding[];
+}): OverviewVerdict {
+  const { hasDeclaredSlos, slos, costBudgets, findings } = options;
+
+  const burning = slos
+    .filter((s) => s.burnRate >= 1 && !s.ceremonial)
+    .sort(
+      (a, b) =>
+        b.burnRate - a.burnRate ||
+        (a.timeToExhaustionMs ?? Infinity) -
+          (b.timeToExhaustionMs ?? Infinity),
+    );
+
+  if (burning.length > 0) {
+    const top = burning[0]!;
+    const tte = formatExhaustion(top.timeToExhaustionMs);
+    const plural =
+      burning.length === 1
+        ? "one objective is burning fast"
+        : `${burning.length} objectives are burning`;
+    return {
+      tone: top.burnRate >= 6 ? "critical" : "warn",
+      line: `${plural} — ${top.name} will exhaust its budget ${tte}`,
+    };
+  }
+
+  const costBurning = costBudgets
+    .filter((c) => c.burnRate >= 1)
+    .sort(
+      (a, b) =>
+        b.burnRate - a.burnRate ||
+        (a.timeToExhaustionMs ?? Infinity) -
+          (b.timeToExhaustionMs ?? Infinity),
+    );
+  if (costBurning.length > 0) {
+    const top = costBurning[0]!;
+    return {
+      tone: "warn",
+      line: `cost budget burning — ${top.name} will exhaust ${formatExhaustion(top.timeToExhaustionMs)}`,
+    };
+  }
+
+  if (findings.length > 0) {
+    const top = findings[0]!;
+    return {
+      tone: top.userHarm >= 90 ? "critical" : "warn",
+      line: `${top.title.toLowerCase()}: ${top.detail}`,
+    };
+  }
+
+  if (!hasDeclaredSlos) {
+    return {
+      tone: "empty",
+      line: "no objectives declared yet — findings and golden signals below; declare a first SLO on your busiest flow",
+    };
+  }
+
+  const ceremonial = slos.filter((s) => s.ceremonial);
+  if (ceremonial.length === slos.length && slos.length > 0) {
+    return {
+      tone: "ok",
+      line: `all ${slos.length} objective${slos.length === 1 ? "" : "s"} within budget — ${ceremonial.length} marked ceremonial (no burn in 90 days)`,
+    };
+  }
+
+  return {
+    tone: "ok",
+    line: "all objectives within budget — no burning SLOs",
+  };
+}
+
+/**
+ * Format time-to-exhaustion for the verdict line.
+ *
+ * @param ms - Milliseconds, or null
+ */
+export function formatExhaustion(ms: number | null): string {
+  if (ms == null) return "if the current burn continues";
+  if (ms <= 0) return "now";
+  const days = ms / 86_400_000;
+  if (days >= 2) return `in ${Math.round(days)} days`;
+  if (days >= 1) return "in 1 day";
+  const hours = ms / 3_600_000;
+  if (hours >= 2) return `in ${Math.round(hours)} hours`;
+  if (hours >= 1) return "in 1 hour";
+  const mins = Math.max(1, Math.round(ms / 60_000));
+  return `in ${mins} minute${mins === 1 ? "" : "s"}`;
+}
+
+/**
+ * Format a burn rate for display (e.g. `2.4×`).
+ *
+ * @param burnRate - Ratio
+ */
+export function formatBurnRate(burnRate: number): string {
+  if (!Number.isFinite(burnRate)) return "∞×";
+  if (burnRate >= 10) return `${burnRate.toFixed(0)}×`;
+  if (burnRate >= 1) return `${burnRate.toFixed(1)}×`;
+  return `${burnRate.toFixed(2)}×`;
+}
+
+/**
+ * Format a duration for budget strips.
+ *
+ * @param ms - Milliseconds, or null
+ */
+export function formatBudgetDuration(ms: number | null): string {
+  if (ms == null) return "—";
+  if (ms <= 0) return "exhausted";
+  return formatExhaustion(ms).replace(/^in /, "");
+}

package/src/console/ui/plugins/PluginsA11yView.tsx

@@ -0,0 +1,227 @@
+/**
+ * Static Plugins markup for the axe gate — same landmarks / roles as the
+ * live panel (console §9.15).
+ */
+
+import { copyCommandLabel, copyableCommand } from "./command.ts";
+import { PLUGINS_LIST_FIXTURE } from "./fixture.ts";
+import { groupPlugins } from "./group.ts";
+
+/** Props for {@link PluginsA11yView}. */
+export interface PluginsA11yViewProps {
+  /** Plugin to open in detail. */
+  readonly openPlugin?: string;
+}
+
+/**
+ * Accessible Plugins list + detail for CI.
+ *
+ * @param props - Open plugin
+ */
+export function PluginsA11yView(props: PluginsA11yViewProps) {
+  const list = PLUGINS_LIST_FIXTURE;
+  const openId = props.openPlugin ?? "auth";
+  const open = list.plugins.find((p) => p.id === openId) ?? list.plugins[0]!;
+  const groups = groupPlugins(list.plugins, {});
+  const command = copyableCommand(open);
+
+  return (
+    <div className="plugins-a11y">
+      <a href="#plugins-main">Skip to main content</a>
+      <header>
+        <h1>Plugins</h1>
+        <p>
+          Origin × state — CORE stays listed when off; local/community only when
+          plugged. Read-only; git review is the approval.
+        </p>
+        <label>
+          Filter plugins
+          <input aria-label="Filter plugins" defaultValue="" />
+        </label>
+        <fieldset>
+          <legend>Origin</legend>
+          <label>
+            <input type="radio" name="origin" value="" defaultChecked /> All
+          </label>
+          <label>
+            <input type="radio" name="origin" value="core" /> Core
+          </label>
+          <label>
+            <input type="radio" name="origin" value="local" /> Local
+          </label>
+          <label>
+            <input type="radio" name="origin" value="community" /> Community
+          </label>
+        </fieldset>
+        <fieldset>
+          <legend>State</legend>
+          <label>
+            <input type="radio" name="state" value="" defaultChecked /> All
+          </label>
+          <label>
+            <input type="radio" name="state" value="on" /> On
+          </label>
+          <label>
+            <input type="radio" name="state" value="off" /> Off
+          </label>
+        </fieldset>
+      </header>
+      <main id="plugins-main">
+        <section aria-label="Plugins by origin">
+          <h2>Catalogue</h2>
+          {groups.map((g) => (
+            <section key={g.id} aria-label={g.label}>
+              <h3>{g.label}</h3>
+              <ul>
+                {g.items.map((p) => (
+                  <li key={p.id}>
+                    <button
+                      type="button"
+                      aria-pressed={p.id === open.id}
+                      style={{ minHeight: 32, width: "100%" }}
+                    >
+                      <span>{p.id}</span>
+                      <span> {p.state}</span>
+                      <span> {p.origin}</span>
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            </section>
+          ))}
+        </section>
+
+        <section aria-label="Plugin detail" aria-live="polite">
+          <h2>
+            {open.id}{" "}
+            <span>
+              ({open.origin} · {open.state})
+            </span>
+          </h2>
+          {open.summary ? <p>{open.summary}</p> : null}
+          {open.version ? <p>Version {open.version}</p> : null}
+
+          <section aria-label="Declares">
+            <h3>Declares</h3>
+            <p>Boot-time — schema, elements, drivers, panels, CLI</p>
+            {open.declares.length === 0 ? (
+              <p>None</p>
+            ) : (
+              <ul>
+                {open.declares.map((d) => (
+                  <li key={d}>{d}</li>
+                ))}
+              </ul>
+            )}
+          </section>
+
+          <section aria-label="Intercepts">
+            <h3>Intercepts</h3>
+            <p>Per-request hooks with measured cost</p>
+            {open.intercepts.length === 0 ? (
+              <p>None</p>
+            ) : (
+              <table>
+                <caption>Hook stages and measured mean cost</caption>
+                <thead>
+                  <tr>
+                    <th scope="col">Stage</th>
+                    <th scope="col">Mean ms</th>
+                    <th scope="col">Samples</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  {open.intercepts.map((i) => (
+                    <tr key={i.stage}>
+                      <th scope="row">{i.stage}</th>
+                      <td>
+                        {i.meanMs === null ? "—" : i.meanMs.toFixed(2)}
+                      </td>
+                      <td>{i.count}</td>
+                    </tr>
+                  ))}
+                </tbody>
+              </table>
+            )}
+            {open.hookCost ? (
+              <p role="status">
+                p50 {open.hookCost.p50Ms.toFixed(2)} ms · p95{" "}
+                {open.hookCost.p95Ms.toFixed(2)} ms · n={open.hookCost.count}
+              </p>
+            ) : null}
+          </section>
+
+          <section aria-label="Supply chain">
+            <h3>Supply chain</h3>
+            <ul>
+              <li>
+                Lifecycle scripts: {open.supplyChain.lifecycleScripts.state} —{" "}
+                {open.supplyChain.lifecycleScripts.detail}
+              </li>
+              <li>
+                Release cooldown: {open.supplyChain.releaseCooldown.state} —{" "}
+                {open.supplyChain.releaseCooldown.detail}
+              </li>
+              <li>
+                node: scan: {open.supplyChain.nodeImportScan.state} —{" "}
+                {open.supplyChain.nodeImportScan.detail}
+              </li>
+              <li>
+                npm provenance: {open.supplyChain.npmProvenance.state} —{" "}
+                {open.supplyChain.npmProvenance.detail}
+              </li>
+              <li>
+                Boot conflicts: {open.supplyChain.bootConflicts.state} —{" "}
+                {open.supplyChain.bootConflicts.detail}
+              </li>
+            </ul>
+          </section>
+
+          <section aria-label="Capability diff">
+            <h3>Capability diff</h3>
+            <p>
+              From git merge-base via <code>diffManifest</code> (same as{" "}
+              <code>oke doctor --diff</code>)
+            </p>
+            {open.capabilityDiff.length === 0 ? (
+              <p>No pending capability changes for this plugin</p>
+            ) : (
+              <ul>
+                {open.capabilityDiff.map((c) => (
+                  <li key={c.path}>
+                    <a href={`/manifest-diff?path=${encodeURIComponent(c.path)}`}>
+                      {c.summary}
+                    </a>
+                  </li>
+                ))}
+              </ul>
+            )}
+          </section>
+
+          <section aria-label="Install command">
+            <h3>Command</h3>
+            {command ? (
+              <>
+                <pre>
+                  <code>{command}</code>
+                </pre>
+                <button type="button" style={{ minHeight: 32 }}>
+                  {copyCommandLabel(open)}
+                </button>
+                <p>
+                  The Console never installs. Git review is the approval — run
+                  this yourself.
+                </p>
+              </>
+            ) : (
+              <p>
+                No install command — toggle off by removing the code line, not
+                from this UI.
+              </p>
+            )}
+          </section>
+        </section>
+      </main>
+    </div>
+  );
+}

package/src/console/ui/plugins/a11y.test.tsx

@@ -0,0 +1,97 @@
+/**
+ * Accessibility gate — axe reports zero violations at WCAG 2.2 AA
+ * (console §7.5 · §9.15).
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import axe from "axe-core";
+import { Window } from "happy-dom";
+import { createRoot, type Root } from "react-dom/client";
+import { act } from "react";
+import { PluginsA11yView } from "./PluginsA11yView.tsx";
+
+describe("Plugins panel accessibility", () => {
+  let window: Window;
+  let root: Root;
+  let container: HTMLElement;
+
+  beforeEach(() => {
+    (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT =
+      true;
+    window = new Window({ url: "http://console.test/plugins" });
+    Object.defineProperty(globalThis, "window", {
+      value: window,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "document", {
+      value: window.document,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "HTMLElement", {
+      value: window.HTMLElement,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "Node", {
+      value: window.Node,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "navigator", {
+      value: window.navigator,
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "getComputedStyle", {
+      value: window.getComputedStyle.bind(window),
+      configurable: true,
+      writable: true,
+    });
+    Object.defineProperty(globalThis, "requestAnimationFrame", {
+      value: (cb: FrameRequestCallback) => window.setTimeout(cb, 0),
+      configurable: true,
+      writable: true,
+    });
+
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createRoot(container);
+  });
+
+  afterEach(() => {
+    act(() => {
+      root.unmount();
+    });
+    container.remove();
+    window.close();
+  });
+
+  test("axe reports zero violations at WCAG 2.2 AA", async () => {
+    await act(async () => {
+      root.render(<PluginsA11yView openPlugin="auth" />);
+    });
+
+    await new Promise((r) => setTimeout(r, 10));
+
+    const results = await axe.run(container, {
+      runOnly: {
+        type: "tag",
+        values: ["wcag2a", "wcag2aa", "wcag22aa"],
+      },
+    });
+
+    if (results.violations.length > 0) {
+      const summary = results.violations
+        .map(
+          (v) =>
+            `${v.id}: ${v.help} (${v.nodes.length} nodes) — ${v.nodes.map((n) => n.html).join("; ")}`,
+        )
+        .join("\n");
+      console.error(summary);
+    }
+
+    expect(results.violations).toEqual([]);
+  });
+});

package/src/console/ui/plugins/command.test.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyable command — never an install button affordance.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { copyCommandLabel, copyableCommand } from "./command.ts";
+import { PLUGINS_LIST_FIXTURE } from "./fixture.ts";
+
+describe("copyableCommand", () => {
+  test("community hands bun add; core off hands enable hint", () => {
+    const community = PLUGINS_LIST_FIXTURE.plugins.find((p) => p.id === "oke-slack")!;
+    expect(copyableCommand(community)).toBe("bun add oke-slack");
+    expect(copyCommandLabel(community)).toBe("Copy bun add command");
+
+    const rate = PLUGINS_LIST_FIXTURE.plugins.find((p) => p.id === "rate-limit")!;
+    expect(copyableCommand(rate)).toContain("rateLimit");
+    expect(copyCommandLabel(rate)).toBe("Copy enable hint");
+
+    const auth = PLUGINS_LIST_FIXTURE.plugins.find((p) => p.id === "auth")!;
+    expect(copyableCommand(auth)).toBeNull();
+  });
+});

package/src/console/ui/plugins/command.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyable install / enable commands — Console never installs (console §9.15).
+ */
+
+import type { PluginRecord } from "./types.ts";
+
+/**
+ * Command or hint to show for a plugin (copy only — no approve/install).
+ *
+ * @param plugin - Row
+ */
+export function copyableCommand(plugin: PluginRecord): string | null {
+  if (plugin.installCommand) return plugin.installCommand;
+  if (plugin.enableHint) return plugin.enableHint;
+  return null;
+}
+
+/**
+ * Label for the copy control.
+ *
+ * @param plugin - Row
+ */
+export function copyCommandLabel(plugin: PluginRecord): string {
+  if (plugin.installCommand) return "Copy bun add command";
+  if (plugin.enableHint) return "Copy enable hint";
+  return "No command";
+}

package/src/console/ui/plugins/findings.ts

@@ -0,0 +1,39 @@
+/**
+ * Plugin capability-widening findings (console §9.15 · §9.16).
+ *
+ * Classification comes from Manifest Diff (`diffManifest` → permission-widening
+ * on `/plugins/…`). This module only selects those rows — no re-derivation.
+ */
+
+import type { DiffChangeRecord } from "../diff/types.ts";
+
+/** One plugin capability widening from Diff. */
+export interface PluginCapabilityFinding {
+  readonly path: string;
+  readonly summary: string;
+  readonly kind: DiffChangeRecord["kind"];
+}
+
+/**
+ * Plugin capability widenings from a Manifest Diff projection.
+ *
+ * @param changes - Diff panel change rows (already classified)
+ */
+export function pluginCapabilityFindings(
+  changes: readonly DiffChangeRecord[],
+): readonly PluginCapabilityFinding[] {
+  return changes
+    .filter(
+      (c) =>
+        c.category === "permission-widening" &&
+        (c.path.startsWith("/plugins/") ||
+          c.path.startsWith("/plugins") ||
+          c.summary.toLowerCase().includes("plugin")),
+    )
+    .map((c) => ({
+      path: c.path,
+      summary: c.summary,
+      kind: c.kind,
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+}