taskforce-loop-engineering 0.15.3 → 0.15.5

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.15.5 - 2026-08-24
+
+- Treat embedded-runtime `incomplete_turn` / abandoned-liveness trailers as recoverable interruptions even when the dispatcher wrapper exits zero, preventing partial work from being accepted or stale human gates from being replayed.
+- Keep future paid, deployment, and publication authorization boundaries deferred while an unrelated safe project backlog item remains actionable.
+- Reconcile an already-materialized premature deferred gate by superseding it and restoring the project carrier to the runnable queue.
+- Resolve the authoritative project from checkpoint milestones when a task still carries a broader parent project id.
+
+## 0.15.4 - 2026-08-22
+
+- Preserve source conversation and project metadata across revision planning, direct revision enqueue, and saved-plan application.
+- Refuse to create an unroutable revision when a routed source task has lost its required channel or target.
+- Materialize a human-input gate for the newest authoritative project carrier when it finishes blocked, while continuing to suppress historical failed-task replay.
+- Add regression coverage for routed revision inheritance and blocked project gate delivery.
+
 ## 0.15.3 - 2026-08-22
 
 - Remove workspace-specific Ironman queue and dispatcher instructions from the distributed skill.

package/lib/core.mjs

@@ -1266,17 +1266,32 @@ export async function reconcileProjectGates(root, options = {}) {
         gate = { ...gate, ...await gateProjectMetadata(root, task, checkpoint) };
         await writeJson(full, gate);
       }
-      const spec = specs.get(gate.project_id);
+      const spec = await projectSpecForCheckpoint(root, [...specs.values()], gate.project_id, checkpoint);
+      if (spec?.project && gate.project_id !== spec.project) {
+        gate = { ...gate, project_id: spec.project };
+        await writeJson(full, gate);
+      }
+      const safeBacklogActionable = gate.gate_kind === 'deferred_authorization'
+        && await projectHasSafeActionableBacklog(root, spec);
       const invalid = gate.gate_kind === 'deferred_authorization' && await projectTerminalAccepted(root, spec)
         ? { code: 'project_accepted_optional_deferred', status: 'superseded' }
-        : gateInvalidity(gate, spec);
+        : safeBacklogActionable
+          ? { code: 'safe_backlog_actionable', status: 'superseded' }
+          : gateInvalidity(gate, spec);
       if (!invalid) continue;
       const now = new Date().toISOString();
       const reconciled = { ...gate, status: invalid.status, reconciliation: { ...invalid, reconciled_at: now } };
       await writeJson(full, reconciled);
       if (found?.subdir === 'waiting' && task?.waitingGateId === gate.gate_id) {
-        const canceledFile = path.join(queueSubdirFor(root, queue, 'canceled'), path.basename(found.file));
-        await writeJson(canceledFile, { ...task, status: invalid.status, canceledAt: now, gateReconciliation: reconciled.reconciliation });
+        const resumeSafeBacklog = invalid.code === 'safe_backlog_actionable';
+        const destinationFile = path.join(queueSubdirFor(root, queue, resumeSafeBacklog ? 'inbox' : 'canceled'), path.basename(found.file));
+        const restored = { ...task, status: resumeSafeBacklog ? 'queued' : invalid.status, gateReconciliation: reconciled.reconciliation };
+        delete restored.waitingGateId;
+        delete restored.waitKind;
+        delete restored.waitingSince;
+        if (!resumeSafeBacklog) restored.canceledAt = now;
+        else restored.requeuedAt = now;
+        await writeJson(destinationFile, restored);
         await rm(found.file, { force: true });
       }
       results.push({ queue, gateId: gate.gate_id, projectId: gate.project_id, outcome: invalid.status, reason: invalid.code });
@@ -1883,6 +1898,25 @@ function taskSourceFromOptions(options = {}) {
   return Object.values(source).some(Boolean) ? source : null;
 }
 
+function taskSourceOptions(source) {
+  if (!source) return {};
+  return {
+    sourceChannel: source.channel ?? undefined,
+    sourceTarget: source.target ?? undefined,
+    sourceAccount: source.account ?? undefined,
+    sourceMessageId: source.message_id ?? undefined,
+    sourceReplyTo: source.reply_to ?? undefined
+  };
+}
+
+function assertRevisionRoutingSource(task) {
+  const explicitlyRouted = String(task?.body ?? '').startsWith('This task was explicitly routed to Loop Engineering from a source conversation.');
+  if (!task?.source && !explicitlyRouted) return;
+  if (!task?.source?.channel || !task?.source?.target) {
+    throw new Error(`Routed revision source task ${task?.id ?? 'unknown'} is missing source.channel/source.target; refusing to create an unroutable revision.`);
+  }
+}
+
 export function classifyLoopMessage(message) {
   const text = String(message ?? '').trim();
   if (!text) throw new Error('route-message requires --message.');
@@ -2380,6 +2414,43 @@ function materializableDeferredGates(checkpoint) {
   });
 }
 
+async function projectBacklogItems(root, spec) {
+  if (!spec) return [];
+  const configured = spec.backlogSource ?? spec.authoritativeBacklog;
+  if (!configured) return [];
+  let loaded;
+  try {
+    loaded = await readJson(path.resolve(root, safeRelativePath(configured, 'project backlog source')));
+  } catch {
+    return [];
+  }
+  return Array.isArray(loaded.items) ? loaded.items : Array.isArray(loaded.tasks) ? loaded.tasks : [];
+}
+
+async function projectSpecForCheckpoint(root, specs, projectId, checkpoint) {
+  const direct = specs.find((item) => item.project === projectId);
+  const milestoneId = checkpoint?.milestone_id;
+  if (!milestoneId) return direct;
+  if ((await projectBacklogItems(root, direct)).some((item) => item.id === milestoneId)) return direct;
+  for (const spec of specs) {
+    if ((await projectBacklogItems(root, spec)).some((item) => item.id === milestoneId)) return spec;
+  }
+  return direct;
+}
+
+async function projectHasSafeActionableBacklog(root, spec) {
+  const items = await projectBacklogItems(root, spec);
+  const byId = new Map(items.map((item) => [item.id, item]));
+  const complete = new Set(['accepted', 'complete', 'completed', 'done', 'phase_complete']);
+  const runnable = new Set(['pending', 'queued', 'ready', 'in_progress', 'active']);
+  return items.some((item) => {
+    if (!item?.id || !runnable.has(item.status)) return false;
+    if (item.requires_human_input === true || item.blocked === true || item.status === 'blocked') return false;
+    const dependencies = Array.isArray(item.dependsOn) ? item.dependsOn : Array.isArray(item.depends_on) ? item.depends_on : [];
+    return dependencies.every((id) => complete.has(byId.get(id)?.status));
+  });
+}
+
 async function tasksById(root, queue) {
   const tasks = new Map();
   for (const subdir of ['inbox', 'active', 'waiting', 'done', 'failed', 'canceled']) {
@@ -2433,9 +2504,14 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     const deferredOnly = latestDeferredGates.length > 0
       && (!Array.isArray(latestCheckpoint.blockers) || latestCheckpoint.blockers.length === 0)
       && !['needs_human_input', 'blocked'].includes(latestCheckpoint.status);
-    const spec = specs.find((item) => item.project === metadata.project_id);
+    const spec = await projectSpecForCheckpoint(root, specs, metadata.project_id, latestCheckpoint);
     if (deferredOnly && await projectTerminalAccepted(root, spec)) continue;
-    candidates.push({ taskId, entry, projectId: metadata.project_id, ...checkpoints[0] });
+    // deferred_gates describe later authority boundaries. They become a
+    // waiting gate only after the authoritative backlog has no unrelated safe
+    // item left to run. Otherwise a future paid/deploy/publish boundary would
+    // incorrectly stop local project development.
+    if (deferredOnly && await projectHasSafeActionableBacklog(root, spec)) continue;
+    candidates.push({ taskId, entry, projectId: spec?.project ?? metadata.project_id, ...checkpoints[0] });
   }
 
   // A project deferred gate is materialized only from its newest authoritative
@@ -2446,7 +2522,12 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     if (!current || taskRecency(candidate.entry.task) > taskRecency(current.entry.task)) newestByProject.set(candidate.projectId, candidate);
   }
   return candidates.filter((candidate) => {
-    if (candidate.projectId) return newestByProject.get(candidate.projectId) === candidate && candidate.entry.subdir !== 'failed';
+    if (candidate.projectId) {
+      const authoritative = newestByProject.get(candidate.projectId) === candidate;
+      const actionableFailed = candidate.entry.subdir === 'failed'
+        && ['needs_human_input', 'blocked'].includes(candidate.checkpoint.status);
+      return authoritative && (candidate.entry.subdir !== 'failed' || actionableFailed);
+    }
     return ['inbox', 'active', 'waiting'].includes(candidate.entry.subdir)
       || (candidate.entry.subdir === 'failed' && ['needs_human_input', 'blocked'].includes(candidate.checkpoint.status));
   });
@@ -5232,6 +5313,7 @@ export async function queueRevisionPlan(root, queue, taskId, options = {}) {
   const found = await findTaskFile(root, normalized, taskId, ['failed', 'done']);
   if (!found) throw new Error(`Task not found for revision: ${taskId}`);
   const task = await readJson(found.file);
+  assertRevisionRoutingSource(task);
   if (!task.runPath) throw new Error(`Task has no runPath for revision: ${task.id}`);
   const run = await readJson(path.join(root, safeRelativePath(task.runPath, 'task runPath')));
   const humanDecision = await latestHumanDecision(root, normalized, task.id);
@@ -5255,6 +5337,8 @@ export async function queueRevisionPlan(root, queue, taskId, options = {}) {
   const plannedTask = {
     title,
     body,
+    source: task.source ?? null,
+    projectId: task.projectId ?? task.project_id ?? null,
     revisionOf: task.id,
     revisionSourceRun: task.runPath,
     revisionRequestPath,
@@ -5288,7 +5372,9 @@ export async function queueRevisionNext(root, queue, taskId, options = {}) {
   const enqueued = await enqueueTask(root, {
     queue: plan.queue,
     title: plan.plannedTask.title,
-    task: plan.plannedTask.body
+    task: plan.plannedTask.body,
+    projectId: plan.plannedTask.projectId ?? undefined,
+    ...taskSourceOptions(plan.plannedTask.source)
   });
   const nextTask = {
     ...enqueued.task,
@@ -5340,7 +5426,9 @@ export async function queueRevisionApplyPlan(root, planPath, options = {}) {
   const enqueued = await enqueueTask(root, {
     queue: normalized,
     title: plan.plannedTask.title,
-    task: plan.plannedTask.body
+    task: plan.plannedTask.body,
+    projectId: plan.plannedTask.projectId ?? undefined,
+    ...taskSourceOptions(plan.plannedTask.source)
   });
   const guard = plan.revisionPolicyGuard ?? plan.plannedTask.revisionPolicyGuard ?? null;
   const nextTask = {
@@ -8700,6 +8788,9 @@ const DEFAULT_REQUIRES_HUMAN_ACTION_PATTERNS = [
 ];
 
 const DEFAULT_RECOVERABLE_RUNTIME_PATTERNS = [
+  { category: 'incomplete_turn', pattern: '"kind": "incomplete_turn"' },
+  { category: 'incomplete_turn', pattern: '"livenessState": "abandoned"' },
+  { category: 'incomplete_turn', pattern: 'stopped before confirming the turn was complete' },
   { category: 'compaction_timeout', pattern: 'compaction timed out' },
   { category: 'compaction_timeout', pattern: 'transcript compaction failed' },
   { category: 'transport_error', pattern: 'connection reset' },
@@ -8709,7 +8800,28 @@ const DEFAULT_RECOVERABLE_RUNTIME_PATTERNS = [
 ];
 
 export function dispatchFailureClassification(result, retry = {}) {
-  if (!result || result.exitCode === 0) {
+  if (!result) {
+    return {
+      category: 'ok',
+      requiresHumanAction: false,
+      matchedPattern: null
+    };
+  }
+  // Some embedded runtimes exit their wrapper successfully after the model
+  // turn itself was abandoned. Inspect the structured trailer before trusting
+  // exitCode=0 or the queue may accept partial work and replay a stale gate.
+  const output = `${result.stderr ?? ''}\n${result.stdout ?? ''}`.toLowerCase();
+  const runtimePatterns = retry.recoverableRuntimePatterns ?? DEFAULT_RECOVERABLE_RUNTIME_PATTERNS;
+  const runtimeMatch = runtimePatterns.find((entry) => output.includes(String(entry.pattern ?? entry).toLowerCase()));
+  if (runtimeMatch) {
+    return {
+      category: runtimeMatch.category ?? 'runtime_interruption',
+      requiresHumanAction: false,
+      recoverableRuntime: true,
+      matchedPattern: runtimeMatch.pattern ?? runtimeMatch
+    };
+  }
+  if (result.exitCode === 0) {
     return {
       category: 'ok',
       requiresHumanAction: false,
@@ -8724,7 +8836,6 @@ export function dispatchFailureClassification(result, retry = {}) {
       matchedPattern: null
     };
   }
-  const output = `${result.stderr ?? ''}\n${result.stdout ?? ''}`.toLowerCase();
   const patterns = retry.requiresHumanActionPatterns ?? DEFAULT_REQUIRES_HUMAN_ACTION_PATTERNS;
   const matched = patterns.find((pattern) => output.includes(pattern.toLowerCase()));
   if (matched) {
@@ -8735,16 +8846,6 @@ export function dispatchFailureClassification(result, retry = {}) {
       matchedPattern: matched
     };
   }
-  const runtimePatterns = retry.recoverableRuntimePatterns ?? DEFAULT_RECOVERABLE_RUNTIME_PATTERNS;
-  const runtimeMatch = runtimePatterns.find((entry) => output.includes(String(entry.pattern ?? entry).toLowerCase()));
-  if (runtimeMatch) {
-    return {
-      category: runtimeMatch.category ?? 'runtime_interruption',
-      requiresHumanAction: false,
-      recoverableRuntime: true,
-      matchedPattern: runtimeMatch.pattern ?? runtimeMatch
-    };
-  }
   return {
     category: 'retryable_failure',
     requiresHumanAction: false,
@@ -8877,9 +8978,11 @@ async function runDispatchWithRetry(root, options, queue, task, activeFile, runI
       result,
       failureClassification
     });
-    const dispatchStatus = result.exitCode === 0
-      ? 'passed'
-      : failureClassification.requiresHumanAction ? 'needs_human_action' : 'failed';
+    const dispatchStatus = failureClassification.recoverableRuntime
+      ? 'interrupted'
+      : result.exitCode === 0
+        ? 'passed'
+        : failureClassification.requiresHumanAction ? 'needs_human_action' : 'failed';
     runContext.progress?.emit('dispatch', dispatchStatus, `Dispatcher attempt ${attempt} exited ${result.exitCode}`, {
       attempt,
       exitCode: result.exitCode,
@@ -9206,6 +9309,10 @@ export async function runQueueOnce(root, options) {
           const dispatchClassification = dispatchAttempts[dispatchAttempts.length - 1]?.failureClassification ?? null;
           if (dispatch?.canceled) {
             finalStatus = 'superseded';
+          } else if (dispatchClassification?.recoverableRuntime) {
+            const recoveryCount = Number(task.runtimeRecoveryCount ?? 0);
+            const recoveryMax = Number(options.retry?.runtimeRecoveryMaxAttempts ?? 2);
+            finalStatus = recoveryCount < recoveryMax ? 'runtime_interrupted' : 'runtime_blocked';
           } else if (dispatch?.exitCode === 0 && worktreeEnabled(options)) {
             verification = await runVerifyCommands(options.worktree?.verifyCommands ?? [], worktree.path, timeoutMs, progress);
             const verifyOk = verification.every((entry) => entry.result.exitCode === 0);
@@ -9215,10 +9322,6 @@ export async function runQueueOnce(root, options) {
               finalStatus = 'completed';
             } else if (dispatchClassification?.requiresHumanAction) {
               finalStatus = 'needs_human_input';
-            } else if (dispatchClassification?.recoverableRuntime) {
-              const recoveryCount = Number(task.runtimeRecoveryCount ?? 0);
-              const recoveryMax = Number(options.retry?.runtimeRecoveryMaxAttempts ?? 2);
-              finalStatus = recoveryCount < recoveryMax ? 'runtime_interrupted' : 'runtime_blocked';
             } else {
               finalStatus = 'failed';
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.15.3",
+  "version": "0.15.5",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",

package/scripts/final-judgement-self-test.mjs

@@ -47,6 +47,36 @@ assert.equal(inferTaskScope({ body: 'Continue the overall project with a product
   assert.equal(classification.recoverableRuntime, true);
 }
 
+{
+  const classification = dispatchFailureClassification({
+    exitCode: 0,
+    timedOut: false,
+    stderr: '',
+    stdout: JSON.stringify({
+      replayInvalid: true,
+      livenessState: 'abandoned',
+      error: {
+        kind: 'incomplete_turn',
+        message: 'Codex stopped before confirming the turn was complete. Some work may already have been performed; verify the current state before retrying.'
+      }
+    }, null, 2)
+  });
+  assert.equal(classification.category, 'incomplete_turn');
+  assert.equal(classification.recoverableRuntime, true);
+  assert.equal(classification.requiresHumanAction, false);
+}
+
+{
+  const classification = dispatchFailureClassification({
+    exitCode: 0,
+    timedOut: false,
+    stderr: '',
+    stdout: JSON.stringify({ livenessState: 'working', completion: { stopReason: 'stop' } })
+  });
+  assert.equal(classification.category, 'ok');
+  assert.equal(classification.recoverableRuntime, undefined);
+}
+
 {
   const devPlan = { checkpoints: [{ id: 'cp1' }] };
   const reviews = { reviews: [{ checkpointId: 'cp38', sequence: 38, status: 'accepted', projectCompletion: { status: 'in_progress' } }] };

package/scripts/project-gate-reconciliation-self-test.mjs

@@ -111,6 +111,28 @@ assert.equal(deferredGate.authorization_requirements[0].action, 'production_roll
 assert.match(deferredGate.authorization_requirements[0].required_authority, /Owner authorization/);
 assert.equal((await queueStatus(root, queue)).waiting >= 1, true);
 
+// A future authorization must not stop the project while an unrelated safe
+// backlog item remains actionable.
+await reconcileProjectGates(root, { queue });
+await writeFile(authoritativeBacklog, `${JSON.stringify({
+  status: 'ongoing',
+  items: [
+    { id: 'LOCAL-01', status: 'phase_complete', dependsOn: [] },
+    { id: 'LOCAL-02', status: 'pending', dependsOn: ['LOCAL-01'] }
+  ]
+}, null, 2)}\n`);
+const futureGateTask = await enqueueTask(root, { queue, title: 'OpenReel future production gate', task: 'Continue safe local backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const futureGateDir = path.join(taskRuntimeDirFor(root, queue, futureGateTask.task.id), 'checkpoints');
+await mkdir(futureGateDir, { recursive: true });
+await writeFile(path.join(futureGateDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: futureGateTask.task.id, checkpoint_id: 'cp1', status: 'ready_for_acceptance', blockers: [],
+  project_completion: { status: 'in_progress' }, next_action: 'Implement LOCAL-02 locally.',
+  deferred_gates: [{ id: 'production-later', action: 'production_deploy', required_authority: 'Owner authorization after local candidate acceptance.' }]
+}, null, 2)}\n`);
+const futureNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(futureNotice.results.some((item) => item.taskId === futureGateTask.task.id), false);
+assert.equal((await queueStatus(root, queue)).waiting, 0);
+
 // Conditional policy boundaries are not current blockers. Plain prose in
 // deferred_gates must not materialize a gate without a concrete action and
 // authority requirement.
@@ -145,4 +167,4 @@ const acceptedNotice = await notifyHumanInputRequests(root, { queue, notifyComma
 assert.equal(acceptedNotice.results.some((item) => item.taskId === acceptedOptional.task.id), false);
 assert.equal((await queueStatus(root, queue)).waiting, 0);
 
-console.log(JSON.stringify({ status: 'ok', assertions: ['standing project authorization reaches task contract', 'structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred gate', 'conditional policy prose does not create a gate', 'accepted project optional deferred gate stays out of queue'] }));
+console.log(JSON.stringify({ status: 'ok', assertions: ['standing project authorization reaches task contract', 'structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred gate', 'future gate does not stop safe actionable backlog', 'conditional policy prose does not create a gate', 'accepted project optional deferred gate stays out of queue'] }));

package/scripts/route-notify-self-test.mjs

@@ -11,6 +11,7 @@ import {
   notifyHumanInputRequests,
   notifyTerminalTasks,
   queueHumanDecision,
+  queueRevisionNext,
   queueDirFor,
   queueStatus,
   queueSubdirFor,
@@ -562,5 +563,96 @@ assert.equal((await readdir(queueSubdirFor(regressionRoot, regressionQueue, 'don
 const regressionRepeated = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
 assert.equal(regressionRepeated.sent, 0);
 
+// The newest authoritative project carrier may itself finish blocked. It must
+// become a durable waiting gate instead of being discarded with historical
+// failed attempts.
+const blockedProjectTask = 'latest-blocked';
+await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'failed'), `${blockedProjectTask}.json`), {
+  id: blockedProjectTask,
+  title: 'demo latest blocked',
+  body: 'demo R-1',
+  projectId: 'demo',
+  status: 'blocked',
+  enqueuedAt: '2026-01-03T00:00:00Z',
+  source: { channel: 'feishu', target: 'owner' }
+});
+await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'checkpoints', 'cp2.json'), {
+  version: 1,
+  task_id: blockedProjectTask,
+  checkpoint_id: 'cp2',
+  milestone_id: 'R-1',
+  sequence: 2,
+  status: 'needs_human_input',
+  blockers: ['Approve the production activation.'],
+  verification: [],
+  risks: [],
+  project_completion: 'in_progress',
+  next_action: 'wait'
+});
+await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'final_judgement.json'), {
+  version: 1,
+  task_id: blockedProjectTask,
+  outcome: 'blocked',
+  coverage: { effective_review_ids: ['cp2'] }
+});
+const blockedProjectGate = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
+assert.equal(blockedProjectGate.sent, 1);
+assert.equal((await readJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'waiting'), `${blockedProjectTask}.json`))).status, 'waiting_for_human');
+
+// A routed revision must preserve the complete source envelope so a later
+// human gate or terminal result returns to the originating conversation.
+const revisionQueue = 'revision-routing';
+const revisionSource = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  supersedeActive: true,
+  queue: revisionQueue,
+  message: '走 loop fix revision routing',
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-revision',
+  sourceAccount: 'main',
+  sourceMessageId: 'revision-source-message',
+  sourceReplyTo: 'revision-source-reply'
+});
+const revisionSourceFile = path.join(queueSubdirFor(root, revisionQueue, 'inbox'), `${revisionSource.task.id}.json`);
+const revisionFailedFile = path.join(queueSubdirFor(root, revisionQueue, 'failed'), `${revisionSource.task.id}.json`);
+const revisionRequestFile = path.join(taskRuntimeDirFor(root, revisionQueue, revisionSource.task.id), 'revision_request.json');
+const revisionRunFile = path.join(queueSubdirFor(root, revisionQueue, 'runs'), `${revisionSource.task.id}.json`);
+await writeJson(revisionRequestFile, {
+  version: 1,
+  task_id: revisionSource.task.id,
+  status: 'requested',
+  revision_goals: [{ check: 'routing', required_change: 'Preserve source routing.' }],
+  next_checkpoint: { suggested_id: 'cp2' }
+});
+await writeJson(revisionRunFile, {
+  version: 2,
+  taskId: revisionSource.task.id,
+  status: 'failed',
+  finalJudgement: { outcome: 'needs_revision' },
+  revisionRequest: { path: path.relative(root, revisionRequestFile) }
+});
+await writeJson(revisionFailedFile, {
+  ...revisionSource.task,
+  status: 'failed',
+  projectId: 'demo-project',
+  runPath: path.relative(root, revisionRunFile)
+});
+await rm(revisionSourceFile, { force: true });
+const revision = await queueRevisionNext(root, revisionQueue, revisionSource.task.id, {
+  force: true,
+  strategy: 'Preserve the source envelope and verify blocked notification delivery.'
+});
+assert.deepEqual(revision.nextTask.source, revisionSource.task.source);
+assert.equal(revision.nextTask.projectId, 'demo-project');
+
+const unroutable = { ...await readJson(revisionFailedFile) };
+delete unroutable.source;
+await writeJson(revisionFailedFile, unroutable);
+await assert.rejects(
+  queueRevisionNext(root, revisionQueue, revisionSource.task.id, { force: true }),
+  /refusing to create an unroutable revision/
+);
+
 console.log('route/notify self-test passed');
 await import('./config-drift-self-test.mjs');