taskforce-loop-engineering 0.8.2 → 0.8.4

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.8.4 - 2026-08-07
+
+- Reclaim queue locks immediately when their recorded owner PID no longer
+  exists, even if the lease has not expired. Scheduler status no longer reports
+  those dead-owner locks as live, and an orphaned `active/` task forces recovery
+  on the next timer wake-up instead of waiting for scheduler backoff or lease
+  expiry.
+
+- Distinguish one-time secret human inputs from durable non-sensitive decisions
+  and attestations, so review approvals remain available as structured evidence
+  while OTPs, passwords, tokens, and credential values are still destroyed after
+  consumption.
+- Restrict human-gate reconciliation to the final judgement's effective
+  checkpoint set for every outcome, preventing a project-in-progress tick from
+  resurrecting historical waiting gates after a newer checkpoint clears them.
+- Allow an explicitly superseded human gate to requeue a task from `waiting/`
+  through the normal queue CLI instead of requiring a manual file move.
+
+## 0.8.3 - 2026-08-07
+
+- Select the latest single-milestone checkpoint by durable checkpoint identity/sequence instead of regenerated acceptance-review timestamps, preventing a lexically late legacy `cp9` review from overriding a blocked `cp46+` checkpoint.
+- Limit blocked human-input notification to the final judgement's effective checkpoint set, move blocked tasks from `failed/` into `waiting/`, and make the local Ironman scheduler run human-gate and terminal notification reconciliation after each notified tick.
+
 ## 0.8.2 - 2026-08-07
 
 - Classify transcript-compaction timeouts and selected transport failures as recoverable runtime interruptions instead of development revisions. Preserve accepted checkpoints, rotate the worker session, and return the same project task to the queue with bounded recovery attempts.

package/README.md

@@ -370,6 +370,11 @@ loop-engineering queue-human-input-resolve \
 The human-input notifier scans active and terminal tasks, sends the concrete
 checkpoint blocker, and records a `waiting_for_human` gate. Resolution is
 idempotent; a terminal blocked task is requeued with the response attached.
+OTP, password, token, credential, and verification-code gates are inferred as
+one-time secrets and destroyed after consumption. Review decisions, approvals,
+assignments, and attestations remain available in the gate event as durable
+non-sensitive evidence. Use `--secret-input` or `--non-secret-input` to override
+the inference when gate wording is ambiguous.
 
 Goal-directed controllers can use the exported `normalizeGoalDecision`,
 `goalLoopTransition`, and `goalStrategyFingerprint` helpers. They distinguish

package/bin/loop-engineering.mjs

@@ -154,6 +154,8 @@ function parseArgs(argv) {
     else if (a === '--notify-command') args.notifyCommand = argv[++i];
     else if (a === '--gate-id') args.gateId = argv[++i];
     else if (a === '--input') args.input = argv[++i];
+    else if (a === '--secret-input') args.secretInput = true;
+    else if (a === '--non-secret-input') args.nonSecretInput = true;
     else if (a === '--source-channel') args.sourceChannel = argv[++i];
     else if (a === '--source-target') args.sourceTarget = argv[++i];
     else if (a === '--source-account') args.sourceAccount = argv[++i];
@@ -2077,7 +2079,7 @@ async function queueRequeueCommand(args) {
   if (!args.taskId) throw new Error('queue-requeue requires --task-id.');
   const config = await loadQueueConfig(args.root, args.config);
   const options = mergeQueueOptions(config, args);
-  const result = await queueRequeue(args.root, options.queue, args.taskId);
+  const result = await queueRequeue(args.root, options.queue, args.taskId, { from: args.from });
   if (args.json) console.log(JSON.stringify(result, null, 2));
   else console.log(`requeued ${result.taskId}: ${result.file}`);
   return 0;

package/lib/core.mjs

@@ -1822,7 +1822,18 @@ export async function notifyHumanInputRequests(root, options = {}) {
   for (const [taskId, entry] of tasks) {
     if (!entry.task.source) continue;
     const checkpointsDir = path.join(taskRuntimeDirFor(root, queue, taskId), 'checkpoints');
-    for (const file of await listJson(checkpointsDir)) {
+    let checkpointFiles = await listJson(checkpointsDir);
+    const judgementFile = path.join(taskRuntimeDirFor(root, queue, taskId), 'final_judgement.json');
+    if (await exists(judgementFile)) {
+      const judgement = await readJson(judgementFile);
+      const effectiveIds = Array.isArray(judgement?.coverage?.effective_review_ids)
+        ? new Set(judgement.coverage.effective_review_ids)
+        : null;
+      if (effectiveIds?.size > 0) {
+        checkpointFiles = checkpointFiles.filter((file) => effectiveIds.has(path.basename(file, '.json')));
+      }
+    }
+    for (const file of checkpointFiles) {
       const checkpoint = await readJson(path.join(checkpointsDir, file));
       if (!['needs_human_input', 'blocked'].includes(checkpoint?.status)) continue;
       const checkpointId = checkpoint.checkpoint_id ?? path.basename(file, '.json');
@@ -1830,17 +1841,17 @@ export async function notifyHumanInputRequests(root, options = {}) {
       const ledgerFile = path.join(gatesDir, `${safeTaskId(taskId)}.${normalizeLoopId(checkpointId)}.json`);
       if (await exists(ledgerFile)) {
         const gate = await readJson(ledgerFile);
-        if (gate.status === 'waiting_for_human' && entry.subdir === 'inbox') {
-          const inboxFile = path.join(queueSubdirFor(root, queue, 'inbox'), `${safeTaskId(taskId)}.json`);
-          if (await exists(inboxFile)) {
-            const waitingFile = path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(inboxFile));
+        if (gate.status === 'waiting_for_human' && ['inbox', 'failed'].includes(entry.subdir)) {
+          const sourceFile = path.join(queueSubdirFor(root, queue, entry.subdir), `${safeTaskId(taskId)}.json`);
+          if (await exists(sourceFile)) {
+            const waitingFile = path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(sourceFile));
             await writeJson(waitingFile, {
               ...entry.task,
               status: 'waiting_for_human',
               waitingGateId: gateId,
               waitingSince: gate.requested_at ?? new Date().toISOString()
             });
-            await rm(inboxFile, { force: true });
+            await rm(sourceFile, { force: true });
           }
         }
         results.push({ taskId, checkpointId, gateId, outcome: gate.status === 'resolved' ? 'resolved' : 'already_notified', ledger: path.relative(root, ledgerFile) });
@@ -1880,17 +1891,17 @@ export async function notifyHumanInputRequests(root, options = {}) {
         requested_at: new Date().toISOString(),
         notification: compactCommandResult(result)
       });
-      if (entry.subdir === 'inbox') {
-        const inboxFile = path.join(queueSubdirFor(root, queue, 'inbox'), `${safeTaskId(taskId)}.json`);
-        if (await exists(inboxFile)) {
-          const waitingFile = path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(inboxFile));
+      if (['inbox', 'failed'].includes(entry.subdir)) {
+        const sourceFile = path.join(queueSubdirFor(root, queue, entry.subdir), `${safeTaskId(taskId)}.json`);
+        if (await exists(sourceFile)) {
+          const waitingFile = path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(sourceFile));
           await writeJson(waitingFile, {
             ...entry.task,
             status: 'waiting_for_human',
             waitingGateId: gateId,
             waitingSince: new Date().toISOString()
           });
-          await rm(inboxFile, { force: true });
+          await rm(sourceFile, { force: true });
         }
       }
       results.push({ taskId, checkpointId, gateId, outcome: 'sent', ledger: path.relative(root, ledgerFile) });
@@ -1921,28 +1932,40 @@ export async function resolveHumanInput(root, options = {}) {
   if (['resolved', 'consumed', 'satisfied'].includes(gate.status)) return { gate, outcome: 'already_resolved', ledger: path.relative(root, ledgerFile) };
   const receivedAt = new Date().toISOString();
   const response = options.input.trim();
+  const requestText = `${gate.request ?? ''}\n${JSON.stringify(gate.needed ?? '')}`.toLowerCase();
+  const inferredSecret = /(?:otp|one[- ]time|verification code|sms code|验证码|校验码|口令|password|api[ _-]?key|access[ _-]?token|secret|credential value|密钥|令牌)/i.test(requestText);
+  const inputKind = options.secretInput === true
+    ? 'secret'
+    : options.nonSecretInput === true
+      ? 'attestation'
+      : inferredSecret ? 'secret' : 'attestation';
+  const secretReceived = inputKind === 'secret';
   const secretDir = path.join(queueDirFor(root, queue), 'human-input', 'secrets');
   const eventsDir = path.join(queueDirFor(root, queue), 'human-input', 'events');
-  await mkdir(secretDir, { recursive: true, mode: 0o700 });
   await mkdir(eventsDir, { recursive: true });
-  const secretFile = path.join(secretDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.secret`);
-  const handle = await open(secretFile, 'wx', 0o600);
-  try {
-    await handle.writeFile(response);
-  } finally {
-    await handle.close();
+  let secretFile = null;
+  if (secretReceived) {
+    await mkdir(secretDir, { recursive: true, mode: 0o700 });
+    secretFile = path.join(secretDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.secret`);
+    const handle = await open(secretFile, 'wx', 0o600);
+    try {
+      await handle.writeFile(response);
+    } finally {
+      await handle.close();
+    }
   }
   const responseSha256 = createHash('sha256').update(response).digest('hex');
   const resolved = {
     ...gate,
     status: 'resolved',
-    secret_received: true,
+    input_kind: inputKind,
+    secret_received: secretReceived,
     response_sha256: responseSha256,
-    response_ref: path.relative(root, secretFile),
+    ...(secretReceived ? { response_ref: path.relative(root, secretFile) } : { response }),
     response_message_id: options.sourceMessageId ?? null,
     resolved_at: receivedAt
   };
-  delete resolved.response;
+  if (secretReceived) delete resolved.response;
   await writeJson(ledgerFile, resolved);
   const eventFile = path.join(eventsDir, `${safeTaskId(taskId)}.${checkpointId}.${isoStamp()}.json`);
   await writeJson(eventFile, {
@@ -1952,9 +1975,10 @@ export async function resolveHumanInput(root, options = {}) {
     task_id: taskId,
     checkpoint_id: checkpointId,
     status: 'pending_consumption',
-    secret_received: true,
+    input_kind: inputKind,
+    secret_received: secretReceived,
     response_sha256: responseSha256,
-    response_ref: path.relative(root, secretFile),
+    ...(secretReceived ? { response_ref: path.relative(root, secretFile) } : { response }),
     response_message_id: options.sourceMessageId ?? null,
     created_at: receivedAt
   });
@@ -1968,7 +1992,8 @@ export async function resolveHumanInput(root, options = {}) {
       humanInput: {
         gate_id: options.gateId,
         checkpoint_id: checkpointId,
-        secret_received: true,
+        input_kind: inputKind,
+        secret_received: secretReceived,
         response_sha256: responseSha256,
         event: path.relative(root, eventFile),
         received_at: receivedAt
@@ -2019,8 +2044,10 @@ async function prepareHumanInputContext(root, queue, taskId) {
       checkpoint_id: consumed.checkpoint_id,
       status: consumed.status,
       secret_received: Boolean(consumed.secret_received),
+      input_kind: consumed.input_kind ?? (consumed.secret_received ? 'secret' : 'attestation'),
       response_sha256: consumed.response_sha256 ?? null,
       response_ref: consumed.response_ref ? path.join(root, consumed.response_ref) : null,
+      response: consumed.secret_received ? null : consumed.response ?? null,
       resolved_at: consumed.resolved_at ?? null,
       consumed_at: consumed.consumed_at ?? null
     });
@@ -2845,6 +2872,7 @@ export async function writeAcceptanceReviews(root, queue, task, taskContract, ac
       milestoneId: checkpoint.milestone_id ?? null,
       revisesCheckpointId: checkpoint.revises_checkpoint_id ?? null,
       sequence: Number(checkpoint.sequence ?? String(checkpoint.checkpoint_id ?? '').match(/(\d+)$/)?.[1] ?? 0),
+      checkpointCreatedAt: checkpoint.created_at ?? null,
       createdAt: checkpoint.created_at ?? review.created_at,
       projectCompletion: checkpoint.project_completion ?? null,
       status: review.status,
@@ -2871,11 +2899,16 @@ function compareReviewSequence(a, b) {
 }
 
 function compareReviewRecency(a, b) {
-  const createdDelta = String(a.createdAt ?? '').localeCompare(String(b.createdAt ?? ''));
-  if (createdDelta !== 0 && a.createdAt && b.createdAt) return createdDelta;
   const aCheckpoint = Number(String(a.checkpointId ?? '').match(/(\d+)$/)?.[1] ?? 0);
   const bCheckpoint = Number(String(b.checkpointId ?? '').match(/(\d+)$/)?.[1] ?? 0);
   if (aCheckpoint !== bCheckpoint) return aCheckpoint - bCheckpoint;
+  // Review artifacts are regenerated as a batch. Their generated_at values
+  // therefore describe directory traversal order, not checkpoint recency.
+  // Only trust a timestamp that came from the checkpoint itself.
+  const checkpointCreatedDelta = String(a.checkpointCreatedAt ?? '').localeCompare(String(b.checkpointCreatedAt ?? ''));
+  if (checkpointCreatedDelta !== 0 && a.checkpointCreatedAt && b.checkpointCreatedAt) return checkpointCreatedDelta;
+  const sequenceDelta = Number(a.sequence ?? 0) - Number(b.sequence ?? 0);
+  if (sequenceDelta !== 0) return sequenceDelta;
   return compareReviewSequence(a, b);
 }
 
@@ -3174,6 +3207,7 @@ export async function queueStatus(root, queue) {
   await ensureQueueDirs(root, queue);
   const activeFiles = await listJson(queueSubdirFor(root, queue, 'active'));
   const lock = await readQueueLock(root, queue);
+  const lockOwnerAlive = queueLockOwnerAlive(lock);
   return {
     queue,
     queued: (await listJson(queueSubdirFor(root, queue, 'inbox'))).length,
@@ -3183,8 +3217,10 @@ export async function queueStatus(root, queue) {
     failed: (await listJson(queueSubdirFor(root, queue, 'failed'))).length,
     canceled: (await listJson(queueSubdirFor(root, queue, 'canceled'))).length,
     runs: (await listJson(queueSubdirFor(root, queue, 'runs'))).length,
-    locked: Boolean(lock && Date.parse(lock.expiresAt) > Date.now()),
-    lockExpiresAt: lock?.expiresAt ?? null
+    locked: Boolean(lock && Date.parse(lock.expiresAt) > Date.now() && lockOwnerAlive),
+    lockExpiresAt: lock?.expiresAt ?? null,
+    lockPid: lock?.pid ?? null,
+    lockOwnerAlive
   };
 }
 
@@ -3492,7 +3528,13 @@ export async function queueSchedulerTick(root, options) {
   const previous = await readQueueSchedulerState(root, queue);
   const previousProgress = await readQueueProgressState(root, queue);
   const statusBefore = await queueStatus(root, queue);
-  const due = !previous?.nextRunAt || Date.parse(previous.nextRunAt) <= nowMs || Boolean(options.forceDue);
+  // An active task without a live lock owner is an orphan. Do not let a
+  // previously scheduled backoff postpone recovery until nextRunAt.
+  const orphanedActive = statusBefore.active > 0 && !statusBefore.locked;
+  const due = orphanedActive
+    || !previous?.nextRunAt
+    || Date.parse(previous.nextRunAt) <= nowMs
+    || Boolean(options.forceDue);
   let runResult = null;
   let executed = false;
   let status = due ? 'due' : 'not_due';
@@ -3751,11 +3793,27 @@ async function readQueueLock(root, queue) {
   }
 }
 
+function processIsAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // EPERM means the process exists but this user cannot signal it.
+    return Boolean(err && err.code === 'EPERM');
+  }
+}
+
+function queueLockOwnerAlive(lock) {
+  return Boolean(lock && processIsAlive(lock.pid));
+}
+
 async function acquireQueueLock(root, queue, leaseMs) {
   const lockFile = path.join(queueDirFor(root, queue), 'queue.lock');
   const now = Date.now();
   const existing = await readQueueLock(root, queue);
-  if (existing && Date.parse(existing.expiresAt) > now) {
+  const existingOwnerAlive = queueLockOwnerAlive(existing);
+  if (existing && Date.parse(existing.expiresAt) > now && existingOwnerAlive) {
     return { acquired: false, lock: existing };
   }
   if (existing) await rm(lockFile, { force: true });
@@ -3770,7 +3828,14 @@ async function acquireQueueLock(root, queue, leaseMs) {
   try {
     handle = await open(lockFile, 'wx');
     await handle.writeFile(`${JSON.stringify(lock, null, 2)}\n`);
-    return { acquired: true, lock };
+    return {
+      acquired: true,
+      lock,
+      reclaimedLock: existing ? {
+        lock: existing,
+        reason: existingOwnerAlive ? 'expired_lease' : 'dead_owner_pid'
+      } : null
+    };
   } catch (err) {
     if (err && err.code === 'EEXIST') {
       return { acquired: false, lock: await readQueueLock(root, queue) };
@@ -3846,7 +3911,9 @@ export async function queueCancel(root, queue, taskId, options = {}) {
 export async function queueRequeue(root, queue, taskId, options = {}) {
   const normalized = normalizeLoopId(queue);
   await ensureQueueDirs(root, normalized);
-  const found = await findTaskFile(root, normalized, taskId, options.from ? [options.from] : ['failed', 'active', 'canceled']);
+  const allowedSources = ['failed', 'active', 'waiting', 'canceled'];
+  if (options.from && !allowedSources.includes(options.from)) throw new Error(`Unsupported requeue source: ${options.from}`);
+  const found = await findTaskFile(root, normalized, taskId, options.from ? [options.from] : allowedSources);
   if (!found) throw new Error(`Task not found in requeueable state: ${taskId}`);
   const task = await readJson(found.file);
   const inboxFile = path.join(queueSubdirFor(root, normalized, 'inbox'), path.basename(found.file));
@@ -7757,7 +7824,7 @@ async function recoverStaleActive(root, queue, staleActiveMs) {
   return recovered;
 }
 
-async function recoverOrphanActive(root, queue) {
+async function recoverOrphanActive(root, queue, recoveryReason = 'queue_lock_reacquired_with_active_task') {
   const activeDir = queueSubdirFor(root, queue, 'active');
   const inboxDir = queueSubdirFor(root, queue, 'inbox');
   const files = await listJson(activeDir);
@@ -7776,7 +7843,7 @@ async function recoverOrphanActive(root, queue) {
       orphanRecoveryCount: (task.orphanRecoveryCount ?? 0) + 1,
       requeuedAt: recoveredAt,
       requeuedFrom: 'active',
-      recoveryReason: 'queue_lock_reacquired_with_active_task'
+      recoveryReason
     });
     recovered.push({
       taskId: task.id,
@@ -8176,7 +8243,10 @@ export async function runQueueOnce(root, options) {
     // queue lease. Any task left in active/ is therefore an orphan from an
     // interrupted parent runner. Requeue it immediately so existing
     // checkpoints can be reviewed and execution can resume in this tick.
-    const orphanRecovered = await recoverOrphanActive(root, queue);
+    const recoveryReason = lockResult.reclaimedLock?.reason === 'dead_owner_pid'
+      ? 'dead_queue_lock_owner_pid'
+      : 'queue_lock_reacquired_with_active_task';
+    const orphanRecovered = await recoverOrphanActive(root, queue, recoveryReason);
     if (orphanRecovered.length > 0) {
       progress.emit('queue', 'orphan_recovered', `Recovered ${orphanRecovered.length} orphan active task(s)`, {
         queue,

package/package.json

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

@@ -16,6 +16,20 @@ const baseContract = { task_id: 't1', risk_level: 'L1', requires_human_gate: fal
   assert.equal(selectEffectiveAcceptanceReviews(devPlan, reviews)[0].checkpointId, 'cp10');
 }
 
+{
+  const devPlan = { checkpoints: [{ id: 'cp1' }] };
+  const reviews = {
+    reviews: [
+      // Acceptance reviews are regenerated in filename traversal order. A
+      // legacy cp9 review can consequently have a later review timestamp than
+      // the real latest cp46 checkpoint; that timestamp must not win.
+      { checkpointId: 'cp46', sequence: 9, createdAt: '2026-08-07T18:27:18.990Z', status: 'blocked' },
+      { checkpointId: 'cp9', sequence: 1, createdAt: '2026-08-07T18:27:18.992Z', status: 'accepted' }
+    ]
+  };
+  assert.equal(selectEffectiveAcceptanceReviews(devPlan, reviews)[0].checkpointId, 'cp46');
+}
+
 {
   const classification = dispatchFailureClassification({
     exitCode: 1,

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

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import assert from 'node:assert/strict';
-import { mkdtemp, readdir, rename, rm } from 'node:fs/promises';
+import { access, mkdtemp, readdir, rename, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import {
@@ -11,6 +11,7 @@ import {
   notifyHumanInputRequests,
   notifyTerminalTasks,
   queueHumanDecision,
+  queueDirFor,
   queueStatus,
   queueSubdirFor,
   readJson,
@@ -92,6 +93,14 @@ const orphanInbox = path.join(queueSubdirFor(root, orphanQueue, 'inbox'), orphan
 const orphanActive = path.join(queueSubdirFor(root, orphanQueue, 'active'), orphanName);
 await writeJson(orphanActive, { ...(await readJson(orphanInbox)), status: 'active', startedAt: new Date().toISOString() });
 await rm(orphanInbox, { force: true });
+// A future lease owned by a dead PID must not hide the orphan until expiry.
+await writeJson(path.join(queueDirFor(root, orphanQueue), 'queue.lock'), {
+  version: 1,
+  queue: orphanQueue,
+  pid: 2_147_483_647,
+  acquiredAt: new Date().toISOString(),
+  expiresAt: new Date(Date.now() + 60_000).toISOString()
+});
 await writeJson(path.join(taskRuntimeDirFor(root, orphanQueue, orphanRouted.task.id), 'checkpoints', 'cp-before-crash.json'), {
   version: 1,
   task_id: orphanRouted.task.id,
@@ -118,6 +127,7 @@ assert.ok(orphanRun.progress.some((event) => event.status === 'orphan_recovered'
 const orphanTerminal = await readJson(path.join(root, orphanRun.taskPath));
 assert.equal(orphanTerminal.orphanRecoveryCount, 1);
 assert.equal(orphanTerminal.requeuedFrom, 'active');
+assert.equal(orphanTerminal.recoveryReason, 'dead_queue_lock_owner_pid');
 assert.equal((await readJson(path.join(taskRuntimeDirFor(root, orphanQueue, orphanRouted.task.id), 'checkpoints', 'cp-before-crash.json'))).checkpoint_id, 'cp-before-crash');
 
 const reviewQueue = 'human-review-smoke';
@@ -371,7 +381,9 @@ assert.match(gateDryRun.results[0].message, /Provide the SMS code/);
 const gateSent = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
 assert.equal(gateSent.sent, 1);
 const gateId = gateSent.results[0].gateId;
-const resolved = await resolveHumanInput(root, { queue, gateId, input: '123456', sourceMessageId: 'reply-1' });
+assert.equal((await readJson(path.join(queueSubdirFor(root, queue, 'waiting'), path.basename(failedFile)))).status, 'waiting_for_human');
+await assert.rejects(access(failedFile));
+const resolved = await resolveHumanInput(root, { queue, gateId, input: '123456', sourceMessageId: 'reply-1', secretInput: true });
 assert.equal(resolved.outcome, 'resolved_and_requeued');
 const requeuedTask = await readJson(path.join(queueSubdirFor(root, queue, 'inbox'), path.basename(failedFile)));
 assert.equal(requeuedTask.humanInput.secret_received, true);
@@ -380,6 +392,43 @@ const resolvedGate = await readJson(path.join(root, resolved.ledger ?? gateSent.
 assert.equal(JSON.stringify(resolvedGate).includes('123456'), false);
 assert.equal(resolvedGate.response_sha256.length, 64);
 
+// Non-sensitive decisions and attestations remain available to the next worker
+// tick instead of being destroyed like OTPs and credentials.
+const attestationCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-attestation.json');
+await writeJson(attestationCheckpoint, {
+  version: 1, task_id: routed.task.id, checkpoint_id: 'cp-attestation', status: 'needs_human_input',
+  blockers: [{ id: 'review-decision', reason: 'Provide the independent review decision.' }],
+  verification: [], risks: [], next_action: 'wait'
+});
+await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+const attestationGateId = `${routed.task.id}:cp-attestation`;
+const attestationResolved = await resolveHumanInput(root, {
+  queue,
+  gateId: attestationGateId,
+  input: 'Reviewer accepts the candidate for the next gated stage.'
+});
+assert.equal(attestationResolved.gate.input_kind, 'attestation');
+assert.equal(attestationResolved.gate.secret_received, false);
+assert.equal(attestationResolved.gate.response, 'Reviewer accepts the candidate for the next gated stage.');
+assert.equal(attestationResolved.gate.response_ref, undefined);
+
+// A project-in-progress judgement with a newer effective checkpoint must not
+// resurrect historical waiting gates from older checkpoints.
+const attestationDoneCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-attestation-done.json');
+await writeJson(attestationDoneCheckpoint, {
+  version: 1, task_id: routed.task.id, checkpoint_id: 'cp-attestation-done',
+  revises_checkpoint_id: 'cp-attestation', sequence: 2, status: 'ready_for_acceptance',
+  blockers: [], verification: [{ observation: 'attestation', result: 'accepted' }], risks: [], next_action: 'continue'
+});
+const finalJudgementFile = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'final_judgement.json');
+await writeJson(finalJudgementFile, {
+  version: 1, task_id: routed.task.id, outcome: 'project_in_progress',
+  coverage: { effective_review_ids: ['cp-attestation-done'] }
+});
+const noHistoricalGateReplay = await notifyHumanInputRequests(root, { queue, dryRun: true });
+assert.equal(noHistoricalGateReplay.inspected, 0);
+await rm(finalJudgementFile, { force: true });
+
 // Queued tasks receive a non-sensitive event reference without being moved.
 const queuedCheckpoint = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-queued.json');
 await writeJson(queuedCheckpoint, {

package/skills/taskforce-loop-engineering/SKILL.md

@@ -216,7 +216,7 @@ loop-engineering queue-revision-next --root <workspace> --queue <queue> --task-i
 loop-engineering queue-lineage --root <workspace> --queue <queue> --task-id <id>
 loop-engineering queue-lineage-bundle --root <workspace> --queue <queue> --task-id <id>
 loop-engineering queue-human-decision --root <workspace> --queue <queue> --task-id <id> --decision approve|request_changes|reject
-loop-engineering queue-human-input-resolve --root <workspace> --queue <queue> --gate-id <task:checkpoint> --input "<response>"
+loop-engineering queue-human-input-resolve --root <workspace> --queue <queue> --gate-id <task:checkpoint> --input "<response>" [--secret-input|--non-secret-input]
 loop-engineering queue-terminal-notify --root <workspace> --queue <queue> (--notify-command "<command>" | --dry-run)
 loop-engineering queue-human-input-notify --root <workspace> --queue <queue> (--notify-command "<command>" | --dry-run)
 ```