fluncle 0.135.0 → 0.137.0

package/bin/fluncle.mjs

@@ -561,7 +561,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.135.0".trim() ? "0.135.0".trim() : "0.1.0";
+  currentVersion = "0.137.0".trim() ? "0.137.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.135.0".trim() ? "0.135.0".trim() : "0.1.0";
+  currentVersion2 = "0.137.0".trim() ? "0.137.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2247,11 +2247,11 @@ var init_src = __esm(() => {
     },
     {
       exposedContent: [
-        "the mixability set-builder — chain a set from Fluncle's findings that mixes clean, share it as a link"
+        "the free mixing tool — name artists you like, and Fluncle ranks what mixes in clean next from the whole archive; chain a set and share it as a link"
       ],
       kind: "web_route",
       name: "web.mix",
-      operatorNotes: "ADMIN-GATED at launch (RFC mixability-engine, Decision 1): the full /mix set-builder ships behind admin auth until the archive clears the ~250-finding floor. Registered here as `pending` (dark to every public consumer — the dev-row, llms.txt, the sitemap, /status) so going public is one flip: remove `pending` + set a web weight + announce. The `list_mixable_tracks` API op already ships at its final public tier, so the flip needs no rebuild. No probeConfig — the admin gate 302s a bare GET to /admin/login, which would read as a false 'down'.",
+      operatorNotes: "PUBLIC-CAPABLE, gated by a SELF-LIFTING DEPTH MEASUREMENT (not admin auth). The old ~250-finding / admin gate is gone: `/mix` now measures the live archive on every load (`getMixChainDepth` — can the median track reach a full set + rail by a named harmonic move?) and opens to the world on its own the day the catalogue lands enough keyed depth. Until then a stranger is redirected home and the operator still gets in to dogfood. This entry stays `pending` (dark to the dev-row, llms.txt, the sitemap, /status) ONLY so we do not advertise a URL that still redirects — the flip is: confirm the depth gate has opened in prod, remove `pending`, announce. The web weight is pre-set, so the flip needs no other change. No probeConfig — a closed gate 302s a bare GET, which would read as a false 'down'.",
       pending: true,
       route: "/mix",
       url: `${SITE}/mix`,
@@ -3443,6 +3443,9 @@ async function trackObserveCommand(idOrLogId, options) {
   if (options.durationTargetSec !== undefined) {
     body.durationTargetSec = options.durationTargetSec;
   }
+  if (typeof options.promptVersion === "number") {
+    body.promptVersion = options.promptVersion;
+  }
   if (options.contextNote !== undefined) {
     body.contextNote = options.contextNote;
   }
@@ -3466,6 +3469,9 @@ async function trackNoteCommand(idOrLogId, options) {
   if (options.dryRun) {
     body.dryRun = true;
   }
+  if (typeof options.promptVersion === "number") {
+    body.promptVersion = options.promptVersion;
+  }
   return adminApiPost(`/api/admin/tracks/${encodeURIComponent(idOrLogId)}/note`, body);
 }
 var DEFAULT_VIDEO_MODEL = "anthropic/claude-opus-4-8", DEFAULT_VIDEO_REASONING = "high", FOUND_BASE = "https://found.fluncle.com", VIDEO_FIELDS, RERENDER_CONTRACT_FIELDS, RERENDER_ADVISORY_FIELDS, FOOTAGE_FIELDS, PLATE_FIELDS, NON_FILE_OPTIONS;
@@ -5018,6 +5024,9 @@ function buildBody2(options, { requireContent }) {
   } else if (requireContent) {
     throw new CliError2("missing_content", "A draft needs the structured content payload via --content-file <edition.json>");
   }
+  if (requireContent && typeof options.promptVersion === "number") {
+    body.promptVersion = options.promptVersion;
+  }
   if (options.subject !== undefined) {
     body.subject = options.subject;
   }
@@ -5095,6 +5104,7 @@ function requireTitle(options) {
 async function logbookCreateCommand(sector, options) {
   return adminApiPost(`/api/admin/logbook/${encodeURIComponent(sector)}`, {
     body: resolveBody(options),
+    ...typeof options.promptVersion === "number" ? { promptVersion: options.promptVersion } : {},
     title: requireTitle(options)
   });
 }
@@ -5109,6 +5119,193 @@ var init_admin_logbook = __esm(() => {
   init_output();
 });
 
+// src/commands/admin-prompts.ts
+var exports_admin_prompts = {};
+__export(exports_admin_prompts, {
+  renderDiff: () => renderDiff,
+  promptsListCommand: () => promptsListCommand,
+  promptUpdateCommand: () => promptUpdateCommand,
+  promptRows: () => promptRows,
+  promptRollbackCommand: () => promptRollbackCommand,
+  promptResetCommand: () => promptResetCommand,
+  promptGetCommand: () => promptGetCommand,
+  promptDiffCommand: () => promptDiffCommand,
+  promptDetailCommand: () => promptDetailCommand,
+  parseVersion: () => parseVersion3,
+  parseAgainst: () => parseAgainst,
+  historyRows: () => historyRows,
+  diffLines: () => diffLines,
+  bodyLines: () => bodyLines
+});
+import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
+async function promptsListCommand() {
+  const response = await adminApiGet("/api/admin/prompts");
+  return response.prompts;
+}
+async function promptGetCommand(slug) {
+  return adminApiGet(`/api/admin/prompts/${encodeURIComponent(slug)}`);
+}
+async function promptDetailCommand(slug) {
+  const prompts = await promptsListCommand();
+  const detail = prompts.find((prompt) => prompt.slug === slug);
+  if (!detail) {
+    throw new CliError2("unknown_prompt", `No prompt goes by "${slug}". The registered ones: ${prompts.map((prompt) => prompt.slug).join(", ")}`);
+  }
+  return detail;
+}
+function resolveBody2(options) {
+  if (options.bodyFile === undefined) {
+    throw new CliError2("missing_body", "An edit needs a body via --body-file <prompt.txt>. Start from `fluncle admin prompts get <slug> --json | jq -r .body`.");
+  }
+  if (!existsSync6(options.bodyFile)) {
+    throw new CliError2("file_not_found", `Body file not found: ${options.bodyFile}`);
+  }
+  const body = readFileSync6(options.bodyFile, "utf-8");
+  if (body.trim().length === 0) {
+    throw new CliError2("empty_body", "A prompt body cannot be empty. Nothing was appended.");
+  }
+  return body;
+}
+async function promptUpdateCommand(slug, options) {
+  const body = resolveBody2(options);
+  const note = options.note?.trim();
+  const response = await adminApiPost(`/api/admin/prompts/${encodeURIComponent(slug)}`, note ? { body, note } : { body });
+  return { slug, version: response.version };
+}
+async function promptRollbackCommand(slug, version) {
+  const detail = await promptDetailCommand(slug);
+  const target = detail.versions.find((candidate) => candidate.version === version);
+  if (!target) {
+    const known = detail.versions.map((candidate) => `v${candidate.version}`).join(", ");
+    throw new CliError2("unknown_version", known.length > 0 ? `${slug} has no v${version}. On file: ${known}. For the repo's baked default, run \`fluncle admin prompts reset ${slug}\`.` : `${slug} has no history yet: the repo's baked default is what runs. There is nothing to roll back to.`);
+  }
+  return restore(detail, { body: target.body, from: version, note: `rolled back to v${version}` });
+}
+async function promptResetCommand(slug) {
+  const detail = await promptDetailCommand(slug);
+  return restore(detail, {
+    body: detail.defaultBody,
+    from: 0,
+    note: "reset to the repo's baked default"
+  });
+}
+async function restore(detail, input) {
+  if (input.body.trim() === detail.activeBody.trim()) {
+    return { from: input.from, skipped: true, slug: detail.slug, version: detail.activeVersion };
+  }
+  const response = await adminApiPost(`/api/admin/prompts/${encodeURIComponent(detail.slug)}`, { body: input.body, note: input.note });
+  return { from: input.from, skipped: false, slug: detail.slug, version: response.version };
+}
+function parseAgainst(value) {
+  if (value === undefined || value.trim().toLowerCase() === "default") {
+    return { kind: "default" };
+  }
+  const version = parseVersion3(value);
+  if (version === undefined) {
+    throw new CliError2("invalid_against", `--against takes a version (3, or v3) or the word default. Got "${value}".`);
+  }
+  return { kind: "version", version };
+}
+function parseVersion3(value) {
+  const digits = /^v?(\d+)$/.exec(value.trim());
+  const parsed = digits?.[1];
+  if (parsed === undefined) {
+    return;
+  }
+  const version = Number.parseInt(parsed, 10);
+  return Number.isFinite(version) && version > 0 ? version : undefined;
+}
+function bodyLines(body) {
+  return body.replace(/\r\n/g, `
+`).replace(/\n+$/, "").split(`
+`);
+}
+function diffLines(before, after) {
+  const rows = before.length;
+  const cols = after.length;
+  const width = cols + 1;
+  const lengths = new Int32Array((rows + 1) * width);
+  const lcs = (row2, col2) => lengths[row2 * width + col2] ?? 0;
+  for (let row2 = rows - 1;row2 >= 0; row2 -= 1) {
+    for (let col2 = cols - 1;col2 >= 0; col2 -= 1) {
+      lengths[row2 * width + col2] = before[row2] === after[col2] ? lcs(row2 + 1, col2 + 1) + 1 : Math.max(lcs(row2 + 1, col2), lcs(row2, col2 + 1));
+    }
+  }
+  const lines = [];
+  let row = 0;
+  let col = 0;
+  while (row < rows && col < cols) {
+    if (before[row] === after[col]) {
+      lines.push({ kind: "context", text: before[row] ?? "" });
+      row += 1;
+      col += 1;
+      continue;
+    }
+    if (lcs(row + 1, col) >= lcs(row, col + 1)) {
+      lines.push({ kind: "remove", text: before[row] ?? "" });
+      row += 1;
+      continue;
+    }
+    lines.push({ kind: "add", text: after[col] ?? "" });
+    col += 1;
+  }
+  while (row < rows) {
+    lines.push({ kind: "remove", text: before[row] ?? "" });
+    row += 1;
+  }
+  while (col < cols) {
+    lines.push({ kind: "add", text: after[col] ?? "" });
+    col += 1;
+  }
+  return lines;
+}
+function renderDiff(lines) {
+  return lines.map((line) => {
+    const marker = line.kind === "add" ? "+" : line.kind === "remove" ? "-" : " ";
+    return `${marker} ${line.text}`;
+  });
+}
+async function promptDiffCommand(slug, against) {
+  const detail = await promptDetailCommand(slug);
+  const from = against.kind === "default" ? { body: detail.defaultBody, label: "the repo's baked default", version: 0 } : resolveAgainstVersion(detail, against.version);
+  const lines = diffLines(bodyLines(from.body), bodyLines(detail.activeBody));
+  return {
+    added: lines.filter((line) => line.kind === "add").length,
+    against: { label: from.label, version: from.version },
+    lines,
+    live: { source: detail.source, version: detail.activeVersion },
+    removed: lines.filter((line) => line.kind === "remove").length,
+    slug: detail.slug
+  };
+}
+function resolveAgainstVersion(detail, version) {
+  const target = detail.versions.find((candidate) => candidate.version === version);
+  if (!target) {
+    const known = detail.versions.map((candidate) => `v${candidate.version}`).join(", ");
+    throw new CliError2("unknown_version", known.length > 0 ? `${detail.slug} has no v${version}. On file: ${known}.` : `${detail.slug} has no history yet. Diff against the repo's default instead: drop --against.`);
+  }
+  return { body: target.body, label: `v${version}`, version };
+}
+function promptRows(prompts) {
+  const slugWidth = prompts.reduce((width, prompt) => Math.max(width, prompt.slug.length), 0);
+  const surfaceWidth = prompts.reduce((width, prompt) => Math.max(width, prompt.surface.length), 0);
+  return prompts.map((prompt) => {
+    const live = prompt.source === "override" ? `v${prompt.activeVersion}` : "default";
+    return `${prompt.slug.padEnd(slugWidth)}  ${prompt.surface.padEnd(surfaceWidth)}  ${live.padEnd(7)}  ${prompt.title}`;
+  });
+}
+function historyRows(versions) {
+  return versions.map((version) => {
+    const when = version.createdAt.slice(0, 10);
+    const note = version.note?.trim();
+    return `v${version.version}  ${when}  ${version.createdBy.padEnd(8)}  ${note && note.length > 0 ? note : "(no note)"}`;
+  });
+}
+var init_admin_prompts = __esm(() => {
+  init_api();
+  init_output();
+});
+
 // src/commands/add.ts
 async function addCommand2(spotifyUrl, options) {
   const result = await adminApiPost("/api/admin/tracks", {
@@ -5197,7 +5394,10 @@ async function approveSubmissionCommand(submissionId, options = {}) {
   console.log(`Approved ${formatTrackLine(submission)}.`);
 }
 async function triageSubmissionCommand(submissionId, verdict, options = {}) {
-  const response = await adminApiPost(`/api/admin/submissions/${encodeURIComponent(submissionId)}/triage`, { verdict });
+  const response = await adminApiPost(`/api/admin/submissions/${encodeURIComponent(submissionId)}/triage`, {
+    ...typeof options.promptVersion === "number" ? { promptVersion: options.promptVersion } : {},
+    verdict
+  });
   if (options.json) {
     printJson2({ ok: true, submission: response.submission });
     return;
@@ -5546,6 +5746,22 @@ var init_admin_artists = __esm(() => {
   init_api();
 });
 
+// src/commands/admin-labels.ts
+var exports_admin_labels = {};
+__export(exports_admin_labels, {
+  backfillLabelImagesCommand: () => backfillLabelImagesCommand
+});
+async function backfillLabelImagesCommand(limit, dryRun, cursor) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  return adminApiPost(`/api/admin/backfill/label-images?${params.toString()}`);
+}
+var init_admin_labels = __esm(() => {
+  init_api();
+});
+
 // src/commands/preview-migration.ts
 var exports_preview_migration = {};
 __export(exports_preview_migration, {
@@ -5845,7 +6061,7 @@ var init_format2 = __esm(() => {
 });
 
 // src/cli.ts
-import { existsSync as existsSync6, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import path2 from "path";
 
 // ../../node_modules/commander/lib/error.js
@@ -8210,7 +8426,7 @@ function addAdminCommands(program2) {
     const { previewArchiveUploadCommand: previewArchiveUploadCommand2 } = await Promise.resolve().then(() => (init_preview_archive(), exports_preview_archive));
     await runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCommand2);
   });
-  adminTrack.command("observe").description("Render Fluncle's spoken field observation for a track (Cartesia, Worker-side)").argument("[idOrLogId]").option("--queue", "Show the observe worklist (notes but no observation yet), oldest first", false).option("--limit <limit>", "Number of findings to show with --queue", "10").option("--script <text>", "The voice-gated observation script (the spoken text)").option("--script-file <file>", "Read the observation script from a file (e.g. observation.txt)").option("--voice-id <id>", "Override the configured Cartesia voice id").option("--duration-ms <ms>", "Probed audio duration in ms (else derived from word timestamps)").option("--duration-target-sec <sec>", "Target observation length in seconds (20\u201345)").option("--context-note <text>", "Pre-fetched factual context (else the Worker firecrawls)").option("--force", "Re-render even if an observation already exists (voice re-tune / fix)", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
+  adminTrack.command("observe").description("Render Fluncle's spoken field observation for a track (Cartesia, Worker-side)").argument("[idOrLogId]").option("--queue", "Show the observe worklist (notes but no observation yet), oldest first", false).option("--limit <limit>", "Number of findings to show with --queue", "10").option("--script <text>", "The voice-gated observation script (the spoken text)").option("--script-file <file>", "Read the observation script from a file (e.g. observation.txt)").option("--voice-id <id>", "Override the configured Cartesia voice id").option("--duration-ms <ms>", "Probed audio duration in ms (else derived from word timestamps)").option("--duration-target-sec <sec>", "Target observation length in seconds (20\u201345)").option("--context-note <text>", "Pre-fetched factual context (else the Worker firecrawls)").option("--prompt-version <n>", "The prompt-registry version that authored this (the sweep sends it; it is the artifact's provenance)").option("--force", "Re-render even if an observation already exists (voice re-tune / fix)", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
     if (options.queue) {
       const { observeQueueCommand: observeQueueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
       await runAdminObserveQueue(options, observeQueueCommand2);
@@ -8228,7 +8444,7 @@ function addAdminCommands(program2) {
     const { trackContextCommand: trackContextCommand2 } = await Promise.resolve().then(() => (init_track(), exports_track));
     await runTrackContext(idOrLogId, options, trackContextCommand2);
   });
-  adminTrack.command("note").description("Author the editorial note for a finding (fills an empty note only)").argument("[idOrLogId]").option("--queue", "Show the note worklist (context'd findings with no note yet), oldest first", false).option("--limit <limit>", "Number of findings to show with --queue", "10").option("--script <text>", "The voice-gated editorial note").option("--script-file <file>", "Read the editorial note from a file").option("--dry-run", "Run the voice + echo gates and report the verdict without storing anything", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
+  adminTrack.command("note").description("Author the editorial note for a finding (fills an empty note only)").argument("[idOrLogId]").option("--queue", "Show the note worklist (context'd findings with no note yet), oldest first", false).option("--limit <limit>", "Number of findings to show with --queue", "10").option("--script <text>", "The voice-gated editorial note").option("--script-file <file>", "Read the editorial note from a file").option("--prompt-version <n>", "The prompt-registry version that authored the note (the sweep sends this; it is the note's provenance)").option("--dry-run", "Run the voice + echo gates and report the verdict without storing anything", false).option("--json", "Print JSON", false).allowExcessArguments().action(async (idOrLogId, options) => {
     if (options.queue) {
       const { noteQueueCommand: noteQueueCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
       await runAdminNoteQueue(options, noteQueueCommand2);
@@ -8361,9 +8577,9 @@ function addAdminCommands(program2) {
   adminNewsletter.action(() => {
     adminNewsletter.outputHelp();
   });
-  adminNewsletter.command("draft").description("Persist a newsletter edition draft (the agent authors it, you send it)").option("--content-file <file>", "Structured edition content payload (JSON)").option("--subject <text>", "Email subject line").option("--window-since <date>", "Discovery-window start (ISO)").option("--window-until <date>", "Discovery-window end (ISO)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+  adminNewsletter.command("draft").description("Persist a newsletter edition draft (the agent authors it, you send it)").option("--content-file <file>", "Structured edition content payload (JSON)").option("--subject <text>", "Email subject line").option("--window-since <date>", "Discovery-window start (ISO)").option("--window-until <date>", "Discovery-window end (ISO)").option("--prompt-version <n>", "The prompt-registry version that authored this (the sweep sends it; it is the edition's provenance)").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
     const { newsletterDraftCommand: newsletterDraftCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
-    await runNewsletterDraft(options, newsletterDraftCommand2);
+    await runNewsletterDraft({ ...options, promptVersion: parsePromptVersion(options.promptVersion) }, newsletterDraftCommand2);
   });
   adminNewsletter.command("update").description("Update a draft edition's payload, subject, or window").argument("[id]").option("--content-file <file>", "Structured edition content payload (JSON)").option("--subject <text>", "Email subject line").option("--window-since <date>", "Discovery-window start (ISO)").option("--window-until <date>", "Discovery-window end (ISO)").option("--json", "Print JSON", false).allowExcessArguments().action(async (id, options) => {
     const { newsletterUpdateCommand: newsletterUpdateCommand2 } = await Promise.resolve().then(() => (init_newsletter(), exports_newsletter));
@@ -8389,7 +8605,7 @@ function addAdminCommands(program2) {
     const { logbookGapsCommand: logbookGapsCommand2 } = await Promise.resolve().then(() => (init_admin_logbook(), exports_admin_logbook));
     await runLogbookGaps(options, logbookGapsCommand2);
   });
-  adminLogbook.command("create").description("Author a sector-day's entry (fills an empty sector only)").argument("[sector]").option("--title <text>", "The entry title").option("--body <text>", "The entry body (markdown; [[logId]] figure tokens)").option("--body-file <file>", "Read the body from a file (the sweep's path)").option("--json", "Print JSON", false).allowExcessArguments().action(async (sector, options) => {
+  adminLogbook.command("create").description("Author a sector-day's entry (fills an empty sector only)").argument("[sector]").option("--title <text>", "The entry title").option("--body <text>", "The entry body (markdown; [[logId]] figure tokens)").option("--body-file <file>", "Read the body from a file (the sweep's path)").option("--prompt-version <n>", "The prompt-registry version that authored this (the sweep sends it; it is the artifact's provenance)").option("--json", "Print JSON", false).allowExcessArguments().action(async (sector, options) => {
     const { logbookCreateCommand: logbookCreateCommand2 } = await Promise.resolve().then(() => (init_admin_logbook(), exports_admin_logbook));
     await runLogbookWrite(sector, options, logbookCreateCommand2);
   });
@@ -8397,6 +8613,38 @@ function addAdminCommands(program2) {
     const { logbookUpdateCommand: logbookUpdateCommand2 } = await Promise.resolve().then(() => (init_admin_logbook(), exports_admin_logbook));
     await runLogbookWrite(sector, options, logbookUpdateCommand2);
   });
+  const adminPrompts = configureCommand(admin.command("prompts").description("The prompt registry: what Fluncle tells the models"));
+  adminPrompts.action(() => {
+    adminPrompts.outputHelp();
+  });
+  adminPrompts.command("list").description("Every prompt: where it runs, and whether the repo default or an edit is live").option("--json", "Print JSON", false).allowExcessArguments().action(async (options) => {
+    const { promptsListCommand: promptsListCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptsList(options, promptsListCommand2);
+  });
+  adminPrompts.command("get").description("The body running right now, with its version and source").argument("[slug]").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
+    const { promptGetCommand: promptGetCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptGet(slug, options, promptGetCommand2);
+  });
+  adminPrompts.command("history").description("Every version of a prompt, newest first: when, who, and the why").argument("[slug]").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
+    const { promptDetailCommand: promptDetailCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptHistory(slug, options, promptDetailCommand2);
+  });
+  adminPrompts.command("diff").description("Line diff: the live body against the repo default, or against a version").argument("[slug]").option("--against <version>", "A version (3, or v3) or the word default", "default").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
+    const { parseAgainst: parseAgainst2, promptDiffCommand: promptDiffCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptDiff(slug, options, { parseAgainst: parseAgainst2, promptDiffCommand: promptDiffCommand2 });
+  });
+  adminPrompts.command("update").description("Append an edited body as a new version. OPERATOR only").argument("[slug]").option("--body-file <file>", "Read the new prompt body from a file").option("--note <text>", 'The why, for the history ("shortened the neighbour block")').option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
+    const { promptUpdateCommand: promptUpdateCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptUpdate(slug, options, promptUpdateCommand2);
+  });
+  adminPrompts.command("rollback").description("Put an old version's body back, as a new version. OPERATOR only").argument("[slug]").argument("[version]").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, version, options) => {
+    const { parseVersion: parseVersion4, promptRollbackCommand: promptRollbackCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptRollback(slug, version, options, { parseVersion: parseVersion4, promptRollbackCommand: promptRollbackCommand2 });
+  });
+  adminPrompts.command("reset").description("Put the repo's baked default back, as a new version. OPERATOR only").argument("[slug]").option("--json", "Print JSON", false).allowExcessArguments().action(async (slug, options) => {
+    const { promptResetCommand: promptResetCommand2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+    await runPromptReset(slug, options, promptResetCommand2);
+  });
   const submissions = configureCommand(admin.command("submissions").description("Review listener submissions"));
   submissions.option("--json", "Print JSON", false).action(async (options) => {
     const { listSubmissionsCommand: listSubmissionsCommand2 } = await Promise.resolve().then(() => (init_submissions(), exports_submissions));
@@ -8423,16 +8671,19 @@ function addAdminCommands(program2) {
     const { approveSubmissionCommand: approveSubmissionCommand2 } = await Promise.resolve().then(() => (init_submissions(), exports_submissions));
     await approveSubmissionCommand2(submissionId, options);
   });
-  submissions.command("triage").description("Write the pre-chew triage verdict onto a pending submission").argument("[submissionId]").option("--verdict <text>", "The triage verdict one-liner").option("--verdict-file <file>", "Read the verdict from a file").option("--json", "Print JSON", false).action(async (submissionId, options) => {
+  submissions.command("triage").description("Write the pre-chew triage verdict onto a pending submission").argument("[submissionId]").option("--verdict <text>", "The triage verdict one-liner").option("--verdict-file <file>", "Read the verdict from a file").option("--prompt-version <n>", "The prompt-registry version that authored this (the sweep sends it; it is the artifact's provenance)").option("--json", "Print JSON", false).action(async (submissionId, options) => {
     if (!submissionId) {
       throw new Error("Missing submission id for: triage");
     }
-    const verdict = options.verdictFile ? readFileSync6(options.verdictFile, "utf8") : options.verdict;
+    const verdict = options.verdictFile ? readFileSync7(options.verdictFile, "utf8") : options.verdict;
     if (!verdict || !verdict.trim()) {
       throw new Error("Usage: fluncle admin submissions triage <submissionId> (--verdict <text> | --verdict-file <file>) [--json]");
     }
     const { triageSubmissionCommand: triageSubmissionCommand2 } = await Promise.resolve().then(() => (init_submissions(), exports_submissions));
-    await triageSubmissionCommand2(submissionId, verdict, { json: options.json });
+    await triageSubmissionCommand2(submissionId, verdict, {
+      json: options.json,
+      promptVersion: parsePromptVersion(options.promptVersion)
+    });
   });
   const auth = configureCommand(admin.command("auth").description("Authentication commands"));
   auth.command("spotify").description("Authorize Spotify access").action(async () => {
@@ -8527,6 +8778,10 @@ function addAdminCommands(program2) {
     const { backfillArtistImagesCommand: backfillArtistImagesCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
     await runBackfillArtistImages(options, backfillArtistImagesCommand2);
   });
+  backfill.command("label-images").description("Resolve label logos (Discogs \u2192 Wikidata) into R2 for existing labels").option("--dry-run", "Report the eligible worklist without any vendor call or write", false).option("--limit <limit>", "Max labels to process", "50").option("--json", "Print JSON", false).action(async (options) => {
+    const { backfillLabelImagesCommand: backfillLabelImagesCommand2 } = await Promise.resolve().then(() => (init_admin_labels(), exports_admin_labels));
+    await runBackfillLabelImages(options, backfillLabelImagesCommand2);
+  });
   artists.command("resolve").description("Resolve an artist's social identity (MB url-rels + Firecrawl gap-fill)").argument("[artistId]").option("--queue", "Show the resolve worklist (artists awaiting resolution), oldest first", false).option("--limit <limit>", "Number of artists to show with --queue", "50").option("--json", "Print JSON", false).allowExcessArguments().action(async (artistId, options) => {
     if (options.queue) {
       const { listArtistsCommand: listArtistsCommand2 } = await Promise.resolve().then(() => (init_admin_artists(), exports_admin_artists));
@@ -8564,7 +8819,7 @@ async function runTrackPreviewArchive(idOrLogId, options, previewArchiveUploadCo
   console.log(`  mime: ${result.mime}`);
 }
 async function runTrackObserve(idOrLogId, options, trackObserveCommand2) {
-  const script = options.scriptFile ? readFileSync6(options.scriptFile, "utf8") : options.script;
+  const script = options.scriptFile ? readFileSync7(options.scriptFile, "utf8") : options.script;
   if (!idOrLogId || !script || !script.trim()) {
     throw new Error("Usage: fluncle admin tracks observe <track_id|log_id> (--script <text> | --script-file <file>) [--voice-id <id>] [--duration-ms <ms>] [--context-note <text>] [--json]");
   }
@@ -8581,6 +8836,7 @@ async function runTrackObserve(idOrLogId, options, trackObserveCommand2) {
     durationMs,
     durationTargetSec,
     force: options.force,
+    promptVersion: parsePromptVersion(options.promptVersion),
     script: script.trim(),
     voiceId: options.voiceId
   });
@@ -8619,14 +8875,22 @@ async function runTrackContext(idOrLogId, options, trackContextCommand2) {
     console.log(`  sources: ${result.sources.join(", ")}`);
   }
 }
+function parsePromptVersion(raw) {
+  if (raw === undefined) {
+    return;
+  }
+  const parsed = Number(raw);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
 async function runTrackNote(idOrLogId, options, trackNoteCommand2) {
-  const note = options.scriptFile ? readFileSync6(options.scriptFile, "utf8") : options.script;
+  const note = options.scriptFile ? readFileSync7(options.scriptFile, "utf8") : options.script;
   if (!idOrLogId || !note || !note.trim()) {
     throw new Error("Usage: fluncle admin tracks note <track_id|log_id> (--script <text> | --script-file <file>) [--dry-run] [--json]");
   }
   const result = await trackNoteCommand2(idOrLogId, {
     dryRun: options.dryRun,
-    note: note.trim()
+    note: note.trim(),
+    promptVersion: parsePromptVersion(options.promptVersion)
   });
   if (options.json) {
     printJson(result);
@@ -9009,6 +9273,63 @@ async function runBackfillArtistImages(options, backfillArtistImagesCommand2) {
     process.exitCode = 1;
   }
 }
+async function runBackfillLabelImages(options, backfillLabelImagesCommand2) {
+  const limit = parseListLimit(options.limit);
+  const resolved = [];
+  const none = [];
+  const failed = [];
+  let cursor;
+  let dryRun = options.dryRun;
+  let throttled = false;
+  while (resolved.length + none.length + failed.length < limit) {
+    const remaining = limit - (resolved.length + none.length + failed.length);
+    const result = await backfillLabelImagesCommand2(remaining, options.dryRun, cursor);
+    dryRun = result.dryRun;
+    resolved.push(...result.resolved);
+    none.push(...result.none);
+    failed.push(...result.failed);
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would resolve" : "resolved";
+      console.log(`  \u2026${verb2} ${result.resolvedCount}; ${result.noneCount} without an image; ${result.failedCount} failed`);
+    }
+    if (result.rateLimited) {
+      throttled = true;
+      break;
+    }
+    if (result.nextCursor === null) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
+  if (options.json) {
+    printJson({
+      dryRun,
+      failed,
+      failedCount: failed.length,
+      none,
+      noneCount: none.length,
+      ok: true,
+      rateLimited: throttled,
+      resolved,
+      resolvedCount: resolved.length
+    });
+    if (failed.length > 0) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+  const verb = dryRun ? "Would resolve" : "Resolved";
+  console.log(`${verb} ${resolved.length} label logo(s); ${none.length} without an image; ${failed.length} failed.`);
+  for (const slug of resolved) {
+    console.log(`  ${slug}`);
+  }
+  for (const item of failed) {
+    console.log(`  ${item.slug}: ${item.error}`);
+  }
+  if (failed.length > 0) {
+    process.exitCode = 1;
+  }
+}
 async function runArtistResolveQueue(options, listArtistsCommand2) {
   const limit = parseListLimit(options.limit);
   const result = await listArtistsCommand2(limit ?? 50);
@@ -9059,7 +9380,7 @@ async function runTrackVideo(idOrLogId, options, trackVideoCommand2) {
       return;
     }
     const candidate = path2.join(dir, name);
-    return existsSync6(candidate) ? candidate : undefined;
+    return existsSync7(candidate) ? candidate : undefined;
   };
   const resolveFile = (explicit, name) => {
     if (explicit) {
@@ -9271,7 +9592,7 @@ async function runTrackUpdate(trackId, options, trackUpdateCommand3) {
   if (options.analyzedFrom !== undefined && options.analyzedFrom !== "full" && options.analyzedFrom !== "preview") {
     throw new Error(`Invalid --analyzed-from: ${options.analyzedFrom} (expected full or preview)`);
   }
-  const embeddingRaw = options.embeddingFile ? readFileSync6(options.embeddingFile, "utf8") : options.embedding;
+  const embeddingRaw = options.embeddingFile ? readFileSync7(options.embeddingFile, "utf8") : options.embedding;
   const embedding = parseEmbeddingArg(embeddingRaw);
   const result = await trackUpdateCommand3(trackId, {
     analyzedAt: options.analyzedAt,
@@ -9644,6 +9965,7 @@ async function runLogbookWrite(sector, options, writeCommand) {
   const result = await writeCommand(sector, {
     body: options.body,
     bodyFile: options.bodyFile,
+    promptVersion: parsePromptVersion(options.promptVersion),
     title: options.title
   });
   if (options.json) {
@@ -9653,6 +9975,109 @@ async function runLogbookWrite(sector, options, writeCommand) {
   const skipped = "skipped" in result && result.skipped;
   console.log(skipped ? `sector ${result.entry.sector}: an entry already stands \u2014 no-op (${result.entry.generatedBy})` : `sector ${result.entry.sector}: ${result.entry.title}`);
 }
+function requirePromptSlug(slug) {
+  if (!slug) {
+    throw new Error("Missing prompt slug. `fluncle admin prompts list` names them all.");
+  }
+  return slug;
+}
+async function runPromptsList(options, promptsListCommand2) {
+  const prompts = await promptsListCommand2();
+  if (options.json) {
+    printJson({ ok: true, prompts });
+    return;
+  }
+  const { promptRows: promptRows2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+  for (const row of promptRows2(prompts)) {
+    console.log(row);
+  }
+}
+async function runPromptGet(slug, options, promptGetCommand2) {
+  const resolved = await promptGetCommand2(requirePromptSlug(slug));
+  if (options.json) {
+    printJson(resolved);
+    return;
+  }
+  const live = resolved.source === "override" ? `v${resolved.version}, an operator edit` : "the repo's baked default (v0)";
+  console.log(`${resolved.slug}: ${live}`);
+  console.log("");
+  console.log(resolved.body);
+}
+async function runPromptHistory(slug, options, promptDetailCommand2) {
+  const detail = await promptDetailCommand2(requirePromptSlug(slug));
+  if (options.json) {
+    printJson({
+      activeVersion: detail.activeVersion,
+      ok: true,
+      slug: detail.slug,
+      source: detail.source,
+      versions: detail.versions
+    });
+    return;
+  }
+  if (detail.versions.length === 0) {
+    console.log(`${detail.slug}: never edited. The repo's baked default is what runs.`);
+    return;
+  }
+  const { historyRows: historyRows2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+  for (const row of historyRows2(detail.versions)) {
+    console.log(row);
+  }
+}
+async function runPromptDiff(slug, options, commands) {
+  const against = commands.parseAgainst(options.against);
+  const result = await commands.promptDiffCommand(requirePromptSlug(slug), against);
+  if (options.json) {
+    printJson({ ok: true, ...result });
+    return;
+  }
+  const live = result.live.source === "override" ? `v${result.live.version}` : "the repo's baked default";
+  if (result.added === 0 && result.removed === 0) {
+    console.log(`${result.slug}: ${live} and ${result.against.label} are the same body.`);
+    return;
+  }
+  const { renderDiff: renderDiff2 } = await Promise.resolve().then(() => (init_admin_prompts(), exports_admin_prompts));
+  console.log(`${result.slug}: ${result.against.label} (-) against ${live} (+)`);
+  for (const line of renderDiff2(result.lines)) {
+    console.log(line);
+  }
+  console.log(`${result.added} added, ${result.removed} removed.`);
+}
+async function runPromptUpdate(slug, options, promptUpdateCommand2) {
+  const result = await promptUpdateCommand2(requirePromptSlug(slug), {
+    bodyFile: options.bodyFile,
+    note: options.note
+  });
+  if (options.json) {
+    printJson({ ok: true, ...result });
+    return;
+  }
+  console.log(`${result.slug}: v${result.version} is live. Nothing to deploy.`);
+}
+async function runPromptRollback(slug, version, options, commands) {
+  const promptSlug = requirePromptSlug(slug);
+  if (!version) {
+    throw new Error(`Missing version. \`fluncle admin prompts history ${promptSlug}\` lists what you can go back to.`);
+  }
+  const parsed = commands.parseVersion(version);
+  if (parsed === undefined) {
+    throw new Error(`A version reads as 3 or v3. Got "${version}".`);
+  }
+  const result = await commands.promptRollbackCommand(promptSlug, parsed);
+  if (options.json) {
+    printJson({ ok: true, ...result });
+    return;
+  }
+  console.log(result.skipped ? `${result.slug}: v${result.from} is already the body running. Nothing appended.` : `${result.slug}: back on v${result.from}'s body, live as v${result.version}.`);
+}
+async function runPromptReset(slug, options, promptResetCommand2) {
+  const result = await promptResetCommand2(requirePromptSlug(slug));
+  if (options.json) {
+    printJson({ ok: true, ...result });
+    return;
+  }
+  console.log(result.skipped ? `${result.slug}: already running the repo's baked default. Nothing appended.` : `${result.slug}: back on the repo's baked default, live as v${result.version}.`);
+}
 async function runAdd(spotifyUrl, options, addCommand3) {
   if (!spotifyUrl) {
     throw new Error("Missing Spotify track URL");
@@ -9858,7 +10283,7 @@ async function runGalaxyEmbeddings(options, galaxyEmbeddingsCommand2) {
   console.log(`${result.embeddings.length} embedding(s)${result.nextCursor ? ` \xB7 nextCursor: ${result.nextCursor}` : " \xB7 end of corpus"}`);
 }
 async function runGalaxyMapWrite(options, galaxyMapWriteCommand2) {
-  const raw = JSON.parse(readFileSync6(options.file, "utf8"));
+  const raw = JSON.parse(readFileSync7(options.file, "utf8"));
   const clusters = Array.isArray(raw) || raw === null ? raw : raw.clusters;
   if (!Array.isArray(clusters)) {
     throw new Error("Invalid --file: expected { clusters: [...] } or a JSON array of cluster rows");
@@ -10400,6 +10825,7 @@ function normalizeCommanderError(error) {
   return new Error(message);
 }
 var stringOptions = new Set([
+  "--against",
   "--analyzed-at",
   "--analyzed-from",
   "--at",
@@ -10451,6 +10877,7 @@ var stringOptions = new Set([
   "--plate-background",
   "--platform",
   "--poster",
+  "--prompt-version",
   "--props",
   "--query",
   "--reasoning",

package/package.json

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