@legioncodeinc/hive 0.1.0

package/dist/dashboard/web/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../../src/dashboard/web/main.tsx"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAE9C,wGAAwG;AACxG,SAAS,KAAK;IACb,MAAM,IAAI,GAAG,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;IAC7C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO;IAC1B,yFAAyF;IACzF,8FAA8F;IAC9F,+FAA+F;IAC/F,iGAAiG;IACjG,wFAAwF;IACxF,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,IAAI,QAAQ,CAAC;IACtE,MAAM,SAAS,GAAG,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC;IAEpF,+FAA+F;IAC/F,4FAA4F;IAC5F,8FAA8F;IAC9F,gEAAgE;IAChE,MAAM,QAAQ,GAAG,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAChF,MAAM,MAAM,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;IAE3C,MAAM,OAAO,GACZ,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CACtB,KAAC,aAAa,IAAC,SAAS,EAAE,SAAS,GAAI,CACvC,CAAC,CAAC,CAAC,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,CACxB,KAAC,WAAW,IAAC,SAAS,EAAE,SAAS,GAAI,CACrC,CAAC,CAAC,CAAC,CACH,KAAC,KAAK,IAAC,SAAS,EAAE,SAAS,GAAI,CAC/B,CAAC;IAEH,UAAU,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAC,KAAK,CAAC,UAAU,cAAE,OAAO,GAAoB,CAAC,CAAC;AACzE,CAAC;AAED,KAAK,EAAE,CAAC"}

package/dist/dashboard/web/needs-project.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The shared "needs a project selection" EMPTY STATE — PRD-049e (49e-AC-5) — and the FIRST-RUN
+ * "pick a folder to start" CTA — PRD-059b (b-AC-1).
+ *
+ * When no project is selected in the scope switcher (or none is accessible), every project-specific
+ * page renders {@link NeedsProjectSelection} — the explicit empty/needs-selection state INSTEAD of any
+ * data, never another project's rows. It is one shared component (not duplicated per page) so the copy
+ * stays consistent and the jscpd gate is satisfied (a single definition, three call sites).
+ *
+ * When the workspace has ZERO bound projects, the dashboard's PRIMARY content is {@link FirstRunBindCTA}
+ * (b-AC-1): a purposeful "No active projects? Pick a folder to start" call-to-action with one line of
+ * plain instruction and the daemon-served {@link FolderPicker} behind it. On a successful bind it routes
+ * to the Projects page (b-AC-4). Both live here so the empty-state family stays one module. Every visual
+ * value is an existing DS token.
+ */
+import React from "react";
+import type { WireClient } from "./wire.js";
+/**
+ * The explicit needs-selection panel (49e-AC-5). Rendered by the graph / memories / sync pages when
+ * `useScope().scope.project` is undefined: an honest "pick a project to view its <surface>" message,
+ * NOT a faked/another-project's view. `surface` names the page's data ("codebase graph", "memories", …)
+ * so the copy reads naturally per page.
+ */
+export declare function NeedsProjectSelection({ surface }: {
+    surface: string;
+}): React.JSX.Element;
+/** Props for {@link FirstRunBindCTA}. */
+export interface FirstRunBindCTAProps {
+    /** The shared wire client (the shell/page passes the SAME one — never `createWireClient`). */
+    readonly wire: WireClient;
+    /**
+     * Navigate the dashboard to a hash route. On a successful first bind the CTA routes to the Projects
+     * page (b-AC-4). The shell passes its 037b `navigate`; a test passes a spy.
+     */
+    readonly navigate: (route: string) => void;
+    /**
+     * The host-stamped asset base (`data-asset-base`, `/dashboard` in production). The brand mark MUST
+     * be resolved against it — a hardcoded relative `assets/…` resolves to the unserved `/assets/…`
+     * (a 404), unlike the sidebar/setup-gate which already use `assetBase`. Threaded from `PageProps`.
+     */
+    readonly assetBase: string;
+}
+/**
+ * The first-run "Pick a folder to start" CTA (PRD-059b b-AC-1). Rendered as the PRIMARY dashboard
+ * content when the workspace has ZERO bound projects — never an empty switcher or a blank page. It
+ * states the one action plainly ("point Honeycomb at the repo or folder you want it to remember"),
+ * then reveals the daemon-served {@link FolderPicker} so the user can browse, name, and bind a folder.
+ * On a successful bind it advances to the Projects page (b-AC-4); capture begins because the 059a gate
+ * opens the moment the binding is written (daemon-side).
+ */
+export declare function FirstRunBindCTA({ wire, navigate, assetBase }: FirstRunBindCTAProps): React.JSX.Element;

package/dist/dashboard/web/needs-project.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The shared "needs a project selection" EMPTY STATE — PRD-049e (49e-AC-5) — and the FIRST-RUN
+ * "pick a folder to start" CTA — PRD-059b (b-AC-1).
+ *
+ * When no project is selected in the scope switcher (or none is accessible), every project-specific
+ * page renders {@link NeedsProjectSelection} — the explicit empty/needs-selection state INSTEAD of any
+ * data, never another project's rows. It is one shared component (not duplicated per page) so the copy
+ * stays consistent and the jscpd gate is satisfied (a single definition, three call sites).
+ *
+ * When the workspace has ZERO bound projects, the dashboard's PRIMARY content is {@link FirstRunBindCTA}
+ * (b-AC-1): a purposeful "No active projects? Pick a folder to start" call-to-action with one line of
+ * plain instruction and the daemon-served {@link FolderPicker} behind it. On a successful bind it routes
+ * to the Projects page (b-AC-4). Both live here so the empty-state family stays one module. Every visual
+ * value is an existing DS token.
+ */
+import React from "react";
+import { Button } from "./primitives.js";
+import { FolderPicker } from "./folder-picker.js";
+import { PROJECTS_ROUTE } from "./registry.js";
+/**
+ * The explicit needs-selection panel (49e-AC-5). Rendered by the graph / memories / sync pages when
+ * `useScope().scope.project` is undefined: an honest "pick a project to view its <surface>" message,
+ * NOT a faked/another-project's view. `surface` names the page's data ("codebase graph", "memories", …)
+ * so the copy reads naturally per page.
+ */
+export function NeedsProjectSelection({ surface }) {
+    return (_jsxs("div", { "data-testid": "needs-project-selection", style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            justifyContent: "center",
+            gap: 10,
+            minHeight: 320,
+            padding: "48px 16px",
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border-default)",
+            borderRadius: "var(--radius-lg)",
+            textAlign: "center",
+        }, children: [_jsx("div", { style: { fontSize: 15, color: "var(--text-secondary)" }, children: "No project selected." }), _jsxs("span", { style: { fontFamily: "var(--font-mono)", fontSize: 12, color: "var(--text-tertiary)", maxWidth: 460 }, children: ["Pick a project in the scope switcher (top of the sidebar) to view its ", surface, "."] })] }));
+}
+/**
+ * The first-run "Pick a folder to start" CTA (PRD-059b b-AC-1). Rendered as the PRIMARY dashboard
+ * content when the workspace has ZERO bound projects — never an empty switcher or a blank page. It
+ * states the one action plainly ("point Honeycomb at the repo or folder you want it to remember"),
+ * then reveals the daemon-served {@link FolderPicker} so the user can browse, name, and bind a folder.
+ * On a successful bind it advances to the Projects page (b-AC-4); capture begins because the 059a gate
+ * opens the moment the binding is written (daemon-side).
+ */
+export function FirstRunBindCTA({ wire, navigate, assetBase }) {
+    const [picking, setPicking] = React.useState(false);
+    const onBound = React.useCallback((_ack) => {
+        // b-AC-4: the bind is written + the 059a gate opened daemon-side; advance to the Projects page
+        // where the freshly-bound project now appears (the page hydrates from the synced registry).
+        navigate(PROJECTS_ROUTE);
+    }, [navigate]);
+    return (_jsxs("div", { "data-testid": "first-run-bind", style: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "center",
+            gap: 16,
+            padding: "48px 16px",
+            background: "var(--bg-surface)",
+            border: "1px solid var(--border-default)",
+            borderRadius: "var(--radius-lg)",
+            textAlign: "center",
+        }, children: [_jsx("img", { src: `${assetBase}/honeycomb-memory-cluster.svg`, width: 48, height: 48, alt: "" }), _jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 8, maxWidth: 480 }, children: [_jsx("div", { style: { fontSize: 17, fontWeight: 700, color: "var(--text-primary)", letterSpacing: "-0.02em" }, children: "No active projects?" }), _jsx("div", { style: { fontSize: 14, color: "var(--text-secondary)", lineHeight: 1.5 }, children: "Pick a folder to start \u2014 point Honeycomb at the repo or folder you want it to remember, and it begins capturing there." })] }), picking ? (_jsx("div", { style: { width: "100%", maxWidth: 620, textAlign: "left" }, children: _jsx(FolderPicker, { wire: wire, onBound: onBound, onCancel: () => setPicking(false) }) })) : (_jsx(Button, { variant: "primary", size: "lg", onClick: () => setPicking(true), "data-testid": "first-run-pick", children: "Pick a folder to start" }))] }));
+}
+//# sourceMappingURL=needs-project.js.map

package/dist/dashboard/web/needs-project.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"needs-project.js","sourceRoot":"","sources":["../../../src/dashboard/web/needs-project.tsx"],"names":[],"mappings":"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"}

package/dist/dashboard/web/page-frame.d.ts

@@ -0,0 +1,95 @@
+/**
+ * The shared PAGE FRAME + the page contract — PRD-037c (the extensibility surface).
+ *
+ * Every routed page (the Dashboard lift-and-shift plus the six PRD-039..044 destinations) renders
+ * INSIDE `<PageFrame>`: an optional mono eyebrow, a title, and a content body capped at the
+ * preserved readable max-width (the old `.wrap` 1180px cap, D-8). The frame's background is
+ * transparent — the canvas `--bg-canvas` shows through and panels inside keep their own
+ * `--bg-surface` (mirrors the `Panel` header rhythm in `panels.tsx` but at PAGE scale). A page
+ * therefore carries NO chrome of its own (037c AC-1): the shell owns the sidebar/header, the page
+ * owns its content.
+ *
+ * `PageProps` is the single contract the router outlet passes EVERY page (037c): the shared `wire`
+ * client (so a page never re-creates one), the `daemonUp` flag (the shell owns the down state, so a
+ * page renders content assuming up — D-5), and the `assetBase`. `usePoll` is the documented
+ * hydration recipe — fetch-on-mount + interval + cleanup-on-unmount — replicating the old
+ * `app.tsx`'s log/health poll so a page (Logs, Memories, Graph…) hydrates the same way without
+ * re-deriving the lifecycle (037c AC-4).
+ *
+ * Every visual value here is an existing `var(--…)` design token — NO new token (D-3 / D-9).
+ */
+import React from "react";
+import type { HealthReasonsWire, WireClient } from "./wire.js";
+/**
+ * The props the router outlet passes every routed page (037c). A page reads the SHARED `wire`
+ * (never `createWireClient` itself), renders content for the up daemon (the shell swaps in the
+ * ConnectivityBanner when down — D-5, so `daemonUp` is informational for a page that wants to
+ * gate its own polling), and uses `assetBase` for any host-served asset (e.g. the mark).
+ */
+export interface PageProps {
+    /** The shared, already-constructed wire client (the shell builds ONE and passes it down). */
+    readonly wire: WireClient;
+    /** Daemon liveness — the shell owns the down view-swap; a page may use this to gate its polling. */
+    readonly daemonUp: boolean;
+    /** The base path the host serves assets (mark/logo) under (loopback, no secret — D-9). */
+    readonly assetBase: string;
+    /**
+     * Whether a Pollinate pass is currently active (D-5: the "Pollinate now" action lives in the SHELL chrome,
+     * so the pollinating flag is owned there and passed DOWN). Informational for most pages; the Dashboard
+     * page reads it to drive the graph/card pollinate pulse. Defaults `false` for a page that ignores it.
+     */
+    readonly pollinating?: boolean;
+    /**
+     * The latest `/health` subsystem reasons, owned by the SHELL's single liveness poll and passed DOWN
+     * (so a page never polls `/health` a second time — the home's per-subsystem strip reads THIS). `null`
+     * before the first probe resolves or when the mode-gated public body omits reasons. Defaults `null`.
+     */
+    readonly healthReasons?: HealthReasonsWire | null;
+}
+/** The maximum readable content width — preserves the old `.wrap` 1180px cap (D-8). */
+export declare const PAGE_MAX_WIDTH: 1180;
+/** Props for {@link PageFrame}. */
+export interface PageFrameProps {
+    /** The page title (page-scale heading). */
+    readonly title: string;
+    /** An optional mono eyebrow above the title (e.g. a route tag or count). */
+    readonly eyebrow?: string;
+    /** An optional right-aligned slot on the title row (a page-level action/status). */
+    readonly right?: React.ReactNode;
+    /** The page content (panels, grids, etc.). */
+    readonly children?: React.ReactNode;
+}
+/**
+ * The shared page layout (037c AC-1). An optional mono eyebrow + a title row, then the content
+ * body capped at {@link PAGE_MAX_WIDTH}. Transparent background (the canvas shows through). Uses
+ * only existing DS tokens — the title treatment mirrors the `Panel` header (`--text-base`+,
+ * `--text-primary`, `letterSpacing: -0.01em`); the eyebrow mirrors the mono `--text-tertiary`
+ * uppercase eyebrow the KPI/health strip already speak.
+ */
+export declare function PageFrame({ title, eyebrow, right, children }: PageFrameProps): React.JSX.Element;
+/**
+ * The documented hydration recipe (037c AC-4): fetch-on-mount + interval poll + cleanup-on-unmount,
+ * replicating the old `app.tsx`'s log/health poll lifecycle so a page polls a live endpoint the
+ * SAME way the dashboard does today. `fn` is invoked once immediately on mount, then every `ms`
+ * until the component unmounts; the `setInterval` is cleared and an `alive` flag prevents a
+ * late-resolving async `fn` from updating an unmounted tree. `fn` is held in a ref so a page can
+ * pass an inline closure without re-subscribing the interval every render (only `ms` re-arms it).
+ *
+ * ── Background pause (perf) ──────────────────────────────────────────────────
+ *   A dashboard left open in a BACKGROUND tab must not keep hitting the daemon/DeepLake. So a tick
+ *   NO-OPs while `document.visibilityState === "hidden"`; the interval keeps its cadence but does no
+ *   work until the tab is foregrounded again. A `visibilitychange` → visible fires an IMMEDIATE tick
+ *   so returning to the tab refreshes at once instead of waiting up to `ms`. This is the single seam
+ *   every page's poll inherits the pause from.
+ *
+ * @example
+ *   // A Logs page that polls /api/logs every 2.5s and stops on unmount:
+ *   usePoll(async () => setLines(await wire.logs(8)), 2500);
+ */
+/**
+ * Whether the tab is currently backgrounded (the single visibility predicate). A backgrounded
+ * dashboard should not keep hitting the daemon/DeepLake, so {@link usePoll} and the pages' own raw
+ * poll loops skip their fetch while this is true. SSR/non-DOM safe (returns `false` with no `document`).
+ */
+export declare function isTabHidden(): boolean;
+export declare function usePoll(fn: () => void | Promise<void>, ms: number): void;

package/dist/dashboard/web/page-frame.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The shared PAGE FRAME + the page contract — PRD-037c (the extensibility surface).
+ *
+ * Every routed page (the Dashboard lift-and-shift plus the six PRD-039..044 destinations) renders
+ * INSIDE `<PageFrame>`: an optional mono eyebrow, a title, and a content body capped at the
+ * preserved readable max-width (the old `.wrap` 1180px cap, D-8). The frame's background is
+ * transparent — the canvas `--bg-canvas` shows through and panels inside keep their own
+ * `--bg-surface` (mirrors the `Panel` header rhythm in `panels.tsx` but at PAGE scale). A page
+ * therefore carries NO chrome of its own (037c AC-1): the shell owns the sidebar/header, the page
+ * owns its content.
+ *
+ * `PageProps` is the single contract the router outlet passes EVERY page (037c): the shared `wire`
+ * client (so a page never re-creates one), the `daemonUp` flag (the shell owns the down state, so a
+ * page renders content assuming up — D-5), and the `assetBase`. `usePoll` is the documented
+ * hydration recipe — fetch-on-mount + interval + cleanup-on-unmount — replicating the old
+ * `app.tsx`'s log/health poll so a page (Logs, Memories, Graph…) hydrates the same way without
+ * re-deriving the lifecycle (037c AC-4).
+ *
+ * Every visual value here is an existing `var(--…)` design token — NO new token (D-3 / D-9).
+ */
+import React from "react";
+/** The maximum readable content width — preserves the old `.wrap` 1180px cap (D-8). */
+export const PAGE_MAX_WIDTH = 1180;
+/**
+ * The shared page layout (037c AC-1). An optional mono eyebrow + a title row, then the content
+ * body capped at {@link PAGE_MAX_WIDTH}. Transparent background (the canvas shows through). Uses
+ * only existing DS tokens — the title treatment mirrors the `Panel` header (`--text-base`+,
+ * `--text-primary`, `letterSpacing: -0.01em`); the eyebrow mirrors the mono `--text-tertiary`
+ * uppercase eyebrow the KPI/health strip already speak.
+ */
+export function PageFrame({ title, eyebrow, right, children }) {
+    return (_jsxs("div", { style: { maxWidth: PAGE_MAX_WIDTH, margin: "0 auto", width: "100%" }, children: [_jsxs("header", { style: { display: "flex", alignItems: "center", gap: 12, marginBottom: 18 }, children: [_jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 4, minWidth: 0 }, children: [eyebrow !== undefined && eyebrow !== "" && (_jsx("span", { style: {
+                                    fontFamily: "var(--font-mono)",
+                                    fontSize: 11,
+                                    color: "var(--text-tertiary)",
+                                    textTransform: "uppercase",
+                                    letterSpacing: "0.08em",
+                                }, children: eyebrow })), _jsx("h1", { style: { fontSize: "var(--text-lg)", fontWeight: 700, color: "var(--text-primary)", margin: 0, letterSpacing: "-0.01em", lineHeight: 1.1 }, children: title })] }), _jsx("span", { style: { flex: 1 } }), right] }), _jsx("div", { children: children })] }));
+}
+/**
+ * The documented hydration recipe (037c AC-4): fetch-on-mount + interval poll + cleanup-on-unmount,
+ * replicating the old `app.tsx`'s log/health poll lifecycle so a page polls a live endpoint the
+ * SAME way the dashboard does today. `fn` is invoked once immediately on mount, then every `ms`
+ * until the component unmounts; the `setInterval` is cleared and an `alive` flag prevents a
+ * late-resolving async `fn` from updating an unmounted tree. `fn` is held in a ref so a page can
+ * pass an inline closure without re-subscribing the interval every render (only `ms` re-arms it).
+ *
+ * ── Background pause (perf) ──────────────────────────────────────────────────
+ *   A dashboard left open in a BACKGROUND tab must not keep hitting the daemon/DeepLake. So a tick
+ *   NO-OPs while `document.visibilityState === "hidden"`; the interval keeps its cadence but does no
+ *   work until the tab is foregrounded again. A `visibilitychange` → visible fires an IMMEDIATE tick
+ *   so returning to the tab refreshes at once instead of waiting up to `ms`. This is the single seam
+ *   every page's poll inherits the pause from.
+ *
+ * @example
+ *   // A Logs page that polls /api/logs every 2.5s and stops on unmount:
+ *   usePoll(async () => setLines(await wire.logs(8)), 2500);
+ */
+/**
+ * Whether the tab is currently backgrounded (the single visibility predicate). A backgrounded
+ * dashboard should not keep hitting the daemon/DeepLake, so {@link usePoll} and the pages' own raw
+ * poll loops skip their fetch while this is true. SSR/non-DOM safe (returns `false` with no `document`).
+ */
+export function isTabHidden() {
+    return typeof document !== "undefined" && document.visibilityState === "hidden";
+}
+export function usePoll(fn, ms) {
+    const fnRef = React.useRef(fn);
+    // Keep the latest `fn` without re-arming the interval (only `ms` re-arms it).
+    React.useEffect(() => {
+        fnRef.current = fn;
+    }, [fn]);
+    React.useEffect(() => {
+        let alive = true;
+        const tick = async () => {
+            if (!alive || isTabHidden())
+                return;
+            await fnRef.current();
+        };
+        void tick();
+        const id = setInterval(() => void tick(), ms);
+        // Refresh immediately on re-foreground (the skipped ticks left the view as stale as `ms` ago).
+        const onVisible = () => {
+            if (!isTabHidden())
+                void tick();
+        };
+        if (typeof document !== "undefined")
+            document.addEventListener("visibilitychange", onVisible);
+        return () => {
+            alive = false;
+            clearInterval(id);
+            if (typeof document !== "undefined")
+                document.removeEventListener("visibilitychange", onVisible);
+        };
+    }, [ms]);
+}
+//# sourceMappingURL=page-frame.js.map

package/dist/dashboard/web/page-frame.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-frame.js","sourceRoot":"","sources":["../../../src/dashboard/web/page-frame.tsx"],"names":[],"mappings":"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"}

package/dist/dashboard/web/pages/coming-soon.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The shared "coming soon" placeholder — PRD-037b/037c (empty-frame the six non-Dashboard routes).
+ *
+ * 037 stands up LIVE, testable routes for Harnesses/Memories/Graph/Sync/Logs/Settings before PRDs
+ * 039-044 fill them. Each placeholder is a one-liner over this shared frame so the six pages do not
+ * duplicate the same markup (jscpd discipline — one helper, six thin call sites). It renders inside
+ * `<PageFrame>` (037c) with a mono "coming soon · owned by PRD-0XX" note, using only DS tokens. No
+ * data, no secret — the route is reachable and the seam is proven; the content arrives in its PRD.
+ */
+import React from "react";
+/** Props for {@link ComingSoon}: the page title, its route tag, and the owning PRD id. */
+export interface ComingSoonProps {
+    /** The page title (the nav label, e.g. `Harnesses`). */
+    readonly title: string;
+    /** The owning downstream PRD id, e.g. `PRD-039`, shown in the note so the seam is self-documenting. */
+    readonly ownerPrd: string;
+}
+/**
+ * A reachable, empty-framed route placeholder. The eyebrow carries a mono "coming soon" tag and the
+ * body a single line crediting the owning PRD, so a dogfooder navigating to the route sees an honest
+ * "owned by PRD-0XX" note rather than a blank screen, and a test can assert the route mounted.
+ */
+export declare function ComingSoon({ title, ownerPrd }: ComingSoonProps): React.JSX.Element;

package/dist/dashboard/web/pages/coming-soon.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { PageFrame } from "../page-frame.js";
+/**
+ * A reachable, empty-framed route placeholder. The eyebrow carries a mono "coming soon" tag and the
+ * body a single line crediting the owning PRD, so a dogfooder navigating to the route sees an honest
+ * "owned by PRD-0XX" note rather than a blank screen, and a test can assert the route mounted.
+ */
+export function ComingSoon({ title, ownerPrd }) {
+    return (_jsx(PageFrame, { title: title, eyebrow: "coming soon", children: _jsxs("div", { style: {
+                padding: "28px 20px",
+                background: "var(--bg-surface)",
+                border: "1px solid var(--border-default)",
+                borderRadius: "var(--radius-lg)",
+                color: "var(--text-tertiary)",
+                fontFamily: "var(--font-mono)",
+                fontSize: 13,
+            }, children: ["coming soon \u00B7 owned by ", ownerPrd] }) }));
+}
+//# sourceMappingURL=coming-soon.js.map

package/dist/dashboard/web/pages/coming-soon.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coming-soon.js","sourceRoot":"","sources":["../../../../src/dashboard/web/pages/coming-soon.tsx"],"names":[],"mappings":";AAYA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAU7C;;;;GAIG;AACH,MAAM,UAAU,UAAU,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAmB;IAC9D,OAAO,CACN,KAAC,SAAS,IAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAC,aAAa,YAC7C,eACC,KAAK,EAAE;gBACN,OAAO,EAAE,WAAW;gBACpB,UAAU,EAAE,mBAAmB;gBAC/B,MAAM,EAAE,iCAAiC;gBACzC,YAAY,EAAE,kBAAkB;gBAChC,KAAK,EAAE,sBAAsB;gBAC7B,UAAU,EAAE,kBAAkB;gBAC9B,QAAQ,EAAE,EAAE;aACZ,6CAEuB,QAAQ,IAC3B,GACK,CACZ,CAAC;AACH,CAAC"}

package/dist/dashboard/web/pages/dashboard.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The DASHBOARD page — the zoned home (PRD-038, re-laying the PRD-037b lift-and-shift).
+ *
+ * PRD-037 lifted the old `app.tsx` body onto this route VERBATIM. PRD-038 reorganizes that body into
+ * three named AREA landmarks so the home reads as zones, not one undifferentiated scroll (parent
+ * D-1 / AC-1):
+ *   1. `<section data-area="kpi-band">`     — the per-subsystem health strip + the four headline KPIs
+ *                                             (Memories, Turns, Est. savings, Team skills — 038a).
+ *   2. `<section data-area="recall-area">`  — the recall bar + recalled-memory cards + the PRD-029
+ *                                             lexical-fallback badge, the centerpiece (038b, moved
+ *                                             VERBATIM — same `wire.recall` POST, same render).
+ *   3. `<section data-area="harness-area">` — the {@link HarnessStrip} (wired-in chips + per-harness
+ *                                             KPI tiles + a short-tail `/api/logs` stream — 038c),
+ *                                             then the existing 2-col grid + the full live log,
+ *                                             reorganized into the zone (kept, not dropped).
+ *
+ * Behavior is UNCHANGED — recall, polling, and the KPI/grid panels are MOVED into the areas, not
+ * rebuilt (parent D-2/D-3/D-4). The page hydrates from the SHARED `wire` the shell passes via
+ * {@link PageProps} (it never calls `createWireClient` — the shell builds ONE) and reads the
+ * shell-owned `pollinating` flag (D-6: the "Pollinate now" action, the identity, the coarse daemon pill, and
+ * the daemon-down swap live in the shell, so this page renders NO header of its own). Every visual
+ * value is an existing `var(--…)` DS token; no new token, primitive, or daemon route (AC-7/AC-8).
+ */
+import React from "react";
+import { type PageProps } from "../page-frame.js";
+/**
+ * The Dashboard route content (the lift-and-shift, D-6). On mount it hydrates every view from the
+ * shared `wire` (AC-2), polls `/api/logs` (AC-4) and `/health` for the strip reasons (PRD-029), and
+ * runs recall (AC-3). The `pollinating` pulse is owned by the shell (D-5) and read from props. All
+ * polling clears on unmount. NO header — the shell owns the chrome (D-5).
+ */
+export declare function DashboardPage({ wire, pollinating, healthReasons }: PageProps): React.JSX.Element;

package/dist/dashboard/web/pages/dashboard.js

@@ -0,0 +1,205 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * The DASHBOARD page — the zoned home (PRD-038, re-laying the PRD-037b lift-and-shift).
+ *
+ * PRD-037 lifted the old `app.tsx` body onto this route VERBATIM. PRD-038 reorganizes that body into
+ * three named AREA landmarks so the home reads as zones, not one undifferentiated scroll (parent
+ * D-1 / AC-1):
+ *   1. `<section data-area="kpi-band">`     — the per-subsystem health strip + the four headline KPIs
+ *                                             (Memories, Turns, Est. savings, Team skills — 038a).
+ *   2. `<section data-area="recall-area">`  — the recall bar + recalled-memory cards + the PRD-029
+ *                                             lexical-fallback badge, the centerpiece (038b, moved
+ *                                             VERBATIM — same `wire.recall` POST, same render).
+ *   3. `<section data-area="harness-area">` — the {@link HarnessStrip} (wired-in chips + per-harness
+ *                                             KPI tiles + a short-tail `/api/logs` stream — 038c),
+ *                                             then the existing 2-col grid + the full live log,
+ *                                             reorganized into the zone (kept, not dropped).
+ *
+ * Behavior is UNCHANGED — recall, polling, and the KPI/grid panels are MOVED into the areas, not
+ * rebuilt (parent D-2/D-3/D-4). The page hydrates from the SHARED `wire` the shell passes via
+ * {@link PageProps} (it never calls `createWireClient` — the shell builds ONE) and reads the
+ * shell-owned `pollinating` flag (D-6: the "Pollinate now" action, the identity, the coarse daemon pill, and
+ * the daemon-down swap live in the shell, so this page renders NO header of its own). Every visual
+ * value is an existing `var(--…)` DS token; no new token, primitive, or daemon route (AC-7/AC-8).
+ */
+import React from "react";
+import { Badge, Button, Input, Kpi, MemoryCard } from "../primitives.js";
+import { LiveLog, RulesPanel, SessionsPanel, SettingsPanel, SkillSyncPanel } from "../panels.js";
+import { HarnessStrip } from "../harness-strip.js";
+import { useScope } from "../scope-context.js";
+import { usePoll } from "../page-frame.js";
+import { EMPTY_KPIS, EMPTY_VAULT_SETTINGS, formatLogLine, } from "../wire.js";
+/** How often the live-log poll re-reads `/api/logs` (ms). Reasonable cadence, stopped on unmount. */
+const LOG_POLL_MS = 2500;
+/** How often the harness-strip poll re-reads `/api/diagnostics/harnesses` for last-seen recency (ms). */
+const HARNESS_POLL_MS = 5000;
+/** How many recent log lines the panel keeps. */
+const MAX_LOG_LINES = 8;
+/** The short-tail cap for the harness-area live stream — tighter than the full log (038c-AC-2 / OQ-4). */
+const MAX_STREAM_LINES = 5;
+/** The local-clock prefix for a client-originated log line (recall notes). */
+function clockPrefix() {
+    return new Date().toTimeString().slice(0, 8);
+}
+/** The recall bar: a mono lg Input + a primary Recall button. Enter and click both fire. */
+function RecallBar({ query, setQuery, onRecall, busy, }) {
+    return (_jsxs("div", { style: { display: "flex", gap: 10, marginBottom: 18 }, children: [_jsx("div", { style: { flex: 1 }, children: _jsx(Input, { mono: true, size: "lg", value: query, placeholder: "recall\u2026  e.g. how do we deploy", onChange: (e) => setQuery(e.target.value), onKeyDown: (e) => {
+                        if (e.key === "Enter")
+                            onRecall();
+                    } }) }), _jsx(Button, { variant: "primary", size: "lg", onClick: onRecall, disabled: busy, children: busy ? "…" : "Recall" })] }));
+}
+/**
+ * The PRD-029 "lexical fallback" badge (AC-1). Rendered ONLY when the recall response carried
+ * `degraded: true` (embeddings off/absent → lexical BM25/ILIKE). Renders subsystem STATE only — the
+ * single closed flag, NO token/org/header (AC-5) — using the kit's `Badge` in the `warning` tone.
+ */
+function LexicalFallbackBadge() {
+    return (_jsx("span", { title: "recall fell back to lexical (embeddings off) \u2014 semantic ranking unavailable", style: { display: "inline-flex" }, children: _jsx(Badge, { tone: "warning", mono: true, dot: true, children: "lexical fallback" }) }));
+}
+/** The display label + degraded predicate for one subsystem chip in {@link HealthStrip}. */
+const SUBSYSTEMS = [
+    { key: "storage", label: "storage", degraded: (r) => r.storage === "unreachable" },
+    { key: "embeddings", label: "semantic", degraded: (r) => r.embeddings === "off" },
+    { key: "schema", label: "schema", degraded: (r) => r.schema === "missing_table" },
+    // PRD-063b (b-AC-7): the Portkey gateway chip. `unconfigured` (on but no key) + `unreachable`
+    // (a real call failed) are the DOWN states → critical; `off` (not in force) + `ok` are healthy.
+    { key: "portkey", label: "portkey", degraded: (r) => r.portkey === "unconfigured" || r.portkey === "unreachable" },
+];
+/**
+ * The PRD-029 per-subsystem health strip (D-2 render). Reads the `/health` `reasons` block and renders
+ * one small chip per subsystem — `storage`, `semantic` (embeddings), `schema` — tinting a degraded one
+ * `critical` and a healthy one `verified`. When `reasons` is `null` (the mode-gated public body, which
+ * the LOCAL dashboard never gets — defensive) the whole strip renders NOTHING.
+ *
+ * AC-5: every chip renders a subsystem NAME + a closed-enum STATE only — no token/org/endpoint/header.
+ */
+function HealthStrip({ reasons }) {
+    if (reasons === null)
+        return null;
+    return (_jsxs("div", { "data-testid": "health-strip", style: { display: "flex", alignItems: "center", gap: 8, marginBottom: 18, flexWrap: "wrap" }, children: [_jsx("span", { style: { fontFamily: "var(--font-mono)", fontSize: 11, color: "var(--text-tertiary)", textTransform: "uppercase", letterSpacing: "0.08em" }, children: "subsystems" }), SUBSYSTEMS.map((s) => {
+                const down = s.degraded(reasons);
+                const state = String(reasons[s.key]);
+                return (_jsxs(Badge, { tone: down ? "critical" : "verified", mono: true, dot: true, children: [s.label, ": ", state] }, s.key));
+            })] }));
+}
+/**
+ * The Dashboard route content (the lift-and-shift, D-6). On mount it hydrates every view from the
+ * shared `wire` (AC-2), polls `/api/logs` (AC-4) and `/health` for the strip reasons (PRD-029), and
+ * runs recall (AC-3). The `pollinating` pulse is owned by the shell (D-5) and read from props. All
+ * polling clears on unmount. NO header — the shell owns the chrome (D-5).
+ */
+export function DashboardPage({ wire, pollinating = false, healthReasons = null }) {
+    // PRD-049e: the active dashboard scope — the selected project re-scopes the KPI band's
+    // project-bearing counts (Memories / Turns / Est. savings). Absent → the workspace-wide view.
+    const { scope } = useScope();
+    // ── view state (hydrated from the shared wire) ──
+    // `healthReasons` is no longer polled here — the SHELL owns the single /health poll and passes the
+    // reasons down via PageProps (the former double-poll is gone). It still feeds the subsystem strip.
+    const [kpis, setKpis] = React.useState(EMPTY_KPIS);
+    const [sessions, setSessions] = React.useState([]);
+    const [rules, setRules] = React.useState([]);
+    const [skills, setSkills] = React.useState([]);
+    const [vaultSettings, setVaultSettings] = React.useState(EMPTY_VAULT_SETTINGS);
+    const [secretNames, setSecretNames] = React.useState([]);
+    // ── harness-area state (038c) — the PRD-039 registry/telemetry backbone (`wire.harnesses()`) ──
+    const [harnesses, setHarnesses] = React.useState([]);
+    // ── recall state (AC-3) ──
+    const [query, setQuery] = React.useState("how do we deploy");
+    const [results, setResults] = React.useState([]);
+    const [recallBusy, setRecallBusy] = React.useState(false);
+    const [recalled, setRecalled] = React.useState(false);
+    const [recallNonce, setRecallNonce] = React.useState(0);
+    const [recallDegraded, setRecallDegraded] = React.useState(false);
+    // ── log + recall-note state (AC-4) ──
+    const [logLines, setLogLines] = React.useState([]);
+    const [notes, setNotes] = React.useState([]);
+    /** Push a client-originated note (recall summary) onto the live-log feed. */
+    const pushNote = React.useCallback((text) => {
+        setNotes((prev) => [`${clockPrefix()}  ${text}`, ...prev].slice(0, MAX_LOG_LINES));
+    }, []);
+    // PRD-049e: a monotonic request token guarding `hydrate` against a stale-overwrite race. Since the
+    // hydrate effect now re-runs on `scope.project` change, a SLOWER response for the PREVIOUS project can
+    // resolve AFTER the newer selection's and repaint the band with stale data. Each hydrate bumps this and
+    // captures its own token; only the LATEST run commits its state (older in-flight runs bail post-await).
+    const hydrateSeqRef = React.useRef(0);
+    /**
+     * Hydrate the diagnostics views + the vault settings from the live endpoints (AC-2), in ONE
+     * batched `Promise.all` round-trip (parity with the old app). The org/workspace `settings` view
+     * now renders in the SHELL header (D-5), so the page no longer keeps it — but the shell hydrates
+     * its own settings; this page hydrates only what its body renders.
+     */
+    const hydrate = React.useCallback(async () => {
+        const seq = ++hydrateSeqRef.current;
+        const [k, sess, r, sk, vs, sn] = await Promise.all([
+            wire.kpis(scope.project),
+            wire.sessions(),
+            wire.rules(),
+            wire.skills(),
+            wire.vaultSettings(),
+            wire.secretNames(),
+        ]);
+        // A newer hydrate (a faster project switch) superseded this one → drop this stale result wholesale
+        // so the band never flickers back to the previous project's numbers.
+        if (seq !== hydrateSeqRef.current)
+            return;
+        setKpis(k);
+        setSessions(sess);
+        setRules(r);
+        setSkills(sk);
+        setVaultSettings(vs);
+        setSecretNames(sn);
+    }, [wire, scope.project]);
+    /** PRD-032c (AC-5): persist one vault `setting` through the daemon, then RE-READ the persisted truth. */
+    const saveSetting = React.useCallback(async (key, value) => {
+        const ok = await wire.setSetting(key, value);
+        const [vs, sn] = await Promise.all([wire.vaultSettings(), wire.secretNames()]);
+        setVaultSettings(vs);
+        setSecretNames(sn);
+        return ok;
+    }, [wire]);
+    // AC-2: hydrate once on mount.
+    React.useEffect(() => {
+        void hydrate();
+    }, [hydrate]);
+    // Defer the below-the-fold harness area to a SECOND paint so the KPI band + recall (what the operator
+    // looks at) are interactive first. The flag flips in a passive effect (after the first commit paints),
+    // so the heavy strip/grid/log mount on the next render, not the first. The `harness-area` landmark
+    // itself always renders (stable layout); only its CONTENTS wait for this.
+    const [showSecondary, setShowSecondary] = React.useState(false);
+    React.useEffect(() => {
+        setShowSecondary(true);
+    }, []);
+    // AC-4: poll /api/logs and render real daemon log lines. Via `usePoll` → shared background-tab pause +
+    // stop-on-unmount (no hand-rolled interval/alive loop).
+    usePoll(async () => {
+        const records = await wire.logs(MAX_LOG_LINES);
+        setLogLines(records.slice(-MAX_LOG_LINES).reverse().map(formatLogLine));
+    }, LOG_POLL_MS);
+    // 038c: poll the PRD-039 harness registry/telemetry for the wired-in strip + per-harness tiles. A light
+    // poll keeps last-seen recency fresh; a failure degrades to [] (wire-safe). Via `usePoll` (gated + cleaned).
+    usePoll(async () => setHarnesses(await wire.harnesses()), HARNESS_POLL_MS);
+    // AC-3: recall → POST /api/memories/recall → render the hits as MemoryCards.
+    const recall = React.useCallback(async () => {
+        const q = query.trim();
+        if (q === "" || recallBusy)
+            return;
+        setRecallBusy(true);
+        const { memories, degraded } = await wire.recall(q);
+        setResults(memories);
+        setRecalled(true);
+        setRecallDegraded(degraded);
+        setRecallNonce((n) => n + 1);
+        const top = memories.length > 0 ? ` · ${memories[0]?.score.toFixed(2)} top` : "";
+        pushNote(`recall    "${q}" → ${memories.length} hits${top}`);
+        setRecallBusy(false);
+    }, [query, recallBusy, wire, pushNote]);
+    // The live-log feed merges client notes (recall) ahead of the polled daemon lines.
+    const feed = React.useMemo(() => [...notes, ...logLines].slice(0, MAX_LOG_LINES), [notes, logLines]);
+    // 038c-AC-2: the harness-area short-tail stream — the SAME polled /api/logs lines, capped tighter
+    // than the full log. `/api/logs` carries no per-line harness field (c-OQ-3), so it is unlabeled.
+    const streamLines = React.useMemo(() => logLines.slice(0, MAX_STREAM_LINES), [logLines]);
+    return (_jsxs(_Fragment, { children: [_jsxs("section", { "data-area": "kpi-band", "aria-label": "Key metrics", style: { marginBottom: 22 }, children: [_jsx(HealthStrip, { reasons: healthReasons }), _jsxs("div", { className: "kpirow", children: [_jsx(Kpi, { label: "Memories", value: kpis.memoryCount.toLocaleString(), accent: "honey" }), _jsx(Kpi, { label: "Turns", value: kpis.turnCount || kpis.sessionCount, accent: "neutral" }), _jsx(Kpi, { label: "Est. savings", value: kpis.estimatedSavings.toLocaleString(), unit: "tok", accent: "verified" }), _jsx(Kpi, { label: "Team skills", value: kpis.teamSkillCount, accent: "pollinate" })] })] }), _jsxs("section", { "data-area": "recall-area", "aria-label": "Memory search", style: { marginBottom: 22 }, children: [_jsx(RecallBar, { query: query, setQuery: setQuery, onRecall: recall, busy: recallBusy }), recalled && recallDegraded && (_jsxs("div", { style: { display: "flex", alignItems: "center", gap: 8, marginBottom: 12 }, children: [_jsx("span", { style: { fontFamily: "var(--font-mono)", fontSize: 11, color: "var(--text-tertiary)", textTransform: "uppercase", letterSpacing: "0.08em" }, children: "recall" }), _jsx(LexicalFallbackBadge, {})] })), _jsx("div", { style: { display: "flex", flexDirection: "column", gap: 10 }, children: results.length === 0
+                            ? recalled && (_jsx("div", { style: { padding: "10px 4px", fontSize: 13, color: "var(--text-tertiary)" }, children: "No memories matched that query." }))
+                            : results.map((m, i) => (_jsx("div", { className: "mem-enter", style: { animationDelay: `${i * 55}ms` }, children: _jsx(MemoryCard, { ...m, pollinating: pollinating && i === 1 }) }, m.memoryKey))) }, recallNonce)] }), _jsx("section", { "data-area": "harness-area", "aria-label": "Harnesses and activity", children: showSecondary && (_jsxs(_Fragment, { children: [_jsx("div", { style: { marginBottom: 16 }, children: _jsx(HarnessStrip, { harnesses: harnesses, streamLines: streamLines }) }), _jsxs("div", { className: "grid2", style: { marginBottom: 16 }, children: [_jsxs("div", { className: "col", children: [_jsx(SessionsPanel, { sessions: sessions }), _jsx(RulesPanel, { rules: rules })] }), _jsxs("div", { className: "col", children: [_jsx(SettingsPanel, { catalog: vaultSettings.catalog, settings: vaultSettings.settings, secretNames: secretNames, onSave: saveSetting }), _jsx(SkillSyncPanel, { skills: skills })] })] }), _jsx(LiveLog, { lines: feed })] })) })] }));
+}
+//# sourceMappingURL=dashboard.js.map