@casecore/release-agent 0.1.4 → 0.1.7

package/README.md

@@ -13,7 +13,7 @@
 ## Подключение
 
 ```sh
-pnpm add --save-exact @casecore/release-agent@0.1.0
+pnpm add --save-exact @casecore/release-agent@0.1.7
 ```
 
 В проекте фиксируются точная версия и `pnpm-lock.yaml`. Поддерживается Node.js
@@ -281,3 +281,54 @@ RELEASE_AGENT_TARBALL=/absolute/path/casecore-release-agent-0.1.0.tgz \
 
 Запуск проверок и сборок должен учитывать действующее разрешение владельца задачи;
 наличие команд и тестов не является подтверждением их успешного выполнения.
+
+## Завершение исходной попытки публикации
+
+Начиная с 0.1.6 адаптер может реализовать `publicationTerminal(command, context)`.
+Движок вызывает его после сохранения подтверждённого результата `deployed` либо
+штатного `failed` до установки. Адаптер закрывает свой исходный журнал под своей
+блокировкой; общий движок и исходные часы выполнения остаются единственными.
+
+`readPublicationTerminalAuthority(context.authority, context.bindings)` возвращает
+подтверждённый результат с точной исходной командой, исполнителем, кандидатом и
+исходными часами. Поле `artifactIdentity` отдельно хранит подписанную идентичность
+артефакта: её SHA может отличаться от SHA исходных изменений. Authority действует
+только внутри ограниченного 30 секундами callback; скопированный объект, snapshot
+или digest полномочия не дают. Перед записью адаптер проверяет `context.signal`.
+
+Ошибка callback сохраняет фактический результат установки и записывается в
+диагностику; она не подтверждает закрытие исходного журнала. Повторный
+`reconcile(commandId)` и восстановление после перезапуска получают новое
+полномочие только после свежей независимой проверки production либо штатного
+восстановления FAILED с native ACK. Запись адаптера должна быть идемпотентной для
+той же исходной попытки. Публикация 0.1.6 и обновление установок проверяются отдельно
+от локальной готовности этого исходного контракта.
+
+Для первой установки уже собранного артефакта тот же callback вызывается с
+`bindings.action: 'deploy'`. Его `repository` и `ref` берутся из сохранённого
+артефактного кандидата; исходные шесть полей `delivery` остаются неизменными.
+Адаптер обязан реализовать `verifyArtifactDelivery(command, identity, delivery,
+source, context)` и подтвердить подпись, исходную операцию и происхождение
+артефакта. `context.completedAt` — сохранённое время завершения установки.
+Повторное подтверждение после истечения срока проверяет этот результат и свежий
+production readback; новую установку или продление срока оно не разрешает.
+
+`await sealPublicationTerminalReceipt(authority, bindings, managementToken)`
+сохраняет заверенный результат в существующем журнале движка перед возвратом.
+`verifyPublicationTerminalReceipt(receipt, managementToken)` проверяет HMAC и
+возвращает данные, которые не являются authority. Токен управления уже должен
+быть настроен у обоих участников; передавать его с результатом нельзя.
+Авторизованный `GET /v1/release-control/publications/:commandId/terminal` читает
+сохранённый результат без нового workflow claim или запуска. Для результата,
+принятого через существующий report, адаптер может предоставить
+`readTerminalReceipt(commandId)`. Неизвестный результат возвращает 404;
+неподтверждённые ошибки установки не получают такой результат.
+
+Отказ до push использует тот же guarded recovery с `kind: failed_before_source_push`,
+`stage: source_ready` и `sourceExecution` вместо GitHub `delivery`. Исходная sealed
+попытка имеет `schema: 1`, `kind: source_not_pushed`, `id`, `candidateId`,
+`sourceCommit`, `requestedAt`, `deadlineAt`, `policy: immediate`. Обязательный
+`verifyPublicationSourceFailure` подтверждает эту границу под удерживаемым guard.
+Любой bound delivery, артефакт или начатая следующая стадия отказывают. ACK сохраняет
+предыдущую рабочую установку и снимает блокировку без создания GitHub-статуса или
+publication-terminal receipt. Истёкший срок не продлевается.

package/dist/exclusive-operation.mjs

@@ -18,6 +18,9 @@ function metadata(producer) {
   assert.ok(state, 'DELIVERY_OPERATION_BARRIER_REQUIRED');
   return state;
 }
+export function assertProducerOperation(producer) {
+  assert.ok(metadata(producer).activity > 0, 'DELIVERY_OPERATION_AUTHORITY_REQUIRED');
+}
 function pendingFailures(producer, state) {
   return [
     ...Object.values(producer.state.commands),

package/dist/index.mjs

@@ -1,5 +1,5 @@
 export * from './pipeline.mjs';
 export * from './source-store.mjs';
 export * from './producer.mjs';
-export { publicationFailureProofDigest } from './producer-publication-failure.mjs';
+export { publicationFailureProofDigest, validateSourceRecoveryExecution } from './producer-publication-failure.mjs';
 export { createProtectedJsonStore } from './journal.mjs';

package/dist/producer-admission.mjs

@@ -151,6 +151,9 @@ export class ProducerAdmission extends ProducerState {
         command: structuredClone(input),
         baseline: structuredClone(current.installed),
         ...(publication && candidate ? { sourceCandidate: structuredClone(candidate) } : {}),
+        ...(!publication && input.action === 'deploy' && candidate?.deliveryExecution
+          ? { artifactCandidate: structuredClone(candidate) }
+          : {}),
         ...(candidate?.deliveryExecution ? { deliveryExecution: candidate.deliveryExecution } : {}),
         ack,
       };

package/dist/producer-delivery.mjs

@@ -6,7 +6,7 @@ export async function verifyPublicationDelivery(
   producer,
   command,
   delivery,
-  { fresh = true } = {}
+  { fresh = true, verification } = {}
 ) {
   assert.equal(command.action, 'publish');
   validateOriginalDelivery(delivery, command.expectedSource.sourceCommit);
@@ -19,7 +19,7 @@ export async function verifyPublicationDelivery(
     assert.deepEqual(item.deliveryExecution, delivery, 'Original published delivery changed');
   if (typeof producer.provider.verifyPublicationDelivery === 'function')
     assert.equal(
-      await producer.provider.verifyPublicationDelivery(command, delivery),
+      await producer.provider.verifyPublicationDelivery(command, delivery, verification),
       true,
       'Original delivery correlation was not verified'
     );

package/dist/producer-execution.mjs

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { notifyPublicationTerminal } from './publication-terminal.mjs';
 import { canonical } from './protocol-internals.mjs';
 import { sameIdentity, acceptedProduction } from './protocol.mjs';
 import { blocker, failureMessage, failedProduction } from './producer-support.mjs';
@@ -6,10 +7,7 @@ import { ProducerPublication } from './producer-publication.mjs';
 
 export class ProducerExecution extends ProducerPublication {
   async qualifyForwardRecovery(run, command) {
-    if (
-      command.action === 'publish' &&
-      !this.state.commands[command.commandId]?.artifactIdentity
-    )
+    if (command.action === 'publish' && !this.state.commands[command.commandId]?.artifactIdentity)
       return;
     command = this.resolvedCommand(command);
     if (
@@ -49,33 +47,27 @@ export class ProducerExecution extends ProducerPublication {
           run.committedReadback = fact;
           run.completedAt ??= this.now().toISOString();
           for (const row of run.stages.filter((s) =>
-            ['running', 'unverified'].includes(s.status),
+            ['running', 'unverified'].includes(s.status)
           )) {
             row.status = 'failed';
             row.completedAt ??= run.completedAt;
             row.elapsedMs = row.startedAt
-              ? Math.max(
-                  0,
-                  Date.parse(row.completedAt) - Date.parse(row.startedAt),
-                )
+              ? Math.max(0, Date.parse(row.completedAt) - Date.parse(row.startedAt))
               : null;
-            row.failure = blocker(
-              'INTERRUPTED_PROOF',
-              'Подтверждение результата было прервано',
-            );
+            row.failure = blocker('INTERRUPTED_PROOF', 'Подтверждение результата было прервано');
           }
           run.blockers.push(
             blocker(
               'FORWARD_CORRECTION_REQUIRED',
-              'Установка завершена, приёмка не пройдена; требуется исправляющий релиз',
-            ),
+              'Установка завершена, приёмка не пройдена; требуется исправляющий релиз'
+            )
           );
           this.event(
             run.id,
             null,
             'failure',
             'Разрешён исправляющий релиз; исходная выкатка завершилась ошибкой',
-            'error',
+            'error'
           );
         }
       } catch (qualificationError) {
@@ -87,13 +79,12 @@ export class ProducerExecution extends ProducerPublication {
   }
   async execute(command, { activated = false } = {}) {
     const run = this.state.runs.find((r) => r.commandId === command.commandId);
-    const remaining = () =>
-      Date.parse(command.deadlineAt) - this.now().getTime();
+    const remaining = () => Date.parse(command.deadlineAt) - this.now().getTime();
     let suspended = false;
     const stage = async (
       id,
       operation,
-      { inputsDigest = null, reusedFromRunId = null, queuedAt = null } = {},
+      { inputsDigest = null, reusedFromRunId = null, queuedAt = null } = {}
     ) => {
       assert.ok(remaining() > 0, 'Original deadline exceeded');
       if (id === 'deploy') run.recoveryState = 'unverified';
@@ -103,8 +94,7 @@ export class ProducerExecution extends ProducerPublication {
         command.action === 'publish' &&
         this.provider.remotePublication === true &&
         row.startedAt !== null;
-      if (!retained || !['passed', 'reused'].includes(row.status))
-        row.status = 'running';
+      if (!retained || !['passed', 'reused'].includes(row.status)) row.status = 'running';
       if (!retained) row.startedAt = this.now().toISOString();
       if (!retained) row.inputsDigest = inputsDigest;
       if (!retained)
@@ -149,10 +139,7 @@ export class ProducerExecution extends ProducerPublication {
       } finally {
         if (!suspended) {
           row.completedAt = this.now().toISOString();
-          row.elapsedMs = Math.max(
-            0,
-            Date.parse(row.completedAt) - Date.parse(row.startedAt),
-          );
+          row.elapsedMs = Math.max(0, Date.parse(row.completedAt) - Date.parse(row.startedAt));
           this.event(run.id, id, 'stage', `${row.title}: ${row.status}`);
         }
         await this.save();
@@ -160,21 +147,15 @@ export class ProducerExecution extends ProducerPublication {
     };
     try {
       if (command.lane === 'scheduled' && !activated) {
-        assert.ok(
-          this.provider.announce,
-          'Scheduled notice transport is not configured',
-        );
+        assert.ok(this.provider.announce, 'Scheduled notice transport is not configured');
         await this.provider.announce(command);
         run.noticeAt = this.now().toISOString();
-        if (
-          Date.parse(command.activationAt) <
-          Date.parse(run.noticeAt) + 86400000
-        ) {
+        if (Date.parse(command.activationAt) < Date.parse(run.noticeAt) + 86400000) {
           run.status = 'blocked';
           run.blockers = [
             blocker(
               'NOTICE_WINDOW_TOO_SHORT',
-              'От фактического уведомления до установки должно пройти минимум 24 часа',
+              'От фактического уведомления до установки должно пройти минимум 24 часа'
             ),
           ];
           await this.save();
@@ -184,11 +165,7 @@ export class ProducerExecution extends ProducerPublication {
         // Scheduling is durable; reconciliation resumes after the activation time.
         run.status = 'queued';
         run.blockers = [
-          blocker(
-            'SCHEDULED_ACTIVATION',
-            'Ожидается согласованное окно установки',
-            true,
-          ),
+          blocker('SCHEDULED_ACTIVATION', 'Ожидается согласованное окно установки', true),
         ];
         await this.save();
         return;
@@ -202,27 +179,23 @@ export class ProducerExecution extends ProducerPublication {
         admitted?.ack.state === 'accepted' &&
         canonical(admitted.command) === canonical(command) &&
         Number.isFinite(Date.parse(run.noticeAt)) &&
-        Date.parse(command.activationAt) >=
-          Date.parse(run.noticeAt) + 86400000 &&
+        Date.parse(command.activationAt) >= Date.parse(run.noticeAt) + 86400000 &&
         Date.parse(command.activationAt) <= this.now().getTime();
       await this.provider.execute(command, {
         stage,
         remainingMs: remaining,
         admittedScheduled,
-        bindDelivery: (delivery) =>
-          this.bindPublicationDelivery(command, delivery),
+        bindDelivery: (delivery) => this.bindPublicationDelivery(command, delivery),
         bindArtifact: (identity, options) =>
           this.bindPublicationArtifact(command, identity, options),
         event: async (fact) => {
-          assert.ok(
-            ['source_ready', 'quality', 'source_merge'].includes(fact.stage),
-          );
+          assert.ok(['source_ready', 'quality', 'source_merge'].includes(fact.stage));
           assert.ok(['running', 'completed', 'failed'].includes(fact.status));
           this.event(
             run.id,
             fact.stage === 'source_ready' ? 'source_ready' : 'ci',
             'log',
-            `${fact.stage}: ${fact.status}`,
+            `${fact.stage}: ${fact.status}`
           );
           await this.save();
         },
@@ -232,7 +205,7 @@ export class ProducerExecution extends ProducerPublication {
         run.stages
           .filter((s) => s.id !== 'production_acceptance')
           .every((s) => ['passed', 'reused'].includes(s.status)),
-        'Every prerequisite stage needs actual proof',
+        'Every prerequisite stage needs actual proof'
       );
       const readback = await stage('production_acceptance', async (signal) => {
         const fact = await this.provider.readProduction(resolved, { signal });
@@ -243,15 +216,13 @@ export class ProducerExecution extends ProducerPublication {
         }
         assert.ok(
           acceptedProduction(fact, resolved, this.now()),
-          'Independent production identity and functional proof required',
+          'Independent production identity and functional proof required'
         );
         return fact;
       });
       run.recoveryState = 'verified';
       if (command.action === 'rollback') {
-        const previous = this.state.runs.find(
-          (r) => r.id === command.previousRunId,
-        );
+        const previous = this.state.runs.find((r) => r.id === command.previousRunId);
         if (previous) {
           previous.status = 'failed';
           previous.recoveryState = 'verified';
@@ -259,7 +230,7 @@ export class ProducerExecution extends ProducerPublication {
           previous.blockers = [
             blocker(
               'RECOVERY_VERIFIED',
-              'Предыдущая установка восстановлена; исходная выкатка завершилась ошибкой',
+              'Предыдущая установка восстановлена; исходная выкатка завершилась ошибкой'
             ),
           ];
         }
@@ -270,7 +241,7 @@ export class ProducerExecution extends ProducerPublication {
         run.id,
         null,
         'readback',
-        'Производственная версия и функциональная проверка подтверждены',
+        'Производственная версия и функциональная проверка подтверждены'
       );
     } catch (error) {
       if (
@@ -288,19 +259,17 @@ export class ProducerExecution extends ProducerPublication {
           remaining() <= 0 ? 'DEADLINE_EXCEEDED' : 'RECONCILIATION_REQUIRED',
           remaining() <= 0
             ? 'Исходный срок выполнения истёк'
-            : 'Выполнение требует проверки фактического результата',
+            : 'Выполнение требует проверки фактического результата'
         ),
       ];
       this.event(run.id, null, 'failure', run.blockers[0].message, 'error');
       await this.qualifyForwardRecovery(run, command);
     } finally {
-      if (
-        !suspended &&
-        !run.blockers.some((b) => b.code === 'SCHEDULED_ACTIVATION')
-      )
+      if (!suspended && !run.blockers.some((b) => b.code === 'SCHEDULED_ACTIVATION'))
         run.completedAt = this.now().toISOString();
       await this.save();
     }
+    await notifyPublicationTerminal(this, this.state.commands[command.commandId], run);
   }
   async resumeScheduled() {
     if (this.scheduling) return;
@@ -310,11 +279,11 @@ export class ProducerExecution extends ProducerPublication {
         (r) =>
           r.status === 'queued' &&
           r.lane === 'scheduled' &&
-          Date.parse(r.activationAt) <= this.now().getTime(),
+          Date.parse(r.activationAt) <= this.now().getTime()
       )) {
         const command = this.state.commands[run.commandId].command;
         const candidate = (await this.snapshot()).candidates.find(
-          (c) => c.id === command.candidateId,
+          (c) => c.id === command.candidateId
         );
         if (
           Date.parse(command.deadlineAt) <= this.now().getTime() ||
@@ -325,22 +294,19 @@ export class ProducerExecution extends ProducerPublication {
           run.blockers = [
             blocker(
               'SCHEDULED_CANDIDATE_INVALID',
-              'Срок истёк или подготовленный кандидат изменился',
+              'Срок истёк или подготовленный кандидат изменился'
             ),
           ];
           await this.save();
           continue;
         }
         run.blockers = [];
-        if (
-          Date.parse(command.activationAt) <
-          Date.parse(run.noticeAt) + 86400000
-        ) {
+        if (Date.parse(command.activationAt) < Date.parse(run.noticeAt) + 86400000) {
           run.status = 'blocked';
           run.blockers = [
             blocker(
               'NOTICE_WINDOW_TOO_SHORT',
-              'Недостаточно времени после фактического уведомления',
+              'Недостаточно времени после фактического уведомления'
             ),
           ];
           await this.save();

package/dist/producer-journal.mjs

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { hash, canonical, keys, uuid } from './protocol-internals.mjs';
 import { validateRunnerCommand, validateProducerSnapshot } from './protocol.mjs';
+import { validatePublicationTerminalReceipt } from './publication-terminal-receipt.mjs';
 import {
   validatePublicationFailureRecord,
   validatePublicationFailureReadback,
@@ -29,6 +30,46 @@ export function validProducerState(state, installationKey, sourcePolicy) {
       assert.equal(item.ack.protocolVersion, 1);
       assert.ok(['accepted', 'rejected'].includes(item.ack.state));
       assert.match(item.ack.runId, uuid);
+      if (item.artifactCandidate) {
+        assert.equal(item.command.action, 'deploy');
+        assert.equal(
+          canonical(item.artifactCandidate.identity),
+          canonical(item.command.expectedIdentity)
+        );
+        assert.equal(
+          canonical(item.artifactCandidate.deliveryExecution),
+          canonical(item.deliveryExecution)
+        );
+      }
+      if (item.deliveryTerminalReceipt) {
+        const proof = validatePublicationTerminalReceipt(item.deliveryTerminalReceipt).proof;
+        assert.equal(proof.bindings.commandId, id);
+        assert.equal(proof.bindings.runId, item.ack.runId);
+        assert.equal(proof.bindings.installationKey, installationKey);
+        assert.equal(proof.bindings.action, item.command.action);
+        assert.equal(proof.bindings.candidateId, item.command.candidateId);
+        assert.equal(proof.bindings.provider, item.command.executionProvider);
+        assert.equal(canonical(proof.bindings.delivery), canonical(item.deliveryExecution));
+        const source =
+          item.command.action === 'publish'
+            ? item.command.expectedSource
+            : item.artifactCandidate?.source;
+        assert.equal(proof.bindings.repository, source?.repository);
+        assert.equal(proof.bindings.ref, source?.ref);
+        assert.equal(
+          canonical({ identity: proof.artifactIdentity }),
+          canonical({
+            identity:
+              item.command.action === 'publish'
+                ? (item.artifactIdentity ?? null)
+                : item.command.expectedIdentity,
+          })
+        );
+        const run = state.runs.find((value) => value.id === item.ack.runId);
+        assert.equal(run?.status, proof.status);
+        assert.equal(run?.completedAt, proof.completedAt);
+        assert.equal(run?.recoveryState, 'verified');
+      }
       if (item.publicationFailureReconciliation !== undefined)
         validatePublicationFailureRecord(
           item.publicationFailureReconciliation,
@@ -59,6 +100,9 @@ export function validProducerState(state, installationKey, sourcePolicy) {
       if (reconciliation) {
         assert.equal(state.commands[run.commandId].command.action, 'publish');
         assert.ok(!state.commands[run.commandId].artifactIdentity);
+        if (reconciliation.fact?.kind === 'failed_before_source_push')
+          for (const stage of run.stages.filter((stage) => stage.id !== 'source_ready'))
+            assert.ok(stage.status === 'pending' && stage.startedAt === null);
         if (reconciliation.state === 'settled') {
           assert.equal(run.status, 'failed');
           assert.equal(run.recoveryState, 'verified');

package/dist/producer-publication-failure.mjs

@@ -4,6 +4,8 @@ import {
   hash,
   keys,
   timestamp,
+  uuid,
+  boundedText,
   completeIdentity,
   validateReadback,
 } from './protocol-internals.mjs';
@@ -11,20 +13,43 @@ import { acceptedProduction, sameIdentity } from './protocol.mjs';
 import { validateOriginalDelivery, blocker } from './producer-support.mjs';
 import { verifyPublicationDelivery } from './producer-delivery.mjs';
 import { reservePublicationFailureReconciliation } from './exclusive-operation.mjs';
+import { notifyPublicationTerminal } from './publication-terminal.mjs';
 
 const stages = ['source_ready', 'ci', 'build', 'verify', 'publish'];
 export function publicationFailureProofDigest(fact, baselineReadback) {
   return `sha256:${hash(canonical({ fact, baselineReadback }))}`;
 }
 
+export function validateSourceRecoveryExecution(value, command) {
+  keys(value, ['schema', 'kind', 'id', 'candidateId', 'sourceCommit', 'requestedAt', 'deadlineAt', 'policy']);
+  assert.equal(value.schema, 1);
+  assert.equal(value.kind, 'source_not_pushed');
+  assert.match(value.id, uuid);
+  assert.match(value.sourceCommit, /^[a-f0-9]{40}$/);
+  boundedText(value.candidateId);
+  assert.equal(value.policy, 'immediate');
+  timestamp(value.requestedAt);
+  timestamp(value.deadlineAt);
+  assert.equal(Date.parse(value.deadlineAt) - Date.parse(value.requestedAt), 900000);
+  if (command) {
+    assert.equal(command.action, 'publish');
+    assert.equal(value.candidateId, command.candidateId);
+    assert.equal(value.sourceCommit, command.expectedSource.sourceCommit);
+    assert.equal(value.requestedAt, command.requestedAt);
+    assert.equal(value.deadlineAt, command.deadlineAt);
+  }
+  return value;
+}
+
 export function validatePublicationFailureFact(fact, command, delivery) {
+  const beforePush = fact?.kind === 'failed_before_source_push';
   keys(fact, [
     'schema',
     'kind',
     'commandId',
     'installationKey',
     'expectedSource',
-    'delivery',
+    beforePush ? 'sourceExecution' : 'delivery',
     'observedAt',
     'stage',
     'authenticated',
@@ -34,15 +59,21 @@ export function validatePublicationFailureFact(fact, command, delivery) {
     'installationNotStarted',
   ]);
   assert.equal(fact.schema, 1);
-  assert.equal(fact.kind, 'failed_before_installation');
+  assert.ok(beforePush || fact.kind === 'failed_before_installation');
   assert.equal(fact.commandId, command.commandId);
   assert.equal(fact.installationKey, command.installationKey);
   keys(fact.expectedSource, ['repository', 'ref', 'sourceCommit']);
   assert.equal(canonical(fact.expectedSource), canonical(command.expectedSource));
-  validateOriginalDelivery(fact.delivery, command.expectedSource.sourceCommit);
-  assert.equal(fact.delivery.requestedAt, command.requestedAt);
-  assert.equal(fact.delivery.deadlineAt, command.deadlineAt);
-  if (delivery) assert.deepEqual(fact.delivery, delivery);
+  if (beforePush) {
+    assert.ok(delivery == null, 'Source failure cannot replace an admitted GitHub delivery');
+    validateSourceRecoveryExecution(fact.sourceExecution, command);
+    assert.equal(fact.stage, 'source_ready');
+  } else {
+    validateOriginalDelivery(fact.delivery, command.expectedSource.sourceCommit);
+    assert.equal(fact.delivery.requestedAt, command.requestedAt);
+    assert.equal(fact.delivery.deadlineAt, command.deadlineAt);
+    if (delivery) assert.deepEqual(fact.delivery, delivery);
+  }
   timestamp(fact.observedAt);
   assert.ok(stages.includes(fact.stage));
   for (const field of [
@@ -97,10 +128,20 @@ export function validatePublicationFailureRecord(record, command, delivery, base
     assert.ok(record.baselineReadback, 'Settled recovery requires its production baseline proof');
 }
 
-export async function reconcilePublicationFailure(producer, item, run) {
+export async function reconcilePublicationFailure(
+  producer,
+  item,
+  run,
+  { terminalRetry = false } = {}
+) {
   assert.equal(item.ack.state, 'accepted');
   assert.equal(item.command.action, 'publish');
-  assert.equal(run.status, 'blocked');
+  assert.ok(
+    run.status === 'blocked' ||
+      (terminalRetry &&
+        run.status === 'failed' &&
+        item.publicationFailureReconciliation?.state === 'settled')
+  );
   assert.ok(!item.artifactIdentity);
   for (const id of ['deploy', 'production_acceptance']) {
     const row = run.stages.find((stage) => stage.id === id);
@@ -137,7 +178,9 @@ export async function reconcilePublicationFailure(producer, item, run) {
       fact: null,
       baselineReadback: null,
     };
+    if (terminalRetry) item.publicationFailureReconciliation.state = 'pending';
     assert.equal(item.publicationFailureReconciliation.state, 'pending');
+    run.status = 'blocked';
     run.recoveryState = 'unverified';
     run.completedAt = null;
     await bounded(producer.save());
@@ -196,7 +239,19 @@ export async function reconcilePublicationFailure(producer, item, run) {
       const { observedAt: _newTime, ...newIdentity } = fact;
       assert.deepEqual(newIdentity, oldIdentity, 'Publication failure reconciliation changed');
     }
-    await bounded(
+    const beforePush = fact.kind === 'failed_before_source_push';
+    if (beforePush) {
+      assert.ok(!item.deliveryExecution && !item.artifactIdentity);
+      for (const stage of run.stages.filter((stage) => stage.id !== 'source_ready'))
+        assert.ok(stage.status === 'pending' && stage.startedAt === null,
+          'Source failure cannot erase a started downstream stage');
+      assert.equal(typeof producer.provider.verifyPublicationSourceFailure, 'function',
+        'Source failure boundary verifier required');
+      assert.equal(await bounded(producer.provider.verifyPublicationSourceFailure(
+        structuredClone(item.command), structuredClone(fact.sourceExecution),
+        { signal: controller.signal, recoveryDeadlineAt }
+      )), true, 'Source failure boundary was not verified');
+    } else await bounded(
       verifyPublicationDelivery(producer, item.command, fact.delivery, { fresh: false })
     );
     await bounded(guard.assertOwned());
@@ -205,7 +260,7 @@ export async function reconcilePublicationFailure(producer, item, run) {
     assertFresh();
     item.publicationFailureReconciliation.fact = fact;
     item.publicationFailureReconciliation.baselineReadback = baselineReadback;
-    item.deliveryExecution = structuredClone(fact.delivery);
+    if (!beforePush) item.deliveryExecution = structuredClone(fact.delivery);
     run.readback = structuredClone(baselineReadback);
     await bounded(producer.save());
     const proofDigest = publicationFailureProofDigest(fact, baselineReadback);
@@ -267,4 +322,8 @@ export async function reconcilePublicationFailure(producer, item, run) {
     if (guard && !settled && !releasing && typeof guard.release === 'function') void cleanup(guard);
     lease.release({ resolved: settled });
   }
+  // Pre-push source recovery has no GitHub delivery or publication-terminal MAC.
+  // Its existing guarded acknowledgement is the sole settlement boundary.
+  if (settled && item.publicationFailureReconciliation.fact.kind !== 'failed_before_source_push')
+    await notifyPublicationTerminal(producer, item, run);
 }