taskforce-loop-engineering 0.15.3 → 0.15.4

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 0.15.4 - 2026-08-22
+
+- Preserve source conversation and project metadata across revision planning, direct revision enqueue, and saved-plan application.
+- Refuse to create an unroutable revision when a routed source task has lost its required channel or target.
+- Materialize a human-input gate for the newest authoritative project carrier when it finishes blocked, while continuing to suppress historical failed-task replay.
+- Add regression coverage for routed revision inheritance and blocked project gate delivery.
+
 ## 0.15.3 - 2026-08-22
 
 - Remove workspace-specific Ironman queue and dispatcher instructions from the distributed skill.

package/lib/core.mjs

@@ -1883,6 +1883,25 @@ function taskSourceFromOptions(options = {}) {
   return Object.values(source).some(Boolean) ? source : null;
 }
 
+function taskSourceOptions(source) {
+  if (!source) return {};
+  return {
+    sourceChannel: source.channel ?? undefined,
+    sourceTarget: source.target ?? undefined,
+    sourceAccount: source.account ?? undefined,
+    sourceMessageId: source.message_id ?? undefined,
+    sourceReplyTo: source.reply_to ?? undefined
+  };
+}
+
+function assertRevisionRoutingSource(task) {
+  const explicitlyRouted = String(task?.body ?? '').startsWith('This task was explicitly routed to Loop Engineering from a source conversation.');
+  if (!task?.source && !explicitlyRouted) return;
+  if (!task?.source?.channel || !task?.source?.target) {
+    throw new Error(`Routed revision source task ${task?.id ?? 'unknown'} is missing source.channel/source.target; refusing to create an unroutable revision.`);
+  }
+}
+
 export function classifyLoopMessage(message) {
   const text = String(message ?? '').trim();
   if (!text) throw new Error('route-message requires --message.');
@@ -2446,7 +2465,12 @@ async function authoritativeHumanGateCandidates(root, queue, tasks) {
     if (!current || taskRecency(candidate.entry.task) > taskRecency(current.entry.task)) newestByProject.set(candidate.projectId, candidate);
   }
   return candidates.filter((candidate) => {
-    if (candidate.projectId) return newestByProject.get(candidate.projectId) === candidate && candidate.entry.subdir !== 'failed';
+    if (candidate.projectId) {
+      const authoritative = newestByProject.get(candidate.projectId) === candidate;
+      const actionableFailed = candidate.entry.subdir === 'failed'
+        && ['needs_human_input', 'blocked'].includes(candidate.checkpoint.status);
+      return authoritative && (candidate.entry.subdir !== 'failed' || actionableFailed);
+    }
     return ['inbox', 'active', 'waiting'].includes(candidate.entry.subdir)
       || (candidate.entry.subdir === 'failed' && ['needs_human_input', 'blocked'].includes(candidate.checkpoint.status));
   });
@@ -5232,6 +5256,7 @@ export async function queueRevisionPlan(root, queue, taskId, options = {}) {
   const found = await findTaskFile(root, normalized, taskId, ['failed', 'done']);
   if (!found) throw new Error(`Task not found for revision: ${taskId}`);
   const task = await readJson(found.file);
+  assertRevisionRoutingSource(task);
   if (!task.runPath) throw new Error(`Task has no runPath for revision: ${task.id}`);
   const run = await readJson(path.join(root, safeRelativePath(task.runPath, 'task runPath')));
   const humanDecision = await latestHumanDecision(root, normalized, task.id);
@@ -5255,6 +5280,8 @@ export async function queueRevisionPlan(root, queue, taskId, options = {}) {
   const plannedTask = {
     title,
     body,
+    source: task.source ?? null,
+    projectId: task.projectId ?? task.project_id ?? null,
     revisionOf: task.id,
     revisionSourceRun: task.runPath,
     revisionRequestPath,
@@ -5288,7 +5315,9 @@ export async function queueRevisionNext(root, queue, taskId, options = {}) {
   const enqueued = await enqueueTask(root, {
     queue: plan.queue,
     title: plan.plannedTask.title,
-    task: plan.plannedTask.body
+    task: plan.plannedTask.body,
+    projectId: plan.plannedTask.projectId ?? undefined,
+    ...taskSourceOptions(plan.plannedTask.source)
   });
   const nextTask = {
     ...enqueued.task,
@@ -5340,7 +5369,9 @@ export async function queueRevisionApplyPlan(root, planPath, options = {}) {
   const enqueued = await enqueueTask(root, {
     queue: normalized,
     title: plan.plannedTask.title,
-    task: plan.plannedTask.body
+    task: plan.plannedTask.body,
+    projectId: plan.plannedTask.projectId ?? undefined,
+    ...taskSourceOptions(plan.plannedTask.source)
   });
   const guard = plan.revisionPolicyGuard ?? plan.plannedTask.revisionPolicyGuard ?? null;
   const nextTask = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.15.3",
+  "version": "0.15.4",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",

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

@@ -11,6 +11,7 @@ import {
   notifyHumanInputRequests,
   notifyTerminalTasks,
   queueHumanDecision,
+  queueRevisionNext,
   queueDirFor,
   queueStatus,
   queueSubdirFor,
@@ -562,5 +563,96 @@ assert.equal((await readdir(queueSubdirFor(regressionRoot, regressionQueue, 'don
 const regressionRepeated = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
 assert.equal(regressionRepeated.sent, 0);
 
+// The newest authoritative project carrier may itself finish blocked. It must
+// become a durable waiting gate instead of being discarded with historical
+// failed attempts.
+const blockedProjectTask = 'latest-blocked';
+await writeJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'failed'), `${blockedProjectTask}.json`), {
+  id: blockedProjectTask,
+  title: 'demo latest blocked',
+  body: 'demo R-1',
+  projectId: 'demo',
+  status: 'blocked',
+  enqueuedAt: '2026-01-03T00:00:00Z',
+  source: { channel: 'feishu', target: 'owner' }
+});
+await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'checkpoints', 'cp2.json'), {
+  version: 1,
+  task_id: blockedProjectTask,
+  checkpoint_id: 'cp2',
+  milestone_id: 'R-1',
+  sequence: 2,
+  status: 'needs_human_input',
+  blockers: ['Approve the production activation.'],
+  verification: [],
+  risks: [],
+  project_completion: 'in_progress',
+  next_action: 'wait'
+});
+await writeJson(path.join(taskRuntimeDirFor(regressionRoot, regressionQueue, blockedProjectTask), 'final_judgement.json'), {
+  version: 1,
+  task_id: blockedProjectTask,
+  outcome: 'blocked',
+  coverage: { effective_review_ids: ['cp2'] }
+});
+const blockedProjectGate = await notifyHumanInputRequests(regressionRoot, { queue: regressionQueue, notifyCommand: '/bin/true' });
+assert.equal(blockedProjectGate.sent, 1);
+assert.equal((await readJson(path.join(queueSubdirFor(regressionRoot, regressionQueue, 'waiting'), `${blockedProjectTask}.json`))).status, 'waiting_for_human');
+
+// A routed revision must preserve the complete source envelope so a later
+// human gate or terminal result returns to the originating conversation.
+const revisionQueue = 'revision-routing';
+const revisionSource = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  supersedeActive: true,
+  queue: revisionQueue,
+  message: '走 loop fix revision routing',
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-revision',
+  sourceAccount: 'main',
+  sourceMessageId: 'revision-source-message',
+  sourceReplyTo: 'revision-source-reply'
+});
+const revisionSourceFile = path.join(queueSubdirFor(root, revisionQueue, 'inbox'), `${revisionSource.task.id}.json`);
+const revisionFailedFile = path.join(queueSubdirFor(root, revisionQueue, 'failed'), `${revisionSource.task.id}.json`);
+const revisionRequestFile = path.join(taskRuntimeDirFor(root, revisionQueue, revisionSource.task.id), 'revision_request.json');
+const revisionRunFile = path.join(queueSubdirFor(root, revisionQueue, 'runs'), `${revisionSource.task.id}.json`);
+await writeJson(revisionRequestFile, {
+  version: 1,
+  task_id: revisionSource.task.id,
+  status: 'requested',
+  revision_goals: [{ check: 'routing', required_change: 'Preserve source routing.' }],
+  next_checkpoint: { suggested_id: 'cp2' }
+});
+await writeJson(revisionRunFile, {
+  version: 2,
+  taskId: revisionSource.task.id,
+  status: 'failed',
+  finalJudgement: { outcome: 'needs_revision' },
+  revisionRequest: { path: path.relative(root, revisionRequestFile) }
+});
+await writeJson(revisionFailedFile, {
+  ...revisionSource.task,
+  status: 'failed',
+  projectId: 'demo-project',
+  runPath: path.relative(root, revisionRunFile)
+});
+await rm(revisionSourceFile, { force: true });
+const revision = await queueRevisionNext(root, revisionQueue, revisionSource.task.id, {
+  force: true,
+  strategy: 'Preserve the source envelope and verify blocked notification delivery.'
+});
+assert.deepEqual(revision.nextTask.source, revisionSource.task.source);
+assert.equal(revision.nextTask.projectId, 'demo-project');
+
+const unroutable = { ...await readJson(revisionFailedFile) };
+delete unroutable.source;
+await writeJson(revisionFailedFile, unroutable);
+await assert.rejects(
+  queueRevisionNext(root, revisionQueue, revisionSource.task.id, { force: true }),
+  /refusing to create an unroutable revision/
+);
+
 console.log('route/notify self-test passed');
 await import('./config-drift-self-test.mjs');