fluncle 0.264.0 → 0.266.0

package/bin/fluncle.mjs

@@ -380,6 +380,12 @@ var require_main = __commonJS(function(exports, module) {
 });
 
 // src/env.ts
+var exports_env = {};
+__export(exports_env, {
+  getApiBaseUrl: () => getApiBaseUrl,
+  loadEnv: () => loadEnv,
+  readOptionalEnv: () => readOptionalEnv
+});
 import { homedir } from "node:os";
 import { join } from "node:path";
 function loadEnv(keys) {
@@ -399,6 +405,10 @@ function loadEnv(keys) {
   }
   return result;
 }
+function readOptionalEnv(key) {
+  loadConfig();
+  return process.env[key] || undefined;
+}
 function getApiBaseUrl() {
   loadConfig();
   return (process.env.FLUNCLE_API_BASE_URL ?? "https://www.fluncle.com").replace(/\/+$/, "");
@@ -622,7 +632,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.264.0".trim() ? "0.264.0".trim() : "0.1.0";
+  currentVersion = "0.266.0".trim() ? "0.266.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2335,12 +2345,12 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.264.0".trim() ? "0.264.0".trim() : "0.1.0";
+  currentVersion2 = "0.266.0".trim() ? "0.266.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
 function liveSurfaces() {
-  return SURFACES.filter((surface) => surface.pending !== true);
+  return SURFACES.filter((surface) => surface.pending !== true && surface.dormant === undefined);
 }
 var SITE = "https://www.fluncle.com", PROBE_CADENCE_MS, PROBE_TIMEOUT_MS, MINUTE_MS, SURFACES;
 var init_src = __esm(() => {
@@ -3524,12 +3534,13 @@ var init_src = __esm(() => {
       weights: { status: "hidden" }
     },
     {
+      dormant: "the iOS app has no users, and the mirror's embedded-replica sync of the main database halves the primary's write capacity while it runs",
       exposedContent: [
         "mirror the anchored, explicitly allowlisted public catalogue into the shared read-only device replica"
       ],
       kind: "cron",
       name: "cron.device-mirror",
-      operatorNotes: "hourly, run by a host systemd timer (docs/agents/hermes/device-mirror-timer/). Explicitly synchronizes one restart-safe local embedded replica, materializes the anchored track IDs once, derives and validates one allowlisted generation locally, then stages bounded changes and atomically cuts the complete verified generation into the shared device database. Sync, derivation, upload, validation, or cutover failure leaves the previous generation visible; rebuilding the target database remains forbidden because it would reset the libSQL replication log and force every device to bootstrap again. A schema-version mismatch stops for an operator migration. Zero LLM tokens. Source: docs/agents/hermes/scripts/device-mirror.*.",
+      operatorNotes: "DORMANT: parked by docs/agents/hermes/device-mirror-timer/DORMANT, which keeps the installer from enabling its timer and keeps the healthcheck, /status, and the run-ledger roster from expecting it; revival steps are in that directory's README. When live: hourly, run by a host systemd timer (docs/agents/hermes/device-mirror-timer/). Explicitly synchronizes one restart-safe local embedded replica, materializes the anchored track IDs once, derives and validates one allowlisted generation locally, then stages bounded changes and atomically cuts the complete verified generation into the shared device database. Sync, derivation, upload, validation, or cutover failure leaves the previous generation visible; rebuilding the target database remains forbidden because it would reset the libSQL replication log and force every device to bootstrap again. A schema-version mismatch stops for an operator migration. Zero LLM tokens. Source: docs/agents/hermes/scripts/device-mirror.*.",
       probeConfig: {
         cadenceMs: 60 * MINUTE_MS,
         cronName: "fluncle-device-mirror",
@@ -3663,11 +3674,11 @@ var init_src = __esm(() => {
     {
       command: "fluncle admin tracks context --queue",
       exposedContent: [
-        "Firecrawl facts → distilled context_note + a Texture: line (Worker-side Haiku)"
+        "Firecrawl facts → distilled context_note + a Texture: line (Worker-side OpenRouter distill)"
       ],
       kind: "cron",
       name: "cron.context-note",
-      operatorNotes: "every 5m. --no-agent trigger; the Worker does the Firecrawl + Haiku distill. Zero on-box tokens.",
+      operatorNotes: "every 5m. --no-agent trigger; the Worker does the Firecrawl + OpenRouter distill. Zero on-box tokens.",
       probeConfig: { cadenceMs: 5 * MINUTE_MS, cronName: "fluncle-context-note", kind: "cron" },
       statusDescription: "distills the facts behind each finding",
       title: "Context notes",
@@ -3714,13 +3725,32 @@ var init_src = __esm(() => {
     },
     {
       command: "fluncle admin labels list --seed-state undecided",
-      exposedContent: ["read the undecided crawl-seed pile and report whether a triage round is due"],
+      exposedContent: [
+        "read the undecided crawl-seed pile and, once a round is due, research it into proposals"
+      ],
       kind: "cron",
       name: "cron.label-triage",
-      operatorNotes: "daily. A PURE trigger — zero model tokens, one countless admin read and a sort. Fires only when 40+ NEVER-LOOKED labels have accumulated; stale ones ride along but never trigger a round. It cannot rule: recording a finding is record_label_triage (agent tier) and ruling is update_label (operator tier), which 403s the box token. The batched research leg is deliberately unwired until the gate proves it reports honestly. Source: docs/agents/hermes/scripts/{label-triage-sweep.ts,label-triage-sweep.sh}.",
+      operatorNotes: "daily. The gate is one countless admin read and a sort; it fires only when 40+ NEVER-LOOKED labels with a MusicBrainz identity and no artist rules have accumulated, and stale ones ride along. A fired round runs one claude -p per batch of 10 labels (capped at 3 batches and 30 labels) whose only fetcher is `fluncle admin labels evidence`; the model holds no Fluncle token, and the script records each verdict with record_label_triage (agent tier). It cannot rule: update_label is operator tier and 403s the box token. Labels a round left unfinished (a failed batch, or past the cap) are carried and fire the next day. The model runs --restricted with dontAsk permissions, confined to its batch directory and the skill. A fired round that records zero proposals, or any failed batch, exits non-zero, reads failed on /status and posts to Discord. Source: docs/agents/hermes/scripts/{label-triage-sweep.ts,label-triage-sweep.sh}.",
       probeConfig: { cadenceMs: 24 * 60 * MINUTE_MS, cronName: "fluncle-label-triage", kind: "cron" },
-      statusDescription: "reports when the label pile needs a round",
-      title: "Label triage gate",
+      statusDescription: "researches the label pile when it needs a round",
+      title: "Label triage",
+      weights: { status: "hidden" }
+    },
+    {
+      exposedContent: [
+        "nightly label-outlier review list — every album and label-less single of embedded catalogue tracks scored against the rest of its own label, the far ones flagged onto /admin/label-outliers (--no-agent)"
+      ],
+      kind: "cron",
+      name: "cron.label-outliers",
+      operatorNotes: "05:30 Amsterdam daily, retry slot 06:30. Reads its scoring inputs (embedded catalogue tracks with their raw vector bytes, artist credits, album Discogs styles) from the AGENT-tier list_label_outlier_inputs op in keyset pages of 1,000, each page its own admitted heavy-read phase, into a local file it scores and deletes (about 51 pages and 280 MB a night at 50k tracks; an admission yield mid-walk leaves the payload unstarted for the retry slot). It scores each album's mean cosine to its label's leave-it-out centroid as a robust z against that label's own spread (labels under 8 albums use the whole catalogue), and keeps the ones at z <= -4 whose artists have fewer than 3 typical tracks elsewhere and whose album Discogs does not file under Drum n Bass or Jungle. A corpus under 10,000 usable vectors or under 95% usable, or more than 2,000 flags, fails loudly and writes nothing. It then fires the AGENT-tier record_label_outliers op in its own admitted phase; the Worker refuses a duplicated, partial, or collapsed run (fewer than 80% of the live embedded catalogue), replaces the stored list, and returns every visible unit not yet announced. The sweep posts one Discord summary and only then acknowledges them by unit and fingerprint (acknowledge_label_outlier_alerts), so a lost response re-alerts next run. Dismissing is operator tier (set_label_outliers_dismissed) and holds until the album's tracks change. Zero LLM tokens. Source: docs/agents/hermes/scripts/label-outliers*.ts. See docs/catalogue-crawler.md.",
+      probeConfig: {
+        cadenceMs: 24 * 60 * MINUTE_MS,
+        cronName: "fluncle-label-outliers",
+        kind: "cron",
+        schedule: { time: "05:30", tz: "Europe/Amsterdam" }
+      },
+      statusDescription: "flags albums that sound unlike their label",
+      title: "Label outliers",
       weights: { status: "hidden" }
     },
     {
@@ -3874,7 +3904,7 @@ var init_src = __esm(() => {
       ],
       kind: "cron",
       name: "cron.healthcheck",
-      operatorNotes: "every 10m, run by a rave-02 host systemd timer (docs/agents/hermes/healthcheck-timer/) — decoupled from the Hermes cron gateway so the prober isn't starved by the scheduler it monitors. Pure probing, zero LLM tokens. POSTs to the agent-tier record_health op that /status reads.",
+      operatorNotes: "every 10m, run by a rave-02 host systemd timer (docs/agents/hermes/healthcheck-timer/) — decoupled from the Hermes cron gateway so the prober isn't starved by the scheduler it monitors. Pure probing, zero LLM tokens. POSTs to the agent-tier record_health op that /status reads, and makes one record_database_write_probe call per tick that feeds database admission's write-latency guardrail.",
       probeConfig: { cadenceMs: 10 * MINUTE_MS, cronName: "fluncle-healthcheck", kind: "cron" },
       statusDescription: "the prober behind this very page",
       title: "Healthcheck prober",
@@ -4020,6 +4050,21 @@ var init_src = __esm(() => {
       title: "Funnel snapshot",
       weights: { status: "hidden" }
     },
+    {
+      exposedContent: [
+        "Turso usage and overage reading — the organisation's current-cycle usage priced against the plan and projected to the reset, stored in the telemetry database for the /admin/costs Turso panel (--no-agent)"
+      ],
+      kind: "cron",
+      name: "cron.turso-usage",
+      operatorNotes: "Every 6 hours (OnUnitActiveSec), no retry slot: the counters are cumulative, so the next tick loses nothing. Reads the Turso Platform API (organization usage, database list, subscription, upcoming invoice) with TURSO_PLATFORM_API_TOKEN + TURSO_PLATFORM_ORG from the sweep secrets file, then fires the AGENT-tier record_turso_usage op. The Worker prices the reading with the versioned table in apps/web/src/lib/turso-pricing.ts (list rates, so an upper bound), projects the UTC-month cycle from the recent daily run-rate, stores it in the telemetry database, and claims a (cycle, level) alert row when the projected overage reaches the turso_usage_alert_threshold_usd setting (default $50) or twice it. The sweep posts one Discord message and only then acknowledges the levels (acknowledge_turso_usage_alerts), so a lost post re-sends next run. Missing credentials fail the run by name. Zero LLM tokens. Source: docs/agents/hermes/scripts/turso-usage-sweep.*. See docs/agents/hermes/turso-usage-timer/README.md.",
+      operatorOnly: "the database bill is an operator concern; the job still reports to the prober, the run ledger, and the /admin/costs Turso panel, never to the public status board",
+      probeConfig: {
+        cadenceMs: 6 * 60 * MINUTE_MS,
+        cronName: "fluncle-turso-usage",
+        kind: "cron"
+      },
+      weights: {}
+    },
     {
       exposedContent: [
         "daily per-post social-metrics snapshot — appends each published post's Postiz reach (views/likes/comments/…) into an append-only ledger, one row per post per day (--no-agent)"
@@ -4039,7 +4084,7 @@ var init_src = __esm(() => {
     },
     {
       exposedContent: [
-        "nightly codebase audit — one domain/night on a 7-day rotation; opens a PR the reviewer merges (claude -p, subscription auth)"
+        "nightly codebase audit — one domain/night on an 8-domain rotation; opens a PR the reviewer merges (claude -p, subscription auth)"
       ],
       kind: "cron",
       name: "cron.audit",
@@ -10497,7 +10542,8 @@ var init_admin_catalogue = __esm(() => {
       limit: number2().int().min(1).max(MAX_CRAWL_PREPARE_LIMIT).default(2),
       maxHop: number2().int().min(0).max(3).default(2),
       phase: literal("prepare"),
-      sampleStorableRepair: boolean2().optional()
+      sampleStorableRepair: boolean2().optional(),
+      skipFrontierPendingCount: boolean2().optional()
     }),
     object({
       phase: literal("fetch"),
@@ -10522,7 +10568,7 @@ var init_admin_catalogue = __esm(() => {
     object({
       boxFetch: boolean2(),
       capabilities: CrawlPhaseCapabilitiesSchema.optional(),
-      frontierPending: number2(),
+      frontierPending: number2().optional(),
       initialization: CrawlPhaseInitializationSchema,
       items: array(object({
         fetchPlan: CrawlFetchPlanSchema,
@@ -11146,7 +11192,7 @@ var init_admin_albums = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-artifacts.ts
-var ARTIFACT_CHANGE_API_MAX_LIMIT = 500, ARTIFACT_SNAPSHOT_API_MAX_LIMIT = 200, ARTIFACT_COMPACTION_API_MAX_LIMIT = 1000, ARTIFACT_SUPPORTED_CONTRACTS, ArtifactStreamSchema, ArtifactContractSchema, ConsumerIdSchema, DigestSchema, SequenceSchema, ArtifactRebuildCheckpointSchema, ArtifactConsumerStatusSchema, ArtifactChangeEventSchema, ArtifactSnapshotItemSchema, ArtifactSnapshotPageSchema, ArtifactChangePageSchema, ArtifactCompactionResultSchema, registerArtifactConsumer, getArtifactConsumer, listArtifactSnapshot, checkpointArtifactRebuild, activateArtifactConsumer, listArtifactChanges, acknowledgeArtifactChanges, inactivateArtifactConsumer, compactArtifactChanges, adminArtifactsContract;
+var ARTIFACT_CHANGE_API_MAX_LIMIT = 500, ARTIFACT_SNAPSHOT_API_MAX_LIMIT = 200, ARTIFACT_COMPACTION_API_MAX_LIMIT = 1000, ARTIFACT_SUPPORTED_CONTRACTS, ArtifactStreamSchema, ArtifactContractSchema, ConsumerIdSchema, DigestSchema, SequenceSchema, ArtifactRebuildCheckpointSchema, ArtifactConsumerStatusSchema, ArtifactChangeEventSchema, ArtifactSnapshotItemSchema, ArtifactSnapshotPageSchema, ArtifactChangePageSchema, ArtifactCompactionResultSchema, SonarSourceAfterSchema, SonarSourceLimitSchema, SonarSourceIdsSchema, listSonarTrackDigests, listSonarTracks, listSonarCentroidDigests, listSonarCentroids, registerArtifactConsumer, getArtifactConsumer, listArtifactSnapshot, checkpointArtifactRebuild, activateArtifactConsumer, listArtifactChanges, acknowledgeArtifactChanges, inactivateArtifactConsumer, compactArtifactChanges, adminArtifactsContract;
 var init_admin_artifacts = __esm(() => {
   init_dist3();
   init_zod();
@@ -11260,6 +11306,57 @@ var init_admin_artifacts = __esm(() => {
     ok: literal(true),
     reason: _enum(["compacted", "empty", "no_safe_barrier"])
   });
+  SonarSourceAfterSchema = string2().min(1).max(1024).optional();
+  SonarSourceLimitSchema = number3().int().min(1).max(2000).default(1000);
+  SonarSourceIdsSchema = array(string2().min(1).max(1024)).min(1).max(200).refine((ids) => new Set(ids).size === ids.length);
+  listSonarTrackDigests = oc.route({
+    method: "GET",
+    operationId: "listSonarTrackDigests",
+    path: "/admin/sonar/source/tracks",
+    summary: "List source track digests and revisions",
+    tags: ["Admin"]
+  }).input(strictObject({ after: SonarSourceAfterSchema, limit: SonarSourceLimitSchema })).output(strictObject({
+    items: array(strictObject({
+      payloadDigest: DigestSchema,
+      revision: SequenceSchema,
+      subjectId: string2().min(1).max(1024)
+    })),
+    nextAfter: string2().nullable(),
+    ok: literal(true)
+  }));
+  listSonarTracks = oc.route({
+    method: "POST",
+    operationId: "listSonarTracks",
+    path: "/admin/sonar/source/tracks/items",
+    summary: "Read selected source tracks",
+    tags: ["Admin"]
+  }).input(strictObject({ subjectIds: SonarSourceIdsSchema })).output(strictObject({
+    absentIds: array(string2()),
+    items: array(ArtifactSnapshotItemSchema.extend({ revision: SequenceSchema })),
+    ok: literal(true)
+  }));
+  listSonarCentroidDigests = oc.route({
+    method: "GET",
+    operationId: "listSonarCentroidDigests",
+    path: "/admin/sonar/source/centroids",
+    summary: "List source artist centroid digests",
+    tags: ["Admin"]
+  }).input(strictObject({ after: SonarSourceAfterSchema, limit: SonarSourceLimitSchema })).output(strictObject({
+    items: array(strictObject({ artistId: string2(), digest: DigestSchema })),
+    nextAfter: string2().nullable(),
+    ok: literal(true)
+  }));
+  listSonarCentroids = oc.route({
+    method: "POST",
+    operationId: "listSonarCentroids",
+    path: "/admin/sonar/source/centroids/items",
+    summary: "Read selected artist centroids",
+    tags: ["Admin"]
+  }).input(strictObject({ artistIds: SonarSourceIdsSchema })).output(strictObject({
+    absentIds: array(string2()),
+    items: array(strictObject({ artistId: string2(), blobBase64: string2(), digest: DigestSchema })),
+    ok: literal(true)
+  }));
   registerArtifactConsumer = oc.route({
     method: "POST",
     operationId: "registerArtifactConsumer",
@@ -11360,6 +11457,10 @@ var init_admin_artifacts = __esm(() => {
     inactivate_artifact_consumer: inactivateArtifactConsumer,
     list_artifact_changes: listArtifactChanges,
     list_artifact_snapshot: listArtifactSnapshot,
+    list_sonar_centroid_digests: listSonarCentroidDigests,
+    list_sonar_centroids: listSonarCentroids,
+    list_sonar_track_digests: listSonarTrackDigests,
+    list_sonar_tracks: listSonarTracks,
     register_artifact_consumer: registerArtifactConsumer
   };
 });
@@ -12459,7 +12560,7 @@ var init_admin_costs = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-database-admission.ts
-var DatabaseAdmissionActionSchema, DatabaseAdmissionLaneSchema, DatabaseAdmissionOutcomeSchema, DatabaseAdmissionYieldReasonSchema, DatabaseAdmissionInputSchema, DatabaseAdmissionResponseSchema, coordinateDatabaseAdmission, adminDatabaseAdmissionContract;
+var DatabaseAdmissionActionSchema, DatabaseAdmissionLaneSchema, DatabaseAdmissionOutcomeSchema, DatabaseAdmissionYieldReasonSchema, DatabaseAdmissionInputSchema, DatabaseAdmissionResponseSchema, coordinateDatabaseAdmission, DatabaseWriteProbeOutcomeSchema, DatabaseWriteProbeResponseSchema, recordDatabaseWriteProbe, adminDatabaseAdmissionContract;
 var init_admin_database_admission = __esm(() => {
   init_dist3();
   init_zod();
@@ -12478,12 +12579,15 @@ var init_admin_database_admission = __esm(() => {
     "database-health",
     "direct-read-latency",
     "public-latency",
-    "queue"
+    "queue",
+    "write-latency"
   ]);
   DatabaseAdmissionInputSchema = object({
     action: DatabaseAdmissionActionSchema,
     fencingToken: number2().int().positive().optional(),
+    notAfterMs: number2().int().nonnegative().optional(),
     owner: string2().min(1).max(64).regex(/^[a-z0-9][a-z0-9.-]*$/),
+    protocolVersion: literal(2).optional(),
     runId: string2().min(1).max(96).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/)
   }).refine((input) => input.action === "acquire" || input.action === "cancel" || input.fencingToken !== undefined, "heartbeat and release require a fencing token");
   DatabaseAdmissionResponseSchema = object({
@@ -12495,10 +12599,12 @@ var init_admin_database_admission = __esm(() => {
     holdMs: number2().int().nonnegative(),
     lane: DatabaseAdmissionLaneSchema,
     leaseExpiresAtMs: number2().int().nonnegative().nullable(),
+    leaseRemainingMs: number2().int().nonnegative().nullable(),
     operationId: string2().min(1).max(64),
     outcome: DatabaseAdmissionOutcomeSchema,
     queueAgeMs: number2().int().nonnegative(),
     recovered: boolean2(),
+    retryAfterMs: number2().int().nonnegative().nullable(),
     waitMs: number2().int().nonnegative(),
     yieldReason: DatabaseAdmissionYieldReasonSchema.nullable()
   });
@@ -12509,8 +12615,23 @@ var init_admin_database_admission = __esm(() => {
     summary: "Coordinate one registry-classified recurring database operation",
     tags: ["Admin"]
   }).input(DatabaseAdmissionInputSchema).output(DatabaseAdmissionResponseSchema);
+  DatabaseWriteProbeOutcomeSchema = _enum(["failed", "ok", "slow", "stalled"]);
+  DatabaseWriteProbeResponseSchema = object({
+    latencyMs: number2().int().nonnegative().nullable(),
+    ok: literal(true),
+    outcome: DatabaseWriteProbeOutcomeSchema,
+    recorded: boolean2()
+  });
+  recordDatabaseWriteProbe = oc.route({
+    method: "POST",
+    operationId: "recordDatabaseWriteProbe",
+    path: "/admin/database-admission/write-probe",
+    summary: "Time one bounded write to the primary database and record it for admission",
+    tags: ["Admin"]
+  }).input(object({})).output(DatabaseWriteProbeResponseSchema);
   adminDatabaseAdmissionContract = {
-    coordinate_database_admission: coordinateDatabaseAdmission
+    coordinate_database_admission: coordinateDatabaseAdmission,
+    record_database_write_probe: recordDatabaseWriteProbe
   };
 });
 
@@ -13824,6 +13945,142 @@ var init_admin_hub_counts = __esm(() => {
   };
 });
 
+// ../../packages/contracts/src/orpc/admin-label-outliers.ts
+var MAX_RECORDED_LABEL_OUTLIERS = 2000, MAX_LABEL_OUTLIER_DISMISSALS = 500, LabelOutlierReferenceSchema, RecordedLabelOutlierSchema, LabelOutlierRunSchema, AlertedLabelOutlierSchema, PendingLabelOutlierAlertSchema, recordLabelOutliers, acknowledgeLabelOutlierAlerts, LabelOutlierTrackSchema, LabelOutlierItemSchema, listLabelOutliers, setLabelOutliersDismissed, LabelOutlierInputTrackSchema, LabelOutlierInputAlbumSchema, listLabelOutlierInputs, adminLabelOutliersContract;
+var init_admin_label_outliers = __esm(() => {
+  init_dist3();
+  init_zod();
+  LabelOutlierReferenceSchema = _enum(["catalogue", "label"]);
+  RecordedLabelOutlierSchema = object({
+    albumId: string2().min(1).max(256).nullable(),
+    artistSupport: number2().int().min(0),
+    fingerprint: string2().min(1).max(128),
+    labelId: string2().min(1).max(256).nullable(),
+    reference: LabelOutlierReferenceSchema,
+    referenceMedian: number2(),
+    score: number2(),
+    singleTrackId: string2().min(1).max(256).nullable(),
+    trackCount: number2().int().min(1),
+    unitId: string2().min(1).max(256),
+    z: number2()
+  }).meta({ id: "RecordedLabelOutlier" });
+  LabelOutlierRunSchema = object({
+    flagged: number2().int().min(0),
+    labelsScored: number2().int().min(0),
+    ranAt: string2(),
+    replicaSyncedAt: string2().nullable(),
+    tracksScored: number2().int().min(0),
+    unitsScored: number2().int().min(0)
+  }).meta({ id: "LabelOutlierRun" });
+  AlertedLabelOutlierSchema = object({
+    fingerprint: string2().min(1).max(128),
+    unitId: string2().min(1).max(256)
+  }).meta({ id: "AlertedLabelOutlier" });
+  PendingLabelOutlierAlertSchema = object({
+    albumName: string2().nullable(),
+    labelName: string2().nullable(),
+    title: string2(),
+    unitId: string2()
+  }).meta({ id: "PendingLabelOutlierAlert" });
+  recordLabelOutliers = oc.route({
+    method: "PUT",
+    operationId: "recordLabelOutliers",
+    path: "/admin/label-outliers",
+    summary: "Replace the nightly label-outlier review list with the box's scored set",
+    tags: ["Admin"]
+  }).input(object({
+    labelsScored: number2().int().min(0),
+    outliers: array(RecordedLabelOutlierSchema).max(MAX_RECORDED_LABEL_OUTLIERS),
+    replicaSyncedAt: string2().nullable(),
+    totalFlagged: number2().int().min(0),
+    tracksScored: number2().int().min(0),
+    unitsScored: number2().int().min(0)
+  })).output(object({
+    flagged: number2().int(),
+    ok: literal(true),
+    pendingAlertUnits: array(AlertedLabelOutlierSchema),
+    pendingAlerts: array(PendingLabelOutlierAlertSchema),
+    removed: number2().int()
+  }));
+  acknowledgeLabelOutlierAlerts = oc.route({
+    method: "PUT",
+    operationId: "acknowledgeLabelOutlierAlerts",
+    path: "/admin/label-outliers/alerts",
+    summary: "Mark flagged label outliers as announced, once their Discord summary has landed",
+    tags: ["Admin"]
+  }).input(object({
+    units: array(AlertedLabelOutlierSchema).min(1).max(MAX_RECORDED_LABEL_OUTLIERS)
+  })).output(object({ acknowledged: number2().int(), ok: literal(true) }));
+  LabelOutlierTrackSchema = object({
+    artists: array(object({ name: string2(), slug: string2() })),
+    title: string2(),
+    trackId: string2()
+  }).meta({ id: "LabelOutlierTrack" });
+  LabelOutlierItemSchema = object({
+    album: object({ id: string2(), name: string2(), slug: string2() }).nullable(),
+    artistSupport: number2(),
+    discogsStyles: array(string2()),
+    dismissedAt: string2().nullable(),
+    firstFlaggedAt: string2(),
+    label: object({ id: string2(), name: string2(), slug: string2() }).nullable(),
+    reference: LabelOutlierReferenceSchema,
+    referenceMedian: number2(),
+    score: number2(),
+    trackCount: number2(),
+    tracks: array(LabelOutlierTrackSchema),
+    unitId: string2(),
+    z: number2()
+  }).meta({ id: "LabelOutlierItem" });
+  listLabelOutliers = oc.route({
+    method: "GET",
+    operationId: "listLabelOutliers",
+    path: "/admin/label-outliers",
+    summary: "The label-outlier review list: albums and singles that sound unlike their label",
+    tags: ["Admin"]
+  }).output(object({
+    items: array(LabelOutlierItemSchema),
+    lastRun: LabelOutlierRunSchema.nullable(),
+    ok: literal(true)
+  }));
+  setLabelOutliersDismissed = oc.route({
+    method: "PUT",
+    operationId: "setLabelOutliersDismissed",
+    path: "/admin/label-outliers/dismissed",
+    summary: "Mark flagged label outliers as looking fine, or put them back on the list (operator)",
+    tags: ["Admin"]
+  }).input(object({
+    dismissed: boolean2(),
+    unitIds: array(string2().min(1).max(256)).min(1).max(MAX_LABEL_OUTLIER_DISMISSALS)
+  })).output(object({ changed: number2().int(), ok: literal(true) }));
+  LabelOutlierInputTrackSchema = object({
+    albumId: string2().nullable(),
+    artistIds: array(string2()),
+    embeddingBase64: string2(),
+    labelId: string2().nullable(),
+    trackId: string2()
+  }).meta({ id: "LabelOutlierInputTrack" });
+  LabelOutlierInputAlbumSchema = object({ discogsStyles: string2(), id: string2() }).meta({ id: "LabelOutlierInputAlbum" });
+  listLabelOutlierInputs = oc.route({
+    method: "GET",
+    operationId: "listLabelOutlierInputs",
+    path: "/admin/label-outliers/inputs",
+    summary: "One keyset page of the label-outlier scoring inputs: embedded catalogue tracks with their raw vector bytes, artist credits, and album Discogs styles",
+    tags: ["Admin"]
+  }).input(object({ cursor: string2().max(512).optional(), limit: string2().optional() })).output(object({
+    albums: array(LabelOutlierInputAlbumSchema),
+    nextCursor: string2().nullable(),
+    ok: literal(true),
+    tracks: array(LabelOutlierInputTrackSchema)
+  }));
+  adminLabelOutliersContract = {
+    acknowledge_label_outlier_alerts: acknowledgeLabelOutlierAlerts,
+    list_label_outlier_inputs: listLabelOutlierInputs,
+    list_label_outliers: listLabelOutliers,
+    record_label_outliers: recordLabelOutliers,
+    set_label_outliers_dismissed: setLabelOutliersDismissed
+  };
+});
+
 // ../../packages/contracts/src/orpc/admin-labels.ts
 var LabelSeedStateSchema, LabelTriageVerdictSchema, LabelAdminItemSchema, listLabelsAdmin, updateLabel, listLabelArtistRules, LABEL_ARTIST_RULES_MAX = 100, LABEL_TRIAGE_RULE_PROPOSALS_MAX, replaceLabelArtistRules, MergeLabelResultSchema, mergeLabel, MB_LABEL_MBID_PATTERN, MintLabelOutcomeSchema, LabelTakeOverResultSchema, mintLabel, LabelAliasSourceSchema, LabelAliasKindSchema, LabelAliasCandidateSchema, listLabelAliases, confirmLabelAlias, rejectLabelAlias, DescribeLabelBodySchema, describeLabel, draftLabelBio, LabelBioWorkItemSchema, listLabelsMissingBio, TriageRuleProposalSchema, RecordLabelTriageBodySchema, recordLabelTriage, adminLabelsContract;
 var init_admin_labels = __esm(() => {
@@ -13833,6 +14090,7 @@ var init_admin_labels = __esm(() => {
   LabelSeedStateSchema = _enum(["disabled", "enabled", "undecided"]).meta({ id: "LabelSeedState" });
   LabelTriageVerdictSchema = _enum(["dnb", "dnb_partial", "not_dnb", "unclear"]).meta({ id: "LabelTriageVerdict" });
   LabelAdminItemSchema = object({
+    carriesArtistRules: boolean2().optional(),
     createdAt: string2(),
     disambiguation: string2().nullable().optional(),
     findingCount: number2(),
@@ -15872,6 +16130,145 @@ var init_admin_telemetry2 = __esm(() => {
   };
 });
 
+// ../../packages/contracts/src/orpc/admin-turso-usage.ts
+var MAX_TURSO_USAGE_DATABASES = 500, TURSO_USAGE_THRESHOLD_MIN_USD = 1, TURSO_USAGE_THRESHOLD_MAX_USD = 1e5, Count, CycleKey, TursoUsageResourceKeySchema, TursoUsageRateBasisSchema, TursoUsageTotalsSchema, TursoDatabaseUsageSchema, TursoUsageResourceSchema, TursoAttributedDatabaseSchema, TursoUsageSnapshotSchema, TursoUsageHistoryDaySchema, TursoUsageAlertSchema, TursoUsageAlertKeySchema, recordTursoUsage, getTursoUsage, acknowledgeTursoUsageAlerts, setTursoUsageThreshold, adminTursoUsageContract;
+var init_admin_turso_usage = __esm(() => {
+  init_dist3();
+  init_zod();
+  Count = number2().int().min(0);
+  CycleKey = string2().regex(/^\d{4}-\d{2}$/);
+  TursoUsageResourceKeySchema = _enum([
+    "rowsRead",
+    "rowsWritten",
+    "storage",
+    "embeddedSyncs"
+  ]);
+  TursoUsageRateBasisSchema = _enum(["recent", "cycle-to-date", "none"]);
+  TursoUsageTotalsSchema = object({
+    bytesSynced: Count,
+    rowsRead: Count,
+    rowsWritten: Count,
+    storageBytes: Count
+  }).meta({ id: "TursoUsageTotals" });
+  TursoDatabaseUsageSchema = TursoUsageTotalsSchema.extend({
+    name: string2().min(1).max(256)
+  }).meta({ id: "TursoDatabaseUsage" });
+  TursoUsageResourceSchema = object({
+    dailyRate: number2().min(0),
+    included: number2().min(0),
+    key: TursoUsageResourceKeySchema,
+    overageUsd: number2().min(0),
+    projectedOverageUsd: number2().min(0),
+    projectedUsed: number2().min(0),
+    unitSize: number2().positive(),
+    usdPerUnit: number2().min(0),
+    used: number2().min(0)
+  }).meta({ id: "TursoUsageResource" });
+  TursoAttributedDatabaseSchema = TursoDatabaseUsageSchema.extend({
+    attributedOverageUsd: number2().min(0)
+  }).meta({ id: "TursoAttributedDatabase" });
+  TursoUsageSnapshotSchema = object({
+    baseUsd: number2().min(0).nullable(),
+    cycle: CycleKey,
+    cycleEnd: string2(),
+    cycleStart: string2(),
+    databases: array(TursoAttributedDatabaseSchema),
+    observedAt: string2(),
+    overageUsd: number2().min(0),
+    overagesEnabled: boolean2(),
+    plan: string2(),
+    priceSource: string2(),
+    priceTableVersion: string2(),
+    priced: boolean2(),
+    projectedBillUsd: number2().min(0).nullable(),
+    projectedOverageUsd: number2().min(0),
+    rateBasis: TursoUsageRateBasisSchema,
+    rateWindowHours: number2().min(0).nullable(),
+    resources: array(TursoUsageResourceSchema),
+    timeline: string2().nullable(),
+    upcomingInvoiceUsd: number2().min(0).nullable()
+  }).meta({ id: "TursoUsageSnapshot" });
+  TursoUsageHistoryDaySchema = object({
+    bytesSynced: Count,
+    day: string2(),
+    overageUsd: number2().min(0),
+    projectedOverageUsd: number2().min(0),
+    rowsRead: Count,
+    rowsWritten: Count,
+    storageBytes: Count
+  }).meta({ id: "TursoUsageHistoryDay" });
+  TursoUsageAlertSchema = object({
+    cycle: CycleKey,
+    deliveredAt: string2().nullable(),
+    levelUsd: number2().positive(),
+    projectedOverageUsd: number2().min(0),
+    raisedAt: string2()
+  }).meta({ id: "TursoUsageAlert" });
+  TursoUsageAlertKeySchema = object({
+    cycle: CycleKey,
+    levelUsd: number2().positive()
+  }).meta({ id: "TursoUsageAlertKey" });
+  recordTursoUsage = oc.route({
+    method: "POST",
+    operationId: "recordTursoUsage",
+    path: "/admin/costs/turso-usage",
+    summary: "Record one Turso platform usage reading and price it against the plan",
+    tags: ["Admin"]
+  }).input(object({
+    databases: array(TursoDatabaseUsageSchema).max(MAX_TURSO_USAGE_DATABASES),
+    observedAt: string2().min(1).max(64),
+    plan: object({
+      name: string2().min(1).max(64),
+      overages: boolean2(),
+      timeline: string2().max(32).nullable()
+    }),
+    upcomingInvoiceUsd: number2().min(0).nullable(),
+    usage: TursoUsageTotalsSchema
+  })).output(object({
+    ok: literal(true),
+    pendingAlerts: array(TursoUsageAlertSchema),
+    snapshot: TursoUsageSnapshotSchema,
+    stored: boolean2(),
+    thresholdUsd: number2().positive()
+  }));
+  getTursoUsage = oc.route({
+    method: "GET",
+    operationId: "getTursoUsage",
+    path: "/admin/costs/turso-usage",
+    summary: "The latest priced Turso usage reading, its per-day history, and this cycle's alerts (operator)",
+    tags: ["Admin"]
+  }).output(object({
+    alerts: array(TursoUsageAlertSchema),
+    available: boolean2(),
+    history: array(TursoUsageHistoryDaySchema),
+    latest: TursoUsageSnapshotSchema.nullable(),
+    ok: literal(true),
+    thresholdUsd: number2().positive()
+  }));
+  acknowledgeTursoUsageAlerts = oc.route({
+    method: "PUT",
+    operationId: "acknowledgeTursoUsageAlerts",
+    path: "/admin/costs/turso-usage/alerts",
+    summary: "Mark Turso overage alerts as delivered, once their Discord post has landed",
+    tags: ["Admin"]
+  }).input(object({ alerts: array(TursoUsageAlertKeySchema).min(1).max(20) })).output(object({ acknowledged: number2().int().min(0), ok: literal(true) }));
+  setTursoUsageThreshold = oc.route({
+    method: "PUT",
+    operationId: "setTursoUsageThreshold",
+    path: "/admin/costs/turso-usage/threshold",
+    summary: "Set the projected Turso overage that raises a Discord alert (operator)",
+    tags: ["Admin"]
+  }).input(object({
+    thresholdUsd: number2().min(TURSO_USAGE_THRESHOLD_MIN_USD).max(TURSO_USAGE_THRESHOLD_MAX_USD)
+  })).output(object({ ok: literal(true), thresholdUsd: number2().positive() }));
+  adminTursoUsageContract = {
+    acknowledge_turso_usage_alerts: acknowledgeTursoUsageAlerts,
+    get_turso_usage: getTursoUsage,
+    record_turso_usage: recordTursoUsage,
+    set_turso_usage_threshold: setTursoUsageThreshold
+  };
+});
+
 // ../../packages/contracts/src/orpc/admin-twitch.ts
 var recordLiveState, adminTwitchContract;
 var init_admin_twitch = __esm(() => {
@@ -17286,6 +17683,7 @@ var init_orpc = __esm(() => {
   init_admin_funnel();
   init_admin_health();
   init_admin_hub_counts();
+  init_admin_label_outliers();
   init_admin_labels();
   init_admin_logbook();
   init_admin_migrations();
@@ -17300,6 +17698,7 @@ var init_orpc = __esm(() => {
   init_admin_tokens();
   init_admin_tracks();
   init_admin_telemetry2();
+  init_admin_turso_usage();
   init_admin_twitch();
   init_admin_users();
   init_devices();
@@ -17332,6 +17731,7 @@ var init_orpc = __esm(() => {
   init_mix();
   init_galaxies2();
   init_graph();
+  init_admin_label_outliers();
   init_admin_galaxies();
   init_admin_albums();
   init_admin_artifacts();
@@ -17349,6 +17749,7 @@ var init_orpc = __esm(() => {
   init_admin_notes();
   init_admin_observations();
   init_admin_costs();
+  init_admin_turso_usage();
   init_admin_database_admission();
   init_admin_telemetry2();
   init_admin_health();
@@ -17417,6 +17818,7 @@ var init_orpc = __esm(() => {
     ...adminHealthContract,
     ...adminHubCountsContract,
     ...followDigestContract,
+    ...adminLabelOutliersContract,
     ...adminLabelsContract,
     ...adminLogbookContract,
     ...adminMigrationsContract,
@@ -17431,6 +17833,7 @@ var init_orpc = __esm(() => {
     ...adminTokensContract,
     ...adminTracksContract,
     ...adminTelemetryContract,
+    ...adminTursoUsageContract,
     ...adminTwitchContract,
     ...adminUsersContract,
     ...devicesContract,
@@ -19858,6 +20261,974 @@ var init_admin_covers = __esm(() => {
   init_api();
 });
 
+// src/evidence-http.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+function defaultCacheDir() {
+  const base = process.env.XDG_CACHE_HOME || join6(homedir4(), ".cache");
+  return join6(base, "fluncle", "label-evidence");
+}
+function createEvidenceHttp(overrides = {}) {
+  return {
+    cacheDir: defaultCacheDir(),
+    cacheTtlMs: 7 * 24 * 60 * 60 * 1000,
+    fetch: (url, init) => globalThis.fetch(url, init),
+    now: () => Date.now(),
+    policies: SOURCE_POLICIES,
+    random: Math.random,
+    refresh: false,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    stats: { cacheHits: 0, requests: 0 },
+    ...overrides
+  };
+}
+function cachePath(http, source, key) {
+  const digest = createHash("sha256").update(key).digest("hex");
+  return join6(http.cacheDir, source, `${digest}.json`);
+}
+async function readCache2(http, source, key) {
+  if (http.refresh) {
+    return null;
+  }
+  try {
+    const entry = JSON.parse(await readFile2(cachePath(http, source, key), "utf8"));
+    if (entry.key !== key || http.now() - entry.fetchedAt > http.cacheTtlMs) {
+      return null;
+    }
+    return entry.text;
+  } catch {
+    return null;
+  }
+}
+async function writeCache2(http, source, key, text) {
+  const path = cachePath(http, source, key);
+  const temp = `${path}.${process.pid}.${Math.floor(http.random() * 1e9)}.tmp`;
+  try {
+    await mkdir2(join6(http.cacheDir, source), { recursive: true });
+    await writeFile2(temp, JSON.stringify({ fetchedAt: http.now(), key, text }));
+    await rename(temp, path);
+  } catch {
+    await rm(temp, { force: true }).catch(() => {
+      return;
+    });
+  }
+}
+async function withSlotLock(http, source, critical) {
+  const dir = join6(http.cacheDir, "slots");
+  await mkdir2(dir, { recursive: true });
+  const lock = join6(dir, `${source}.lock`);
+  for (;; ) {
+    try {
+      await mkdir2(lock);
+      break;
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        throw error;
+      }
+      const held = await stat(lock).catch(() => null);
+      if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS) {
+        const evicted = `${lock}.stale.${process.pid}.${Math.floor(Math.random() * 1e9)}`;
+        const won = await rename(lock, evicted).then(() => true, () => false);
+        if (won) {
+          await rm(evicted, { force: true, recursive: true });
+        }
+        continue;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 15 + Math.floor(Math.random() * 35)));
+    }
+  }
+  try {
+    return await critical(join6(dir, `${source}.next`));
+  } finally {
+    await rm(lock, { force: true, recursive: true });
+  }
+}
+async function readNextSlot(slotFile) {
+  const raw = await readFile2(slotFile, "utf8").catch(() => "0");
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : 0;
+}
+async function reserveSlot(http, source) {
+  const interval = http.policies[source].intervalMs;
+  const slotAt = await withSlotLock(http, source, async (slotFile) => {
+    const now = http.now();
+    const slot = Math.max(now, await readNextSlot(slotFile));
+    await writeFile2(slotFile, String(slot + interval));
+    return slot;
+  });
+  const wait = slotAt - http.now();
+  if (wait > 0) {
+    await http.sleep(wait);
+  }
+}
+async function pushSlotBack(http, source, until) {
+  await withSlotLock(http, source, async (slotFile) => {
+    if (await readNextSlot(slotFile) < until) {
+      await writeFile2(slotFile, String(until));
+    }
+  });
+}
+function parseRetryAfter(value, now) {
+  if (!value) {
+    return null;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1000);
+  }
+  const at = Date.parse(value);
+  return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500 && status !== 501;
+}
+function failureKind(status) {
+  if (status === 404) {
+    return "not_found";
+  }
+  return status === 429 || status === 503 ? "rate_limited" : "http";
+}
+async function performWithTimeout(perform, timeoutMs) {
+  const controller = new AbortController;
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve({ timedOut: true });
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      perform(controller.signal).then((response) => ({ response }), (error) => controller.signal.aborted ? { timedOut: true } : { error }),
+      timeout
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchEvidenceText(http, source, cacheKey, perform, accept = () => true) {
+  const hit = await readCache2(http, source, cacheKey);
+  if (hit !== null && accept(hit)) {
+    http.stats.cacheHits += 1;
+    return { cached: true, text: hit };
+  }
+  const policy = http.policies[source];
+  let last;
+  for (let attempt = 1;attempt <= policy.attempts; attempt += 1) {
+    await reserveSlot(http, source);
+    http.stats.requests += 1;
+    const outcome = await performWithTimeout(perform, policy.timeoutMs);
+    let retryAfterMs = null;
+    if ("response" in outcome) {
+      const { response } = outcome;
+      const success = response.status >= 200 && response.status < 300;
+      if (success && accept(response.text)) {
+        await writeCache2(http, source, cacheKey, response.text);
+        return { cached: false, text: response.text };
+      }
+      if (success) {
+        last = new EvidenceFetchError("invalid", `${source} answered HTTP ${response.status} with a body that is not the expected data`, attempt, response.status);
+      } else {
+        last = new EvidenceFetchError(failureKind(response.status), `${source} answered HTTP ${response.status}`, attempt, response.status);
+        if (!isRetryableStatus(response.status)) {
+          throw last;
+        }
+        retryAfterMs = parseRetryAfter(response.headers.get("retry-after"), http.now());
+        if (retryAfterMs !== null) {
+          await pushSlotBack(http, source, http.now() + Math.min(retryAfterMs, policy.maxBackoffMs));
+        }
+        if (retryAfterMs !== null && retryAfterMs > policy.maxBackoffMs) {
+          throw new EvidenceFetchError("rate_limited", `${source} asked to wait ${Math.ceil(retryAfterMs / 1000)} s, past the ${policy.maxBackoffMs / 1000} s limit`, attempt, response.status);
+        }
+      }
+    } else if ("timedOut" in outcome) {
+      last = new EvidenceFetchError("timeout", `${source} did not answer within ${policy.timeoutMs} ms`, attempt);
+    } else {
+      const reason = outcome.error instanceof Error ? outcome.error.message : String(outcome.error);
+      last = new EvidenceFetchError("network", `${source} request failed: ${reason}`, attempt);
+    }
+    if (attempt === policy.attempts) {
+      break;
+    }
+    const exponential = policy.intervalMs * 2 ** attempt;
+    const backoff = Math.min(policy.maxBackoffMs, Math.max(retryAfterMs ?? 0, exponential) + Math.floor(http.random() * 250));
+    await http.sleep(backoff);
+  }
+  throw new EvidenceFetchError(last?.kind ?? "network", `${last?.message ?? `${source} request failed`} (gave up after ${policy.attempts} attempts)`, policy.attempts, last?.status);
+}
+function isJson(text) {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function fetchEvidenceJson(http, source, url, headers = {}) {
+  const { cached, text } = await fetchEvidenceText(http, source, `GET ${url}`, async (signal) => {
+    const response = await http.fetch(url, {
+      headers: { Accept: "application/json", "User-Agent": EVIDENCE_USER_AGENT, ...headers },
+      signal
+    });
+    return { headers: response.headers, status: response.status, text: await response.text() };
+  }, isJson);
+  return { cached, data: JSON.parse(text) };
+}
+var SOURCE_POLICIES, EVIDENCE_USER_AGENT = "FluncleLabelTriage/1.0 ( https://www.fluncle.com )", EvidenceFetchError, LOCK_STALE_MS = 1e4;
+var init_evidence_http = __esm(() => {
+  SOURCE_POLICIES = {
+    apple: { attempts: 3, intervalMs: 3000, maxBackoffMs: 30000, timeoutMs: 1e4 },
+    beatport: { attempts: 2, intervalMs: 1000, maxBackoffMs: 30000, timeoutMs: 75000 },
+    discogs: { attempts: 3, intervalMs: 2500, maxBackoffMs: 30000, timeoutMs: 15000 },
+    musicbrainz: { attempts: 4, intervalMs: 1100, maxBackoffMs: 30000, timeoutMs: 20000 }
+  };
+  EvidenceFetchError = class EvidenceFetchError extends Error {
+    attempts;
+    kind;
+    status;
+    constructor(kind, message, attempts, status) {
+      super(message);
+      this.name = "EvidenceFetchError";
+      this.kind = kind;
+      this.attempts = attempts;
+      this.status = status;
+    }
+  };
+});
+
+// src/commands/admin-labels.ts
+var exports_admin_labels = {};
+__export(exports_admin_labels, {
+  resolveLabel: () => resolveLabel2
+});
+async function resolveLabel2(slugOrId) {
+  const { labels } = await adminApiGet("/api/v1/admin/labels");
+  const match = labels.find((label) => label.slug === slugOrId || label.id === slugOrId);
+  if (!match) {
+    throw new Error(`No label with slug or id '${slugOrId}' — check \`fluncle labels\``);
+  }
+  return match;
+}
+var init_admin_labels3 = __esm(() => {
+  init_api();
+  init_admin_artists3();
+});
+
+// src/commands/admin-label-evidence.ts
+import { spawn } from "node:child_process";
+function parseCensusPages(value) {
+  const pages = Number(value);
+  if (!Number.isInteger(pages) || pages < 1 || pages > MAX_CENSUS_PAGES) {
+    throw new Error(`Pass --census-pages 1-${MAX_CENSUS_PAGES}`);
+  }
+  return pages;
+}
+function parseEvidenceSources(value) {
+  if (value === undefined || value.trim() === "") {
+    return [...EVIDENCE_SOURCES];
+  }
+  const wanted = value.split(",").map((entry) => entry.trim().toLowerCase());
+  const unknown = wanted.filter((entry) => !EVIDENCE_SOURCES.includes(entry));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown source(s): ${unknown.join(", ")} — pick from ${EVIDENCE_SOURCES.join(", ")}`);
+  }
+  return EVIDENCE_SOURCES.filter((source) => wanted.includes(source));
+}
+function failureOf(error, request) {
+  if (error instanceof EvidenceFetchError) {
+    return {
+      attempts: error.attempts,
+      kind: error.kind,
+      message: error.message,
+      request,
+      ...error.status === undefined ? {} : { status: error.status }
+    };
+  }
+  return {
+    kind: "parse",
+    message: error instanceof Error ? error.message : String(error),
+    request
+  };
+}
+function statusFrom(parts, failures) {
+  if (failures === 0) {
+    return "ok";
+  }
+  return failures < parts ? "partial" : "error";
+}
+function tally(names) {
+  const counts = new Map;
+  for (const name of names) {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return [...counts.entries()].map(([name, count]) => ({ count, name })).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+function firstCredit(credit) {
+  const head = credit?.[0];
+  const mbid = head?.artist?.id;
+  if (!mbid) {
+    return null;
+  }
+  return { mbid, name: head?.artist?.name ?? head?.name ?? mbid };
+}
+function crawlRuleCredit(credit) {
+  for (const entry of credit ?? []) {
+    const name = entry.artist?.name ?? entry.name;
+    const mbid = entry.artist?.id;
+    if (name && mbid && mbid !== VARIOUS_ARTISTS_MBID) {
+      return { mbid, name };
+    }
+  }
+  return null;
+}
+function creditString(credit) {
+  return (credit ?? []).map((entry) => entry.name ?? entry.artist?.name ?? "").join(" / ");
+}
+function linkOf(links, host) {
+  return links.find((link) => link.url.includes(host))?.url ?? null;
+}
+function toLabelFacts(payload, mbid) {
+  const relations = payload.relations ?? [];
+  return {
+    area: payload.area?.name ?? null,
+    country: payload.country ?? null,
+    disambiguation: payload.disambiguation || null,
+    genres: (payload.genres ?? []).flatMap((genre) => genre.name ? [genre.name] : []),
+    labelCode: payload["label-code"] ?? null,
+    labelRelations: relations.flatMap((relation) => relation.label?.id ? [
+      {
+        direction: relation.direction ?? "forward",
+        mbid: relation.label.id,
+        name: relation.label.name ?? relation.label.id,
+        type: relation.type ?? "unknown"
+      }
+    ] : []),
+    lifeSpan: {
+      begin: payload["life-span"]?.begin ?? null,
+      end: payload["life-span"]?.end ?? null,
+      ended: payload["life-span"]?.ended === true
+    },
+    links: relations.flatMap((relation) => relation.url?.resource ? [{ type: relation.type ?? "unknown", url: relation.url.resource }] : []),
+    mbid: payload.id ?? mbid,
+    name: payload.name ?? mbid,
+    tags: (payload.tags ?? []).flatMap((tag) => tag.name ? [tag.name] : []),
+    type: payload.type ?? null
+  };
+}
+function toReleaseFacts(browse, mbid) {
+  const releases = browse.releases ?? [];
+  const byArtist = new Map;
+  let variousArtistsReleases = 0;
+  const samples = releases.map((release) => {
+    const head = firstCredit(release["artist-credit"]);
+    if (head?.mbid === VARIOUS_ARTISTS_MBID) {
+      variousArtistsReleases += 1;
+    } else if (head) {
+      const entry = byArtist.get(head.mbid) ?? { mbid: head.mbid, name: head.name, releases: 0 };
+      entry.releases += 1;
+      byArtist.set(head.mbid, entry);
+    }
+    const info = release["label-info"]?.find((entry) => entry.label?.id === mbid);
+    const formats = [
+      ...new Set((release.media ?? []).flatMap((m) => m.format ? [m.format] : []))
+    ];
+    return {
+      artist: creditString(release["artist-credit"]),
+      barcode: release.barcode || null,
+      catno: info?.["catalog-number"] ?? null,
+      date: release.date || null,
+      format: formats.length > 0 ? formats.join(" + ") : null,
+      mbid: release.id,
+      status: release.status ?? null,
+      title: release.title ?? ""
+    };
+  });
+  return {
+    firstCreditArtists: [...byArtist.values()].sort((a, b) => b.releases - a.releases || a.name.localeCompare(b.name)).slice(0, FIRST_CREDIT_ARTISTS),
+    releaseCount: browse["release-count"] ?? releases.length,
+    releases: samples.sort((a, b) => (b.date ?? "").localeCompare(a.date ?? "")).slice(0, RELEASE_SAMPLE),
+    releasesRead: releases.length,
+    variousArtistsReleases
+  };
+}
+async function runCensus(deps, mbid, maxPages) {
+  const credits = new Map;
+  const seen = new Set;
+  let offset = 0;
+  let pagesFetched = 0;
+  let releaseCount = 0;
+  let allCached = true;
+  let failure;
+  let uncredited = 0;
+  while (pagesFetched < maxPages) {
+    const url = `${MB_ROOT}/release?label=${mbid}&inc=artist-credits+recordings&limit=100&offset=${offset}&fmt=json`;
+    let page;
+    try {
+      page = await fetchEvidenceJson(deps.http, "musicbrainz", url);
+    } catch (error) {
+      if (pagesFetched === 0) {
+        throw error;
+      }
+      failure = failureOf(error, url);
+      break;
+    }
+    const { cached, data } = page;
+    const releases = data.releases ?? [];
+    allCached &&= cached;
+    pagesFetched += 1;
+    releaseCount = data["release-count"] ?? releaseCount;
+    for (const release of releases) {
+      for (const medium of release.media ?? []) {
+        for (const track of medium.tracks ?? []) {
+          const recordingId = track.recording?.id;
+          if (!recordingId || seen.has(recordingId)) {
+            continue;
+          }
+          seen.add(recordingId);
+          const head = crawlRuleCredit(track.recording?.["artist-credit"] ?? release["artist-credit"]);
+          if (!head) {
+            uncredited += 1;
+            continue;
+          }
+          const entry = credits.get(head.mbid) ?? {
+            artistMbid: head.mbid,
+            artistName: head.name,
+            recordings: 0
+          };
+          entry.recordings += 1;
+          credits.set(head.mbid, entry);
+        }
+      }
+    }
+    offset += releases.length;
+    if (releases.length === 0 || offset >= releaseCount) {
+      break;
+    }
+  }
+  const sampled = offset < releaseCount;
+  const firstCredits = [...credits.values()].sort((a, b) => b.recordings - a.recordings || a.artistName.localeCompare(b.artistName));
+  return {
+    cached: allCached,
+    ...failure ? { failure } : {},
+    census: {
+      caveat: sampled ? `sampled: first ${offset} of ${releaseCount} releases${failure ? " (a later page failed)" : ""}` : null,
+      firstCredits,
+      pagesFetched,
+      recordingsCounted: firstCredits.reduce((sum, entry) => sum + entry.recordings, uncredited),
+      releaseCount,
+      releasesRead: offset,
+      sampled,
+      uncreditedRecordings: uncredited
+    }
+  };
+}
+async function gatherMusicBrainz(deps, mbid, options) {
+  const data = {};
+  const errors = [];
+  let parts = 2;
+  let allCached = true;
+  const labelUrl = `${MB_ROOT}/label/${mbid}?inc=aliases+label-rels+url-rels+tags+genres&fmt=json`;
+  try {
+    const { cached, data: payload } = await fetchEvidenceJson(deps.http, "musicbrainz", labelUrl);
+    allCached &&= cached;
+    data.label = toLabelFacts(payload, mbid);
+  } catch (error) {
+    errors.push(failureOf(error, labelUrl));
+  }
+  const releasesUrl = `${MB_ROOT}/release?label=${mbid}&inc=artist-credits+labels+media&limit=100&fmt=json`;
+  try {
+    const { cached, data: browse } = await fetchEvidenceJson(deps.http, "musicbrainz", releasesUrl);
+    allCached &&= cached;
+    data.releases = toReleaseFacts(browse, mbid);
+  } catch (error) {
+    errors.push(failureOf(error, releasesUrl));
+  }
+  if (options.census) {
+    parts += 1;
+    try {
+      const { cached, census, failure } = await runCensus(deps, mbid, options.censusPages);
+      allCached &&= cached;
+      data.census = census;
+      if (failure) {
+        errors.push(failure);
+      }
+    } catch (error) {
+      errors.push(failureOf(error, `${MB_ROOT}/release?label=${mbid}&inc=recordings (census)`));
+    }
+  }
+  return {
+    cached: allCached,
+    data,
+    ...errors.length > 0 ? { errors } : {},
+    status: statusFrom(parts, errors.length)
+  };
+}
+function discogsLabelIdFrom(url) {
+  const match = url ? /discogs\.com\/(?:[a-z]{2}\/)?label\/(\d+)/i.exec(url) : null;
+  return match?.[1] ? Number(match[1]) : null;
+}
+function beatportLabelUrlFrom(url) {
+  const match = url ? /beatport\.com\/label\/([^/?#]+)\/(\d+)/i.exec(url) : null;
+  return match?.[1] && match[2] ? `https://www.beatport.com/label/${match[1]}/${match[2]}` : null;
+}
+function discogsHeaders(deps) {
+  return deps.discogsToken ? { Authorization: `Discogs token=${deps.discogsToken}` } : {};
+}
+async function discogsCandidates(deps, name) {
+  const searchUrl = `${DISCOGS_ROOT}/database/search?type=label&q=${encodeURIComponent(name)}&per_page=5`;
+  try {
+    const { cached, data } = await fetchEvidenceJson(deps.http, "discogs", searchUrl, discogsHeaders(deps));
+    const candidates = (data.results ?? []).flatMap((result) => result.id ? [
+      {
+        id: result.id,
+        title: result.title ?? "",
+        url: `https://www.discogs.com${result.uri ?? `/label/${result.id}`}`
+      }
+    ] : []);
+    return {
+      cached,
+      data: { candidates },
+      note: "The MusicBrainz label has no Discogs link. Candidates are unverified name matches: confirm the identity before citing any of them.",
+      status: "no_link"
+    };
+  } catch (error) {
+    return {
+      errors: [failureOf(error, searchUrl)],
+      note: "The MusicBrainz label has no Discogs link.",
+      status: "no_link"
+    };
+  }
+}
+function toDiscogsLabel(payload, labelId, fallbackName) {
+  const sublabels = (payload.sublabels ?? []).flatMap((entry) => entry.name ? [entry.name] : []);
+  const parent = payload.parent_label;
+  return {
+    id: payload.id ?? labelId,
+    name: payload.name ?? fallbackName,
+    parentLabel: parent?.id === undefined ? null : { id: parent.id, name: parent.name ?? "" },
+    profile: (payload.profile ?? "").slice(0, PROFILE_CHARS),
+    sublabelCount: sublabels.length,
+    sublabels: sublabels.slice(0, 30),
+    url: payload.uri ?? `https://www.discogs.com/label/${labelId}`,
+    urls: payload.urls ?? []
+  };
+}
+function toDiscogsReleases(payload) {
+  const releases = payload.releases ?? [];
+  const ids = releases.flatMap((release) => {
+    const id = release.type === "master" ? release.main_release : release.id;
+    return typeof id === "number" ? [id] : [];
+  });
+  return {
+    facts: {
+      releaseCount: payload.pagination?.items ?? releases.length,
+      sample: releases.slice(0, DISCOGS_RELEASE_SAMPLE).map((release) => ({
+        artist: release.artist ?? "",
+        catno: release.catno ?? null,
+        format: release.format ?? null,
+        title: release.title ?? "",
+        year: release.year || null
+      })),
+      topArtists: tally(releases.map((release) => release.artist ?? "")).filter((entry) => entry.name !== "").slice(0, 15).map((entry) => ({ name: entry.name, releases: entry.count }))
+    },
+    ids
+  };
+}
+async function gatherDiscogs(deps, mb) {
+  const labelFacts = mb.label;
+  if (!labelFacts) {
+    return {
+      note: "MusicBrainz label unavailable, so no Discogs link to follow",
+      status: "skipped"
+    };
+  }
+  const labelId = discogsLabelIdFrom(linkOf(labelFacts.links, "discogs.com"));
+  if (labelId === null) {
+    return discogsCandidates(deps, labelFacts.name);
+  }
+  const headers = discogsHeaders(deps);
+  const data = {};
+  const errors = [];
+  const releaseIds = new Set;
+  let allCached = true;
+  const labelUrl = `${DISCOGS_ROOT}/labels/${labelId}`;
+  try {
+    const { cached, data: payload } = await fetchEvidenceJson(deps.http, "discogs", labelUrl, headers);
+    allCached &&= cached;
+    data.label = toDiscogsLabel(payload, labelId, labelFacts.name);
+  } catch (error) {
+    errors.push(failureOf(error, labelUrl));
+  }
+  const releasesUrl = `${DISCOGS_ROOT}/labels/${labelId}/releases?per_page=100&page=1`;
+  try {
+    const { cached, data: payload } = await fetchEvidenceJson(deps.http, "discogs", releasesUrl, headers);
+    allCached &&= cached;
+    const { facts, ids } = toDiscogsReleases(payload);
+    data.releases = facts;
+    for (const id of ids) {
+      releaseIds.add(id);
+    }
+  } catch (error) {
+    errors.push(failureOf(error, releasesUrl));
+  }
+  if (releaseIds.size > 0) {
+    const styled = await readDiscogsStyles(deps, releaseIds, data.label?.name ?? labelFacts.name);
+    allCached &&= styled.cached;
+    errors.push(...styled.errors);
+    data.styles = styled.styles;
+  }
+  return {
+    cached: allCached,
+    data,
+    ...errors.length > 0 ? { errors } : {},
+    status: discogsStatus(data, errors)
+  };
+}
+function discogsStatus(data, errors) {
+  if (Object.keys(data).length === 0) {
+    return "error";
+  }
+  return errors.length > 0 ? "partial" : "ok";
+}
+function discogsSearchName(name) {
+  return name.replace(/\s*\(\d+\)$/, "").replace(/^[^\p{L}\p{N}]+/u, "");
+}
+async function readDiscogsStyles(deps, releaseIds, labelName) {
+  const headers = discogsHeaders(deps);
+  const styled = new Map;
+  const errors = [];
+  let allCached = true;
+  let viaSearch = 0;
+  const searchUrl = `${DISCOGS_ROOT}/database/search?type=release&label=${encodeURIComponent(discogsSearchName(labelName))}&per_page=100`;
+  try {
+    const { cached, data } = await fetchEvidenceJson(deps.http, "discogs", searchUrl, headers);
+    allCached &&= cached;
+    for (const result of data.results ?? []) {
+      if (typeof result.id === "number" && releaseIds.has(result.id) && !styled.has(result.id)) {
+        styled.set(result.id, { genres: result.genre ?? [], styles: result.style ?? [] });
+      }
+    }
+    viaSearch = styled.size;
+  } catch (error) {
+    errors.push(failureOf(error, searchUrl));
+  }
+  const target = Math.min(DISCOGS_STYLE_TARGET, releaseIds.size);
+  const unread = [...releaseIds].filter((id) => !styled.has(id));
+  let reads = 0;
+  for (const id of unread) {
+    if (styled.size >= target || reads >= DISCOGS_RELEASE_READS) {
+      break;
+    }
+    reads += 1;
+    const releaseUrl = `${DISCOGS_ROOT}/releases/${id}`;
+    try {
+      const { cached, data } = await fetchEvidenceJson(deps.http, "discogs", releaseUrl, headers);
+      allCached &&= cached;
+      styled.set(id, { genres: data.genres ?? [], styles: data.styles ?? [] });
+    } catch (error) {
+      errors.push(failureOf(error, releaseUrl));
+    }
+  }
+  const rows = [...styled.values()];
+  return {
+    cached: allCached,
+    errors,
+    styles: {
+      genres: tally(rows.flatMap((row) => row.genres)),
+      labelReleasesListed: releaseIds.size,
+      releasesRead: rows.length,
+      styles: tally(rows.flatMap((row) => row.styles)).slice(0, 25),
+      viaRelease: rows.length - viaSearch,
+      viaSearch
+    }
+  };
+}
+function facetCounts(rows) {
+  return (rows ?? []).flatMap((row) => row.name && typeof row.count === "number" ? [{ count: row.count, name: row.name }] : []).sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+}
+function parseBeatportTracksPage(html) {
+  const island = /<script id="__NEXT_DATA__"[^>]*>([\s\S]*?)<\/script>/.exec(html);
+  if (!island?.[1]) {
+    return null;
+  }
+  let queries;
+  try {
+    const parsed = JSON.parse(island[1]);
+    queries = parsed.props?.pageProps?.dehydratedState?.queries ?? [];
+  } catch {
+    return null;
+  }
+  const tracks = queries.find((query) => query.queryKey?.[0] === "tracks" && query.state?.data?.facets?.fields)?.state?.data;
+  if (!tracks) {
+    return null;
+  }
+  const fields = tracks.facets?.fields;
+  const genres = facetCounts(fields?.genre);
+  const total = genres.reduce((sum, genre) => sum + genre.count, 0);
+  return {
+    genres: genres.map((genre) => ({
+      ...genre,
+      share: total > 0 ? Math.round(genre.count / total * 1000) / 1000 : 0
+    })),
+    subGenres: facetCounts(fields?.sub_genre),
+    topArtists: facetCounts(fields?.artists).slice(0, 15),
+    trackCount: tracks.count ?? total
+  };
+}
+async function gatherBeatport(deps, mb) {
+  if (!mb.label) {
+    return {
+      note: "MusicBrainz label unavailable, so no Beatport link to follow",
+      status: "skipped"
+    };
+  }
+  const labelUrl = beatportLabelUrlFrom(linkOf(mb.label.links, "beatport.com"));
+  if (labelUrl === null) {
+    return { note: "The MusicBrainz label has no Beatport link.", status: "no_link" };
+  }
+  if (deps.scraper === null) {
+    return {
+      note: "Beatport needs Firecrawl: set FIRECRAWL_API_KEY or install the firecrawl CLI.",
+      status: "not_configured"
+    };
+  }
+  const scraper = deps.scraper;
+  const tracksUrl = `${labelUrl}/tracks`;
+  try {
+    const { cached, text } = await fetchEvidenceText(deps.http, "beatport", `SCRAPE ${tracksUrl}`, (signal) => scraper(tracksUrl, signal), (html) => parseBeatportTracksPage(html) !== null);
+    const facts = parseBeatportTracksPage(text);
+    if (facts === null) {
+      return {
+        errors: [
+          {
+            kind: "parse",
+            message: "The Beatport page carried no tracks facet (a missing label or a layout change)",
+            request: tracksUrl
+          }
+        ],
+        status: "error"
+      };
+    }
+    return { cached, data: { ...facts, labelUrl, tracksUrl }, status: "ok" };
+  } catch (error) {
+    return { errors: [failureOf(error, tracksUrl)], status: "error" };
+  }
+}
+async function gatherApple(deps, mb) {
+  if (!mb.releases) {
+    return {
+      note: "MusicBrainz releases unavailable, so no barcodes to look up",
+      status: "skipped"
+    };
+  }
+  const seen = new Set;
+  const targets = mb.releases.releases.filter((release) => {
+    if (!release.barcode || seen.has(release.barcode)) {
+      return false;
+    }
+    seen.add(release.barcode);
+    return true;
+  });
+  if (targets.length === 0) {
+    return { note: "No sampled MusicBrainz release carries a barcode.", status: "no_link" };
+  }
+  const releases = [];
+  const errors = [];
+  let allCached = true;
+  for (const target of targets.slice(0, APPLE_LOOKUPS)) {
+    const barcode = target.barcode ?? "";
+    const url = `https://itunes.apple.com/lookup?upc=${encodeURIComponent(barcode)}&entity=album`;
+    try {
+      const { cached, data } = await fetchEvidenceJson(deps.http, "apple", url);
+      allCached &&= cached;
+      const hit = (data.results ?? []).find((result) => result.wrapperType === "collection");
+      releases.push(hit ? {
+        artistName: hit.artistName,
+        barcode,
+        collectionName: hit.collectionName,
+        copyright: hit.copyright,
+        found: true,
+        mbTitle: target.title,
+        primaryGenreName: hit.primaryGenreName
+      } : { barcode, found: false, mbTitle: target.title });
+    } catch (error) {
+      errors.push(failureOf(error, url));
+    }
+  }
+  const looked = Math.min(targets.length, APPLE_LOOKUPS);
+  return {
+    cached: allCached,
+    data: {
+      found: releases.filter((release) => release.found).length,
+      genres: tally(releases.flatMap((release) => release.primaryGenreName ?? [])),
+      looked,
+      releases
+    },
+    ...errors.length > 0 ? { errors } : {},
+    status: statusFrom(looked, errors.length)
+  };
+}
+function skipped() {
+  return { note: "Not requested (--sources).", status: "skipped" };
+}
+async function resolveTarget(input, deps) {
+  const trimmed = input.trim();
+  if (MBID_PATTERN3.test(trimmed)) {
+    return { input: trimmed, mbLabelId: trimmed.toLowerCase() };
+  }
+  const label = await deps.resolveLabel(trimmed);
+  if (!label.mbLabelId) {
+    throw new Error(`Label '${label.slug}' has no MusicBrainz identity (mb_label_id), so nothing says which same-named label to research. Resolve it by hand first (docs/label-entity.md).`);
+  }
+  return {
+    id: label.id,
+    input: trimmed,
+    mbLabelId: label.mbLabelId.toLowerCase(),
+    name: label.name,
+    seedState: label.seedState,
+    slug: label.slug
+  };
+}
+async function gatherLabelEvidence(input, options, deps) {
+  const label = await resolveTarget(input, deps);
+  const wants = (source) => options.sources.includes(source);
+  const needsMb = wants("musicbrainz") || wants("discogs") || wants("beatport") || wants("apple");
+  const musicbrainz = needsMb ? await gatherMusicBrainz(deps, label.mbLabelId, options) : skipped();
+  const mb = musicbrainz.data ?? {};
+  const [discogs, beatport, apple] = await Promise.all([
+    wants("discogs") ? gatherDiscogs(deps, mb) : Promise.resolve(skipped()),
+    wants("beatport") ? gatherBeatport(deps, mb) : Promise.resolve(skipped()),
+    wants("apple") ? gatherApple(deps, mb) : Promise.resolve(skipped())
+  ]);
+  const sources = { apple, beatport, discogs, musicbrainz };
+  const reports = Object.entries(sources);
+  const errors = reports.flatMap(([source, report]) => (report.errors ?? []).map((failure) => ({ ...failure, source })));
+  const requested = reports.filter(([source]) => wants(source));
+  const answered = requested.filter(([, report]) => ["no_link", "ok", "partial"].includes(report.status));
+  return {
+    errors,
+    fetchedAt: new Date(deps.http.now()).toISOString(),
+    label: { ...label, name: label.name ?? mb.label?.name },
+    ok: answered.length > 0,
+    partial: answered.length < requested.length || errors.length > 0,
+    requests: { cacheHits: deps.http.stats.cacheHits, network: deps.http.stats.requests },
+    sources
+  };
+}
+function firecrawlApiScraper(apiKey, http) {
+  return async (url, signal) => {
+    const response = await http.fetch(FIRECRAWL_SCRAPE_URL, {
+      body: JSON.stringify({ formats: ["rawHtml"], url }),
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      method: "POST",
+      signal
+    });
+    if (!response.ok) {
+      return { headers: response.headers, status: response.status, text: await response.text() };
+    }
+    const payload = await response.json();
+    return {
+      headers: response.headers,
+      status: payload.data?.metadata?.statusCode ?? 200,
+      text: payload.data?.rawHtml ?? ""
+    };
+  };
+}
+function firecrawlCliScraper(binary) {
+  return (url, signal) => new Promise((resolve, reject) => {
+    const child = spawn(binary, ["scrape", "-f", "rawHtml", url], {
+      signal,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const out = [];
+    const err = [];
+    child.stdout.on("data", (chunk) => out.push(chunk));
+    child.stderr.on("data", (chunk) => err.push(chunk));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({
+          headers: { get: () => null },
+          status: 200,
+          text: Buffer.concat(out).toString("utf8")
+        });
+        return;
+      }
+      const tail = Buffer.concat(err).toString("utf8").trim().split(`
+`).slice(-2).join(" ");
+      reject(new Error(`firecrawl CLI exited ${code}: ${tail}`));
+    });
+  });
+}
+function defaultBeatportScraper(env, http) {
+  if (env.firecrawlApiKey) {
+    return firecrawlApiScraper(env.firecrawlApiKey, http);
+  }
+  return env.firecrawlBinary ? firecrawlCliScraper(env.firecrawlBinary) : null;
+}
+async function labelEvidenceCommand(input, options) {
+  const [{ readOptionalEnv }, { resolveLabel }] = await Promise.all([
+    Promise.resolve().then(() => (init_env(), exports_env)),
+    Promise.resolve().then(() => (init_admin_labels3(), exports_admin_labels))
+  ]);
+  const http = createEvidenceHttp({ refresh: options.refresh });
+  const discogsToken = readOptionalEnv("DISCOGS_USER_TOKEN");
+  if (discogsToken) {
+    http.policies = { ...http.policies, discogs: { ...http.policies.discogs, intervalMs: 1100 } };
+  }
+  return gatherLabelEvidence(input, options, {
+    discogsToken,
+    http,
+    resolveLabel,
+    scraper: defaultBeatportScraper({
+      firecrawlApiKey: readOptionalEnv("FIRECRAWL_API_KEY"),
+      firecrawlBinary: Bun.which("firecrawl")
+    }, http)
+  });
+}
+function countLine(counts, limit) {
+  return counts.slice(0, limit).map((entry) => `${entry.name} ${entry.count}`).join(", ");
+}
+function labelEvidenceLines(evidence) {
+  const { apple, beatport, discogs, musicbrainz } = evidence.sources;
+  const mb = musicbrainz.data;
+  const name = evidence.label.name ?? evidence.label.mbLabelId;
+  const lines = [`${name} (${evidence.label.mbLabelId})`];
+  const mbParts = [];
+  if (mb?.label) {
+    mbParts.push([mb.label.type, mb.label.area, mb.label.lifeSpan.begin].filter(Boolean).join(", "));
+  }
+  if (mb?.releases) {
+    const top = mb.releases.firstCreditArtists.slice(0, 6).map((artist) => `${artist.name} ${artist.releases}`).join(", ");
+    mbParts.push(`${mb.releases.releaseCount} releases; first credits: ${top || "none"}`);
+  }
+  if (mb?.census) {
+    mbParts.push(`census ${mb.census.recordingsCounted} recordings over ${mb.census.releasesRead} releases${mb.census.caveat ? ` (${mb.census.caveat})` : ""}`);
+  }
+  lines.push(`  musicbrainz: ${musicbrainz.status}${mbParts.length ? ` — ${mbParts.join("; ")}` : ""}`);
+  const dg = discogs.data;
+  const dgDetail = dg?.styles ? `styles: ${countLine(dg.styles.styles, 6)} (${dg.styles.releasesRead} releases)` : dg?.candidates ? `unverified candidates: ${dg.candidates.map((c) => c.title).join(", ") || "none"}` : discogs.note;
+  lines.push(`  discogs: ${discogs.status}${dgDetail ? ` — ${dgDetail}` : ""}`);
+  const bp = beatport.data;
+  const bpDetail = bp ? `${bp.trackCount} tracks; genres: ${bp.genres.slice(0, 5).map((genre) => `${genre.name} ${Math.round(genre.share * 100)}%`).join(", ")}` : beatport.note;
+  lines.push(`  beatport: ${beatport.status}${bpDetail ? ` — ${bpDetail}` : ""}`);
+  const ap = apple.data;
+  const apDetail = ap ? `${ap.found}/${ap.looked} found; genres: ${countLine(ap.genres, 4) || "none"}` : apple.note;
+  lines.push(`  apple: ${apple.status}${apDetail ? ` — ${apDetail}` : ""}`);
+  for (const failure of evidence.errors) {
+    lines.push(`  ! ${failure.source}: ${failure.message}`);
+  }
+  return lines;
+}
+var MBID_PATTERN3, MB_ROOT = "https://musicbrainz.org/ws/2", DISCOGS_ROOT = "https://api.discogs.com", FIRECRAWL_SCRAPE_URL = "https://api.firecrawl.dev/v2/scrape", VARIOUS_ARTISTS_MBID = "89ad4ac3-39f7-470e-963a-56509c546377", RELEASE_SAMPLE = 12, FIRST_CREDIT_ARTISTS = 25, APPLE_LOOKUPS = 5, DISCOGS_RELEASE_SAMPLE = 8, DISCOGS_STYLE_TARGET = 10, DISCOGS_RELEASE_READS = 8, PROFILE_CHARS = 800, EVIDENCE_SOURCES, MAX_CENSUS_PAGES = 5;
+var init_admin_label_evidence = __esm(() => {
+  init_evidence_http();
+  MBID_PATTERN3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  EVIDENCE_SOURCES = ["musicbrainz", "discogs", "beatport", "apple"];
+});
+
 // src/commands/admin-albums.ts
 async function describeAlbumCommand(slug, options) {
   return adminApiPost(`/api/v1/admin/albums/${encodeURIComponent(slug)}/bio`, buildBioBody2(options));
@@ -23700,8 +25071,28 @@ JSON field reference:
     }
     for (const label of labels) {
       const looked = label.triageCheckedAt ? label.triageVerdict : "never looked";
-      console.log(`${label.slug}  ${label.seedState}  ${looked ?? ""}`.trimEnd());
+      const rules = label.carriesArtistRules ? "  artist rules" : "";
+      console.log(`${label.slug}  ${label.seedState}  ${looked ?? ""}${rules}`.trimEnd());
+    }
+  });
+  labels.command("evidence").description("Gather a label's MusicBrainz, Discogs, Beatport and Apple evidence for triage (cached, rate-limited)").argument("<label>", "The label's MusicBrainz MBID, slug, or lbl_\u2026 id").option("--census", "Also count FIRST credits per recording over the label's releases", false).option("--census-pages <n>", "MusicBrainz pages the census may read, 1-5", "5").option("--sources <list>", "Comma list of musicbrainz,discogs,beatport,apple (default all)").option("--refresh", "Ignore cached responses and fetch fresh", false).option("--json", "Print JSON", false).action(async (input, options) => {
+    await Promise.resolve().then(() => init_admin_label_evidence());
+    const censusPages = parseCensusPages(options.censusPages);
+    const evidence = await labelEvidenceCommand(input, {
+      census: options.census,
+      censusPages,
+      refresh: options.refresh,
+      sources: parseEvidenceSources(options.sources)
+    });
+    if (!evidence.ok) {
+      process.exitCode = 1;
+    }
+    if (options.json) {
+      printJson(evidence);
+      return;
     }
+    console.log(labelEvidenceLines(evidence).join(`
+`));
   });
   labels.command("triage").description("Record what a triage round found for a label (agent; never rules)").argument("<slug>", "The label slug").requiredOption("--payload <file>", "JSON file holding the round's finding for this label").option("--json", "Print JSON", false).action(async (slug, options) => {
     const payload = JSON.parse(readFileSync6(options.payload, "utf8"));
@@ -26691,6 +28082,7 @@ var stringOptions = new Set([
   "--bpm-confidence",
   "--bpm-source",
   "--calls",
+  "--census-pages",
   "--composition",
   "--consumer-digest",
   "--consumer-item-count",
@@ -26769,6 +28161,7 @@ var stringOptions = new Set([
   "--since",
   "--soundcloud-url",
   "--source",
+  "--sources",
   "--status",
   "--stale-before",
   "--stream",