@hoox-sh/hoox-tui 0.3.2 → 0.4.0

package/src/services/cli-bridge/index.ts

@@ -21,7 +21,11 @@
  * for any CLI failure, regardless of which view triggered it.
  */
 import * as path from "path";
-import { getHooxRepoPath, resolveHooxRuntimeRoot } from "@hoox-sh/hoox-shared";
+import {
+  getHooxRepoPath,
+  resolveHooxRuntimeRoot,
+  isTruthyKillSwitchFlag,
+} from "@hoox-sh/hoox-shared";
 import type { CliResult, CliErrorType, CliErrorDetails } from "../../types";
 import type {
   ExecOptions,
@@ -129,6 +133,21 @@ export function tryParseJsonLoose(stdout: string): unknown | null {
   return null;
 }
 
+/** Unwrap `hoox config kv get --json` `{ key, value }` into the stored string. */
+function unwrapKvGetPayload(payload: unknown): string | null | undefined {
+  if (payload == null) return undefined;
+  if (typeof payload !== "object" || Array.isArray(payload)) return undefined;
+  if (!("value" in payload)) return undefined;
+  const v = (payload as { value: unknown }).value;
+  if (v == null) return null;
+  if (typeof v === "string") return v;
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+}
+
 /**
  * Redact CLI argv values that are likely secrets before logging or
  * surfacing in the status bar (`command` field).
@@ -241,8 +260,8 @@ export function parseDbQueryResult(stdout: string): DbQueryResult {
   }
 
   // Derive column order from the first row's keys.
-  const columns =
-    rows.length > 0 && rows[0] !== null ? Object.keys(rows[0]) : [];
+  const firstRow = rows[0];
+  const columns = firstRow ? Object.keys(firstRow) : [];
 
   // wrangler's `meta.duration` is reported in seconds (float). Convert to ms.
   let executionTimeMs: number | null = null;
@@ -369,6 +388,7 @@ export function parseSecretsList(stdout: string): SecretMetadata[] {
         if (typeof item === "string") {
           result.push({
             name: item,
+            worker: envelope.worker,
             type: inferSecretType(item),
             source: "config",
           });
@@ -383,12 +403,13 @@ export function parseSecretsList(stdout: string): SecretMetadata[] {
   if (typeof parsed === "object" && !Array.isArray(parsed)) {
     const entries = Object.entries(parsed as Record<string, unknown>);
     const result: SecretMetadata[] = [];
-    for (const [, value] of entries) {
+    for (const [worker, value] of entries) {
       if (Array.isArray(value)) {
         for (const item of value) {
           if (typeof item === "string") {
             result.push({
               name: item,
+              worker,
               type: inferSecretType(item),
               source: "config",
             });
@@ -613,14 +634,14 @@ export function parseKillSwitchStatus(
   if (valueMatch) {
     const raw = valueMatch[1] ?? null;
     return {
-      engaged: raw === "true",
+      engaged: isTruthyKillSwitchFlag(raw),
       rawValue: raw,
       timestamp,
       action,
     };
   }
 
-  // Unknown output — treat as released (fail-open for display, but flag raw)
+  // Unknown output — do not claim the switch is released
   return { engaged: false, rawValue: null, timestamp, action };
 }
 
@@ -963,7 +984,22 @@ class CliBridgeImpl {
       let data: T | null = null;
       if (options?.json && exitCode === 0 && stdout.trim()) {
         const parsed = tryParseJsonLoose(stdout);
-        if (parsed !== null) data = parsed as T;
+        if (parsed !== null) {
+          data = parsed as T;
+        } else {
+          return {
+            success: false,
+            exitCode,
+            stdout: this.truncateOutput(stdout),
+            stderr: this.truncateOutput(
+              stderrResult || "CLI --json output was not valid JSON"
+            ),
+            data: null,
+            duration: performance.now() - start,
+            command,
+            errorType: "non-zero-exit",
+          };
+        }
       }
 
       // Classify the failure (success leaves errorType=null).
@@ -1386,16 +1422,24 @@ class CliBridgeImpl {
       tag: `config:kv:get:${key}`,
     }).then((result) => {
       if (!result.success) {
-        // Missing key is not a hard error — the CLI exits non-zero with
-        // a "not found" message and the viewer should display an empty
-        // value rather than an error pill.
-        const combined = `${result.stdout}\n${result.stderr}`.toLowerCase();
-        if (combined.includes("not found")) {
+        const combined = `${result.stdout}\n${result.stderr}`;
+        const missingKey = /Key\s+"[^"]+"\s+not found in KV namespace/i.test(
+          combined
+        );
+        if (missingKey && result.errorType !== "binary-not-found") {
           return { ...result, data: null, success: true };
         }
         return { ...result, data: null };
       }
+      const fromData = unwrapKvGetPayload(result.data);
+      if (fromData !== undefined) {
+        return { ...result, data: fromData };
+      }
       const cleaned = result.stdout.replace(/\n$/, "").trim();
+      const fromStdout = unwrapKvGetPayload(tryParseJsonLoose(cleaned));
+      if (fromStdout !== undefined) {
+        return { ...result, data: fromStdout };
+      }
       return {
         ...result,
         data: cleaned.length > 0 ? cleaned : null,

package/src/services/cli-bridge/standalone.ts

@@ -270,7 +270,10 @@ export function agentChatStream(
 
         while (!abortController.signal.aborted) {
           const { done, value } = await reader.read();
-          if (done) break;
+          if (done) {
+            completed = true;
+            break;
+          }
 
           buffer += decoder.decode(value, { stream: true });
           const lines = buffer.split("\n");

package/src/services/cli-bridge/types.ts

@@ -80,11 +80,7 @@ export interface KillSwitchStatus {
  *   - no data                 → "unknown"
  */
 export type QueueDepthStatus =
-  | "healthy"
-  | "backlogged"
-  | "critical"
-  | "paused"
-  | "unknown";
+  "healthy" | "backlogged" | "critical" | "paused" | "unknown";
 
 /** Per-queue depth info. See {@link QueueDepthStatus} for status semantics. */
 export interface QueueDepth {
@@ -139,8 +135,7 @@ export interface DbQueryResult {
  * command to the local `hoox` binary.
  */
 export type SqlValidationResult =
-  | { readonly: true }
-  | { readonly: false; reason: string };
+  { readonly: true } | { readonly: false; reason: string };
 
 /**
  * A single Cloudflare Workers secret metadata (read-only, no values exposed).
@@ -150,8 +145,10 @@ export type SqlValidationResult =
  * (`hoox config secrets list`) only surfaces names/types anyway.
  */
 export interface SecretMetadata {
-  /** Secret name / key, e.g. "BINANCE_KEY_BINDING" or "OPENAI_API_KEY". */
+  /** Secret name / key, e.g. "EXCHANGE_KEY_BINDING" or "OPENAI_API_KEY". */
   name: string;
+  /** Worker that declared the secret (all-workers list). */
+  worker?: string;
   /**
    * Inferred type based on naming conventions. Cloudflare secrets store
    * does not expose per-secret type metadata, so we derive it from the
@@ -239,7 +236,7 @@ export interface KvKeySnapshot {
 export interface ModelHealth {
   /** Provider name, e.g. "Workers AI", "OpenAI", "Anthropic", "Google", "Azure" */
   name: string;
-  /** Provider-specific model identifier, e.g. "@cf/meta/llama-3.1-8b-instruct" */
+  /** Provider-specific model identifier, e.g. "@cf/meta/llama-3.1-8b-instruct-fp8" */
   model: string;
   /** Operational state */
   status: "online" | "degraded" | "offline";

package/src/services/cli-bridge.test.ts

@@ -624,8 +624,18 @@ describe("parseSecretsList", () => {
       })
     );
     expect(out).toEqual([
-      { name: "API_KEY", type: "api_key", source: "config" },
-      { name: "auth_token", type: "token", source: "config" },
+      {
+        name: "API_KEY",
+        worker: "trade-worker",
+        type: "api_key",
+        source: "config",
+      },
+      {
+        name: "auth_token",
+        worker: "trade-worker",
+        type: "token",
+        source: "config",
+      },
     ]);
   });
 
@@ -1118,7 +1128,10 @@ describe("CliBridge methods (exec stubbed)", () => {
   });
 
   it("configKvGet treats not found as success null", async () => {
-    bridge.exec = (async () => failExec("key not found")) as typeof bridge.exec;
+    bridge.exec = (async () =>
+      failExec(
+        'Key "missing" not found in KV namespace'
+      )) as typeof bridge.exec;
     const result = (await bridge.configKvGet("missing")) as CliResult<
       string | null
     >;
@@ -1127,7 +1140,10 @@ describe("CliBridge methods (exec stubbed)", () => {
   });
 
   it("configKvGet returns trimmed value", async () => {
-    bridge.exec = (async () => okExec("hello\n")) as typeof bridge.exec;
+    bridge.exec = (async () =>
+      okExec(
+        JSON.stringify({ key: "k", value: "hello" })
+      )) as typeof bridge.exec;
     const result = (await bridge.configKvGet("k")) as CliResult<string | null>;
     expect(result.data).toBe("hello");
   });

package/src/services/clipboard.ts

@@ -59,8 +59,8 @@ export async function copyViaSystemClipboard(
         stdout: "ignore",
         stderr: "ignore",
       });
-      proc.stdin.write(text);
-      proc.stdin.end();
+      void proc.stdin.write(text);
+      void proc.stdin.end();
 
       let timedOut = false;
       const timer = setTimeout(() => {

package/src/stores/service-store.test.ts

@@ -134,8 +134,8 @@ describe("useServiceStore", () => {
 
       const state = useServiceStore.getState();
       expect(state.workers).toHaveLength(2);
-      expect(state.workers[0].name).toBe("alpha");
-      expect(state.workers[1].name).toBe("beta");
+      expect(state.workers[0]?.name).toBe("alpha");
+      expect(state.workers[1]?.name).toBe("beta");
       expect(state.lastUpdated).toBeGreaterThan(0);
     });
 
@@ -714,13 +714,13 @@ describe("useServiceStore", () => {
 
       const alerts = useServiceStore.getState().alerts;
       expect(alerts).toHaveLength(1);
-      expect(alerts[0].severity).toBe("error");
-      expect(alerts[0].type).toBe("connection");
-      expect(alerts[0].message).toContain("CLI failure");
-      expect(alerts[0].message).toContain("Build failed: missing import");
-      expect(alerts[0].acknowledged).toBe(false);
-      expect(alerts[0].id).toBeTruthy();
-      expect(alerts[0].timestamp).toBeGreaterThan(0);
+      expect(alerts[0]?.severity).toBe("error");
+      expect(alerts[0]?.type).toBe("connection");
+      expect(alerts[0]?.message).toContain("CLI failure");
+      expect(alerts[0]?.message).toContain("Build failed: missing import");
+      expect(alerts[0]?.acknowledged).toBe(false);
+      expect(alerts[0]?.id).toBeTruthy();
+      expect(alerts[0]?.timestamp).toBeGreaterThan(0);
     });
 
     it("appends multiple alerts without dropping older ones under the cap", () => {
@@ -733,8 +733,8 @@ describe("useServiceStore", () => {
 
       const alerts = useServiceStore.getState().alerts;
       expect(alerts).toHaveLength(2);
-      expect(alerts[0].message).toContain("Build failed: missing import");
-      expect(alerts[1].message).toContain("second failure");
+      expect(alerts[0]?.message).toContain("Build failed: missing import");
+      expect(alerts[1]?.message).toContain("second failure");
     });
 
     it("respects the MAX_ALERTS cap of 100 entries", () => {
@@ -747,7 +747,7 @@ describe("useServiceStore", () => {
       expect(useServiceStore.getState().alerts).toHaveLength(100);
       // Newest entries survive
       const alerts = useServiceStore.getState().alerts;
-      expect(alerts[alerts.length - 1].message).toContain("failure 109");
+      expect(alerts[alerts.length - 1]?.message).toContain("failure 109");
     });
 
     it("also works when stderr is empty (falls back to command summary)", () => {
@@ -761,21 +761,24 @@ describe("useServiceStore", () => {
       expect(lastError).toBe(cliFailure.command);
       // And the alert still contains the command
       const alerts = useServiceStore.getState().alerts;
-      expect(alerts[0].message).toContain("CLI failure");
-      expect(alerts[0].message).toContain("hoox deploy all");
+      expect(alerts[0]?.message).toContain("CLI failure");
+      expect(alerts[0]?.message).toContain("hoox deploy all");
     });
   });
 
   // ── Ring Buffer Limits ────────────────────────────────────────────────────
 
   describe("ring buffer limits", () => {
+    // NOTE: each push through the immer-backed store costs a few ms, so
+    // these bulk-fill loops get explicit timeouts instead of bun's 5s
+    // default (they time out on loaded machines otherwise).
     it("caps trade stream at 500 entries", () => {
       const store = useServiceStore.getState();
       for (let i = 0; i < 600; i++) {
         store.pushTrade(makeTrade({ id: `t${i}` }));
       }
       expect(useServiceStore.getState().tradeStream).toHaveLength(500);
-    });
+    }, 30000);
 
     it("trade stream keeps newest entries when exceeding cap", () => {
       const store = useServiceStore.getState();
@@ -788,7 +791,7 @@ describe("useServiceStore", () => {
       expect(stream).toHaveLength(500);
       // "first" should be dropped
       expect(stream.find((t) => t.id === "first")).toBeUndefined();
-    });
+    }, 30000);
 
     it("caps alerts at 100 entries", () => {
       for (let i = 0; i < 150; i++) {
@@ -818,7 +821,7 @@ describe("useServiceStore", () => {
         useServiceStore.getState().pushLog(makeLog({ id: `l${i}` }));
       }
       expect(useServiceStore.getState().logs).toHaveLength(1000);
-    });
+    }, 30000);
 
     it("logs buffer keeps newest entries when exceeding cap", () => {
       useServiceStore.getState().pushLog(makeLog({ id: "first-log" }));
@@ -828,7 +831,7 @@ describe("useServiceStore", () => {
       expect(
         useServiceStore.getState().logs.find((l) => l.id === "first-log")
       ).toBeUndefined();
-    });
+    }, 30000);
 
     it("trade stream preserves order (FIFO)", () => {
       const store = useServiceStore.getState();
@@ -837,9 +840,9 @@ describe("useServiceStore", () => {
       store.pushTrade(makeTrade({ id: "c", timestamp: 3 }));
 
       const stream = useServiceStore.getState().tradeStream;
-      expect(stream[0].id).toBe("a");
-      expect(stream[1].id).toBe("b");
-      expect(stream[2].id).toBe("c");
+      expect(stream[0]?.id).toBe("a");
+      expect(stream[1]?.id).toBe("b");
+      expect(stream[2]?.id).toBe("c");
     });
   });
 
@@ -854,7 +857,7 @@ describe("useServiceStore", () => {
       useServiceStore.getState().addAlert(alert);
 
       expect(useServiceStore.getState().alerts).toHaveLength(1);
-      expect(useServiceStore.getState().alerts[0].message).toBe(
+      expect(useServiceStore.getState().alerts[0]?.message).toBe(
         "CPU threshold exceeded"
       );
     });
@@ -947,7 +950,7 @@ describe("useServiceStore", () => {
     it("subscribes to SSE trade stream", async () => {
       await useServiceStore.getState().streamTrades();
       expect(subscribeSSEMock).toHaveBeenCalledTimes(1);
-      expect(subscribeSSEMock.mock.calls[0][0]).toBe("/v1/trades/stream");
+      expect(subscribeSSEMock.mock.calls[0]?.[0]).toBe("/v1/trades/stream");
     });
 
     it("streamTrades does not throw on SSE connection failure", async () => {
@@ -971,7 +974,7 @@ describe("useServiceStore", () => {
       const trade = makeTrade({ id: "sse-t1", symbol: "ETH" });
       emitSseEvent(trade, "/v1/trades");
       expect(useServiceStore.getState().tradeStream).toHaveLength(1);
-      expect(useServiceStore.getState().tradeStream[0].id).toBe("sse-t1");
+      expect(useServiceStore.getState().tradeStream[0]?.id).toBe("sse-t1");
     });
   });
 
@@ -979,7 +982,7 @@ describe("useServiceStore", () => {
     it("subscribes to SSE log stream", async () => {
       await useServiceStore.getState().streamLogs();
       expect(subscribeSSEMock).toHaveBeenCalledTimes(1);
-      expect(subscribeSSEMock.mock.calls[0][0]).toBe("/v1/logs/stream");
+      expect(subscribeSSEMock.mock.calls[0]?.[0]).toBe("/v1/logs/stream");
     });
 
     it("pushes logs from SSE events into the ring buffer", async () => {
@@ -987,7 +990,7 @@ describe("useServiceStore", () => {
       const log = makeLog({ id: "sse-l1", message: "from-sse" });
       emitSseEvent(log, "/v1/logs");
       expect(useServiceStore.getState().logs).toHaveLength(1);
-      expect(useServiceStore.getState().logs[0].message).toBe("from-sse");
+      expect(useServiceStore.getState().logs[0]?.message).toBe("from-sse");
     });
   });
 

package/src/stores/session-restore.test.ts

@@ -63,6 +63,7 @@ describe("session restore / save", () => {
     expect(session.activeView).toBe("dashboard");
     expect(session.sidebarExpanded).toBe(true);
     expect(session.lastData).toBe(0);
+    expect(session.fromDisk).toBe(false);
   });
 
   it("round-trips every ViewId (all 16)", async () => {
@@ -74,6 +75,7 @@ describe("session restore / save", () => {
       expect(restored.sidebarExpanded).toBe(true);
       expect(restored.windowSize).toEqual({ cols: 100, rows: 40 });
       expect(restored.lastData).toBe(12345);
+      expect(restored.fromDisk).toBe(true);
     }
   });
 

package/src/test-setup.ts

@@ -65,7 +65,7 @@ try {
 //   - The Temporal Dead Zone race condition is avoided because we've
 //     already pre-loaded @opentui/core above
 
-mock.module("@opentui/core/testing", () => {
+void mock.module("@opentui/core/testing", () => {
   if (coreAvailable && realCreateTestRenderer) {
     return {
       // Spread any other exports from the real module (setRendererCapabilities,
@@ -157,10 +157,7 @@ installSpawnShim();
 //
 // Per-test overrides: import { cliBridgeDouble, resetCliBridgeDouble } from
 // "./cli-bridge-test-double" and use mockResolvedValue / mockImplementation.
-import {
-  cliBridgeDouble,
-  createCliBridgeModuleMock,
-} from "./cli-bridge-test-double";
+import { createCliBridgeModuleMock } from "./cli-bridge-test-double";
 
 const cliBridgeModule = await createCliBridgeModuleMock();
 
@@ -180,7 +177,7 @@ function installCliBridgeDouble(): void {
   ];
   for (const p of paths) {
     try {
-      mock.module(p, () => cliBridgeModule);
+      void mock.module(p, () => cliBridgeModule);
     } catch {
       // Specifier may be invalid in some environments — ignore
     }
@@ -189,11 +186,6 @@ function installCliBridgeDouble(): void {
 
 installCliBridgeDouble();
 
-// Expose for tests that need the double without importing the helper path
-(
-  globalThis as unknown as { __hooxCliBridgeDouble?: typeof cliBridgeDouble }
-).__hooxCliBridgeDouble = cliBridgeDouble;
-
 // ── Shared network doubles (api-client + SSE) ────────────────────────────────
 //
 // service-store (and views that call fetchWorkers / stream*) must not hit a
@@ -257,14 +249,14 @@ async function installNetworkDoubles(): Promise<void> {
 
   for (const p of apiPaths) {
     try {
-      mock.module(p, apiFactory);
+      void mock.module(p, apiFactory);
     } catch {
       // ignore bad specifier
     }
   }
   for (const p of ssePaths) {
     try {
-      mock.module(p, sseFactory);
+      void mock.module(p, sseFactory);
     } catch {
       // ignore
     }

package/src/test-utils.ts

@@ -20,7 +20,7 @@
  */
 
 import type { ReactNode } from "react";
-import type { ViewId } from "@hoox-sh/hoox-shared";
+import { VIEW_IDS, type ViewId } from "@hoox-sh/hoox-shared";
 
 export {
   cliBridgeDouble,
@@ -43,35 +43,15 @@ export {
   sseSubscriptions,
 } from "./network-test-double";
 
-/** Canonical 16 ViewIds — keep aligned with types.ts + view-registry. */
-export const ALL_VIEW_IDS: ViewId[] = [
-  "dashboard",
-  "workers",
-  "worker-detail",
-  "trade-monitor",
-  "logs-viewer",
-  "service-manager",
-  "config-editor",
-  "setup-wizard",
-  "settings",
-  "queue-depth",
-  "kv-viewer",
-  "secrets-viewer",
-  "db-query",
-  "ai-chat",
-  "edge-topology",
-  "worker-settings",
-];
+/** Canonical ViewIds — same tuple as shared `VIEW_IDS`. */
+export const ALL_VIEW_IDS: readonly ViewId[] = VIEW_IDS;
 
 // ── Type Aliases ─────────────────────────────────────────────────────────────
 
 export type WorkerStatus = "operational" | "degraded" | "down";
 export type LogLevel = "debug" | "info" | "warn" | "error";
 export type ConnectionStatus =
-  | "connected"
-  | "polling"
-  | "offline"
-  | "reconnecting";
+  "connected" | "polling" | "offline" | "reconnecting";
 export type TradeSide = "buy" | "sell";
 
 export interface TestWorkerInfo {

package/src/types.ts

@@ -7,34 +7,19 @@
  * TUI-specific types — Navigation, modals, keyboard shortcuts.
  */
 
-import type { CliErrorType, CliErrorDetails } from "@hoox-sh/hoox-shared";
+import {
+  VIEW_IDS,
+  type ViewId,
+  type CliErrorType,
+  type CliErrorDetails,
+} from "@hoox-sh/hoox-shared";
 
 // Re-export shared CLI error types for convenience so consumers can
 // import everything from the tui/types module.
-export type { CliErrorType, CliErrorDetails };
-
-/** All primary views registered with the TUI. */
-export const ALL_VIEWS = [
-  "dashboard",
-  "workers",
-  "worker-detail",
-  "trade-monitor",
-  "logs-viewer",
-  "service-manager",
-  "config-editor",
-  "setup-wizard",
-  "settings",
-  "queue-depth",
-  "kv-viewer",
-  "secrets-viewer",
-  "db-query",
-  "ai-chat",
-  "edge-topology",
-  "worker-settings",
-] as const;
-
-export type ViewId = (typeof ALL_VIEWS)[number];
+export type { CliErrorType, CliErrorDetails, ViewId };
+export { VIEW_IDS as ALL_VIEWS };
 
+/** Sidebar / tab labels for each {@link ViewId}. */
 export const VIEW_LABELS: Record<ViewId, string> = {
   dashboard: "DASHBOARD",
   workers: "WORKERS",
@@ -54,29 +39,6 @@ export const VIEW_LABELS: Record<ViewId, string> = {
   "worker-settings": "W SETTINGS",
 };
 
-export const VIEW_ORDER: ViewId[] = [
-  "dashboard",
-  "workers",
-  "worker-detail",
-  "trade-monitor",
-  "logs-viewer",
-  "service-manager",
-  "config-editor",
-  "setup-wizard",
-  "settings",
-  "queue-depth",
-  "kv-viewer",
-  "secrets-viewer",
-  "db-query",
-  "ai-chat",
-  "edge-topology",
-  "worker-settings",
-];
-
-export function viewIndex(view: ViewId): number {
-  return VIEW_ORDER.indexOf(view);
-}
-
 export type ModalType = "confirm" | "choice" | "loading" | "prompt";
 
 export interface ModalState {

package/src/utils/colors.test.ts

@@ -31,10 +31,15 @@ function hexToRgb(hex: string): { r: number; g: number; b: number } | null {
     /^#?([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})([0-9A-Fa-f]{2})$/
   );
   if (!match) return null;
+  const rHex = match[1];
+  const gHex = match[2];
+  const bHex = match[3];
+  if (rHex === undefined || gHex === undefined || bHex === undefined)
+    return null;
   return {
-    r: parseInt(match[1], 16),
-    g: parseInt(match[2], 16),
-    b: parseInt(match[3], 16),
+    r: parseInt(rHex, 16),
+    g: parseInt(gHex, 16),
+    b: parseInt(bHex, 16),
   };
 }
 

package/src/view-registry.test.ts

@@ -4,7 +4,7 @@
  */
 
 import { describe, it, expect } from "bun:test";
-import type { ViewId } from "@hoox-sh/hoox-shared";
+import { VIEW_IDS, type ViewId } from "@hoox-sh/hoox-shared";
 import {
   VIEW_REGISTRY,
   REGISTERED_VIEW_IDS,
@@ -19,24 +19,7 @@ import {
   ALL_PALETTE_COMMANDS,
 } from "./view-registry";
 
-const ALL_VIEWS: ViewId[] = [
-  "dashboard",
-  "workers",
-  "worker-detail",
-  "trade-monitor",
-  "logs-viewer",
-  "service-manager",
-  "config-editor",
-  "setup-wizard",
-  "settings",
-  "queue-depth",
-  "kv-viewer",
-  "secrets-viewer",
-  "db-query",
-  "ai-chat",
-  "edge-topology",
-  "worker-settings",
-];
+const ALL_VIEWS: ViewId[] = [...VIEW_IDS];
 
 describe("view-registry", () => {
   it("covers every ViewId exactly once in order", () => {