ccqa 1.51.1 → 1.52.0

package/dist/hub-client/index.d.cts

@@ -0,0 +1,1376 @@
+import { z } from "zod";
+
+//#region src/hub/contract/schema.d.ts
+/**
+ * The hub's public REST contract (docs/hub-api.md). These schemas are
+ * consumed on both sides of the wire: the hub validates request/response
+ * bodies against them, and `ccqa/hub-client` re-exports them so any HTTP
+ * client — the ccqa CLI, an intranet web app, the hub's own bundled UI —
+ * gets the same types.
+ */
+/**
+ * A run's outcome. "running" is non-terminal/mutable — an opened run
+ * (`POST /runs/open`) sits in this state while it's patched incrementally.
+ * "passed"/"failed" are terminal/immutable: a pushed run (`POST /runs`)
+ * starts there directly, and an opened run ends there once done.
+ */
+declare const RunStatusSchema: z.ZodEnum<{
+  passed: "passed";
+  failed: "failed";
+  running: "running";
+}>;
+type RunStatus = z.infer<typeof RunStatusSchema>;
+/**
+ * A pushed run. All fields are derived server-side from the report the client
+ * pushed (`POST /runs`) — the run is immutable once created.
+ */
+declare const RunSchema: z.ZodObject<{
+  id: z.ZodString;
+  project: z.ZodString;
+  profile: z.ZodNullable<z.ZodString>;
+  branch: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    running: "running";
+  }>;
+  kind: z.ZodDefault<z.ZodEnum<{
+    run: "run";
+    drift: "drift";
+    record: "record";
+  }>>;
+  drift: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+    specs: z.ZodNumber;
+    testDrift: z.ZodNumber;
+    specChange: z.ZodNumber;
+    productBug: z.ZodDefault<z.ZodNumber>;
+    environment: z.ZodDefault<z.ZodNumber>;
+    unknown: z.ZodNumber;
+  }, z.core.$strip>>>;
+  gradedDrift: z.ZodOptional<z.ZodObject<{
+    specs: z.ZodNumber;
+    testDrift: z.ZodNumber;
+    specChange: z.ZodNumber;
+    productBug: z.ZodDefault<z.ZodNumber>;
+    environment: z.ZodDefault<z.ZodNumber>;
+    unknown: z.ZodNumber;
+    noDrift: z.ZodNumber;
+    graded: z.ZodNumber;
+  }, z.core.$strip>>;
+  specs: z.ZodObject<{
+    total: z.ZodNumber;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+  }, z.core.$strip>;
+  gitHead: z.ZodNullable<z.ZodString>;
+  promptVersion: z.ZodString;
+  costUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+  ciRunId: z.ZodNullable<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  reportCreatedAt: z.ZodString;
+  createdAt: z.ZodString;
+  deployedSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  deployedShaSource: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    "hub-deploy-log": "hub-deploy-log";
+    client: "client";
+  }>>>;
+  deployedShaAmbiguous: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type Run = z.infer<typeof RunSchema>;
+/**
+ * One failing spec's triage: the AI's prediction (read-only, sourced from
+ * the run's report) paired with the human-recorded actual cause (write-only
+ * from the client's perspective — the API is how it gets in).
+ */
+declare const TriageCaseSchema: z.ZodObject<{
+  feature: z.ZodString;
+  spec: z.ZodString;
+  target: z.ZodOptional<z.ZodString>;
+  predicted: z.ZodObject<{
+    label: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>;
+    confidence: z.ZodNumber;
+    subDiagnosis: z.ZodOptional<z.ZodString>;
+    headline: z.ZodString;
+  }, z.core.$strip>;
+  actual: z.ZodNullable<z.ZodObject<{
+    cause: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      NO_DRIFT: "NO_DRIFT";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+    recordedAt: z.ZodString;
+    invalidForKind: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type TriageCase = z.infer<typeof TriageCaseSchema>;
+declare const RunTriageSchema: z.ZodObject<{
+  runId: z.ZodString;
+  promptVersion: z.ZodString;
+  cases: z.ZodArray<z.ZodObject<{
+    feature: z.ZodString;
+    spec: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+    predicted: z.ZodObject<{
+      label: z.ZodEnum<{
+        TEST_DRIFT: "TEST_DRIFT";
+        SPEC_CHANGE: "SPEC_CHANGE";
+        PRODUCT_BUG: "PRODUCT_BUG";
+        ENVIRONMENT: "ENVIRONMENT";
+        UNKNOWN: "UNKNOWN";
+      }>;
+      confidence: z.ZodNumber;
+      subDiagnosis: z.ZodOptional<z.ZodString>;
+      headline: z.ZodString;
+    }, z.core.$strip>;
+    actual: z.ZodNullable<z.ZodObject<{
+      cause: z.ZodEnum<{
+        TEST_DRIFT: "TEST_DRIFT";
+        SPEC_CHANGE: "SPEC_CHANGE";
+        PRODUCT_BUG: "PRODUCT_BUG";
+        ENVIRONMENT: "ENVIRONMENT";
+        NO_DRIFT: "NO_DRIFT";
+      }>;
+      note: z.ZodOptional<z.ZodString>;
+      recordedAt: z.ZodString;
+      invalidForKind: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  recorded: z.ZodNumber;
+  recordedInvalidForKind: z.ZodNumber;
+  total: z.ZodNumber;
+}, z.core.$strip>;
+type RunTriage = z.infer<typeof RunTriageSchema>;
+declare const PutActualCauseRequestSchema: z.ZodObject<{
+  cause: z.ZodEnum<{
+    TEST_DRIFT: "TEST_DRIFT";
+    SPEC_CHANGE: "SPEC_CHANGE";
+    PRODUCT_BUG: "PRODUCT_BUG";
+    ENVIRONMENT: "ENVIRONMENT";
+    NO_DRIFT: "NO_DRIFT";
+  }>;
+  note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PutActualCauseRequest = z.infer<typeof PutActualCauseRequestSchema>;
+/** Response of `PUT /runs/:id/triage/actual-causes`. */
+declare const ImportActualCausesResponseSchema: z.ZodObject<{
+  imported: z.ZodNumber;
+  rejected: z.ZodArray<z.ZodObject<{
+    feature: z.ZodString;
+    spec: z.ZodString;
+    reason: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ImportActualCausesResponse = z.infer<typeof ImportActualCausesResponseSchema>;
+/**
+ * One spec's "last time it passed" record in the last-green ledger. The hub
+ * updates the ledger whenever a `kind: "run"` run reaches a terminal state:
+ * every spec that passed gets its entry advanced to that run's `gitHead`
+ * (newest `at` wins, so out-of-order finalizes can't move a baseline
+ * backwards). `ccqa run --on-fail-explain` reads it to diff each
+ * failing spec against the commit where that spec was last green.
+ */
+declare const LastGreenEntrySchema: z.ZodObject<{
+  gitHead: z.ZodString;
+  runId: z.ZodString;
+  at: z.ZodString;
+}, z.core.$strip>;
+type LastGreenEntry = z.infer<typeof LastGreenEntrySchema>;
+/** One deploy, as the consumer's deploy job reported it (ADR-0010). */
+declare const DeployEntrySchema: z.ZodObject<{
+  index: z.ZodNumber;
+  sha: z.ZodString;
+  previousSha: z.ZodNullable<z.ZodString>;
+  at: z.ZodString;
+  ref: z.ZodOptional<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodString>;
+  changedPaths: z.ZodNullable<z.ZodArray<z.ZodString>>;
+  hasSelection: z.ZodDefault<z.ZodBoolean>;
+  gapBefore: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type DeployEntry = z.infer<typeof DeployEntrySchema>;
+/** Body of `POST /projects/:project/locks?profile=`. */
+declare const AcquireLocksRequestSchema: z.ZodObject<{
+  specs: z.ZodArray<z.ZodString>;
+  kind: z.ZodEnum<{
+    run: "run";
+    audit: "audit";
+  }>;
+  holder: z.ZodString;
+  ttlSeconds: z.ZodNumber;
+}, z.core.$strip>;
+type AcquireLocksRequest = z.infer<typeof AcquireLocksRequestSchema>;
+/**
+ * Which specs the caller may work on. `denied` is not an error: another job got
+ * there first, and skipping those is the whole point.
+ */
+declare const AcquireLocksResponseSchema: z.ZodObject<{
+  granted: z.ZodArray<z.ZodString>;
+  denied: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type AcquireLocksResponse = z.infer<typeof AcquireLocksResponseSchema>;
+/** Answer of PUT (the attestation as stamped) and GET (the whole document). */
+declare const AttestationResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  profile: z.ZodString;
+  spec: z.ZodString;
+  attestation: z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    deployedSha: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type AttestationResponse = z.infer<typeof AttestationResponseSchema>;
+declare const AttestationsResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  profile: z.ZodString;
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+    deployedSha: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AttestationsResponse = z.infer<typeof AttestationsResponseSchema>;
+declare const AuditDismissalResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  spec: z.ZodString;
+  dismissal: z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodString;
+    auditRunId: z.ZodString;
+    label: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>;
+    headline: z.ZodString;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type AuditDismissalResponse = z.infer<typeof AuditDismissalResponseSchema>;
+declare const AuditDismissalsResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    by: z.ZodString;
+    at: z.ZodString;
+    note: z.ZodString;
+    auditRunId: z.ZodString;
+    label: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>;
+    headline: z.ZodString;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AuditDismissalsResponse = z.infer<typeof AuditDismissalsResponseSchema>;
+/** Body of `GET /projects/:project/audit-needed?profile=`: one answer per spec. */
+declare const AuditNeedReportSchema: z.ZodObject<{
+  project: z.ZodString;
+  profile: z.ZodString;
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    because: z.ZodEnum<{
+      deployReached: "deployReached";
+      neverAudited: "neverAudited";
+      cannotTell: "cannotTell";
+      held: "held";
+      current: "current";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+      noSelectionInRange: "noSelectionInRange";
+      selectionUnknown: "selectionUnknown";
+      noDeployLog: "noDeployLog";
+      unknownDeployedSha: "unknownDeployedSha";
+      ambiguousDeployedSha: "ambiguousDeployedSha";
+      deployedShaNotInLog: "deployedShaNotInLog";
+      gapInRange: "gapInRange";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AuditNeedReport = z.infer<typeof AuditNeedReportSchema>;
+/** Body of `GET /projects/:project/rerun?profile=`: one verdict per spec in the perspectives document. */
+declare const RerunReportSchema: z.ZodObject<{
+  project: z.ZodString;
+  profile: z.ZodString;
+  deployHead: z.ZodNullable<z.ZodObject<{
+    index: z.ZodNumber;
+    sha: z.ZodString;
+    at: z.ZodString;
+  }, z.core.$strip>>;
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    verdict: z.ZodEnum<{
+      inProgress: "inProgress";
+      needsRepair: "needsRepair";
+      rerunNeeded: "rerunNeeded";
+      verified: "verified";
+      manuallyVerified: "manuallyVerified";
+    }>;
+    audit: z.ZodEnum<{
+      due: "due";
+      clean: "clean";
+      drifted: "drifted";
+      undecided: "undecided";
+    }>;
+    execution: z.ZodEnum<{
+      passed: "passed";
+      failed: "failed";
+      stale: "stale";
+      neverRun: "neverRun";
+    }>;
+    driftLabel: z.ZodOptional<z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+    }>>;
+    auditAssumedReached: z.ZodOptional<z.ZodEnum<{
+      noSelectionInRange: "noSelectionInRange";
+      selectionUnknown: "selectionUnknown";
+      noDeployLog: "noDeployLog";
+      unknownDeployedSha: "unknownDeployedSha";
+      ambiguousDeployedSha: "ambiguousDeployedSha";
+      deployedShaNotInLog: "deployedShaNotInLog";
+      gapInRange: "gapInRange";
+    }>>;
+    auditDismissed: z.ZodOptional<z.ZodObject<{
+      by: z.ZodString;
+      at: z.ZodString;
+      note: z.ZodString;
+      auditRunId: z.ZodString;
+      label: z.ZodEnum<{
+        TEST_DRIFT: "TEST_DRIFT";
+        SPEC_CHANGE: "SPEC_CHANGE";
+        PRODUCT_BUG: "PRODUCT_BUG";
+        ENVIRONMENT: "ENVIRONMENT";
+        UNKNOWN: "UNKNOWN";
+      }>;
+      headline: z.ZodString;
+    }, z.core.$strip>>;
+    auditDismissalApplied: z.ZodOptional<z.ZodBoolean>;
+    executionAssumedReached: z.ZodOptional<z.ZodEnum<{
+      noSelectionInRange: "noSelectionInRange";
+      selectionUnknown: "selectionUnknown";
+      noDeployLog: "noDeployLog";
+      unknownDeployedSha: "unknownDeployedSha";
+      ambiguousDeployedSha: "ambiguousDeployedSha";
+      deployedShaNotInLog: "deployedShaNotInLog";
+      gapInRange: "gapInRange";
+    }>>;
+    specChangedSince: z.ZodOptional<z.ZodString>;
+    manual: z.ZodOptional<z.ZodObject<{
+      by: z.ZodString;
+      at: z.ZodString;
+      note: z.ZodOptional<z.ZodString>;
+      deployedSha: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    manualLapsed: z.ZodOptional<z.ZodObject<{
+      by: z.ZodString;
+      at: z.ZodString;
+      note: z.ZodOptional<z.ZodString>;
+      deployedSha: z.ZodNullable<z.ZodString>;
+      because: z.ZodEnum<{
+        deployReached: "deployReached";
+        cannotPlace: "cannotPlace";
+        specEdited: "specEdited";
+        newerRed: "newerRed";
+      }>;
+    }, z.core.$strip>>;
+    manualLapsedByDeploy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      index: z.ZodNumber;
+      sha: z.ZodString;
+      at: z.ZodString;
+    }, z.core.$strip>>>;
+    manualLapsedReason: z.ZodOptional<z.ZodEnum<{
+      noSelectionInRange: "noSelectionInRange";
+      selectionUnknown: "selectionUnknown";
+      noDeployLog: "noDeployLog";
+      unknownDeployedSha: "unknownDeployedSha";
+      ambiguousDeployedSha: "ambiguousDeployedSha";
+      deployedShaNotInLog: "deployedShaNotInLog";
+      gapInRange: "gapInRange";
+    }>>;
+    heldBy: z.ZodNullable<z.ZodObject<{
+      kind: z.ZodEnum<{
+        run: "run";
+        audit: "audit";
+      }>;
+      holder: z.ZodString;
+      expiresAt: z.ZodString;
+    }, z.core.$strip>>;
+    lastRun: z.ZodNullable<z.ZodObject<{
+      gitHead: z.ZodString;
+      runId: z.ZodString;
+      at: z.ZodString;
+      deployedSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      deployedShaAmbiguous: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    lastGreen: z.ZodNullable<z.ZodObject<{
+      gitHead: z.ZodString;
+      runId: z.ZodString;
+      at: z.ZodString;
+      deployedSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      deployedShaAmbiguous: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    lastRed: z.ZodNullable<z.ZodObject<{
+      gitHead: z.ZodString;
+      runId: z.ZodString;
+      at: z.ZodString;
+      deployedSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      deployedShaAmbiguous: z.ZodOptional<z.ZodBoolean>;
+      label: z.ZodOptional<z.ZodEnum<{
+        TEST_DRIFT: "TEST_DRIFT";
+        SPEC_CHANGE: "SPEC_CHANGE";
+        PRODUCT_BUG: "PRODUCT_BUG";
+        ENVIRONMENT: "ENVIRONMENT";
+        UNKNOWN: "UNKNOWN";
+      }>>;
+      headline: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    touchedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    touchedByDeploy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      index: z.ZodNumber;
+      sha: z.ZodString;
+      at: z.ZodString;
+    }, z.core.$strip>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RerunReport = z.infer<typeof RerunReportSchema>;
+/** Body of `POST /projects/:project/deploys?profile=` — what the deploy job shipped. */
+declare const RecordDeployRequestSchema: z.ZodObject<{
+  sha: z.ZodString;
+  previousSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  changedPaths: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  selection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    verdict: z.ZodEnum<{
+      unknown: "unknown";
+      needed: "needed";
+      notNeeded: "notNeeded";
+    }>;
+    reason: z.ZodString;
+    touchedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>>;
+  ref: z.ZodOptional<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RecordDeployRequest = z.infer<typeof RecordDeployRequestSchema>;
+/** Body of `GET /projects/:project/deploys?profile=` — newest last, as stored. */
+declare const DeployLogResponseSchema: z.ZodObject<{
+  entries: z.ZodArray<z.ZodObject<{
+    index: z.ZodNumber;
+    sha: z.ZodString;
+    previousSha: z.ZodNullable<z.ZodString>;
+    at: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    runUrl: z.ZodOptional<z.ZodString>;
+    changedPaths: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    hasSelection: z.ZodDefault<z.ZodBoolean>;
+    gapBefore: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  nextIndex: z.ZodNumber;
+}, z.core.$strip>;
+type DeployLogResponse = z.infer<typeof DeployLogResponseSchema>;
+/**
+ * Body of `GET /projects/:project/drift`. No `?profile=` — see `SpecDriftEntrySchema`.
+ */
+declare const DriftLedgerResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    label: z.ZodNullable<z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>>;
+    surface: z.ZodOptional<z.ZodEnum<{
+      spec: "spec";
+      generated: "generated";
+    }>>;
+    subDiagnosis: z.ZodOptional<z.ZodEnum<{
+      OVER_ASSERTION: "OVER_ASSERTION";
+      SELECTOR_DRIFT: "SELECTOR_DRIFT";
+      NONE: "NONE";
+    }>>;
+    specChangeKind: z.ZodOptional<z.ZodEnum<{
+      FEATURE_REMOVED: "FEATURE_REMOVED";
+      BEHAVIOUR_CHANGED: "BEHAVIOUR_CHANGED";
+    }>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    headline: z.ZodOptional<z.ZodString>;
+    gitHead: z.ZodString;
+    runId: z.ZodString;
+    at: z.ZodString;
+    graded: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type DriftLedgerResponse = z.infer<typeof DriftLedgerResponseSchema>;
+/**
+ * What one batch of ccqa invocations spent on Claude, as the job that ran them
+ * reported it (see `SpendStore`). `label` is the consumer's name for the batch
+ * — its job name — and the only thing that says where the money went.
+ */
+declare const SpendEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  at: z.ZodString;
+  costUsd: z.ZodNumber;
+  label: z.ZodString;
+  ciRunId: z.ZodOptional<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SpendEntry = z.infer<typeof SpendEntrySchema>;
+/** Body of `POST /projects/:project/spend` — one batch's total. `at` defaults to now. */
+declare const RecordSpendRequestSchema: z.ZodObject<{
+  costUsd: z.ZodNumber;
+  label: z.ZodString;
+  at: z.ZodOptional<z.ZodString>;
+  ciRunId: z.ZodOptional<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type RecordSpendRequest = z.infer<typeof RecordSpendRequestSchema>;
+/**
+ * Body of `GET /projects/:project/spend?since=&until=`, newest first. `since`
+ * and `until` echo the window that was asked for (null for an open end), so a
+ * reader of `totalUsd` can tell what it totals.
+ */
+declare const SpendLogResponseSchema: z.ZodObject<{
+  project: z.ZodString;
+  since: z.ZodNullable<z.ZodString>;
+  until: z.ZodNullable<z.ZodString>;
+  totalUsd: z.ZodNumber;
+  entries: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    at: z.ZodString;
+    costUsd: z.ZodNumber;
+    label: z.ZodString;
+    ciRunId: z.ZodOptional<z.ZodString>;
+    runUrl: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type SpendLogResponse = z.infer<typeof SpendLogResponseSchema>;
+declare const CoverageEdgesDocSchema: z.ZodObject<{
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    measuredAt: z.ZodNumber;
+    runId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type CoverageEdgesDoc = z.infer<typeof CoverageEdgesDocSchema>;
+/**
+ * Body of `PUT /projects/:project/coverage-edges` — the specs one run
+ * measured. Merged into the stored document, never replacing other specs'
+ * entries; an empty file set is not a measurement and is rejected per entry.
+ */
+declare const CoverageEdgesUpsertSchema: z.ZodObject<{
+  specs: z.ZodRecord<z.ZodString, z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type CoverageEdgesUpsert = z.infer<typeof CoverageEdgesUpsertSchema>;
+//#endregion
+//#region src/coverage/resolve-stream.d.ts
+/**
+ * What one run's slice of the stream resolves to. The shape is the read-out
+ * API of `CoverageResolver` written down: what the coverage page needs to
+ * draw, and nothing the stream cannot support.
+ */
+declare const ResolvedCoverageSchema: z.ZodObject<{
+  runId: z.ZodString;
+  hubRunId: z.ZodOptional<z.ZodString>;
+  asOf: z.ZodNumber;
+  lastSeq: z.ZodNumber;
+  universe: z.ZodOptional<z.ZodObject<{
+    include: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  specs: z.ZodArray<z.ZodObject<{
+    specId: z.ZodString;
+    files: z.ZodArray<z.ZodString>;
+    actorEvents: z.ZodRecord<z.ZodString, z.ZodNumber>;
+  }, z.core.$strip>>;
+  boot: z.ZodArray<z.ZodString>;
+  health: z.ZodObject<{
+    heardFromApplication: z.ZodBoolean;
+    pushesDuringRun: z.ZodNumber;
+    attributedSpecs: z.ZodNumber;
+    rejectedPushes: z.ZodNumber;
+    uninstrumentedFiles: z.ZodNumber;
+    uninstrumentedProcesses: z.ZodNumber;
+    droppedPushes: z.ZodNumber;
+    unmappedActorEvents: z.ZodNumber;
+    outsideWindowEvents: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    specsMeasured: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type ResolvedCoverage = z.infer<typeof ResolvedCoverageSchema>;
+//#endregion
+//#region src/prompts/prompt-names.d.ts
+/**
+ * The fixed set of prompt assets the hub stores per project/profile, and which
+ * each is fetched at run time by the CLI. Kept as a tiny, dependency-free
+ * module so both the hub side (store/handlers) and the client/CLI can share
+ * the names without a circular import.
+ *
+ * Two kinds share one namespace:
+ *  - "guidance": Markdown — every `.user.md` file, plus the record/live/
+ *    playwright/runn `.agent.md` notes (despite the "agent" name, these are
+ *    plain prose, not the learned JSON below).
+ *  - "custom-prompt": JSON Claude writes — only `triage.agent` and
+ *    `audit.agent`, calibration distilled from graded cases and injected at
+ *    run time.
+ *
+ * `triage.*` belongs to `ccqa run`'s failure classification and `audit.*` to
+ * `ccqa audit`. They are two prompts because they answer two questions in one
+ * shared vocabulary: the audit decides whether a spec still describes the
+ * code (from the source alone), and the run decides why it failed, using the
+ * execution evidence — the two commands run independently, neither gating the
+ * other (ADR-0016).
+ *
+ * Hub names are extensionless (`record.agent`), local files keep their real
+ * extensions; `PROMPT_LOCAL_PATHS` is the single mapping every caller (push,
+ * pull, learn, UI) goes through so the two never drift.
+ */
+declare const PROMPT_NAMES: readonly ["record.user", "record.agent", "live.user", "live.agent", "playwright.user", "playwright.agent", "runn.user", "runn.agent", "triage.user", "triage.agent", "audit.user", "audit.agent"];
+type PromptName = (typeof PROMPT_NAMES)[number];
+//#endregion
+//#region src/report/schema.d.ts
+declare const ReportSpecResultSchema: z.ZodObject<{
+  feature: z.ZodString;
+  spec: z.ZodString;
+  title: z.ZodNullable<z.ZodString>;
+  target: z.ZodOptional<z.ZodString>;
+  mode: z.ZodOptional<z.ZodEnum<{
+    live: "live";
+    deterministic: "deterministic";
+  }>>;
+  status: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    skipped: "skipped";
+  }>;
+  skipReason: z.ZodOptional<z.ZodString>;
+  testCounts: z.ZodNullable<z.ZodObject<{
+    total: z.ZodNumber;
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+  }, z.core.$strip>>;
+  durationMs: z.ZodNullable<z.ZodNumber>;
+  startedAt: z.ZodOptional<z.ZodString>;
+  finishedAt: z.ZodOptional<z.ZodString>;
+  assertions: z.ZodNullable<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+      passed: "passed";
+      failed: "failed";
+      skipped: "skipped";
+    }>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+  }, z.core.$strip>>>;
+  analysis: z.ZodNullable<z.ZodObject<{
+    label: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>;
+    confidence: z.ZodNumber;
+    subDiagnosis: z.ZodOptional<z.ZodEnum<{
+      TIMING_ISSUE: "TIMING_ISSUE";
+      OVER_ASSERTION: "OVER_ASSERTION";
+      SELECTOR_DRIFT: "SELECTOR_DRIFT";
+      DATA_MISSING: "DATA_MISSING";
+      NONE: "NONE";
+    }>>;
+    headline: z.ZodDefault<z.ZodString>;
+    recommendation: z.ZodDefault<z.ZodString>;
+    evidence: z.ZodArray<z.ZodObject<{
+      file: z.ZodOptional<z.ZodString>;
+      detail: z.ZodString;
+      citation: z.ZodOptional<z.ZodEnum<{
+        corrected: "corrected";
+        unverified: "unverified";
+      }>>;
+    }, z.core.$strip>>;
+    reasoning: z.ZodString;
+    surface: z.ZodOptional<z.ZodEnum<{
+      spec: "spec";
+      generated: "generated";
+    }>>;
+    specChangeKind: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+      FEATURE_REMOVED: "FEATURE_REMOVED";
+      BEHAVIOUR_CHANGED: "BEHAVIOUR_CHANGED";
+    }>>>;
+  }, z.core.$strip>>;
+  analysisSkipped: z.ZodNullable<z.ZodString>;
+  rerun: z.ZodOptional<z.ZodObject<{
+    outcome: z.ZodEnum<{
+      passed: "passed";
+      failed: "failed";
+    }>;
+  }, z.core.$strip>>;
+  customPromptVersion: z.ZodOptional<z.ZodString>;
+  analysisBase: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    ref: z.ZodString;
+    sha: z.ZodString;
+  }, z.core.$strip>>>;
+  failureLogExcerpt: z.ZodNullable<z.ZodString>;
+  diffExcerpt: z.ZodNullable<z.ZodString>;
+  specYaml: z.ZodNullable<z.ZodString>;
+  evidence: z.ZodNullable<z.ZodArray<z.ZodObject<{
+    stepId: z.ZodString;
+    source: z.ZodString;
+    pngPath: z.ZodString;
+    beforePngPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodNullable<z.ZodString>;
+    title: z.ZodNullable<z.ZodString>;
+    capturedAt: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+      passed: "passed";
+      failed: "failed";
+    }>>;
+    failureSummary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+  }, z.core.$strip>>>;
+  evidenceUnavailable: z.ZodOptional<z.ZodString>;
+  artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+      image: "image";
+      text: "text";
+      json: "json";
+      binary: "binary";
+    }>;
+    sizeBytes: z.ZodNumber;
+  }, z.core.$strip>>>;
+  coverage: z.ZodOptional<z.ZodObject<{
+    files: z.ZodArray<z.ZodString>;
+    frontendFiles: z.ZodNumber;
+    backendFiles: z.ZodNumber;
+    backendReported: z.ZodBoolean;
+    frontendReported: z.ZodBoolean;
+    frontendStopped: z.ZodBoolean;
+    actorWindows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      key: z.ZodString;
+      events: z.ZodNumber;
+    }, z.core.$strip>>>;
+    excludedDependencies: z.ZodNumber;
+    gaps: z.ZodObject<{
+      unattributed: z.ZodNumber;
+      unmappedScripts: z.ZodNumber;
+      unmappedRanges: z.ZodNumber;
+      outsideProject: z.ZodNumber;
+      unresolvedSources: z.ZodNumber;
+      outsideProjectSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      unresolvedSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      uninstrumentedFiles: z.ZodNumber;
+      uninstrumentedProcesses: z.ZodNumber;
+      droppedPushes: z.ZodNumber;
+      unmappedActorEvents: z.ZodDefault<z.ZodNumber>;
+      outsideWindowEvents: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  coverageUnavailable: z.ZodOptional<z.ZodString>;
+  liveRun: z.ZodNullable<z.ZodObject<{
+    runId: z.ZodString;
+    sessionName: z.ZodString;
+    startedAt: z.ZodString;
+    durationMs: z.ZodNumber;
+    steps: z.ZodArray<z.ZodObject<{
+      stepId: z.ZodString;
+      source: z.ZodString;
+      instruction: z.ZodString;
+      expected: z.ZodString;
+      status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+      }>;
+      reasoning: z.ZodString;
+      beforePng: z.ZodNullable<z.ZodString>;
+      afterPng: z.ZodNullable<z.ZodString>;
+      durationMs: z.ZodNumber;
+      cost: z.ZodObject<{
+        totalCostUsd: z.ZodNullable<z.ZodNumber>;
+        durationApiMs: z.ZodNullable<z.ZodNumber>;
+        numTurns: z.ZodNullable<z.ZodNumber>;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        models: z.ZodArray<z.ZodString>;
+      }, z.core.$strip>;
+      commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    cost: z.ZodObject<{
+      totalCostUsd: z.ZodNullable<z.ZodNumber>;
+      durationApiMs: z.ZodNullable<z.ZodNumber>;
+      numTurns: z.ZodNullable<z.ZodNumber>;
+      inputTokens: z.ZodNullable<z.ZodNumber>;
+      cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+      cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+      outputTokens: z.ZodNullable<z.ZodNumber>;
+      models: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ReportSpecResult = z.infer<typeof ReportSpecResultSchema>;
+declare const RunReportDataSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  kind: z.ZodDefault<z.ZodEnum<{
+    run: "run";
+    drift: "drift";
+    record: "record";
+  }>>;
+  createdAt: z.ZodString;
+  runId: z.ZodNullable<z.ZodString>;
+  runUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  git: z.ZodObject<{
+    head: z.ZodNullable<z.ZodString>;
+    base: z.ZodNullable<z.ZodString>;
+    baseSha: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    baseSource: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+      explicit: "explicit";
+      "github-base-ref": "github-base-ref";
+      "last-green": "last-green";
+    }>>>;
+  }, z.core.$strip>;
+  model: z.ZodNullable<z.ZodString>;
+  language: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+  promptVersion: z.ZodString;
+  customPromptVersion: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+  triageUserPromptHash: z.ZodOptional<z.ZodString>;
+  deployedSha: z.ZodOptional<z.ZodString>;
+  cost: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+    totalCostUsd: z.ZodNullable<z.ZodNumber>;
+    durationApiMs: z.ZodNullable<z.ZodNumber>;
+    numTurns: z.ZodNullable<z.ZodNumber>;
+    inputTokens: z.ZodNullable<z.ZodNumber>;
+    cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+    cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+    outputTokens: z.ZodNullable<z.ZodNumber>;
+    models: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>>;
+  coverageUniverse: z.ZodOptional<z.ZodObject<{
+    include: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>;
+  results: z.ZodArray<z.ZodObject<{
+    feature: z.ZodString;
+    spec: z.ZodString;
+    title: z.ZodNullable<z.ZodString>;
+    target: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<{
+      live: "live";
+      deterministic: "deterministic";
+    }>>;
+    status: z.ZodEnum<{
+      passed: "passed";
+      failed: "failed";
+      skipped: "skipped";
+    }>;
+    skipReason: z.ZodOptional<z.ZodString>;
+    testCounts: z.ZodNullable<z.ZodObject<{
+      total: z.ZodNumber;
+      passed: z.ZodNumber;
+      failed: z.ZodNumber;
+    }, z.core.$strip>>;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    assertions: z.ZodNullable<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+        skipped: "skipped";
+      }>;
+      durationMs: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    analysis: z.ZodNullable<z.ZodObject<{
+      label: z.ZodEnum<{
+        TEST_DRIFT: "TEST_DRIFT";
+        SPEC_CHANGE: "SPEC_CHANGE";
+        PRODUCT_BUG: "PRODUCT_BUG";
+        ENVIRONMENT: "ENVIRONMENT";
+        UNKNOWN: "UNKNOWN";
+      }>;
+      confidence: z.ZodNumber;
+      subDiagnosis: z.ZodOptional<z.ZodEnum<{
+        TIMING_ISSUE: "TIMING_ISSUE";
+        OVER_ASSERTION: "OVER_ASSERTION";
+        SELECTOR_DRIFT: "SELECTOR_DRIFT";
+        DATA_MISSING: "DATA_MISSING";
+        NONE: "NONE";
+      }>>;
+      headline: z.ZodDefault<z.ZodString>;
+      recommendation: z.ZodDefault<z.ZodString>;
+      evidence: z.ZodArray<z.ZodObject<{
+        file: z.ZodOptional<z.ZodString>;
+        detail: z.ZodString;
+        citation: z.ZodOptional<z.ZodEnum<{
+          corrected: "corrected";
+          unverified: "unverified";
+        }>>;
+      }, z.core.$strip>>;
+      reasoning: z.ZodString;
+      surface: z.ZodOptional<z.ZodEnum<{
+        spec: "spec";
+        generated: "generated";
+      }>>;
+      specChangeKind: z.ZodCatch<z.ZodOptional<z.ZodEnum<{
+        FEATURE_REMOVED: "FEATURE_REMOVED";
+        BEHAVIOUR_CHANGED: "BEHAVIOUR_CHANGED";
+      }>>>;
+    }, z.core.$strip>>;
+    analysisSkipped: z.ZodNullable<z.ZodString>;
+    rerun: z.ZodOptional<z.ZodObject<{
+      outcome: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+      }>;
+    }, z.core.$strip>>;
+    customPromptVersion: z.ZodOptional<z.ZodString>;
+    analysisBase: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      ref: z.ZodString;
+      sha: z.ZodString;
+    }, z.core.$strip>>>;
+    failureLogExcerpt: z.ZodNullable<z.ZodString>;
+    diffExcerpt: z.ZodNullable<z.ZodString>;
+    specYaml: z.ZodNullable<z.ZodString>;
+    evidence: z.ZodNullable<z.ZodArray<z.ZodObject<{
+      stepId: z.ZodString;
+      source: z.ZodString;
+      pngPath: z.ZodString;
+      beforePngPath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      url: z.ZodNullable<z.ZodString>;
+      title: z.ZodNullable<z.ZodString>;
+      capturedAt: z.ZodNullable<z.ZodString>;
+      description: z.ZodNullable<z.ZodString>;
+      status: z.ZodDefault<z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+      }>>;
+      failureSummary: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    evidenceUnavailable: z.ZodOptional<z.ZodString>;
+    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      path: z.ZodString;
+      kind: z.ZodEnum<{
+        image: "image";
+        text: "text";
+        json: "json";
+        binary: "binary";
+      }>;
+      sizeBytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+    coverage: z.ZodOptional<z.ZodObject<{
+      files: z.ZodArray<z.ZodString>;
+      frontendFiles: z.ZodNumber;
+      backendFiles: z.ZodNumber;
+      backendReported: z.ZodBoolean;
+      frontendReported: z.ZodBoolean;
+      frontendStopped: z.ZodBoolean;
+      actorWindows: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        events: z.ZodNumber;
+      }, z.core.$strip>>>;
+      excludedDependencies: z.ZodNumber;
+      gaps: z.ZodObject<{
+        unattributed: z.ZodNumber;
+        unmappedScripts: z.ZodNumber;
+        unmappedRanges: z.ZodNumber;
+        outsideProject: z.ZodNumber;
+        unresolvedSources: z.ZodNumber;
+        outsideProjectSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        unresolvedSamples: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        uninstrumentedFiles: z.ZodNumber;
+        uninstrumentedProcesses: z.ZodNumber;
+        droppedPushes: z.ZodNumber;
+        unmappedActorEvents: z.ZodDefault<z.ZodNumber>;
+        outsideWindowEvents: z.ZodDefault<z.ZodNumber>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    coverageUnavailable: z.ZodOptional<z.ZodString>;
+    liveRun: z.ZodNullable<z.ZodObject<{
+      runId: z.ZodString;
+      sessionName: z.ZodString;
+      startedAt: z.ZodString;
+      durationMs: z.ZodNumber;
+      steps: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        source: z.ZodString;
+        instruction: z.ZodString;
+        expected: z.ZodString;
+        status: z.ZodEnum<{
+          passed: "passed";
+          failed: "failed";
+          skipped: "skipped";
+        }>;
+        reasoning: z.ZodString;
+        beforePng: z.ZodNullable<z.ZodString>;
+        afterPng: z.ZodNullable<z.ZodString>;
+        durationMs: z.ZodNumber;
+        cost: z.ZodObject<{
+          totalCostUsd: z.ZodNullable<z.ZodNumber>;
+          durationApiMs: z.ZodNullable<z.ZodNumber>;
+          numTurns: z.ZodNullable<z.ZodNumber>;
+          inputTokens: z.ZodNullable<z.ZodNumber>;
+          cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+          cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+          outputTokens: z.ZodNullable<z.ZodNumber>;
+          models: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+        commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      }, z.core.$strip>>;
+      cost: z.ZodObject<{
+        totalCostUsd: z.ZodNullable<z.ZodNumber>;
+        durationApiMs: z.ZodNullable<z.ZodNumber>;
+        numTurns: z.ZodNullable<z.ZodNumber>;
+        inputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodNullable<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodNullable<z.ZodNumber>;
+        outputTokens: z.ZodNullable<z.ZodNumber>;
+        models: z.ZodArray<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RunReportData = z.infer<typeof RunReportDataSchema>;
+declare const LabelsExportSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  runId: z.ZodNullable<z.ZodString>;
+  promptVersion: z.ZodString;
+  exportedAt: z.ZodString;
+  labels: z.ZodArray<z.ZodObject<{
+    feature: z.ZodString;
+    spec: z.ZodString;
+    predicted: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      UNKNOWN: "UNKNOWN";
+    }>;
+    label: z.ZodEnum<{
+      TEST_DRIFT: "TEST_DRIFT";
+      SPEC_CHANGE: "SPEC_CHANGE";
+      PRODUCT_BUG: "PRODUCT_BUG";
+      ENVIRONMENT: "ENVIRONMENT";
+      NO_DRIFT: "NO_DRIFT";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type LabelsExport = z.infer<typeof LabelsExportSchema>;
+//#endregion
+//#region src/run/incremental-report.d.ts
+/**
+ * The report envelope fields that don't change spec-to-spec — everything in
+ * `RunReportData` except `results`. Captured once when the writer is created
+ * so each incremental flush produces the same envelope the final batch write
+ * used to.
+ */
+type ReportEnvelope = Omit<RunReportData, "results">;
+//#endregion
+//#region src/hub-client/index.d.ts
+/**
+ * Body of a `PATCH /runs/:id` incremental push: the newly-finished spec rows,
+ * their evidence PNGs (posix relPath → base64), the report envelope metadata
+ * (filled once the real git diff is known), and — on the last patch — `done`
+ * with the terminal status.
+ */
+interface PatchRunRequest {
+  rows: ReportSpecResult[];
+  /** reportDir-relative posix path → base64 PNG bytes. */
+  evidence?: Record<string, string>;
+  done?: boolean;
+  finalStatus?: "passed" | "failed";
+  reportMeta?: Partial<ReportEnvelope>;
+}
+/**
+ * TypeScript client for the ccqa hub's public REST API (docs/hub-api.md).
+ * Uses the global `fetch` only — no `node:*` imports — so this same module
+ * works unmodified as a browser bundle (an intranet dashboard) or in a
+ * Node script (the `ccqa hub push/pull` CLI, which is itself just one more
+ * consumer of this client).
+ */
+interface HubClientOptions {
+  baseUrl: string;
+  token: string;
+  /**
+   * Extra headers sent on every request, ahead of any per-call headers and
+   * the `Authorization` header (e.g. an infra gateway/ALB bypass header in
+   * CI — never overrides `Authorization`).
+   */
+  headers?: Record<string, string>;
+  /** Override for testing; defaults to the global `fetch`. */
+  fetchImpl?: typeof fetch;
+}
+declare class HubApiError extends Error {
+  readonly status: number;
+  readonly code: string;
+  constructor(status: number, code: string, message: string);
+}
+interface HubVariable {
+  name: string;
+  sensitive: boolean;
+  updatedAt: string;
+  value?: string;
+}
+interface HubPromptMeta {
+  name: string;
+  kind: "guidance" | "custom-prompt";
+  updatedAt: string;
+  meta: Record<string, unknown>;
+}
+/**
+ * What `GET /api/v1/coverage` answers: one run's resolved view of the
+ * project's coverage event stream, plus every run the stream retains (newest
+ * first, bounded server-side). `resolved` is null when the stream holds no
+ * measured run.
+ */
+interface HubCoverageAnswer {
+  resolved: ResolvedCoverage | null;
+  runIds: string[];
+}
+interface HubClient {
+  /**
+   * Push a report directory (as a tar.gz) for an already-finished `ccqa run`.
+   *
+   * `deployedSha` asserts the commit the environment was running *when the run
+   * started*. Without it the hub falls back to its deploy-log head, which by
+   * push time is the head after the run — a deploy that landed mid-run would
+   * then read as that run's baseline.
+   */
+  pushRun(archive: Uint8Array, meta: {
+    project: string;
+    branch?: string;
+    profile?: string;
+    kind?: Run["kind"];
+    deployedSha?: string;
+  }): Promise<Run>;
+  /**
+   * Open a `running` run to push results into incrementally. Returns the new
+   * run's id. Non-retryable (a dropped response after the server committed
+   * would leave a second open run); callers degrade to local-only on failure.
+   * `gitHead` stamps the run's commit at open time, so even a run that dies
+   * before its final reconcile patch is attributable to a commit.
+   *
+   * `deployedSha` does the same for the environment's commit: the baseline the
+   * caller selected against, which a `--rerun` inherits from an earlier run.
+   * Left unset the hub reads its own deploy-log head, which by the time this
+   * call lands can already name a later deploy.
+   */
+  openRun(meta: {
+    project: string;
+    branch?: string;
+    profile?: string;
+    kind?: Run["kind"];
+    gitHead?: string;
+    deployedSha?: string;
+    /** CI run id (GITHUB_RUN_ID) and its run URL, stamped at open time so an
+     *  interrupted incremental run still links back to its CI run. */
+    ciRunId?: string;
+    runUrl?: string;
+  }): Promise<Run>;
+  /** Add finished spec rows (+ evidence) to a running run; `done` closes it. */
+  patchRun(id: string, body: PatchRunRequest): Promise<Run>;
+  /** `ciRunId` answers "which runs did this CI job create", whatever the window. */
+  listRuns(q?: {
+    project?: string;
+    branch?: string;
+    status?: RunStatus;
+    kind?: Run["kind"];
+    ciRunId?: string;
+    limit?: number;
+  }): Promise<Run[]>;
+  getRun(id: string): Promise<Run>;
+  getReport(id: string): Promise<unknown>;
+  downloadArtifacts(id: string): Promise<Uint8Array>;
+  /**
+   * The project's coverage event stream, resolved for one run — `runId`
+   * omitted means the most recently measured run. Spec selection reads its
+   * reach edges through this (ADR-0024).
+   */
+  getCoverage(project: string, q?: {
+    runId?: string;
+  }): Promise<HubCoverageAnswer>;
+  /**
+   * Merge one run's measured reach into the project's coverage-edge ledger
+   * (ADR-0026). The hub stamps `measuredAt` with its own clock.
+   */
+  putCoverageEdges(project: string, upsert: CoverageEdgesUpsert): Promise<void>;
+  /** The coverage-edge ledger, or `null` when nothing is stored (or the hub predates it). */
+  getCoverageEdges(project: string): Promise<CoverageEdgesDoc | null>;
+  /**
+   * Source maps for what a commit deployed, addressed by the asset path the
+   * browser requests. Coverage falls back to these when the build keeps its
+   * maps out of the CDN, which is the usual choice — a map hands out source.
+   */
+  putSourceMap(project: string, commit: string, assetPath: string, map: Uint8Array): Promise<void>;
+  getSourceMap(project: string, commit: string, assetPath: string): Promise<string | null>;
+  listSourceMaps(project: string, commit: string): Promise<string[]>;
+  /** Ends a push, letting the hub drop the commits it no longer keeps. */
+  sweepSourceMaps(project: string): Promise<void>;
+  getTriage(id: string): Promise<RunTriage>;
+  putActualCause(id: string, c: {
+    feature: string;
+    spec: string;
+  }, v: PutActualCauseRequest): Promise<TriageCase>;
+  deleteActualCause(id: string, c: {
+    feature: string;
+    spec: string;
+  }): Promise<void>;
+  importActualCauses(id: string, labels: LabelsExport): Promise<ImportActualCausesResponse>;
+  /** Every project the hub knows (from runs and stored secrets). */
+  listProjects(): Promise<string[]>;
+  /**
+   * The last-green ledger for one project/profile: "feature/spec" → the run
+   * head where that spec last passed. `branch` entries overlay
+   * `fallbackBranch` (typically the default branch) entries server-side.
+   */
+  getLastGreen(project: string, q: {
+    profile?: string;
+    branch: string;
+    fallbackBranch?: string;
+  }): Promise<Record<string, LastGreenEntry>>;
+  /**
+   * Per spec of one project/profile: is its last result still trustworthy?
+   * Answers `ccqa run --only-hub-rerun-needed`. 404 when the project has no
+   * perspectives document — there is then no spec registered to compare
+   * against a deploy, which the caller must report rather than read as
+   * "nothing to run".
+   */
+  getRerun(project: string, q: {
+    profile: string;
+  }): Promise<RerunReport>;
+  /**
+   * Per spec of one project/profile: has a deploy landed on the code it covers
+   * since the audit last read it? Answers `ccqa audit
+   * --only-hub-audit-needed`. 404 on a project with no perspectives document,
+   * for the same reason `getRerun` does.
+   */
+  getAuditNeed(project: string, q: {
+    profile: string;
+  }): Promise<AuditNeedReport>;
+  /**
+   * Take the specs that are free, so a second job does not start on one this
+   * run is already working. `denied` is part of the answer, not an error.
+   */
+  acquireLocks(project: string, q: {
+    profile: string;
+  }, body: AcquireLocksRequest): Promise<AcquireLocksResponse>;
+  /** Drop everything `runId` holds. Safe to call when it holds nothing. */
+  releaseLocks(project: string, q: {
+    profile: string;
+  }, holder: string): Promise<void>;
+  /** Every attestation for the profile, standing and lapsed alike. */
+  getAttestations(project: string, q: {
+    profile: string;
+  }): Promise<AttestationsResponse>;
+  /** Record that a person checked `spec` by hand. The hub stamps the time and deploy head. */
+  putAttestation(project: string, q: {
+    profile: string;
+  }, body: {
+    spec: string;
+    by: string;
+    note?: string;
+  }): Promise<AttestationResponse>;
+  /** Revoke a spec's attestation. Revoking one that does not exist succeeds. */
+  deleteAttestation(project: string, q: {
+    profile: string;
+  }, spec: string): Promise<void>;
+  /** Every dismissed audit finding for the project, current and superseded alike. No profile — findings are about the repository. */
+  getAuditDismissals(project: string): Promise<AuditDismissalsResponse>;
+  /**
+   * Record that a person judged `spec`'s current audit finding wrong. The hub
+   * reads which finding that is from the ledger and pins the dismissal to it;
+   * a spec with no open finding is rejected.
+   */
+  putAuditDismissal(project: string, body: {
+    spec: string;
+    by: string;
+    note: string;
+  }): Promise<AuditDismissalResponse>;
+  /** Withdraw a dismissal, putting the audit's finding back in force. */
+  deleteAuditDismissal(project: string, spec: string): Promise<void>;
+  /**
+   * Every spec's last `ccqa audit --report-to-hub` result, keyed by "feature/spec". No
+   * profile — drift asks whether a spec still describes the code, not
+   * whether an environment is stale.
+   */
+  getDriftLedger(project: string): Promise<DriftLedgerResponse>;
+  /** Tell the hub what a deploy shipped (`ccqa hub deploy record`). */
+  recordDeploy(project: string, profile: string, body: RecordDeployRequest): Promise<DeployEntry>;
+  /** The profile's retained deploy log, oldest first; `limit` keeps the newest N. */
+  getDeployLog(project: string, q: {
+    profile: string;
+    limit?: number;
+  }): Promise<DeployLogResponse>;
+  /**
+   * Report what one batch of ccqa invocations cost (`ccqa hub cost push`).
+   * Read instead of a sum over runs, never alongside one (ADR-0017).
+   */
+  recordSpend(project: string, body: RecordSpendRequest): Promise<SpendEntry>;
+  /** The project's spend over `[since, until)`, newest first, with the window's total. */
+  getSpend(project: string, q?: {
+    since?: string;
+    until?: string;
+  }): Promise<SpendLogResponse>;
+  putSession(project: string, profile: string, name: string, storageState: unknown): Promise<void>;
+  getSession(project: string, profile: string, name: string): Promise<unknown>;
+  listSessions(project: string, profile: string): Promise<{
+    name: string;
+    updatedAt: string;
+  }[]>;
+  deleteSession(project: string, profile: string, name: string): Promise<void>;
+  putVariable(project: string, profile: string, name: string, v: {
+    value: string;
+    sensitive: boolean;
+  }): Promise<void>;
+  listVariables(project: string, profile: string, opts?: {
+    includeValues?: boolean;
+  }): Promise<HubVariable[]>;
+  deleteVariable(project: string, profile: string, name: string): Promise<void>;
+  putPrompt(project: string, name: PromptName, body: string): Promise<void>;
+  getPrompt(project: string, name: PromptName): Promise<string | null>;
+  listPrompts(project: string): Promise<HubPromptMeta[]>;
+  deletePrompt(project: string, name: PromptName): Promise<void>;
+  /** The project's perspectives document (coverage inventory), stored hub-only. */
+  putPerspectives(project: string, doc: unknown): Promise<void>;
+  getPerspectives(project: string): Promise<unknown | null>;
+  /** Set (or clear, with an empty string) the human note on one spec's entry. */
+  patchPerspectivesNote(project: string, c: {
+    feature: string;
+    spec: string;
+    note: string;
+  }): Promise<void>;
+  deletePerspectives(project: string): Promise<void>;
+}
+/**
+ * One round trip against a hub, with the client's shared policy: bearer auth,
+ * per-attempt timeout, retries for idempotent methods, `HubApiError` on the
+ * final non-ok answer. Exported for the one caller outside the client
+ * (`CoverageInbox`), whose POSTs are appends a duplicate cannot corrupt —
+ * unlike the client's own POSTs — so it may opt into `retry: "post-once"`,
+ * one extra attempt after a 5xx or network error.
+ */
+declare function hubRequest(opts: HubClientOptions, path: string, init?: RequestInit, retry?: "post-once"): Promise<Response>;
+declare function createHubClient(opts: HubClientOptions): HubClient;
+//#endregion
+export { HubApiError, HubClient, HubClientOptions, HubCoverageAnswer, HubPromptMeta, HubVariable, PatchRunRequest, createHubClient, hubRequest };