fluncle 0.128.0 → 0.130.0

package/bin/fluncle.mjs

@@ -561,7 +561,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.128.0".trim() ? "0.128.0".trim() : "0.1.0";
+  currentVersion = "0.130.0".trim() ? "0.130.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.128.0".trim() ? "0.128.0".trim() : "0.1.0";
+  currentVersion2 = "0.130.0".trim() ? "0.130.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: [
@@ -3531,6 +3570,7 @@ var init_track2 = __esm(() => {
 var exports_admin_tracks = {};
 __export(exports_admin_tracks, {
   vehiclesCommand: () => vehiclesCommand,
+  trackWorkCommand: () => trackWorkCommand,
   requeueAnalysisCommand: () => requeueAnalysisCommand,
   queueCommand: () => queueCommand,
   observeQueueCommand: () => observeQueueCommand,
@@ -3632,6 +3672,15 @@ async function embedQueueCommand(limit) {
 async function captureQueueCommand(limit) {
   return fetchAdminTracks({ captureQueue: true, max: limit, order: "desc" });
 }
+async function trackWorkCommand(options) {
+  const params = new URLSearchParams({
+    kind: options.kind,
+    limit: String(Math.min(Math.max(1, options.limit), 200)),
+    scope: options.scope
+  });
+  const response = await adminApiGet(`/api/admin/tracks/work?${params.toString()}`);
+  return response.tracks ?? [];
+}
 async function requeueAnalysisCommand(options) {
   const findings = await fetchAdminTracks({ max: options.max, order: "asc" });
   const stale = findings.filter((track) => track.analyzedFrom !== "full");
@@ -4097,6 +4146,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) {
@@ -7960,6 +8026,10 @@ function addAdminCommands(program2) {
     const { captureQueueCommand: captureQueueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminCaptureQueue(options, captureQueueCommand2);
   });
+  adminTracks.command("work").description("The audio pipeline's worklist for one stage, in capture-priority order").requiredOption("--kind <kind>", "Pipeline stage: analyze | capture | embed").option("--scope <scope>", "Which half of the archive: all | catalogue | findings", "all").option("--limit <limit>", "Rows to show", "10").option("--json", "Print JSON", false).action(async (options) => {
+    const { trackWorkCommand: trackWorkCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runAdminTrackWork(options, trackWorkCommand2);
+  });
   adminTracks.command("requeue-analysis").description("Re-queue findings whose BPM/key are preview-grade (dry-run; --apply to flip)").option("--apply", "Actually flip statuses (default is a dry-run preview)", false).option("--limit <limit>", "Cap the archive walk (default: the whole archive)").option("--json", "Print JSON", false).action(async (options) => {
     const { requeueAnalysisCommand: requeueAnalysisCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runAdminRequeueAnalysis(options, requeueAnalysisCommand2);
@@ -8065,6 +8135,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();
@@ -9116,6 +9202,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>");
@@ -9629,6 +9748,42 @@ async function runAdminCaptureQueue(options, captureQueueCommand2) {
   console.log(trackRows2(tracks).join(`
 `));
 }
+var TRACK_WORK_KINDS = new Set(["analyze", "capture", "embed"]);
+var TRACK_WORK_SCOPES = new Set(["all", "catalogue", "findings"]);
+async function runAdminTrackWork(options, trackWorkCommand2) {
+  const kind = options.kind?.trim().toLowerCase() ?? "";
+  const scope = options.scope?.trim().toLowerCase() ?? "all";
+  if (!TRACK_WORK_KINDS.has(kind)) {
+    console.error(`--kind must be one of: analyze, capture, embed (got "${options.kind}")`);
+    process.exitCode = 1;
+    return;
+  }
+  if (!TRACK_WORK_SCOPES.has(scope)) {
+    console.error(`--scope must be one of: all, catalogue, findings (got "${options.scope}")`);
+    process.exitCode = 1;
+    return;
+  }
+  const tracks = await trackWorkCommand2({
+    kind,
+    limit: parseListLimit(options.limit),
+    scope
+  });
+  if (options.json) {
+    printJson({ ok: true, tracks });
+    return;
+  }
+  if (tracks.length === 0) {
+    console.log(`Nothing to ${kind}. The ${scope} queue is drained.`);
+    return;
+  }
+  const noun = tracks.length === 1 ? "track" : "tracks";
+  console.log(`${tracks.length} ${noun} to ${kind} (${scope}), in drain order:`);
+  for (const track of tracks) {
+    const who = track.logId ?? `${track.trackId} \xB7 catalogue`;
+    const rung = track.capturePriority === null ? "" : ` \xB7 p${track.capturePriority}`;
+    console.log(`  ${who}${rung} \u2014 ${track.artists.join(", ")} \u2014 ${track.title}`);
+  }
+}
 var REQUEUE_ANALYSIS_ARCHIVE_CAP = 1e6;
 function parseRequeueAnalysisLimit(value) {
   if (value === undefined) {
@@ -9970,6 +10125,7 @@ var stringOptions = new Set([
   "--scheduled-for",
   "--script",
   "--script-file",
+  "--scope",
   "--seed",
   "--soundcloud-url",
   "--source",

package/package.json

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