taskforce-loop-engineering 0.15.9 → 0.15.10

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.15.10 - 2026-08-28
+
+- Materialize human-input gates only for permissions or external conditions that are explicitly missing and needed now; preserve authorized, consumed, future, and conditional boundaries as audit context instead of repeatedly blocking project progress.
+- Honor project standing authorization for in-scope production backup, deploy, restart, readiness, restore, and rollback work while keeping publication, credential, destructive, and other excluded actions gated.
+- Resolve checkpoint-bound subproject backlogs when deciding whether safe project work remains, with regression coverage for current blockers, dormant gates, and publication boundaries.
+
 ## 0.15.9 - 2026-08-25
 
 - Clarify that the disposable OpenClaw smoke may write required checkpoint and verification artifacts only inside its temporary Loop runtime queue while user/project files, configuration, credentials, and external state remain read-only.

package/lib/core.mjs

@@ -2428,8 +2428,8 @@ export async function refreshTaskAcceptance(root, options = {}) {
   };
 }
 
-function humanInputMessage(queue, task, checkpoint, gateId, language = 'en') {
-  const blockers = Array.isArray(checkpoint.blockers) ? checkpoint.blockers : [];
+function humanInputMessage(queue, task, checkpoint, gateId, language = 'en', blockers = null) {
+  blockers = blockers ?? (Array.isArray(checkpoint.blockers) ? checkpoint.blockers : []);
   const deferredGates = materializableDeferredGates(checkpoint);
   const requirements = blockers.length > 0 ? blockers : deferredGates;
   const blockerText = requirements.length
@@ -2453,45 +2453,99 @@ function humanInputMessage(queue, task, checkpoint, gateId, language = 'en') {
   ].join('\n');
 }
 
+function blockerCoveredByContractAuthorization(blocker, contract) {
+  if (!blocker || typeof blocker !== 'object' || Array.isArray(blocker)) return false;
+  const state = String(blocker.authorization_state ?? blocker.state ?? '')
+    .trim().toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
+  const neededWhen = String(blocker.needed_when ?? '')
+    .trim().toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
+  if (['authorized', 'consumed', 'satisfied', 'future', 'not_required'].includes(state)) return true;
+  // A conditional blocker is non-materializable only while the condition is
+  // still in the future. Once the producer explicitly says it is needed now
+  // and materialize=true, it is a real current blocker and must stop the
+  // queue instead of being downgraded to an endless development revision.
+  if (state === 'conditional'
+    && blocker.materialize !== true
+    && !['now', 'current', 'immediate'].includes(neededWhen)) return true;
+  if (blocker.materialize === false) return true;
+  const allowed = new Set(contract?.constraints?.allowed_actions ?? []);
+  if (!allowed.has('in_scope_production_deploy_config_backup_restore_rollback_under_standing_authorization')) return false;
+  const text = `${blocker.action ?? ''} ${blocker.required_authority ?? blocker.reason ?? ''}`.toLowerCase();
+  const productionSequence = /(deploy|deployment|materialize|activate|reactivate|restart|process[- ]control|backup|restore|rollback|readiness|persistence|部署|重启|备份|恢复|回滚)/.test(text);
+  const excluded = /(publish|publication|credential|secret|delete|destructive|external send|发布|凭据|密钥|删除|破坏性|外部发送)/.test(text);
+  return productionSequence && !excluded;
+}
+
+function materializableBlockers(checkpoint, contract = null) {
+  const blockers = Array.isArray(checkpoint?.blockers) ? checkpoint.blockers.filter(Boolean) : [];
+  return blockers.filter((blocker) => !blockerCoveredByContractAuthorization(blocker, contract));
+}
+
 function materializableDeferredGates(checkpoint) {
   const gates = Array.isArray(checkpoint?.deferred_gates) ? checkpoint.deferred_gates : [];
   return gates.filter((gate) => {
     if (!gate || typeof gate !== 'object' || Array.isArray(gate)) return false;
     const action = gate.action ?? gate.kind;
     const authority = gate.required_authority ?? gate.human_action_required;
+    const authorizationState = String(gate.authorization_state ?? gate.state ?? '')
+      .trim().toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
+    const neededWhen = String(gate.needed_when ?? '')
+      .trim().toLowerCase().replaceAll('-', '_').replaceAll(' ', '_');
+    const nonMaterializableStates = new Set([
+      'authorized', 'consumed', 'satisfied', 'future', 'conditional', 'not_required'
+    ]);
+    // Deferred gates are future-boundary records, not implicit current human
+    // requests. Require an explicit missing/required state and a current
+    // needed_when marker before materializing one. Legacy unstructured notes
+    // remain audit evidence and cannot manufacture a waiting gate.
+    const explicitlyMissing = ['missing', 'required', 'unauthorized'].includes(authorizationState);
+    const neededNow = ['now', 'current', 'immediate'].includes(neededWhen);
     return typeof action === 'string' && action.trim().length > 0
       && typeof authority === 'string' && authority.trim().length > 0
       && gate.materialize !== false
-      && !['future', 'conditional', 'not_required'].includes(gate.state);
+      && explicitlyMissing
+      && neededNow
+      && !nonMaterializableStates.has(authorizationState)
+      && !['future', 'later', 'conditional', 'after_acceptance', 'after_completion'].includes(neededWhen);
   });
 }
 
-async function projectBacklogItems(root, spec) {
+async function projectBacklogItems(root, spec, checkpoint = null) {
   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 [];
+  const checkpointSource = checkpoint?.backlog_source ?? checkpoint?.authoritative_backlog;
+  const configuredSources = [
+    checkpointSource,
+    ...(Array.isArray(spec.checkpointBacklogSources) ? spec.checkpointBacklogSources : []),
+    spec.backlogSource,
+    spec.authoritativeBacklog
+  ].filter(Boolean);
+  const items = [];
+  for (const configured of configuredSources) {
+    let loaded;
+    try {
+      loaded = await readJson(path.resolve(root, safeRelativePath(configured, 'project backlog source')));
+    } catch {
+      continue;
+    }
+    const loadedItems = Array.isArray(loaded.items) ? loaded.items : Array.isArray(loaded.tasks) ? loaded.tasks : [];
+    items.push(...loadedItems);
   }
-  return Array.isArray(loaded.items) ? loaded.items : Array.isArray(loaded.tasks) ? loaded.tasks : [];
+  return [...new Map(items.filter((item) => item?.id).map((item) => [item.id, item])).values()];
 }
 
 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;
+  if ((await projectBacklogItems(root, direct, checkpoint)).some((item) => item.id === milestoneId)) return direct;
   for (const spec of specs) {
-    if ((await projectBacklogItems(root, spec)).some((item) => item.id === milestoneId)) return spec;
+    if ((await projectBacklogItems(root, spec, checkpoint)).some((item) => item.id === milestoneId)) return spec;
   }
   return direct;
 }
 
-async function projectHasSafeActionableBacklog(root, spec) {
-  const items = await projectBacklogItems(root, spec);
+async function projectHasSafeActionableBacklog(root, spec, checkpoint = null) {
+  const items = await projectBacklogItems(root, spec, checkpoint);
   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']);
@@ -2528,6 +2582,8 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
   for (const [taskId, entry] of tasks) {
     if (!entry.task.source || entry.subdir === 'canceled') continue;
     const runtimeDir = taskRuntimeDirFor(root, queue, taskId);
+    const contractFile = path.join(runtimeDir, 'task_contract.json');
+    const contract = await exists(contractFile) ? await readJson(contractFile) : null;
     let files = await listJson(path.join(runtimeDir, 'checkpoints'));
     const judgementFile = path.join(runtimeDir, 'final_judgement.json');
     if (await exists(judgementFile)) {
@@ -2542,8 +2598,9 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
       const checkpointFile = path.join(runtimeDir, 'checkpoints', file);
       const checkpoint = await readJson(checkpointFile);
       const deferred = materializableDeferredGates(checkpoint);
-      if (['needs_human_input', 'blocked'].includes(checkpoint?.status) || deferred.length > 0) {
-        checkpoints.push({ file, checkpoint, mtimeMs: (await stat(checkpointFile)).mtimeMs });
+      const blockers = materializableBlockers(checkpoint, contract);
+      if ((['needs_human_input', 'blocked'].includes(checkpoint?.status) && blockers.length > 0) || deferred.length > 0) {
+        checkpoints.push({ file, checkpoint, blockers, mtimeMs: (await stat(checkpointFile)).mtimeMs });
       }
     }
     if (checkpoints.length === 0) continue;
@@ -2554,7 +2611,7 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     const latestCheckpoint = checkpoints[0].checkpoint;
     const latestDeferredGates = materializableDeferredGates(latestCheckpoint);
     const deferredOnly = latestDeferredGates.length > 0
-      && (!Array.isArray(latestCheckpoint.blockers) || latestCheckpoint.blockers.length === 0)
+      && checkpoints[0].blockers.length === 0
       && !['needs_human_input', 'blocked'].includes(latestCheckpoint.status);
     const spec = await projectSpecForCheckpoint(root, specs, metadata.project_id, latestCheckpoint);
     if (deferredOnly && await projectTerminalAccepted(root, spec)) continue;
@@ -2562,8 +2619,8 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     // 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] });
+    if (deferredOnly && await projectHasSafeActionableBacklog(root, spec, latestCheckpoint)) continue;
+    candidates.push({ taskId, entry, projectId: spec?.project ?? metadata.project_id, contract, ...checkpoints[0] });
   }
 
   // A project deferred gate is materialized only from its newest authoritative
@@ -2598,7 +2655,7 @@ export async function notifyHumanInputRequests(root, options = {}) {
   await mkdir(gatesDir, { recursive: true });
   const results = [];
   const candidates = await authoritativeHumanGateCandidates(root, queue, tasks);
-  for (const { taskId, entry, file, checkpoint } of candidates) {
+  for (const { taskId, entry, file, checkpoint, blockers } of candidates) {
       const deferredGates = materializableDeferredGates(checkpoint);
       const checkpointId = checkpoint.checkpoint_id ?? path.basename(file, '.json');
       const gateId = `${taskId}:${checkpointId}`;
@@ -2654,7 +2711,7 @@ export async function notifyHumanInputRequests(root, options = {}) {
           }
         }
       }
-      const message = humanInputMessage(queue, entry.task, checkpoint, gateId, language);
+      const message = humanInputMessage(queue, entry.task, checkpoint, gateId, language, blockers);
       if (options.dryRun) {
         results.push({ taskId, checkpointId, gateId, outcome: 'dry_run', message, source: entry.task.source });
         continue;
@@ -3445,6 +3502,14 @@ function buildDevPlan(contract, acceptancePlan, firstCheckpointId = 'cp1') {
       files_changed: [],
       verification: [],
       blockers: [],
+      blocker_schema: {
+        action: 'Concrete action that cannot proceed now.',
+        required_authority: 'Specific authority or input that is currently missing.',
+        authorization_state: 'missing | authorized | consumed | satisfied | future | conditional | not_required',
+        authority_ref: 'Required when authorization_state is not missing.',
+        needed_when: 'now | future condition',
+        materialize: 'Set false for authorized or non-current boundaries.'
+      },
       deferred_gates: [],
       deferred_gate_schema: {
         action: 'Concrete action that cannot proceed now.',
@@ -3494,10 +3559,11 @@ async function checkpointSummary(root, devPlan) {
   };
 }
 
-function checkpointReviewStatus(checkpoint) {
+function checkpointReviewStatus(checkpoint, contract = null) {
   if (!checkpoint) return 'blocked';
-  if (checkpoint.status === 'blocked' || checkpoint.status === 'needs_human_input') return 'blocked';
-  if (Array.isArray(checkpoint.blockers) && checkpoint.blockers.length > 0) return 'revise';
+  const blockers = materializableBlockers(checkpoint, contract);
+  if ((checkpoint.status === 'blocked' || checkpoint.status === 'needs_human_input') && blockers.length > 0) return 'blocked';
+  if (blockers.length > 0) return 'revise';
   if (!Array.isArray(checkpoint.verification) || checkpoint.verification.length === 0) return 'revise';
   if (checkpoint.status !== 'ready_for_acceptance') return 'revise';
   return 'accepted';
@@ -3605,7 +3671,7 @@ function evaluateAcceptanceCritic(critic, context) {
 function buildCriticReviews(contract, acceptancePlan, checkpoint) {
   const missingCheckpoint = !checkpoint;
   const hasVerification = Array.isArray(checkpoint?.verification) && checkpoint.verification.length > 0;
-  const hasBlockers = Array.isArray(checkpoint?.blockers) && checkpoint.blockers.length > 0;
+  const hasBlockers = materializableBlockers(checkpoint, contract).length > 0;
   const hasSummary = typeof checkpoint?.summary === 'string' && checkpoint.summary.trim().length > 0;
   const hasRisks = Array.isArray(checkpoint?.risks);
   const blockedActions = contract.constraints?.blocked_actions ?? [];
@@ -3652,7 +3718,7 @@ function continuationNextAction(value) {
 }
 
 function buildCheckpointReview(contract, acceptancePlan, checkpoint) {
-  const baseStatus = checkpointReviewStatus(checkpoint);
+  const baseStatus = checkpointReviewStatus(checkpoint, contract);
   const failed = [];
   const passed = [];
   const blocked = [];
@@ -3677,8 +3743,9 @@ function buildCheckpointReview(contract, acceptancePlan, checkpoint) {
       });
     }
 
-    if (Array.isArray(checkpoint.blockers) && checkpoint.blockers.length > 0) {
-      blocked.push(...checkpoint.blockers.map((item) => typeof item === 'string' ? item : JSON.stringify(item)));
+    const effectiveBlockers = materializableBlockers(checkpoint, contract);
+    if (effectiveBlockers.length > 0) {
+      blocked.push(...effectiveBlockers.map((item) => typeof item === 'string' ? item : JSON.stringify(item)));
     } else {
       passed.push('Checkpoint reports no blockers.');
     }
@@ -9348,6 +9415,9 @@ export async function runQueueOnce(root, options) {
           env: {
             ...taskPlanningEnv(root, taskContract, acceptancePlan, devPlan),
             LOOP_SESSION_GENERATION: String(task.runtimeSessionGeneration ?? 0),
+            LOOP_EXECUTION_TARGET_JSON: options.executionTarget
+              ? JSON.stringify(options.executionTarget)
+              : '',
             LOOP_HUMAN_INPUT_CONTEXT_FILE: humanInputContextFile,
             LOOP_HUMAN_INPUT_CONTEXT_FILE_REL: path.relative(root, humanInputContextFile)
           },

package/package.json

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

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

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { doctorReport, enqueueTask, notifyHumanInputRequests, projectStatus, queueStatus, reconcileProjectGates, routeLoopMessage, taskRuntimeDirFor, writeTaskContract } from '../lib/core.mjs';
+import { doctorReport, enqueueTask, notifyHumanInputRequests, projectStatus, queueStatus, reconcileProjectGates, resolveHumanInput, routeLoopMessage, taskRuntimeDirFor, writeTaskContract } from '../lib/core.mjs';
 
 const root = await mkdtemp(path.join(os.tmpdir(), 'loop-project-gates-'));
 const queue = 'shared';
@@ -139,7 +139,11 @@ await writeFile(path.join(deferredDir, 'cp-ready.json'), `${JSON.stringify({
   version: 1, task_id: deferred.task.id, checkpoint_id: 'cp-ready', milestone_id: 'S-01', requirement_ids: ['S-01'],
   status: 'ready_for_acceptance', blockers: [], verification: ['local phase passed'], risks: [],
   project_completion: { status: 'in_progress' },
-  deferred_gates: [{ id: 'S-01-production', action: 'production_rollback_drill', required_authority: 'Owner authorization for the exact production rollback drill scope.' }]
+  deferred_gates: [{
+    id: 'S-01-production', action: 'production_rollback_drill',
+    required_authority: 'Owner authorization for the exact production rollback drill scope.',
+    authorization_state: 'missing', needed_when: 'now', materialize: true
+  }]
 }, null, 2)}\n`);
 const deferredNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 const deferredResult = deferredNotice.results.find((item) => item.taskId === deferred.task.id);
@@ -187,6 +191,123 @@ await writeFile(path.join(conditionalDir, 'cp1.json'), `${JSON.stringify({
 const conditionalNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(conditionalNotice.results.some((item) => item.taskId === conditional.task.id), false);
 
+// A conditional formal blocker becomes current when the producer explicitly
+// marks it needed now and materialize=true. It must stop once, rather than be
+// filtered into a needs_revision/project_in_progress polling loop.
+const conditionalNow = await enqueueTask(root, { queue, title: 'OpenReel conditional blocker now', task: 'Wait for a real external precondition', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const conditionalNowDir = path.join(taskRuntimeDirFor(root, queue, conditionalNow.task.id), 'checkpoints');
+await mkdir(conditionalNowDir, { recursive: true });
+await writeFile(path.join(conditionalNowDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: conditionalNow.task.id, checkpoint_id: 'cp1', status: 'blocked',
+  blockers: [{
+    action: 'Run the authorized provider probe.', required_authority: 'Restore the required remote execution precondition.',
+    authorization_state: 'conditional', needed_when: 'now', materialize: true
+  }],
+  deferred_gates: []
+}, null, 2)}\n`);
+const conditionalNowNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(conditionalNowNotice.results.find((item) => item.taskId === conditionalNow.task.id)?.outcome, 'sent');
+await resolveHumanInput(root, { queue, gateId: `${conditionalNow.task.id}:cp1`, input: 'external precondition restored' });
+await reconcileProjectGates(root, { queue });
+
+// Authorization already granted or already consumed is audit context, not a
+// new human-input request. A future boundary is likewise dormant.
+for (const authorizationState of ['authorized', 'consumed', 'future']) {
+  const stateTask = await enqueueTask(root, { queue, title: `OpenReel ${authorizationState} authority`, task: 'Continue within recorded authority', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+  const stateDir = path.join(taskRuntimeDirFor(root, queue, stateTask.task.id), 'checkpoints');
+  await mkdir(stateDir, { recursive: true });
+  await writeFile(path.join(stateDir, 'cp1.json'), `${JSON.stringify({
+    version: 1, task_id: stateTask.task.id, checkpoint_id: 'cp1', status: 'ready_for_acceptance', blockers: [],
+    project_completion: { status: 'in_progress' },
+    deferred_gates: [{
+      action: 'Execute the bounded action.', required_authority: 'Recorded owner authority.',
+      authorization_state: authorizationState, authority_ref: 'test-authority',
+      needed_when: authorizationState === 'future' ? 'after_acceptance' : 'now'
+    }]
+  }, null, 2)}\n`);
+  const stateNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+  assert.equal(stateNotice.results.some((item) => item.taskId === stateTask.task.id), false, `${authorizationState} authority must not create a waiting gate`);
+}
+
+// A checkpoint may bind an active subproject backlog. This prevents a global
+// project ledger from hiding the safe next milestone.
+await writeFile(authoritativeBacklog, `${JSON.stringify({ status: 'ongoing', items: [{ id: 'GLOBAL-01', status: 'accepted', dependsOn: [] }] }, null, 2)}\n`);
+const subprojectBacklog = path.join(root, 'project', 'cdqi2-backlog.json');
+await writeFile(subprojectBacklog, `${JSON.stringify({
+  status: 'ongoing', items: [
+    { id: 'CDQI2-10', status: 'accepted', dependsOn: [] },
+    { id: 'CDQI2-11', status: 'in_progress', dependsOn: ['CDQI2-10'] }
+  ]
+}, null, 2)}\n`);
+const subprojectTask = await enqueueTask(root, { queue, title: 'OpenReel CDQI2 actionable backlog', task: 'Continue CDQI2-11', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const subprojectDir = path.join(taskRuntimeDirFor(root, queue, subprojectTask.task.id), 'checkpoints');
+await mkdir(subprojectDir, { recursive: true });
+await writeFile(path.join(subprojectDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: subprojectTask.task.id, checkpoint_id: 'cp1', milestone_id: 'CDQI2-11',
+  backlog_source: 'project/cdqi2-backlog.json', status: 'ready_for_acceptance', blockers: [],
+  project_completion: { status: 'in_progress' },
+  deferred_gates: [{ action: 'Publish after T11.', required_authority: 'Owner publication approval.' }]
+}, null, 2)}\n`);
+const subprojectNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(subprojectNotice.results.some((item) => item.taskId === subprojectTask.task.id), false, 'safe checkpoint-bound backlog must prevent waiting');
+
+// A genuinely missing current authorization becomes a waiting gate once no
+// safe project work remains.
+await writeFile(authoritativeBacklog, `${JSON.stringify({ status: 'ongoing', items: [{ id: 'GLOBAL-01', status: 'accepted', dependsOn: [] }] }, null, 2)}\n`);
+const missing = await enqueueTask(root, { queue, title: 'OpenReel missing current authority', task: 'Perform currently gated action', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const missingDir = path.join(taskRuntimeDirFor(root, queue, missing.task.id), 'checkpoints');
+await mkdir(missingDir, { recursive: true });
+await writeFile(path.join(missingDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: missing.task.id, checkpoint_id: 'cp1', status: 'ready_for_acceptance', blockers: [],
+  project_completion: { status: 'in_progress' },
+  deferred_gates: [{ action: 'Publish now.', required_authority: 'Owner publication approval.', authorization_state: 'missing', needed_when: 'now' }]
+}, null, 2)}\n`);
+const missingNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(missingNotice.results.find((item) => item.taskId === missing.task.id)?.outcome, 'sent');
+await reconcileProjectGates(root, { queue });
+
+// A formal blocker that merely restates an in-scope production sequence
+// covered by the project standing authorization must not stop the queue.
+await writeFile(projectFile, `${JSON.stringify({
+  ...spec,
+  backlogSource: 'project/backlog.json',
+  acceptanceLedger: 'project/acceptance-ledger.json',
+  terminalContract: 'project/terminal.md',
+  actionPolicy: {
+    deploy: 'standing_authorization_openreel_2026-08-19',
+    productionConfig: 'standing_authorization_openreel_2026-08-19',
+    backupRestoreRollbackRehearsal: 'standing_authorization_openreel_2026-08-19'
+  }
+}, null, 2)}\n`);
+const coveredBlocker = await enqueueTask(root, { queue, title: 'OpenReel covered production blocker', task: 'Deploy accepted candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const coveredContract = await writeTaskContract(root, queue, coveredBlocker.task);
+assert.equal(coveredContract.contract.constraints.project_authorization.production_authorized, true);
+const coveredDir = path.join(taskRuntimeDirFor(root, queue, coveredBlocker.task.id), 'checkpoints');
+await mkdir(coveredDir, { recursive: true });
+await writeFile(path.join(coveredDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: coveredBlocker.task.id, checkpoint_id: 'cp1', status: 'needs_human_input',
+  blockers: [{ action: 'Back up, deploy, restart, verify readiness and rehearse rollback on the established production target.', required_authority: 'Separate process-control confirmation.' }],
+  verification: ['candidate accepted'], risks: [], project_completion: { status: 'in_progress' }
+}, null, 2)}\n`);
+const coveredNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(coveredNotice.results.some((item) => item.taskId === coveredBlocker.task.id), false, 'standing-authorized production blocker must not create a gate');
+
+// Explicitly authorized blocker metadata is also non-materializable, while a
+// genuinely missing publication permission remains a human gate.
+const publication = await enqueueTask(root, { queue, title: 'OpenReel publication blocker', task: 'Publish candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+await writeTaskContract(root, queue, publication.task);
+const publicationDir = path.join(taskRuntimeDirFor(root, queue, publication.task.id), 'checkpoints');
+await mkdir(publicationDir, { recursive: true });
+await writeFile(path.join(publicationDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: publication.task.id, checkpoint_id: 'cp1', status: 'needs_human_input',
+  blockers: [{ action: 'Publish externally now.', required_authority: 'Owner publication confirmation.', authorization_state: 'missing', needed_when: 'now' }],
+  verification: ['candidate ready'], risks: [], project_completion: { status: 'in_progress' }
+}, null, 2)}\n`);
+const publicationNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(publicationNotice.results.find((item) => item.taskId === publication.task.id)?.outcome, 'sent', 'missing publication authority must create a gate');
+await resolveHumanInput(root, { queue, gateId: `${publication.task.id}:cp1`, input: 'test resolution' });
+await reconcileProjectGates(root, { queue });
+
 // Once the authoritative project ledger accepts the terminal contract, an
 // optional post-completion deferred action stays in operations backlog and
 // neither creates nor retains a project-queue waiting gate.
@@ -223,4 +344,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', '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'] }));
+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', 'authorized and consumed authority do not create gates', 'checkpoint-bound subproject backlog remains actionable', 'missing current authority creates a gate', 'standing-authorized production blocker does not create a gate', 'missing publication blocker creates a gate', 'accepted project optional deferred gate stays out of queue'] }));

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

@@ -548,7 +548,10 @@ for (const [id, enqueuedAt] of [['history-done', '2026-01-01T00:00:00Z'], ['late
   });
   await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, id), 'checkpoints', 'cp1.json'), {
     version: 1, task_id: id, checkpoint_id: 'cp1', milestone_id: 'R-1', sequence: 1,
-    status: 'ready_for_acceptance', blockers: [], deferred_gates: [{ id: 'R-1', action: 'approve_requirement', required_authority: 'Approve R-1.' }],
+    status: 'ready_for_acceptance', blockers: [], deferred_gates: [{
+      id: 'R-1', action: 'approve_requirement', required_authority: 'Approve R-1.',
+      authorization_state: 'missing', needed_when: 'now', materialize: true
+    }],
     verification: [], risks: [], project_completion: 'in_progress', next_action: 'wait'
   });
   await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, id), 'final_judgement.json'), {