taskforce-loop-engineering 0.8.1 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # 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.
+- Bound long-lived project sessions by rotating the worker session after a configurable number of successful project ticks (`retry.sessionMaxTicks`, default 10).
+
 ## 0.8.1 - 2026-08-07
 
 - Make the standard OpenClaw installer and upgrade path install and enable a managed per-queue systemd user scheduler, configure required scheduler heartbeats by default, and use an absolute packaged CLI path so systemd does not depend on an interactive shell `PATH`.

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);
 }
 
@@ -2912,10 +2929,19 @@ export function buildFinalJudgement(contract, acceptancePlan, devPlan, checkpoin
   const reviseCount = effectiveReviews.filter((item) => item.status === 'revise').length;
   const blockedCount = effectiveReviews.filter((item) => item.status === 'blocked').length;
   const dispatchStatus = context.dispatchStatus ?? 'unknown';
+  const dispatchFailure = context.dispatchFailureClassification ?? null;
   const projectCompletionAccepted = effectiveReviews.some((review) => review.projectCompletion?.status === 'accepted');
   let outcome = 'needs_revision';
 
-  if (dispatchStatus === 'blocked_preflight') {
+  if (dispatchStatus === 'runtime_interrupted') {
+    outcome = 'runtime_interrupted';
+    reasons.push(`A recoverable runtime interruption stopped the worker${dispatchFailure?.category ? ` (${dispatchFailure.category})` : ''}.`);
+    nextActions.push('Rotate the worker session and resume from the latest durable checkpoint without creating a development revision.');
+  } else if (dispatchStatus === 'runtime_blocked') {
+    outcome = 'runtime_blocked';
+    reasons.push('Recoverable runtime interruption retries were exhausted.');
+    nextActions.push('Inspect the runtime transport/session failure before resuming the project.');
+  } else if (dispatchStatus === 'blocked_preflight') {
     outcome = 'blocked';
     reasons.push('Preflight blocked the task before development dispatch.');
     nextActions.push('Resolve preflight findings and rerun the queue task.');
@@ -3031,6 +3057,8 @@ function queueStatusFromFinalJudgement(currentStatus, finalJudgement) {
   const outcome = finalJudgement.judgement.outcome;
   if (outcome === 'ready_to_apply') return currentStatus;
   if (outcome === 'project_in_progress') return outcome;
+  if (outcome === 'runtime_interrupted') return outcome;
+  if (outcome === 'runtime_blocked') return outcome;
   if (outcome === 'ready_for_human_review') return outcome;
   return outcome;
 }
@@ -7827,7 +7855,16 @@ const DEFAULT_REQUIRES_HUMAN_ACTION_PATTERNS = [
   '用户限制'
 ];
 
-function dispatchFailureClassification(result, retry = {}) {
+const DEFAULT_RECOVERABLE_RUNTIME_PATTERNS = [
+  { category: 'compaction_timeout', pattern: 'compaction timed out' },
+  { category: 'compaction_timeout', pattern: 'transcript compaction failed' },
+  { category: 'transport_error', pattern: 'connection reset' },
+  { category: 'transport_error', pattern: 'socket hang up' },
+  { category: 'transport_error', pattern: 'network error' },
+  { category: 'rate_limit', pattern: 'rate limit' }
+];
+
+export function dispatchFailureClassification(result, retry = {}) {
   if (!result || result.exitCode === 0) {
     return {
       category: 'ok',
@@ -7839,6 +7876,7 @@ function dispatchFailureClassification(result, retry = {}) {
     return {
       category: 'timeout',
       requiresHumanAction: false,
+      recoverableRuntime: true,
       matchedPattern: null
     };
   }
@@ -7849,12 +7887,24 @@ function dispatchFailureClassification(result, retry = {}) {
     return {
       category: 'requires_human_action',
       requiresHumanAction: true,
+      recoverableRuntime: false,
       matchedPattern: matched
     };
   }
+  const runtimePatterns = retry.recoverableRuntimePatterns ?? DEFAULT_RECOVERABLE_RUNTIME_PATTERNS;
+  const runtimeMatch = runtimePatterns.find((entry) => output.includes(String(entry.pattern ?? entry).toLowerCase()));
+  if (runtimeMatch) {
+    return {
+      category: runtimeMatch.category ?? 'runtime_interruption',
+      requiresHumanAction: false,
+      recoverableRuntime: true,
+      matchedPattern: runtimeMatch.pattern ?? runtimeMatch
+    };
+  }
   return {
     category: 'retryable_failure',
     requiresHumanAction: false,
+    recoverableRuntime: false,
     matchedPattern: null
   };
 }
@@ -8264,6 +8314,7 @@ export async function runQueueOnce(root, options) {
         const runContext = {
           env: {
             ...taskPlanningEnv(root, taskContract, acceptancePlan, devPlan),
+            LOOP_SESSION_GENERATION: String(task.runtimeSessionGeneration ?? 0),
             LOOP_HUMAN_INPUT_CONTEXT_FILE: humanInputContextFile,
             LOOP_HUMAN_INPUT_CONTEXT_FILE_REL: path.relative(root, humanInputContextFile)
           },
@@ -8312,9 +8363,17 @@ export async function runQueueOnce(root, options) {
             const verifyOk = verification.every((entry) => entry.result.exitCode === 0);
             finalStatus = verifyOk ? 'completed' : 'verify_failed';
           } else {
-            finalStatus = dispatch?.exitCode === 0
-              ? 'completed'
-              : dispatchClassification?.requiresHumanAction ? 'needs_human_input' : 'failed';
+            if (dispatch?.exitCode === 0) {
+              finalStatus = 'completed';
+            } else if (dispatchClassification?.requiresHumanAction) {
+              finalStatus = 'needs_human_input';
+            } else if (dispatchClassification?.recoverableRuntime) {
+              const recoveryCount = Number(task.runtimeRecoveryCount ?? 0);
+              const recoveryMax = Number(options.retry?.runtimeRecoveryMaxAttempts ?? 2);
+              finalStatus = recoveryCount < recoveryMax ? 'runtime_interrupted' : 'runtime_blocked';
+            } else {
+              finalStatus = 'failed';
+            }
           }
         }
         worktreeInspection = await inspectWorktree(worktree);
@@ -8361,6 +8420,7 @@ export async function runQueueOnce(root, options) {
       });
       if (!finalJudgement) finalJudgement = await writeFinalJudgement(root, queue, task, taskContract, acceptancePlan, devPlan, checkpoints, acceptanceReviews, {
         dispatchStatus: finalStatus,
+        dispatchFailureClassification: dispatchAttempts[dispatchAttempts.length - 1]?.failureClassification ?? null,
         verificationFailed: verification.some((entry) => entry.result.exitCode !== 0)
       });
       progress.emit('final-judge', finalJudgement.judgement.outcome, `Final judgement: ${finalJudgement.judgement.outcome}`, {
@@ -8397,6 +8457,7 @@ export async function runQueueOnce(root, options) {
     if (!finalJudgement) {
       finalJudgement = await writeFinalJudgement(root, queue, task, taskContract, acceptancePlan, devPlan, checkpoints, acceptanceReviews, {
         dispatchStatus: finalStatus,
+        dispatchFailureClassification: dispatchAttempts[dispatchAttempts.length - 1]?.failureClassification ?? null,
         verificationFailed: verification.some((entry) => entry.result.exitCode !== 0)
       });
       finalStatus = queueStatusFromFinalJudgement(finalStatus, finalJudgement);
@@ -8405,13 +8466,13 @@ export async function runQueueOnce(root, options) {
       revisionRequest = await writeRevisionRequest(root, queue, task, taskContract, acceptancePlan, devPlan, finalJudgement, acceptanceReviews);
     }
 
-    destination = finalStatus === 'project_in_progress'
+    destination = ['project_in_progress', 'runtime_interrupted'].includes(finalStatus)
       ? queueSubdirFor(root, queue, 'inbox')
       : finalStatus === 'completed'
       ? queueSubdirFor(root, queue, 'done')
       : finalStatus === 'superseded' ? queueSubdirFor(root, queue, 'canceled')
       : queueSubdirFor(root, queue, 'failed');
-    exitCode = ['completed', 'superseded', 'project_in_progress'].includes(finalStatus) ? 0 : 1;
+    exitCode = ['completed', 'superseded', 'project_in_progress', 'runtime_interrupted'].includes(finalStatus) ? 0 : 1;
 
     const finishedAt = new Date().toISOString();
     progress.emit('queue', finalStatus === 'completed' ? 'completed' : finalStatus === 'project_in_progress' ? 'continued' : 'needs_attention', `Task finished with status ${finalStatus}`, {
@@ -8421,7 +8482,7 @@ export async function runQueueOnce(root, options) {
     });
     const completedTask = {
       ...task,
-      status: finalStatus === 'project_in_progress' ? 'queued' : finalStatus,
+      status: ['project_in_progress', 'runtime_interrupted'].includes(finalStatus) ? 'queued' : finalStatus,
       startedAt,
       finishedAt,
       attempts: (task.attempts ?? 0) + Math.max(dispatchAttempts.length, dispatch ? 1 : 0),
@@ -8430,6 +8491,19 @@ export async function runQueueOnce(root, options) {
     if (finalStatus === 'project_in_progress') {
       completedTask.projectContinuedAt = finishedAt;
       completedTask.projectContinuationCount = (task.projectContinuationCount ?? 0) + 1;
+      completedTask.runtimeRecoveryCount = 0;
+      const sessionMaxTicks = Math.max(1, Number(options.retry?.sessionMaxTicks ?? 10));
+      if (completedTask.projectContinuationCount % sessionMaxTicks === 0) {
+        completedTask.runtimeSessionGeneration = Number(task.runtimeSessionGeneration ?? 0) + 1;
+        completedTask.sessionRotatedAt = finishedAt;
+        completedTask.sessionRotationReason = 'bounded_tick_limit';
+      }
+    }
+    if (finalStatus === 'runtime_interrupted') {
+      completedTask.runtimeRecoveryCount = Number(task.runtimeRecoveryCount ?? 0) + 1;
+      completedTask.runtimeSessionGeneration = Number(task.runtimeSessionGeneration ?? 0) + 1;
+      completedTask.runtimeInterruptedAt = finishedAt;
+      completedTask.runtimeInterruption = dispatchAttempts[dispatchAttempts.length - 1]?.failureClassification ?? null;
     }
     const completedFile = path.join(destination, path.basename(activeFile));
     await writeJson(completedFile, completedTask);

package/package.json

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

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { buildFinalJudgement, selectEffectiveAcceptanceReviews } from '../lib/core.mjs';
+import { buildFinalJudgement, dispatchFailureClassification, selectEffectiveAcceptanceReviews } from '../lib/core.mjs';
 
 const basePlan = { rubric: [], automation: [] };
 const baseContract = { task_id: 't1', risk_level: 'L1', requires_human_gate: false, task_scope: 'scoped_task' };
@@ -16,6 +16,49 @@ 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,
+    timedOut: false,
+    stderr: 'CLI transcript compaction failed: Compaction timed out',
+    stdout: ''
+  });
+  assert.equal(classification.category, 'compaction_timeout');
+  assert.equal(classification.recoverableRuntime, true);
+}
+
+{
+  const devPlan = { checkpoints: [{ id: 'cp1' }] };
+  const reviews = { reviews: [{ checkpointId: 'cp38', sequence: 38, status: 'accepted', projectCompletion: { status: 'in_progress' } }] };
+  const judgement = buildFinalJudgement(
+    { ...baseContract, task_scope: 'project' },
+    basePlan,
+    devPlan,
+    { count: 38 },
+    reviews,
+    {
+      dispatchStatus: 'runtime_interrupted',
+      dispatchFailureClassification: { category: 'compaction_timeout', recoverableRuntime: true }
+    }
+  );
+  assert.equal(judgement.outcome, 'runtime_interrupted');
+  assert.equal(judgement.reasons.some((reason) => reason.includes('development')), false);
+}
+
 {
   const devPlan = { checkpoints: [{ id: 'cp1' }] };
   const reviews = {

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

@@ -55,7 +55,8 @@ const queue = JSON.parse(await readFile(path.join(root, 'configs/loops/queues/te
 if (queue.dispatcher !== 'node scripts/loops/openclaw-loop-dispatch.mjs') throw new Error('dispatcher was not installed');
 if (queue.scheduler?.required !== true || queue.scheduler?.heartbeatMaxAgeMs !== 300000) throw new Error('required scheduler heartbeat was not installed');
 const dispatcher = await readFile(path.join(root, 'scripts/loops/openclaw-loop-dispatch.mjs'), 'utf8');
-if (!dispatcher.includes('already loop-managed') || !dispatcher.includes("'--agent', \"builder\"") || !dispatcher.includes('LOOP_LATEST_AMENDMENT_FILE')) throw new Error('worker, recursion guard, or amendment polling missing');
+if (!dispatcher.includes('already loop-managed') || !dispatcher.includes("'--agent', \"builder\"") || !dispatcher.includes('LOOP_LATEST_AMENDMENT_FILE') || !dispatcher.includes('LOOP_SESSION_GENERATION') || !dispatcher.includes('-g${sessionGeneration}')) throw new Error('worker, recursion guard, amendment polling, or session generation missing');
+if (queue.retry?.runtimeRecoveryMaxAttempts !== 2 || queue.retry?.sessionMaxTicks !== 10) throw new Error('bounded runtime recovery policy was not installed');
 const instructions = await readFile(path.join(root, 'AGENTS.md'), 'utf8');
 if (!instructions.includes('走 loop') || !instructions.includes('immediately execute')) throw new Error('conversation instructions missing');
 const wrapper = await readFile(path.join(root, 'scripts/loops/openclaw-loop.mjs'), 'utf8');

package/scripts/openclaw-install.mjs

@@ -68,6 +68,7 @@ function dispatcherSource({ workerAgent, openclawBin }) {
 import { readFile } from 'node:fs/promises';
 import { spawn } from 'node:child_process';
 const task = JSON.parse(await readFile(process.env.LOOP_TASK_FILE, 'utf8'));
+const sessionGeneration = Number.parseInt(process.env.LOOP_SESSION_GENERATION || '0', 10) || 0;
 const prompt = [
   'You are receiving an already loop-managed task.',
   'Do not route or enqueue this task again, even if its quoted request contains a loop trigger.',
@@ -84,7 +85,7 @@ const prompt = [
 ].join('\\n');
 const child = spawn(${JSON.stringify(openclawBin)}, [
   'agent', '--agent', ${JSON.stringify(workerAgent)},
-  '--session-key', \`agent:${workerAgent}:loop-task-\${task.id}\`,
+  '--session-key', \`agent:${workerAgent}:loop-task-\${task.id}-g\${sessionGeneration}\`,
   '--message', prompt, '--json', '--timeout', '1800'
 ], { cwd: process.cwd(), env: process.env, stdio: 'inherit' });
 child.on('close', (code, signal) => { process.exitCode = code ?? (signal ? 128 : 1); });
@@ -228,7 +229,7 @@ async function main() {
       preflightConfig: 'configs/loops/workspace-health.json',
       timeoutMs: 1800000, leaseMs: 1860000, staleActiveMs: 3600000,
       scheduler: { required: true, heartbeatMaxAgeMs: 300000, initialInterval: '1m', minInterval: '1m', maxInterval: '4h', speedupFactor: 0.5, backoffFactor: 2, idleBackoffFactor: 2, humanGateBackoffFactor: 3, longRunHeadroomFactor: 1.25, jitter: '10s' },
-      retry: { maxAttempts: 1, retryDelayMs: 0, retryExitCodes: [1], requiresHumanActionPatterns: ['requires human', '需要人工', 'Permission denied', 'Operation not permitted'] },
+      retry: { maxAttempts: 1, runtimeRecoveryMaxAttempts: 2, sessionMaxTicks: 10, retryDelayMs: 0, retryExitCodes: [1], requiresHumanActionPatterns: ['requires human', '需要人工', 'Permission denied', 'Operation not permitted'] },
       revisionPolicy: { enabled: true, maxRevisionRounds: 3, sameFailureThreshold: 2, requireStrategyChange: true }
     }, null, 2)}\n`;
     const dispatcherContent = dispatcherSource(args);

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)));