taskforce-loop-engineering 0.15.14 → 0.15.16

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.15.16 - 2026-09-13
+
+- Resolve canonical project identifiers from nested checkpoint completion metadata so migrated project tasks continue against the correct authoritative backlog.
+- Keep future external-action authorization gates deferred while safe local project work remains actionable.
+- Add regression coverage for checkpoint-only project metadata and premature deferred-gate reconciliation.
+
+## 0.15.15 - 2026-08-31
+
+- Lock a task-level accepted terminal checkpoint monotonically so later broader-project governance cannot reopen or overwrite the completed task.
+- Require fully materialized, source/actor/generation-bound Human Gate artifacts before moving tasks to waiting or sending actionable notifications.
+- Fail closed for incomplete or non-authoritative Gate artifacts, and keep dry-run previews free of actionable reply commands.
+- Add regressions for broader-project scope creep after task acceptance, empty/unbound gates, authoritative waiting placement, and notification consistency.
+
 ## 0.15.14 - 2026-08-30
 
 - Add one authoritative cross-interface Human Gate command core for Dashboard and trusted chat adapters, with strict source binding, generation fencing, idempotency receipts, confirmation escalation, and fail-closed handling of ordinary chat.

package/lib/core.mjs

@@ -1214,7 +1214,12 @@ function requirementIdsFromCheckpoint(checkpoint, specs) {
 }
 
 function inferProjectSpec(task, checkpoint, specs, requirementIds = []) {
-  const explicit = checkpoint?.project_id ?? checkpoint?.projectId ?? task?.project_id ?? task?.projectId;
+  const explicit = checkpoint?.project_id
+    ?? checkpoint?.projectId
+    ?? checkpoint?.project_completion?.project
+    ?? checkpoint?.projectCompletion?.project
+    ?? task?.project_id
+    ?? task?.projectId;
   if (explicit) return specs.find((spec) => spec.project === explicit) ?? null;
   const text = `${task?.title ?? ''}\n${task?.body ?? ''}`.toLowerCase();
   const candidates = specs.map((spec) => ({
@@ -2453,6 +2458,33 @@ function humanInputMessage(queue, task, checkpoint, gateId, language = 'en', blo
   ].join('\n');
 }
 
+function authoritativeGateBindings(task) {
+  const source = task?.source;
+  const generation = Number(task?.runtimeSessionGeneration ?? 0);
+  if (!source?.channel || !source?.target || !source?.account || !Number.isInteger(generation) || generation < 0) return null;
+  return {
+    source_binding: {
+      channel: source.channel,
+      target: source.target,
+      account: source.account,
+      message_id: source.messageId ?? source.message_id ?? null
+    },
+    actor_binding: { kind: 'source_target', actor_id: source.target, account: source.account },
+    generation
+  };
+}
+
+function authoritativeGateReady(gate, task) {
+  const expected = authoritativeGateBindings(task);
+  if (!expected || !gate || gate.status !== 'waiting_for_human') return false;
+  return gate.source_binding?.channel === expected.source_binding.channel
+    && gate.source_binding?.target === expected.source_binding.target
+    && gate.source_binding?.account === expected.source_binding.account
+    && gate.actor_binding?.actor_id === expected.actor_binding.actor_id
+    && gate.actor_binding?.account === expected.actor_binding.account
+    && gate.generation === expected.generation;
+}
+
 function blockerCoveredByContractAuthorization(blocker, contract) {
   if (!blocker || typeof blocker !== 'object' || Array.isArray(blocker)) return false;
   const state = String(blocker.authorization_state ?? blocker.state ?? '')
@@ -2660,8 +2692,17 @@ export async function notifyHumanInputRequests(root, options = {}) {
       const checkpointId = checkpoint.checkpoint_id ?? path.basename(file, '.json');
       const gateId = `${taskId}:${checkpointId}`;
       const ledgerFile = path.join(gatesDir, `${safeTaskId(taskId)}.${normalizeLoopId(checkpointId)}.json`);
+      const bindings = authoritativeGateBindings(entry.task);
+      if (!bindings) {
+        results.push({ taskId, checkpointId, gateId, outcome: 'fail_closed', error: 'incomplete_source_actor_generation_binding' });
+        continue;
+      }
       if (await exists(ledgerFile)) {
         const gate = await readJson(ledgerFile);
+        if (!authoritativeGateReady(gate, entry.task)) {
+          results.push({ taskId, checkpointId, gateId, outcome: 'fail_closed', error: 'non_authoritative_gate_artifact', ledger: path.relative(root, ledgerFile) });
+          continue;
+        }
         if (gate.status === 'waiting_for_human' && ['inbox', 'done', 'failed'].includes(entry.subdir)) {
           const sourceFile = path.join(queueSubdirFor(root, queue, entry.subdir), `${safeTaskId(taskId)}.json`);
           if (await exists(sourceFile)) {
@@ -2693,7 +2734,7 @@ export async function notifyHumanInputRequests(root, options = {}) {
             id: gate?.id ?? `deferred-${index + 1}`, action: gate?.action ?? gate?.kind ?? null,
             required_authority: gate?.required_authority ?? gate?.human_action_required ?? gate?.reason ?? gate?.description ?? String(gate),
             scope: gate?.scope ?? null
-          })), source: entry.task.source, requested_at: now,
+          })), source: entry.task.source, ...bindings, requested_at: now,
           notification_record: { status: 'pending', attempts: 0, idempotency_key: gateId }
         });
         if (['inbox', 'done', 'failed'].includes(entry.subdir)) {
@@ -2711,11 +2752,16 @@ export async function notifyHumanInputRequests(root, options = {}) {
           }
         }
       }
-      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 });
+        results.push({ taskId, checkpointId, gateId, outcome: 'dry_run', preview: 'authoritative_gate_would_be_materialized', source: entry.task.source });
+        continue;
+      }
+      const materializedGate = await readJson(ledgerFile);
+      if (!authoritativeGateReady(materializedGate, entry.task)) {
+        results.push({ taskId, checkpointId, gateId, outcome: 'fail_closed', error: 'gate_materialization_validation_failed' });
         continue;
       }
+      const message = humanInputMessage(queue, entry.task, checkpoint, gateId, language, blockers);
       const result = await runCommand(`${options.notifyCommand} ${shellQuote(message)}`, {
         cwd: root,
         timeoutMs: options.timeoutMs ?? 60_000,
@@ -2873,7 +2919,19 @@ async function prepareHumanInputContext(root, queue, taskId) {
   for (const file of await listJson(gatesDir)) {
     const full = path.join(gatesDir, file);
     const gate = await readJson(full);
-    if (gate.task_id !== taskId || !['resolved', 'consumed'].includes(gate.status)) continue;
+    if (gate.task_id !== taskId || !['resolved', 'consumed', 'waiting_for_human'].includes(gate.status)) continue;
+    if (gate.status === 'waiting_for_human') {
+      gates.push({
+        gate_id: gate.gate_id,
+        checkpoint_id: gate.checkpoint_id,
+        status: gate.status,
+        source_binding: gate.source_binding ?? null,
+        actor_binding: gate.actor_binding ?? null,
+        generation: gate.generation ?? null,
+        authoritative: true
+      });
+      continue;
+    }
     const consumedAt = gate.consumed_at ?? new Date().toISOString();
     const consumed = gate.status === 'resolved' ? { ...gate, status: 'consumed', consumed_at: consumedAt } : gate;
     if (gate.status === 'resolved') await writeJson(full, consumed);
@@ -3698,9 +3756,8 @@ function aggregateCriticStatus(baseStatus, criticReviews) {
 }
 
 function projectCompletionStatus(value) {
-  if (typeof value === 'string') return value;
-  if (value && typeof value === 'object') return value.status ?? null;
-  return null;
+  const raw = typeof value === 'string' ? value : value && typeof value === 'object' ? value.status : null;
+  return ['accepted', 'complete', 'completed'].includes(raw) ? 'accepted' : raw;
 }
 
 function continuationNextAction(value) {
@@ -3880,11 +3937,22 @@ function compareReviewRecency(a, b) {
   return compareReviewSequence(a, b);
 }
 
-export function selectEffectiveAcceptanceReviews(devPlan, acceptanceReviews) {
+function terminalTaskReview(review, contract = {}) {
+  if (review?.status !== 'accepted') return false;
+  return projectCompletionStatus(review.projectCompletion) === 'accepted'
+    || review.taskTerminal === true;
+}
+
+export function selectEffectiveAcceptanceReviews(devPlan, acceptanceReviews, contract = {}) {
   const allReviews = acceptanceReviews?.reviews ?? [];
   const planned = Array.isArray(devPlan?.checkpoints) ? devPlan.checkpoints : [];
   if (planned.length <= 1) {
-    return [...allReviews].sort(compareReviewRecency).slice(-1);
+    const ordered = [...allReviews].sort(compareReviewRecency);
+    // A task-level terminal acceptance is monotonic. Later checkpoints may
+    // report broader project governance, but they cannot reopen or overwrite
+    // the completed task. Broader work belongs to the project ledger/gates.
+    const terminal = ordered.find((review) => terminalTaskReview(review, contract));
+    return terminal ? [terminal] : ordered.slice(-1);
   }
   const selected = [];
   for (const checkpoint of planned) {
@@ -3907,7 +3975,7 @@ export function buildFinalJudgement(contract, acceptancePlan, devPlan, checkpoin
   // Checkpoints produced after the planned set are revision/progress snapshots,
   // not additional required milestones. Judge the latest complete set so a
   // resolved historical blocker does not permanently poison the task.
-  const effectiveReviews = selectEffectiveAcceptanceReviews(devPlan, acceptanceReviews);
+  const effectiveReviews = selectEffectiveAcceptanceReviews(devPlan, acceptanceReviews, contract);
   const reviewCount = effectiveReviews.length;
   const acceptedCount = effectiveReviews.filter((item) => item.status === 'accepted').length;
   const reviseCount = effectiveReviews.filter((item) => item.status === 'revise').length;
@@ -4011,6 +4079,7 @@ export function buildFinalJudgement(contract, acceptancePlan, devPlan, checkpoin
       reviews: reviewCount,
       historical_reviews: allReviews.length,
       effective_review_ids: effectiveReviews.map((review) => review.checkpointId),
+      terminal_lock: effectiveReviews.some((review) => terminalTaskReview(review, contract)),
       accepted: acceptedCount,
       revise: reviseCount,
       blocked: blockedCount,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.15.14",
+  "version": "0.15.16",
   "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

@@ -194,4 +194,29 @@ assert.equal(inferTaskScope({ body: 'Continue the overall project with a product
   assert.deepEqual(judgement.residual_risks, ['A non-blocking operational risk remains after acceptance.']);
 }
 
+// Regression: once cp19 accepted the task's own terminal contract, a later
+// checkpoint carrying broader-project human acceptance cannot reopen it.
+{
+  const devPlan = { checkpoints: [{ id: 'cp1' }] };
+  const reviews = { reviews: [
+    {
+      checkpointId: 'cp19', sequence: 19, status: 'accepted',
+      projectCompletion: { status: 'complete' }, checkpointRisks: []
+    },
+    {
+      checkpointId: 'cp21', sequence: 21, status: 'blocked',
+      projectCompletion: { status: 'needs_human_acceptance' },
+      checkpointNextAction: 'owner accepts broader OpenReel v4 project'
+    }
+  ] };
+  const judgement = buildFinalJudgement(
+    { ...baseContract, task_scope: 'project', requires_human_gate: false },
+    basePlan, devPlan, { count: 21 }, reviews, { dispatchStatus: 'completed' }
+  );
+  assert.equal(judgement.outcome, 'ready_to_apply');
+  assert.deepEqual(judgement.coverage.effective_review_ids, ['cp19']);
+  assert.equal(judgement.coverage.terminal_lock, true);
+  assert.equal(judgement.requires_human_gate, false);
+}
+
 console.log('final judgement self-test passed');

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

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { access, 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, resolveHumanInput, routeLoopMessage, taskRuntimeDirFor, writeTaskContract } from '../lib/core.mjs';
@@ -40,7 +40,7 @@ assert(authorizedContract.constraints.allowed_actions.includes('paid_provider_ac
 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 b = await enqueueTask(root, { queue, title: 'OpenReel B-01', task: 'Project openreel requirement B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const checkpointDir = path.join(taskRuntimeDirFor(root, queue, b.task.id), 'checkpoints');
 await mkdir(checkpointDir, { recursive: true });
 await writeFile(path.join(checkpointDir, 'cp1.json'), `${JSON.stringify({ version: 1, task_id: b.task.id, checkpoint_id: 'cp1', milestone_id: 'B-01', requirement_ids: ['B-01'], status: 'needs_human_input', blockers: ['Authorize B-01'] }, null, 2)}\n`);
@@ -132,7 +132,7 @@ await writeFile(projectFile, `${JSON.stringify({
 
 // A ready milestone with project in progress and a deferred authorization is
 // converted into a structured waiting gate, not left as prose on a done task.
-const deferred = await enqueueTask(root, { queue, title: 'OpenReel deferred S-01', task: 'Project openreel S-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const deferred = await enqueueTask(root, { queue, title: 'OpenReel deferred S-01', task: 'Project openreel S-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const deferredDir = path.join(taskRuntimeDirFor(root, queue, deferred.task.id), 'checkpoints');
 await mkdir(deferredDir, { recursive: true });
 await writeFile(path.join(deferredDir, 'cp-ready.json'), `${JSON.stringify({
@@ -164,7 +164,7 @@ await writeFile(authoritativeBacklog, `${JSON.stringify({
     { 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 futureGateTask = await enqueueTask(root, { queue, title: 'OpenReel future production gate', task: 'Continue safe local backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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({
@@ -176,11 +176,51 @@ const futureNotice = await notifyHumanInputRequests(root, { queue, notifyCommand
 assert.equal(futureNotice.results.some((item) => item.taskId === futureGateTask.task.id), false);
 assert.equal((await queueStatus(root, queue)).waiting, 0);
 
+// Older queue carriers can lack project metadata while the worker checkpoint
+// records the canonical project id inside project_completion. Resolve that id
+// before evaluating deferred gates so safe local backlog keeps running.
+const nestedProjectTask = await enqueueTask(root, {
+  queue,
+  title: 'Continue R1-R7',
+  task: 'Continue the next safe local milestone',
+  sourceChannel: 'test',
+  sourceTarget: 'owner',
+  sourceAccount: 'main'
+});
+const nestedProjectDir = path.join(taskRuntimeDirFor(root, queue, nestedProjectTask.task.id), 'checkpoints');
+await mkdir(nestedProjectDir, { recursive: true });
+await writeFile(path.join(nestedProjectDir, 'cp1.json'), `${JSON.stringify({
+  version: 1,
+  task_id: nestedProjectTask.task.id,
+  checkpoint_id: 'cp1',
+  status: 'ready_for_acceptance',
+  blockers: [],
+  project_completion: { project: 'openreel', 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.',
+    authorization_state: 'missing',
+    needed_when: 'now',
+    materialize: true
+  }]
+}, null, 2)}\n`);
+const nestedProjectNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(nestedProjectNotice.results.some((item) => item.taskId === nestedProjectTask.task.id), false);
+const nestedProjectStatus = await queueStatus(root, queue);
+assert.equal(nestedProjectStatus.waiting, 0);
+await access(path.join(root, nestedProjectTask.file));
+await assert.rejects(
+  access(path.join(taskRuntimeDirFor(root, queue, nestedProjectTask.task.id), 'human_input_gate.json')),
+  { code: 'ENOENT' }
+);
+
 // 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 conditional = await enqueueTask(root, { queue, title: 'OpenReel conditional policy boundary', task: 'Continue safe OpenReel backlog', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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({
@@ -194,7 +234,7 @@ assert.equal(conditionalNotice.results.some((item) => item.taskId === conditiona
 // 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 conditionalNow = await enqueueTask(root, { queue, title: 'OpenReel conditional blocker now', task: 'Wait for a real external precondition', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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({
@@ -213,7 +253,7 @@ 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 stateTask = await enqueueTask(root, { queue, title: `OpenReel ${authorizationState} authority`, task: 'Continue within recorded authority', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
   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({
@@ -239,7 +279,7 @@ await writeFile(subprojectBacklog, `${JSON.stringify({
     { 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 subprojectTask = await enqueueTask(root, { queue, title: 'OpenReel CDQI2 actionable backlog', task: 'Continue CDQI2-11', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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({
@@ -254,7 +294,7 @@ assert.equal(subprojectNotice.results.some((item) => item.taskId === subprojectT
 // 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 missing = await enqueueTask(root, { queue, title: 'OpenReel missing current authority', task: 'Perform currently gated action', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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({
@@ -279,7 +319,7 @@ await writeFile(projectFile, `${JSON.stringify({
     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 coveredBlocker = await enqueueTask(root, { queue, title: 'OpenReel covered production blocker', task: 'Deploy accepted candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 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');
@@ -294,7 +334,7 @@ assert.equal(coveredNotice.results.some((item) => item.taskId === coveredBlocker
 
 // 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' });
+const publication = await enqueueTask(root, { queue, title: 'OpenReel publication blocker', task: 'Publish candidate', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 await writeTaskContract(root, queue, publication.task);
 const publicationDir = path.join(taskRuntimeDirFor(root, queue, publication.task.id), 'checkpoints');
 await mkdir(publicationDir, { recursive: true });
@@ -332,7 +372,7 @@ await rename(legacyInbox, `${legacyInbox}.moved`);
 await reconcileProjectGates(root, { queue });
 assert.equal((await queueStatus(root, queue)).done >= 1, true, 'accepted project task must close in done, not canceled');
 assert.equal(JSON.parse(await readFile(legacyGateFile, 'utf8')).status, 'superseded');
-const acceptedOptional = await enqueueTask(root, { queue, title: 'OpenReel optional operations transfer', task: 'Project openreel optional post-completion transfer', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const acceptedOptional = await enqueueTask(root, { queue, title: 'OpenReel optional operations transfer', task: 'Project openreel optional post-completion transfer', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner', sourceAccount: 'main' });
 const acceptedOptionalDir = path.join(taskRuntimeDirFor(root, queue, acceptedOptional.task.id), 'checkpoints');
 await mkdir(acceptedOptionalDir, { recursive: true });
 await writeFile(path.join(acceptedOptionalDir, 'cp1.json'), `${JSON.stringify({
@@ -344,4 +384,19 @@ 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', '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'] }));
+// Missing source/actor/generation binding must fail closed: no waiting move,
+// no gate command text, and no notification invocation.
+const unbound = await enqueueTask(root, { queue, title: 'Unbound human request', task: 'Project openreel B-01', projectId: 'openreel', sourceChannel: 'test', sourceTarget: 'owner' });
+const unboundDir = path.join(taskRuntimeDirFor(root, queue, unbound.task.id), 'checkpoints');
+await mkdir(unboundDir, { recursive: true });
+await writeFile(path.join(unboundDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: unbound.task.id, checkpoint_id: 'cp1', milestone_id: 'B-01',
+  status: 'needs_human_input', blockers: [{ action: 'approve', required_authority: 'owner', authorization_state: 'missing', needed_when: 'now' }]
+}, null, 2)}\n`);
+const unboundNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+const unboundResult = unboundNotice.results.find((item) => item.taskId === unbound.task.id);
+assert.equal(unboundResult.outcome, 'fail_closed');
+assert.equal(unboundResult.message, undefined);
+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', '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', 'unbound gate fails closed without actionable text'] }));

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

@@ -423,8 +423,8 @@ await writeJson(path.join(root, 'configs', 'loops', 'queues', `${queue}.json`),
 
 const gateDryRun = await notifyHumanInputRequests(root, { queue, dryRun: true });
 assert.equal(gateDryRun.results[0].outcome, 'dry_run');
-assert.match(gateDryRun.results[0].message, /Provide the SMS code/);
-assert.match(gateDryRun.results[0].message, /正在等待你的输入/);
+assert.equal(gateDryRun.results[0].preview, 'authoritative_gate_would_be_materialized');
+assert.equal(gateDryRun.results[0].message, undefined, 'dry-run must not emit an actionable reply command before gate materialization');
 const gateSent = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(gateSent.sent, 1);
 const gateId = gateSent.results[0].gateId;
@@ -544,7 +544,7 @@ await writeJson(path.join(regressionRoot, 'configs', 'loops', 'projects', 'demo.
 for (const [id, enqueuedAt] of [['history-done', '2026-01-01T00:00:00Z'], ['latest-done', '2026-01-02T00:00:00Z']]) {
   await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'done'), `${id}.json`), {
     id, title: `demo ${id}`, body: 'demo R-1', projectId: 'demo', status: 'completed', enqueuedAt,
-    source: { channel: 'test', target: 'owner' }
+    source: { channel: 'test', target: 'owner', account: 'main' }
   });
   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,
@@ -577,7 +577,7 @@ await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'faile
   projectId: 'demo',
   status: 'blocked',
   enqueuedAt: '2026-01-03T00:00:00Z',
-  source: { channel: 'feishu', target: 'owner' }
+  source: { channel: 'feishu', target: 'owner', account: 'main' }
 });
 await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'checkpoints', 'cp2.json'), {
   version: 1,

package/skills/taskforce-loop-engineering/references/npm-package.md

@@ -1,7 +1,7 @@
 # npm Package
 
 Package name: `taskforce-loop-engineering`
-Version: `0.9.0`
+Version: `0.15.16`
 
 Install from npm: