fluncle 0.256.0 → 0.258.0

package/bin/fluncle.mjs

@@ -622,7 +622,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.256.0".trim() ? "0.256.0".trim() : "0.1.0";
+  currentVersion = "0.258.0".trim() ? "0.258.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2335,7 +2335,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.256.0".trim() ? "0.256.0".trim() : "0.1.0";
+  currentVersion2 = "0.258.0".trim() ? "0.258.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -3469,6 +3469,18 @@ var init_src = __esm(() => {
       title: "Freshness tap",
       weights: { status: "hidden" }
     },
+    {
+      exposedContent: [
+        "checks pipeline yield against measured backlog and alerts the operator on sustained stalls"
+      ],
+      kind: "cron",
+      name: "cron.pipeline-watch",
+      operatorNotes: "Every 15m from a host calendar timer. Reads sweep markers and agent-tier status/worklist counters; alerts Discord on incident open, reminders, and recovery. Source: docs/agents/hermes/scripts/pipeline-watch.*.",
+      probeConfig: { cadenceMs: 15 * MINUTE_MS, cronName: "fluncle-pipeline-watch", kind: "cron" },
+      statusDescription: "watches for stalled track processing",
+      title: "Track watch",
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin catalogue rank",
       exposedContent: [
@@ -3699,6 +3711,17 @@ var init_src = __esm(() => {
       title: "Label bios",
       weights: { status: "hidden" }
     },
+    {
+      command: "fluncle admin labels list --seed-state undecided",
+      exposedContent: ["read the undecided crawl-seed pile and report whether a triage round is due"],
+      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}.",
+      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",
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin albums describe --queue",
       exposedContent: [
@@ -4428,6 +4451,7 @@ var SOURCE_LABELS;
 var init_admin_attention = __esm(() => {
   init_api();
   SOURCE_LABELS = {
+    "anchor-failure": "anchor failure",
     "anchor-review": "version check",
     "artist-review": "artist links",
     "attach-cues": "cues",
@@ -10149,85 +10173,756 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// ../../packages/contracts/src/orpc/admin-albums.ts
-var DescribeAlbumBodySchema, describeAlbum, draftAlbumBio, AlbumBioWorkItemSchema, listAlbumsMissingBio, adminAlbumsContract;
-var init_admin_albums = __esm(() => {
+// ../../packages/contracts/src/orpc/admin-catalogue.ts
+var CatalogueLensSchema, CapturePriorityReasonSchema, CatalogueMatchSchema, CatalogueTrackItemSchema, CatalogueSummarySchema, listCatalogueTracks, rankCatalogue, recordDemand, clearWrongAudio, requeueUnmatchedCaptures, requeueAnchor, requeueIsrcRecovery, flagWrongAudio, forceCapture, certifyTrack, setTrackDismissed, CaptureVerifyItemSchema, listUnverifiedCaptures, verifyCapture, CrawlPassSchema, CrawlPhaseInitializationSchema, MAX_CRAWL_PREPARE_LIMIT = 6, CrawlFetchPlanSchema, SuppliedCrawlBodySchema, MAX_CRAWL_COMMIT_BATCH, CRAWL_COMMIT_TOKEN_MAX_BYTES, CRAWL_COMMIT_BATCH_MAX_TOTAL_BYTES, CrawlCommitItemSchema, CrawlCommitReceiptSchema, CrawlPhaseCapabilitiesSchema, CrawlPhaseInputSchema, CrawlPhaseOutputSchema, CrawlStatusSchema, CrawlPipelineSummarySchema, crawlCatalogue, commitCrawlNodes, getCrawlStatus, ANCHOR_CANDIDATE_LIMIT = 100, ANCHOR_ARTIST_LIMIT = 20, ANCHOR_TEXT_MAX = 300, ANCHOR_ISRC_MAX = 64, ANCHOR_ID_MAX = 64, ANCHOR_URL_MAX = 2048, AnchorCandidateSchema, anchorTrack, recordAnchorFailure, DEEZER_CANDIDATE_LIMIT = 5, DEEZER_TEXT_MAX = 300, DEEZER_ISRC_MAX = 64, DEEZER_TRACK_ID_MAX = 32, DeezerIsrcCandidateSchema, resolveAnchor, resolveAnchorReview, setAnchorSearch, setAnchorApify, CaptureBudgetStateSchema, getCaptureBudget, setCaptureBudget, AnchorApifyBudgetSchema, getAnchorApifyBudget, setAnchorApifyBudget, SpotifyAnchorBreakerStateSchema, AnchorRungFlagsSchema, getSpotifyAnchorBreaker, resetSpotifyAnchorBreaker, AppleBreakerStateSchema, resetAppleBreaker, adminCatalogueContract;
+var init_admin_catalogue = __esm(() => {
   init_dist3();
   init_zod();
-  DescribeAlbumBodySchema = looseObject({
-    bio: unknown().optional(),
-    dryRun: unknown().optional(),
-    finalAttempt: boolean2().optional(),
-    promptVersion: number2().int().min(0).optional()
-  });
-  describeAlbum = oc.route({
+  CatalogueLensSchema = _enum(["capture", "dismissed", "ear", "failed", "quarantine", "unmatched"]).meta({ id: "CatalogueLens" });
+  CapturePriorityReasonSchema = object({
+    kind: _enum(["artist", "label", "none", "seed-label", "skipped-label", "unauthorized"]),
+    name: string2().nullable()
+  }).meta({ id: "CapturePriorityReason" });
+  CatalogueMatchSchema = object({
+    artists: array(string2()),
+    logId: string2().nullable(),
+    title: string2(),
+    trackId: string2()
+  }).meta({ id: "CatalogueMatch" });
+  CatalogueTrackItemSchema = object({
+    albumImageUrl: string2().nullable(),
+    appleMusicUrl: string2().nullable(),
+    artists: array(string2()),
+    bpm: number2().nullable(),
+    capturePriority: number2().nullable(),
+    captureReason: CapturePriorityReasonSchema.nullable(),
+    captureStatus: string2().nullable(),
+    captureVerification: string2().nullable(),
+    dismissedAt: string2().nullable(),
+    duplicateOf: CatalogueMatchSchema.nullable(),
+    hasCapturedAudio: boolean2(),
+    hasPreview: boolean2(),
+    isrc: string2().nullable(),
+    key: string2().nullable(),
+    label: string2().nullable(),
+    nearestFinding: CatalogueMatchSchema.nullable(),
+    nearestFindingScore: number2().nullable(),
+    rankedAt: string2().nullable(),
+    releaseDate: string2().nullable(),
+    sourceAudioAttemptedAt: string2().nullable().optional(),
+    spotifyUrl: string2().nullable(),
+    title: string2(),
+    trackId: string2()
+  }).meta({ id: "CatalogueTrackItem" });
+  CatalogueSummarySchema = object({
+    awaitingCapture: number2(),
+    awaitingRank: number2(),
+    dismissed: number2(),
+    quarantined: number2(),
+    ranked: number2(),
+    total: number2()
+  }).meta({ id: "CatalogueSummary" });
+  listCatalogueTracks = oc.route({
+    method: "GET",
+    operationId: "listCatalogueTracks",
+    path: "/admin/catalogue",
+    summary: "The ranked catalogue: closest to a finding (`ear`), or next to capture (`capture`)",
+    tags: ["Admin"]
+  }).input(object({
+    lens: CatalogueLensSchema.default("ear"),
+    limit: number3().int().min(1).max(200).default(50)
+  })).output(object({
+    ok: literal(true),
+    summary: CatalogueSummarySchema,
+    tracks: array(CatalogueTrackItemSchema)
+  }));
+  rankCatalogue = oc.route({
     method: "POST",
-    operationId: "describeAlbum",
-    path: "/admin/albums/{slug}/bio",
-    summary: "Auto-author an album's voiced bio (fills an empty bio only)",
+    operationId: "rankCatalogue",
+    path: "/admin/catalogue/rank",
+    summary: "One tick of the catalogue ranking sweep (nearest finding + capture priority)",
     tags: ["Admin"]
-  }).input(DescribeAlbumBodySchema.extend({ slug: string2() })).output(object({
-    bio: string2(),
-    dryRun: literal(true).optional(),
-    gateBypassed: literal(true).optional(),
+  }).input(object({
+    countRemaining: boolean3().default(false),
+    limit: number3().int().min(1).max(1000).default(250)
+  })).output(object({
     ok: literal(true),
-    skipped: boolean2().optional(),
-    slug: string2(),
-    voiceViolations: array(string2()).optional()
+    summary: object({
+      catalogueDuplicates: number2(),
+      corpus: string2(),
+      embeddedFindings: number2(),
+      findings: number2(),
+      prioritized: number2(),
+      quarantined: number2(),
+      remaining: number2(),
+      scored: number2()
+    }),
+    telescope: union([
+      object({ changed: boolean2(), ok: literal(true), size: number2() }),
+      object({ ok: literal(false), reason: string2() })
+    ]).optional()
   }));
-  draftAlbumBio = oc.route({
-    method: "GET",
-    operationId: "draftAlbumBio",
-    path: "/admin/albums/{slug}/bio-draft",
-    summary: "Assemble a ready-to-author bio prompt for an album (Worker-side grounding)",
+  recordDemand = oc.route({
+    method: "POST",
+    operationId: "recordDemand",
+    path: "/admin/catalogue/demand",
+    summary: "One demand tick: reorder crawl/capture priority from Simple Analytics pageviews",
     tags: ["Admin"]
-  }).input(object({ slug: string2() })).output(object({
-    findingCount: number2(),
-    found: boolean2(),
-    hasFacts: boolean2(),
-    name: string2(),
-    prompt: string2(),
-    promptVersion: number2()
+  }).input(object({})).output(object({
+    ok: literal(true),
+    summary: object({
+      configured: boolean2(),
+      demandedArtists: number2(),
+      demandedLabels: number2(),
+      frontierPromoted: number2(),
+      pagesRead: number2(),
+      totalPageviews: number2(),
+      tracksScored: number2(),
+      unknownSlugs: number2(),
+      window: object({ end: string2(), start: string2() })
+    })
   }));
-  AlbumBioWorkItemSchema = object({ id: string2(), name: string2(), slug: string2() }).meta({ id: "AlbumBioWorkItem" });
-  listAlbumsMissingBio = oc.route({
+  clearWrongAudio = oc.route({
+    method: "POST",
+    operationId: "clearWrongAudio",
+    path: "/admin/catalogue/wrong-audio/clear",
+    summary: "Overrule the wrong-audio quarantine on one catalogue row (operator)",
+    tags: ["Admin"]
+  }).input(object({ trackId: string2().min(1) })).output(object({ cleared: boolean2(), ok: literal(true) }));
+  requeueUnmatchedCaptures = oc.route({
+    method: "POST",
+    operationId: "requeueUnmatchedCaptures",
+    path: "/admin/catalogue/captures/requeue-unmatched",
+    summary: "Re-queue terminal-unmatched catalogue captures after a matcher improvement (operator)",
+    tags: ["Admin"]
+  }).input(object({})).output(object({ ok: literal(true), requeued: number2(), skippedVetoed: number2() }));
+  requeueAnchor = oc.route({
+    method: "POST",
+    operationId: "requeueAnchor",
+    path: "/admin/catalogue/anchor/requeue",
+    summary: "Clear named rows' anchor re-ask backoff or terminal validation error (operator)",
+    tags: ["Admin"]
+  }).input(object({ trackIds: array(string2().min(1)).min(1).max(250) })).output(object({ ok: literal(true), requeued: number2() }));
+  requeueIsrcRecovery = oc.route({
+    method: "POST",
+    operationId: "requeueIsrcRecovery",
+    path: "/admin/catalogue/isrc-recovery/requeue",
+    summary: "Clear Deezer-empty ISRC-recovery stamps from a named window (operator)",
+    tags: ["Admin"]
+  }).input(object({
+    dryRun: boolean2().default(true),
+    since: string2().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z)?$/, "since must be an ISO date (2026-09-09) or instant (2026-09-09T00:00:00.000Z)")
+  })).output(object({
+    dryRun: boolean2(),
+    matched: number2(),
+    ok: literal(true),
+    requeued: number2()
+  }));
+  flagWrongAudio = oc.route({
+    method: "POST",
+    operationId: "flagWrongAudio",
+    path: "/admin/catalogue/wrong-audio/flag",
+    summary: "Flag a finding's captured audio as the wrong recording (operator)",
+    tags: ["Admin"]
+  }).input(object({ trackId: string2().min(1) })).output(object({ flagged: boolean2(), ok: literal(true) }));
+  forceCapture = oc.route({
+    method: "POST",
+    operationId: "forceCapture",
+    path: "/admin/catalogue/force-capture",
+    summary: "Overrule the duplicate veto on one catalogue row so it can be captured (operator)",
+    tags: ["Admin"]
+  }).input(object({ trackId: string2().min(1) })).output(object({ forced: boolean2(), ok: literal(true) }));
+  certifyTrack = oc.route({
+    method: "POST",
+    operationId: "certifyTrack",
+    path: "/admin/catalogue/certify",
+    summary: "Certify an existing catalogue track in place — mint its finding (operator)",
+    tags: ["Admin"]
+  }).input(object({ note: string2().optional(), trackId: string2().min(1) })).output(object({ logId: string2(), ok: literal(true) }));
+  setTrackDismissed = oc.route({
+    method: "PUT",
+    operationId: "setTrackDismissed",
+    path: "/admin/catalogue/dismissed",
+    summary: "Dismiss a catalogue track ('not for me') or restore it (operator)",
+    tags: ["Admin"]
+  }).input(object({ dismissed: boolean2(), trackId: string2().min(1) })).output(object({ changed: boolean2(), ok: literal(true) }));
+  CaptureVerifyItemSchema = object({
+    artists: array(string2()),
+    certified: boolean2(),
+    durationMs: number2(),
+    isrc: string2().nullable(),
+    logId: string2().nullable(),
+    sourceAudioKey: string2(),
+    title: string2(),
+    trackId: string2()
+  }).meta({ id: "CaptureVerifyItem" });
+  listUnverifiedCaptures = oc.route({
     method: "GET",
-    operationId: "listAlbumsMissingBio",
-    path: "/admin/albums/bio-queue",
-    summary: "List albums with findings but no bio yet, oldest first (the bio worklist)",
+    operationId: "listUnverifiedCaptures",
+    path: "/admin/catalogue/captures/unverified",
+    summary: "Captured rows not yet fingerprint-verified against their preview (the backfill worklist)",
     tags: ["Admin"]
-  }).input(object({ limit: string2().optional() })).output(object({ albums: array(AlbumBioWorkItemSchema), ok: literal(true) }));
-  adminAlbumsContract = {
-    describe_album: describeAlbum,
-    draft_album_bio: draftAlbumBio,
-    list_albums_missing_bio: listAlbumsMissingBio
-  };
-});
-
-// ../../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 init_admin_artifacts = __esm(() => {
-  init_dist3();
-  init_zod();
-  ARTIFACT_SUPPORTED_CONTRACTS = [
-    { formatVersion: 1, stream: "device.album", streamVersion: 1 },
-    { formatVersion: 1, stream: "device.artist", streamVersion: 1 },
-    { formatVersion: 1, stream: "device.finding", streamVersion: 1 },
-    { formatVersion: 1, stream: "device.label", streamVersion: 1 },
-    { formatVersion: 1, stream: "device.track", streamVersion: 1 },
-    { formatVersion: 1, stream: "device.track-artist", streamVersion: 1 },
-    { formatVersion: 1, stream: "sonar.track", streamVersion: 1 }
-  ];
-  ArtifactStreamSchema = _enum([
-    "device.album",
-    "device.artist",
-    "device.finding",
-    "device.label",
-    "device.track",
-    "device.track-artist",
-    "sonar.track"
-  ]);
-  ArtifactContractSchema = strictObject({
+  }).input(object({
+    count: boolean3().default(false),
+    limit: number3().int().min(1).max(200).default(50)
+  })).output(object({
+    ok: literal(true),
+    queued: number2().optional(),
+    tracks: array(CaptureVerifyItemSchema)
+  }));
+  verifyCapture = oc.route({
+    method: "POST",
+    operationId: "verifyCapture",
+    path: "/admin/catalogue/captures/verify",
+    summary: "Record a capture's fingerprint verdict against its preview, and route it",
+    tags: ["Admin"]
+  }).input(object({
+    trackId: string2().min(1),
+    verdict: _enum(["match", "mismatch", "no-preview"])
+  })).output(object({
+    action: _enum([
+      "flagged-finding",
+      "not-captured",
+      "operator-verified",
+      "preview-match",
+      "quarantined-catalogue",
+      "unverified"
+    ]),
+    ok: literal(true)
+  }));
+  CrawlPassSchema = object({
+    artistsRearmed: number2().optional(),
+    dryRun: boolean2(),
+    expanded: number2(),
+    failed: number2(),
+    frontierPending: number2(),
+    labelsDiscovered: array(string2()),
+    maxHop: number2(),
+    nodesEnqueued: number2(),
+    rateLimited: boolean2(),
+    releaseDetailsStored: number2().optional(),
+    releasesRearmed: number2(),
+    seeded: number2(),
+    seedsRearmed: number2(),
+    tracksAllowedIn: number2().optional(),
+    tracksFound: number2(),
+    tracksSkipped: number2(),
+    tracksSkippedArtistRule: number2().optional(),
+    tracksSkippedHeld: number2().optional(),
+    tracksSkippedLabelGate: number2().optional(),
+    tracksWritten: number2()
+  }).meta({ id: "CrawlPass" });
+  CrawlPhaseInitializationSchema = object({
+    artistsRearmed: number2(),
+    releasesRearmed: number2(),
+    seeded: number2(),
+    seedsRearmed: number2()
+  });
+  CrawlFetchPlanSchema = discriminatedUnion("kind", [
+    object({ kind: literal("none") }),
+    object({ kind: literal("single"), url: string2().max(2048) }),
+    object({
+      countField: literal("release-count"),
+      kind: literal("tail"),
+      pageSize: number2().int().positive(),
+      pageUrlTemplate: string2().max(2048),
+      probeUrl: string2().max(2048)
+    })
+  ]);
+  SuppliedCrawlBodySchema = object({
+    body: json().optional(),
+    outcome: _enum(["body", "empty", "invalid", "oversize", "throttled"]),
+    url: string2().max(2048)
+  });
+  MAX_CRAWL_COMMIT_BATCH = MAX_CRAWL_PREPARE_LIMIT;
+  CRAWL_COMMIT_TOKEN_MAX_BYTES = 2 * 1024 * 1024;
+  CRAWL_COMMIT_BATCH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+  CrawlCommitItemSchema = strictObject({
+    commitToken: string2().max(CRAWL_COMMIT_TOKEN_MAX_BYTES),
+    operationId: literal("catalogue.crawl"),
+    operationKey: string2().max(128),
+    requestDigest: string2().regex(/^[0-9a-f]{64}$/)
+  });
+  CrawlCommitReceiptSchema = object({
+    elapsedMs: number2().int().min(0).optional(),
+    error: string2().max(500).optional(),
+    operationKey: string2().max(128),
+    outcome: _enum([
+      "committed",
+      "conflict",
+      "failed",
+      "in-progress",
+      "lookup-failed",
+      "rejected",
+      "safely-retryable"
+    ]),
+    replayed: boolean2(),
+    result: json().optional(),
+    resultIdentity: string2().optional(),
+    state: _enum(["accepted", "committed", "rejected"]).optional()
+  }).meta({ id: "CrawlCommitReceipt" });
+  CrawlPhaseCapabilitiesSchema = strictObject({
+    commitBatchLimit: number2().int().min(1).max(MAX_CRAWL_COMMIT_BATCH),
+    commitBatchMaxTotalBytes: number2().int().min(1)
+  });
+  CrawlPhaseInputSchema = discriminatedUnion("phase", [
+    object({ phase: literal("initialize") }),
+    object({
+      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()
+    }),
+    object({
+      phase: literal("fetch"),
+      preparedToken: string2().max(2 * 1024 * 1024),
+      supplied: array(SuppliedCrawlBodySchema).max(2).optional()
+    }),
+    object({
+      commitToken: string2().max(2 * 1024 * 1024),
+      operationId: literal("catalogue.crawl"),
+      operationKey: string2().max(128),
+      phase: literal("commit"),
+      requestDigest: string2().regex(/^[0-9a-f]{64}$/)
+    })
+  ]);
+  CrawlPhaseOutputSchema = discriminatedUnion("phase", [
+    object({
+      initialization: CrawlPhaseInitializationSchema,
+      kind: _enum(["initialized", "unavailable"]),
+      ok: literal(true),
+      phase: literal("initialize")
+    }),
+    object({
+      boxFetch: boolean2(),
+      capabilities: CrawlPhaseCapabilitiesSchema.optional(),
+      frontierPending: number2(),
+      initialization: CrawlPhaseInitializationSchema,
+      items: array(object({
+        fetchPlan: CrawlFetchPlanSchema,
+        nodeId: string2(),
+        nodeKind: _enum(["artist", "label", "release"]).optional(),
+        preparedToken: string2()
+      })).max(MAX_CRAWL_PREPARE_LIMIT),
+      kind: _enum(["drained", "prepared", "unavailable"]),
+      ok: literal(true),
+      phase: literal("prepare"),
+      storableReady: boolean2().nullable().optional()
+    }),
+    object({
+      commitToken: string2(),
+      ok: literal(true),
+      operationId: literal("catalogue.crawl"),
+      operationKey: string2(),
+      phase: literal("fetch"),
+      rateLimited: boolean2().optional(),
+      requestDigest: string2()
+    }),
+    object({
+      ok: literal(true),
+      phase: literal("commit"),
+      receipt: object({
+        outcome: _enum([
+          "committed",
+          "conflict",
+          "in-progress",
+          "lookup-failed",
+          "rejected",
+          "safely-retryable"
+        ]),
+        replayed: boolean2(),
+        result: json().optional(),
+        resultIdentity: string2().optional(),
+        state: _enum(["accepted", "committed", "rejected"]).optional()
+      })
+    })
+  ]);
+  CrawlStatusSchema = object({
+    anchorsPending: number2(),
+    catalogueTracks: number2(),
+    frontier: object({
+      done: number2(),
+      failed: number2(),
+      pending: number2(),
+      skipped: number2()
+    }),
+    frontierByKind: object({
+      artist: number2(),
+      label: number2(),
+      release: number2()
+    }),
+    labelsUndecided: number2(),
+    seedLabels: array(string2()),
+    storablePending: number2(),
+    undecidedLabelsQueued: number2(),
+    unstorablePending: number2()
+  }).meta({ id: "CrawlStatus" });
+  CrawlPipelineSummarySchema = object({
+    anchorsPending: number2(),
+    frontier: object({ pending: number2() }),
+    storablePending: number2(),
+    summary: literal(true),
+    unstorablePending: number2()
+  }).meta({ id: "CrawlPipelineSummary" });
+  crawlCatalogue = oc.route({
+    inputStructure: "detailed",
+    method: "POST",
+    operationId: "crawlCatalogue",
+    path: "/admin/catalogue/crawl",
+    summary: "Run one bounded, resumable pass of the catalogue crawler",
+    tags: ["Admin"]
+  }).input(object({
+    body: CrawlPhaseInputSchema.optional(),
+    query: object({
+      dryRun: string2().optional(),
+      limit: string2().optional(),
+      maxHop: string2().optional()
+    })
+  })).output(union([CrawlPassSchema.extend({ ok: literal(true) }), CrawlPhaseOutputSchema]));
+  commitCrawlNodes = oc.route({
+    method: "POST",
+    operationId: "commitCrawlNodes",
+    path: "/admin/catalogue/crawl/commits",
+    summary: "Commit one claim's fetched crawl nodes in a single admitted phase",
+    tags: ["Admin"]
+  }).input(strictObject({
+    items: array(CrawlCommitItemSchema).min(1).max(MAX_CRAWL_COMMIT_BATCH)
+  })).output(strictObject({
+    deferred: number2().int().min(0),
+    ok: literal(true),
+    receipts: array(CrawlCommitReceiptSchema).max(MAX_CRAWL_COMMIT_BATCH)
+  }));
+  getCrawlStatus = oc.route({
+    method: "GET",
+    operationId: "getCrawlStatus",
+    path: "/admin/catalogue/crawl",
+    summary: "The crawl frontier's state, the catalogue size, and the seed set",
+    tags: ["Admin"]
+  }).input(object({ summary: string2().optional() })).output(union([
+    CrawlStatusSchema.extend({ ok: literal(true) }),
+    CrawlPipelineSummarySchema.extend({ ok: literal(true) })
+  ]));
+  AnchorCandidateSchema = object({
+    albumImageUrl: string2().max(ANCHOR_URL_MAX).nullish(),
+    artists: array(object({
+      id: string2().max(ANCHOR_ID_MAX).nullish(),
+      name: string2().max(ANCHOR_TEXT_MAX)
+    })).max(ANCHOR_ARTIST_LIMIT).default([]),
+    durationMs: number2().nullish(),
+    isrc: string2().max(ANCHOR_ISRC_MAX).nullish(),
+    spotifyTrackId: string2().max(ANCHOR_ID_MAX).optional(),
+    title: string2().max(ANCHOR_TEXT_MAX).default(""),
+    uri: string2().max(ANCHOR_URL_MAX).optional(),
+    url: string2().max(ANCHOR_URL_MAX).optional()
+  }).refine((candidate) => Boolean(candidate.spotifyTrackId ?? candidate.uri ?? candidate.url), {
+    error: "a candidate must carry a spotifyTrackId, uri, or url"
+  }).meta({ id: "AnchorCandidate" });
+  anchorTrack = oc.route({
+    method: "POST",
+    operationId: "anchorTrack",
+    path: "/admin/catalogue/anchor",
+    summary: "Verify box-supplied Spotify candidates against a catalogue row and write its anchor",
+    tags: ["Admin"]
+  }).input(object({
+    candidates: array(AnchorCandidateSchema).max(ANCHOR_CANDIDATE_LIMIT).default([]),
+    trackId: string2().min(1)
+  })).output(object({
+    anchored: boolean2(),
+    ok: literal(true),
+    verifiedBy: _enum(["isrc", "search", "search-subset"]).nullable()
+  }));
+  recordAnchorFailure = oc.route({
+    method: "POST",
+    operationId: "recordAnchorFailure",
+    path: "/admin/catalogue/anchor/failure",
+    summary: "Record a deterministic anchor candidate rejection",
+    tags: ["Admin"]
+  }).input(object({ status: union([literal(400), literal(422)]), trackId: string2().min(1) })).output(object({ attempts: number2().int(), ok: literal(true), terminal: boolean2() }));
+  DeezerIsrcCandidateSchema = object({
+    artistName: string2().max(DEEZER_TEXT_MAX),
+    deezerTrackId: string2().max(DEEZER_TRACK_ID_MAX).optional(),
+    durationMs: number2().positive().finite(),
+    isrc: string2().max(DEEZER_ISRC_MAX),
+    title: string2().max(DEEZER_TEXT_MAX)
+  }).meta({ id: "DeezerIsrcCandidate" });
+  resolveAnchor = oc.route({
+    method: "POST",
+    operationId: "resolveAnchor",
+    path: "/admin/catalogue/anchor/resolve",
+    summary: "Resolve a catalogue row's Spotify anchor from the free rungs (ListenBrainz + dark Spotify search)",
+    tags: ["Admin"]
+  }).input(object({
+    deezerCandidates: array(DeezerIsrcCandidateSchema).max(DEEZER_CANDIDATE_LIMIT).optional(),
+    spotifySearch: boolean2().optional(),
+    trackId: string2().min(1)
+  })).output(object({
+    anchored: boolean2(),
+    apifyBudgetRemaining: number2().int().nonnegative(),
+    apifyEligible: boolean2(),
+    apifyEnabled: boolean2(),
+    apifyIneligibleReason: _enum(["apify_budget_spent", "awaiting_free_ask"]).nullable(),
+    freeDurationMsOmitted: number2().int().nonnegative(),
+    isrcRecoveredByDeezer: boolean2(),
+    listenbrainzOutcome: _enum([
+      "anchored",
+      "empty-ids",
+      "gate-rejected",
+      "metadata-failed",
+      "no-map",
+      "no-mbid",
+      "not-attempted",
+      "request-failed",
+      "yielded-on-breaker"
+    ]),
+    ok: literal(true),
+    source: _enum(["listenbrainz", "spotify-isrc", "spotify-search"]).nullable(),
+    spotifyIsrcAsked: boolean2(),
+    spotifySearchDone: boolean2(),
+    spotifySearchEnabled: boolean2(),
+    spotifyThrottled: boolean2(),
+    stamped: boolean2(),
+    verifiedBy: _enum(["isrc", "search", "search-subset"]).nullable()
+  }));
+  resolveAnchorReview = oc.route({
+    method: "POST",
+    operationId: "resolveAnchorReview",
+    path: "/admin/catalogue/anchor/reviews/{trackId}/resolve",
+    summary: "Rule on a suspected version mismatch: anchor to the candidate, or dismiss (operator)",
+    tags: ["Admin"]
+  }).input(object({
+    resolution: _enum(["accepted", "dismissed"]),
+    trackId: string2().min(1)
+  })).output(object({
+    anchored: boolean2(),
+    ok: literal(true),
+    review: object({
+      candidateTitle: string2(),
+      spotifyTrackId: string2().optional()
+    })
+  }));
+  setAnchorSearch = oc.route({
+    method: "PUT",
+    operationId: "setAnchorSearch",
+    path: "/admin/catalogue/anchor/search",
+    summary: "Flip the dark flag for the Spotify anchor-search rungs (operator)",
+    tags: ["Admin"]
+  }).input(object({ enabled: boolean2() })).output(object({ enabled: boolean2(), ok: literal(true) }));
+  setAnchorApify = oc.route({
+    method: "PUT",
+    operationId: "setAnchorApify",
+    path: "/admin/catalogue/anchor/apify",
+    summary: "Flip the Apify anchor-fallback kill-flag — off = no-budget graceful state (operator)",
+    tags: ["Admin"]
+  }).input(object({ enabled: boolean2() })).output(object({ enabled: boolean2(), ok: literal(true), requeued: number2() }));
+  CaptureBudgetStateSchema = object({
+    budget: object({ dailyBytes: number2(), dailyTracks: number2() }),
+    closedReason: _enum(["bytes_spent", "paused", "tracks_spent"]).nullable(),
+    open: boolean2(),
+    paused: boolean2(),
+    remainingBytes: number2(),
+    remainingTracks: number2(),
+    spend: object({ bytes: number2(), tracks: number2() }),
+    windowHours: number2()
+  }).meta({ id: "CaptureBudgetState" });
+  getCaptureBudget = oc.route({
+    method: "GET",
+    operationId: "getCaptureBudget",
+    path: "/admin/catalogue/capture-budget",
+    summary: "The catalogue capture budget: the switch, the caps, the 24h spend, what is left",
+    tags: ["Admin"]
+  }).input(object({})).output(CaptureBudgetStateSchema.extend({ ok: literal(true) }));
+  setCaptureBudget = oc.route({
+    method: "PUT",
+    operationId: "setCaptureBudget",
+    path: "/admin/catalogue/capture-budget",
+    summary: "Set the catalogue capture budget / flip its kill switch (operator)",
+    tags: ["Admin"]
+  }).input(object({
+    dailyBytes: number2().int().min(0).optional(),
+    dailyTracks: number2().int().min(0).optional(),
+    paused: boolean2().optional()
+  })).output(CaptureBudgetStateSchema.extend({ ok: literal(true) }));
+  AnchorApifyBudgetSchema = object({
+    dailyRows: number2(),
+    day: string2(),
+    remainingRows: number2(),
+    rowsSent: number2(),
+    spent: boolean2()
+  }).meta({ id: "AnchorApifyBudget" });
+  getAnchorApifyBudget = oc.route({
+    method: "GET",
+    operationId: "getAnchorApifyBudget",
+    path: "/admin/catalogue/anchor/apify-budget",
+    summary: "The metered Apify anchor rung's daily row cap, today's spend, and what is left",
+    tags: ["Admin"]
+  }).input(object({})).output(AnchorApifyBudgetSchema.extend({ ok: literal(true) }));
+  setAnchorApifyBudget = oc.route({
+    method: "PUT",
+    operationId: "setAnchorApifyBudget",
+    path: "/admin/catalogue/anchor/apify-budget",
+    summary: "Set the metered Apify anchor rung's daily row cap (operator)",
+    tags: ["Admin"]
+  }).input(object({ dailyRows: number2().int().min(0) })).output(AnchorApifyBudgetSchema.extend({ ok: literal(true) }));
+  SpotifyAnchorBreakerStateSchema = object({
+    cooldownRemainingMs: number2(),
+    reason: string2().nullable(),
+    throttlesInWindow: number2(),
+    tripped: boolean2(),
+    trippedAt: string2().nullable()
+  }).meta({ id: "SpotifyAnchorBreakerState" });
+  AnchorRungFlagsSchema = object({
+    apifyBudget: AnchorApifyBudgetSchema,
+    apifyEnabled: boolean2(),
+    gateReason: _enum([
+      "friday_window",
+      "flag_off",
+      "breaker_quota",
+      "breaker_throttle",
+      "shared_meter",
+      "open"
+    ]),
+    nextEligibleAt: string2().nullable(),
+    spotifySearchEnabled: boolean2()
+  }).meta({ id: "AnchorRungFlags" });
+  getSpotifyAnchorBreaker = oc.route({
+    method: "GET",
+    operationId: "getSpotifyAnchorBreaker",
+    path: "/admin/catalogue/anchor/breaker",
+    summary: "The Spotify anchor-search throttle breaker: tripped, why, how long left, and the rungs",
+    tags: ["Admin"]
+  }).input(object({})).output(SpotifyAnchorBreakerStateSchema.extend({ ok: literal(true), rungs: AnchorRungFlagsSchema }));
+  resetSpotifyAnchorBreaker = oc.route({
+    method: "POST",
+    operationId: "resetSpotifyAnchorBreaker",
+    path: "/admin/catalogue/anchor/breaker/reset",
+    summary: "Clear the Spotify anchor-search throttle breaker (operator)",
+    tags: ["Admin"]
+  }).input(object({})).output(SpotifyAnchorBreakerStateSchema.extend({ ok: literal(true) }));
+  AppleBreakerStateSchema = object({
+    consecutiveAuthFailures: number2(),
+    cooldownRemainingMs: number2(),
+    tripped: boolean2(),
+    trippedAt: string2().nullable()
+  }).meta({ id: "AppleBreakerState" });
+  resetAppleBreaker = oc.route({
+    method: "POST",
+    operationId: "resetAppleBreaker",
+    path: "/admin/catalogue/apple-breaker/reset",
+    summary: "Clear the Apple failure-regime breaker (operator)",
+    tags: ["Admin"]
+  }).input(object({})).output(AppleBreakerStateSchema.extend({ ok: literal(true) }));
+  adminCatalogueContract = {
+    anchor_track: anchorTrack,
+    certify_track: certifyTrack,
+    clear_wrong_audio: clearWrongAudio,
+    commit_crawl_nodes: commitCrawlNodes,
+    crawl_catalogue: crawlCatalogue,
+    flag_wrong_audio: flagWrongAudio,
+    force_capture: forceCapture,
+    get_anchor_apify_budget: getAnchorApifyBudget,
+    get_capture_budget: getCaptureBudget,
+    get_crawl_status: getCrawlStatus,
+    get_spotify_anchor_breaker: getSpotifyAnchorBreaker,
+    list_catalogue_tracks: listCatalogueTracks,
+    list_unverified_captures: listUnverifiedCaptures,
+    rank_catalogue: rankCatalogue,
+    record_anchor_failure: recordAnchorFailure,
+    record_demand: recordDemand,
+    requeue_anchor: requeueAnchor,
+    requeue_isrc_recovery: requeueIsrcRecovery,
+    requeue_unmatched_captures: requeueUnmatchedCaptures,
+    reset_apple_breaker: resetAppleBreaker,
+    reset_spotify_anchor_breaker: resetSpotifyAnchorBreaker,
+    resolve_anchor: resolveAnchor,
+    resolve_anchor_review: resolveAnchorReview,
+    set_anchor_apify: setAnchorApify,
+    set_anchor_apify_budget: setAnchorApifyBudget,
+    set_anchor_search: setAnchorSearch,
+    set_capture_budget: setCaptureBudget,
+    set_track_dismissed: setTrackDismissed,
+    verify_capture: verifyCapture
+  };
+});
+
+// ../../packages/contracts/src/orpc/admin-albums.ts
+var DescribeAlbumBodySchema, describeAlbum, draftAlbumBio, AlbumBioWorkItemSchema, listAlbumsMissingBio, adminAlbumsContract;
+var init_admin_albums = __esm(() => {
+  init_dist3();
+  init_zod();
+  DescribeAlbumBodySchema = looseObject({
+    bio: unknown().optional(),
+    dryRun: unknown().optional(),
+    finalAttempt: boolean2().optional(),
+    promptVersion: number2().int().min(0).optional()
+  });
+  describeAlbum = oc.route({
+    method: "POST",
+    operationId: "describeAlbum",
+    path: "/admin/albums/{slug}/bio",
+    summary: "Auto-author an album's voiced bio (fills an empty bio only)",
+    tags: ["Admin"]
+  }).input(DescribeAlbumBodySchema.extend({ slug: string2() })).output(object({
+    bio: string2(),
+    dryRun: literal(true).optional(),
+    gateBypassed: literal(true).optional(),
+    ok: literal(true),
+    skipped: boolean2().optional(),
+    slug: string2(),
+    voiceViolations: array(string2()).optional()
+  }));
+  draftAlbumBio = oc.route({
+    method: "GET",
+    operationId: "draftAlbumBio",
+    path: "/admin/albums/{slug}/bio-draft",
+    summary: "Assemble a ready-to-author bio prompt for an album (Worker-side grounding)",
+    tags: ["Admin"]
+  }).input(object({ slug: string2() })).output(object({
+    findingCount: number2(),
+    found: boolean2(),
+    hasFacts: boolean2(),
+    name: string2(),
+    prompt: string2(),
+    promptVersion: number2()
+  }));
+  AlbumBioWorkItemSchema = object({ id: string2(), name: string2(), slug: string2() }).meta({ id: "AlbumBioWorkItem" });
+  listAlbumsMissingBio = oc.route({
+    method: "GET",
+    operationId: "listAlbumsMissingBio",
+    path: "/admin/albums/bio-queue",
+    summary: "List albums with findings but no bio yet, oldest first (the bio worklist)",
+    tags: ["Admin"]
+  }).input(object({ limit: string2().optional() })).output(object({ albums: array(AlbumBioWorkItemSchema), ok: literal(true) }));
+  adminAlbumsContract = {
+    describe_album: describeAlbum,
+    draft_album_bio: draftAlbumBio,
+    list_albums_missing_bio: listAlbumsMissingBio
+  };
+});
+
+// ../../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 init_admin_artifacts = __esm(() => {
+  init_dist3();
+  init_zod();
+  ARTIFACT_SUPPORTED_CONTRACTS = [
+    { formatVersion: 1, stream: "device.album", streamVersion: 1 },
+    { formatVersion: 1, stream: "device.artist", streamVersion: 1 },
+    { formatVersion: 1, stream: "device.finding", streamVersion: 1 },
+    { formatVersion: 1, stream: "device.label", streamVersion: 1 },
+    { formatVersion: 1, stream: "device.track", streamVersion: 1 },
+    { formatVersion: 1, stream: "device.track-artist", streamVersion: 1 },
+    { formatVersion: 1, stream: "sonar.track", streamVersion: 1 }
+  ];
+  ArtifactStreamSchema = _enum([
+    "device.album",
+    "device.artist",
+    "device.finding",
+    "device.label",
+    "device.track",
+    "device.track-artist",
+    "sonar.track"
+  ]);
+  ArtifactContractSchema = strictObject({
     formatVersion: number2().int().positive(),
     stream: ArtifactStreamSchema,
     streamVersion: number2().int().positive()
@@ -10764,6 +11459,7 @@ var init_admin_attention2 = __esm(() => {
   init_dist3();
   init_zod();
   AttentionSourceSchema = _enum([
+    "anchor-failure",
     "anchor-review",
     "artist-review",
     "attach-cues",
@@ -10899,458 +11595,125 @@ var init_admin_backfills = __esm(() => {
       context.addIssue({
         code: "custom",
         message: "Discogs label detail id must match its work id"
-      });
-    }
-  }).meta({ id: "DiscogsLabelCandidate" });
-  DiscogsLabelCandidateBatchSchema = array(DiscogsLabelCandidateSchema).max(DISCOGS_LABEL_WORK_LIMIT).superRefine((entries, context) => {
-    const slugs = new Set;
-    const base64Chars = entries.reduce((total, entry) => total + (entry.image?.bytesBase64.length ?? 0), 0);
-    if (base64Chars > MAX_LABEL_IMAGE_BASE64_CHARS * DISCOGS_LABEL_WORK_LIMIT) {
-      context.addIssue({
-        code: "custom",
-        message: "Discogs label-image candidate batch exceeds its decoded-image budget"
-      });
-    }
-    for (const entry of entries) {
-      if (slugs.has(entry.slug)) {
-        context.addIssue({
-          code: "custom",
-          message: "Discogs label candidate slugs must be unique"
-        });
-        return;
-      }
-      slugs.add(entry.slug);
-    }
-  });
-  DiscogsLabelWorkSchema = object({
-    discogsLabelId: DiscogsIdSchema,
-    slug: string2().min(1).max(DISCOGS_TEXT_MAX)
-  }).meta({ id: "DiscogsLabelWork" });
-  DiscogsResolvedSchema = object({
-    logId: string2(),
-    masterId: number2().optional(),
-    releaseId: number2(),
-    source: string2()
-  }).meta({ id: "DiscogsBackfillResolved" });
-  LastfmFailedSchema = object({
-    error: string2(),
-    logId: string2()
-  }).meta({ id: "LastfmBackfillFailed" });
-  AppleMusicResolvedSchema = object({
-    logId: string2(),
-    url: string2()
-  }).meta({ id: "AppleMusicBackfillResolved" });
-  AppleMusicFailedSchema = object({
-    error: string2(),
-    logId: string2()
-  }).meta({ id: "AppleMusicBackfillFailed" });
-  backfillDiscogs = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillDiscogs",
-    path: "/admin/backfill/discogs",
-    summary: "Back-fill Discogs release ids over published findings (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    body: object({
-      discogsCandidates: DiscogsReleaseCandidateBatchSchema.optional()
-    }).optional(),
-    query: object({
-      boxFetch: string2().optional(),
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    discogsWork: array(DiscogsReleaseWorkSchema).max(DISCOGS_RELEASE_WORK_LIMIT),
-    dryRun: boolean2(),
-    nextCursor: string2().nullable(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    rateLimitedBy: _enum(["discogs", "musicbrainz"]).nullable(),
-    resolved: array(DiscogsResolvedSchema),
-    resolvedCount: number2(),
-    skipped: array(string2()),
-    skippedCount: number2(),
-    unresolved: array(string2()),
-    unresolvedCount: number2()
-  }));
-  DiscogsFactsResolvedSchema = object({
-    catno: string2(),
-    slug: string2()
-  }).meta({ id: "DiscogsFactsResolved" });
-  DiscogsFactsFailedSchema = object({
-    error: string2(),
-    slug: string2()
-  }).meta({ id: "DiscogsFactsFailed" });
-  backfillDiscogsFacts = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillDiscogsFacts",
-    path: "/admin/backfill/discogs-facts",
-    summary: "Back-fill album catalogue numbers + styles from already-resolved Discogs releases",
-    tags: ["Admin"]
-  }).input(object({
-    body: object({
-      discogsCandidates: DiscogsFactsCandidateBatchSchema.optional()
-    }).optional(),
-    query: object({
-      boxFetch: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    configured: boolean2(),
-    discogsWork: array(DiscogsFactsWorkSchema).max(DISCOGS_FACTS_WORK_LIMIT),
-    dryRun: boolean2(),
-    failed: array(DiscogsFactsFailedSchema),
-    failedCount: number2(),
-    none: array(string2()),
-    noneCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(DiscogsFactsResolvedSchema),
-    resolvedCount: number2()
-  }));
-  backfillLastfm = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillLastfm",
-    path: "/admin/backfill/lastfm",
-    summary: "Back-fill Last.fm loves over published findings (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    dryRun: boolean2(),
-    failed: array(LastfmFailedSchema),
-    failedCount: number2(),
-    loved: array(string2()),
-    lovedCount: number2(),
-    nextCursor: string2().nullable(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    skipped: array(string2()),
-    skippedCount: number2()
-  }));
-  backfillAppleMusic = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillAppleMusic",
-    path: "/admin/backfill/apple-music",
-    summary: "Back-fill Apple Music URLs over published findings by exact ISRC (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    albumFactsWritten: number2(),
-    breakerTripped: boolean2(),
-    configured: boolean2(),
-    dryRun: boolean2(),
-    failed: array(AppleMusicFailedSchema),
-    failedCount: number2(),
-    nextCursor: string2().nullable(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(AppleMusicResolvedSchema),
-    resolvedCount: number2(),
-    skipped: array(string2()),
-    skippedCount: number2(),
-    unresolved: array(string2()),
-    unresolvedCount: number2()
-  }));
-  AppleCatalogueResolvedSchema = object({
-    trackId: string2(),
-    url: string2()
-  }).meta({ id: "AppleCatalogueResolved" });
-  AppleCatalogueFailedSchema = object({
-    error: string2(),
-    trackId: string2()
-  }).meta({ id: "AppleCatalogueFailed" });
-  backfillAppleCatalogue = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillAppleCatalogue",
-    path: "/admin/backfill/apple-catalogue",
-    summary: "Back-fill Apple URLs + album facts over catalogue tracks by exact ISRC (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    albumFactsWritten: number2(),
-    breakerTripped: boolean2(),
-    configured: boolean2(),
-    dryRun: boolean2(),
-    failed: array(AppleCatalogueFailedSchema),
-    failedCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(AppleCatalogueResolvedSchema),
-    resolvedCount: number2(),
-    unresolved: array(string2()),
-    unresolvedCount: number2()
-  }));
-  BeatportResolvedSchema = object({
+      });
+    }
+  }).meta({ id: "DiscogsLabelCandidate" });
+  DiscogsLabelCandidateBatchSchema = array(DiscogsLabelCandidateSchema).max(DISCOGS_LABEL_WORK_LIMIT).superRefine((entries, context) => {
+    const slugs = new Set;
+    const base64Chars = entries.reduce((total, entry) => total + (entry.image?.bytesBase64.length ?? 0), 0);
+    if (base64Chars > MAX_LABEL_IMAGE_BASE64_CHARS * DISCOGS_LABEL_WORK_LIMIT) {
+      context.addIssue({
+        code: "custom",
+        message: "Discogs label-image candidate batch exceeds its decoded-image budget"
+      });
+    }
+    for (const entry of entries) {
+      if (slugs.has(entry.slug)) {
+        context.addIssue({
+          code: "custom",
+          message: "Discogs label candidate slugs must be unique"
+        });
+        return;
+      }
+      slugs.add(entry.slug);
+    }
+  });
+  DiscogsLabelWorkSchema = object({
+    discogsLabelId: DiscogsIdSchema,
+    slug: string2().min(1).max(DISCOGS_TEXT_MAX)
+  }).meta({ id: "DiscogsLabelWork" });
+  DiscogsResolvedSchema = object({
     logId: string2(),
-    url: string2()
-  }).meta({ id: "BeatportResolved" });
-  BeatportFailedSchema = object({
+    masterId: number2().optional(),
+    releaseId: number2(),
+    source: string2()
+  }).meta({ id: "DiscogsBackfillResolved" });
+  LastfmFailedSchema = object({
     error: string2(),
     logId: string2()
-  }).meta({ id: "BeatportFailed" });
-  BeatportCatalogueResolvedSchema = object({
-    trackId: string2(),
+  }).meta({ id: "LastfmBackfillFailed" });
+  AppleMusicResolvedSchema = object({
+    logId: string2(),
     url: string2()
-  }).meta({ id: "BeatportCatalogueResolved" });
-  BeatportCatalogueFailedSchema = object({
+  }).meta({ id: "AppleMusicBackfillResolved" });
+  AppleMusicFailedSchema = object({
     error: string2(),
-    trackId: string2()
-  }).meta({ id: "BeatportCatalogueFailed" });
-  backfillBeatport = oc.route({
+    logId: string2()
+  }).meta({ id: "AppleMusicBackfillFailed" });
+  backfillDiscogs = oc.route({
     inputStructure: "detailed",
     method: "POST",
-    operationId: "backfillBeatport",
-    path: "/admin/backfill/beatport",
-    summary: "Back-fill Beatport URLs over published findings by exact ISRC",
+    operationId: "backfillDiscogs",
+    path: "/admin/backfill/discogs",
+    summary: "Back-fill Discogs release ids over published findings (batched)",
     tags: ["Admin"]
   }).input(object({
+    body: object({
+      discogsCandidates: DiscogsReleaseCandidateBatchSchema.optional()
+    }).optional(),
     query: object({
+      boxFetch: string2().optional(),
       cursor: string2().optional(),
       dryRun: string2().optional(),
       limit: string2().optional()
     })
   })).output(object({
-    catalogueFailed: array(BeatportCatalogueFailedSchema),
-    catalogueFailedCount: number2(),
-    catalogueResolved: array(BeatportCatalogueResolvedSchema),
-    catalogueResolvedCount: number2(),
-    catalogueUnresolved: array(string2()),
-    catalogueUnresolvedCount: number2(),
-    configured: boolean2(),
+    discogsWork: array(DiscogsReleaseWorkSchema).max(DISCOGS_RELEASE_WORK_LIMIT),
     dryRun: boolean2(),
-    failed: array(BeatportFailedSchema),
-    failedCount: number2(),
     nextCursor: string2().nullable(),
     ok: literal(true),
-    resolved: array(BeatportResolvedSchema),
+    rateLimited: boolean2(),
+    rateLimitedBy: _enum(["discogs", "musicbrainz"]).nullable(),
+    resolved: array(DiscogsResolvedSchema),
     resolvedCount: number2(),
     skipped: array(string2()),
     skippedCount: number2(),
     unresolved: array(string2()),
     unresolvedCount: number2()
   }));
-  DeezerResolvedSchema = object({
-    trackId: string2(),
-    url: string2()
-  }).meta({ id: "DeezerResolved" });
-  DeezerFailedSchema = object({
-    error: string2(),
-    trackId: string2()
-  }).meta({ id: "DeezerFailed" });
-  backfillDeezer = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillDeezer",
-    path: "/admin/backfill/deezer",
-    summary: "Back-fill Deezer track ids over certified + catalogue rows by exact ISRC",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    dryRun: boolean2(),
-    failed: array(DeezerFailedSchema),
-    failedCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(DeezerResolvedSchema),
-    resolvedCount: number2(),
-    unresolved: array(string2()),
-    unresolvedCount: number2(),
-    unvouchable: array(string2()),
-    unvouchableCount: number2()
-  }));
-  backfillLabelReleases = oc.route({
-    method: "POST",
-    operationId: "backfillLabelReleases",
-    path: "/admin/backfill/label-releases",
-    summary: "Tap Spotify's fresh releases for enabled seed labels into catalogue rows (bounded)",
-    tags: ["Admin"]
-  }).input(object({
-    dryRun: boolean2().default(false),
-    limit: number3().int().min(1).max(200).default(5)
-  })).output(object({
-    albumsMatched: number2(),
-    albumsSeen: number2(),
-    budgetPaused: boolean2(),
-    configured: boolean2(),
-    dryRun: boolean2(),
-    failedFetches: number2(),
-    failedLabels: array(string2()),
-    fetchCeilingHit: boolean2(),
-    labelSlugs: array(string2()),
-    labelsProbed: number2(),
-    newRows: number2(),
-    newTrackIds: array(string2()),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    skippedKnown: number2(),
-    skippedUndated: number2(),
-    skippedUngrounded: number2(),
-    tracksSkippedArtistRule: number2().optional()
-  }));
-  LabelImagesBackfillFailedSchema = object({
+  DiscogsFactsResolvedSchema = object({
+    catno: string2(),
+    slug: string2()
+  }).meta({ id: "DiscogsFactsResolved" });
+  DiscogsFactsFailedSchema = object({
     error: string2(),
     slug: string2()
-  }).meta({ id: "LabelImagesBackfillFailed" });
-  backfillLabelImages = oc.route({
+  }).meta({ id: "DiscogsFactsFailed" });
+  backfillDiscogsFacts = oc.route({
     inputStructure: "detailed",
     method: "POST",
-    operationId: "backfillLabelImages",
-    path: "/admin/backfill/label-images",
-    summary: "Resolve label logos (Discogs → Wikidata) into R2 for existing labels (batched)",
+    operationId: "backfillDiscogsFacts",
+    path: "/admin/backfill/discogs-facts",
+    summary: "Back-fill album catalogue numbers + styles from already-resolved Discogs releases",
     tags: ["Admin"]
   }).input(object({
     body: object({
-      discogsCandidates: DiscogsLabelCandidateBatchSchema.optional()
+      discogsCandidates: DiscogsFactsCandidateBatchSchema.optional()
     }).optional(),
     query: object({
       boxFetch: string2().optional(),
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    discogsWork: array(DiscogsLabelWorkSchema).max(DISCOGS_LABEL_WORK_LIMIT),
-    dryRun: boolean2(),
-    failed: array(LabelImagesBackfillFailedSchema),
-    failedCount: number2(),
-    nextCursor: string2().nullable(),
-    none: array(string2()),
-    noneCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(string2()),
-    resolvedCount: number2()
-  }));
-  LabelLineageBackfillFailedSchema = object({
-    error: string2(),
-    slug: string2()
-  }).meta({ id: "LabelLineageBackfillFailed" });
-  backfillLabelLineage = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillLabelLineage",
-    path: "/admin/backfill/label-lineage",
-    summary: "Resolve label lineage (founding date, place, parent imprint) from MusicBrainz (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      limit: string2().optional()
-    })
-  })).output(object({
-    dryRun: boolean2(),
-    failed: array(LabelLineageBackfillFailedSchema),
-    failedCount: number2(),
-    nextCursor: string2().nullable(),
-    none: array(string2()),
-    noneCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    resolved: array(string2()),
-    resolvedCount: number2(),
-    unmatchedParents: number2()
-  }));
-  CoverMastersFailedSchema = object({
-    error: string2(),
-    slug: string2()
-  }).meta({ id: "CoverMastersFailed" });
-  backfillCoverMasters = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillCoverMasters",
-    path: "/admin/backfill/cover-masters",
-    summary: "Resolve owned ≤1200² cover masters (album/artist) into R2 (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      cursor: string2().optional(),
-      dryRun: string2().optional(),
-      kind: string2().optional(),
-      limit: string2().optional(),
-      retry: string2().optional()
-    })
-  })).output(object({
-    dryRun: boolean2(),
-    failed: array(CoverMastersFailedSchema),
-    failedCount: number2(),
-    kind: _enum(["album", "artist"]),
-    nextCursor: string2().nullable(),
-    none: array(string2()),
-    noneCount: number2(),
-    ok: literal(true),
-    rateLimited: boolean2(),
-    requeued: array(string2()).optional(),
-    requeuedCount: number2().optional(),
-    resolved: array(string2()),
-    resolvedCount: number2()
-  }));
-  RecordingMbidsFailedSchema = object({
-    error: string2(),
-    trackId: string2()
-  }).meta({ id: "RecordingMbidsBackfillFailed" });
-  backfillRecordingMbids = oc.route({
-    inputStructure: "detailed",
-    method: "POST",
-    operationId: "backfillRecordingMbids",
-    path: "/admin/backfill/recording-mbids",
-    summary: "Fill MusicBrainz recording MBIDs (crawler PK strip + ISRC resolve) over tracks (batched)",
-    tags: ["Admin"]
-  }).input(object({
-    query: object({
-      cursor: string2().optional(),
       dryRun: string2().optional(),
-      isrcRefreshLimit: string2().optional(),
       limit: string2().optional()
     })
   })).output(object({
+    configured: boolean2(),
+    discogsWork: array(DiscogsFactsWorkSchema).max(DISCOGS_FACTS_WORK_LIMIT),
     dryRun: boolean2(),
-    failed: array(RecordingMbidsFailedSchema),
+    failed: array(DiscogsFactsFailedSchema),
     failedCount: number2(),
-    isrcRefreshMissed: array(string2()),
-    isrcRefreshMissedCount: number2(),
-    isrcRefreshed: array(string2()),
-    isrcRefreshedCount: number2(),
-    missed: array(string2()),
-    missedCount: number2(),
-    nextCursor: string2().nullable(),
+    none: array(string2()),
+    noneCount: number2(),
     ok: literal(true),
-    prefixStripped: number2(),
     rateLimited: boolean2(),
-    resolved: array(string2()),
+    resolved: array(DiscogsFactsResolvedSchema),
     resolvedCount: number2()
   }));
-  backfillArtistEdges = oc.route({
+  backfillLastfm = oc.route({
     inputStructure: "detailed",
     method: "POST",
-    operationId: "backfillArtistEdges",
-    path: "/admin/backfill/artist-edges",
-    summary: "Fold artists_json names onto existing artist identities → track_artists (batched)",
+    operationId: "backfillLastfm",
+    path: "/admin/backfill/lastfm",
+    summary: "Back-fill Last.fm loves over published findings (batched)",
     tags: ["Admin"]
   }).input(object({
     query: object({
@@ -11360,25 +11723,22 @@ var init_admin_backfills = __esm(() => {
     })
   })).output(object({
     dryRun: boolean2(),
-    edgesWritten: number2(),
-    fullyMatched: array(string2()),
-    fullyMatchedCount: number2(),
+    failed: array(LastfmFailedSchema),
+    failedCount: number2(),
+    loved: array(string2()),
+    lovedCount: number2(),
     nextCursor: string2().nullable(),
     ok: literal(true),
-    partiallyMatched: array(string2()),
-    partiallyMatchedCount: number2(),
-    queueDepth: number2(),
-    scanned: number2(),
-    unmatchedNames: number2(),
-    zeroMatched: array(string2()),
-    zeroMatchedCount: number2()
+    rateLimited: boolean2(),
+    skipped: array(string2()),
+    skippedCount: number2()
   }));
-  backfillArtistCredits = oc.route({
+  backfillAppleMusic = oc.route({
     inputStructure: "detailed",
     method: "POST",
-    operationId: "backfillArtistCredits",
-    path: "/admin/backfill/artist-credits",
-    summary: "Mint identity-true artists from MusicBrainz credits for slice 0's zero-matched residual (batched)",
+    operationId: "backfillAppleMusic",
+    path: "/admin/backfill/apple-music",
+    summary: "Back-fill Apple Music URLs over published findings by exact ISRC (batched)",
     tags: ["Admin"]
   }).input(object({
     query: object({
@@ -11387,699 +11747,395 @@ var init_admin_backfills = __esm(() => {
       limit: string2().optional()
     })
   })).output(object({
-    adoptedArtists: number2(),
+    albumFactsWritten: number2(),
+    breakerTripped: boolean2(),
+    configured: boolean2(),
     dryRun: boolean2(),
-    edgesWritten: number2(),
-    matchedArtists: number2(),
-    mintedArtists: number2(),
+    failed: array(AppleMusicFailedSchema),
+    failedCount: number2(),
     nextCursor: string2().nullable(),
     ok: literal(true),
     rateLimited: boolean2(),
-    scanned: number2(),
-    skippedNoIdentity: number2()
-  }));
-  adminBackfillsContract = {
-    backfill_apple_catalogue: backfillAppleCatalogue,
-    backfill_apple_music: backfillAppleMusic,
-    backfill_artist_credits: backfillArtistCredits,
-    backfill_artist_edges: backfillArtistEdges,
-    backfill_beatport: backfillBeatport,
-    backfill_cover_masters: backfillCoverMasters,
-    backfill_deezer: backfillDeezer,
-    backfill_discogs: backfillDiscogs,
-    backfill_discogs_facts: backfillDiscogsFacts,
-    backfill_label_images: backfillLabelImages,
-    backfill_label_lineage: backfillLabelLineage,
-    backfill_label_releases: backfillLabelReleases,
-    backfill_lastfm: backfillLastfm,
-    backfill_recording_mbids: backfillRecordingMbids
-  };
-});
-
-// ../../packages/contracts/src/orpc/admin-bios.ts
-var BioEntityKindSchema, resolveBioReview, adminBiosContract;
-var init_admin_bios = __esm(() => {
-  init_dist3();
-  init_zod();
-  BioEntityKindSchema = _enum(["album", "artist", "label"]).meta({ id: "BioEntityKind" });
-  resolveBioReview = oc.route({
-    method: "POST",
-    operationId: "resolveBioReview",
-    path: "/admin/bio-reviews/{kind}/{slug}/resolve",
-    summary: "Rule on a bio that landed past the voice gate: keep it or send it back (operator)",
-    tags: ["Admin"]
-  }).input(object({
-    kind: BioEntityKindSchema,
-    resolution: _enum(["keep", "rewrite"]),
-    slug: string2()
-  })).output(object({
-    kind: BioEntityKindSchema,
-    ok: literal(true),
-    resolution: _enum(["keep", "rewrite"]),
-    slug: string2()
+    resolved: array(AppleMusicResolvedSchema),
+    resolvedCount: number2(),
+    skipped: array(string2()),
+    skippedCount: number2(),
+    unresolved: array(string2()),
+    unresolvedCount: number2()
   }));
-  adminBiosContract = {
-    resolve_bio_review: resolveBioReview
-  };
-});
-
-// ../../packages/contracts/src/orpc/admin-catalogue.ts
-var CatalogueLensSchema, CapturePriorityReasonSchema, CatalogueMatchSchema, CatalogueTrackItemSchema, CatalogueSummarySchema, listCatalogueTracks, rankCatalogue, recordDemand, clearWrongAudio, requeueUnmatchedCaptures, requeueAnchor, requeueIsrcRecovery, flagWrongAudio, forceCapture, certifyTrack, setTrackDismissed, CaptureVerifyItemSchema, listUnverifiedCaptures, verifyCapture, CrawlPassSchema, CrawlPhaseInitializationSchema, MAX_CRAWL_PREPARE_LIMIT = 6, CrawlFetchPlanSchema, SuppliedCrawlBodySchema, MAX_CRAWL_COMMIT_BATCH, CRAWL_COMMIT_TOKEN_MAX_BYTES, CRAWL_COMMIT_BATCH_MAX_TOTAL_BYTES, CrawlCommitItemSchema, CrawlCommitReceiptSchema, CrawlPhaseCapabilitiesSchema, CrawlPhaseInputSchema, CrawlPhaseOutputSchema, CrawlStatusSchema, crawlCatalogue, commitCrawlNodes, getCrawlStatus, ANCHOR_CANDIDATE_LIMIT = 100, ANCHOR_ARTIST_LIMIT = 20, ANCHOR_TEXT_MAX = 300, ANCHOR_ISRC_MAX = 64, ANCHOR_ID_MAX = 64, ANCHOR_URL_MAX = 2048, AnchorCandidateSchema, anchorTrack, DEEZER_CANDIDATE_LIMIT = 5, DEEZER_TEXT_MAX = 300, DEEZER_ISRC_MAX = 64, DEEZER_TRACK_ID_MAX = 32, DeezerIsrcCandidateSchema, resolveAnchor, resolveAnchorReview, setAnchorSearch, setAnchorApify, CaptureBudgetStateSchema, getCaptureBudget, setCaptureBudget, AnchorApifyBudgetSchema, getAnchorApifyBudget, setAnchorApifyBudget, SpotifyAnchorBreakerStateSchema, AnchorRungFlagsSchema, getSpotifyAnchorBreaker, resetSpotifyAnchorBreaker, AppleBreakerStateSchema, resetAppleBreaker, adminCatalogueContract;
-var init_admin_catalogue = __esm(() => {
-  init_dist3();
-  init_zod();
-  CatalogueLensSchema = _enum(["capture", "dismissed", "ear", "failed", "quarantine", "unmatched"]).meta({ id: "CatalogueLens" });
-  CapturePriorityReasonSchema = object({
-    kind: _enum(["artist", "label", "none", "seed-label", "skipped-label", "unauthorized"]),
-    name: string2().nullable()
-  }).meta({ id: "CapturePriorityReason" });
-  CatalogueMatchSchema = object({
-    artists: array(string2()),
-    logId: string2().nullable(),
-    title: string2(),
-    trackId: string2()
-  }).meta({ id: "CatalogueMatch" });
-  CatalogueTrackItemSchema = object({
-    albumImageUrl: string2().nullable(),
-    appleMusicUrl: string2().nullable(),
-    artists: array(string2()),
-    bpm: number2().nullable(),
-    capturePriority: number2().nullable(),
-    captureReason: CapturePriorityReasonSchema.nullable(),
-    captureStatus: string2().nullable(),
-    captureVerification: string2().nullable(),
-    dismissedAt: string2().nullable(),
-    duplicateOf: CatalogueMatchSchema.nullable(),
-    hasCapturedAudio: boolean2(),
-    hasPreview: boolean2(),
-    isrc: string2().nullable(),
-    key: string2().nullable(),
-    label: string2().nullable(),
-    nearestFinding: CatalogueMatchSchema.nullable(),
-    nearestFindingScore: number2().nullable(),
-    rankedAt: string2().nullable(),
-    releaseDate: string2().nullable(),
-    sourceAudioAttemptedAt: string2().nullable().optional(),
-    spotifyUrl: string2().nullable(),
-    title: string2(),
+  AppleCatalogueResolvedSchema = object({
+    trackId: string2(),
+    url: string2()
+  }).meta({ id: "AppleCatalogueResolved" });
+  AppleCatalogueFailedSchema = object({
+    error: string2(),
     trackId: string2()
-  }).meta({ id: "CatalogueTrackItem" });
-  CatalogueSummarySchema = object({
-    awaitingCapture: number2(),
-    awaitingRank: number2(),
-    dismissed: number2(),
-    quarantined: number2(),
-    ranked: number2(),
-    total: number2()
-  }).meta({ id: "CatalogueSummary" });
-  listCatalogueTracks = oc.route({
-    method: "GET",
-    operationId: "listCatalogueTracks",
-    path: "/admin/catalogue",
-    summary: "The ranked catalogue: closest to a finding (`ear`), or next to capture (`capture`)",
-    tags: ["Admin"]
-  }).input(object({
-    lens: CatalogueLensSchema.default("ear"),
-    limit: number3().int().min(1).max(200).default(50)
-  })).output(object({
-    ok: literal(true),
-    summary: CatalogueSummarySchema,
-    tracks: array(CatalogueTrackItemSchema)
-  }));
-  rankCatalogue = oc.route({
+  }).meta({ id: "AppleCatalogueFailed" });
+  backfillAppleCatalogue = oc.route({
+    inputStructure: "detailed",
     method: "POST",
-    operationId: "rankCatalogue",
-    path: "/admin/catalogue/rank",
-    summary: "One tick of the catalogue ranking sweep (nearest finding + capture priority)",
+    operationId: "backfillAppleCatalogue",
+    path: "/admin/backfill/apple-catalogue",
+    summary: "Back-fill Apple URLs + album facts over catalogue tracks by exact ISRC (batched)",
     tags: ["Admin"]
   }).input(object({
-    countRemaining: boolean3().default(false),
-    limit: number3().int().min(1).max(1000).default(250)
+    query: object({
+      dryRun: string2().optional(),
+      limit: string2().optional()
+    })
   })).output(object({
+    albumFactsWritten: number2(),
+    breakerTripped: boolean2(),
+    configured: boolean2(),
+    dryRun: boolean2(),
+    failed: array(AppleCatalogueFailedSchema),
+    failedCount: number2(),
     ok: literal(true),
-    summary: object({
-      catalogueDuplicates: number2(),
-      corpus: string2(),
-      embeddedFindings: number2(),
-      findings: number2(),
-      prioritized: number2(),
-      quarantined: number2(),
-      remaining: number2(),
-      scored: number2()
-    }),
-    telescope: union([
-      object({ changed: boolean2(), ok: literal(true), size: number2() }),
-      object({ ok: literal(false), reason: string2() })
-    ]).optional()
-  }));
-  recordDemand = oc.route({
-    method: "POST",
-    operationId: "recordDemand",
-    path: "/admin/catalogue/demand",
-    summary: "One demand tick: reorder crawl/capture priority from Simple Analytics pageviews",
-    tags: ["Admin"]
-  }).input(object({})).output(object({
-    ok: literal(true),
-    summary: object({
-      configured: boolean2(),
-      demandedArtists: number2(),
-      demandedLabels: number2(),
-      frontierPromoted: number2(),
-      pagesRead: number2(),
-      totalPageviews: number2(),
-      tracksScored: number2(),
-      unknownSlugs: number2(),
-      window: object({ end: string2(), start: string2() })
-    })
+    rateLimited: boolean2(),
+    resolved: array(AppleCatalogueResolvedSchema),
+    resolvedCount: number2(),
+    unresolved: array(string2()),
+    unresolvedCount: number2()
   }));
-  clearWrongAudio = oc.route({
-    method: "POST",
-    operationId: "clearWrongAudio",
-    path: "/admin/catalogue/wrong-audio/clear",
-    summary: "Overrule the wrong-audio quarantine on one catalogue row (operator)",
-    tags: ["Admin"]
-  }).input(object({ trackId: string2().min(1) })).output(object({ cleared: boolean2(), ok: literal(true) }));
-  requeueUnmatchedCaptures = oc.route({
-    method: "POST",
-    operationId: "requeueUnmatchedCaptures",
-    path: "/admin/catalogue/captures/requeue-unmatched",
-    summary: "Re-queue terminal-unmatched catalogue captures after a matcher improvement (operator)",
-    tags: ["Admin"]
-  }).input(object({})).output(object({ ok: literal(true), requeued: number2(), skippedVetoed: number2() }));
-  requeueAnchor = oc.route({
-    method: "POST",
-    operationId: "requeueAnchor",
-    path: "/admin/catalogue/anchor/requeue",
-    summary: "Clear named rows' anchor re-ask backoff so the next tick retries them (operator)",
-    tags: ["Admin"]
-  }).input(object({ trackIds: array(string2().min(1)).min(1).max(250) })).output(object({ ok: literal(true), requeued: number2() }));
-  requeueIsrcRecovery = oc.route({
+  BeatportResolvedSchema = object({
+    logId: string2(),
+    url: string2()
+  }).meta({ id: "BeatportResolved" });
+  BeatportFailedSchema = object({
+    error: string2(),
+    logId: string2()
+  }).meta({ id: "BeatportFailed" });
+  BeatportCatalogueResolvedSchema = object({
+    trackId: string2(),
+    url: string2()
+  }).meta({ id: "BeatportCatalogueResolved" });
+  BeatportCatalogueFailedSchema = object({
+    error: string2(),
+    trackId: string2()
+  }).meta({ id: "BeatportCatalogueFailed" });
+  backfillBeatport = oc.route({
+    inputStructure: "detailed",
     method: "POST",
-    operationId: "requeueIsrcRecovery",
-    path: "/admin/catalogue/isrc-recovery/requeue",
-    summary: "Clear Deezer-empty ISRC-recovery stamps from a named window (operator)",
+    operationId: "backfillBeatport",
+    path: "/admin/backfill/beatport",
+    summary: "Back-fill Beatport URLs over published findings by exact ISRC",
     tags: ["Admin"]
   }).input(object({
-    dryRun: boolean2().default(true),
-    since: string2().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z)?$/, "since must be an ISO date (2026-09-09) or instant (2026-09-09T00:00:00.000Z)")
+    query: object({
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      limit: string2().optional()
+    })
   })).output(object({
+    catalogueFailed: array(BeatportCatalogueFailedSchema),
+    catalogueFailedCount: number2(),
+    catalogueResolved: array(BeatportCatalogueResolvedSchema),
+    catalogueResolvedCount: number2(),
+    catalogueUnresolved: array(string2()),
+    catalogueUnresolvedCount: number2(),
+    configured: boolean2(),
     dryRun: boolean2(),
-    matched: number2(),
+    failed: array(BeatportFailedSchema),
+    failedCount: number2(),
+    nextCursor: string2().nullable(),
     ok: literal(true),
-    requeued: number2()
+    resolved: array(BeatportResolvedSchema),
+    resolvedCount: number2(),
+    skipped: array(string2()),
+    skippedCount: number2(),
+    unresolved: array(string2()),
+    unresolvedCount: number2()
   }));
-  flagWrongAudio = oc.route({
-    method: "POST",
-    operationId: "flagWrongAudio",
-    path: "/admin/catalogue/wrong-audio/flag",
-    summary: "Flag a finding's captured audio as the wrong recording (operator)",
-    tags: ["Admin"]
-  }).input(object({ trackId: string2().min(1) })).output(object({ flagged: boolean2(), ok: literal(true) }));
-  forceCapture = oc.route({
-    method: "POST",
-    operationId: "forceCapture",
-    path: "/admin/catalogue/force-capture",
-    summary: "Overrule the duplicate veto on one catalogue row so it can be captured (operator)",
-    tags: ["Admin"]
-  }).input(object({ trackId: string2().min(1) })).output(object({ forced: boolean2(), ok: literal(true) }));
-  certifyTrack = oc.route({
-    method: "POST",
-    operationId: "certifyTrack",
-    path: "/admin/catalogue/certify",
-    summary: "Certify an existing catalogue track in place — mint its finding (operator)",
-    tags: ["Admin"]
-  }).input(object({ note: string2().optional(), trackId: string2().min(1) })).output(object({ logId: string2(), ok: literal(true) }));
-  setTrackDismissed = oc.route({
-    method: "PUT",
-    operationId: "setTrackDismissed",
-    path: "/admin/catalogue/dismissed",
-    summary: "Dismiss a catalogue track ('not for me') or restore it (operator)",
-    tags: ["Admin"]
-  }).input(object({ dismissed: boolean2(), trackId: string2().min(1) })).output(object({ changed: boolean2(), ok: literal(true) }));
-  CaptureVerifyItemSchema = object({
-    artists: array(string2()),
-    certified: boolean2(),
-    durationMs: number2(),
-    isrc: string2().nullable(),
-    logId: string2().nullable(),
-    sourceAudioKey: string2(),
-    title: string2(),
+  DeezerResolvedSchema = object({
+    trackId: string2(),
+    url: string2()
+  }).meta({ id: "DeezerResolved" });
+  DeezerFailedSchema = object({
+    error: string2(),
     trackId: string2()
-  }).meta({ id: "CaptureVerifyItem" });
-  listUnverifiedCaptures = oc.route({
-    method: "GET",
-    operationId: "listUnverifiedCaptures",
-    path: "/admin/catalogue/captures/unverified",
-    summary: "Captured rows not yet fingerprint-verified against their preview (the backfill worklist)",
+  }).meta({ id: "DeezerFailed" });
+  backfillDeezer = oc.route({
+    inputStructure: "detailed",
+    method: "POST",
+    operationId: "backfillDeezer",
+    path: "/admin/backfill/deezer",
+    summary: "Back-fill Deezer track ids over certified + catalogue rows by exact ISRC",
     tags: ["Admin"]
   }).input(object({
-    count: boolean3().default(false),
-    limit: number3().int().min(1).max(200).default(50)
+    query: object({
+      dryRun: string2().optional(),
+      limit: string2().optional()
+    })
   })).output(object({
+    dryRun: boolean2(),
+    failed: array(DeezerFailedSchema),
+    failedCount: number2(),
     ok: literal(true),
-    queued: number2().optional(),
-    tracks: array(CaptureVerifyItemSchema)
+    rateLimited: boolean2(),
+    resolved: array(DeezerResolvedSchema),
+    resolvedCount: number2(),
+    unresolved: array(string2()),
+    unresolvedCount: number2(),
+    unvouchable: array(string2()),
+    unvouchableCount: number2()
   }));
-  verifyCapture = oc.route({
+  backfillLabelReleases = oc.route({
     method: "POST",
-    operationId: "verifyCapture",
-    path: "/admin/catalogue/captures/verify",
-    summary: "Record a capture's fingerprint verdict against its preview, and route it",
+    operationId: "backfillLabelReleases",
+    path: "/admin/backfill/label-releases",
+    summary: "Tap Spotify's fresh releases for enabled seed labels into catalogue rows (bounded)",
     tags: ["Admin"]
   }).input(object({
-    trackId: string2().min(1),
-    verdict: _enum(["match", "mismatch", "no-preview"])
+    dryRun: boolean2().default(false),
+    limit: number3().int().min(1).max(200).default(5)
   })).output(object({
-    action: _enum([
-      "flagged-finding",
-      "not-captured",
-      "operator-verified",
-      "preview-match",
-      "quarantined-catalogue",
-      "unverified"
-    ]),
-    ok: literal(true)
-  }));
-  CrawlPassSchema = object({
-    artistsRearmed: number2().optional(),
+    albumsMatched: number2(),
+    albumsSeen: number2(),
+    budgetPaused: boolean2(),
+    configured: boolean2(),
     dryRun: boolean2(),
-    expanded: number2(),
-    failed: number2(),
-    frontierPending: number2(),
-    labelsDiscovered: array(string2()),
-    maxHop: number2(),
-    nodesEnqueued: number2(),
+    failedFetches: number2(),
+    failedLabels: array(string2()),
+    fetchCeilingHit: boolean2(),
+    labelSlugs: array(string2()),
+    labelsProbed: number2(),
+    newRows: number2(),
+    newTrackIds: array(string2()),
+    ok: literal(true),
     rateLimited: boolean2(),
-    releasesRearmed: number2(),
-    seeded: number2(),
-    seedsRearmed: number2(),
-    tracksAllowedIn: number2().optional(),
-    tracksFound: number2(),
-    tracksSkipped: number2(),
-    tracksSkippedArtistRule: number2().optional(),
-    tracksSkippedHeld: number2().optional(),
-    tracksSkippedLabelGate: number2().optional(),
-    tracksWritten: number2()
-  }).meta({ id: "CrawlPass" });
-  CrawlPhaseInitializationSchema = object({
-    artistsRearmed: number2(),
-    releasesRearmed: number2(),
-    seeded: number2(),
-    seedsRearmed: number2()
-  });
-  CrawlFetchPlanSchema = discriminatedUnion("kind", [
-    object({ kind: literal("none") }),
-    object({ kind: literal("single"), url: string2().max(2048) }),
-    object({
-      countField: literal("release-count"),
-      kind: literal("tail"),
-      pageSize: number2().int().positive(),
-      pageUrlTemplate: string2().max(2048),
-      probeUrl: string2().max(2048)
-    })
-  ]);
-  SuppliedCrawlBodySchema = object({
-    body: json().optional(),
-    outcome: _enum(["body", "empty", "invalid", "oversize", "throttled"]),
-    url: string2().max(2048)
-  });
-  MAX_CRAWL_COMMIT_BATCH = MAX_CRAWL_PREPARE_LIMIT;
-  CRAWL_COMMIT_TOKEN_MAX_BYTES = 2 * 1024 * 1024;
-  CRAWL_COMMIT_BATCH_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
-  CrawlCommitItemSchema = strictObject({
-    commitToken: string2().max(CRAWL_COMMIT_TOKEN_MAX_BYTES),
-    operationId: literal("catalogue.crawl"),
-    operationKey: string2().max(128),
-    requestDigest: string2().regex(/^[0-9a-f]{64}$/)
-  });
-  CrawlCommitReceiptSchema = object({
-    elapsedMs: number2().int().min(0).optional(),
-    error: string2().max(500).optional(),
-    operationKey: string2().max(128),
-    outcome: _enum([
-      "committed",
-      "conflict",
-      "failed",
-      "in-progress",
-      "lookup-failed",
-      "rejected",
-      "safely-retryable"
-    ]),
-    replayed: boolean2(),
-    result: json().optional(),
-    resultIdentity: string2().optional(),
-    state: _enum(["accepted", "committed", "rejected"]).optional()
-  }).meta({ id: "CrawlCommitReceipt" });
-  CrawlPhaseCapabilitiesSchema = strictObject({
-    commitBatchLimit: number2().int().min(1).max(MAX_CRAWL_COMMIT_BATCH),
-    commitBatchMaxTotalBytes: number2().int().min(1)
-  });
-  CrawlPhaseInputSchema = discriminatedUnion("phase", [
-    object({ phase: literal("initialize") }),
-    object({
-      limit: number2().int().min(1).max(MAX_CRAWL_PREPARE_LIMIT).default(2),
-      maxHop: number2().int().min(0).max(3).default(2),
-      phase: literal("prepare")
-    }),
-    object({
-      phase: literal("fetch"),
-      preparedToken: string2().max(2 * 1024 * 1024),
-      supplied: array(SuppliedCrawlBodySchema).max(2).optional()
-    }),
-    object({
-      commitToken: string2().max(2 * 1024 * 1024),
-      operationId: literal("catalogue.crawl"),
-      operationKey: string2().max(128),
-      phase: literal("commit"),
-      requestDigest: string2().regex(/^[0-9a-f]{64}$/)
+    skippedKnown: number2(),
+    skippedUndated: number2(),
+    skippedUngrounded: number2(),
+    tracksSkippedArtistRule: number2().optional()
+  }));
+  LabelImagesBackfillFailedSchema = object({
+    error: string2(),
+    slug: string2()
+  }).meta({ id: "LabelImagesBackfillFailed" });
+  backfillLabelImages = oc.route({
+    inputStructure: "detailed",
+    method: "POST",
+    operationId: "backfillLabelImages",
+    path: "/admin/backfill/label-images",
+    summary: "Resolve label logos (Discogs → Wikidata) into R2 for existing labels (batched)",
+    tags: ["Admin"]
+  }).input(object({
+    body: object({
+      discogsCandidates: DiscogsLabelCandidateBatchSchema.optional()
+    }).optional(),
+    query: object({
+      boxFetch: string2().optional(),
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      limit: string2().optional()
     })
-  ]);
-  CrawlPhaseOutputSchema = discriminatedUnion("phase", [
-    object({
-      initialization: CrawlPhaseInitializationSchema,
-      kind: _enum(["initialized", "unavailable"]),
-      ok: literal(true),
-      phase: literal("initialize")
-    }),
-    object({
-      boxFetch: boolean2(),
-      capabilities: CrawlPhaseCapabilitiesSchema.optional(),
-      frontierPending: number2(),
-      initialization: CrawlPhaseInitializationSchema,
-      items: array(object({
-        fetchPlan: CrawlFetchPlanSchema,
-        nodeId: string2(),
-        preparedToken: string2()
-      })).max(MAX_CRAWL_PREPARE_LIMIT),
-      kind: _enum(["drained", "prepared", "unavailable"]),
-      ok: literal(true),
-      phase: literal("prepare")
-    }),
-    object({
-      commitToken: string2(),
-      ok: literal(true),
-      operationId: literal("catalogue.crawl"),
-      operationKey: string2(),
-      phase: literal("fetch"),
-      rateLimited: boolean2().optional(),
-      requestDigest: string2()
-    }),
-    object({
-      ok: literal(true),
-      phase: literal("commit"),
-      receipt: object({
-        outcome: _enum([
-          "committed",
-          "conflict",
-          "in-progress",
-          "lookup-failed",
-          "rejected",
-          "safely-retryable"
-        ]),
-        replayed: boolean2(),
-        result: json().optional(),
-        resultIdentity: string2().optional(),
-        state: _enum(["accepted", "committed", "rejected"]).optional()
-      })
+  })).output(object({
+    discogsWork: array(DiscogsLabelWorkSchema).max(DISCOGS_LABEL_WORK_LIMIT),
+    dryRun: boolean2(),
+    failed: array(LabelImagesBackfillFailedSchema),
+    failedCount: number2(),
+    nextCursor: string2().nullable(),
+    none: array(string2()),
+    noneCount: number2(),
+    ok: literal(true),
+    rateLimited: boolean2(),
+    resolved: array(string2()),
+    resolvedCount: number2()
+  }));
+  LabelLineageBackfillFailedSchema = object({
+    error: string2(),
+    slug: string2()
+  }).meta({ id: "LabelLineageBackfillFailed" });
+  backfillLabelLineage = oc.route({
+    inputStructure: "detailed",
+    method: "POST",
+    operationId: "backfillLabelLineage",
+    path: "/admin/backfill/label-lineage",
+    summary: "Resolve label lineage (founding date, place, parent imprint) from MusicBrainz (batched)",
+    tags: ["Admin"]
+  }).input(object({
+    query: object({
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      limit: string2().optional()
     })
-  ]);
-  CrawlStatusSchema = object({
-    anchorsPending: number2(),
-    catalogueTracks: number2(),
-    frontier: object({
-      done: number2(),
-      failed: number2(),
-      pending: number2(),
-      skipped: number2()
-    }),
-    frontierByKind: object({
-      artist: number2(),
-      label: number2(),
-      release: number2()
-    }),
-    labelsUndecided: number2(),
-    seedLabels: array(string2()),
-    storablePending: number2(),
-    undecidedLabelsQueued: number2(),
-    unstorablePending: number2()
-  }).meta({ id: "CrawlStatus" });
-  crawlCatalogue = oc.route({
+  })).output(object({
+    dryRun: boolean2(),
+    failed: array(LabelLineageBackfillFailedSchema),
+    failedCount: number2(),
+    nextCursor: string2().nullable(),
+    none: array(string2()),
+    noneCount: number2(),
+    ok: literal(true),
+    rateLimited: boolean2(),
+    resolved: array(string2()),
+    resolvedCount: number2(),
+    unmatchedParents: number2()
+  }));
+  CoverMastersFailedSchema = object({
+    error: string2(),
+    slug: string2()
+  }).meta({ id: "CoverMastersFailed" });
+  backfillCoverMasters = oc.route({
     inputStructure: "detailed",
     method: "POST",
-    operationId: "crawlCatalogue",
-    path: "/admin/catalogue/crawl",
-    summary: "Run one bounded, resumable pass of the catalogue crawler",
+    operationId: "backfillCoverMasters",
+    path: "/admin/backfill/cover-masters",
+    summary: "Resolve owned ≤1200² cover masters (album/artist) into R2 (batched)",
     tags: ["Admin"]
   }).input(object({
-    body: CrawlPhaseInputSchema.optional(),
     query: object({
+      cursor: string2().optional(),
       dryRun: string2().optional(),
+      kind: string2().optional(),
       limit: string2().optional(),
-      maxHop: string2().optional()
+      retry: string2().optional()
     })
-  })).output(union([CrawlPassSchema.extend({ ok: literal(true) }), CrawlPhaseOutputSchema]));
-  commitCrawlNodes = oc.route({
+  })).output(object({
+    dryRun: boolean2(),
+    failed: array(CoverMastersFailedSchema),
+    failedCount: number2(),
+    kind: _enum(["album", "artist"]),
+    nextCursor: string2().nullable(),
+    none: array(string2()),
+    noneCount: number2(),
+    ok: literal(true),
+    rateLimited: boolean2(),
+    requeued: array(string2()).optional(),
+    requeuedCount: number2().optional(),
+    resolved: array(string2()),
+    resolvedCount: number2()
+  }));
+  RecordingMbidsFailedSchema = object({
+    error: string2(),
+    trackId: string2()
+  }).meta({ id: "RecordingMbidsBackfillFailed" });
+  backfillRecordingMbids = oc.route({
+    inputStructure: "detailed",
     method: "POST",
-    operationId: "commitCrawlNodes",
-    path: "/admin/catalogue/crawl/commits",
-    summary: "Commit one claim's fetched crawl nodes in a single admitted phase",
+    operationId: "backfillRecordingMbids",
+    path: "/admin/backfill/recording-mbids",
+    summary: "Fill MusicBrainz recording MBIDs (crawler PK strip + ISRC resolve) over tracks (batched)",
     tags: ["Admin"]
-  }).input(strictObject({
-    items: array(CrawlCommitItemSchema).min(1).max(MAX_CRAWL_COMMIT_BATCH)
-  })).output(strictObject({
-    deferred: number2().int().min(0),
+  }).input(object({
+    query: object({
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      isrcRefreshLimit: string2().optional(),
+      limit: string2().optional()
+    })
+  })).output(object({
+    dryRun: boolean2(),
+    failed: array(RecordingMbidsFailedSchema),
+    failedCount: number2(),
+    isrcRefreshMissed: array(string2()),
+    isrcRefreshMissedCount: number2(),
+    isrcRefreshed: array(string2()),
+    isrcRefreshedCount: number2(),
+    missed: array(string2()),
+    missedCount: number2(),
+    nextCursor: string2().nullable(),
     ok: literal(true),
-    receipts: array(CrawlCommitReceiptSchema).max(MAX_CRAWL_COMMIT_BATCH)
+    prefixStripped: number2(),
+    rateLimited: boolean2(),
+    resolved: array(string2()),
+    resolvedCount: number2()
   }));
-  getCrawlStatus = oc.route({
-    method: "GET",
-    operationId: "getCrawlStatus",
-    path: "/admin/catalogue/crawl",
-    summary: "The crawl frontier's state, the catalogue size, and the seed set",
-    tags: ["Admin"]
-  }).input(object({})).output(CrawlStatusSchema.extend({ ok: literal(true) }));
-  AnchorCandidateSchema = object({
-    albumImageUrl: string2().max(ANCHOR_URL_MAX).nullish(),
-    artists: array(object({
-      id: string2().max(ANCHOR_ID_MAX).nullish(),
-      name: string2().max(ANCHOR_TEXT_MAX)
-    })).max(ANCHOR_ARTIST_LIMIT).default([]),
-    durationMs: number2().nullish(),
-    isrc: string2().max(ANCHOR_ISRC_MAX).nullish(),
-    spotifyTrackId: string2().max(ANCHOR_ID_MAX).optional(),
-    title: string2().max(ANCHOR_TEXT_MAX).default(""),
-    uri: string2().max(ANCHOR_URL_MAX).optional(),
-    url: string2().max(ANCHOR_URL_MAX).optional()
-  }).refine((candidate) => Boolean(candidate.spotifyTrackId ?? candidate.uri ?? candidate.url), {
-    error: "a candidate must carry a spotifyTrackId, uri, or url"
-  }).meta({ id: "AnchorCandidate" });
-  anchorTrack = oc.route({
+  backfillArtistEdges = oc.route({
+    inputStructure: "detailed",
     method: "POST",
-    operationId: "anchorTrack",
-    path: "/admin/catalogue/anchor",
-    summary: "Verify box-supplied Spotify candidates against a catalogue row and write its anchor",
+    operationId: "backfillArtistEdges",
+    path: "/admin/backfill/artist-edges",
+    summary: "Fold artists_json names onto existing artist identities → track_artists (batched)",
     tags: ["Admin"]
   }).input(object({
-    candidates: array(AnchorCandidateSchema).max(ANCHOR_CANDIDATE_LIMIT).default([]),
-    trackId: string2().min(1)
+    query: object({
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      limit: string2().optional()
+    })
   })).output(object({
-    anchored: boolean2(),
+    dryRun: boolean2(),
+    edgesWritten: number2(),
+    fullyMatched: array(string2()),
+    fullyMatchedCount: number2(),
+    nextCursor: string2().nullable(),
     ok: literal(true),
-    verifiedBy: _enum(["isrc", "search", "search-subset"]).nullable()
-  }));
-  DeezerIsrcCandidateSchema = object({
-    artistName: string2().max(DEEZER_TEXT_MAX),
-    deezerTrackId: string2().max(DEEZER_TRACK_ID_MAX).optional(),
-    durationMs: number2().positive().finite(),
-    isrc: string2().max(DEEZER_ISRC_MAX),
-    title: string2().max(DEEZER_TEXT_MAX)
-  }).meta({ id: "DeezerIsrcCandidate" });
-  resolveAnchor = oc.route({
+    partiallyMatched: array(string2()),
+    partiallyMatchedCount: number2(),
+    queueDepth: number2(),
+    scanned: number2(),
+    unmatchedNames: number2(),
+    zeroMatched: array(string2()),
+    zeroMatchedCount: number2()
+  }));
+  backfillArtistCredits = oc.route({
+    inputStructure: "detailed",
     method: "POST",
-    operationId: "resolveAnchor",
-    path: "/admin/catalogue/anchor/resolve",
-    summary: "Resolve a catalogue row's Spotify anchor from the free rungs (ListenBrainz + dark Spotify search)",
+    operationId: "backfillArtistCredits",
+    path: "/admin/backfill/artist-credits",
+    summary: "Mint identity-true artists from MusicBrainz credits for slice 0's zero-matched residual (batched)",
     tags: ["Admin"]
   }).input(object({
-    deezerCandidates: array(DeezerIsrcCandidateSchema).max(DEEZER_CANDIDATE_LIMIT).optional(),
-    spotifySearch: boolean2().optional(),
-    trackId: string2().min(1)
+    query: object({
+      cursor: string2().optional(),
+      dryRun: string2().optional(),
+      limit: string2().optional()
+    })
   })).output(object({
-    anchored: boolean2(),
-    apifyBudgetRemaining: number2().int().nonnegative(),
-    apifyEligible: boolean2(),
-    apifyEnabled: boolean2(),
-    apifyIneligibleReason: _enum(["apify_budget_spent", "awaiting_free_ask"]).nullable(),
-    freeDurationMsOmitted: number2().int().nonnegative(),
-    isrcRecoveredByDeezer: boolean2(),
-    listenbrainzOutcome: _enum([
-      "anchored",
-      "empty-ids",
-      "gate-rejected",
-      "metadata-failed",
-      "no-map",
-      "no-mbid",
-      "not-attempted",
-      "request-failed",
-      "yielded-on-breaker"
-    ]),
+    adoptedArtists: number2(),
+    dryRun: boolean2(),
+    edgesWritten: number2(),
+    matchedArtists: number2(),
+    mintedArtists: number2(),
+    nextCursor: string2().nullable(),
     ok: literal(true),
-    source: _enum(["listenbrainz", "spotify-isrc", "spotify-search"]).nullable(),
-    spotifyIsrcAsked: boolean2(),
-    spotifySearchDone: boolean2(),
-    spotifySearchEnabled: boolean2(),
-    spotifyThrottled: boolean2(),
-    stamped: boolean2(),
-    verifiedBy: _enum(["isrc", "search", "search-subset"]).nullable()
+    rateLimited: boolean2(),
+    scanned: number2(),
+    skippedNoIdentity: number2()
   }));
-  resolveAnchorReview = oc.route({
+  adminBackfillsContract = {
+    backfill_apple_catalogue: backfillAppleCatalogue,
+    backfill_apple_music: backfillAppleMusic,
+    backfill_artist_credits: backfillArtistCredits,
+    backfill_artist_edges: backfillArtistEdges,
+    backfill_beatport: backfillBeatport,
+    backfill_cover_masters: backfillCoverMasters,
+    backfill_deezer: backfillDeezer,
+    backfill_discogs: backfillDiscogs,
+    backfill_discogs_facts: backfillDiscogsFacts,
+    backfill_label_images: backfillLabelImages,
+    backfill_label_lineage: backfillLabelLineage,
+    backfill_label_releases: backfillLabelReleases,
+    backfill_lastfm: backfillLastfm,
+    backfill_recording_mbids: backfillRecordingMbids
+  };
+});
+
+// ../../packages/contracts/src/orpc/admin-bios.ts
+var BioEntityKindSchema, resolveBioReview, adminBiosContract;
+var init_admin_bios = __esm(() => {
+  init_dist3();
+  init_zod();
+  BioEntityKindSchema = _enum(["album", "artist", "label"]).meta({ id: "BioEntityKind" });
+  resolveBioReview = oc.route({
     method: "POST",
-    operationId: "resolveAnchorReview",
-    path: "/admin/catalogue/anchor/reviews/{trackId}/resolve",
-    summary: "Rule on a suspected version mismatch: anchor to the candidate, or dismiss (operator)",
+    operationId: "resolveBioReview",
+    path: "/admin/bio-reviews/{kind}/{slug}/resolve",
+    summary: "Rule on a bio that landed past the voice gate: keep it or send it back (operator)",
     tags: ["Admin"]
   }).input(object({
-    resolution: _enum(["accepted", "dismissed"]),
-    trackId: string2().min(1)
+    kind: BioEntityKindSchema,
+    resolution: _enum(["keep", "rewrite"]),
+    slug: string2()
   })).output(object({
-    anchored: boolean2(),
+    kind: BioEntityKindSchema,
     ok: literal(true),
-    review: object({
-      candidateTitle: string2(),
-      spotifyTrackId: string2().optional()
-    })
+    resolution: _enum(["keep", "rewrite"]),
+    slug: string2()
   }));
-  setAnchorSearch = oc.route({
-    method: "PUT",
-    operationId: "setAnchorSearch",
-    path: "/admin/catalogue/anchor/search",
-    summary: "Flip the dark flag for the Spotify anchor-search rungs (operator)",
-    tags: ["Admin"]
-  }).input(object({ enabled: boolean2() })).output(object({ enabled: boolean2(), ok: literal(true) }));
-  setAnchorApify = oc.route({
-    method: "PUT",
-    operationId: "setAnchorApify",
-    path: "/admin/catalogue/anchor/apify",
-    summary: "Flip the Apify anchor-fallback kill-flag — off = no-budget graceful state (operator)",
-    tags: ["Admin"]
-  }).input(object({ enabled: boolean2() })).output(object({ enabled: boolean2(), ok: literal(true), requeued: number2() }));
-  CaptureBudgetStateSchema = object({
-    budget: object({ dailyBytes: number2(), dailyTracks: number2() }),
-    closedReason: _enum(["bytes_spent", "paused", "tracks_spent"]).nullable(),
-    open: boolean2(),
-    paused: boolean2(),
-    remainingBytes: number2(),
-    remainingTracks: number2(),
-    spend: object({ bytes: number2(), tracks: number2() }),
-    windowHours: number2()
-  }).meta({ id: "CaptureBudgetState" });
-  getCaptureBudget = oc.route({
-    method: "GET",
-    operationId: "getCaptureBudget",
-    path: "/admin/catalogue/capture-budget",
-    summary: "The catalogue capture budget: the switch, the caps, the 24h spend, what is left",
-    tags: ["Admin"]
-  }).input(object({})).output(CaptureBudgetStateSchema.extend({ ok: literal(true) }));
-  setCaptureBudget = oc.route({
-    method: "PUT",
-    operationId: "setCaptureBudget",
-    path: "/admin/catalogue/capture-budget",
-    summary: "Set the catalogue capture budget / flip its kill switch (operator)",
-    tags: ["Admin"]
-  }).input(object({
-    dailyBytes: number2().int().min(0).optional(),
-    dailyTracks: number2().int().min(0).optional(),
-    paused: boolean2().optional()
-  })).output(CaptureBudgetStateSchema.extend({ ok: literal(true) }));
-  AnchorApifyBudgetSchema = object({
-    dailyRows: number2(),
-    day: string2(),
-    remainingRows: number2(),
-    rowsSent: number2(),
-    spent: boolean2()
-  }).meta({ id: "AnchorApifyBudget" });
-  getAnchorApifyBudget = oc.route({
-    method: "GET",
-    operationId: "getAnchorApifyBudget",
-    path: "/admin/catalogue/anchor/apify-budget",
-    summary: "The metered Apify anchor rung's daily row cap, today's spend, and what is left",
-    tags: ["Admin"]
-  }).input(object({})).output(AnchorApifyBudgetSchema.extend({ ok: literal(true) }));
-  setAnchorApifyBudget = oc.route({
-    method: "PUT",
-    operationId: "setAnchorApifyBudget",
-    path: "/admin/catalogue/anchor/apify-budget",
-    summary: "Set the metered Apify anchor rung's daily row cap (operator)",
-    tags: ["Admin"]
-  }).input(object({ dailyRows: number2().int().min(0) })).output(AnchorApifyBudgetSchema.extend({ ok: literal(true) }));
-  SpotifyAnchorBreakerStateSchema = object({
-    cooldownRemainingMs: number2(),
-    reason: string2().nullable(),
-    throttlesInWindow: number2(),
-    tripped: boolean2(),
-    trippedAt: string2().nullable()
-  }).meta({ id: "SpotifyAnchorBreakerState" });
-  AnchorRungFlagsSchema = object({
-    apifyBudget: AnchorApifyBudgetSchema,
-    apifyEnabled: boolean2(),
-    spotifySearchEnabled: boolean2()
-  }).meta({ id: "AnchorRungFlags" });
-  getSpotifyAnchorBreaker = oc.route({
-    method: "GET",
-    operationId: "getSpotifyAnchorBreaker",
-    path: "/admin/catalogue/anchor/breaker",
-    summary: "The Spotify anchor-search throttle breaker: tripped, why, how long left, and the rungs",
-    tags: ["Admin"]
-  }).input(object({})).output(SpotifyAnchorBreakerStateSchema.extend({ ok: literal(true), rungs: AnchorRungFlagsSchema }));
-  resetSpotifyAnchorBreaker = oc.route({
-    method: "POST",
-    operationId: "resetSpotifyAnchorBreaker",
-    path: "/admin/catalogue/anchor/breaker/reset",
-    summary: "Clear the Spotify anchor-search throttle breaker (operator)",
-    tags: ["Admin"]
-  }).input(object({})).output(SpotifyAnchorBreakerStateSchema.extend({ ok: literal(true) }));
-  AppleBreakerStateSchema = object({
-    consecutiveAuthFailures: number2(),
-    cooldownRemainingMs: number2(),
-    tripped: boolean2(),
-    trippedAt: string2().nullable()
-  }).meta({ id: "AppleBreakerState" });
-  resetAppleBreaker = oc.route({
-    method: "POST",
-    operationId: "resetAppleBreaker",
-    path: "/admin/catalogue/apple-breaker/reset",
-    summary: "Clear the Apple failure-regime breaker (operator)",
-    tags: ["Admin"]
-  }).input(object({})).output(AppleBreakerStateSchema.extend({ ok: literal(true) }));
-  adminCatalogueContract = {
-    anchor_track: anchorTrack,
-    certify_track: certifyTrack,
-    clear_wrong_audio: clearWrongAudio,
-    commit_crawl_nodes: commitCrawlNodes,
-    crawl_catalogue: crawlCatalogue,
-    flag_wrong_audio: flagWrongAudio,
-    force_capture: forceCapture,
-    get_anchor_apify_budget: getAnchorApifyBudget,
-    get_capture_budget: getCaptureBudget,
-    get_crawl_status: getCrawlStatus,
-    get_spotify_anchor_breaker: getSpotifyAnchorBreaker,
-    list_catalogue_tracks: listCatalogueTracks,
-    list_unverified_captures: listUnverifiedCaptures,
-    rank_catalogue: rankCatalogue,
-    record_demand: recordDemand,
-    requeue_anchor: requeueAnchor,
-    requeue_isrc_recovery: requeueIsrcRecovery,
-    requeue_unmatched_captures: requeueUnmatchedCaptures,
-    reset_apple_breaker: resetAppleBreaker,
-    reset_spotify_anchor_breaker: resetSpotifyAnchorBreaker,
-    resolve_anchor: resolveAnchor,
-    resolve_anchor_review: resolveAnchorReview,
-    set_anchor_apify: setAnchorApify,
-    set_anchor_apify_budget: setAnchorApifyBudget,
-    set_anchor_search: setAnchorSearch,
-    set_capture_budget: setCaptureBudget,
-    set_track_dismissed: setTrackDismissed,
-    verify_capture: verifyCapture
+  adminBiosContract = {
+    resolve_bio_review: resolveBioReview
   };
 });
 
@@ -12751,6 +12807,7 @@ var init__shared = __esm(() => {
     postedToTelegram: boolean2(),
     previewUrl: string2().optional(),
     releaseDate: string2().optional(),
+    similar: boolean2().optional(),
     sourceAudioFailures: number2().optional(),
     sourceAudioKey: string2().optional(),
     spotifyUrl: string2(),
@@ -13474,7 +13531,8 @@ var init_admin_hub_counts = __esm(() => {
   init_zod();
   HubCountsTableResultSchema = object({
     corrected: number2(),
-    deferred: number2()
+    deferred: number2(),
+    latestCorrected: number2()
   }).meta({ id: "HubCountsTableResult" });
   HubCountsReconcileCursorSchema = object({
     afterId: string2().min(1).max(512).nullable(),
@@ -13504,12 +13562,13 @@ var init_admin_hub_counts = __esm(() => {
 });
 
 // ../../packages/contracts/src/orpc/admin-labels.ts
-var LabelSeedStateSchema, LabelAdminItemSchema, listLabelsAdmin, updateLabel, listLabelArtistRules, replaceLabelArtistRules, MergeLabelResultSchema, mergeLabel, MB_LABEL_MBID_PATTERN, MintLabelOutcomeSchema, LabelTakeOverResultSchema, mintLabel, LabelAliasSourceSchema, LabelAliasKindSchema, LabelAliasCandidateSchema, listLabelAliases, confirmLabelAlias, rejectLabelAlias, DescribeLabelBodySchema, describeLabel, draftLabelBio, LabelBioWorkItemSchema, listLabelsMissingBio, adminLabelsContract;
+var LabelSeedStateSchema, LabelTriageVerdictSchema, LabelAdminItemSchema, listLabelsAdmin, updateLabel, listLabelArtistRules, 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(() => {
   init_dist3();
   init_zod();
   init_admin_artist_rules();
   LabelSeedStateSchema = _enum(["disabled", "enabled", "undecided"]).meta({ id: "LabelSeedState" });
+  LabelTriageVerdictSchema = _enum(["dnb", "dnb_partial", "not_dnb", "unclear"]).meta({ id: "LabelTriageVerdict" });
   LabelAdminItemSchema = object({
     createdAt: string2(),
     disambiguation: string2().nullable().optional(),
@@ -13524,6 +13583,9 @@ var init_admin_labels = __esm(() => {
     scopeChangedAt: string2().nullable().optional(),
     seedState: LabelSeedStateSchema,
     slug: string2(),
+    triageCheckedAt: string2().nullable().optional(),
+    triageReason: string2().nullable().optional(),
+    triageVerdict: LabelTriageVerdictSchema.nullable().optional(),
     updatedAt: string2()
   }).meta({ id: "LabelAdminItem" });
   listLabelsAdmin = oc.route({
@@ -13703,6 +13765,38 @@ var init_admin_labels = __esm(() => {
     summary: "List labels with findings but no bio yet, oldest first (the bio worklist)",
     tags: ["Admin"]
   }).input(object({ limit: string2().optional() })).output(object({ labels: array(LabelBioWorkItemSchema), ok: literal(true) }));
+  TriageRuleProposalSchema = object({
+    artistMbid: string2(),
+    artistName: string2(),
+    evidence: string2().optional(),
+    firstCreditCount: number2().int().min(0),
+    verdict: _enum(["allow", "block"])
+  });
+  RecordLabelTriageBodySchema = object({
+    censusSummary: string2().optional(),
+    confidence: _enum(["high", "medium", "low"]),
+    evidence: string2(),
+    offLaneShare: number2().min(0).max(1).optional(),
+    reason: string2().optional(),
+    residualOffLaneShare: number2().min(0).max(1).optional(),
+    roundId: string2(),
+    rules: array(TriageRuleProposalSchema).optional(),
+    verdict: LabelTriageVerdictSchema,
+    verifyAgrees: boolean2().optional(),
+    verifyEvidence: string2().optional()
+  }).meta({ id: "RecordLabelTriageBody" });
+  recordLabelTriage = oc.route({
+    method: "POST",
+    operationId: "recordLabelTriage",
+    path: "/admin/labels/{slug}/triage",
+    summary: "Record what a triage round found (stamps the cursor; never rules)",
+    tags: ["Admin"]
+  }).input(RecordLabelTriageBodySchema.extend({ slug: string2() })).output(object({
+    droppedInertRules: number2().int(),
+    ok: literal(true),
+    superseded: boolean2(),
+    triageCheckedAt: string2()
+  }));
   adminLabelsContract = {
     confirm_label_alias: confirmLabelAlias,
     describe_label: describeLabel,
@@ -13713,6 +13807,7 @@ var init_admin_labels = __esm(() => {
     list_labels_missing_bio: listLabelsMissingBio,
     merge_label: mergeLabel,
     mint_label: mintLabel,
+    record_label_triage: recordLabelTriage,
     reject_label_alias: rejectLabelAlias,
     replace_label_artist_rules: replaceLabelArtistRules,
     update_label: updateLabel
@@ -15295,15 +15390,18 @@ var init_admin_tracks = __esm(() => {
     summary: "The audio pipeline's worklist for one stage, in capture-priority order",
     tags: ["Admin"]
   }).input(object({
+    age: string2().optional(),
     count: string2().optional(),
     debtAware: string2().optional(),
     kind: TrackWorkKindSchema,
     limit: number3().int().min(1).max(250).default(50),
+    paidMode: _enum(["quota", "prior"]).optional(),
     scope: TrackWorkScopeSchema.default("all")
   })).output(object({
     capabilities: TrackWorkCapabilitiesSchema.optional(),
     debtPending: boolean2().optional(),
     ok: literal(true),
+    oldestQueuedCaptureOver24h: boolean2().optional(),
     queued: number2().optional(),
     tracks: array(TrackWorkItemSchema)
   }));
@@ -16413,6 +16511,7 @@ var init_search2 = __esm(() => {
     bpmMin: number2().optional(),
     key: string2().optional(),
     label: string2().optional(),
+    sound: string2().optional(),
     soundsLike: string2().optional(),
     soundsLikeArtists: array(string2()).max(6).optional(),
     text: string2().optional(),
@@ -16432,6 +16531,7 @@ var init_search2 = __esm(() => {
     logId: string2().optional(),
     previewable: boolean2().optional(),
     releaseDate: string2().optional(),
+    similar: boolean2().optional(),
     spotifyUrl: string2().optional(),
     title: string2(),
     trackId: string2()
@@ -16694,6 +16794,7 @@ var init_tracks = __esm(() => {
 var contract, CONTRACT_OPERATION_NAMES, CONTRACT_OPERATION_ROUTES;
 var init_orpc = __esm(() => {
   init_dist3();
+  init_admin_catalogue();
   init_admin_albums();
   init_admin_artifacts();
   init_admin_artist_rules();
@@ -19204,6 +19305,19 @@ async function mintLabelCommand(mbLabelId, seedState, takeOverSlug) {
   });
   return { label: response.label, outcome: response.outcome, takenOver: response.takenOver };
 }
+async function listLabelsAdminCommand(seedState) {
+  const query = seedState === undefined ? "" : `?seedState=${encodeURIComponent(seedState)}`;
+  const response = await adminApiGet(`/api/v1/admin/labels${query}`);
+  return response.labels;
+}
+async function recordLabelTriageCommand(slug, payload) {
+  const response = await adminApiPost(`/api/v1/admin/labels/${encodeURIComponent(slug.trim().toLowerCase())}/triage`, payload);
+  return {
+    droppedInertRules: response.droppedInertRules,
+    superseded: response.superseded,
+    triageCheckedAt: response.triageCheckedAt
+  };
+}
 async function describeLabelCommand(slug, options) {
   return adminApiPost(`/api/v1/admin/labels/${encodeURIComponent(slug)}/bio`, buildBioBody2(options));
 }
@@ -23013,6 +23127,33 @@ JSON field reference:
       console.log(line);
     }
   });
+  labels.command("list").description("List labels with their crawl-seed state and triage cursor").option("--seed-state <state>", "Only this state: enabled, disabled, or undecided").option("--json", "Print JSON", false).action(async (options) => {
+    const seedState = options.seedState;
+    if (seedState !== undefined && seedState !== "enabled" && seedState !== "disabled" && seedState !== "undecided") {
+      throw new Error("Pass --seed-state enabled|disabled|undecided");
+    }
+    await Promise.resolve().then(() => init_admin_labels2());
+    const labels = await listLabelsAdminCommand(seedState);
+    if (options.json) {
+      console.log(JSON.stringify({ labels }, null, 2));
+      return;
+    }
+    for (const label of labels) {
+      const looked = label.triageCheckedAt ? label.triageVerdict : "never looked";
+      console.log(`${label.slug}  ${label.seedState}  ${looked ?? ""}`.trimEnd());
+    }
+  });
+  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"));
+    await Promise.resolve().then(() => init_admin_labels2());
+    const result = await recordLabelTriageCommand(slug, payload);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const dropped = result.droppedInertRules > 0 ? ` \u2014 dropped ${result.droppedInertRules} inert` : "";
+    console.log(`${slug} \u2192 ${payload.verdict}${dropped}${result.superseded ? " (superseded)" : ""}`);
+  });
   labels.command("mint").description("Mint a label from its MusicBrainz MBID (operator; idempotent)").argument("<mbid>", "The MusicBrainz label MBID").option("--seed-state <state>", "Rule it on arrival: enabled, disabled, or undecided").option("--take-over <slug>", "Re-point this trackless row's identity onto the minted entity").option("--json", "Print JSON", false).action(async (mbid, options) => {
     const seedState = options.seedState;
     if (seedState !== undefined && seedState !== "enabled" && seedState !== "disabled" && seedState !== "undecided") {
@@ -26043,6 +26184,7 @@ var stringOptions = new Set([
   "--page-digest",
   "--page-limit",
   "--parent-id",
+  "--payload",
   "--plate",
   "--plate-background",
   "--platform",