@animastor/orchestration 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@animastor/orchestration",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "Animastor Orchestration — the generation orchestration/runtime contour of the Animastor backend, physically extracted from the host (§32.30): the unified generation lifecycle owner (orchestrator facade, stage executor, scene callbacks/restoration), the dispatch engine and its lease/quota/retry managers, the reconciliation engine and counter reconciliation, the scene window/scheduler/worker-health, the runtime-result emitter/consumer, and the eight O-2..O-10 port contracts (Persistence, SceneData, PlaceholderAudio, ProgressEvents, AudioFsm, VideoFsm, HubCancel, LayerConfig). The package reaches the host (runtime config slices, Redis-domain state layer, media facades, the S-5 seam registry, the artifact root, the PW-2 workspace resolver) ONLY through the composition-root host-bindings seam — no backend/src require, no storage/book/routes/services, no Redis, no PG, no Express inside.",
     "keywords": [
         "animastor",

package/src/orchestration/orchestrator.js

@@ -20,6 +20,10 @@
 
 // S-2: media-type knowledge (stage lists, fail-event map) resolved via registry
 const mediaRegistry = require('@animastor/generation').mediaRegistry;
+// S-4: filename grammar composed from the canonical owner (bytes unchanged).
+// D1 (stage146): must live at module scope — resetScenes() uses it outside the
+// beginStage() body, so a per-function declaration threw ReferenceError there.
+const artifactNaming = require('@animastor/generation').artifactNaming;
 // S-5: pure FSM-writer ownership (markDirtyScene/setScene*) — re-exported from
 // the state layer; bodies moved verbatim (see state/scene-state-ops.js header).
 const { lazyHostBinding } = require('../host/host-bindings');
@@ -56,8 +60,6 @@ async function planScene(redis, bookId, chapterId, sceneId) {
 // для исполнения генерации).
 async function beginStage(redis, scene, loadedBook, buildId, stage) {
     const dispatchEngine = require('../runtime/dispatch-engine');
-    // S-4: filename grammar composed from the canonical owner (bytes unchanged)
-const artifactNaming = require('@animastor/generation').artifactNaming;
     const bookId = scene.book_id;
     const chapterId = scene.chapter_id;
     const sceneId = scene.scene_id;
@@ -157,20 +159,37 @@ async function completeStage(redis, bookId, chapterId, sceneId, stage, buildId,
 
                 if (sceneRows.length === 1) {
                     const sv = sceneRows[0];
-                    const asset = await persist('sceneAssets.getAsset')(bookId, chapterId, sceneId, stage, buildId);
-
-                    if (asset) {
+                    const versionsConfirm = (row) => {
                         const contentVersionConfirmed =
-                            asset.scene_content_version != null &&
+                            row.scene_content_version != null &&
                             sv.content_version != null &&
-                            asset.scene_content_version >= sv.content_version;
+                            row.scene_content_version >= sv.content_version;
                         const audioVersionConfirmed =
                             stage !== 'audio' || (
-                                asset.scene_audio_config_version != null &&
+                                row.scene_audio_config_version != null &&
                                 sv.audio_config_version != null &&
-                                asset.scene_audio_config_version >= sv.audio_config_version
+                                row.scene_audio_config_version >= sv.audio_config_version
                             );
-                        shouldWriteReady = contentVersionConfirmed && audioVersionConfirmed;
+                        return contentVersionConfirmed && audioVersionConfirmed;
+                    };
+
+                    let asset = await persist('sceneAssets.getAsset')(bookId, chapterId, sceneId, stage, buildId);
+
+                    if (!asset) {
+                        // A1 (stage147): единственная строка ключа может быть
+                        // легаси-строкой с build_id = NULL (Stage 73/76 семейство):
+                        // getAsset(buildId) её не видит, а markReady — единственный
+                        // писатель build_id — вызывается ПОСЛЕ gate (замкнутый цикл
+                        // DIRTY каждые 5 с, stage146 §5.4). РОВНО одно дополнительное
+                        // чтение строки того же ключа с build_id IS NULL — не строки
+                        // другого билда и не «последней любой». Версии проверяются
+                        // теми же правилами; после пропуска markReady проставит
+                        // build_id по существующей логике (buildIdFromArtifactPath).
+                        asset = await persist('sceneAssets.getAssetNullBuild')(bookId, chapterId, sceneId, stage);
+                    }
+
+                    if (asset) {
+                        shouldWriteReady = versionsConfirm(asset);
                     }
                 } else if (sceneRows.length === 0) {
                     // Legacy-книга без version-схемы — READY разрешён (сцена

package/src/orchestration/scene-callbacks.js

@@ -277,17 +277,9 @@ async function handleImageCompleted(redis, bookId, chapterId, sceneId, buildId)
     // T1: возвращает { ok, retryable, reason, artifact }
     log(`IMAGE_CALLBACK: ${bookId}/${chapterId}/${sceneId}`);
 
-    // Stage 143a: legacy canonical scan first (unchanged behavior, also the
-    // path every host stub knows), then — flag on and scan empty — the
-    // published pointer of this scene build as the completion proof.
-    let sceneImage = image.resolveCanonicalSceneImage(
+    const sceneImage = image.resolveCanonicalSceneImage(
         artifactRoot(), buildId, bookId, chapterId, sceneId
     );
-    if (!sceneImage && typeof image.resolveVersionedSceneProof === 'function') {
-        sceneImage = await image.resolveVersionedSceneProof(
-            artifactRoot(), buildId, bookId, chapterId, sceneId
-        );
-    }
 
     // Per-asset check
     const assetStates = await state.getAssetStates(redis, bookId, chapterId, sceneId);
@@ -342,28 +334,7 @@ async function handleImageCompleted(redis, bookId, chapterId, sceneId, buildId)
             const stillPending = [];
             for (const uid of dirtyIds) {
                 const pngPath = path.join(buildDir, artifactNaming.sceneImageName(bookId, chapterId, sceneId, uid));
-                if (fs.existsSync(pngPath)) continue;
-                // ── Stage 143a (phase 2a · N1) ─────────────────────
-                // A versioned-only build never writes the canonical file, so
-                // the published pointer is the completion proof for this
-                // unit. Without it the dirty marker is never cleared and the
-                // unit is force-regenerated on EVERY reconcile pass (infinite
-                // regeneration loop with the flag on).
-                // Flag OFF ⇒ the facade answers null with zero PG calls → the
-                // legacy check above decides, exactly as before.
-                // A pointer-store ERROR keeps the unit pending (never cleared
-                // on an unknown verdict) and is logged.
-                let provenByPointer = false;
-                try {
-                    if (image && typeof image.resolveIuImagePath === 'function') {
-                        const published = await image.resolveIuImagePath(
-                            artifactRoot(), buildId, bookId, chapterId, sceneId, uid);
-                        provenByPointer = !!(published && published.status === 'ok');
-                    }
-                } catch (pgErr) {
-                    warn(`[DIRTY-UNITS] pointer proof unavailable for ${uid}: ${pgErr.message} — keeping it pending`);
-                }
-                if (!provenByPointer) {
+                if (!fs.existsSync(pngPath)) {
                     stillPending.push(uid);
                 }
             }
@@ -372,31 +343,8 @@ async function handleImageCompleted(redis, bookId, chapterId, sceneId, buildId)
                 log(`[DIRTY-UNITS-CLEARED] ${bookId}/${chapterId}/${sceneId}: all ${dirtyIds.length} dirty unit(s) completed, cleared`);
                 try {
                     const iuPrefix = artifactNaming.iuImagePrefix(bookId, chapterId, sceneId);
-                    const scenePrefix = artifactNaming.scenePrefix(bookId, chapterId, sceneId);
                     const allFiles = fs.existsSync(buildDir) ? fs.readdirSync(buildDir) : [];
-                    // ── Stage 143a (phase 2a · N2) ─────────────────
-                    // Ready units = canonical file names ∪ published pointer
-                    // ids (versioned files are invisible to this scan). The
-                    // counter is a DISPLAY source (consumers clamp it), so a
-                    // pointer-store error here only logs and leaves the
-                    // legacy count — never a readiness decision.
-                    const readyIds = new Set();
-                    for (const f of allFiles) {
-                        if (f.startsWith(iuPrefix) && f.endsWith('.png')) {
-                            readyIds.add(f.startsWith(`${scenePrefix}_`)
-                                ? f.slice(scenePrefix.length + 1, -4)
-                                : f);
-                        }
-                    }
-                    if (image && typeof image.listPublishedIuIdsForScene === 'function') {
-                        try {
-                            const publishedIds = await image.listPublishedIuIdsForScene(buildId, bookId, chapterId, sceneId);
-                            for (const id of publishedIds) readyIds.add(String(id));
-                        } catch (pgErr) {
-                            warn(`[IU-COUNTER-RESET] published ids unavailable for ${bookId}/${chapterId}/${sceneId}: ${pgErr.message} — counting canonical files only`);
-                        }
-                    }
-                    const iuFileCount = readyIds.size;
+                    const iuFileCount = allFiles.filter(f => f.startsWith(iuPrefix) && f.endsWith('.png')).length;
                     if (iuFileCount > 0) {
                         const progKey = `animastor:iu-progress:${bookId}:${chapterId}:${sceneId}:image`;
                         await redis.set(progKey, String(iuFileCount), 'EX', 14400);

package/src/orchestration/scene-orchestrator.js

@@ -13,15 +13,10 @@ const chunks = lazyHostBinding('media.audio.chunks');
 // orchestrator never requires gpu-dispatcher or the workflow connector.
 const provider = require('@animastor/generation').comfyuiProvider;
 const runtimeScheduler = require('../runtime/runtime-scheduler');
-// Stage 118 (M3): the shared outcome taxonomy — the dispatch engine (runtime
-// tier) and the stage executors (orchestration tier) must classify a
-// "nothing was enqueued" outcome IDENTICALLY.
-const { classifyNotSentReasons } = require('../runtime/dispatch-outcomes');
 // O-2: persistence arrives ONLY through the PersistencePort (host adapter:
 // storage/runtime-persistence-adapter) — the scene-assets repository left
 // this file. SQL lives host-side.
 const persist = require('../runtime/persistence-port').persist;
-const isPersistencePortWired = require('../runtime/persistence-port').isPersistencePortWired;
 // O-3: scene content arrives ONLY through the SceneDataPort (host adapter:
 // storage/scene-data-adapter) — the Book Model facade (../book →
 // @animastor/vbook-runtime) left this file. Aliased `sceneDataPort` because
@@ -305,22 +300,8 @@ async function executeAudioDispatch(redis, scene, loadedBook, buildId, dispatchI
         const completion = await completeStage(redis, bookId, chapterId, sceneId, 'audio', buildId, dispatchId);
         return { dispatched: false, jobs: 0, completed: completion.completed, reason: 'no_segments' };
     } else {
-        // Stage 116 (D3) / Stage 118 (B3, M3): nothing was enqueued — carry
-        // the precise reason (no live worker / everything already queued /
-        // ambiguous POST) so the dispatch engine can apply a BOUNDED deferral
-        // instead of a fatal cancel.
-        //
-        // Stage 118 (B3): the merged (pure-dialogue) path and the per-segment
-        // path must produce the SAME classification — the merged branch used
-        // to leave the reason empty, so a pure-dialogue scene kept the
-        // 5-second retry loop. `deferReason` is computed by the host (audio
-        // generation) for EVERY path; the fallback below keeps the historic
-        // 'no_jobs_generated' semantics when the host could not classify it.
-        const deferReason = (result && result.reason === 'no_jobs_accepted' && result.deferReason)
-            ? result.deferReason
-            : 'no_jobs_generated';
-        warn(`AUDIO_DISPATCH: generateSceneAudio did not send jobs for ${bookId}/${chapterId}/${sceneId} (${deferReason})`);
-        return { dispatched: false, jobs: 0, reason: deferReason, retryable: true };
+        warn(`AUDIO_DISPATCH: generateSceneAudio did not send jobs for ${bookId}/${chapterId}/${sceneId}`);
+        return { dispatched: false, jobs: 0, reason: 'no_jobs_generated' };
     }
 }
 
@@ -371,11 +352,8 @@ async function executeImageDispatch(redis, scene, loadedBook, buildId, dispatchI
 
     // T3: generateSceneIUImages возвращает количество отправленных jobs
     let jobsSent = 0;
-    // Stage 116 (D3): the result is needed AFTER the try/catch (the deferral
-    // reason) — it must be visible outside the block.
-    let genResult = null;
     try {
-        genResult = await image.generateSceneIUImages(
+        const genResult = await image.generateSceneIUImages(
             redis,
             sceneData,
             bookData,
@@ -399,16 +377,6 @@ async function executeImageDispatch(redis, scene, loadedBook, buildId, dispatchI
         return { dispatched: true, jobs: jobsSent, reason: null };
     }
 
-    // Stage 116 (D3) / Stage 118 (M3): the executor sent NOTHING. That is
-    // not a lost task and not a fatal cancellation — it is a bounded
-    // deferral. The precise reason (no live worker / everything already
-    // queued / ambiguous POST) is carried through so the deferral can be
-    // classified by the shared taxonomy (runtime/dispatch-outcomes).
-    if (genResult && genResult.deferReason) {
-        warn(`IMAGE_DISPATCH: ${bookId}/${chapterId}/${sceneId} — nothing enqueued (${genResult.deferReason}); deferring`);
-        return { dispatched: false, jobs: 0, reason: genResult.deferReason, retryable: true };
-    }
-
     log(`IMAGE_DISPATCH: ${bookId}/${chapterId}/${sceneId} — no jobs sent (cache hit or empty units)`);
     return { dispatched: false, jobs: 0, reason: 'no_jobs_sent' };
 }
@@ -583,41 +551,15 @@ async function executeVideoDispatch(redis, scene, loadedBook, buildId, dispatchI
     await videoOrch.setWaitingChunks(redis, bookId, chapterId, sceneId);
 
     let sentCount = 0;
-    // Stage 116 (D3) / Stage 118 (M3): collect WHY a job was not sent — the
-    // dominant reason becomes the deferral reason (bounded backoff) instead
-    // of the generic 'send_failed'.
-    const notSentReasons = new Map();
     for (const jobSpec of jobsToSend) {
         try {
-            let sendResult = await provider.generate(jobSpec);
-            // Stage 122 (N2): the group file was probed absent above (a cached
-            // group never reaches this loop), so an `already_completed` verdict
-            // is by construction an ORPHANED completion marker. Free it and
-            // retry ONCE so the video regenerates instead of looping on a
-            // 900 s deferral with the scene stuck in the active index (audit
-            // 121 · N2). The release rides the persistence port — the
-            // orchestration tier cannot require the backend helper directly.
-            // Skipped when the port is unwired (harnesses that don't exercise
-            // orphan cleanup); production always wires it in backend.cjs.
-            if (isPersistencePortWired()) {
-                let released = false;
-                try {
-                    released = await persist('idem.releaseTaskDoneIfOrphan')(redis, sendResult);
-                } catch (_) { released = false; }
-                if (released) {
-                    log(`VIDEO_DISPATCH: orphaned completion marker released for ${jobSpec.job_id} — regenerating`);
-                    sendResult = await provider.generate(jobSpec);
-                }
-            }
+            const sendResult = await provider.generate(jobSpec);
             if (sendResult.sent) {
                 sentCount++;
             } else {
-                const reason = sendResult.reason || 'send_failed';
-                notSentReasons.set(reason, (notSentReasons.get(reason) || 0) + 1);
-                warn(`VIDEO_DISPATCH: Hub rejected job ${jobSpec.job_id}: ${sendResult.error || reason}`);
+                warn(`VIDEO_DISPATCH: Hub rejected job ${jobSpec.job_id}: ${sendResult.error || 'unknown'}`);
             }
         } catch (sendErr) {
-            notSentReasons.set('send_failed', (notSentReasons.get('send_failed') || 0) + 1);
             warn(`VIDEO_DISPATCH: provider generate failed for job ${jobSpec.job_id}: ${sendErr.message}`);
         }
     }
@@ -627,13 +569,8 @@ async function executeVideoDispatch(redis, scene, loadedBook, buildId, dispatchI
         return { dispatched: true, jobs: sentCount, reason: null };
     }
 
-    // Stage 116 (D3) / Stage 118 (M3): the shared taxonomy decides whether
-    // the outcome is a bounded deferral. EVERY reason must be deferrable —
-    // a single real failure (send_failed) keeps the historic 'send_failed'
-    // semantics (an immediate retry on the next tick).
-    const deferReason = classifyNotSentReasons(notSentReasons) || 'send_failed';
-    warn(`VIDEO_DISPATCH: ${bookId}/${chapterId}/${sceneId}: nothing enqueued (${deferReason})`);
-    return { dispatched: false, jobs: 0, reason: deferReason, retryable: true };
+    warn(`VIDEO_DISPATCH: ${bookId}/${chapterId}/${sceneId}: all provider.generate calls failed`);
+    return { dispatched: false, jobs: 0, reason: 'send_failed' };
 }
 
 // T4: dispatchStage принимает dispatchId (из dispatch-engine) и передаёт executors