taskforce-loop-engineering 0.15.4 → 0.15.6

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.15.6 - 2026-08-24
+
+- Allow project configurations to use an external authoritative `backlogSource` without duplicating an embedded backlog registry.
+- Keep project status fail-closed when neither an embedded backlog nor an external backlog source is configured.
+- Suppress false registry-drift findings when no embedded projection is intentionally present, while retaining drift detection when both representations exist.
+- Add regression coverage for external-only authoritative project backlogs.
+
+## 0.15.5 - 2026-08-24
+
+- Treat embedded-runtime `incomplete_turn` / abandoned-liveness trailers as recoverable interruptions even when the dispatcher wrapper exits zero, preventing partial work from being accepted or stale human gates from being replayed.
+- Keep future paid, deployment, and publication authorization boundaries deferred while an unrelated safe project backlog item remains actionable.
+- Reconcile an already-materialized premature deferred gate by superseding it and restoring the project carrier to the runnable queue.
+- Resolve the authoritative project from checkpoint milestones when a task still carries a broader parent project id.
+
 ## 0.15.4 - 2026-08-22
 
 - Preserve source conversation and project metadata across revision planning, direct revision enqueue, and saved-plan application.

package/lib/core.mjs

@@ -1266,17 +1266,32 @@ export async function reconcileProjectGates(root, options = {}) {
         gate = { ...gate, ...await gateProjectMetadata(root, task, checkpoint) };
         await writeJson(full, gate);
       }
-      const spec = specs.get(gate.project_id);
+      const spec = await projectSpecForCheckpoint(root, [...specs.values()], gate.project_id, checkpoint);
+      if (spec?.project && gate.project_id !== spec.project) {
+        gate = { ...gate, project_id: spec.project };
+        await writeJson(full, gate);
+      }
+      const safeBacklogActionable = gate.gate_kind === 'deferred_authorization'
+        && await projectHasSafeActionableBacklog(root, spec);
       const invalid = gate.gate_kind === 'deferred_authorization' && await projectTerminalAccepted(root, spec)
         ? { code: 'project_accepted_optional_deferred', status: 'superseded' }
-        : gateInvalidity(gate, spec);
+        : safeBacklogActionable
+          ? { code: 'safe_backlog_actionable', status: 'superseded' }
+          : gateInvalidity(gate, spec);
       if (!invalid) continue;
       const now = new Date().toISOString();
       const reconciled = { ...gate, status: invalid.status, reconciliation: { ...invalid, reconciled_at: now } };
       await writeJson(full, reconciled);
       if (found?.subdir === 'waiting' && task?.waitingGateId === gate.gate_id) {
-        const canceledFile = path.join(queueSubdirFor(root, queue, 'canceled'), path.basename(found.file));
-        await writeJson(canceledFile, { ...task, status: invalid.status, canceledAt: now, gateReconciliation: reconciled.reconciliation });
+        const resumeSafeBacklog = invalid.code === 'safe_backlog_actionable';
+        const destinationFile = path.join(queueSubdirFor(root, queue, resumeSafeBacklog ? 'inbox' : 'canceled'), path.basename(found.file));
+        const restored = { ...task, status: resumeSafeBacklog ? 'queued' : invalid.status, gateReconciliation: reconciled.reconciliation };
+        delete restored.waitingGateId;
+        delete restored.waitKind;
+        delete restored.waitingSince;
+        if (!resumeSafeBacklog) restored.canceledAt = now;
+        else restored.requeuedAt = now;
+        await writeJson(destinationFile, restored);
         await rm(found.file, { force: true });
       }
       results.push({ queue, gateId: gate.gate_id, projectId: gate.project_id, outcome: invalid.status, reason: invalid.code });
@@ -1654,7 +1669,12 @@ function validateProjectSpec(spec) {
     normalizeLoopId(queue.queue);
     if (!['code', 'standard'].includes(queue.kind)) throw new Error(`Unsupported project queue kind: ${queue.kind}`);
   }
-  if (!Array.isArray(spec.backlog) || spec.backlog.length === 0) throw new Error('Project spec backlog must be non-empty.');
+  const hasEmbeddedBacklog = Array.isArray(spec.backlog) && spec.backlog.length > 0;
+  const configuredBacklogSource = spec.backlogSource ?? spec.authoritativeBacklog;
+  const hasConfiguredBacklog = typeof configuredBacklogSource === 'string' && configuredBacklogSource.trim().length > 0;
+  if (!hasEmbeddedBacklog && !hasConfiguredBacklog) {
+    throw new Error('Project spec must provide a non-empty backlog or backlogSource.');
+  }
 }
 
 export async function projectPlan(root, options = {}) {
@@ -1786,17 +1806,20 @@ export async function projectStatus(root, options = {}) {
       acceptanceLedger = { file: path.relative(root, ledgerFile), readable: false, error: error.message };
     }
   }
-  const registryItems = Array.isArray(spec.backlog) ? spec.backlog : [];
+  const hasEmbeddedBacklog = Array.isArray(spec.backlog) && spec.backlog.length > 0;
+  const registryItems = hasEmbeddedBacklog ? spec.backlog : [];
   const sourceItems = backlog ? await readJson(backlogFile).then((loaded) => loaded.items ?? loaded.tasks ?? []) : [];
   const registryById = new Map(registryItems.map((item) => [item.id, item]));
   const sourceById = new Map(sourceItems.map((item) => [item.id, item]));
   const drift = [];
-  for (const id of new Set([...registryById.keys(), ...sourceById.keys()])) {
-    const registry = registryById.get(id);
-    const authoritative = sourceById.get(id);
-    if (!registry || !authoritative) drift.push({ id, kind: registry ? 'missing_from_authoritative_backlog' : 'missing_from_registry' });
-    else if (registry.status !== authoritative.status || Boolean(registry.required) !== Boolean(authoritative.required)) {
-      drift.push({ id, kind: 'status_or_scope_mismatch', registry: { status: registry.status, required: registry.required }, authoritative: { status: authoritative.status, required: authoritative.required } });
+  if (hasEmbeddedBacklog) {
+    for (const id of new Set([...registryById.keys(), ...sourceById.keys()])) {
+      const registry = registryById.get(id);
+      const authoritative = sourceById.get(id);
+      if (!registry || !authoritative) drift.push({ id, kind: registry ? 'missing_from_authoritative_backlog' : 'missing_from_registry' });
+      else if (registry.status !== authoritative.status || Boolean(registry.required) !== Boolean(authoritative.required)) {
+        drift.push({ id, kind: 'status_or_scope_mismatch', registry: { status: registry.status, required: registry.required }, authoritative: { status: authoritative.status, required: authoritative.required } });
+      }
     }
   }
   const projectCompletion = acceptanceLedger?.status === 'accepted' && acceptanceLedger.unmet.length === 0 && acceptanceLedger.blockers.length === 0
@@ -2399,6 +2422,43 @@ function materializableDeferredGates(checkpoint) {
   });
 }
 
+async function projectBacklogItems(root, spec) {
+  if (!spec) return [];
+  const configured = spec.backlogSource ?? spec.authoritativeBacklog;
+  if (!configured) return [];
+  let loaded;
+  try {
+    loaded = await readJson(path.resolve(root, safeRelativePath(configured, 'project backlog source')));
+  } catch {
+    return [];
+  }
+  return Array.isArray(loaded.items) ? loaded.items : Array.isArray(loaded.tasks) ? loaded.tasks : [];
+}
+
+async function projectSpecForCheckpoint(root, specs, projectId, checkpoint) {
+  const direct = specs.find((item) => item.project === projectId);
+  const milestoneId = checkpoint?.milestone_id;
+  if (!milestoneId) return direct;
+  if ((await projectBacklogItems(root, direct)).some((item) => item.id === milestoneId)) return direct;
+  for (const spec of specs) {
+    if ((await projectBacklogItems(root, spec)).some((item) => item.id === milestoneId)) return spec;
+  }
+  return direct;
+}
+
+async function projectHasSafeActionableBacklog(root, spec) {
+  const items = await projectBacklogItems(root, spec);
+  const byId = new Map(items.map((item) => [item.id, item]));
+  const complete = new Set(['accepted', 'complete', 'completed', 'done', 'phase_complete']);
+  const runnable = new Set(['pending', 'queued', 'ready', 'in_progress', 'active']);
+  return items.some((item) => {
+    if (!item?.id || !runnable.has(item.status)) return false;
+    if (item.requires_human_input === true || item.blocked === true || item.status === 'blocked') return false;
+    const dependencies = Array.isArray(item.dependsOn) ? item.dependsOn : Array.isArray(item.depends_on) ? item.depends_on : [];
+    return dependencies.every((id) => complete.has(byId.get(id)?.status));
+  });
+}
+
 async function tasksById(root, queue) {
   const tasks = new Map();
   for (const subdir of ['inbox', 'active', 'waiting', 'done', 'failed', 'canceled']) {
@@ -2452,9 +2512,14 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     const deferredOnly = latestDeferredGates.length > 0
       && (!Array.isArray(latestCheckpoint.blockers) || latestCheckpoint.blockers.length === 0)
       && !['needs_human_input', 'blocked'].includes(latestCheckpoint.status);
-    const spec = specs.find((item) => item.project === metadata.project_id);
+    const spec = await projectSpecForCheckpoint(root, specs, metadata.project_id, latestCheckpoint);
     if (deferredOnly && await projectTerminalAccepted(root, spec)) continue;
-    candidates.push({ taskId, entry, projectId: metadata.project_id, ...checkpoints[0] });
+    // deferred_gates describe later authority boundaries. They become a
+    // waiting gate only after the authoritative backlog has no unrelated safe
+    // item left to run. Otherwise a future paid/deploy/publish boundary would
+    // incorrectly stop local project development.
+    if (deferredOnly && await projectHasSafeActionableBacklog(root, spec)) continue;
+    candidates.push({ taskId, entry, projectId: spec?.project ?? metadata.project_id, ...checkpoints[0] });
   }
 
   // A project deferred gate is materialized only from its newest authoritative
@@ -8731,6 +8796,9 @@ const DEFAULT_REQUIRES_HUMAN_ACTION_PATTERNS = [
 ];
 
 const DEFAULT_RECOVERABLE_RUNTIME_PATTERNS = [
+  { category: 'incomplete_turn', pattern: '"kind": "incomplete_turn"' },
+  { category: 'incomplete_turn', pattern: '"livenessState": "abandoned"' },
+  { category: 'incomplete_turn', pattern: 'stopped before confirming the turn was complete' },
   { category: 'compaction_timeout', pattern: 'compaction timed out' },
   { category: 'compaction_timeout', pattern: 'transcript compaction failed' },
   { category: 'transport_error', pattern: 'connection reset' },
@@ -8740,7 +8808,28 @@ const DEFAULT_RECOVERABLE_RUNTIME_PATTERNS = [
 ];
 
 export function dispatchFailureClassification(result, retry = {}) {
-  if (!result || result.exitCode === 0) {
+  if (!result) {
+    return {
+      category: 'ok',
+      requiresHumanAction: false,
+      matchedPattern: null
+    };
+  }
+  // Some embedded runtimes exit their wrapper successfully after the model
+  // turn itself was abandoned. Inspect the structured trailer before trusting
+  // exitCode=0 or the queue may accept partial work and replay a stale gate.
+  const output = `${result.stderr ?? ''}\n${result.stdout ?? ''}`.toLowerCase();
+  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
+    };
+  }
+  if (result.exitCode === 0) {
     return {
       category: 'ok',
       requiresHumanAction: false,
@@ -8755,7 +8844,6 @@ export function dispatchFailureClassification(result, retry = {}) {
       matchedPattern: null
     };
   }
-  const output = `${result.stderr ?? ''}\n${result.stdout ?? ''}`.toLowerCase();
   const patterns = retry.requiresHumanActionPatterns ?? DEFAULT_REQUIRES_HUMAN_ACTION_PATTERNS;
   const matched = patterns.find((pattern) => output.includes(pattern.toLowerCase()));
   if (matched) {
@@ -8766,16 +8854,6 @@ export function dispatchFailureClassification(result, retry = {}) {
       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,
@@ -8908,9 +8986,11 @@ async function runDispatchWithRetry(root, options, queue, task, activeFile, runI
       result,
       failureClassification
     });
-    const dispatchStatus = result.exitCode === 0
-      ? 'passed'
-      : failureClassification.requiresHumanAction ? 'needs_human_action' : 'failed';
+    const dispatchStatus = failureClassification.recoverableRuntime
+      ? 'interrupted'
+      : result.exitCode === 0
+        ? 'passed'
+        : failureClassification.requiresHumanAction ? 'needs_human_action' : 'failed';
     runContext.progress?.emit('dispatch', dispatchStatus, `Dispatcher attempt ${attempt} exited ${result.exitCode}`, {
       attempt,
       exitCode: result.exitCode,
@@ -9237,6 +9317,10 @@ export async function runQueueOnce(root, options) {
           const dispatchClassification = dispatchAttempts[dispatchAttempts.length - 1]?.failureClassification ?? null;
           if (dispatch?.canceled) {
             finalStatus = 'superseded';
+          } 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 if (dispatch?.exitCode === 0 && worktreeEnabled(options)) {
             verification = await runVerifyCommands(options.worktree?.verifyCommands ?? [], worktree.path, timeoutMs, progress);
             const verifyOk = verification.every((entry) => entry.result.exitCode === 0);
@@ -9246,10 +9330,6 @@ export async function runQueueOnce(root, options) {
               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';
             }

package/package.json

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

@@ -47,6 +47,36 @@ assert.equal(inferTaskScope({ body: 'Continue the overall project with a product
   assert.equal(classification.recoverableRuntime, true);
 }
 
+{
+  const classification = dispatchFailureClassification({
+    exitCode: 0,
+    timedOut: false,
+    stderr: '',
+    stdout: JSON.stringify({
+      replayInvalid: true,
+      livenessState: 'abandoned',
+      error: {
+        kind: 'incomplete_turn',
+        message: 'Codex stopped before confirming the turn was complete. Some work may already have been performed; verify the current state before retrying.'
+      }
+    }, null, 2)
+  });
+  assert.equal(classification.category, 'incomplete_turn');
+  assert.equal(classification.recoverableRuntime, true);
+  assert.equal(classification.requiresHumanAction, false);
+}
+
+{
+  const classification = dispatchFailureClassification({
+    exitCode: 0,
+    timedOut: false,
+    stderr: '',
+    stdout: JSON.stringify({ livenessState: 'working', completion: { stopReason: 'stop' } })
+  });
+  assert.equal(classification.category, 'ok');
+  assert.equal(classification.recoverableRuntime, undefined);
+}
+
 {
   const devPlan = { checkpoints: [{ id: 'cp1' }] };
   const reviews = { reviews: [{ checkpointId: 'cp38', sequence: 38, status: 'accepted', projectCompletion: { status: 'in_progress' } }] };

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

@@ -91,6 +91,27 @@ assert.equal(drifted.authority.acceptanceLedger, 'project/acceptance-ledger.json
 assert.equal(drifted.consistency.ok, false);
 assert(drifted.needsAttention.includes('authoritative_source_drift'));
 
+// A project may keep its authoritative backlog exclusively in backlogSource.
+// Requiring a duplicate embedded backlog makes the two copies drift and used
+// to prevent project-status from reading an otherwise valid project ledger.
+await writeFile(projectFile, `${JSON.stringify({
+  ...spec,
+  backlog: undefined,
+  backlogSource: 'project/backlog.json',
+  acceptanceLedger: 'project/acceptance-ledger.json',
+  terminalContract: 'project/terminal.md'
+}, null, 2)}\n`);
+const externalOnly = await projectStatus(root, { project: 'openreel' });
+assert.equal(externalOnly.backlog.file, 'project/backlog.json');
+assert.equal(externalOnly.backlog.count, 1);
+assert.equal(externalOnly.consistency.ok, true);
+await writeFile(projectFile, `${JSON.stringify({
+  ...spec,
+  backlogSource: 'project/backlog.json',
+  acceptanceLedger: 'project/acceptance-ledger.json',
+  terminalContract: 'project/terminal.md'
+}, null, 2)}\n`);
+
 // 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' });
@@ -111,6 +132,28 @@ assert.equal(deferredGate.authorization_requirements[0].action, 'production_roll
 assert.match(deferredGate.authorization_requirements[0].required_authority, /Owner authorization/);
 assert.equal((await queueStatus(root, queue)).waiting >= 1, true);
 
+// A future authorization must not stop the project while an unrelated safe
+// backlog item remains actionable.
+await reconcileProjectGates(root, { queue });
+await writeFile(authoritativeBacklog, `${JSON.stringify({
+  status: 'ongoing',
+  items: [
+    { id: 'LOCAL-01', status: 'phase_complete', dependsOn: [] },
+    { 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 futureGateDir = path.join(taskRuntimeDirFor(root, queue, futureGateTask.task.id), 'checkpoints');
+await mkdir(futureGateDir, { recursive: true });
+await writeFile(path.join(futureGateDir, 'cp1.json'), `${JSON.stringify({
+  version: 1, task_id: futureGateTask.task.id, checkpoint_id: 'cp1', status: 'ready_for_acceptance', blockers: [],
+  project_completion: { 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.' }]
+}, null, 2)}\n`);
+const futureNotice = await notifyHumanInputRequests(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(futureNotice.results.some((item) => item.taskId === futureGateTask.task.id), false);
+assert.equal((await queueStatus(root, queue)).waiting, 0);
+
 // Conditional policy boundaries are not current blockers. Plain prose in
 // deferred_gates must not materialize a gate without a concrete action and
 // authority requirement.
@@ -145,4 +188,4 @@ 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', 'conditional policy prose does not create a gate', 'accepted project optional deferred gate stays out of queue'] }));
+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', 'accepted project optional deferred gate stays out of queue'] }));