@rslsp1/fa-app-tools 7.2.0 → 7.4.0

package/dist/index.js

@@ -132,7 +132,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "7.2.0";
+var version = "7.4.0";
 
 // src/hooks/useOnClickOutside.ts
 var import_react = require("react");
@@ -2495,9 +2495,9 @@ function mergeSnapshotAndPending(snapshot, pending, bereitsImSnapshot = 0) {
 }
 
 // src/lib/hfEventLog.ts
-function treeUrl(namespace, subdir = "") {
+function treeUrl(namespace, subdir = "", revision = "main") {
   const parts = [namespace.replace(/\/$/, ""), subdir].filter(Boolean).join("/");
-  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/main${parts ? "/" + parts : ""}`;
+  return `${HF_BASE}/api/datasets/${HF_REPO}/tree/${encodeURIComponent(revision)}${parts ? "/" + parts : ""}`;
 }
 var DROSSEL_VERSUCHE = 4;
 var DROSSEL_BASIS_MS = 400;
@@ -2530,8 +2530,8 @@ async function mitGeduld(anfrage) {
   }
   return letzte;
 }
-async function hfListDir(namespace, subdir, token) {
-  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir), {
+async function hfListDir(namespace, subdir, token, revision = "main") {
+  const res = await mitGeduld(() => holeMitZeitlimit(treeUrl(namespace, subdir, revision), {
     headers: { Authorization: `Bearer ${token}` }
   }));
   if (res.status === 404) return [];
@@ -2560,17 +2560,46 @@ function toBase64(text) {
   bytes.forEach((b) => binary += String.fromCharCode(b));
   return btoa(binary);
 }
-async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`) {
+var HfPreconditionFailedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HfPreconditionFailed";
+  }
+};
+async function hfRepoHead(token, revision = "main") {
+  const res = await mitGeduld(() => holeMitZeitlimit(
+    `${HF_BASE}/api/datasets/${HF_REPO}/revision/${encodeURIComponent(revision)}`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  ));
+  if (!res.ok) {
+    throw new Error(`HF revision failed: ${res.status} ${res.statusText} (${revision})`);
+  }
+  const daten = await res.json();
+  if (typeof daten.sha !== "string" || daten.sha.length === 0) {
+    throw new Error(
+      `HF revision ${revision}: die Antwort traegt kein "sha". Erhaltene Felder: ${Object.keys(daten || {}).join(", ") || "(keine)"}.`
+    );
+  }
+  return daten.sha;
+}
+async function hfUploadSmallFile(repoPath, content, token, summary = `Update ${repoPath}`, options) {
+  const kopf = { summary, description: "" };
+  if (options?.parentCommit) kopf.parentCommit = options.parentCommit;
   const res = await fetch(`${HF_BASE}/api/datasets/${HF_REPO}/commit/main`, {
     method: "POST",
     headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/x-ndjson" },
     body: [
-      JSON.stringify({ key: "header", value: { summary, description: "" } }),
+      JSON.stringify({ key: "header", value: kopf }),
       JSON.stringify({ key: "file", value: { path: repoPath, encoding: "base64", content: toBase64(content) } })
     ].join("\n")
   });
   if (!res.ok) {
     const err = await res.text().catch(() => "");
+    if (options?.parentCommit && (res.status === 412 || res.status === 409)) {
+      throw new HfPreconditionFailedError(
+        `HF commit abgelehnt: Der Branch hat sich seit ${options.parentCommit} bewegt (${res.status}). Es wurde nichts geschrieben.`
+      );
+    }
     throw new Error(`HF upload failed: ${res.status} \u2014 ${err.slice(0, 200)}`);
   }
 }
@@ -2620,8 +2649,8 @@ async function mitBegrenzterParallelitaet(count, limit, task) {
   await Promise.all(Array.from({ length: Math.min(limit, count) }, worker));
   if (fehlerAufgetreten) throw ersterFehler;
 }
-async function loadPendingEvents(namespace, token, sinceTs, knownPaths) {
-  const files = await hfListDir(namespace, "events", token);
+async function loadPendingEvents(namespace, token, sinceTs, knownPaths, revision = "main") {
+  const files = await hfListDir(namespace, "events", token, revision);
   const pending = files.filter((f) => f.type === "file" && tsFromEventPath(f.path) > sinceTs && !knownPaths?.has(f.path)).sort((a, b) => a.path.localeCompare(b.path));
   if (!pending.length) return [];
   const raw = new Array(pending.length);
@@ -2666,7 +2695,13 @@ async function writeHFEvent(namespace, token, type, payload, prevTs, options) {
   const suffix = options?.ordered ? `${String(++writeSeq % 1e6).padStart(6, "0")}${uuid}` : uuid;
   const filename = `${tsToFilename(ts)}_${suffix}.json`;
   const repoPath = `${namespace}events/${filename}`;
-  await hfUploadSmallFile(repoPath, JSON.stringify(event, null, 2), token, `Event: ${type}`);
+  await hfUploadSmallFile(
+    repoPath,
+    JSON.stringify(event, null, 2),
+    token,
+    `Event: ${type}`,
+    options?.parentCommit ? { parentCommit: options.parentCommit } : void 0
+  );
   return event;
 }
 
@@ -6018,7 +6053,8 @@ function capabilitiesOf(port) {
     imageBatchHistory: typeof port.imageBatchHistory?.listBatchesForPromptRun === "function",
     imageOrderHistory: typeof port.imageBatchHistory?.listOrdersForPromptRun === "function",
     imageBatchWrite: typeof port.imageBatchWrite?.importBatch === "function",
-    imageGeneration: typeof port.imageGeneration?.startFromPromptRun === "function"
+    imageGeneration: typeof port.imageGeneration?.startFromPromptRun === "function",
+    imageJobs: typeof port.imageJobs?.claimAndRun === "function"
   };
 }
 async function callOptional(capability, operation) {
@@ -9165,13 +9201,13 @@ function noticeFor(ergebnis, was) {
       };
     }
     case "rejected": {
-      const fehler4 = ergebnis.errors ?? [];
+      const fehler5 = ergebnis.errors ?? [];
       const ungeprueft = ergebnis.unchecked ?? [];
       return {
         tone: "rejected",
-        text: `${was}: abgelehnt \u2014 ${fehler4.length} Befund${fehler4.length === 1 ? "" : "e"}.`,
+        text: `${was}: abgelehnt \u2014 ${fehler5.length} Befund${fehler5.length === 1 ? "" : "e"}.`,
         details: [
-          ...fehler4.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
+          ...fehler5.map((f) => `${f.path ?? "(ohne Pfad)"}: ${f.message ?? "ohne Meldung"}`),
           // Nicht verschweigen: was nicht geprüft wurde, ist nicht in Ordnung,
           // sondern ungeprüft.
           ...ungeprueft.map((u) => `ungepr\xFCft: ${u}`)
@@ -12671,7 +12707,7 @@ var ERKLAERUNG = {
 };
 var CapabilityPanel = ({ port, elementId, setupPayload }) => {
   const [bericht, setBericht] = (0, import_react37.useState)(null);
-  const [fehler4, setFehler] = (0, import_react37.useState)(null);
+  const [fehler5, setFehler] = (0, import_react37.useState)(null);
   (0, import_react37.useEffect)(() => {
     let abgemeldet = false;
     setBericht(null);
@@ -12693,10 +12729,10 @@ var CapabilityPanel = ({ port, elementId, setupPayload }) => {
       abgemeldet = true;
     };
   }, [port, elementId, setupPayload]);
-  if (fehler4) {
+  if (fehler5) {
     return /* @__PURE__ */ (0, import_jsx_runtime32.jsxs)("p", { "data-testid": "capability-fehler", role: "alert", children: [
       "F\xE4higkeitsbericht nicht erstellbar: ",
-      fehler4
+      fehler5
     ] });
   }
   if (!bericht) return /* @__PURE__ */ (0, import_jsx_runtime32.jsx)("p", { "data-testid": "capability-laden", children: "F\xE4higkeitsbericht wird erstellt \u2026" });
@@ -13063,7 +13099,60 @@ var SZENEN_EVENT_TYPES = {
    * Der Elementreducer ignoriert auch diesen Typ (`default:`-Zweig); gelesen
    * wird mit `collectImageBatches` (`imageBatchStore.ts`).
    */
-  imageBatchPersisted: "szenen.image_batch_persisted"
+  imageBatchPersisted: "szenen.image_batch_persisted",
+  /**
+   * Ein vorbereiteter Promptvorgang — der Durchstich „Szene → ChatGPT → Lauf".
+   *
+   * Der bestehende Promptpfad ruft das Modell selbst
+   * (`runPromptDerivation()`); ein aufrufendes Chatmodell formuliert dagegen
+   * **zwischen** zwei Werkzeugaufrufen. Damit zerfaellt der eine Vorgang in
+   * zwei, und der zweite braucht genau den Stand, den der erste eingefroren
+   * hat — sonst loeste der Abschluss die inzwischen geaenderte Szene neu auf
+   * und der Lauf behauptete eine Herkunft, die er nicht hat (D-22).
+   *
+   * Deshalb ein eigenes Ereignis und **kein** fluechtiger Prozesszustand: Der
+   * Snapshot ueberlebt Neustart, Hostwechsel und Sitzungsende, weil er im
+   * selben autoritativen Log liegt wie der Lauf, der daraus entsteht.
+   *
+   * Der Elementreducer ignoriert diesen Typ (`default:`-Zweig); gelesen wird
+   * mit `collectPromptOperations` (`scenePromptOperation.ts`).
+   */
+  promptOperationPrepared: "szenen.prompt_operation_prepared",
+  /**
+   * Ein Bildauftrag wartet auf einen ausfuehrenden Flow-Host.
+   *
+   * Die vorhandene Auftragshistorie (`imageGenerationStarted`) beginnt
+   * **unmittelbar vor** dem Provideraufruf und kennt deshalb keinen wartenden
+   * Auftrag. Genau der entsteht hier: Ein Chatmodell beauftragt ueber MCP ein
+   * Bild, der Auftrag wird dauerhaft abgelegt, und der Werkzeugaufruf endet
+   * sofort mit seiner Kennung — er haelt keine Antwort minutenlang offen.
+   *
+   * Traegt **keinen** Prompt: Der steht im referenzierten Lauf, und ihn hier
+   * zu kopieren waere eine zweite Wahrheit ueber denselben eingefrorenen Text
+   * (D-103).
+   */
+  imageJobRequested: "szenen.image_job_requested",
+  /**
+   * Ein Flow-Host beansprucht einen wartenden Bildauftrag.
+   *
+   * Ein append-only Log kennt kein Lock: Zwei Tabs koennen beide anhaengen.
+   * Deshalb ist die Uebernahme **nicht** der Append, sondern das Ergebnis
+   * einer deterministischen Schiedsregel darueber (`winningClaimOf`) — der
+   * erste Anspruch in Logreihenfolge gewinnt, und jeder Host liest nach
+   * seinem Append erneut, bevor er einen bezahlten Provideraufruf startet.
+   * Ein unterlegener Anspruch bleibt sichtbar stehen; er wird nicht geloescht,
+   * weil das Log das nicht kann und weil der Versuch ein Beleg ist.
+   */
+  imageJobClaimed: "szenen.image_job_claimed",
+  /**
+   * Der Bildauftrag ist erledigt — mit dem Ausgang, den der Host gesehen hat.
+   *
+   * Getrennt von `imageGenerationFinished`: Jenes gehoert zum bezahlten
+   * Provideraufruf, dieses zur Zustellung. Ein Auftrag kann fehlschlagen,
+   * **bevor** ein Provider gerufen wurde (abgelehntes Profil), und dann gibt
+   * es kein `imageGenerationFinished`, das den Wartenden erloesen wuerde.
+   */
+  imageJobSettled: "szenen.image_job_settled"
 };
 function sortForReplay(events) {
   return [...events].sort((a, b) => {
@@ -13416,9 +13505,9 @@ async function leseBilderAusZip(datei) {
     );
   }
   const { default: JSZip3 } = await import("jszip");
-  const archiv = await JSZip3.loadAsync(datei).catch((fehler4) => {
+  const archiv = await JSZip3.loadAsync(datei).catch((fehler5) => {
     throw new Error(
-      `${name} konnte nicht als ZIP gelesen werden: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+      `${name} konnte nicht als ZIP gelesen werden: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
     );
   });
   const pfade = [];
@@ -13615,6 +13704,7 @@ var RunImagesPanel = ({ port, lauf }) => {
   const neuLesen = () => setNachladen((n) => n + 1);
   const [erzeugenOffen, setErzeugenOffen] = (0, import_react40.useState)(null);
   const [zuordnenOffen, setZuordnenOffen] = (0, import_react40.useState)(null);
+  const [chatAuftraegeOffen, setChatAuftraegeOffen] = (0, import_react40.useState)(null);
   const quelle = sourceOf(lauf);
   const [wahlPhase] = usePortQuery(
     () => port.imageGeneration ? port.imageGeneration.imageModelChoiceForRun(lauf.run_id) : Promise.resolve({ kind: "ok", value: null }),
@@ -13629,10 +13719,17 @@ var RunImagesPanel = ({ port, lauf }) => {
     () => port.imageBatchHistory ? port.imageBatchHistory.listBatchesForPromptRun(lauf.run_id) : Promise.resolve({ kind: "ok", value: [] }),
     [port, lauf.run_id, nachladen]
   );
+  const [chatAuftraegePhase] = usePortQuery(
+    () => port.imageJobs ? port.imageJobs.listJobs(lauf.run_id) : Promise.resolve({ kind: "ok", value: [] }),
+    [port, lauf.run_id, nachladen]
+  );
   const auftraege = auftraegePhase.status === "ready" ? auftraegePhase.value : [];
   const batches = batchesPhase.status === "ready" ? batchesPhase.value : [];
+  const chatAuftraege = chatAuftraegePhase.status === "ready" ? chatAuftraegePhase.value : [];
+  const offeneChatAuftraege = chatAuftraege.filter((a) => a.status === "pending").length;
   const auffaellige = auftraege.filter((a) => a.status !== "succeeded");
   const erzeugenAuf = erzeugenOffen ?? batches.length === 0;
+  const chatAuftraegeAuf = chatAuftraegeOffen ?? offeneChatAuftraege > 0;
   return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("div", { className: "szenen-bilder", "data-testid": `bilder-${lauf.run_id}`, children: [
     /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("section", { className: "szenen-bilder__eingang", "data-testid": `eingang-${lauf.run_id}`, children: [
       /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("h5", { children: "Eingang \u2014 woraus dieser Prompt entstand" }),
@@ -13753,6 +13850,43 @@ var RunImagesPanel = ({ port, lauf }) => {
         }
       )
     ] }),
+    faehig.imageJobs && /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(
+      "details",
+      {
+        className: "szenen-bilder__aktion",
+        "data-testid": `auftraege-chat-bereich-${lauf.run_id}`,
+        open: chatAuftraegeAuf,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(
+            "summary",
+            {
+              onClick: (e) => {
+                e.preventDefault();
+                setChatAuftraegeOffen(!chatAuftraegeAuf);
+              },
+              children: [
+                "Bildauftraege aus dem Chat",
+                offeneChatAuftraege > 0 ? ` (${offeneChatAuftraege} wartend)` : ""
+              ]
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
+            ChatAuftraegeAktion,
+            {
+              port,
+              lauf,
+              auftraege: chatAuftraege,
+              fehler: chatAuftraegePhase.status === "error" ? chatAuftraegePhase.message : null,
+              laedt: chatAuftraegePhase.status === "loading",
+              onFertig: () => {
+                setChatAuftraegeOffen(true);
+                neuLesen();
+              }
+            }
+          )
+        ]
+      }
+    ),
     /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)(
       "details",
       {
@@ -13936,7 +14070,7 @@ function useBildQuellen(port, bilder) {
     erneutVersuchen: () => setVersuch((n) => n + 1)
   };
 }
-var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("span", { className: "szenen-bilder__meta", "data-testid": `batchbild-${bild.media_ref}`, children: [
+var BildDetails = ({ bild, fehler: fehler5, aufloesbar }) => /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("span", { className: "szenen-bilder__meta", "data-testid": `batchbild-${bild.media_ref}`, children: [
   /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("code", { children: bild.media_ref }),
   /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("span", { children: [
     "Position ",
@@ -13949,7 +14083,7 @@ var BildDetails = ({ bild, fehler: fehler4, aufloesbar }) => /* @__PURE__ */ (0,
     "\xD7",
     bild.height
   ] }) : null,
-  fehler4 && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("em", { "data-testid": `batchbild-fehler-${bild.media_ref}`, children: fehler4 }),
+  fehler5 && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("em", { "data-testid": `batchbild-fehler-${bild.media_ref}`, children: fehler5 }),
   !aufloesbar && // Capability-Grenze, kein Fehler: Dieser Host kann Batches lesen,
   // aber keine Bilder auflösen (E). Kein erfundener Fallback auf eine
   // Serverroute (A6).
@@ -13965,18 +14099,18 @@ var HERKUNFT_KURZ = {
   external_import: "extern importiert"
 };
 var BatchKachel = ({ port, batch }) => {
-  const { quellen, fehler: fehler4, wiederholbar, erneutVersuchen } = useBildQuellen(port, batch.images);
+  const { quellen, fehler: fehler5, wiederholbar, erneutVersuchen } = useBildQuellen(port, batch.images);
   const aufloesbar = Boolean(port.imageLibrary);
   const bilder = batch.images.map((bild) => ({
     id: bild.media_ref,
     quelle: quellen.get(bild.media_ref) ?? null,
     titel: `Bild ${bild.position + 1}`,
-    ...fehler4.get(bild.media_ref) ? { leerText: "Nicht ladbar" } : {},
+    ...fehler5.get(bild.media_ref) ? { leerText: "Nicht ladbar" } : {},
     details: /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
       BildDetails,
       {
         bild,
-        fehler: fehler4.get(bild.media_ref) ?? null,
+        fehler: fehler5.get(bild.media_ref) ?? null,
         aufloesbar
       }
     )
@@ -14036,7 +14170,7 @@ var BatchKachel = ({ port, batch }) => {
             BildDetails,
             {
               bild,
-              fehler: fehler4.get(bild.media_ref) ?? null,
+              fehler: fehler5.get(bild.media_ref) ?? null,
               aufloesbar
             }
           ) }, bild.media_ref)) })
@@ -14305,11 +14439,11 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
         setSeedListe(DEFAULT_SEED_VORLAGE.seeds);
         setVorlageKey(DEFAULT_VORLAGE_KEY);
       }
-    } catch (fehler4) {
+    } catch (fehler5) {
       if (veraltet()) return;
       setNotiz({
         tone: "error",
-        text: fehler4 instanceof Error ? fehler4.message : String(fehler4)
+        text: fehler5 instanceof Error ? fehler5.message : String(fehler5)
       });
     }
     if (veraltet()) return;
@@ -14328,10 +14462,10 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
       setNotiz(
         ergebnis.kind === "ok" ? { tone: "ok", text: `Importiert als Item ${ergebnis.value.item_id} mit ${bilder.length} Bild(ern).` } : noticeFor(ergebnis, "Externe Bilder importieren")
       );
-    } catch (fehler4) {
+    } catch (fehler5) {
       setNotiz({
         tone: "error",
-        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+        text: `Externe Bilder importieren: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
       });
     }
     setLaeuft(false);
@@ -14353,10 +14487,10 @@ var ZuordnenAktion = ({ port, lauf, onFertig }) => {
           ...seed !== void 0 ? { seed } : {}
         });
       }
-    } catch (fehler4) {
+    } catch (fehler5) {
       setNotiz({
         tone: "error",
-        text: `Externe Bilder importieren: ${fehler4 instanceof Error ? fehler4.message : String(fehler4)}`
+        text: `Externe Bilder importieren: ${fehler5 instanceof Error ? fehler5.message : String(fehler5)}`
       });
       return;
     }
@@ -14692,6 +14826,101 @@ function readAsBase64(datei) {
     leser.readAsDataURL(datei);
   });
 }
+var CHAT_AUFTRAG_TEXT = {
+  pending: "wartet auf \xDCbernahme",
+  // Wie bei `started` (D-119): laufend und abgebrochen sind aus dem Log
+  // nicht unterscheidbar, und es gibt keinen automatischen Retry, der die
+  // Unterscheidung bräuchte.
+  claimed: "\xFCbernommen (l\xE4uft oder unterbrochen)",
+  succeeded: "erfolgreich",
+  partial: "teilweise",
+  failed: "fehlgeschlagen",
+  rejected: "abgelehnt \u2014 es wurde nichts ausgef\xFChrt"
+};
+var ChatAuftraegeAktion = ({
+  port,
+  lauf,
+  auftraege,
+  fehler: fehler5,
+  laedt,
+  onFertig
+}) => {
+  const [laufend, setLaufend] = (0, import_react40.useState)(null);
+  const [notiz, setNotiz] = (0, import_react40.useState)(null);
+  async function uebernehmen(jobId) {
+    if (!port.imageJobs) return;
+    setLaufend(jobId);
+    setNotiz(null);
+    try {
+      const ergebnis = await port.imageJobs.claimAndRun(jobId);
+      if (ergebnis.kind === "ok") {
+        setNotiz({
+          tone: ergebnis.job.status === "succeeded" ? "ok" : "rejected",
+          text: `Auftrag ${jobId}: ${CHAT_AUFTRAG_TEXT[ergebnis.job.status]}.` + (ergebnis.job.diagnostic ? ` ${ergebnis.job.diagnostic}` : "")
+        });
+      } else if (ergebnis.kind === "lost") {
+        setNotiz({ tone: "rejected", text: ergebnis.message });
+      } else {
+        setNotiz({ tone: "error", text: ergebnis.message });
+      }
+    } catch (e) {
+      setNotiz({
+        tone: "error",
+        text: `Die \xDCbernahme von Auftrag ${jobId} ist technisch gescheitert: ` + (e instanceof Error ? e.message : String(e))
+      });
+    } finally {
+      setLaufend(null);
+      onFertig();
+    }
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("div", { className: "szenen-bilder__aktion-inhalt", "data-testid": `chat-auftraege-${lauf.run_id}`, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("p", { className: "szenen-area__lead", children: "Auftr\xE4ge, die \xFCber den MCP aus dem Chat kamen. Der Prompt wird nicht kopiert \u2014 ausgef\xFChrt wird der eingefrorene Prompt dieses Laufs." }),
+    fehler5 && /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("p", { role: "alert", "data-testid": `chat-auftraege-fehler-${lauf.run_id}`, children: [
+      "Bildauftr\xE4ge aus dem Chat konnten nicht gelesen werden: ",
+      fehler5
+    ] }),
+    !fehler5 && !laedt && auftraege.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("p", { "data-testid": `chat-auftraege-leer-${lauf.run_id}`, children: "F\xFCr diesen Lauf liegt kein Auftrag aus dem Chat vor." }),
+    notiz && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
+      "p",
+      {
+        role: notiz.tone === "error" ? "alert" : void 0,
+        "data-testid": `chat-auftraege-notiz-${lauf.run_id}`,
+        children: notiz.text
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("ul", { className: "szenen-bilder__auftraege", children: auftraege.map((auftrag) => /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("li", { "data-testid": `chat-auftrag-${auftrag.job_id}`, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("span", { children: CHAT_AUFTRAG_TEXT[auftrag.status] }),
+      " \u2014 ",
+      /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("span", { children: [
+        auftrag.image_count,
+        " ",
+        auftrag.image_count === 1 ? "Bild" : "Bilder",
+        " mit",
+        " ",
+        /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("code", { children: auftrag.execution_target_model_key }),
+        " / ",
+        /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("code", { children: auftrag.execution_profile_id }),
+        auftrag.aspect_ratio ? ` im Format ${auftrag.aspect_ratio}` : ""
+      ] }),
+      auftrag.diagnostic && /* @__PURE__ */ (0, import_jsx_runtime36.jsxs)("span", { children: [
+        " ",
+        auftrag.diagnostic
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("br", {}),
+      /* @__PURE__ */ (0, import_jsx_runtime36.jsx)("code", { className: "szenen-bilder__auftragskennung", children: auftrag.job_id }),
+      auftrag.status === "pending" && /* @__PURE__ */ (0, import_jsx_runtime36.jsx)(
+        "button",
+        {
+          type: "button",
+          disabled: laufend !== null,
+          onClick: () => void uebernehmen(auftrag.job_id),
+          "data-testid": `chat-auftrag-uebernehmen-${auftrag.job_id}`,
+          children: laufend === auftrag.job_id ? "\xDCbernahme l\xE4uft\u2026" : "\xDCbernehmen und ausf\xFChren (kostet einen Bildaufruf)"
+        }
+      )
+    ] }, auftrag.job_id)) })
+  ] });
+};
 
 // src/features/szenen/areas/RunsPanel.tsx
 var import_jsx_runtime37 = require("react/jsx-runtime");
@@ -19253,7 +19482,7 @@ function createHfEventChannel(options) {
   let syncInFlight = null;
   let snapshot = null;
   let snapshotGeladen = ohneSnapshot;
-  const refresh = async () => {
+  const refresh = async (revision = "main") => {
     if (!snapshotGeladen) {
       snapshot = await loadLatestSzenenSnapshot(namespace, token);
       snapshotGeladen = true;
@@ -19261,7 +19490,7 @@ function createHfEventChannel(options) {
         knownPaths.add(`${namespace}events/${name}`);
       }
     }
-    const neue = await loadPendingEvents(namespace, token, sinceTs, knownPaths);
+    const neue = await loadPendingEvents(namespace, token, sinceTs, knownPaths, revision);
     if (neue.length) cachedRawEvents = [...cachedRawEvents, ...neue];
   };
   const sync = () => {
@@ -19272,16 +19501,34 @@ function createHfEventChannel(options) {
     }
     return syncInFlight;
   };
+  const sicht = () => {
+    const pending = cachedRawEvents.filter((event) => typeof event.type === "string" && event.type.startsWith(SZENEN_EVENT_PREFIX)).map((event) => ({
+      type: event.type,
+      payload: event.payload,
+      clientId: event.clientId,
+      ts: event.ts
+    }));
+    return mergeSnapshotAndPending(snapshot, pending).events;
+  };
   return {
     async readEvents() {
       await sync();
-      const pending = cachedRawEvents.filter((event) => typeof event.type === "string" && event.type.startsWith(SZENEN_EVENT_PREFIX)).map((event) => ({
-        type: event.type,
-        payload: event.payload,
-        clientId: event.clientId,
-        ts: event.ts
-      }));
-      return mergeSnapshotAndPending(snapshot, pending).events;
+      return sicht();
+    },
+    async readHead() {
+      return hfRepoHead(token);
+    },
+    async readEventsAt(revision) {
+      await refresh(revision);
+      return sicht();
+    },
+    async appendEventAt(type, payload, parentCommit) {
+      if (!type.startsWith(SZENEN_EVENT_PREFIX)) {
+        throw new Error(
+          `Event-Typ "${type}" gehoert nicht zur Domain szenen. Der geteilte Kanal wird ueber das Praefix "${SZENEN_EVENT_PREFIX}" getrennt.`
+        );
+      }
+      await writeHFEvent(namespace, token, type, payload, [], { ordered: true, parentCommit });
     },
     async appendEvent(type, payload) {
       if (!type.startsWith(SZENEN_EVENT_PREFIX)) {
@@ -19465,11 +19712,11 @@ async function resolveShotPayload(input) {
     };
   }
   const shot = shotPayload;
-  for (const fehler4 of ohneKettenReferenz(
+  for (const fehler5 of ohneKettenReferenz(
     validatePayload("shot", shotPayload).errors,
     chain ? "scene_setup_ref" : null
   )) {
-    diagnostics.push(diagnosticOfSchemaError(fehler4, `Shot ${shotElementId}`));
+    diagnostics.push(diagnosticOfSchemaError(fehler5, `Shot ${shotElementId}`));
   }
   let setup = null;
   let report = null;
@@ -19581,8 +19828,8 @@ async function resolveScenePayload(input) {
     "Kein Scene Setup, kein Shot: Der Lauf entsteht aus der Szene allein. Bildaufbau, Kamera und Zielmodell wurden nicht ergaenzt, sondern sind nicht vorhanden (D-135)."
   ];
   const diagnostics = [];
-  for (const fehler4 of validatePayload("scene", scenePayload).errors) {
-    diagnostics.push(diagnosticOfSchemaError(fehler4, `Szene ${sceneElementId}`));
+  for (const fehler5 of validatePayload("scene", scenePayload).errors) {
+    diagnostics.push(diagnosticOfSchemaError(fehler5, `Szene ${sceneElementId}`));
   }
   const faehig = sceneOnlyCapabilities(scenePayload);
   return komponiere({
@@ -21131,8 +21378,8 @@ function createFlowImageProvider(generateImage) {
             // Kein Seed: weder als Eingabe dokumentiert noch als Ausgabe
             // geliefert — nichts wird erfunden (D-107).
           });
-        } catch (fehler4) {
-          ersterFehler = fehler4 instanceof Error ? fehler4.message : String(fehler4);
+        } catch (fehler5) {
+          ersterFehler = fehler5 instanceof Error ? fehler5.message : String(fehler5);
           break;
         }
       }
@@ -21658,6 +21905,249 @@ function createImageGenerationPort(options) {
   };
 }
 
+// src/lib/szenen/imageJobStore.ts
+var istText6 = (wert) => typeof wert === "string" && wert.trim().length > 0;
+var SETTLED_STATUS = ["succeeded", "partial", "failed", "rejected"];
+function collectImageJobs(events) {
+  const nachId = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobRequested) continue;
+    const payload = event.payload;
+    if (!payload || !istText6(payload.job_id) || !istText6(payload.prompt_run_id)) continue;
+    if (nachId.has(payload.job_id)) continue;
+    nachId.set(payload.job_id, {
+      job_id: payload.job_id,
+      prompt_run_id: payload.prompt_run_id,
+      execution_target_model_key: payload.execution_target_model_key ?? "",
+      execution_profile_id: payload.execution_profile_id ?? "",
+      image_count: typeof payload.image_count === "number" ? payload.image_count : 0,
+      ...payload.aspect_ratio ? { aspect_ratio: payload.aspect_ratio } : {},
+      requested_by: payload.requested_by ?? "",
+      store_id: payload.store_id ?? "",
+      created_at: payload.created_at ?? "",
+      status: "pending",
+      claim_attempts: []
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobClaimed) continue;
+    const payload = event.payload;
+    if (!payload || !istText6(payload.job_id) || !istText6(payload.claim_id)) continue;
+    const auftrag = nachId.get(payload.job_id);
+    if (!auftrag) continue;
+    const anspruch = {
+      job_id: payload.job_id,
+      claim_id: payload.claim_id,
+      client_id: payload.client_id ?? "",
+      claimed_at: payload.claimed_at ?? ""
+    };
+    nachId.set(payload.job_id, {
+      ...auftrag,
+      claim: auftrag.claim ?? anspruch,
+      claim_attempts: [...auftrag.claim_attempts, anspruch],
+      status: auftrag.status === "pending" ? "claimed" : auftrag.status
+    });
+  }
+  for (const event of events) {
+    if (event.type !== SZENEN_EVENT_TYPES.imageJobSettled) continue;
+    const payload = event.payload;
+    if (!payload || !istText6(payload.job_id)) continue;
+    const auftrag = nachId.get(payload.job_id);
+    if (!auftrag) continue;
+    if (!auftrag.claim || auftrag.claim.claim_id !== payload.claim_id) continue;
+    if (auftrag.status !== "claimed") continue;
+    if (!SETTLED_STATUS.includes(payload.status)) continue;
+    nachId.set(payload.job_id, {
+      ...auftrag,
+      status: payload.status,
+      ...payload.generation_batch_id ? { generation_batch_id: payload.generation_batch_id } : {},
+      ...payload.item_id ? { item_id: payload.item_id } : {},
+      ...typeof payload.produced_count === "number" ? { produced_count: payload.produced_count } : {},
+      ...payload.diagnostic ? { diagnostic: payload.diagnostic } : {},
+      settled_at: payload.settled_at ?? ""
+    });
+  }
+  return [...nachId.values()];
+}
+function jobsForPromptRun(events, runId) {
+  return collectImageJobs(events).filter((j) => j.prompt_run_id === runId);
+}
+function findImageJob(events, jobId) {
+  return collectImageJobs(events).find((j) => j.job_id === jobId) ?? null;
+}
+function generationBatchIdOf(jobId) {
+  return `job-${jobId}`;
+}
+
+// src/lib/szenen/imageJobPort.ts
+var ANSPRUCH_VERSUCHE = 4;
+function fehler4(error, aktion) {
+  return {
+    message: `${aktion}: ${error instanceof Error ? error.message : String(error)}`
+  };
+}
+function createImageJobPort(options) {
+  const { channel, imageGeneration, storeId, clientId } = options;
+  const newClaimId = options.newClaimId ?? (() => crypto.randomUUID());
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    async listJobs(runId) {
+      try {
+        return { kind: "ok", value: jobsForPromptRun(await channel.readEvents(), runId) };
+      } catch (error) {
+        return {
+          kind: "error",
+          ...fehler4(error, `Die Bildauftraege des Laufs ${runId} konnten nicht gelesen werden`),
+          retryable: true
+        };
+      }
+    },
+    async claimAndRun(jobId) {
+      let letzterGrund = "";
+      for (let versuch = 1; versuch <= ANSPRUCH_VERSUCHE; versuch += 1) {
+        let kopf;
+        try {
+          kopf = await channel.readHead();
+        } catch (error) {
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Kopf-Commit des Bestands war nicht lesbar; Bildauftrag ${jobId} wurde nicht uebernommen`),
+            retryable: true
+          };
+        }
+        let auftrag;
+        try {
+          auftrag = findImageJob(await channel.readEventsAt(kopf), jobId);
+        } catch (error) {
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Bildauftrag ${jobId} konnte nicht gelesen werden`),
+            retryable: true
+          };
+        }
+        if (!auftrag) {
+          return {
+            kind: "rejected",
+            message: `Der Bildauftrag ${jobId} steht nicht im autoritativen Log dieses Bestands.`
+          };
+        }
+        if (auftrag.store_id !== storeId) {
+          return {
+            kind: "rejected",
+            message: `Der Bildauftrag ${jobId} gilt fuer den Bestand "${auftrag.store_id}", dieser Host arbeitet auf "${storeId}". Nutzer, Umgebung und Bestand muessen zusammenpassen.`
+          };
+        }
+        if (auftrag.status !== "pending") {
+          return {
+            kind: "lost",
+            job: auftrag,
+            message: `Der Bildauftrag ${jobId} ist bereits "${auftrag.status}"` + (auftrag.claim ? ` (Client ${auftrag.claim.client_id})` : "") + ". Er wird nicht erneut ausgefuehrt \u2014 ein zweiter Lauf waere ein zweites Mal bezahlte Rechenzeit."
+          };
+        }
+        const anspruch = {
+          job_id: jobId,
+          claim_id: newClaimId(),
+          client_id: clientId,
+          claimed_at: now().toISOString()
+        };
+        try {
+          await channel.appendEventAt(
+            SZENEN_EVENT_TYPES.imageJobClaimed,
+            anspruch,
+            kopf
+          );
+        } catch (error) {
+          if (istPreconditionFehler(error)) {
+            letzterGrund = error instanceof Error ? error.message : String(error);
+            continue;
+          }
+          return {
+            kind: "error",
+            ...fehler4(error, `Der Anspruch auf Bildauftrag ${jobId} konnte nicht angehaengt werden`),
+            retryable: true
+          };
+        }
+        const gewonnen = {
+          ...auftrag,
+          status: "claimed",
+          claim: anspruch,
+          claim_attempts: [...auftrag.claim_attempts, anspruch]
+        };
+        return await fuehreAus(gewonnen, anspruch, jobId);
+      }
+      return {
+        kind: "error",
+        message: `Der Bildauftrag ${jobId} liess sich in ${ANSPRUCH_VERSUCHE} Versuchen nicht exklusiv uebernehmen \u2014 der Bestand wird gerade von anderer Seite beschrieben (${letzterGrund}). Es wurde nichts ausgefuehrt und nichts bezahlt; ein neuer Versuch ist gefahrlos.`,
+        retryable: true
+      };
+    }
+  };
+  async function fuehreAus(gewonnen, anspruch, jobId) {
+    const ergebnis = await imageGeneration.startFromPromptRun({
+      runId: gewonnen.prompt_run_id,
+      generationBatchId: generationBatchIdOf(jobId),
+      executionTargetModelKey: gewonnen.execution_target_model_key,
+      executionProfileId: gewonnen.execution_profile_id,
+      imageCount: gewonnen.image_count,
+      ...gewonnen.aspect_ratio ? { aspectRatio: gewonnen.aspect_ratio } : {}
+    });
+    const abschluss = {
+      job_id: jobId,
+      claim_id: anspruch.claim_id,
+      ...abschlussFelder(ergebnis, jobId),
+      settled_at: now().toISOString()
+    };
+    try {
+      await channel.appendEvent(SZENEN_EVENT_TYPES.imageJobSettled, abschluss);
+    } catch {
+    }
+    const gelesen = await channel.readEvents().catch(() => null);
+    return {
+      kind: "ok",
+      job: (gelesen && findImageJob(gelesen, jobId)) ?? {
+        ...gewonnen,
+        status: abschluss.status,
+        ...abschluss.generation_batch_id ? { generation_batch_id: abschluss.generation_batch_id } : {},
+        ...abschluss.diagnostic ? { diagnostic: abschluss.diagnostic } : {},
+        settled_at: abschluss.settled_at
+      }
+    };
+  }
+}
+function istPreconditionFehler(error) {
+  return Boolean(error && typeof error === "object" && error.name === "HfPreconditionFailed");
+}
+function abschlussFelder(ergebnis, jobId) {
+  const batchId = generationBatchIdOf(jobId);
+  switch (ergebnis.kind) {
+    case "succeeded":
+      return {
+        status: "succeeded",
+        generation_batch_id: batchId,
+        item_id: ergebnis.batch.item_id,
+        produced_count: ergebnis.batch.images.length
+      };
+    case "partial":
+      return {
+        status: "partial",
+        generation_batch_id: batchId,
+        item_id: ergebnis.batch.item_id,
+        produced_count: ergebnis.produced,
+        diagnostic: `Angefordert ${ergebnis.requested}, geliefert ${ergebnis.produced}.`
+      };
+    case "failed":
+      return { status: "failed", produced_count: 0, diagnostic: ergebnis.message };
+    case "unsupported":
+      return {
+        status: "rejected",
+        produced_count: 0,
+        diagnostic: `Zielmodell "${ergebnis.targetModelKey}" ist in dieser Umgebung nicht ausfuehrbar: ${ergebnis.reason}`
+      };
+    default:
+      return { status: "rejected", produced_count: 0, diagnostic: ergebnis.message };
+  }
+}
+
 // src/lib/szenen/flowViewPort.ts
 var defaultContext = {
   async chainFor(contextId) {
@@ -21756,10 +22246,21 @@ function createFlowSzenenViewPort(options) {
     },
     ...options.now ? { now: options.now } : {}
   }) : void 0;
+  const kanalMitRevision = typeof channel.readHead === "function" && typeof channel.readEventsAt === "function" && typeof channel.appendEventAt === "function";
+  const imageJobs = imageGeneration && hatHfZugangsdaten && kanalMitRevision ? createImageJobPort({
+    channel,
+    imageGeneration,
+    // Dieselbe Form, in der der Server seinen Bestand kennt (`storeId`).
+    storeId: `hf:${options.namespace}`,
+    clientId: options.imageJobClientId ?? crypto.randomUUID(),
+    ...options.newImageJobClaimId ? { newClaimId: options.newImageJobClaimId } : {},
+    ...options.now ? { now: options.now } : {}
+  }) : void 0;
   const port = { elements, context, runs, derivation, imageBatchHistory };
   if (imageLibrary) port.imageLibrary = imageLibrary;
   if (imageBatchWrite) port.imageBatchWrite = imageBatchWrite;
   if (imageGeneration) port.imageGeneration = imageGeneration;
+  if (imageJobs) port.imageJobs = imageJobs;
   return port;
 }