taskforce-loop-engineering 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 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/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 = judgement?.outcome === 'blocked' && 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) });
@@ -2845,6 +2856,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 +2883,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);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "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 {
@@ -371,6 +371,8 @@ 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;
+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' });
 assert.equal(resolved.outcome, 'resolved_and_requeued');
 const requeuedTask = await readJson(path.join(queueSubdirFor(root, queue, 'inbox'), path.basename(failedFile)));