@legioncodeinc/hive 0.1.0

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

@@ -0,0 +1,1937 @@
+/**
+ * The dashboard web app's WIRE LAYER — PRD-024 Wave 2 (AC-2..AC-6).
+ *
+ * The browser app is a THIN CLIENT: it hydrates entirely from the daemon's already-served
+ * JSON endpoints (D-2, no canned `data.js`). This module is the single typed boundary
+ * between the untyped `fetch` Response and the kit's React props:
+ *
+ *   - It declares a zod schema PER endpoint, mirroring the daemon-side view-model contracts
+ *     in `src/dashboard/contracts.ts` (D-5 — reuse the shapes, do not re-derive them). The
+ *     WIRE truth (what `src/daemon/runtime/dashboard/api.ts` + the recall/logs routes
+ *     actually return) is what these schemas validate, NOT the canned `data.js` shapes.
+ *   - It parses every payload through zod, so a malformed/partial response degrades to a
+ *     safe empty/zero state rather than throwing into React (AC-2 empty states).
+ *   - No `any` crosses the fetch boundary: each fetcher returns a typed, validated value.
+ *
+ * Wire endpoints (all loopback, all already served — this app NEVER rebuilds them):
+ *   GET  /api/diagnostics/kpis|sessions|settings|rules|skills   → the dashboard view-models
+ *   GET  /api/graph                                             → the codebase graph view
+ *   POST /api/memories/recall                                   → recall hits
+ *   GET  /api/logs                                              → the request-log ring buffer
+ *   GET  /health                                                → daemon liveness
+ *   POST /api/diagnostics/pollinate                                 → the Wave-1 Pollinate trigger
+ */
+import { z } from "zod";
+import { type RoiTrendView, type RoiView } from "../contracts.js";
+/** The diagnostics view-model endpoints (served under `/api/diagnostics/*` + `/api/graph`). */
+export declare const ENDPOINTS: Readonly<{
+    readonly kpis: "/api/diagnostics/kpis";
+    readonly sessions: "/api/diagnostics/sessions";
+    readonly settings: "/api/diagnostics/settings";
+    readonly rules: "/api/diagnostics/rules";
+    readonly skills: "/api/diagnostics/skills";
+    readonly graph: "/api/graph";
+    readonly graphBuild: "/api/graph/build";
+    readonly memoryGraph: "/api/diagnostics/memory-graph";
+    readonly recall: "/api/memories/recall";
+    readonly memories: "/api/memories";
+    readonly compact: "/api/diagnostics/compact";
+    readonly lifecycleConflicts: "/api/memories/conflicts";
+    readonly lifecycleStaleRefs: "/api/memories/stale-refs";
+    readonly lifecycleHistory: "/api/memories/history";
+    readonly calibration: "/api/memories/calibration";
+    readonly logs: "/api/logs";
+    readonly logsStream: "/api/logs/stream";
+    readonly harnesses: "/api/diagnostics/harnesses";
+    readonly assets: "/api/diagnostics/assets";
+    readonly syncAction: "/api/diagnostics/sync";
+    readonly health: "/health";
+    readonly pollinate: "/api/diagnostics/pollinate";
+    readonly vaultSettings: "/api/settings";
+    readonly secrets: "/api/secrets";
+    readonly authStatus: "/api/auth/status";
+    readonly setupState: "/setup/state";
+    readonly setupLogin: "/setup/login";
+    readonly setupMigrate: "/setup/migrate-from-hivemind";
+    readonly setupMigrateRollback: "/setup/migrate-from-hivemind/rollback";
+    readonly scopeOrgs: "/api/diagnostics/scope/orgs";
+    readonly scopeWorkspaces: "/api/diagnostics/scope/workspaces";
+    readonly scopeProjects: "/api/diagnostics/scope/projects";
+    readonly fsBrowse: "/api/diagnostics/fs/browse";
+    readonly projectsBind: "/api/diagnostics/projects/bind";
+    readonly projectsBindExisting: "/api/diagnostics/projects/bind-existing";
+    readonly projectsUnbind: "/api/diagnostics/projects/unbind";
+    readonly scopeOrgSwitch: "/api/diagnostics/scope/org-switch";
+    readonly scopeWorkspaceSwitch: "/api/diagnostics/scope/workspace-switch";
+    readonly roi: "/api/diagnostics/roi";
+    readonly roiTrend: "/api/diagnostics/roi/trend";
+    readonly actionsLogout: "/api/actions/logout";
+    readonly actionsEmbeddings: "/api/actions/embeddings";
+    readonly actionsRestart: "/api/actions/restart";
+    readonly actionsUninstall: "/api/actions/uninstall";
+}>;
+/**
+ * PRD-049e (49e-AC-2) — the header carrying the dashboard's SELECTED project id. The switcher's
+ * selection is VIEWER-SIDE: stamping this header on a read narrows the daemon's project-segment
+ * predicate to exactly that project (the daemon honors it in `resolveRequestProject`), WITHOUT
+ * touching any per-folder CLI binding (49e-AC-4 — it is a request header, never a write). An empty
+ * selection omits the header (the read stays project-agnostic / cwd-resolved, back-compat).
+ */
+export declare const PROJECT_HEADER: "x-honeycomb-project";
+/** Build the per-request project header, or an empty object when no project is selected. */
+export declare function projectHeader(projectId: string | undefined): Record<string, string>;
+/** PRD-040a — the default first-page size the Memories list requests (the daemon clamps to 500). */
+export declare const DEFAULT_MEMORY_LIST_LIMIT: 50;
+/** `GET /api/diagnostics/kpis` → {@link import("../contracts.js").KpisView}. */
+export declare const KpisSchema: z.ZodObject<{
+    memoryCount: z.ZodCatch<z.ZodNumber>;
+    sessionCount: z.ZodCatch<z.ZodNumber>;
+    turnCount: z.ZodCatch<z.ZodNumber>;
+    estimatedSavings: z.ZodCatch<z.ZodNumber>;
+    teamSkillCount: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type KpisWire = z.infer<typeof KpisSchema>;
+/** One row of `GET /api/diagnostics/sessions` → {@link import("../contracts.js").SessionRow}. */
+export declare const SessionRowSchema: z.ZodObject<{
+    sessionId: z.ZodCatch<z.ZodString>;
+    project: z.ZodCatch<z.ZodString>;
+    startedAt: z.ZodCatch<z.ZodString>;
+    eventCount: z.ZodCatch<z.ZodNumber>;
+    status: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export declare const SessionsSchema: z.ZodObject<{
+    sessions: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodCatch<z.ZodString>;
+        project: z.ZodCatch<z.ZodString>;
+        startedAt: z.ZodCatch<z.ZodString>;
+        eventCount: z.ZodCatch<z.ZodNumber>;
+        status: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SessionRowWire = z.infer<typeof SessionRowSchema>;
+/** `GET /api/diagnostics/settings` → {@link import("../contracts.js").SettingsView}. */
+export declare const SettingsSchema: z.ZodObject<{
+    orgId: z.ZodCatch<z.ZodString>;
+    orgName: z.ZodCatch<z.ZodString>;
+    workspace: z.ZodCatch<z.ZodString>;
+    settings: z.ZodCatch<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type SettingsWire = z.infer<typeof SettingsSchema>;
+/** A graph node/edge → {@link import("../contracts.js").GraphNode} / `GraphEdge`. */
+export declare const GraphNodeSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    label: z.ZodCatch<z.ZodString>;
+    kind: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export declare const GraphEdgeSchema: z.ZodObject<{
+    from: z.ZodCatch<z.ZodString>;
+    to: z.ZodCatch<z.ZodString>;
+    kind: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+/** Bounded-view metadata → {@link import("../contracts.js").GraphViewMeta} (the graph memory cap — the graph cap). */
+export declare const GraphMetaSchema: z.ZodObject<{
+    totalNodes: z.ZodCatch<z.ZodNumber>;
+    totalEdges: z.ZodCatch<z.ZodNumber>;
+    shownNodes: z.ZodCatch<z.ZodNumber>;
+    shownEdges: z.ZodCatch<z.ZodNumber>;
+    truncated: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const GraphSchema: z.ZodObject<{
+    built: z.ZodCatch<z.ZodBoolean>;
+    nodes: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        label: z.ZodCatch<z.ZodString>;
+        kind: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+    edges: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        from: z.ZodCatch<z.ZodString>;
+        to: z.ZodCatch<z.ZodString>;
+        kind: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+    meta: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        totalNodes: z.ZodCatch<z.ZodNumber>;
+        totalEdges: z.ZodCatch<z.ZodNumber>;
+        shownNodes: z.ZodCatch<z.ZodNumber>;
+        shownEdges: z.ZodCatch<z.ZodNumber>;
+        truncated: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GraphWire = z.infer<typeof GraphSchema>;
+/** One rule of `GET /api/diagnostics/rules` → {@link import("../contracts.js").RuleRow}. */
+export declare const RuleRowSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    title: z.ZodCatch<z.ZodString>;
+    active: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const RulesSchema: z.ZodObject<{
+    rules: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        title: z.ZodCatch<z.ZodString>;
+        active: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RuleRowWire = z.infer<typeof RuleRowSchema>;
+/** One skill of `GET /api/diagnostics/skills` → {@link import("../contracts.js").SkillSyncRow}. */
+export declare const SkillRowSchema: z.ZodObject<{
+    name: z.ZodCatch<z.ZodString>;
+    scope: z.ZodCatch<z.ZodString>;
+    syncState: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export declare const SkillsSchema: z.ZodObject<{
+    skills: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        name: z.ZodCatch<z.ZodString>;
+        scope: z.ZodCatch<z.ZodString>;
+        syncState: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SkillRowWire = z.infer<typeof SkillRowSchema>;
+/** The per-section status discriminant → {@link import("../contracts.js").RoiSectionStatus}. */
+export declare const RoiSectionStatusSchema: z.ZodCatch<z.ZodEnum<{
+    ok: "ok";
+    unreachable: "unreachable";
+    partial: "partial";
+    absent: "absent";
+    unauthenticated: "unauthenticated";
+}>>;
+/** The status default for a BILLING-backed line — `unreachable` (couldn't read), not `absent` (no data). */
+export declare const RoiBillingStatusSchema: z.ZodCatch<z.ZodEnum<{
+    ok: "ok";
+    unreachable: "unreachable";
+    partial: "partial";
+    absent: "absent";
+    unauthenticated: "unauthenticated";
+}>>;
+/** The cost-basis tag → {@link import("../contracts.js").RoiCostBasisTag}. */
+export declare const RoiCostBasisSchema: z.ZodCatch<z.ZodEnum<{
+    measured: "measured";
+    allocated: "allocated";
+    none: "none";
+}>>;
+/** The modeled assumption carried as data (e-AC-8) → {@link import("../contracts.js").RoiAssumption}. */
+export declare const RoiAssumptionSchema: z.ZodObject<{
+    kind: z.ZodCatch<z.ZodString>;
+    assumptionText: z.ZodCatch<z.ZodString>;
+    signedOff: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/** The savings section (e-AC-3) → {@link import("../contracts.js").RoiSavingsSection}. */
+export declare const RoiSavingsSectionSchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        partial: "partial";
+        absent: "absent";
+        unauthenticated: "unauthenticated";
+    }>>;
+    measuredCents: z.ZodCatch<z.ZodNumber>;
+    modeledCents: z.ZodCatch<z.ZodNumber>;
+    assumption: z.ZodCatch<z.ZodObject<{
+        kind: z.ZodCatch<z.ZodString>;
+        assumptionText: z.ZodCatch<z.ZodString>;
+        signedOff: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    blendedCentsPerMtok: z.ZodCatch<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/** The infra cost section (e-AC-6) → {@link import("../contracts.js").RoiInfraSection}. */
+export declare const RoiInfraSectionSchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        partial: "partial";
+        absent: "absent";
+        unauthenticated: "unauthenticated";
+    }>>;
+    cents: z.ZodCatch<z.ZodNumber>;
+    costBasis: z.ZodCatch<z.ZodEnum<{
+        measured: "measured";
+        allocated: "allocated";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
+/** One pollination split line → {@link import("../contracts.js").RoiPollinationLine}. */
+export declare const RoiPollinationLineSchema: z.ZodObject<{
+    label: z.ZodCatch<z.ZodString>;
+    cents: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+/** The pollination cost section (e-AC-6) → {@link import("../contracts.js").RoiPollinationSection}. */
+export declare const RoiPollinationSectionSchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        partial: "partial";
+        absent: "absent";
+        unauthenticated: "unauthenticated";
+    }>>;
+    cents: z.ZodCatch<z.ZodNumber>;
+    lines: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        label: z.ZodCatch<z.ZodString>;
+        cents: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** The net-ROI section (e-AC-6) → {@link import("../contracts.js").RoiNetSection}. */
+export declare const RoiNetSectionSchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        partial: "partial";
+        absent: "absent";
+        unauthenticated: "unauthenticated";
+    }>>;
+    computed: z.ZodCatch<z.ZodBoolean>;
+    netCents: z.ZodCatch<z.ZodNumber>;
+    modeled: z.ZodCatch<z.ZodBoolean>;
+    costBasis: z.ZodCatch<z.ZodEnum<{
+        measured: "measured";
+        allocated: "allocated";
+        none: "none";
+    }>>;
+}, z.core.$strip>;
+/** One rollup row → {@link import("../contracts.js").RoiRollupRow}. */
+export declare const RoiRollupRowSchema: z.ZodObject<{
+    key: z.ZodCatch<z.ZodString>;
+    label: z.ZodCatch<z.ZodString>;
+    measuredSavingsCents: z.ZodCatch<z.ZodNumber>;
+    netCents: z.ZodCatch<z.ZodNumber>;
+    infraCostCents: z.ZodCatch<z.ZodNumber>;
+    costBasis: z.ZodCatch<z.ZodEnum<{
+        measured: "measured";
+        allocated: "allocated";
+        none: "none";
+    }>>;
+    sessions: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+/** One rollup view (e-AC-13) → {@link import("../contracts.js").RoiRollup}. */
+export declare const RoiRollupSchema: z.ZodObject<{
+    dimension: z.ZodCatch<z.ZodEnum<{
+        org: "org";
+        team: "team";
+        agent: "agent";
+        project: "project";
+    }>>;
+    rows: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        key: z.ZodCatch<z.ZodString>;
+        label: z.ZodCatch<z.ZodString>;
+        measuredSavingsCents: z.ZodCatch<z.ZodNumber>;
+        netCents: z.ZodCatch<z.ZodNumber>;
+        infraCostCents: z.ZodCatch<z.ZodNumber>;
+        costBasis: z.ZodCatch<z.ZodEnum<{
+            measured: "measured";
+            allocated: "allocated";
+            none: "none";
+        }>>;
+        sessions: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    mixedBasis: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/** `GET /api/diagnostics/roi` → {@link import("../contracts.js").RoiView}. */
+export declare const RoiViewSchema: z.ZodObject<{
+    savings: z.ZodCatch<z.ZodObject<{
+        status: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            unreachable: "unreachable";
+            partial: "partial";
+            absent: "absent";
+            unauthenticated: "unauthenticated";
+        }>>;
+        measuredCents: z.ZodCatch<z.ZodNumber>;
+        modeledCents: z.ZodCatch<z.ZodNumber>;
+        assumption: z.ZodCatch<z.ZodObject<{
+            kind: z.ZodCatch<z.ZodString>;
+            assumptionText: z.ZodCatch<z.ZodString>;
+            signedOff: z.ZodCatch<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        blendedCentsPerMtok: z.ZodCatch<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    infra: z.ZodCatch<z.ZodObject<{
+        status: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            unreachable: "unreachable";
+            partial: "partial";
+            absent: "absent";
+            unauthenticated: "unauthenticated";
+        }>>;
+        cents: z.ZodCatch<z.ZodNumber>;
+        costBasis: z.ZodCatch<z.ZodEnum<{
+            measured: "measured";
+            allocated: "allocated";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    pollination: z.ZodCatch<z.ZodObject<{
+        status: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            unreachable: "unreachable";
+            partial: "partial";
+            absent: "absent";
+            unauthenticated: "unauthenticated";
+        }>>;
+        cents: z.ZodCatch<z.ZodNumber>;
+        lines: z.ZodCatch<z.ZodArray<z.ZodObject<{
+            label: z.ZodCatch<z.ZodString>;
+            cents: z.ZodCatch<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    net: z.ZodCatch<z.ZodObject<{
+        status: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            unreachable: "unreachable";
+            partial: "partial";
+            absent: "absent";
+            unauthenticated: "unauthenticated";
+        }>>;
+        computed: z.ZodCatch<z.ZodBoolean>;
+        netCents: z.ZodCatch<z.ZodNumber>;
+        modeled: z.ZodCatch<z.ZodBoolean>;
+        costBasis: z.ZodCatch<z.ZodEnum<{
+            measured: "measured";
+            allocated: "allocated";
+            none: "none";
+        }>>;
+    }, z.core.$strip>>;
+    rollups: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        dimension: z.ZodCatch<z.ZodEnum<{
+            org: "org";
+            team: "team";
+            agent: "agent";
+            project: "project";
+        }>>;
+        rows: z.ZodCatch<z.ZodArray<z.ZodObject<{
+            key: z.ZodCatch<z.ZodString>;
+            label: z.ZodCatch<z.ZodString>;
+            measuredSavingsCents: z.ZodCatch<z.ZodNumber>;
+            netCents: z.ZodCatch<z.ZodNumber>;
+            infraCostCents: z.ZodCatch<z.ZodNumber>;
+            costBasis: z.ZodCatch<z.ZodEnum<{
+                measured: "measured";
+                allocated: "allocated";
+                none: "none";
+            }>>;
+            sessions: z.ZodCatch<z.ZodNumber>;
+        }, z.core.$strip>>>;
+        mixedBasis: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    perUserAvailable: z.ZodCatch<z.ZodBoolean>;
+    scopedAcrossDevices: z.ZodCatch<z.ZodBoolean>;
+    ratesAsOf: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type RoiViewWire = z.infer<typeof RoiViewSchema>;
+/** One trend point (e-AC-10) → {@link import("../contracts.js").RoiTrendPoint}. */
+export declare const RoiTrendPointSchema: z.ZodObject<{
+    period: z.ZodCatch<z.ZodString>;
+    cents: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+/** One trend series (e-AC-10, dashed=modeled / solid=measured) → {@link import("../contracts.js").RoiTrendSeries}. */
+export declare const RoiTrendSeriesSchema: z.ZodObject<{
+    label: z.ZodCatch<z.ZodString>;
+    modeled: z.ZodCatch<z.ZodBoolean>;
+    points: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        period: z.ZodCatch<z.ZodString>;
+        cents: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** `GET /api/diagnostics/roi/trend` → {@link import("../contracts.js").RoiTrendView}. */
+export declare const RoiTrendViewSchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        partial: "partial";
+        absent: "absent";
+        unauthenticated: "unauthenticated";
+    }>>;
+    series: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        label: z.ZodCatch<z.ZodString>;
+        modeled: z.ZodCatch<z.ZodBoolean>;
+        points: z.ZodCatch<z.ZodArray<z.ZodObject<{
+            period: z.ZodCatch<z.ZodString>;
+            cents: z.ZodCatch<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    startedAt: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type RoiTrendViewWire = z.infer<typeof RoiTrendViewSchema>;
+/** One union row on the wire (mirrors the daemon `AssetSyncRow`). State badges drive off `state`. */
+export declare const AssetSyncRowSchema: z.ZodObject<{
+    assetType: z.ZodCatch<z.ZodEnum<{
+        agent: "agent";
+        skill: "skill";
+    }>>;
+    name: z.ZodCatch<z.ZodString>;
+    description: z.ZodCatch<z.ZodString>;
+    state: z.ZodCatch<z.ZodEnum<{
+        local: "local";
+        pulled: "pulled";
+        shared: "shared";
+    }>>;
+    scope: z.ZodCatch<z.ZodString>;
+    sourceHarness: z.ZodCatch<z.ZodString>;
+    tier: z.ZodCatch<z.ZodString>;
+    style: z.ZodCatch<z.ZodString>;
+    version: z.ZodCatch<z.ZodNumber>;
+    honeycombId: z.ZodCatch<z.ZodString>;
+    authoredByMe: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AssetSyncRowWire = z.infer<typeof AssetSyncRowSchema>;
+/** `GET /api/diagnostics/assets` → `{ skills, agents }`. A bad shape degrades to empty lists. */
+export declare const AssetSyncViewSchema: z.ZodObject<{
+    skills: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        assetType: z.ZodCatch<z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>>;
+        name: z.ZodCatch<z.ZodString>;
+        description: z.ZodCatch<z.ZodString>;
+        state: z.ZodCatch<z.ZodEnum<{
+            local: "local";
+            pulled: "pulled";
+            shared: "shared";
+        }>>;
+        scope: z.ZodCatch<z.ZodString>;
+        sourceHarness: z.ZodCatch<z.ZodString>;
+        tier: z.ZodCatch<z.ZodString>;
+        style: z.ZodCatch<z.ZodString>;
+        version: z.ZodCatch<z.ZodNumber>;
+        honeycombId: z.ZodCatch<z.ZodString>;
+        authoredByMe: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    agents: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        assetType: z.ZodCatch<z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>>;
+        name: z.ZodCatch<z.ZodString>;
+        description: z.ZodCatch<z.ZodString>;
+        state: z.ZodCatch<z.ZodEnum<{
+            local: "local";
+            pulled: "pulled";
+            shared: "shared";
+        }>>;
+        scope: z.ZodCatch<z.ZodString>;
+        sourceHarness: z.ZodCatch<z.ZodString>;
+        tier: z.ZodCatch<z.ZodString>;
+        style: z.ZodCatch<z.ZodString>;
+        version: z.ZodCatch<z.ZodNumber>;
+        honeycombId: z.ZodCatch<z.ZodString>;
+        authoredByMe: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type AssetSyncViewWire = z.infer<typeof AssetSyncViewSchema>;
+/** A sync-action ack (mirrors the daemon `SyncActionResult`). Carries NO blob/secret — id/state/version. */
+export declare const SyncActionResultSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    action: z.ZodCatch<z.ZodEnum<{
+        enable: "enable";
+        disable: "disable";
+        promote: "promote";
+        pull: "pull";
+        demote: "demote";
+    }>>;
+    assetType: z.ZodCatch<z.ZodEnum<{
+        agent: "agent";
+        skill: "skill";
+    }>>;
+    honeycombId: z.ZodCatch<z.ZodString>;
+    state: z.ZodCatch<z.ZodEnum<{
+        "": "";
+        local: "local";
+        pulled: "pulled";
+        shared: "shared";
+    }>>;
+    version: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type SyncActionResultWire = z.infer<typeof SyncActionResultSchema>;
+/** The empty union view the page shows before the first load resolves (or on failure). */
+export declare const EMPTY_ASSET_SYNC_VIEW: AssetSyncViewWire;
+/**
+ * One recall hit on the wire — the `/api/memories/recall` response shape from
+ * `src/daemon/runtime/memories/recall.ts`. PRD-027 Wave 1 made the hit carry a REAL
+ * `{ source, id, text, score, kind, secondary }`: `score` is the fused RRF relevance
+ * (the engine already emits hits ranked DESC by it), `kind` is the provenance class
+ * (`"memory"` distilled vs `"session"` raw dump), and `secondary` is `true` iff the hit
+ * is a drill-down raw session row. The client renders the ENGINE score + ENGINE order —
+ * it NEVER fabricates a score (D-4 / AC-4 removed the old `1 - i*0.06` synthesis).
+ *
+ * The score/kind/secondary fields `.catch()` to safe defaults so an OLDER daemon that
+ * predates Wave 1 (no score on the wire) still renders (degrade gracefully). The LIVE
+ * daemon now always sends them. The kit's `MemoryCard` wants
+ * `{ memoryKey, snippet, source, score, scope, verified }`; we MAP the wire hit to those
+ * props in {@link recall} (id→memoryKey, text→snippet, ENGINE `score`→score, the arm name→
+ * scope hint, `kind`/`secondary`→the distilled-vs-drill-down demotion).
+ */
+export declare const RecallHitSchema: z.ZodObject<{
+    source: z.ZodCatch<z.ZodString>;
+    id: z.ZodCatch<z.ZodString>;
+    text: z.ZodCatch<z.ZodString>;
+    score: z.ZodCatch<z.ZodNumber>;
+    kind: z.ZodCatch<z.ZodEnum<{
+        memory: "memory";
+        session: "session";
+    }>>;
+    secondary: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const RecallResponseSchema: z.ZodObject<{
+    hits: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        source: z.ZodCatch<z.ZodString>;
+        id: z.ZodCatch<z.ZodString>;
+        text: z.ZodCatch<z.ZodString>;
+        score: z.ZodCatch<z.ZodNumber>;
+        kind: z.ZodCatch<z.ZodEnum<{
+            memory: "memory";
+            session: "session";
+        }>>;
+        secondary: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    sources: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    degraded: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/** A rendered recalled memory (the shape the `MemoryCard` consumes). */
+export interface RecalledMemory {
+    readonly memoryKey: string;
+    readonly snippet: string;
+    readonly source: string;
+    /** The ENGINE's fused RRF relevance score (NOT a client fabrication — PRD-027 AC-4). */
+    readonly score: number;
+    readonly scope: string;
+    readonly verified: boolean;
+    /** Provenance class from the engine: distilled `"memory"` vs raw-dump `"session"`. */
+    readonly kind: "memory" | "session";
+    /** `true` iff a drill-down raw session row (the card visually demotes these). */
+    readonly secondary: boolean;
+}
+/**
+ * PRD-040 — one memory row on the wire. MIRRORS the daemon read-model
+ * `src/daemon/runtime/memories/reads.ts` `MemoryRecord` (the original thin shape PLUS the
+ * OQ-1 additive detail metadata). Every field `.catch()`-defaults so a partial/older payload —
+ * a daemon serving only the thin `{ id, type, content, confidence, agentId, createdAt,
+ * updatedAt }`, or a malformed body — degrades to a safe value rather than throwing into React.
+ * The five OQ-1 fields (`visibility`/`sourceType`/`sourceId`/`version`/`hasEmbedding`) are
+ * `.catch()`-defaulted EXACTLY so an older/thin daemon still renders the detail view (with those
+ * fields blank/false). No secret rides this shape — scope tag, provenance, a version, a boolean.
+ */
+export declare const MemoryRecordSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    type: z.ZodCatch<z.ZodString>;
+    content: z.ZodCatch<z.ZodString>;
+    confidence: z.ZodCatch<z.ZodNumber>;
+    agentId: z.ZodCatch<z.ZodString>;
+    createdAt: z.ZodCatch<z.ZodString>;
+    updatedAt: z.ZodCatch<z.ZodString>;
+    visibility: z.ZodCatch<z.ZodString>;
+    sourceType: z.ZodCatch<z.ZodString>;
+    sourceId: z.ZodCatch<z.ZodString>;
+    version: z.ZodCatch<z.ZodNumber>;
+    hasEmbedding: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MemoryRecordWire = z.infer<typeof MemoryRecordSchema>;
+/** `GET /api/memories` body: `{ memories: MemoryRecord[] }`. A bad shape degrades to `[]`. */
+export declare const MemoryListResponseSchema: z.ZodObject<{
+    memories: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        type: z.ZodCatch<z.ZodString>;
+        content: z.ZodCatch<z.ZodString>;
+        confidence: z.ZodCatch<z.ZodNumber>;
+        agentId: z.ZodCatch<z.ZodString>;
+        createdAt: z.ZodCatch<z.ZodString>;
+        updatedAt: z.ZodCatch<z.ZodString>;
+        visibility: z.ZodCatch<z.ZodString>;
+        sourceType: z.ZodCatch<z.ZodString>;
+        sourceId: z.ZodCatch<z.ZodString>;
+        version: z.ZodCatch<z.ZodNumber>;
+        hasEmbedding: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** `GET /api/memories/:id` body: `{ memory: MemoryRecord }`. A 404 is handled at the call site (→ null). */
+export declare const MemoryGetResponseSchema: z.ZodObject<{
+    memory: z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        type: z.ZodCatch<z.ZodString>;
+        content: z.ZodCatch<z.ZodString>;
+        confidence: z.ZodCatch<z.ZodNumber>;
+        agentId: z.ZodCatch<z.ZodString>;
+        createdAt: z.ZodCatch<z.ZodString>;
+        updatedAt: z.ZodCatch<z.ZodString>;
+        visibility: z.ZodCatch<z.ZodString>;
+        sourceType: z.ZodCatch<z.ZodString>;
+        sourceId: z.ZodCatch<z.ZodString>;
+        version: z.ZodCatch<z.ZodNumber>;
+        hasEmbedding: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** `POST /api/memories` (store) ack: `{ id, action }` (201). `id` is null when the daemon dedup-skips. */
+export declare const StoreAckSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    action: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type StoreAckWire = z.infer<typeof StoreAckSchema>;
+/** `POST /api/memories/:id/modify` + `/forget` ack: `{ id, action, audited }`. */
+export declare const WriteAckSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    action: z.ZodCatch<z.ZodString>;
+    audited: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type WriteAckWire = z.infer<typeof WriteAckSchema>;
+/**
+ * PRD-040c — one per-table compaction summary on the wire, MIRRORING the daemon
+ * `CompactTableResult` (`src/daemon/runtime/maintenance/compact-api.ts`): the table name + the
+ * reap counts + an `errored` count (>0 ⇒ "attempted, not completed"). Every field `.catch()`es
+ * so a partial body still renders. No secret — table names + integer counts only.
+ */
+export declare const CompactTableResultSchema: z.ZodObject<{
+    table: z.ZodCatch<z.ZodString>;
+    keysScanned: z.ZodCatch<z.ZodNumber>;
+    keysCompacted: z.ZodCatch<z.ZodNumber>;
+    rowsReaped: z.ZodCatch<z.ZodNumber>;
+    keysSkipped: z.ZodCatch<z.ZodNumber>;
+    errored: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type CompactTableResultWire = z.infer<typeof CompactTableResultSchema>;
+/** `POST /api/diagnostics/compact` body: `{ ok, summaries, skippedTables }`. Degrades to an empty summary. */
+export declare const CompactSummarySchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    summaries: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        table: z.ZodCatch<z.ZodString>;
+        keysScanned: z.ZodCatch<z.ZodNumber>;
+        keysCompacted: z.ZodCatch<z.ZodNumber>;
+        rowsReaped: z.ZodCatch<z.ZodNumber>;
+        keysSkipped: z.ZodCatch<z.ZodNumber>;
+        errored: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    skippedTables: z.ZodCatch<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type CompactSummaryWire = z.infer<typeof CompactSummarySchema>;
+/** One conflict row from `GET /api/memories/conflicts` (the pair + verdict + status). */
+export declare const LifecycleConflictSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    memoryAId: z.ZodCatch<z.ZodString>;
+    memoryBId: z.ZodCatch<z.ZodString>;
+    verdict: z.ZodCatch<z.ZodString>;
+    winnerId: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    status: z.ZodCatch<z.ZodString>;
+    contraScore: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type LifecycleConflictWire = z.infer<typeof LifecycleConflictSchema>;
+export declare const LifecycleConflictsResponseSchema: z.ZodObject<{
+    conflicts: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        memoryAId: z.ZodCatch<z.ZodString>;
+        memoryBId: z.ZodCatch<z.ZodString>;
+        verdict: z.ZodCatch<z.ZodString>;
+        winnerId: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+        status: z.ZodCatch<z.ZodString>;
+        contraScore: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    status: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+/** One stale-ref row from `GET /api/memories/stale-refs` (the memory id + its unresolved refs). */
+export declare const LifecycleStaleRefSchema: z.ZodObject<{
+    memoryId: z.ZodCatch<z.ZodString>;
+    refStatus: z.ZodCatch<z.ZodString>;
+    staleRefs: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    verifiedAt: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type LifecycleStaleRefWire = z.infer<typeof LifecycleStaleRefSchema>;
+export declare const LifecycleStaleRefsResponseSchema: z.ZodObject<{
+    staleRefs: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        memoryId: z.ZodCatch<z.ZodString>;
+        refStatus: z.ZodCatch<z.ZodString>;
+        staleRefs: z.ZodCatch<z.ZodArray<z.ZodString>>;
+        verifiedAt: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** One lifecycle audit row from `GET /api/memories/history?type=lifecycle`. */
+export declare const LifecycleHistorySchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    memoryId: z.ZodCatch<z.ZodString>;
+    actor: z.ZodCatch<z.ZodString>;
+    operation: z.ZodCatch<z.ZodString>;
+    reason: z.ZodCatch<z.ZodString>;
+    confidence: z.ZodCatch<z.ZodNumber>;
+    timestamp: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type LifecycleHistoryWire = z.infer<typeof LifecycleHistorySchema>;
+export declare const LifecycleHistoryResponseSchema: z.ZodObject<{
+    history: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        memoryId: z.ZodCatch<z.ZodString>;
+        actor: z.ZodCatch<z.ZodString>;
+        operation: z.ZodCatch<z.ZodString>;
+        reason: z.ZodCatch<z.ZodString>;
+        confidence: z.ZodCatch<z.ZodNumber>;
+        timestamp: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+    type: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+/** One reliability-diagram bin from `GET /api/memories/calibration` (the 058e introspection payload). */
+export declare const ReliabilityBinSchema: z.ZodObject<{
+    lower: z.ZodCatch<z.ZodNumber>;
+    upper: z.ZodCatch<z.ZodNumber>;
+    meanConfidence: z.ZodCatch<z.ZodNumber>;
+    accuracy: z.ZodCatch<z.ZodNumber>;
+    count: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type ReliabilityBinWire = z.infer<typeof ReliabilityBinSchema>;
+/** The `GET /api/memories/calibration` body (ece/brier/n_samples + reliability diagram, 058e). */
+export declare const CalibrationSchema: z.ZodObject<{
+    ece: z.ZodCatch<z.ZodNumber>;
+    brier: z.ZodCatch<z.ZodNumber>;
+    nSamples: z.ZodCatch<z.ZodNumber>;
+    fitAt: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    identity: z.ZodCatch<z.ZodBoolean>;
+    reliabilityDiagram: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        lower: z.ZodCatch<z.ZodNumber>;
+        upper: z.ZodCatch<z.ZodNumber>;
+        meanConfidence: z.ZodCatch<z.ZodNumber>;
+        accuracy: z.ZodCatch<z.ZodNumber>;
+        count: z.ZodCatch<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CalibrationWire = z.infer<typeof CalibrationSchema>;
+/** The cold-start calibration view the panel shows before the first load (or on failure). */
+export declare const EMPTY_CALIBRATION: CalibrationWire;
+/** One `/api/logs` record (the `RequestLogRecord` the ring buffer serves; no secret in it). */
+export declare const LogRecordSchema: z.ZodObject<{
+    time: z.ZodCatch<z.ZodString>;
+    method: z.ZodCatch<z.ZodString>;
+    path: z.ZodCatch<z.ZodString>;
+    status: z.ZodCatch<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodString>;
+    org: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const LogsResponseSchema: z.ZodObject<{
+    records: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        time: z.ZodCatch<z.ZodString>;
+        method: z.ZodCatch<z.ZodString>;
+        path: z.ZodCatch<z.ZodString>;
+        status: z.ZodCatch<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodString>;
+        org: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    count: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type LogRecordWire = z.infer<typeof LogRecordSchema>;
+/**
+ * PRD-043a/043b — `GET /api/logs/history` body: the durable, filterable, paginated request-log
+ * history (newest first) + the next-page cursor. MIRRORS the daemon `LogsHistoryResponse`
+ * (`src/daemon/runtime/logs/api.ts`). Reuses the SAME secret-free {@link LogRecordSchema} as the
+ * live snapshot, so the history table and the live tail share ONE row shape and never drift. Every
+ * field `.catch()`-defaults so a partial/older payload degrades to a safe empty page (never a throw
+ * into React). `nextCursor` is null on the last page; `persistent:false` means history is
+ * unavailable (the store could not open — the page shows its honest empty/unavailable state).
+ */
+export declare const LogsHistoryResponseSchema: z.ZodObject<{
+    records: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        time: z.ZodCatch<z.ZodString>;
+        method: z.ZodCatch<z.ZodString>;
+        path: z.ZodCatch<z.ZodString>;
+        status: z.ZodCatch<z.ZodNumber>;
+        durationMs: z.ZodOptional<z.ZodNumber>;
+        mode: z.ZodOptional<z.ZodString>;
+        org: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    count: z.ZodCatch<z.ZodNumber>;
+    nextCursor: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    persistent: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type LogsHistoryWire = z.infer<typeof LogsHistoryResponseSchema>;
+/** The fixed, validated filter set the Logs history table drives the `/api/logs/history` query with. */
+export interface LogsHistoryFilters {
+    /** Lower time bound (inclusive), ISO-8601. */
+    readonly since?: string;
+    /** Upper time bound (inclusive), ISO-8601. */
+    readonly until?: string;
+    /** Exact status (`404`) or a class (`5xx`/`4xx`/`2xx`). */
+    readonly status?: string;
+    /** Path exact-or-prefix filter. */
+    readonly path?: string;
+    /** Org/harness filter (exact). */
+    readonly org?: string;
+    /** Page size (clamped daemon-side to `MAX_HISTORY_LIMIT`). */
+    readonly limit?: number;
+    /** The opaque pagination cursor (page strictly before this — older window). */
+    readonly cursor?: string;
+}
+/**
+ * PRD-043c — `GET /api/diagnostics/sessions` (paged) body: the browsable captured-TURNS history +
+ * the next-page cursor. Reuses the SAME {@link SessionRowSchema} as the legacy sessions view (so the
+ * Turns list and the dashboard panel share one row shape). Every field `.catch()`-defaults so a
+ * partial/older daemon payload (one WITHOUT `nextCursor`) degrades to a safe page with no further
+ * cursor, never a throw. The page LABELS these "Turns" (PRD-035a); the storage table stays `sessions`.
+ */
+export declare const TurnsHistoryResponseSchema: z.ZodObject<{
+    sessions: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        sessionId: z.ZodCatch<z.ZodString>;
+        project: z.ZodCatch<z.ZodString>;
+        startedAt: z.ZodCatch<z.ZodString>;
+        eventCount: z.ZodCatch<z.ZodNumber>;
+        status: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+    nextCursor: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type TurnsHistoryWire = z.infer<typeof TurnsHistoryResponseSchema>;
+/** Cursor's `cursor-agent` agents descriptor (039c) — present for Cursor, absent for Claude Code. */
+export declare const HarnessAgentsSchema: z.ZodObject<{
+    kind: z.ZodCatch<z.ZodString>;
+    binary: z.ZodCatch<z.ZodString>;
+    fallbackBin: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** One harness's host-CLI descriptor (mirrors the shim `HostCli`). */
+export declare const HarnessHostCliSchema: z.ZodObject<{
+    bin: z.ZodCatch<z.ZodString>;
+    args: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    fallbackBin: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The data-driven capability descriptor folded into each `HarnessStatus` server-side (039c / c-OQ-2).
+ * The OPTIONAL fields are the genuine shim divergences — a missing field omits that harness's panel
+ * on the detail page (c-AC-3), never a blank. Each field `.catch()`es so a partial body still renders.
+ */
+export declare const HarnessCapabilitiesSchema: z.ZodObject<{
+    name: z.ZodCatch<z.ZodString>;
+    runtimePath: z.ZodCatch<z.ZodString>;
+    contextChannel: z.ZodCatch<z.ZodString>;
+    hostCli: z.ZodCatch<z.ZodObject<{
+        bin: z.ZodCatch<z.ZodString>;
+        args: z.ZodCatch<z.ZodArray<z.ZodString>>;
+        fallbackBin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lifecycleEvents: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    agents: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodCatch<z.ZodString>;
+        binary: z.ZodCatch<z.ZodString>;
+        fallbackBin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    workspaceRoots: z.ZodOptional<z.ZodBoolean>;
+    mcpRegistration: z.ZodOptional<z.ZodBoolean>;
+    contractedTools: z.ZodOptional<z.ZodBoolean>;
+    agentsMdContext: z.ZodOptional<z.ZodBoolean>;
+    userVisibleLogin: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type HarnessCapabilitiesWire = z.infer<typeof HarnessCapabilitiesSchema>;
+/** One harness's status row (mirrors the daemon `HarnessStatus`). `lastSeen` is null when never seen. */
+export declare const HarnessStatusSchema: z.ZodObject<{
+    name: z.ZodCatch<z.ZodString>;
+    installed: z.ZodCatch<z.ZodBoolean>;
+    active: z.ZodCatch<z.ZodBoolean>;
+    lastSeen: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    turnsCaptured: z.ZodCatch<z.ZodNumber>;
+    runtimePath: z.ZodCatch<z.ZodString>;
+    capabilities: z.ZodCatch<z.ZodObject<{
+        name: z.ZodCatch<z.ZodString>;
+        runtimePath: z.ZodCatch<z.ZodString>;
+        contextChannel: z.ZodCatch<z.ZodString>;
+        hostCli: z.ZodCatch<z.ZodObject<{
+            bin: z.ZodCatch<z.ZodString>;
+            args: z.ZodCatch<z.ZodArray<z.ZodString>>;
+            fallbackBin: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        lifecycleEvents: z.ZodCatch<z.ZodArray<z.ZodString>>;
+        agents: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodCatch<z.ZodString>;
+            binary: z.ZodCatch<z.ZodString>;
+            fallbackBin: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        workspaceRoots: z.ZodOptional<z.ZodBoolean>;
+        mcpRegistration: z.ZodOptional<z.ZodBoolean>;
+        contractedTools: z.ZodOptional<z.ZodBoolean>;
+        agentsMdContext: z.ZodOptional<z.ZodBoolean>;
+        userVisibleLogin: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const HarnessStatusResponseSchema: z.ZodObject<{
+    harnesses: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        name: z.ZodCatch<z.ZodString>;
+        installed: z.ZodCatch<z.ZodBoolean>;
+        active: z.ZodCatch<z.ZodBoolean>;
+        lastSeen: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+        turnsCaptured: z.ZodCatch<z.ZodNumber>;
+        runtimePath: z.ZodCatch<z.ZodString>;
+        capabilities: z.ZodCatch<z.ZodObject<{
+            name: z.ZodCatch<z.ZodString>;
+            runtimePath: z.ZodCatch<z.ZodString>;
+            contextChannel: z.ZodCatch<z.ZodString>;
+            hostCli: z.ZodCatch<z.ZodObject<{
+                bin: z.ZodCatch<z.ZodString>;
+                args: z.ZodCatch<z.ZodArray<z.ZodString>>;
+                fallbackBin: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            lifecycleEvents: z.ZodCatch<z.ZodArray<z.ZodString>>;
+            agents: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodCatch<z.ZodString>;
+                binary: z.ZodCatch<z.ZodString>;
+                fallbackBin: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            workspaceRoots: z.ZodOptional<z.ZodBoolean>;
+            mcpRegistration: z.ZodOptional<z.ZodBoolean>;
+            contractedTools: z.ZodOptional<z.ZodBoolean>;
+            agentsMdContext: z.ZodOptional<z.ZodBoolean>;
+            userVisibleLogin: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type HarnessStatusWire = z.infer<typeof HarnessStatusSchema>;
+/** The Wave-1 Pollinate ack (`POST /api/diagnostics/pollinate` → 202 + this body). */
+export declare const PollinateAckSchema: z.ZodObject<{
+    triggered: z.ZodCatch<z.ZodBoolean>;
+    status: z.ZodCatch<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PollinateAck = z.infer<typeof PollinateAckSchema>;
+/**
+ * The `POST /api/graph/build` ack (the codebase-graph build worker's data body). The daemon runs the
+ * REAL worker end-to-end — discover → tree-sitter extract → aggregate → finalize → write the LOCAL
+ * snapshot — and returns `{ built, snapshotSha256, nodeCount, edgeCount, fileCount, parseErrorCount,
+ * cacheStats, localPath, push }`. We only validate the four fields the UI needs (`built` + the counts);
+ * the rest of the body is ignored (zod drops extra keys). Every field `.catch()`-defaults so the 500
+ * error body (`{ error, reason }`) — or any malformed/partial payload — degrades to a safe
+ * `{ built: false, … }` ack rather than throwing into React (the page surfaces an honest inline error).
+ */
+export declare const BuildGraphAckSchema: z.ZodObject<{
+    built: z.ZodCatch<z.ZodBoolean>;
+    nodeCount: z.ZodCatch<z.ZodNumber>;
+    edgeCount: z.ZodCatch<z.ZodNumber>;
+    fileCount: z.ZodCatch<z.ZodNumber>;
+}, z.core.$strip>;
+export type BuildGraphAck = z.infer<typeof BuildGraphAckSchema>;
+/**
+ * The honest failure ack the wire returns when the build POST is rejected, times out, or the body is
+ * malformed (never a throw into React). The page keeps its empty state + shows the inline error line.
+ */
+export declare const FAILED_BUILD_GRAPH_ACK: BuildGraphAck;
+/**
+ * The generous client-side timeout (ms) for `buildGraph()`. The build parses the WHOLE repo with
+ * tree-sitter and can take many seconds to tens of seconds; a short default fetch timeout would abort
+ * a legitimate in-progress build. 120s gives the worker ample headroom — well past the realistic build
+ * time — while still bounding a truly hung request so the button never spins forever.
+ */
+export declare const BUILD_GRAPH_TIMEOUT_MS: 120000;
+/** The `POST /api/actions/logout` ack (`{ ok }`). */
+export declare const ActionOkSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The `POST /api/actions/embeddings` ack: `{ ok, enabled }` (the new persisted on/off state). Both
+ * fields are STRICT (no `.catch` default): a malformed/partial body must FAIL the parse → `postJson`
+ * returns null → `setEmbeddings` reports failure. Defaulting `enabled` to `false` would let a
+ * `setEmbeddings(false)` call falsely "succeed" against a response that never echoed the real state.
+ */
+export declare const EmbeddingsActionSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    enabled: z.ZodBoolean;
+}, z.core.$strip>;
+/** The `POST /api/actions/restart` ack: `{ ok, restarting }`. */
+export declare const RestartActionSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    restarting: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/** The `POST /api/actions/uninstall` result: detected harnesses + the exact CLI command + a note. */
+export declare const UninstallResultSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    harnesses: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    removed: z.ZodCatch<z.ZodBoolean>;
+    command: z.ZodCatch<z.ZodString>;
+    note: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+/** The validated uninstall result the page renders honestly (paths/ids/command only — no secret). */
+export type UninstallResultWire = z.infer<typeof UninstallResultSchema>;
+/**
+ * The PRD-029 per-subsystem `/health` `reasons` block (D-2 render). This MIRRORS the
+ * Wave-1 daemon contract `HealthReasons` in `src/daemon/runtime/health.ts` verbatim — a
+ * closed enum per subsystem, NO secret (D-5: no token/org/endpoint/header rides these,
+ * only subsystem names + coarse states). The dashboard is LOCAL-mode so the daemon's
+ * `/health` body carries this block; on a non-local public body it is absent (the strip
+ * renders nothing — handled at the call site by a `null` reasons).
+ *
+ * Each field `.catch()`es to its HEALTHY value so a malformed/partial `reasons` degrades
+ * to "looks ok" rather than throwing into React — the body crosses the untyped IO boundary
+ * exactly like every other endpoint here. An UNKNOWN enum value (a future daemon adds a
+ * state) also `.catch()`es to the healthy default, never a throw.
+ */
+export declare const HealthReasonsSchema: z.ZodObject<{
+    storage: z.ZodCatch<z.ZodEnum<{
+        unreachable: "unreachable";
+        reachable: "reachable";
+    }>>;
+    embeddings: z.ZodCatch<z.ZodEnum<{
+        on: "on";
+        off: "off";
+    }>>;
+    schema: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        missing_table: "missing_table";
+    }>>;
+    portkey: z.ZodCatch<z.ZodEnum<{
+        ok: "ok";
+        unreachable: "unreachable";
+        off: "off";
+        unconfigured: "unconfigured";
+    }>>;
+}, z.core.$strip>;
+export type HealthReasonsWire = z.infer<typeof HealthReasonsSchema>;
+/**
+ * The `/health` body the daemon serves (the coarse bit + the additive PRD-029 `reasons`).
+ * `reasons` is OPTIONAL — absent on the mode-gated public team/hybrid body, present in
+ * local (which the dashboard always is). The whole body `.catch()`es a bad shape so a
+ * malformed `/health` degrades to "no reasons" (coarse pill only), never a throw.
+ *
+ * NOTE the coarse liveness the app's view-swap keys off (`daemonUp`) comes from the HTTP
+ * `res.ok` (a 503-on-degraded still parses a body), NOT from this `status` field — so the
+ * reasons are purely ADDITIVE render data and never change the existing up/down behaviour.
+ */
+export declare const HealthBodySchema: z.ZodObject<{
+    status: z.ZodCatch<z.ZodString>;
+    reasons: z.ZodOptional<z.ZodObject<{
+        storage: z.ZodCatch<z.ZodEnum<{
+            unreachable: "unreachable";
+            reachable: "reachable";
+        }>>;
+        embeddings: z.ZodCatch<z.ZodEnum<{
+            on: "on";
+            off: "off";
+        }>>;
+        schema: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            missing_table: "missing_table";
+        }>>;
+        portkey: z.ZodCatch<z.ZodEnum<{
+            ok: "ok";
+            unreachable: "unreachable";
+            off: "off";
+            unconfigured: "unconfigured";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** The result of a `/health` probe: coarse liveness + the parsed per-subsystem reasons (or null). */
+export interface HealthProbe {
+    /** Daemon liveness — `true` iff the HTTP response was ok (drives the view-swap, unchanged). */
+    readonly up: boolean;
+    /** The per-subsystem reasons (PRD-029), or `null` when the body omits/malforms them. */
+    readonly reasons: HealthReasonsWire | null;
+}
+/**
+ * One provider entry in the catalog `GET /api/settings` returns — MIRRORS the Wave-1
+ * `ProviderEntry` in `src/daemon/runtime/vault/catalog.ts` (D-6). `models` is the curated,
+ * ordered model list (`models[0]` is the selector default); `openEnded` marks OpenRouter,
+ * whose model id is a free-form passthrough (the panel renders a text input for it).
+ */
+export declare const ProviderEntrySchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    label: z.ZodCatch<z.ZodString>;
+    models: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    openEnded: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ProviderEntryWire = z.infer<typeof ProviderEntrySchema>;
+/**
+ * A single `setting` value on the wire — the vault `setting` class stores a JSON SCALAR
+ * (string | number | boolean), so the panel renders exactly those. A non-scalar (a future
+ * structured setting) would register its own class; here a bad value `.catch()`es to a
+ * harmless empty string so the panel never throws.
+ */
+export declare const SettingValueWireSchema: z.ZodCatch<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+export type SettingValueWire = z.infer<typeof SettingValueWireSchema>;
+/**
+ * The `GET /api/settings` body the Wave-1 daemon serves: `{ settings, catalog }`. `settings`
+ * is the current key→value map of the `setting` class (the active provider/model + the
+ * pollinating toggle + dashboard prefs); `catalog` is the static provider→model list. NO secret
+ * is in this body by construction (the surface reads only the `setting` class). Each field
+ * `.catch()`es to an empty default so a partial body degrades to "nothing selected".
+ */
+export declare const VaultSettingsSchema: z.ZodObject<{
+    settings: z.ZodCatch<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>>;
+    catalog: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        label: z.ZodCatch<z.ZodString>;
+        models: z.ZodCatch<z.ZodArray<z.ZodString>>;
+        openEnded: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type VaultSettingsWire = z.infer<typeof VaultSettingsSchema>;
+/**
+ * The `GET /api/secrets` body (PRD-012a, names-only) — `{ names: string[] }`. The panel reads
+ * this ONLY to show a provider key's PRESENCE ("set ✓" / "not set") by name; there is NO
+ * value-returning route and the panel never asks for one (AC-5 / D-4). A malformed body
+ * `.catch()`es to an empty name list (every provider reads as "not set", never a throw).
+ */
+export declare const SecretNamesSchema: z.ZodObject<{
+    names: z.ZodCatch<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type SecretNamesWire = z.infer<typeof SecretNamesSchema>;
+/** The empty vault-settings view the panel shows before the first load (or on failure). */
+export declare const EMPTY_VAULT_SETTINGS: VaultSettingsWire;
+/**
+ * The `GET /api/auth/status` body the auth section reads (PRD-044a). Metadata ONLY: org id +
+ * name, workspace, agent, the credentials `source` (`env` | `file` | `none`), `savedAt`, and an
+ * optional `expiresAt`. There is deliberately NO `token` field — zod drops any extra `token` key
+ * in the body, so a token can never reach React even if a buggy daemon sent one. Every field
+ * `.catch()`-defaults to a disconnected-safe value (AC-4: degrade, never throw).
+ */
+export declare const AuthStatusSchema: z.ZodObject<{
+    connected: z.ZodCatch<z.ZodBoolean>;
+    orgId: z.ZodCatch<z.ZodString>;
+    orgName: z.ZodCatch<z.ZodString>;
+    workspace: z.ZodCatch<z.ZodString>;
+    agentId: z.ZodCatch<z.ZodString>;
+    source: z.ZodCatch<z.ZodEnum<{
+        file: "file";
+        none: "none";
+        env: "env";
+    }>>;
+    savedAt: z.ZodCatch<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AuthStatusWire = z.infer<typeof AuthStatusSchema>;
+/**
+ * The honest disconnected status the auth section shows before the first load, on any failure,
+ * or when no credentials resolve (AC-4). Never a blank panel, never a fabricated org.
+ */
+export declare const DISCONNECTED_AUTH_STATUS: AuthStatusWire;
+/** Per-tool credential/state directory presence (mirrors the daemon `SetupCredentialsPresence`). */
+export declare const SetupCredentialsSchema: z.ZodObject<{
+    deeplake: z.ZodCatch<z.ZodBoolean>;
+    honeycomb: z.ZodCatch<z.ZodBoolean>;
+    hivemind: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/** The embeddings warmup signal (b-AC-5) — observable, never blocking. */
+export declare const SetupWarmupSchema: z.ZodObject<{
+    enabled: z.ZodCatch<z.ZodBoolean>;
+    live: z.ZodCatch<z.ZodBoolean>;
+    warm: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The `GET /setup/state` body the guided-setup shell reads (PRD-050b). `authenticated` is the
+ * DERIVED auth source of truth (a valid credential loads), NOT the `phase` hint. Every field
+ * `.catch()`-defaults to a fresh-install-safe value so a failed/non-local read renders the
+ * guided-setup state (the safe default), never a throw.
+ */
+export declare const SetupStateSchema: z.ZodObject<{
+    credentials: z.ZodCatch<z.ZodObject<{
+        deeplake: z.ZodCatch<z.ZodBoolean>;
+        honeycomb: z.ZodCatch<z.ZodBoolean>;
+        hivemind: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    phase: z.ZodCatch<z.ZodEnum<{
+        installed: "installed";
+        fresh: "fresh";
+        linking: "linking";
+        linked: "linked";
+        migrating: "migrating";
+        migrated: "migrated";
+    }>>;
+    priorTool: z.ZodCatch<z.ZodObject<{
+        hivemind: z.ZodCatch<z.ZodEnum<{
+            absent: "absent";
+            migrated: "migrated";
+            present: "present";
+        }>>;
+    }, z.core.$strip>>;
+    firstTimeSetupComplete: z.ZodCatch<z.ZodBoolean>;
+    authenticated: z.ZodCatch<z.ZodBoolean>;
+    warmup: z.ZodCatch<z.ZodObject<{
+        enabled: z.ZodCatch<z.ZodBoolean>;
+        live: z.ZodCatch<z.ZodBoolean>;
+        warm: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    migration: z.ZodOptional<z.ZodObject<{
+        phase: z.ZodCatch<z.ZodEnum<{
+            link: "link";
+            backup: "backup";
+            uninstall: "uninstall";
+            done: "done";
+            rolled_back: "rolled_back";
+        }>>;
+        startedAt: z.ZodCatch<z.ZodString>;
+        backupPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SetupStateWire = z.infer<typeof SetupStateSchema>;
+/**
+ * The honest fresh-install setup state the shell shows before the first load, on any failure, or in
+ * non-local mode (the route 404s). `authenticated:false` ⇒ the guided-setup state renders (b-AC-6).
+ */
+export declare const FRESH_SETUP_STATE: SetupStateWire;
+/**
+ * The `POST /setup/login` render payload (PRD-050c, consumed by 050b's "First time setup" button).
+ * The body carries ONLY the `user_code` to display + the verification URIs — NEVER a token/device
+ * code (the schema has no token field by construction). Every field `.catch()`-defaults so a partial
+ * body degrades safely; `verification_uri_complete` is optional (present only when https-validated).
+ */
+export declare const SetupLoginSchema: z.ZodObject<{
+    user_code: z.ZodCatch<z.ZodString>;
+    verification_uri: z.ZodCatch<z.ZodString>;
+    verification_uri_complete: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SetupLoginWire = z.infer<typeof SetupLoginSchema>;
+/**
+ * PRD-050d — the `POST /setup/migrate-from-hivemind` response (consumed by the "Proceed with Honeycomb"
+ * button). Carries the terminal `phase` + a plain-language `message` + the `backupPath` reversibility
+ * anchor + the `needsLogin`/`migrated` flags. NO token/secret rides this shape by construction. Every
+ * field `.catch()`-defaults so a partial/failed body degrades to a safe "not ok" state, never a throw.
+ * `needsLogin:true` ⇒ the page runs the 050c device flow; `migrated:true` ⇒ the silent-adopt completed.
+ */
+export declare const SetupMigrateSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    phase: z.ZodCatch<z.ZodEnum<{
+        link: "link";
+        backup: "backup";
+        uninstall: "uninstall";
+        done: "done";
+        rolled_back: "rolled_back";
+    }>>;
+    message: z.ZodCatch<z.ZodString>;
+    backupPath: z.ZodOptional<z.ZodString>;
+    needsLogin: z.ZodOptional<z.ZodBoolean>;
+    migrated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SetupMigrateWire = z.infer<typeof SetupMigrateSchema>;
+/** The honest "migration unavailable" ack the wizard shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_SETUP_MIGRATE: SetupMigrateWire;
+/** PRD-050d — the `POST /setup/migrate-from-hivemind/rollback` response (the d-AC-7 roll-back affordance). */
+export declare const SetupMigrateRollbackSchema: z.ZodObject<{
+    ok: z.ZodCatch<z.ZodBoolean>;
+    phase: z.ZodCatch<z.ZodLiteral<"rolled_back">>;
+    message: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type SetupMigrateRollbackWire = z.infer<typeof SetupMigrateRollbackSchema>;
+/** The honest "rollback unavailable" ack the wizard shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_SETUP_MIGRATE_ROLLBACK: SetupMigrateRollbackWire;
+/** One enumerated org (id + display name) from `GET /api/diagnostics/scope/orgs`. */
+export declare const ScopeOrgSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    name: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type ScopeOrgWire = z.infer<typeof ScopeOrgSchema>;
+/** The `GET /api/diagnostics/scope/orgs` body — `{ orgs }`. A failure degrades to an empty list. */
+export declare const ScopeOrgsSchema: z.ZodObject<{
+    orgs: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        name: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/** One enumerated workspace (id + display name) from `GET /api/diagnostics/scope/workspaces`. */
+export declare const ScopeWorkspaceSchema: z.ZodObject<{
+    id: z.ZodCatch<z.ZodString>;
+    name: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type ScopeWorkspaceWire = z.infer<typeof ScopeWorkspaceSchema>;
+/**
+ * The `GET /api/diagnostics/scope/workspaces` body — `{ workspaces, org, reminted }`. `reminted` is
+ * true when the daemon re-minted the org-bound token before enumerating (49e-AC-3 observability).
+ */
+export declare const ScopeWorkspacesSchema: z.ZodObject<{
+    workspaces: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        id: z.ZodCatch<z.ZodString>;
+        name: z.ZodCatch<z.ZodString>;
+    }, z.core.$strip>>>;
+    org: z.ZodCatch<z.ZodString>;
+    reminted: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ScopeWorkspacesWire = z.infer<typeof ScopeWorkspacesSchema>;
+/**
+ * One enumerated project (the workspace's synced 049a registry copy) — id + display name + the
+ * PRD-059d `boundLocally` bit. `boundLocally` is true when a local folder→project binding targets
+ * this project on THIS device (the Projects page shows those as ACTIVE); false ⇒ registry-only,
+ * IMPORTABLE (the 059d "Import project from cloud" list shows those). `.catch(false)` so an OLDER
+ * daemon payload that predates the field degrades to "not bound here" (safe: it would appear in the
+ * import list, never silently as active) rather than throwing into React.
+ */
+export declare const ScopeProjectSchema: z.ZodObject<{
+    projectId: z.ZodCatch<z.ZodString>;
+    name: z.ZodCatch<z.ZodString>;
+    boundLocally: z.ZodCatch<z.ZodBoolean>;
+    boundPaths: z.ZodCatch<z.ZodArray<z.ZodString>>;
+    remote: z.ZodCatch<z.ZodString>;
+    memoryCount: z.ZodCatch<z.ZodNumber>;
+    sessionCount: z.ZodCatch<z.ZodNumber>;
+    lastCapture: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ScopeProjectWire = z.infer<typeof ScopeProjectSchema>;
+/** The `GET /api/diagnostics/scope/projects` body — `{ projects, org, workspace }`. */
+export declare const ScopeProjectsSchema: z.ZodObject<{
+    projects: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        projectId: z.ZodCatch<z.ZodString>;
+        name: z.ZodCatch<z.ZodString>;
+        boundLocally: z.ZodCatch<z.ZodBoolean>;
+        boundPaths: z.ZodCatch<z.ZodArray<z.ZodString>>;
+        remote: z.ZodCatch<z.ZodString>;
+        memoryCount: z.ZodCatch<z.ZodNumber>;
+        sessionCount: z.ZodCatch<z.ZodNumber>;
+        lastCapture: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    org: z.ZodCatch<z.ZodString>;
+    workspace: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type ScopeProjectsWire = z.infer<typeof ScopeProjectsSchema>;
+/** One immediate child directory in a browse listing (059b) — basename + absolute path + git-repo marker. */
+export declare const BrowseChildSchema: z.ZodObject<{
+    name: z.ZodCatch<z.ZodString>;
+    path: z.ZodCatch<z.ZodString>;
+    isGitRepo: z.ZodCatch<z.ZodBoolean>;
+}, z.core.$strip>;
+export type BrowseChildWire = z.infer<typeof BrowseChildSchema>;
+/**
+ * The `GET /api/diagnostics/fs/browse` body (059b): the resolved dir + its immediate child
+ * directories. `parent` is null at the allowed root (no traversal above it); `error` is a redacted
+ * reason when the dir could not be read (still a clean body with empty children). A
+ * malformed/absent/non-local body degrades to {@link EMPTY_BROWSE} so the picker shows an honest
+ * empty/unavailable state (never a throw).
+ */
+export declare const BrowseBodySchema: z.ZodObject<{
+    path: z.ZodCatch<z.ZodString>;
+    root: z.ZodCatch<z.ZodString>;
+    parent: z.ZodCatch<z.ZodNullable<z.ZodString>>;
+    children: z.ZodCatch<z.ZodArray<z.ZodObject<{
+        name: z.ZodCatch<z.ZodString>;
+        path: z.ZodCatch<z.ZodString>;
+        isGitRepo: z.ZodCatch<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BrowseBodyWire = z.infer<typeof BrowseBodySchema>;
+/** The honest empty browse body the picker shows when the daemon is unreachable / local-mode is off (b-AC-5). */
+export declare const EMPTY_BROWSE: BrowseBodyWire;
+/**
+ * The `POST /api/diagnostics/projects/bind` (+ `/bind-existing`) ack (059b/059d): the recorded
+ * absolute path + the project it bound to. `bound` is false on a rejected bind (the reserved inbox,
+ * a degenerate name, a non-absolute path), with a redacted `error`. A malformed/failed body degrades
+ * to a not-bound ack so the caller surfaces an honest failure (never a throw).
+ */
+export declare const BindAckSchema: z.ZodObject<{
+    bound: z.ZodCatch<z.ZodBoolean>;
+    path: z.ZodCatch<z.ZodString>;
+    projectId: z.ZodCatch<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BindAckWire = z.infer<typeof BindAckSchema>;
+/** The honest "bind failed" ack the picker shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_BIND_ACK: BindAckWire;
+/** The `POST /api/diagnostics/projects/unbind` ack (059c): whether a LOCAL binding was removed. */
+export declare const UnbindAckSchema: z.ZodObject<{
+    unbound: z.ZodCatch<z.ZodBoolean>;
+    path: z.ZodCatch<z.ZodString>;
+}, z.core.$strip>;
+export type UnbindAckWire = z.infer<typeof UnbindAckSchema>;
+/** The honest "unbind failed" ack the page shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_UNBIND_ACK: UnbindAckWire;
+/**
+ * The `POST /api/diagnostics/scope/org-switch` ack (122-AC-2): the now-active org + whether a token
+ * re-mint ran. `switched:false` with a redacted `error` on a failed switch (no credential / unknown
+ * org / re-mint error). `reminted` is true when a fresh org-bound token was minted (the org changed).
+ * NO token in the body by construction.
+ */
+export declare const OrgSwitchAckSchema: z.ZodObject<{
+    switched: z.ZodCatch<z.ZodBoolean>;
+    org: z.ZodCatch<z.ZodString>;
+    orgName: z.ZodOptional<z.ZodString>;
+    reminted: z.ZodCatch<z.ZodBoolean>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OrgSwitchAckWire = z.infer<typeof OrgSwitchAckSchema>;
+/** The honest "org switch failed" ack the switcher shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_ORG_SWITCH_ACK: OrgSwitchAckWire;
+/** The `POST /api/diagnostics/scope/workspace-switch` ack (IRD-122): the now-active workspace (no re-mint). */
+export declare const WorkspaceSwitchAckSchema: z.ZodObject<{
+    switched: z.ZodCatch<z.ZodBoolean>;
+    workspace: z.ZodCatch<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkspaceSwitchAckWire = z.infer<typeof WorkspaceSwitchAckSchema>;
+/** The honest "workspace switch failed" ack the switcher shows on a non-2xx / network failure (never a throw). */
+export declare const FAILED_WORKSPACE_SWITCH_ACK: WorkspaceSwitchAckWire;
+/**
+ * The non-tenant SESSION headers every dashboard request stamps (PRD-024 Wave 3).
+ *
+ * The `/api/memories` group sits behind the runtime-path + session middleware
+ * (`src/daemon/runtime/middleware/runtime-path.ts`), which REQUIRES
+ * `x-honeycomb-runtime-path: plugin|legacy` AND a non-empty `x-honeycomb-session`. The
+ * dashboard web app is a legitimate loopback thin client — exactly like the CLI/SDK/MCP, which
+ * stamp these — so it must send them too. They carry NO tenant identity (no org GUID) and NO
+ * credential (D-4), so they are safe to stamp client-side; the org comes from the daemon's
+ * LOCAL default scope (the daemon-side Fix A). We deliberately do NOT send `x-honeycomb-org`:
+ * sending a wrong/empty org would trip the cross-tenant guard.
+ *
+ * The session id is a FIXED, clearly-labeled loopback viewer id ("dashboard-web"): a single
+ * long-lived viewer that idempotently re-claims its OWN session (the claim map is per-session),
+ * never conflicting with a harness which uses real session ids. A fixed id keeps the bundle
+ * deterministic and the contract testable (no `Math.random`/`Date.now`).
+ */
+export declare const DASHBOARD_SESSION_HEADERS: Readonly<{
+    readonly "x-honeycomb-runtime-path": "plugin";
+    readonly "x-honeycomb-session": "dashboard-web";
+}>;
+/** The injectable fetch surface (the global in prod; a mock in unit tests). */
+export type FetchLike = typeof fetch;
+/** Construction options for {@link createWireClient}. */
+export interface WireClientOptions {
+    /** The daemon origin the app talks to (defaults to same-origin, i.e. empty prefix). */
+    readonly origin?: string;
+    /** The fetch implementation (defaults to the global `fetch`). */
+    readonly fetchImpl?: FetchLike;
+}
+/** The max characters a recalled snippet renders before it is truncated with an ellipsis. */
+export declare const MAX_SNIPPET_CHARS = 280;
+/**
+ * Format a recall hit's matched `text` into the snippet the {@link MemoryCard} renders. A raw
+ * `session` dump (the JSONB capture turn) is collapsed to one readable line via
+ * {@link humanizeSessionTurn} so the card never shows escaped JSON; a distilled `memory` fact
+ * passes through as prose. EITHER way the result is whitespace-collapsed and capped at
+ * {@link MAX_SNIPPET_CHARS} so a long row can never blow out the card. Exported so a test can
+ * drive it deterministically (mirrors {@link formatLogLine}).
+ */
+export declare function formatRecallSnippet(text: string, kind: "memory" | "session"): string;
+/**
+ * The dashboard web client. Each method hits one already-served endpoint, validates the
+ * payload with zod, and returns a typed value (or a safe empty/zero state). The whole
+ * surface is loopback `fetch` — no DeepLake, no secret, no token (D-4): the app reads only
+ * what the daemon chooses to serve.
+ */
+export interface WireClient {
+    /** The KPI band. PRD-049e: pass the selected project to re-scope the project-bearing counts
+     *  (Memories / Turns / Est. savings); omit it for the workspace-wide view. Team skills is always
+     *  workspace-wide (it has no project segment). */
+    kpis(projectId?: string): Promise<KpisWire>;
+    sessions(): Promise<SessionRowWire[]>;
+    settings(): Promise<SettingsWire>;
+    rules(): Promise<RuleRowWire[]>;
+    skills(): Promise<SkillRowWire[]>;
+    /**
+     * PRD-049e — read the codebase-graph view (`GET /api/graph`). `projectId` (when set) stamps the
+     * selected-project header so the read re-scopes on the dashboard's scope change (49e-AC-2); the
+     * page passes the active `useScope().scope.project`, so a switch re-fetches the graph for the new
+     * project rather than showing the prior scope's cached data.
+     */
+    graph(projectId?: string): Promise<GraphWire>;
+    /**
+     * PRD-041b — read the MEMORY-GRAPH view-model (`GET /api/diagnostics/memory-graph`). Returns the
+     * SAME `GraphWire` shape as {@link graph} (the memory graph is a `GraphView`-shaped source), so the
+     * page feeds it to the SAME `GraphCanvas`. A malformed/absent body — or a `built:false` empty graph
+     * while PRD-008 data is unpopulated — degrades to {@link EMPTY_GRAPH} so the page renders its honest
+     * "no memory graph yet" empty state, never a throw. Validated through the shared `GraphSchema`.
+     */
+    memoryGraph(projectId?: string): Promise<GraphWire>;
+    /**
+     * PRD-060e — read the composite ROI view-model (`GET /api/diagnostics/roi`). Returns the
+     * full {@link RoiViewWire} the page renders as a PURE function (savings/infra/pollination/net
+     * + the org/team/agent/project rollups + the per-user availability flag + `cost_basis`). All
+     * money is INTEGER cents. A malformed/absent/failed body degrades to {@link EMPTY_ROI_VIEW}
+     * (every section `absent`, net NOT computed) so the page renders its honest empty state — a
+     * DASH glyph, never `$0.00` — rather than throwing (e-AC-2/e-AC-5). `projectId` (when set)
+     * stamps the selected-project header so the read re-scopes on a dashboard scope change.
+     */
+    roi(projectId?: string): Promise<RoiView>;
+    /**
+     * PRD-060e — read the ROI trend series (`GET /api/diagnostics/roi/trend`) backing the
+     * inline-SVG chart (e-AC-10, dashed=modeled / solid=measured). All money is INTEGER cents. A
+     * malformed/absent/failed body — or a genuine no-history-yet state — degrades to
+     * {@link EMPTY_ROI_TREND} so the chart renders its honest empty state, never a throw.
+     */
+    roiTrend(range: string, projectId?: string): Promise<RoiTrendView>;
+    recall(query: string, projectId?: string): Promise<{
+        memories: RecalledMemory[];
+        degraded: boolean;
+    }>;
+    /**
+     * PRD-040a — list the scoped tenant's memories (`GET /api/memories`, newest-first). `limit`
+     * bumps for "load more" (the daemon clamps to `MAX_LIST_LIMIT` 500). A malformed/absent body
+     * degrades to `[]` (the page renders its honest empty state). Stamps the session headers.
+     */
+    listMemories(limit?: number, projectId?: string): Promise<MemoryRecordWire[]>;
+    /**
+     * PRD-040a — read one memory by id (`GET /api/memories/:id`). Returns `null` on a 404 (the id is
+     * unknown OR forgotten → the page renders "this memory was forgotten") or any failure.
+     */
+    getMemory(id: string): Promise<MemoryRecordWire | null>;
+    /**
+     * PRD-040b — add a memory (`POST /api/memories`, store). Returns the `{ id, action }` ack, or
+     * `null` on a non-2xx / network failure (the caller surfaces "save failed" and re-reads). The
+     * page never optimistically renders the input — it re-lists after the ack.
+     */
+    addMemory(input: {
+        content: string;
+        type?: string;
+        agentId?: string;
+    }): Promise<StoreAckWire | null>;
+    /**
+     * PRD-040b — edit a memory (`POST /api/memories/:id/modify`, version-bumped + reason-gated).
+     * The `reason` is REQUIRED (the daemon rejects an empty one). Returns the `{ id, action,
+     * audited }` ack, or `null` on a non-2xx / network failure (the caller re-reads the unchanged
+     * persisted value). NEVER a hard-update — the daemon appends a new version.
+     */
+    modifyMemory(id: string, input: {
+        content: string;
+        reason: string;
+        agentId?: string;
+    }): Promise<WriteAckWire | null>;
+    /**
+     * PRD-040b — forget a memory (`POST /api/memories/:id/forget`, reason-gated soft-delete → a
+     * tombstone version). Returns the ack, or `null` on failure. The page gates this behind a confirm.
+     */
+    forgetMemory(id: string, input: {
+        reason: string;
+    }): Promise<WriteAckWire | null>;
+    /**
+     * PRD-040c — trigger version-history compaction (`POST /api/diagnostics/compact`). The optional
+     * `table` selects ONE allow-listed table (omitted ⇒ all). Returns the per-table summary, or
+     * `null` on failure ("compaction unavailable"). The page sends only a KNOWN table name or none —
+     * the daemon matches it against the allow-list, so no attacker-controlled identifier rides this.
+     */
+    compact(table?: string): Promise<CompactSummaryWire | null>;
+    /**
+     * PRD-058d — list the scoped conflict queue (`GET /api/memories/conflicts?status=open`). A
+     * malformed/absent body degrades to `[]` (the panel renders its honest empty state). Scope is
+     * resolved daemon-side from the session — the read is scope-filtered before any content.
+     */
+    lifecycleConflicts(status?: string): Promise<LifecycleConflictWire[]>;
+    /**
+     * PRD-058d — resolve a conflict through the SAME 058b endpoint the CLI uses
+     * (`POST /api/memories/conflicts/:id/resolve`). NO new write path — the daemon applies the κ
+     * assignment, the append-only supersession, the audit append, and the poll-to-convergence
+     * read-back. Returns `true` iff the daemon accepted (2xx); the caller re-reads + polls to
+     * convergence, never an optimistic flip.
+     */
+    resolveConflict(id: string, input: {
+        verdict: string;
+        winnerId?: string;
+        reason?: string;
+    }): Promise<boolean>;
+    /** PRD-058d — list the scoped memories with `ref_status='stale'` + their unresolved refs. Degrades to `[]`. */
+    lifecycleStaleRefs(): Promise<LifecycleStaleRefWire[]>;
+    /** PRD-058d — read the lifecycle-filtered audit (`GET /api/memories/history?type=lifecycle`). Degrades to `[]`. */
+    lifecycleHistory(): Promise<LifecycleHistoryWire[]>;
+    /**
+     * PRD-058d / 058e — read the calibration introspection (`GET /api/memories/calibration`): ECE,
+     * Brier, n_samples, and the reliability-diagram payload. A malformed/absent/cold-start body
+     * degrades to {@link EMPTY_CALIBRATION} (the panel shows "calibration dormant"), never a throw.
+     */
+    calibration(): Promise<CalibrationWire>;
+    logs(limit?: number): Promise<LogRecordWire[]>;
+    /**
+     * PRD-042c / PRD-021d — FOLLOW the `/api/logs/stream` SSE tail (c-AC-2). Subscribes a browser
+     * `EventSource` to the daemon's already-mounted log stream, parsing each `event: "log"` record
+     * through {@link LogRecordSchema} and handing the validated record to `onRecord`. Returns an
+     * unsubscribe function the caller MUST call on unmount (it closes the EventSource). The activity
+     * feed BACKFILLS via {@link logs} first, then follows this tail — no client poll.
+     *
+     * DEGRADES SAFELY: in a non-browser env (jsdom test, SSR) where `EventSource` is unavailable, this
+     * is a no-op that returns an inert unsubscribe — the caller keeps its snapshot and never crashes
+     * (the SSE-record handling is exercised by injecting the parser directly in tests). No record
+     * carries a secret by construction (logger.ts); this introduces none.
+     */
+    logsStream(onRecord: (record: LogRecordWire) => void): () => void;
+    /**
+     * PRD-043a/043b — read the DURABLE, filterable, paginated request-log history
+     * (`GET /api/logs/history`, newest first). Reuses the SAME secret-free `LogRecordWire` shape as
+     * {@link logs}, so the history table and the live tail share one row renderer. A malformed/absent
+     * body degrades to an empty page (`{ records: [], nextCursor: null, persistent: false }`) so the
+     * page renders its honest empty/unavailable state, never a throw. `filters` map 1:1 to the
+     * daemon's validated query params; an undefined filter is simply omitted.
+     */
+    logsHistory(filters?: LogsHistoryFilters): Promise<LogsHistoryWire>;
+    /**
+     * PRD-043c — read the browsable captured-TURNS history (`GET /api/diagnostics/sessions`, paged,
+     * newest first). Returns the turn rows + a `nextCursor` for the next older page. Labeled "Turns"
+     * on the page (PRD-035a); the storage table stays `sessions`. A malformed/absent body degrades to
+     * an empty page so the page renders its honest empty state, never a throw. The daemon reads turns
+     * from DeepLake (eventual consistency) — a freshly captured turn may appear one refresh later.
+     */
+    turnsHistory(opts?: {
+        limit?: number;
+        cursor?: string;
+    }): Promise<TurnsHistoryWire>;
+    /**
+     * PRD-039a — read the harness registry + last-seen telemetry (the data backbone). Returns the
+     * six canonical `HarnessStatus` rows the Harnesses page (039b/039c) renders; a failure degrades
+     * to an empty list (the page shows its honest empty/zero state, never a throw). No second source —
+     * this is the SINGLE backbone (parent D-3).
+     */
+    harnesses(): Promise<HarnessStatusWire[]>;
+    /**
+     * PRD-042 — read the Sync page `installed ∪ synced` union view-model (`GET /api/diagnostics/assets`):
+     * skills + agents, each with its honest state + presentation-safe detail. A malformed/absent body
+     * degrades to {@link EMPTY_ASSET_SYNC_VIEW} (the page renders its honest empty state, never a throw).
+     */
+    assetsView(): Promise<AssetSyncViewWire>;
+    /**
+     * PRD-042 — run one Sync action (`POST /api/diagnostics/sync/{action}`). The daemon performs the REAL
+     * pipeline (publish/pull/tombstone/install-toggle) and returns the CONVERGED result (poll-convergent
+     * read-back). Returns the ack, or `null` on a non-2xx / network failure (the page re-reads the union
+     * and reflects whatever actually persisted — never an optimistic flip). `input` carries the asset
+     * kind + name (+ optional native/honeycombId for promote/pull/demote).
+     */
+    syncAction(action: "promote" | "pull" | "demote" | "enable" | "disable", input: {
+        assetType: "skill" | "agent";
+        name: string;
+        native?: string;
+        honeycombId?: string;
+        harness?: string;
+    }): Promise<SyncActionResultWire | null>;
+    health(): Promise<HealthProbe>;
+    pollinate(): Promise<PollinateAck>;
+    /**
+     * PRD-041a — trigger the codebase-graph BUILD (`POST /api/graph/build`). The daemon runs the REAL
+     * worker end-to-end (discover → tree-sitter extract → aggregate → finalize) and writes the LOCAL
+     * snapshot, then returns the build ack `{ built, nodeCount, edgeCount, fileCount }` (the rest of the
+     * body is ignored). After a `{ built: true }` ack the caller re-runs {@link graph} to render the
+     * fresh snapshot immediately (it is a LOCAL file — no eventual-consistency poll needed). Stamps the
+     * session headers exactly like {@link pollinate}. Uses a GENEROUS timeout ({@link BUILD_GRAPH_TIMEOUT_MS})
+     * — the build is slow (whole-repo tree-sitter parse). Degrades to {@link FAILED_BUILD_GRAPH_ACK} on any
+     * non-2xx / timeout / network / malformed-body failure — NEVER throws into React (the page shows an
+     * honest inline error + keeps the CLI hint).
+     */
+    buildGraph(): Promise<BuildGraphAck>;
+    /** PRD-032c — read the vault `setting` class + the provider→model catalog (`GET /api/settings`). */
+    vaultSettings(): Promise<VaultSettingsWire>;
+    /**
+     * PRD-032c — write one `setting`-class record through the daemon (`POST /api/settings/:key`).
+     * Returns `true` iff the daemon accepted the write (2xx); the caller re-reads to reflect the
+     * PERSISTED value (it never trusts a local-only toggle). The panel NEVER opens the vault
+     * directly — every write goes through this loopback endpoint (PRD-020b posture).
+     */
+    setSetting(key: string, value: SettingValueWire): Promise<boolean>;
+    /**
+     * PRD-032c — read the names-only secret list (`GET /api/secrets`) for provider-key PRESENCE
+     * ("set ✓" / "not set") ONLY. There is no value-returning route; this returns NAMES, never a
+     * value (D-4 / AC-5).
+     */
+    secretNames(): Promise<string[]>;
+    /**
+     * PRD-044b — WRITE-ONLY store a provider key (`POST /api/secrets/:name` with a `{ value }`
+     * body). Returns `true` iff the daemon accepted the write (2xx); any non-2xx (400 invalid
+     * name/value, 502 store failure) reads as "not accepted". The value is sent in the body and
+     * NEVER echoed back (the daemon's 201 carries the NAME only). The caller RE-READS
+     * {@link secretNames} on success so the presence badge reflects the persisted truth — mirroring
+     * the `setSetting` re-read pattern. THERE IS NO `getSecret` METHOD, and none is ever added: a
+     * stored key cannot be read back through any wire method (the load-bearing AC-3 invariant).
+     */
+    setSecret(name: string, value: string): Promise<boolean>;
+    /**
+     * Dashboard actions — log out of DeepLake (`POST /api/actions/logout`): remove the shared
+     * credential so the user can re-authenticate from the dashboard. Returns `true` iff the daemon
+     * accepted (2xx + `{ ok: true }`); a non-2xx / network failure reads as `false`. The caller
+     * re-reads {@link authStatus} so the section flips to disconnected on success.
+     */
+    logout(): Promise<boolean>;
+    /**
+     * Dashboard actions — turn embeddings on/off (`POST /api/actions/embeddings` with `{ enabled }`).
+     * The daemon actuates the embed supervisor LIVE (spawn+warm / stop) AND persists the choice so it
+     * survives a restart. Returns `true` iff accepted (2xx + echoed `enabled` matches the request);
+     * the caller reflects the requested state on success and re-reads {@link health} for the live truth.
+     */
+    setEmbeddings(enabled: boolean): Promise<boolean>;
+    /**
+     * Dashboard actions — restart the daemon (`POST /api/actions/restart`). The daemon spawns a
+     * detached respawn helper, then gracefully shuts down; a fresh daemon comes back on the same port.
+     * Returns `true` iff the restart was acknowledged (2xx + `{ restarting: true }`); the caller then
+     * shows "restarting…" and polls {@link health} until the new daemon answers. Degrades to `false`.
+     */
+    restartDaemon(): Promise<boolean>;
+    /**
+     * Dashboard actions — uninstall (`POST /api/actions/uninstall`). Returns the guided removal: the
+     * detected harnesses + the exact CLI command that fully reverses Honeycomb's footprint (v1 does not
+     * perform the destructive hook removal from the daemon serving this page — see `actions-api.ts`).
+     * A non-2xx / network failure degrades to `null` (the page surfaces an honest error). No secret rides it.
+     */
+    uninstall(): Promise<UninstallResultWire | null>;
+    /**
+     * PRD-044a — read the REDACTED DeepLake auth STATUS (`GET /api/auth/status`). Returns the
+     * daemon's real connected identity (org/workspace/agent/source/savedAt + optional `expiresAt`)
+     * or an honest disconnected status. The body carries NO token (the schema has no token field
+     * by construction); a malformed/absent/failed read degrades to {@link DISCONNECTED_AUTH_STATUS}
+     * (never a throw into React — AC-4). Re-callable on focus/poll so a CLI `honeycomb login`
+     * reflects here.
+     */
+    authStatus(): Promise<AuthStatusWire>;
+    /**
+     * PRD-050b — read the pre-auth guided-setup STATE (`GET /setup/state`). Returns credential-dir
+     * presence + the onboarding phase/prior-tool + the DERIVED `authenticated` bit + the embeddings
+     * warmup signal. Drives the fresh-install vs already-linked render (b-AC-6) and the live
+     * pre-auth→authenticated transition the shell polls for (b-AC-3). A malformed/absent/failed read,
+     * or a non-local 404, degrades to {@link FRESH_SETUP_STATE} (the guided-setup state) — never a
+     * throw into React. The body carries NO token/secret (install metadata only).
+     */
+    setupState(): Promise<SetupStateWire>;
+    /**
+     * PRD-050c (the 050b "First time setup" button handler) — BEGIN the on-page device-flow login
+     * (`POST /setup/login`). Returns the `user_code` + verification URIs to display on the page (the
+     * daemon keeps polling → mint → persist in the background); the shell then polls {@link setupState}
+     * and flips to the authenticated view when the credential lands (b-AC-3). Returns `null` on a
+     * non-2xx (the 502 device-flow-unavailable) / network failure so the button shows an honest error.
+     * The response carries NO token (the schema has no token field by construction — c-AC-4).
+     */
+    setupLogin(): Promise<SetupLoginWire | null>;
+    /**
+     * PRD-050d — "Proceed with Honeycomb": run the Hivemind→Honeycomb migration (`POST
+     * /setup/migrate-from-hivemind`). The daemon backs up + uninstalls Hivemind idempotently, then
+     * verify-and-adopts the shared credential (d-AC-4) or returns `needsLogin:true` (the page then runs
+     * {@link setupLogin}). The response carries the terminal phase + a plain-language message + the
+     * backup path (NO token). Degrades to {@link FAILED_SETUP_MIGRATE} on a non-2xx / network failure so
+     * the wizard shows an honest, recoverable error (never a throw).
+     */
+    migrateFromHivemind(): Promise<SetupMigrateWire>;
+    /**
+     * PRD-050d (d-AC-7) — "Roll back": restore the pre-migration Hivemind backup (`POST
+     * /setup/migrate-from-hivemind/rollback`). Offered when `/setup/state` reports a NON-TERMINAL
+     * `migration.phase` (an interrupted migration). Degrades to {@link FAILED_SETUP_MIGRATE_ROLLBACK} on
+     * a non-2xx / network failure (never a throw).
+     */
+    rollbackMigration(): Promise<SetupMigrateRollbackWire>;
+    /**
+     * PRD-049e (49e-AC-1) — list the orgs the user has access to (`GET /api/diagnostics/scope/orgs`).
+     * Privilege-scoped by the daemon's token (`GET /organizations`); nothing the user lacks access to
+     * appears. A failed/absent/non-local (404) read degrades to `[]` (the switcher shows an empty
+     * state), never a throw. No token rides the body.
+     */
+    scopeOrgs(): Promise<ScopeOrgWire[]>;
+    /**
+     * PRD-049e (49e-AC-1 / 49e-AC-3) — list a given org's workspaces
+     * (`GET /api/diagnostics/scope/workspaces?org=<id>`). When `org` differs from the daemon's
+     * credential org, the daemon RE-MINTS the org-bound token (PRD-011) BEFORE enumerating. Returns the
+     * full body (`{ workspaces, org, reminted }`) so the caller can observe the re-mint. A failed/absent
+     * read degrades to an empty workspace list, never a throw.
+     */
+    scopeWorkspaces(org?: string): Promise<ScopeWorkspacesWire>;
+    /**
+     * PRD-049e (49e-AC-1) / PRD-059d — list the workspace's registry projects
+     * (`GET /api/diagnostics/scope/projects`), the daemon-synced 049a `projects.json` copy (incl. the
+     * `__unsorted__` inbox + each project's `boundLocally` bit). `opts.unbound` stamps `?unbound=1` to
+     * filter to the IMPORTABLE set (registry-only, no local binding on this device — the 059d import
+     * list); omitted ⇒ the full list (the Projects page splits active vs importable on `boundLocally`).
+     * A failed/absent read degrades to `[]`, never a throw.
+     */
+    scopeProjects(opts?: {
+        unbound?: boolean;
+    }): Promise<ScopeProjectWire[]>;
+    /**
+     * PRD-059b — browse a directory's immediate child DIRECTORIES (`GET /api/diagnostics/fs/browse`).
+     * The daemon serves the dirs-only tree (a browser cannot return an absolute path), each child marked
+     * if it is a git repo, clamped to an allowed root (home by default). `path` (when set) browses that
+     * dir; omitted ⇒ the root. A failed/absent/non-local (404) read degrades to {@link EMPTY_BROWSE} so
+     * the picker shows its honest empty/unavailable state (the CLI fallback — b-AC-5), never a throw.
+     */
+    fsBrowse(path?: string): Promise<BrowseBodyWire>;
+    /**
+     * PRD-059b — bind a chosen ABSOLUTE folder to a NEW/named project (`POST /api/diagnostics/projects/bind`).
+     * `name` (when set) is the explicit project name; omitted ⇒ the daemon's CLI-identical suggestion
+     * (git remote repo, else basename). Returns the `{ bound, path, projectId, error? }` ack; degrades
+     * to {@link FAILED_BIND_ACK} on a non-2xx / network failure so the caller surfaces an honest error.
+     */
+    bindProject(input: {
+        path: string;
+        name?: string;
+    }): Promise<BindAckWire>;
+    /**
+     * PRD-059d — bind a chosen ABSOLUTE folder to an EXISTING registry project_id
+     * (`POST /api/diagnostics/projects/bind-existing`) — the cross-device import. Returns the bind ack;
+     * degrades to {@link FAILED_BIND_ACK} on failure. The existing project keeps its registry remote.
+     */
+    bindExistingProject(input: {
+        path: string;
+        projectId: string;
+    }): Promise<BindAckWire>;
+    /**
+     * PRD-059c — remove the LOCAL folder binding for `path` (`POST /api/diagnostics/projects/unbind`).
+     * Capture stops for that folder; the registry project + its existing data are UNTOUCHED. Returns the
+     * `{ unbound, path }` ack; degrades to {@link FAILED_UNBIND_ACK} on a non-2xx / network failure.
+     */
+    unbindProject(input: {
+        path: string;
+    }): Promise<UnbindAckWire>;
+    /**
+     * IRD-122 (122-AC-1/122-AC-2) — persist an ORG switch (`POST /api/diagnostics/scope/org-switch`).
+     * The daemon re-mints a fresh org-bound token (PRD-011) and saves it + the org to the shared
+     * credential — the SAME mechanic as `honeycomb org switch`, so `whoami` reflects it immediately. The
+     * ack carries the now-active org + `reminted` (NO token). Degrades to {@link FAILED_ORG_SWITCH_ACK}
+     * on a non-2xx / network failure so the switcher surfaces an honest "could not switch" (never a no-op).
+     */
+    switchOrg(org: string): Promise<OrgSwitchAckWire>;
+    /**
+     * IRD-122 — persist a WORKSPACE switch (`POST /api/diagnostics/scope/workspace-switch`). Writes only
+     * the shared credential's workspace id (NO re-mint — the workspace resolves server-side), exactly as
+     * `honeycomb workspace switch` does. Degrades to {@link FAILED_WORKSPACE_SWITCH_ACK} on failure.
+     */
+    switchWorkspace(workspace: string): Promise<WorkspaceSwitchAckWire>;
+}
+/** The empty/zero KPIs the UI shows before the first load resolves (or on failure). */
+export declare const EMPTY_KPIS: KpisWire;
+/** The empty settings the header shows before the first load resolves. */
+export declare const EMPTY_SETTINGS: SettingsWire;
+/** The empty graph (renders the kit's "no graph built" empty-state). */
+export declare const EMPTY_GRAPH: GraphWire;
+/**
+ * The client-side render cap (the graph memory cap — memory-aware). The daemon already bounds the
+ * codebase graph (`GET /api/graph` ships ≤ ~750 nodes), but this is the shared defense-in-depth backstop
+ * so NO consumer mounts an unbounded number of SVG node groups, whatever the source (a large memory
+ * graph, an older uncapped daemon, a future endpoint). Set above the daemon budget so the daemon's cap
+ * normally governs and this only catches outliers. Single source for both the full Graph page and the
+ * mini-widget so the policy can never drift between them.
+ */
+export declare const MAX_RENDER_NODES = 1500;
+/**
+ * The companion EDGE cap. Nodes are `<g>` groups but edges are `<line>` elements — a dense graph under
+ * the node cap can still carry hundreds of thousands of edges and lock up layout/SVG. So the helper
+ * bounds edges too. Sized so nodes+edges together stay a few thousand SVG elements (well within budget).
+ */
+export declare const MAX_RENDER_EDGES = 5000;
+/**
+ * Bound a graph to {@link MAX_RENDER_NODES}-ish nodes AND {@link MAX_RENDER_EDGES} edges for rendering
+ * (the shared cap helper). Within BOTH limits → returned unchanged (same ref, so a memoized layout is
+ * not invalidated). Over EITHER → the first `limit` nodes plus at most `MAX_RENDER_EDGES` of the edges
+ * whose both endpoints survive, with `capped:true`. Capping edges as well as nodes is what makes this a
+ * real backstop: a dense graph (or an old uncapped daemon) can no longer flood the DOM with `<line>`s
+ * even when the node count is bounded. Pure — order is whatever the caller already settled (the daemon
+ * ships its bounded set importance-ranked, so "first N" here is already the meaningful head).
+ */
+export declare function capGraphForRender(graph: GraphWire, limit: number): {
+    graph: GraphWire;
+    capped: boolean;
+};
+/** The empty log-history page the table shows before the first load (or on failure / unavailable store). */
+export declare const EMPTY_LOGS_HISTORY: LogsHistoryWire;
+/** The empty turns-history page the Turns section shows before the first load (or on failure). */
+export declare const EMPTY_TURNS_HISTORY: TurnsHistoryWire;
+/**
+ * Build the `/api/logs/history` query string from the SET filters only (an undefined filter is
+ * omitted so the daemon applies its default). Every value is `encodeURIComponent`-escaped so a
+ * path/org/cursor with special characters is a safe single query value (never a query injection).
+ */
+export declare function buildHistoryQueryString(filters: LogsHistoryFilters): string;
+/**
+ * Build the typed wire client (AC-2..AC-6). The `origin` is prefixed onto every path so the
+ * same app works same-origin (served by the host) or against an explicit daemon URL; the
+ * `fetchImpl` is injected so a unit test drives the app with a mocked fetch and no live
+ * network (the test contract). No method ever throws — every failure degrades to an empty
+ * value so the UI shows an honest empty state instead of crashing.
+ */
+export declare function createWireClient(options?: WireClientOptions): WireClient;
+/**
+ * PRD-042c — parse one SSE `event: "log"` frame's `data` payload (a JSON-stringified
+ * {@link RequestLogRecord}) into a validated {@link LogRecordWire}, or `null` on any malformed /
+ * non-JSON / shape-mismatch frame. Validated through the SAME {@link LogRecordSchema} the snapshot
+ * uses, so the SSE tail and the backfill agree on the shape and a bad frame is DROPPED (never thrown
+ * into React). Exported so the page can drive the follow-handler deterministically in tests without a
+ * live EventSource. No secret rides a record by construction (logger.ts).
+ */
+export declare function parseLogRecordEvent(data: unknown): LogRecordWire | null;
+/**
+ * Format one `/api/logs` record into a single mono log line for the LiveLog panel. The
+ * record carries NO token/secret/header (the logger redacts by construction); this
+ * formatter introduces none either — it renders only time + method + path + status (AC-4).
+ */
+export declare function formatLogLine(r: LogRecordWire): string;
+/**
+ * PRD-042c — the `/api/logs` path prefix the Sync activity feed filters on. The Sync action POSTs
+ * land on `/api/diagnostics/sync/{promote,pull,demote,enable,disable}`, and the daemon's
+ * request-logging middleware records EACH (method + path + status, no secret) into the same
+ * `/api/logs` ring buffer the feed reads. Filtering on this prefix yields exactly the sync events
+ * (publish/pull/tombstone), newest first, with no parallel event store (D-6).
+ */
+export declare const SYNC_ACTIVITY_PATH: "/api/diagnostics/sync/";
+/** True iff a `/api/logs` record is a Sync action event (its path is under {@link SYNC_ACTIVITY_PATH}). */
+export declare function isSyncActivityRecord(r: LogRecordWire): boolean;
+/**
+ * PRD-042c — the human action label for a Sync activity record's path (`promote` → "published",
+ * `pull` → "pulled", `demote` → "tombstoned"). The status code drives the success/failure flavor at
+ * the render site. No secret is in a record (logger.ts), so the formatted line is safe to render.
+ */
+export declare function syncActivityVerb(r: LogRecordWire): string;