taskforce-loop-engineering 0.15.0 → 0.15.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Unreleased
 
+## 0.15.2 - 2026-08-21
+
+- Enrich terminal notifications with final judgement, checkpoint summary, verification count, blockers, and next action.
+- Link successful terminal notification ledgers back into queue run artifacts while preserving idempotent delivery.
+- Materialize only actionable deferred human gates, preserve project standing authorizations in task contracts, and allocate append-only checkpoint identifiers when replanning.
+
+## 0.15.1 - 2026-08-20
+
+- Keep generated OpenClaw and Hermes scheduler services healthy when asynchronous human or terminal notification delivery fails, while preserving notification logging and retries.
+
 ## 0.15.0 - 2026-08-20
 
 - Reconcile project-scoped human gates against the authoritative project contract and acceptance ledger, superseding stale or optional deferred gates without replay.

package/lib/core.mjs

@@ -1565,7 +1565,7 @@ function buildProjectSpec(options) {
     assumptions: [
       'Start with local artifacts and local verification.',
       'Use conservative defaults when the brief leaves implementation details open.',
-      'Ask for confirmation before external, destructive, production, push, publish, or deploy actions.'
+      'Apply the configured project action policy; ask only for actions that remain human-gated there.'
     ]
   };
 }
@@ -2102,9 +2102,42 @@ async function installedQueueLanguage(root, queue, fallback = 'en') {
   try { return normalizeLanguage((await readJson(file)).language); } catch { return normalizeLanguage(fallback); }
 }
 
-function terminalNotificationMessage(queue, task, language = 'en') {
+async function terminalNotificationContext(root, queue, task) {
+  const taskDir = taskRuntimeDirFor(root, queue, task.id);
+  const judgementFile = path.join(taskDir, 'final_judgement.json');
+  const checkpointsDir = path.join(taskDir, 'checkpoints');
+  const judgement = await exists(judgementFile) ? await readJson(judgementFile) : null;
+  let checkpoint = null;
+  const checkpointFiles = await listJson(checkpointsDir);
+  if (checkpointFiles.length > 0) {
+    const candidates = await Promise.all(checkpointFiles.map(async (file) => ({
+      file,
+      value: await readJson(path.join(checkpointsDir, file)),
+      mtimeMs: (await stat(path.join(checkpointsDir, file))).mtimeMs
+    })));
+    candidates.sort((a, b) => {
+      const sequenceDelta = Number(a.value?.sequence ?? -1) - Number(b.value?.sequence ?? -1);
+      return sequenceDelta || a.mtimeMs - b.mtimeMs;
+    });
+    checkpoint = candidates.at(-1)?.value ?? null;
+  }
+  return { judgement, checkpoint };
+}
+
+function compactNotificationText(value, max = 500) {
+  const text = String(value ?? '').replace(/\s+/g, ' ').trim();
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+async function terminalNotificationMessage(root, queue, task, language = 'en') {
+  const { judgement, checkpoint } = await terminalNotificationContext(root, queue, task);
   const needsReview = task.status === 'ready_for_human_review';
   const needsHuman = ['needs_human_input', 'blocked', 'ready_for_human_review'].includes(task.status);
+  const summary = compactNotificationText(checkpoint?.summary);
+  const verificationCount = Array.isArray(checkpoint?.verification) ? checkpoint.verification.length : 0;
+  const blockers = Array.isArray(checkpoint?.blockers) ? checkpoint.blockers.filter(Boolean) : [];
+  const outcome = judgement?.outcome;
+  const nextAction = compactNotificationText(judgement?.next_actions?.[0] ?? checkpoint?.next_action, 300);
   if (language === 'zh') return [
     needsReview ? 'Loop 任务已准备好接受人工验收'
       : needsHuman ? 'Loop 任务需要人工输入'
@@ -2112,6 +2145,11 @@ function terminalNotificationMessage(queue, task, language = 'en') {
     `任务：${task.title}`,
     `队列：${queue}`,
     `状态：${task.status}`,
+    ...(outcome ? [`最终判定：${outcome}`] : []),
+    ...(summary ? [`结果：${summary}`] : []),
+    ...(verificationCount ? [`验收：${verificationCount} 项验证证据已记录`] : []),
+    ...(blockers.length ? [`阻塞：${blockers.map((item) => compactNotificationText(item, 180)).join('；')}`] : []),
+    ...(nextAction ? [`下一步：${nextAction}`] : []),
     ...(needsReview
       ? [`下一步：检查最终判定，并为任务 ${task.id} 记录 approve、request_changes 或 reject。`]
       : needsHuman
@@ -2125,6 +2163,11 @@ function terminalNotificationMessage(queue, task, language = 'en') {
     `task: ${task.title}`,
     `queue: ${queue}`,
     `status: ${task.status}`,
+    ...(outcome ? [`final judgement: ${outcome}`] : []),
+    ...(summary ? [`result: ${summary}`] : []),
+    ...(verificationCount ? [`acceptance: ${verificationCount} verification evidence item(s) recorded`] : []),
+    ...(blockers.length ? [`blockers: ${blockers.map((item) => compactNotificationText(item, 180)).join('; ')}`] : []),
+    ...(nextAction ? [`next: ${nextAction}`] : []),
     ...(needsReview
       ? [`next: review the final judgement and record approve, request_changes, or reject for task ${task.id}.`]
       : needsHuman
@@ -2133,6 +2176,22 @@ function terminalNotificationMessage(queue, task, language = 'en') {
   ].join('\n');
 }
 
+async function linkTerminalNotificationToRun(root, task, ledgerFile, ledger, outcome = 'sent') {
+  if (!task.runPath) return false;
+  const runFile = path.resolve(root, task.runPath);
+  if (!await exists(runFile)) return false;
+  const run = await readJson(runFile);
+  await writeJson(runFile, {
+    ...run,
+    terminalNotification: {
+      outcome,
+      ledger: path.relative(root, ledgerFile),
+      notifiedAt: ledger.notified_at
+    }
+  });
+  return true;
+}
+
 export async function notifyTerminalTasks(root, options = {}) {
   const queue = normalizeLoopId(options.queue);
   const language = await installedQueueLanguage(root, queue, options.language);
@@ -2181,10 +2240,14 @@ export async function notifyTerminalTasks(root, options = {}) {
       const key = `${safeTaskId(task.id)}.${normalizeLoopId(task.status)}.json`;
       const ledgerFile = path.join(notificationDir, key);
       if (await exists(ledgerFile)) {
+        if (!options.dryRun) {
+          const ledger = await readJson(ledgerFile);
+          await linkTerminalNotificationToRun(root, task, ledgerFile, ledger);
+        }
         results.push({ taskId: task.id, status: task.status, outcome: 'already_notified', ledger: path.relative(root, ledgerFile) });
         continue;
       }
-      const message = terminalNotificationMessage(queue, task, language);
+      const message = await terminalNotificationMessage(root, queue, task, language);
       if (options.dryRun) {
         results.push({ taskId: task.id, status: task.status, outcome: 'dry_run', message, source: task.source });
         continue;
@@ -2215,6 +2278,7 @@ export async function notifyTerminalTasks(root, options = {}) {
         result: compactCommandResult(result)
       };
       await writeJson(ledgerFile, ledger);
+      await linkTerminalNotificationToRun(root, task, ledgerFile, ledger);
       results.push({ taskId: task.id, status: task.status, outcome: 'sent', ledger: path.relative(root, ledgerFile) });
     }
   }
@@ -2280,7 +2344,7 @@ export async function refreshTaskAcceptance(root, options = {}) {
 
 function humanInputMessage(queue, task, checkpoint, gateId, language = 'en') {
   const blockers = Array.isArray(checkpoint.blockers) ? checkpoint.blockers : [];
-  const deferredGates = Array.isArray(checkpoint.deferred_gates) ? checkpoint.deferred_gates : [];
+  const deferredGates = materializableDeferredGates(checkpoint);
   const requirements = blockers.length > 0 ? blockers : deferredGates;
   const blockerText = requirements.length
     ? requirements.map((item) => typeof item === 'string' ? item : item?.required_authority ?? item?.human_action_required ?? item?.user_action ?? item?.reason ?? item?.description ?? item?.message ?? JSON.stringify(item))
@@ -2303,6 +2367,19 @@ function humanInputMessage(queue, task, checkpoint, gateId, language = 'en') {
   ].join('\n');
 }
 
+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;
+    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);
+  });
+}
+
 async function tasksById(root, queue) {
   const tasks = new Map();
   for (const subdir of ['inbox', 'active', 'waiting', 'done', 'failed', 'canceled']) {
@@ -2341,7 +2418,7 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     for (const file of files) {
       const checkpointFile = path.join(runtimeDir, 'checkpoints', file);
       const checkpoint = await readJson(checkpointFile);
-      const deferred = Array.isArray(checkpoint?.deferred_gates) ? checkpoint.deferred_gates : [];
+      const deferred = materializableDeferredGates(checkpoint);
       if (['needs_human_input', 'blocked'].includes(checkpoint?.status) || deferred.length > 0) {
         checkpoints.push({ file, checkpoint, mtimeMs: (await stat(checkpointFile)).mtimeMs });
       }
@@ -2352,8 +2429,8 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
       || String(b.checkpoint.checkpoint_id ?? b.file).localeCompare(String(a.checkpoint.checkpoint_id ?? a.file)));
     const metadata = await gateProjectMetadata(root, entry.task, checkpoints[0].checkpoint);
     const latestCheckpoint = checkpoints[0].checkpoint;
-    const deferredOnly = Array.isArray(latestCheckpoint.deferred_gates)
-      && latestCheckpoint.deferred_gates.length > 0
+    const latestDeferredGates = materializableDeferredGates(latestCheckpoint);
+    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);
@@ -2389,7 +2466,7 @@ export async function notifyHumanInputRequests(root, options = {}) {
   const results = [];
   const candidates = await authoritativeHumanGateCandidates(root, queue, tasks);
   for (const { taskId, entry, file, checkpoint } of candidates) {
-      const deferredGates = Array.isArray(checkpoint?.deferred_gates) ? checkpoint.deferred_gates : [];
+      const deferredGates = materializableDeferredGates(checkpoint);
       const checkpointId = checkpoint.checkpoint_id ?? path.basename(file, '.json');
       const gateId = `${taskId}:${checkpointId}`;
       const ledgerFile = path.join(gatesDir, `${safeTaskId(taskId)}.${normalizeLoopId(checkpointId)}.json`);
@@ -2789,6 +2866,35 @@ function defaultBlockedActions(riskLevel) {
   return blocked;
 }
 
+function taskProjectReference(task, specs) {
+  const explicit = String(task?.projectId ?? task?.project_id ?? '').trim();
+  if (explicit) return specs.find((spec) => spec.project === explicit) ?? null;
+  const text = `${task?.title ?? ''}\n${task?.body ?? ''}`;
+  return specs
+    .filter((spec) => typeof spec?.project === 'string' && text.includes(spec.project))
+    .sort((a, b) => b.project.length - a.project.length)[0] ?? null;
+}
+
+async function taskProjectAuthorization(root, task) {
+  const projectSpec = taskProjectReference(task, await projectSpecs(root));
+  if (!projectSpec?.actionPolicy || typeof projectSpec.actionPolicy !== 'object') return null;
+  const policy = projectSpec.actionPolicy;
+  const standing = (value) => typeof value === 'string' && value.startsWith('standing_authorization_');
+  const productionAuthorized = standing(policy.deploy)
+    && standing(policy.productionConfig)
+    && standing(policy.backupRestoreRollbackRehearsal);
+  const paidLimit = Number(policy.paidActionPerActionCnyLimit);
+  const paidAuthorized = Number.isFinite(paidLimit) && paidLimit > 0;
+  return {
+    project: projectSpec.project,
+    source: `configs/loops/projects/${projectSpec.project}.json`,
+    production_authorized: productionAuthorized,
+    production_authorization: productionAuthorized ? policy.deploy : null,
+    paid_action_authorized: paidAuthorized,
+    paid_action_per_action_cny_limit: paidAuthorized ? paidLimit : null
+  };
+}
+
 export function inferTaskScope(task) {
   const requestText = `${task?.title ?? ''}\n${task?.body ?? ''}`.toLowerCase();
   // A project can be referenced as context while the routed task is explicitly
@@ -2808,6 +2914,18 @@ function buildTaskContract(queue, task, options = {}) {
   const modelAssessed = task.riskAssessment === 'model_assessed';
   const riskLevel = options.riskLevel ?? (modelAssessed ? 'model_assessed' : inferredRisk.level);
   const taskScope = inferTaskScope(task);
+  const projectAuthorization = options.projectAuthorization ?? null;
+  const blockedActions = defaultBlockedActions(riskLevel).filter((action) => !(
+    projectAuthorization?.production_authorized
+    && action === 'production_config_change_without_explicit_confirmation'
+  ));
+  const allowedActions = defaultAllowedActions(riskLevel);
+  if (projectAuthorization?.production_authorized) {
+    allowedActions.push('in_scope_production_deploy_config_backup_restore_rollback_under_standing_authorization');
+  }
+  if (projectAuthorization?.paid_action_authorized) {
+    allowedActions.push('paid_provider_action_with_existing_credentials_within_per_action_cny_limit');
+  }
   return {
     version: 1,
     task_id: task.id,
@@ -2822,8 +2940,9 @@ function buildTaskContract(queue, task, options = {}) {
       'Verification evidence or blockers'
     ],
     constraints: {
-      allowed_actions: defaultAllowedActions(riskLevel),
-      blocked_actions: defaultBlockedActions(riskLevel),
+      allowed_actions: allowedActions,
+      blocked_actions: blockedActions,
+      ...(projectAuthorization ? { project_authorization: projectAuthorization } : {}),
       workspace: options.workspace ?? null
     },
     risk_level: riskLevel,
@@ -2921,7 +3040,8 @@ export async function writeTaskContract(root, queue, task, options = {}) {
   let contract = buildTaskContract(queue, task, {
     ...options,
     workspace: options.workspace ?? root,
-    historicalPatterns
+    historicalPatterns,
+    projectAuthorization: options.projectAuthorization ?? await taskProjectAuthorization(root, task)
   });
   contract = await mergeLiveAmendments(root, queue, task.id, contract, 'supplemental_requirements');
   await writeJson(file, contract);
@@ -3150,8 +3270,7 @@ export async function writeAcceptancePlan(root, queue, task, taskContract, optio
   };
 }
 
-function buildDevPlan(contract, acceptancePlan) {
-  const firstCheckpointId = 'cp1';
+function buildDevPlan(contract, acceptancePlan, firstCheckpointId = 'cp1') {
   const gated = contract.requires_human_gate;
   return {
     version: 1,
@@ -3194,6 +3313,10 @@ function buildDevPlan(contract, acceptancePlan) {
       verification: [],
       blockers: [],
       deferred_gates: [],
+      deferred_gate_schema: {
+        action: 'Concrete action that cannot proceed now.',
+        required_authority: 'Specific authority or input required for that action.'
+      },
       project_completion: null,
       risks: [],
       next_action: 'acceptance_review'
@@ -3209,7 +3332,14 @@ export async function writeDevPlan(root, queue, task, taskContract, acceptancePl
   await mkdir(checkpointsDir, { recursive: true });
   await mkdir(reviewsDir, { recursive: true });
   const file = path.join(dir, 'dev_plan.json');
-  let plan = buildDevPlan(taskContract.contract, acceptancePlan.plan);
+  const existingCheckpointFiles = await listJson(checkpointsDir);
+  const usedCheckpointNumbers = new Set(existingCheckpointFiles
+    .map((file) => Number(String(file).match(/^cp(\d+)\.json$/)?.[1]))
+    .filter((value) => Number.isInteger(value) && value > 0));
+  let checkpointNumber = 1;
+  while (usedCheckpointNumbers.has(checkpointNumber)) checkpointNumber += 1;
+  const nextCheckpointId = `cp${checkpointNumber}`;
+  let plan = buildDevPlan(taskContract.contract, acceptancePlan.plan, nextCheckpointId);
   plan = await mergeLiveAmendments(root, queue, task.id, plan, 'supplemental_instructions');
   await writeJson(file, plan);
   return {
@@ -3490,7 +3620,7 @@ export async function writeAcceptanceReviews(root, queue, task, taskContract, ac
       checkpointCreatedAt: checkpoint.created_at ?? null,
       createdAt: checkpoint.created_at ?? review.created_at,
       projectCompletion: checkpoint.project_completion ?? null,
-      deferredGates: Array.isArray(checkpoint.deferred_gates) ? checkpoint.deferred_gates : [],
+      deferredGates: materializableDeferredGates(checkpoint),
       status: review.status,
       file: path.relative(root, reviewFile)
     });

package/package.json

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

package/scripts/hermes-install-self-test.mjs

@@ -33,6 +33,7 @@ const install = await run(process.execPath, [installer, ...base, '--confirm-inst
 const queue = JSON.parse(await readFile(path.join(root, 'configs/loops/queues/hermes-tasks.json'), 'utf8')); if (queue.dispatcher !== 'node scripts/loops/hermes-loop-dispatch.mjs' || queue.scheduler?.required !== true) throw new Error('Hermes queue wiring missing');
 const instructions = await readFile(path.join(root, 'AGENTS.md'), 'utf8'); if (!instructions.includes('Use Loop Engineering to fix this issue') || !instructions.includes('Queue this only; do not run it yet') || /走 loop|只入队|只排队/.test(instructions)) throw new Error('Hermes English conversation instructions are missing or contain Chinese routing examples');
 const wrapper = await readFile(path.join(root, 'scripts/loops/hermes-loop.mjs'), 'utf8'); if (!wrapper.includes('queue') || !wrapper.includes('continue') || /只入队|只排队|继续当前/.test(wrapper)) throw new Error('Hermes English wrapper routing was not fully localized');
+if (!wrapper.includes('process.exitCode = tickCode;') || wrapper.includes('process.exitCode = tickCode || humanCode || terminalCode;')) throw new Error('Hermes scheduler health still depends on notification delivery');
 const dispatcher = await readFile(path.join(root, 'scripts/loops/hermes-loop-dispatch.mjs'), 'utf8'); if (!dispatcher.includes("'-z', prompt")) throw new Error('Hermes one-shot dispatcher missing');
 const notifier = path.join(root, 'scripts/loops/hermes-loop-notify.mjs'); const notify = await run(process.execPath, [notifier, 'hello from loop'], { env: { ...process.env, HERMES_SEND_CAPTURE: sendCapture, LOOP_NOTIFICATION_SOURCE: JSON.stringify({ channel: 'telegram', target: 'telegram:12345' }) } }); if (notify.code !== 0) throw new Error(`Hermes notifier failed: ${notify.stderr}`);
 const sent = JSON.parse(await readFile(sendCapture, 'utf8')); if (!sent.includes('telegram:12345') || !sent.includes('hello from loop')) throw new Error('Hermes notifier did not preserve delivery target/message');

package/scripts/hermes-install.mjs

@@ -116,7 +116,7 @@ if (command === 'route') {
   const tickCode = await run(['queue-scheduler-tick', '--config', ${JSON.stringify(`configs/loops/queues/${queue}.json`)}, '--progress-notify-command', 'node scripts/loops/hermes-loop-notify.mjs', ...rest]);
   const humanCode = await run(['queue-human-input-notify', '--queue', ${JSON.stringify(queue)}, '--notify-command', 'node scripts/loops/hermes-loop-notify.mjs']);
   const terminalCode = await run(['queue-terminal-notify', '--queue', ${JSON.stringify(queue)}, '--notify-command', 'node scripts/loops/hermes-loop-notify.mjs']);
-  process.exitCode = tickCode || humanCode || terminalCode;
+  process.exitCode = tickCode;
 } else { console.error(${JSON.stringify(text(language, 'Usage: node scripts/loops/hermes-loop.mjs route|run-once|scheduler-tick', '用法：node scripts/loops/hermes-loop.mjs route|run-once|scheduler-tick'))}); process.exitCode = 1; }
 `;
 }

package/scripts/openclaw-install-self-test.mjs

@@ -70,6 +70,7 @@ const instructions = await readFile(path.join(root, 'AGENTS.md'), 'utf8');
 if (!instructions.includes('Use Loop Engineering to fix this issue') || !instructions.includes('Queue this only; do not run it yet') || /走 loop|只入队|只排队/.test(instructions)) throw new Error('English conversation instructions are missing or contain Chinese routing examples');
 const wrapper = await readFile(path.join(root, 'scripts/loops/openclaw-loop.mjs'), 'utf8');
 if (!wrapper.includes('--supersede-active') || !wrapper.includes('--amend-active') || !wrapper.includes('--progress-notify-command') || !wrapper.includes('runWhenUnlocked') || wrapper.includes("run-queue-drain', '--config'") || wrapper.includes("spawn('loop-engineering'") || !wrapper.includes('queue-human-input-notify') || !wrapper.includes('queue-terminal-notify') || !wrapper.includes('queue-scheduler-tick') || !wrapper.includes('queue') || !wrapper.includes('continue') || /只入队|只排队|继续当前/.test(wrapper) || !wrapper.includes('requiredSource') || !wrapper.includes('--source-message-id')) throw new Error('supersede/amend routing, source fail-closed policy, localization, absolute CLI, scheduler, live progress, async notification, or queue-only routing missing');
+if (!wrapper.includes('process.exitCode = tickCode;') || wrapper.includes('process.exitCode = tickCode || humanNotifyCode || terminalNotifyCode;')) throw new Error('scheduler health still depends on notification delivery');
 const missingSourceRoute = await new Promise((resolve) => {
   const child = spawn(process.execPath, [path.join(root, 'scripts/loops/openclaw-loop.mjs'), 'route', '--message', '用 loop engineering 对齐系统'], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
   let stderr = ''; child.stderr.on('data', (chunk) => { stderr += chunk; });

package/scripts/openclaw-install.mjs

@@ -218,7 +218,7 @@ if (command === 'route') {
   const tickCode = await run(['queue-scheduler-tick', '--config', ${JSON.stringify(`configs/loops/queues/${queue}.json`)}, '--progress-notify-command', 'node scripts/loops/openclaw-loop-notify.mjs', ...rest]);
   const humanNotifyCode = await run(['queue-human-input-notify', '--queue', ${JSON.stringify(queue)}, '--notify-command', 'node scripts/loops/openclaw-loop-notify.mjs']);
   const terminalNotifyCode = await run(['queue-terminal-notify', '--queue', ${JSON.stringify(queue)}, '--notify-command', 'node scripts/loops/openclaw-loop-notify.mjs']);
-  process.exitCode = tickCode || humanNotifyCode || terminalNotifyCode;
+  process.exitCode = tickCode;
 } else {
   console.error(${JSON.stringify(usage)});
   process.exitCode = 1;

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 } from '../lib/core.mjs';
+import { doctorReport, enqueueTask, notifyHumanInputRequests, projectStatus, queueStatus, reconcileProjectGates, routeLoopMessage, taskRuntimeDirFor, writeTaskContract } from '../lib/core.mjs';
 
 const root = await mkdtemp(path.join(os.tmpdir(), 'loop-project-gates-'));
 const queue = 'shared';
@@ -14,6 +14,32 @@ const spec = { schemaVersion: 1, project: 'openreel', type: 'code_project', queu
 await mkdir(path.dirname(projectFile), { recursive: true });
 await writeFile(projectFile, `${JSON.stringify(spec, null, 2)}\n`);
 
+// A project standing authorization must reach the generated task contract.
+// It authorizes only the configured in-scope production and bounded paid
+// actions; unrelated external, destructive, credential, push and publish
+// actions remain blocked.
+await writeFile(projectFile, `${JSON.stringify({
+  ...spec,
+  actionPolicy: {
+    deploy: 'standing_authorization_openreel_2026-08-19',
+    productionConfig: 'standing_authorization_openreel_2026-08-19',
+    backupRestoreRollbackRehearsal: 'standing_authorization_openreel_2026-08-19',
+    paidActionPerActionCnyLimit: 100,
+    externalWrites: 'human_confirm',
+    destructiveActions: 'human_confirm'
+  }
+}, null, 2)}\n`);
+const authorizedTask = await enqueueTask(root, { queue, title: 'OpenReel production acceptance', task: 'Continue project openreel production acceptance under its action policy', projectId: 'openreel' });
+const authorizedContract = (await writeTaskContract(root, queue, authorizedTask.task)).contract;
+assert.equal(authorizedContract.constraints.project_authorization.project, 'openreel');
+assert.equal(authorizedContract.constraints.project_authorization.production_authorized, true);
+assert.equal(authorizedContract.constraints.project_authorization.paid_action_per_action_cny_limit, 100);
+assert.equal(authorizedContract.constraints.blocked_actions.includes('production_config_change_without_explicit_confirmation'), false);
+assert(authorizedContract.constraints.allowed_actions.includes('in_scope_production_deploy_config_backup_restore_rollback_under_standing_authorization'));
+assert(authorizedContract.constraints.allowed_actions.includes('paid_provider_action_with_existing_credentials_within_per_action_cny_limit'));
+assert(authorizedContract.constraints.blocked_actions.includes('credential_change_without_explicit_confirmation'));
+await writeFile(projectFile, `${JSON.stringify(spec, null, 2)}\n`);
+
 const b = await enqueueTask(root, { queue, title: 'OpenReel B-01', task: 'Project openreel requirement B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
 const checkpointDir = path.join(taskRuntimeDirFor(root, queue, b.task.id), 'checkpoints');
 await mkdir(checkpointDir, { recursive: true });
@@ -85,6 +111,21 @@ 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);
 
+// Conditional policy boundaries are not current blockers. Plain prose in
+// deferred_gates must not materialize a gate without a concrete action and
+// authority requirement.
+await reconcileProjectGates(root, { queue });
+const conditional = await enqueueTask(root, { queue, title: 'OpenReel conditional policy boundary', task: 'Continue safe OpenReel backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const conditionalDir = path.join(taskRuntimeDirFor(root, queue, conditional.task.id), 'checkpoints');
+await mkdir(conditionalDir, { recursive: true });
+await writeFile(path.join(conditionalDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: conditional.task.id, checkpoint_id: 'cp1', status: 'ready_for_acceptance', blockers: [],
+  project_completion: { status: 'in_progress' },
+  deferred_gates: ['Any future paid action above the standing limit requires confirmation.']
+}, null, 2)}\n`);
+const conditionalNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(conditionalNotice.results.some((item) => item.taskId === conditional.task.id), false);
+
 // 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.
@@ -104,4 +145,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: ['structured gate context', 'B-01 waiting to zero', 'project-isolated supersede', 'doctor strong validation', 'authoritative ledger drift', 'ready milestone deferred 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', 'conditional policy prose does not create a gate', 'accepted project optional deferred gate stays out of queue'] }));

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

@@ -20,12 +20,25 @@ import {
   runQueueOnce,
   runQueueDrain,
   taskRuntimeDirFor,
+  writeDevPlan,
   writeJson
 } from '../lib/core.mjs';
 
 const root = await mkdtemp(path.join(tmpdir(), 'loop-route-notify-'));
 const queue = 'route-smoke';
 
+// Replanning the same durable task must never point a worker at an existing
+// checkpoint file. Historical checkpoint evidence is append-only.
+const checkpointTask = { id: 'checkpoint-sequence' };
+const checkpointContract = { contract: { task_id: checkpointTask.id, risk_level: 'L1', requires_human_gate: false } };
+const checkpointAcceptance = { plan: { functional_checks: [], regression_checks: [], negative_tests: [] } };
+const firstDevPlan = await writeDevPlan(root, queue, checkpointTask, checkpointContract, checkpointAcceptance);
+assert.equal(firstDevPlan.plan.checkpoints[0].id, 'cp1');
+await writeJson(path.join(taskRuntimeDirFor(root, queue, checkpointTask.id), 'checkpoints', 'cp1.json'), { checkpoint_id: 'cp1' });
+const secondDevPlan = await writeDevPlan(root, queue, checkpointTask, checkpointContract, checkpointAcceptance);
+assert.equal(secondDevPlan.plan.checkpoints[0].id, 'cp2');
+assert.equal(secondDevPlan.plan.checkpoint_schema.checkpoint_id, 'cp2');
+
 assert.equal(normalizeGoalDecision({ verdict: 'revise' }).decision, 'change_strategy');
 assert.deepEqual(goalLoopTransition({ decision: 'change_strategy' }, { round: 1, maxRounds: 3 }), {
   status: 'replan_pending',
@@ -495,12 +508,27 @@ assert.deepEqual(await readJson(activeRequeued), activeBefore);
 await rename(activeRequeued, inboxRequeued);
 await writeJson(failedFile, { ...requeuedTask, status: 'needs_human_input' });
 await rm(inboxRequeued, { force: true });
+await writeJson(path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-terminal.json'), {
+  version: 1, task_id: routed.task.id, checkpoint_id: 'cp-terminal', sequence: 99,
+  status: 'ready_for_acceptance', summary: 'Terminal summary is visible.', blockers: [],
+  verification: [{ command: 'self-test', result: 'passed' }], risks: [], next_action: 'report'
+});
+await writeJson(finalJudgementFile, {
+  version: 1, task_id: routed.task.id, outcome: 'ready_to_apply', next_actions: ['Report the accepted result.']
+});
 
 const dryRun = await notifyTerminalTasks(root, { queue, dryRun: true });
 assert.match(dryRun.results[0].message, /Loop 任务/);
+assert.match(dryRun.results[0].message, /最终判定：/);
+assert.match(dryRun.results[0].message, /结果：/);
 assert.equal(dryRun.results[0].outcome, 'dry_run');
 const sent = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(sent.sent, 1);
+const notifiedTask = await readJson(path.join(queueSubdirFor(root, queue, 'failed'), path.basename(failedFile)));
+if (notifiedTask.runPath) {
+  const notifiedRun = await readJson(path.join(root, notifiedTask.runPath));
+  assert.equal(notifiedRun.terminalNotification?.outcome, 'sent');
+}
 const repeated = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(repeated.results[0].outcome, 'already_notified');
 
@@ -519,7 +547,7 @@ 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', required_authority: 'Approve R-1.' }],
+    status: 'ready_for_acceptance', blockers: [], deferred_gates: [{ id: 'R-1', action: 'approve_requirement', required_authority: 'Approve R-1.' }],
     verification: [], risks: [], project_completion: 'in_progress', next_action: 'wait'
   });
   await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, id), 'final_judgement.json'), {