okengine 0.1.4

package/src/console/ui/clock/health.ts

@@ -0,0 +1,61 @@
+/**
+ * Format cron health four numbers for display (console §9.6).
+ */
+
+import type { ClockCronRecord, CronHealth } from "./types.ts";
+
+/** Display lines for the four health numbers. */
+export interface HealthLines {
+  readonly drift: string;
+  readonly overdue: string;
+  readonly missedWithPolicy: string;
+  readonly lease: string;
+}
+
+/**
+ * Format health for a cron row.
+ *
+ * @param health - Health payload
+ */
+export function formatHealth(health: CronHealth): HealthLines {
+  return {
+    drift:
+      health.driftMs == null
+        ? "drift unknown"
+        : `drift ${formatSignedMs(health.driftMs)}`,
+    overdue: health.overdue ? "overdue" : "on time",
+    missedWithPolicy: `${health.missedRuns} missed · catch-up ${health.catchUp}`,
+    lease: health.leaderInstanceId
+      ? `lease ${health.leaderInstanceId}`
+      : "no lease",
+  };
+}
+
+/**
+ * Filter crons by query.
+ *
+ * @param crons - Cron rows
+ * @param q - Query
+ */
+export function filterCrons(
+  crons: readonly ClockCronRecord[],
+  q: string,
+): readonly ClockCronRecord[] {
+  const needle = q.trim().toLowerCase();
+  if (!needle) return crons;
+  return crons.filter(
+    (c) =>
+      c.name.toLowerCase().includes(needle) ||
+      (c.effectiveCron?.toLowerCase().includes(needle) ?? false) ||
+      (c.effectiveEvery?.toLowerCase().includes(needle) ?? false) ||
+      c.flowIds.some((id) => id.toLowerCase().includes(needle)),
+  );
+}
+
+function formatSignedMs(ms: number): string {
+  const sign = ms >= 0 ? "+" : "-";
+  const abs = Math.abs(ms);
+  if (abs < 1_000) return `${sign}${abs}ms`;
+  if (abs < 60_000) return `${sign}${Math.round(abs / 1000)}s`;
+  return `${sign}${Math.round(abs / 60_000)}m`;
+}

package/src/console/ui/clock/index.ts

@@ -0,0 +1,49 @@
+/**
+ * Clock panel pure modules (console §9.6).
+ */
+
+export type {
+  CatchUpPolicy,
+  ClockCronRecord,
+  ClockListResponse,
+  CronHealth,
+  CronStatus,
+  DstAmbiguityView,
+  TimelineEvent,
+  WaitingOnCount,
+  WaitingOnRecord,
+} from "./types.ts";
+
+export { CLOCK_LIST_FIXTURE } from "./fixture.ts";
+
+export {
+  parseClockSearch,
+  serializeClockSearch,
+  openCron,
+  openWake,
+  closeClockDetail,
+  type ClockSearch,
+} from "./search.ts";
+
+export { forwardTimeline, formatTimelineWhen } from "./timeline.ts";
+
+export {
+  aggregateByLabel,
+  waitingOnBanner,
+  formatWakeIn,
+  filterWaitingOn,
+} from "./waiting-on.ts";
+
+export { formatHealth, filterCrons, type HealthLines } from "./health.ts";
+
+export {
+  overdueCronFindings,
+  type OverdueCronFinding,
+} from "./findings.ts";
+
+export {
+  runNowConfirmation,
+  validateTypedConfirm,
+  UNDO_WINDOW_MS,
+  type ConfirmationPattern,
+} from "./confirmation.ts";

package/src/console/ui/clock/search.test.ts

@@ -0,0 +1,39 @@
+/**
+ * Clock URL search.
+ */
+
+import { describe, expect, test } from "bun:test";
+import {
+  closeClockDetail,
+  openCron,
+  openWake,
+  parseClockSearch,
+  serializeClockSearch,
+} from "./search.ts";
+
+describe("clock search", () => {
+  test("round-trips open cron + action", () => {
+    const s = openCron({}, "nightly");
+    expect(s.cron).toBe("nightly");
+    const withAction = { ...s, action: "run" as const };
+    expect(serializeClockSearch(withAction)).toEqual({
+      cron: "nightly",
+      action: "run",
+    });
+    expect(parseClockSearch({ cron: "nightly", action: "run" })).toEqual(
+      withAction,
+    );
+  });
+
+  test("openWake clears cron", () => {
+    const s = openWake({ cron: "x" }, "run_1");
+    expect(s.wake).toBe("run_1");
+    expect(s.cron).toBeUndefined();
+  });
+
+  test("closeClockDetail", () => {
+    expect(closeClockDetail({ cron: "a", wake: "b", action: "edit", q: "z" })).toEqual({
+      q: "z",
+    });
+  });
+});

package/src/console/ui/clock/search.ts

@@ -0,0 +1,76 @@
+/**
+ * URL search state for the Clock panel.
+ */
+
+import { z } from "zod";
+
+const ClockSearchSchema = z.object({
+  q: z.string().optional(),
+  /** Open cron name. */
+  cron: z.string().optional(),
+  /** Open waiting-on run id. */
+  wake: z.string().optional(),
+  /** Active action in the detail pane. */
+  action: z.enum(["run", "edit"]).optional(),
+});
+
+/** Parsed Clock URL search. */
+export type ClockSearch = z.infer<typeof ClockSearchSchema>;
+
+/**
+ * Parse Clock panel search params.
+ *
+ * @param search - Raw router search
+ */
+export function parseClockSearch(
+  search: Record<string, unknown>,
+): ClockSearch {
+  const parsed = ClockSearchSchema.safeParse(search);
+  return parsed.success ? parsed.data : {};
+}
+
+/**
+ * Serialize Clock search for navigation (omit empties).
+ *
+ * @param search - Search state
+ */
+export function serializeClockSearch(
+  search: ClockSearch,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (search.q) out.q = search.q;
+  if (search.cron) out.cron = search.cron;
+  if (search.wake) out.wake = search.wake;
+  if (search.action) out.action = search.action;
+  return out;
+}
+
+/**
+ * Open a cron in the URL.
+ *
+ * @param search - Current search
+ * @param name - Cron name
+ */
+export function openCron(search: ClockSearch, name: string): ClockSearch {
+  return { ...search, cron: name, wake: undefined, action: undefined };
+}
+
+/**
+ * Open a waiting-on run in the URL.
+ *
+ * @param search - Current search
+ * @param runId - Run id
+ */
+export function openWake(search: ClockSearch, runId: string): ClockSearch {
+  return { ...search, wake: runId, cron: undefined, action: undefined };
+}
+
+/**
+ * Close open detail.
+ *
+ * @param search - Current search
+ */
+export function closeClockDetail(search: ClockSearch): ClockSearch {
+  const { cron: _c, wake: _w, action: _a, ...rest } = search;
+  return rest;
+}

package/src/console/ui/clock/timeline.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Forward timeline helpers.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { CLOCK_LIST_FIXTURE } from "./fixture.ts";
+import { formatTimelineWhen, forwardTimeline } from "./timeline.ts";
+
+describe("forwardTimeline", () => {
+  test("keeps next-24h events sorted", () => {
+    const now = CLOCK_LIST_FIXTURE.now;
+    const events = forwardTimeline(
+      [
+        ...CLOCK_LIST_FIXTURE.timeline,
+        {
+          at: now + 48 * 3_600_000,
+          kind: "cron",
+          name: "too-far",
+        },
+        {
+          at: now - 1,
+          kind: "wake",
+          name: "past",
+        },
+      ],
+      now,
+    );
+    expect(events.every((e) => e.at >= now && e.at < now + 86_400_000)).toBe(
+      true,
+    );
+    expect(events.find((e) => e.name === "too-far")).toBeUndefined();
+    expect(events.find((e) => e.name === "past")).toBeUndefined();
+    for (let i = 1; i < events.length; i++) {
+      expect(events[i]!.at).toBeGreaterThanOrEqual(events[i - 1]!.at);
+    }
+  });
+});
+
+describe("formatTimelineWhen", () => {
+  test("formats relative wake", () => {
+    expect(formatTimelineWhen(60_000, 0)).toBe("in 1m");
+    expect(formatTimelineWhen(3_600_000, 0)).toBe("in 1h");
+  });
+});

package/src/console/ui/clock/timeline.ts

@@ -0,0 +1,41 @@
+/**
+ * Forward timeline helpers — next 24h list, not a grid (console §9.6).
+ */
+
+import type { TimelineEvent } from "./types.ts";
+
+/**
+ * Filter timeline events to those within the next 24h from `now`.
+ *
+ * @param events - Timeline events
+ * @param now - Anchor epoch-ms
+ */
+export function forwardTimeline(
+  events: readonly TimelineEvent[],
+  now: number,
+): readonly TimelineEvent[] {
+  const until = now + 24 * 60 * 60 * 1000;
+  return events
+    .filter((e) => e.at >= now && e.at < until)
+    .slice()
+    .sort((a, b) => a.at - b.at || a.name.localeCompare(b.name));
+}
+
+/**
+ * Format an absolute time relative to `now` for the timeline row.
+ *
+ * @param at - Event epoch-ms
+ * @param now - Anchor
+ */
+export function formatTimelineWhen(at: number, now: number): string {
+  const delta = at - now;
+  if (delta < 0) return "past";
+  if (delta < 60_000) return `in ${Math.round(delta / 1000)}s`;
+  if (delta < 3_600_000) return `in ${Math.round(delta / 60_000)}m`;
+  if (delta < 86_400_000) {
+    const h = Math.floor(delta / 3_600_000);
+    const m = Math.round((delta % 3_600_000) / 60_000);
+    return m > 0 ? `in ${h}h ${m}m` : `in ${h}h`;
+  }
+  return new Date(at).toISOString();
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Clock panel view types (console §9.6).
+ */
+
+/** Cron lifecycle status. */
+export type CronStatus = "active" | "paused" | "orphaned";
+
+/** Catch-up policy matching ClockRuntime physics. */
+export type CatchUpPolicy = "one";
+
+/** Four-number cron health. */
+export interface CronHealth {
+  readonly driftMs: number | null;
+  readonly overdue: boolean;
+  readonly missedRuns: number;
+  readonly catchUp: CatchUpPolicy;
+  readonly leaderInstanceId?: string;
+  readonly leaderLeaseUntil?: number;
+}
+
+/** DST ambiguity payload (only when expression+zone hit gap/overlap). */
+export interface DstAmbiguityView {
+  readonly kind: "gap" | "overlap";
+  readonly reason: string;
+  readonly on: string;
+  readonly localTime: string;
+}
+
+/** One cron row from `console.clock.list`. */
+export interface ClockCronRecord {
+  readonly name: string;
+  readonly status: CronStatus;
+  readonly timezone: string;
+  readonly overridable: boolean;
+  readonly declaredCron?: string;
+  readonly declaredEvery?: string;
+  readonly effectiveCron?: string;
+  readonly effectiveEvery?: string;
+  readonly lastRunAt?: number;
+  readonly nextRunAt?: number;
+  readonly health: CronHealth;
+  readonly dstAmbiguity: DstAmbiguityView | null;
+  readonly external: boolean;
+  readonly flowIds: readonly string[];
+}
+
+/** Sleeping durable run in the waiting-on list. */
+export interface WaitingOnRecord {
+  readonly runId: string;
+  readonly flow: string;
+  readonly label: string;
+  readonly wakeAt: number;
+  readonly wakeInMs: number;
+  readonly step: string | null;
+}
+
+/** Aggregate by sleep label. */
+export interface WaitingOnCount {
+  readonly label: string;
+  readonly count: number;
+}
+
+/** Forward timeline event. */
+export interface TimelineEvent {
+  readonly at: number;
+  readonly kind: "cron" | "wake";
+  readonly name: string;
+  readonly meta?: string;
+}
+
+/** List response envelope. */
+export interface ClockListResponse {
+  readonly now: number;
+  readonly crons: readonly ClockCronRecord[];
+  readonly waitingOn: readonly WaitingOnRecord[];
+  readonly waitingOnCounts: readonly WaitingOnCount[];
+  readonly timeline: readonly TimelineEvent[];
+}

package/src/console/ui/clock/waiting-on.test.ts

@@ -0,0 +1,34 @@
+/**
+ * Waiting-on helpers.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { CLOCK_LIST_FIXTURE } from "./fixture.ts";
+import {
+  aggregateByLabel,
+  formatWakeIn,
+  waitingOnBanner,
+} from "./waiting-on.ts";
+
+describe("waiting-on", () => {
+  test("aggregates by label", () => {
+    const counts = aggregateByLabel(CLOCK_LIST_FIXTURE.waitingOn);
+    expect(counts[0]).toEqual({ label: "trial-period", count: 2 });
+    expect(counts.find((c) => c.label === "verify-window")?.count).toBe(1);
+  });
+
+  test("banner summarizes sleeping system", () => {
+    const banner = waitingOnBanner(
+      CLOCK_LIST_FIXTURE.waitingOn.length,
+      CLOCK_LIST_FIXTURE.waitingOnCounts,
+    );
+    expect(banner).toContain("3 sleeping");
+    expect(banner).toContain("trial-period");
+  });
+
+  test("formatWakeIn", () => {
+    expect(formatWakeIn(0)).toBe("due");
+    expect(formatWakeIn(45_000)).toBe("45s");
+    expect(formatWakeIn(120_000)).toBe("2m");
+  });
+});

package/src/console/ui/clock/waiting-on.ts

@@ -0,0 +1,83 @@
+/**
+ * Waiting-on list helpers — sleeping durable runs from the journal.
+ */
+
+import type { WaitingOnCount, WaitingOnRecord } from "./types.ts";
+
+/**
+ * Aggregate waiting-on rows by sleep label (UI mirror of server counts).
+ *
+ * @param rows - Waiting-on rows
+ */
+export function aggregateByLabel(
+  rows: readonly WaitingOnRecord[],
+): readonly WaitingOnCount[] {
+  const counts = new Map<string, number>();
+  for (const r of rows) {
+    const label = r.label || "(unlabelled)";
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  }
+  return [...counts.entries()]
+    .map(([label, count]) => ({ label, count }))
+    .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+}
+
+/**
+ * Banner summary: "3 sleeping — 2 trial-period, 1 verify-window".
+ *
+ * @param total - Total sleeping
+ * @param counts - Per-label counts
+ */
+export function waitingOnBanner(
+  total: number,
+  counts: readonly WaitingOnCount[],
+): string {
+  if (total === 0) return "Nothing waiting";
+  const parts = counts
+    .slice(0, 4)
+    .map((c) => `${c.count} ${c.label}`)
+    .join(", ");
+  return `${total} sleeping — ${parts}`;
+}
+
+/**
+ * Format wake-in duration.
+ *
+ * @param ms - Milliseconds until wake
+ */
+export function formatWakeIn(ms: number): string {
+  if (ms <= 0) return "due";
+  if (ms < 1_000) return `${ms}ms`;
+  const sec = Math.floor(ms / 1_000);
+  if (sec < 60) return `${sec}s`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m`;
+  const hr = Math.floor(min / 60);
+  if (hr < 48) {
+    const rem = min % 60;
+    return rem > 0 ? `${hr}h ${rem}m` : `${hr}h`;
+  }
+  const days = Math.floor(hr / 24);
+  return `${days}d`;
+}
+
+/**
+ * Filter waiting-on by query string.
+ *
+ * @param rows - Rows
+ * @param q - Query
+ */
+export function filterWaitingOn(
+  rows: readonly WaitingOnRecord[],
+  q: string,
+): readonly WaitingOnRecord[] {
+  const needle = q.trim().toLowerCase();
+  if (!needle) return rows;
+  return rows.filter(
+    (r) =>
+      r.label.toLowerCase().includes(needle) ||
+      r.flow.toLowerCase().includes(needle) ||
+      r.runId.toLowerCase().includes(needle) ||
+      (r.step?.toLowerCase().includes(needle) ?? false),
+  );
+}

package/src/console/ui/confirmation.unify.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Typed-confirmation unification — every panel must call the shared
+ * `validateTypedConfirm` from `flows/confirmation.ts`, not a local reimplementation.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { validateTypedConfirm as shared } from "./flows/confirmation.ts";
+import { validateTypedConfirm as fromAccess } from "./access/confirmation.ts";
+import { validateTypedConfirm as fromChannels } from "./channels/confirmation.ts";
+import { validateTypedConfirm as fromClock } from "./clock/confirmation.ts";
+import { validateTypedConfirm as fromSignals } from "./signals/confirmation.ts";
+import { validateTypedConfirm as fromStore } from "./store/confirmation.ts";
+import { validateTypedConfirm as fromVault } from "./vault/confirmation.ts";
+
+const UI_ROOT = import.meta.dir;
+
+/**
+ * Collect `*.ts` / `*.tsx` under a directory (skip dist / node_modules).
+ *
+ * @param dir - Root
+ */
+async function collectSources(dir: string): Promise<string[]> {
+  const out: string[] = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "dist" || entry.name === "node_modules") continue;
+      out.push(...(await collectSources(path)));
+      continue;
+    }
+    if (/\.tsx?$/.test(entry.name)) out.push(path);
+  }
+  return out;
+}
+
+describe("validateTypedConfirm unification", () => {
+  test("every panel confirmation module re-exports the shared implementation", () => {
+    expect(fromAccess).toBe(shared);
+    expect(fromChannels).toBe(shared);
+    expect(fromClock).toBe(shared);
+    expect(fromSignals).toBe(shared);
+    expect(fromStore).toBe(shared);
+    expect(fromVault).toBe(shared);
+  });
+
+  test("no panel reimplements typed-confirm validation locally", async () => {
+    const files = await collectSources(UI_ROOT);
+    const localImpl: string[] = [];
+    for (const file of files) {
+      if (file.endsWith("/flows/confirmation.ts")) continue;
+      if (file.endsWith(".test.ts") || file.endsWith(".test.tsx")) continue;
+      const text = await Bun.file(file).text();
+      // A local function body (not a re-export) would declare the name with `(`.
+      if (/function\s+validateTypedConfirm\s*\(/.test(text)) {
+        localImpl.push(file);
+      }
+      if (
+        /const\s+validateTypedConfirm\s*=/.test(text) &&
+        !/export\s*\{[^}]*validateTypedConfirm/.test(text)
+      ) {
+        // Allow `import { validateTypedConfirm }` — flag only local const assignment.
+        if (!/import\s*\{[^}]*validateTypedConfirm/.test(text)) {
+          localImpl.push(file);
+        }
+      }
+    }
+    expect(localImpl).toEqual([]);
+  });
+
+  test("call sites cover Signals · Store · Clock · Access · Channels · Vault · Flows", async () => {
+    const expected = [
+      "shell/panels/signals/SignalsPanel.tsx",
+      "shell/panels/store/StorePanel.tsx",
+      "shell/panels/clock/ClockPanel.tsx",
+      "shell/panels/access/AccessPanel.tsx",
+      "shell/panels/channels/ChannelsPanel.tsx",
+      "shell/panels/vault/VaultPanel.tsx",
+      "shell/panels/flows/FlowDrawer.tsx",
+    ];
+    const missing: string[] = [];
+    for (const rel of expected) {
+      const text = await Bun.file(join(UI_ROOT, rel)).text();
+      if (!text.includes("validateTypedConfirm(")) {
+        missing.push(rel);
+      }
+    }
+    expect(missing).toEqual([]);
+  });
+});

package/src/console/ui/diff/DiffA11yView.tsx

@@ -0,0 +1,85 @@
+/**
+ * Static Manifest Diff markup for the axe gate — same landmarks as the live panel.
+ */
+
+import { formatCiGate, groupByCategory } from "./group.ts";
+import { DIFF_LIST_FIXTURE } from "./fixture.ts";
+
+/** Props for {@link DiffA11yView}. */
+export interface DiffA11yViewProps {
+  /** Focused Manifest path. */
+  readonly path?: string;
+}
+
+/**
+ * Accessible Manifest Diff list for CI.
+ *
+ * @param props - Open selection
+ */
+export function DiffA11yView(props: DiffA11yViewProps) {
+  const data = DIFF_LIST_FIXTURE;
+  const groups = groupByCategory(data.changes);
+  const focusPath = props.path ?? data.changes[3]?.path;
+
+  return (
+    <div className="diff-a11y">
+      <a href="#diff-main">Skip to main content</a>
+      <header>
+        <h1>Manifest Diff</h1>
+        <p>
+          Blast radius of a deploy — contract, permission, effect, and no-impact
+          changes. Read-only compare of current Manifest vs baseline.
+        </p>
+        <label>
+          Filter changes
+          <input aria-label="Filter changes" defaultValue="" />
+        </label>
+      </header>
+
+      <section aria-label="CI gate summary" role="status">
+        <h2>CI gate</h2>
+        <p>
+          {data.blockedCount} undeclared break
+          {data.blockedCount === 1 ? "" : "s"} blocked ·{" "}
+          {data.acknowledgedCount} acknowledged with breaking: true
+        </p>
+      </section>
+
+      <main id="diff-main">
+        {groups.map((group) => (
+          <section
+            key={group.category}
+            aria-label={group.label}
+          >
+            <h2>{group.label}</h2>
+            <ul>
+              {group.items.map((item) => {
+                const gate = formatCiGate(item.ciGate);
+                const selected = item.path === focusPath;
+                return (
+                  <li key={item.path}>
+                    <article
+                      aria-current={selected ? "true" : undefined}
+                    >
+                      <h3>
+                        <code>{item.path}</code>
+                      </h3>
+                      <p>{item.summary}</p>
+                      {item.blastLine ? (
+                        <p role="status">{item.blastLine}</p>
+                      ) : null}
+                      {item.weeklyBillLine ? (
+                        <p>Weekly bill: {item.weeklyBillLine}</p>
+                      ) : null}
+                      {gate ? <p role="status">{gate}</p> : null}
+                    </article>
+                  </li>
+                );
+              })}
+            </ul>
+          </section>
+        ))}
+      </main>
+    </div>
+  );
+}