taskforce-loop-engineering 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 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

@@ -2912,10 +2912,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 +3040,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 +7838,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 +7859,7 @@ function dispatchFailureClassification(result, retry = {}) {
     return {
       category: 'timeout',
       requiresHumanAction: false,
+      recoverableRuntime: true,
       matchedPattern: null
     };
   }
@@ -7849,12 +7870,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 +8297,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 +8346,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 +8403,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 +8440,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 +8449,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 +8465,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 +8474,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.2",
   "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,35 @@ const baseContract = { task_id: 't1', risk_level: 'L1', requires_human_gate: fal
   assert.equal(selectEffectiveAcceptanceReviews(devPlan, reviews)[0].checkpointId, 'cp10');
 }
 
+{
+  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);