fluncle 0.127.0 → 0.129.0

package/bin/fluncle.mjs

@@ -561,7 +561,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.127.0".trim() ? "0.127.0".trim() : "0.1.0";
+  currentVersion = "0.129.0".trim() ? "0.129.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -2189,7 +2189,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.127.0".trim() ? "0.127.0".trim() : "0.1.0";
+  currentVersion2 = "0.129.0".trim() ? "0.129.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2346,6 +2346,34 @@ var init_src = __esm(() => {
       url: `${SITE}/artist`,
       weights: { ssh: "secondary", web: "secondary" }
     },
+    {
+      discoveryUrl: `${SITE}/llms.txt`,
+      exposedContent: [
+        "/labels — every record label Fluncle has found a banger on",
+        "/label/:slug — one label: its findings, the artists on it, and the rest of its catalogue"
+      ],
+      kind: "web_route",
+      name: "web.labels",
+      operatorNotes: "The label half of the graph (log ↔ artist ↔ label ↔ album). The INDEX is probeable (always 200); the slug page is not, so the probe targets /labels. A label below the renderable-track floor renders noindex + stays out of the sitemap (the ARTIST_INDEX_MIN_FINDINGS precedent). The page is BLIND to the label's crawl seed_state — that is crawl scope, never storage (docs/label-entity.md); the operator's ruling station is /admin/labels.",
+      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
+      route: "/labels",
+      url: `${SITE}/labels`,
+      weights: { web: "secondary" }
+    },
+    {
+      discoveryUrl: `${SITE}/llms.txt`,
+      exposedContent: [
+        "/albums — every record Fluncle has found a banger on",
+        "/album/:slug — one record: its findings, its artists, its label, and the rest of its tracklist"
+      ],
+      kind: "web_route",
+      name: "web.albums",
+      operatorNotes: "The album half of the graph, and the node that closes it: the album page carries the album → label edge (a link, plus `albumRelease.recordLabel` in its MusicAlbum JSON-LD). The INDEX is probeable (always 200); the slug page is not. Bounded by the archive, not the catalogue — an album earns a page by carrying a finding (docs/album-entity.md).",
+      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
+      route: "/albums",
+      url: `${SITE}/albums`,
+      weights: { web: "secondary" }
+    },
     {
       exposedContent: [
         "/galaxies — the browse-by-feel lens: the archive grouped into operator-named sonic galaxies (k-means over the MuQ audio embedding space)",
@@ -2982,6 +3010,17 @@ var init_src = __esm(() => {
       probeConfig: { cadenceMs: 20 * MINUTE_MS, cronName: "fluncle-clip-drip", kind: "cron" },
       weights: { status: "hidden" }
     },
+    {
+      command: "fluncle admin publish pause",
+      exposedContent: [
+        "advance one freshly-rendered finding into the publish push — YouTube Short + TikTok inbox draft (--no-agent, Worker HTTP)"
+      ],
+      kind: "cron",
+      name: "cron.publish-advance",
+      operatorNotes: "every 30m. Pure HTTP trigger, zero LLM tokens. The last autonomy gap: render finishes → this pushes, with no operator beat between. Admin tier (needs the Worker's Postiz key, which the box never sees — the box only triggers; the `drip_clips` / `capture_post_urls` precedent). SHIPS DARK: the Worker's kill switch is DEFAULT-DENY (only an explicit `false` in the `publish_advance_paused` setting runs it), so the timer ticks and posts nothing until `fluncle admin publish resume`. The Worker reads the switch FIRST, then advances at most ONE ready finding — both masters finalized, 15m settled, the whole bundle served on R2, the (track, platform) row CLAIMED atomically before any Postiz call, a rolling-24h cap of 6 pushes. A failed push is left `failed` for the operator and never auto-retried. Source: docs/agents/hermes/scripts/publish-advance-sweep.sh. Probed on /status as cron.publish-advance.",
+      probeConfig: { cadenceMs: 30 * MINUTE_MS, cronName: "fluncle-publish-advance", kind: "cron" },
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin tracks queue",
       exposedContent: [
@@ -4097,6 +4136,23 @@ var init_mixtape_youtube2 = __esm(() => {
   init_output();
 });
 
+// src/commands/publish.ts
+var exports_publish = {};
+__export(exports_publish, {
+  publishAdvancePauseCommand: () => publishAdvancePauseCommand,
+  publishAdvanceCommand: () => publishAdvanceCommand
+});
+async function publishAdvanceCommand() {
+  return adminApiPost("/api/admin/social/publish/advance", {});
+}
+async function publishAdvancePauseCommand(paused) {
+  const response = await adminApiPut("/api/admin/social/publish/advance/state", { paused });
+  return response.paused;
+}
+var init_publish = __esm(() => {
+  init_api();
+});
+
 // ../../packages/contracts/src/util/multipart.ts
 function planMultipart(contentLength, partSize = DEFAULT_PART_SIZE) {
   if (!Number.isInteger(contentLength) || contentLength <= 0) {
@@ -5295,6 +5351,29 @@ var init_auth_lastfm = __esm(() => {
   init_api();
 });
 
+// src/commands/admin-catalogue.ts
+var exports_admin_catalogue = {};
+__export(exports_admin_catalogue, {
+  catalogueRankCommand: () => catalogueRankCommand,
+  catalogueListCommand: () => catalogueListCommand
+});
+async function catalogueRankCommand(options) {
+  const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
+  const response = await adminApiPost("/api/admin/catalogue/rank", limit ? { limit } : {});
+  return response.summary;
+}
+async function catalogueListCommand(options) {
+  const params = new URLSearchParams;
+  params.set("lens", options.lens === "capture" ? "capture" : "ear");
+  if (options.limit) {
+    params.set("limit", options.limit);
+  }
+  return adminApiGet(`/api/admin/catalogue?${params.toString()}`);
+}
+var init_admin_catalogue = __esm(() => {
+  init_api();
+});
+
 // src/commands/admin-artists.ts
 var exports_admin_artists = {};
 __export(exports_admin_artists, {
@@ -8042,6 +8121,22 @@ function addAdminCommands(program2) {
     const { mixtapeResyncCommand: mixtapeResyncCommand2 } = await Promise.resolve().then(() => (init_mixtapes(), exports_mixtapes));
     await runMixtapeResync(idOrLogId, options, mixtapeResyncCommand2);
   });
+  const adminPublish = configureCommand(admin.command("publish").description("Render \u2192 publish auto-advance commands"));
+  adminPublish.action(() => {
+    adminPublish.outputHelp();
+  });
+  adminPublish.command("advance").description("Run one tick of the render \u2192 publish auto-advance (kill-switch aware)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+    const { publishAdvanceCommand: publishAdvanceCommand2 } = await Promise.resolve().then(() => (init_publish(), exports_publish));
+    await runPublishAdvance(options, publishAdvanceCommand2);
+  });
+  adminPublish.command("pause").description("Pause the render \u2192 publish auto-advance, the kill switch (operator)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+    const { publishAdvancePauseCommand: publishAdvancePauseCommand2 } = await Promise.resolve().then(() => (init_publish(), exports_publish));
+    await runPublishAdvancePause(true, options, publishAdvancePauseCommand2);
+  });
+  adminPublish.command("resume").description("Resume the render \u2192 publish auto-advance, clear the kill switch (operator)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+    const { publishAdvancePauseCommand: publishAdvancePauseCommand2 } = await Promise.resolve().then(() => (init_publish(), exports_publish));
+    await runPublishAdvancePause(false, options, publishAdvancePauseCommand2);
+  });
   const adminClips = configureCommand(admin.command("clips").description("Mixtape clip (Fluncle Studio) commands"));
   adminClips.action(() => {
     adminClips.outputHelp();
@@ -8212,6 +8307,18 @@ function addAdminCommands(program2) {
     const { galaxyMapWriteCommand: galaxyMapWriteCommand2 } = await Promise.resolve().then(() => (init_galaxies(), exports_galaxies));
     await runGalaxyMapWrite(options, galaxyMapWriteCommand2);
   });
+  const catalogue = configureCommand(admin.command("catalogue").description("The catalogue (uncertified tracks) + its ranking"));
+  catalogue.action(() => {
+    catalogue.outputHelp();
+  });
+  catalogue.command("rank").description("Run one tick of the ranking sweep (nearest finding + capture priority)").option("--limit <limit>", "Candidates per tick (default 250)").option("--json", "Print JSON", false).action(async (options) => {
+    const { catalogueRankCommand: catalogueRankCommand2 } = await Promise.resolve().then(() => (init_admin_catalogue(), exports_admin_catalogue));
+    await runCatalogueRank(options, catalogueRankCommand2);
+  });
+  catalogue.command("list").description("The ranked catalogue: closest to a finding (ear), or next to capture").option("--lens <lens>", "ear (default) or capture", "ear").option("--limit <limit>", "Rows (default 50, max 200)").option("--json", "Print JSON", false).action(async (options) => {
+    const { catalogueListCommand: catalogueListCommand2 } = await Promise.resolve().then(() => (init_admin_catalogue(), exports_admin_catalogue));
+    await runCatalogueList(options, catalogueListCommand2);
+  });
   const backfill = configureCommand(admin.command("backfills").description("Backfill operator-only archives"));
   backfill.action(() => {
     backfill.outputHelp();
@@ -9081,6 +9188,39 @@ async function runClipsDripPause(paused, options, clipDripPauseCommand2) {
   }
   console.log(result ? "The drip-feed is paused." : "The drip-feed is running.");
 }
+async function runPublishAdvance(options, publishAdvanceCommand2) {
+  const result = await publishAdvanceCommand2();
+  if (options.json) {
+    printJson(result);
+    return;
+  }
+  if (result.paused) {
+    console.log("Auto-advance is paused \u2014 nothing pushed.");
+    return;
+  }
+  if (result.pushed.length === 0 && result.held.length === 0 && result.failed.length === 0) {
+    console.log("Nothing ready to advance.");
+    return;
+  }
+  for (const push of result.pushed) {
+    console.log(`Pushed ${push.logId} to ${push.platform} (${push.status}).`);
+  }
+  for (const held of result.held) {
+    const detail = held.missing?.length ? ` (${held.missing.join(", ")})` : "";
+    console.log(`Held ${held.platform} for ${held.trackId}: ${held.reason}${detail}.`);
+  }
+  for (const failure of result.failed) {
+    console.log(`Failed ${failure.platform} for ${failure.trackId} \u2014 left for the operator.`);
+  }
+}
+async function runPublishAdvancePause(paused, options, publishAdvancePauseCommand2) {
+  const result = await publishAdvancePauseCommand2(paused);
+  if (options.json) {
+    printJson({ ok: true, paused: result });
+    return;
+  }
+  console.log(result ? "The publish auto-advance is paused." : "The publish auto-advance is running.");
+}
 async function runMixtapeGet(idOrLogId, options, mixtapeGetCommand2) {
   if (!idOrLogId) {
     throw new Error("Missing mixtape id or log id. Usage: fluncle admin mixtapes get <id|logId>");
@@ -9314,6 +9454,41 @@ async function runGalaxies(slug, options, commands) {
     console.log(`${galaxy.name.padEnd(40)} ${String(galaxy.memberCount).padStart(3)} finding${galaxy.memberCount === 1 ? "" : "s"}`);
   }
 }
+async function runCatalogueRank(options, catalogueRankCommand2) {
+  const summary = await catalogueRankCommand2({ limit: options.limit });
+  if (options.json) {
+    printJson({ ok: true, summary });
+    return;
+  }
+  console.log(`Ranked ${summary.scored} against ${summary.embeddedFindings} embedded findings; prioritized ${summary.prioritized} for capture. ${summary.remaining} still stale.`);
+}
+async function runCatalogueList(options, catalogueListCommand2) {
+  const { summary, tracks } = await catalogueListCommand2({
+    lens: options.lens,
+    limit: options.limit
+  });
+  if (options.json) {
+    printJson({ ok: true, summary, tracks });
+    return;
+  }
+  if (tracks.length === 0) {
+    console.log("Nothing out there yet.");
+    return;
+  }
+  for (const track of tracks) {
+    const identity = `${track.artists.join(", ")} \u2014 ${track.title}`;
+    if (options.lens === "capture") {
+      const reason = track.captureReason;
+      const why2 = reason?.kind === "artist" ? `${reason.name} is already in the archive` : reason?.kind === "label" ? `${reason.name} already carries a finding` : reason?.kind === "seed-label" ? `${reason.name} is a label the crawler digs from` : reason?.kind === "skipped-label" ? `${reason.name} is not your lane \u2014 ranked last, kept anyway` : "nothing ties it to the archive yet";
+      console.log(`${String(track.capturePriority ?? 0)}  ${identity.padEnd(52)} ${why2}`);
+      continue;
+    }
+    const match = track.nearestFinding;
+    const score = track.nearestFindingScore?.toFixed(2) ?? "\u2014";
+    const why = match ? `closest to ${match.logId ? `${match.logId} ` : ""}${match.artists.join(", ")} \u2014 ${match.title}` : "nothing to compare it to yet";
+    console.log(`${score}  ${identity.padEnd(52)} ${why}`);
+  }
+}
 async function runGalaxyMapRead(options, galaxyMapReadCommand2) {
   const galaxies = await galaxyMapReadCommand2();
   if (options.json) {
@@ -9878,6 +10053,7 @@ var stringOptions = new Set([
   "--key-confidence",
   "--key-source",
   "--kind",
+  "--lens",
   "--limit",
   "--metrics",
   "--mime",

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.127.0"
+  "version": "0.129.0"
 }