taskforce-loop-engineering 0.15.2 → 0.15.4

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## 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.
+- Resolve the installed queue and managed wrapper from each OpenClaw workspace, while keeping existing queue data untouched.
+- Add a distribution self-test that rejects host-specific dispatcher leakage in future packages.
+
 ## 0.15.2 - 2026-08-21
 
 - Enrich terminal notifications with final judgement, checkpoint summary, verification count, blockers, and next action.

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.2",
+  "version": "0.15.4",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",
@@ -20,7 +20,7 @@
     "check:adapters": "node --check lib/runtime-adapter-sdk.mjs && node scripts/runtime-adapter-conformance.mjs",
     "demo:adapter": "node examples/adapter-sdk-demo.mjs",
     "check:production-trust": "node --check lib/runtime-adapter-v1.mjs && node --check lib/durable-journal.mjs && node --check lib/execution-ledger.mjs && node --check lib/production-evidence.mjs && node --check lib/upgrade-planner.mjs && node scripts/production-acceptance.mjs",
-    "check:config-drift": "node --check scripts/config-drift-self-test.mjs && node scripts/config-drift-self-test.mjs",
+    "check:config-drift": "node scripts/distribution-skill-self-test.mjs && node --check scripts/config-drift-self-test.mjs && node scripts/config-drift-self-test.mjs",
     "check:openclaw-install": "node --check scripts/openclaw-install.mjs && node --check scripts/openclaw-doctor.mjs && node --check scripts/openclaw-smoke.mjs && node --check scripts/openclaw-manage.mjs && node scripts/openclaw-install-self-test.mjs",
     "check:hermes-install": "node --check scripts/hermes-install.mjs && node --check scripts/hermes-doctor.mjs && node --check scripts/hermes-smoke.mjs && node scripts/hermes-install-self-test.mjs",
     "check:project-gates": "node --check lib/core.mjs && node scripts/project-gate-reconciliation-self-test.mjs",

package/scripts/distribution-skill-self-test.mjs

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const skill = await readFile(new URL('../skills/taskforce-loop-engineering/SKILL.md', import.meta.url), 'utf8');
+
+for (const forbidden of ['ironman-task-runner', 'ironman-task-runner.mjs']) {
+  assert.equal(skill.includes(forbidden), false, `distributed skill contains local dispatcher reference: ${forbidden}`);
+}
+
+for (const required of ['agent-tasks', 'scripts/loops/openclaw-loop.mjs', 'configs/loops/queues/']) {
+  assert.equal(skill.includes(required), true, `distributed skill is missing generic integration guidance: ${required}`);
+}
+
+console.log('distribution skill self-test passed');

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

package/skills/taskforce-loop-engineering/SKILL.md

@@ -127,15 +127,17 @@ Interpret explicit loop language as follows:
 - A new explicit `走 loop` request while another task is active is a correction/replacement, not ordinary backlog. Supersede the active task at a safe boundary, retain its evidence and lineage, then start the replacement after the lock is released.
 - Status, progress, evidence, or failure questions are read-only and must not start another tick unless the user explicitly asks to continue/run.
 
-In this workspace, the default queue is `ironman-task-runner` when no queue is named. Use the installed workspace wrapper when present:
+Do not infer a queue or dispatcher from this skill. Use the integration installed in the current workspace. For OpenClaw, inspect the generated queue configuration under `configs/loops/queues/` and use the managed wrapper when present. A default installation uses queue `agent-tasks` and the generic wrapper below; an operator may choose another queue or worker during installation.
 
 ```bash
-node scripts/loops/ironman-task-runner.mjs route --message "<original user message>" --confirm-execute [source options]
-node scripts/loops/ironman-task-runner.mjs run-once --notify
-node scripts/loops/ironman-task-runner.mjs status --json
-node scripts/loops/ironman-task-runner.mjs peek --json
+node scripts/loops/openclaw-loop.mjs route --message "<original user message>" [source options]
+node scripts/loops/openclaw-loop.mjs run-once
+loop-engineering queue-status --queue <installed-queue> --root . --json
+loop-engineering queue-peek --queue <installed-queue> --root . --json
 ```
 
+If the managed wrapper or queue configuration is absent, stop and run the platform installer/doctor workflow above. Product names, personal agent names, and host-specific dispatchers belong in local workspace instructions, never in this distributed skill.
+
 Pass the original request faithfully. Preserve source channel, target, account, message id, and reply-to metadata so progress, human gates, and terminal results return to the originating conversation. Missing delivery routing must fail closed.
 
 ## Task vs Project Classification