taskforce-loop-engineering 0.7.0

package/scripts/openclaw-smoke.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+function parseArgs(argv) {
+  const out = { root: process.cwd(), queue: 'agent-tasks', workerAgent: 'main', openclawBin: 'openclaw', loopBin: 'loop-engineering', json: false, keepArtifacts: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--root') out.root = path.resolve(argv[++i]);
+    else if (arg === '--queue') out.queue = argv[++i];
+    else if (arg === '--worker-agent') out.workerAgent = argv[++i];
+    else if (arg === '--openclaw-bin') out.openclawBin = argv[++i];
+    else if (arg === '--loop-bin') out.loopBin = argv[++i];
+    else if (arg === '--keep-artifacts') out.keepArtifacts = true;
+    else if (arg === '--json') out.json = true;
+    else if (arg === '--help' || arg === '-h') out.help = true;
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  return out;
+}
+
+function run(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { cwd: options.cwd, env: options.env || process.env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = ''; let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.on('error', (error) => resolve({ code: 127, stdout, stderr: `${stderr}${error.message}` }));
+    child.on('close', (code, signal) => resolve({ code: code ?? (signal ? 128 : 1), stdout, stderr }));
+  });
+}
+
+async function exists(file) { try { await access(file); return true; } catch { return false; } }
+function safeId(value) { if (!/^[a-zA-Z0-9._-]+$/.test(value)) throw new Error('queue contains unsupported characters.'); return value; }
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    console.log('Usage: loop-engineering-openclaw-smoke [--root workspace] [--queue agent-tasks] [--worker-agent main] [--openclaw-bin openclaw] [--loop-bin loop-engineering] [--keep-artifacts] [--json]');
+    return;
+  }
+  safeId(args.queue);
+  const runToken = `${Date.now()}-${process.pid}`;
+  const smokeQueue = `smoke-${args.queue}-${runToken}`;
+  const baseConfig = path.join(args.root, `configs/loops/queues/${args.queue}.json`);
+  const smokeConfig = path.join(args.root, `configs/loops/queues/${smokeQueue}.json`);
+  const smokeRuntime = path.join(args.root, 'runtime', 'loops', smokeQueue);
+  const doctorScript = new URL('./openclaw-doctor.mjs', import.meta.url).pathname;
+  const steps = [];
+  let taskId = null;
+  try {
+    const doctor = await run(process.execPath, [doctorScript, '--root', args.root, '--queue', args.queue, '--worker-agent', args.workerAgent, '--openclaw-bin', args.openclawBin, '--json'], { cwd: args.root });
+    steps.push({ id: 'doctor', ok: doctor.code === 0 });
+    if (doctor.code !== 0) throw new Error(`doctor failed: ${doctor.stderr || doctor.stdout}`);
+    const config = JSON.parse(await readFile(baseConfig, 'utf8'));
+    config.queue = smokeQueue;
+    config.description = 'Temporary read-only OpenClaw integration smoke queue.';
+    config.retry = { ...(config.retry || {}), maxAttempts: 1 };
+    await mkdir(path.dirname(smokeConfig), { recursive: true });
+    await writeFile(smokeConfig, `${JSON.stringify(config, null, 2)}\n`);
+    const message = '走 loop：Perform a read-only integration smoke. Do not change files or external state. Report SMOKE_OK with verification evidence.';
+    const route = await run(args.loopBin, ['route-message', '--root', args.root, '--queue', smokeQueue, '--message', message, '--route', '--confirm-execute', '--source-channel', 'feishu', '--source-target', 'user:loop-smoke-dry-run', '--source-account', 'doctor', '--source-message-id', `smoke-${runToken}`, '--source-reply-to', `smoke-${runToken}`, '--json'], { cwd: args.root });
+    steps.push({ id: 'route', ok: route.code === 0 });
+    if (route.code !== 0) throw new Error(`route failed: ${route.stderr || route.stdout}`);
+    const routed = JSON.parse(route.stdout);
+    taskId = routed.task?.id || null;
+    const execute = await run(args.loopBin, ['run-queue', '--root', args.root, '--config', path.relative(args.root, smokeConfig), '--json'], { cwd: args.root });
+    steps.push({ id: 'worker_execution', ok: execute.code === 0 });
+    if (execute.code !== 0) throw new Error(`worker execution failed: ${execute.stderr || execute.stdout}`);
+    const taskDir = taskId ? path.join(smokeRuntime, 'tasks', taskId) : '';
+    for (const artifact of ['task_contract.json', 'dev_plan.json', 'acceptance_plan.json', 'final_judgement.json']) {
+      const ok = Boolean(taskDir) && await exists(path.join(taskDir, artifact));
+      steps.push({ id: `artifact:${artifact}`, ok });
+      if (!ok) throw new Error(`missing smoke artifact: ${artifact}`);
+    }
+    const notifyEnv = { ...process.env, LOOP_NOTIFICATION_DRY_RUN: '1' };
+    const notifyCommand = 'node scripts/loops/openclaw-loop-notify.mjs';
+    const humanNotify = await run(args.loopBin, ['queue-human-input-notify', '--root', args.root, '--queue', smokeQueue, '--notify-command', notifyCommand, '--json'], { cwd: args.root, env: notifyEnv });
+    steps.push({ id: 'human_gate_scan', ok: humanNotify.code === 0 });
+    const terminalNotify = await run(args.loopBin, ['queue-terminal-notify', '--root', args.root, '--queue', smokeQueue, '--notify-command', notifyCommand, '--json'], { cwd: args.root, env: notifyEnv });
+    const terminal = terminalNotify.code === 0 ? JSON.parse(terminalNotify.stdout) : null;
+    const terminalOk = terminalNotify.code === 0 && terminal?.sent === 1;
+    steps.push({ id: 'terminal_dry_run_return', ok: terminalOk });
+    if (!terminalOk) throw new Error(`terminal dry-run failed: ${terminalNotify.stderr || terminalNotify.stdout}`);
+    const report = { version: 1, status: 'ok', readOnlyTask: true, externalWrite: false, queue: args.queue, smokeQueue, workerAgent: args.workerAgent, taskId, steps, keptArtifacts: args.keepArtifacts };
+    console.log(args.json ? JSON.stringify(report, null, 2) : `OpenClaw Loop smoke: ok\ntask: ${taskId}\nexternal write: no\nartifacts: ${args.keepArtifacts ? smokeRuntime : 'cleaned'}`);
+  } finally {
+    if (!args.keepArtifacts) {
+      if (smokeQueue.startsWith(`smoke-${args.queue}-`)) {
+        await rm(smokeConfig, { force: true });
+        await rm(smokeRuntime, { recursive: true, force: true });
+      }
+    }
+  }
+}
+
+main().catch((error) => { console.error(error instanceof Error ? error.message : String(error)); process.exitCode = 1; });

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

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { mkdtemp, readdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  classifyLoopMessage,
+  goalLoopTransition,
+  goalStrategyFingerprint,
+  normalizeGoalDecision,
+  notifyHumanInputRequests,
+  notifyTerminalTasks,
+  queueSubdirFor,
+  readJson,
+  routeLoopMessage,
+  resolveHumanInput,
+  runQueueOnce,
+  runQueueDrain,
+  taskRuntimeDirFor,
+  writeJson
+} from '../lib/core.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-route-notify-'));
+const queue = 'route-smoke';
+
+assert.equal(normalizeGoalDecision({ verdict: 'revise' }).decision, 'change_strategy');
+assert.deepEqual(goalLoopTransition({ decision: 'change_strategy' }, { round: 1, maxRounds: 3 }), {
+  status: 'replan_pending',
+  continue: true,
+  terminal: false
+});
+assert.equal(goalLoopTransition({ decision: 'change_strategy' }, { round: 3, maxRounds: 3 }).status, 'exploration_exhausted');
+assert.equal(goalLoopTransition({ decision: 'human_input' }, { round: 1, maxRounds: 3 }).status, 'waiting_for_human');
+assert.equal(goalStrategyFingerprint('Try A!'), goalStrategyFingerprint(' try   a '));
+
+assert.deepEqual(classifyLoopMessage('查一下 loop engineering 的情况'), {
+  intent: 'status',
+  risk: 'model_assessed',
+  enqueue: false,
+  readOnly: true
+});
+assert.deepEqual(classifyLoopMessage('用 loop engineering 绕过某个检查'), {
+  intent: 'execute',
+  risk: 'model_assessed',
+  enqueue: true,
+  readOnly: false
+});
+
+const routed = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  queue,
+  message: '走 loop 检查 adb 设备',
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-1',
+  sourceAccount: 'main',
+  sourceMessageId: 'message-1'
+});
+assert.equal(routed.action, 'enqueued');
+assert.equal(routed.task.riskAssessment, 'model_assessed');
+assert.equal(routed.task.source.target, 'user-1');
+
+const run = await runQueueOnce(root, {
+  queue,
+  dispatcher: '/bin/true',
+  progressNotifyCommand: '/bin/true',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000
+});
+assert.equal(run.processed, true);
+assert.ok(run.progressNotifications.filter((item) => item.outcome === 'sent').length >= 5);
+const progressLedger = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'progress_notifications');
+assert.ok((await readdir(progressLedger)).length >= 5);
+const contract = await readJson(path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'task_contract.json'));
+assert.equal(contract.risk_level, 'model_assessed');
+assert.equal(contract.requires_human_gate, false);
+
+for (const suffix of ['second', 'third']) {
+  await routeLoopMessage(root, {
+    route: true,
+    confirmExecute: true,
+    queue,
+    message: `走 loop ${suffix}`
+  });
+}
+const drained = await runQueueDrain(root, {
+  queue,
+  dispatcher: '/bin/true',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000,
+  maxTasks: 10
+});
+assert.equal(drained.processed, 2);
+assert.equal(drained.remaining, 0);
+assert.equal(drained.stopReason, 'empty');
+
+const handoffQueue = 'handoff-smoke';
+await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  queue: handoffQueue,
+  message: '走 loop first handoff task'
+});
+let handoffEnqueue = null;
+const handedOff = await runQueueDrain(root, {
+  queue: handoffQueue,
+  dispatcher: '/bin/sleep 0.1',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000,
+  maxTasks: 10,
+  onProgress: (event) => {
+    if (event.status !== 'activated' || handoffEnqueue) return;
+    handoffEnqueue = routeLoopMessage(root, {
+      route: true,
+      confirmExecute: true,
+      queue: handoffQueue,
+      message: '走 loop task enqueued while first is active'
+    });
+  }
+});
+await handoffEnqueue;
+assert.equal(handedOff.processed, 2);
+assert.equal(handedOff.remaining, 0);
+assert.equal(handedOff.stopReason, 'empty');
+
+const supersedeQueue = 'supersede-smoke';
+const original = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  supersedeActive: true,
+  queue: supersedeQueue,
+  message: '走 loop original task'
+});
+let activated;
+const activeReady = new Promise((resolve) => { activated = resolve; });
+const originalRunPromise = runQueueOnce(root, {
+  queue: supersedeQueue,
+  dispatcher: '/bin/sleep 5',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000,
+  onProgress: (event) => {
+    if (event.phase === 'dispatch' && event.status === 'running') activated();
+  }
+});
+await activeReady;
+const replacement = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  supersedeActive: true,
+  queue: supersedeQueue,
+  message: '走 loop corrected replacement task'
+});
+assert.equal(replacement.action, 'supersede_requested');
+assert.equal(replacement.supersededTaskId, original.task.id);
+assert.equal(replacement.task.supersedesTaskId, original.task.id);
+const originalRun = await originalRunPromise;
+assert.equal(originalRun.status, 'superseded');
+assert.equal(originalRun.run.dispatch.canceled, true);
+assert.equal(originalRun.run.finalJudgement.outcome, 'superseded');
+assert.match(originalRun.taskPath, /canceled/);
+const replacementRun = await runQueueOnce(root, {
+  queue: supersedeQueue,
+  dispatcher: '/bin/true',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000
+});
+assert.equal(replacementRun.processed, true);
+assert.equal(replacementRun.run.taskId, replacement.task.id);
+
+const amendmentQueue = 'amendment-smoke';
+const amendmentOriginal = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  supersedeActive: true,
+  queue: amendmentQueue,
+  message: '走 loop original task that will receive a supplement',
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-1'
+});
+let amendmentActivated;
+const amendmentReady = new Promise((resolve) => { amendmentActivated = resolve; });
+let checkpointWrite = null;
+const amendmentRunPromise = runQueueOnce(root, {
+  queue: amendmentQueue,
+  dispatcher: '/bin/sleep 0.2',
+  timeoutMs: 10_000,
+  leaseMs: 20_000,
+  staleActiveMs: 60_000,
+  progressNotifyCommand: '/bin/true',
+  progressHeartbeatMs: 25,
+  checkpointPollMs: 10,
+  onProgress: (event) => {
+    if (event.phase === 'dispatch' && event.status === 'running') {
+      amendmentActivated();
+      checkpointWrite = writeJson(path.join(taskRuntimeDirFor(root, amendmentQueue, amendmentOriginal.task.id), 'checkpoints', 'cp-live.json'), {
+        version: 1,
+        task_id: amendmentOriginal.task.id,
+        checkpoint_id: 'cp-live',
+        status: 'ready_for_acceptance',
+        summary: 'Live checkpoint visible to the source conversation.',
+        files_changed: [],
+        verification: [{ command: '/bin/true', outcome: 'passed' }],
+        blockers: [],
+        risks: [],
+        next_action: 'acceptance_review'
+      });
+    }
+  }
+});
+await amendmentReady;
+const amendment = await routeLoopMessage(root, {
+  route: true,
+  confirmExecute: true,
+  amendActive: true,
+  queue: amendmentQueue,
+  message: '继续当前 loop，补充要求：验收必须覆盖新的边界条件',
+  sourceChannel: 'feishu',
+  sourceTarget: 'user-1',
+  sourceMessageId: 'amendment-1'
+});
+assert.equal(amendment.action, 'active_task_amended');
+assert.equal(amendment.taskId, amendmentOriginal.task.id);
+assert.equal(amendment.amendment.sequence, 1);
+assert.equal(amendment.updatedPlans.length, 3);
+assert.match(amendment.amendmentFile, /amendments\/0001\.json$/);
+const amendedContract = await readJson(path.join(taskRuntimeDirFor(root, amendmentQueue, amendmentOriginal.task.id), 'task_contract.json'));
+const amendedAcceptance = await readJson(path.join(taskRuntimeDirFor(root, amendmentQueue, amendmentOriginal.task.id), 'acceptance_plan.json'));
+const amendedDev = await readJson(path.join(taskRuntimeDirFor(root, amendmentQueue, amendmentOriginal.task.id), 'dev_plan.json'));
+assert.equal(amendedContract.amendment_version, 1);
+assert.match(amendedContract.supplemental_requirements[0], /新的边界条件/);
+assert.match(amendedAcceptance.supplemental_checks[0], /新的边界条件/);
+assert.match(amendedDev.supplemental_instructions[0], /新的边界条件/);
+const amendmentRun = await amendmentRunPromise;
+await checkpointWrite;
+assert.notEqual(amendmentRun.status, 'superseded');
+assert.equal(amendmentRun.run.dispatch.canceled, false);
+assert.ok(amendmentRun.progress.some((event) => event.status === 'heartbeat'));
+assert.ok(amendmentRun.progress.some((event) => event.status === 'checkpoint_update'));
+assert.ok(amendmentRun.progressNotifications.filter((item) => item.outcome === 'sent').length >= 7);
+await assert.rejects(
+  routeLoopMessage(root, {
+    route: true,
+    confirmExecute: true,
+    amendActive: true,
+    queue: amendmentQueue,
+    message: '继续当前 loop，补充要求：任务结束后不应再接受补充'
+  }),
+  /No active loop task exists to amend/
+);
+
+const terminalFile = path.join(root, run.taskPath);
+const terminalTask = await readJson(terminalFile);
+terminalTask.status = 'needs_human_input';
+const checkpointFile = path.join(taskRuntimeDirFor(root, queue, routed.task.id), 'checkpoints', 'cp-human.json');
+await writeJson(checkpointFile, {
+  version: 1,
+  task_id: routed.task.id,
+  checkpoint_id: 'cp-human',
+  status: 'needs_human_input',
+  summary: 'Waiting for a one-time code.',
+  blockers: [{ human_action_required: 'Provide the SMS code.' }],
+  verification: [],
+  risks: [],
+  next_action: 'wait_for_sms_code'
+});
+const failedFile = path.join(queueSubdirFor(root, queue, 'failed'), path.basename(terminalFile));
+await writeJson(failedFile, terminalTask);
+if (failedFile !== terminalFile) await rm(terminalFile, { force: true });
+
+const gateDryRun = await notifyHumanInputRequests(root, { queue, dryRun: true });
+assert.equal(gateDryRun.results[0].outcome, 'dry_run');
+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;
+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)));
+assert.equal(requeuedTask.humanInput.response, '123456');
+assert.match(requeuedTask.body, /Human input for gate/);
+await writeJson(failedFile, { ...requeuedTask, status: 'needs_human_input' });
+await rm(path.join(queueSubdirFor(root, queue, 'inbox'), path.basename(failedFile)), { force: true });
+
+const dryRun = await notifyTerminalTasks(root, { queue, dryRun: true });
+assert.equal(dryRun.results[0].outcome, 'dry_run');
+const sent = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(sent.sent, 1);
+const repeated = await notifyTerminalTasks(root, { queue, notifyCommand: '/bin/true' });
+assert.equal(repeated.results[0].outcome, 'already_notified');
+
+console.log('route/notify self-test passed');
+await import('./config-drift-self-test.mjs');

package/scripts/run-loop-cron.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+WORKDIR="${LOOP_WORKDIR:-$(pwd)}"
+CONFIG="${1:-}"
+LOG_DIR="${LOOP_LOG_DIR:-$WORKDIR/logs}"
+SEND_CMD="${LOOP_ALERT_COMMAND:-}"
+
+if [[ -z "$CONFIG" ]]; then
+  echo "Usage: run-loop-cron.sh <loop-config.json>" >&2
+  exit 2
+fi
+
+mkdir -p "$LOG_DIR"
+cd "$WORKDIR"
+
+loop_id="$(node -e '
+const fs = require("fs");
+const config = process.argv[1];
+try {
+  const spec = JSON.parse(fs.readFileSync(config, "utf8"));
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(spec.id || "")) process.exit(2);
+  process.stdout.write(spec.id);
+} catch {
+  process.exit(2);
+}
+' "$CONFIG")"
+
+stamp="$(date -u '+%Y-%m-%dT%H:%M:%SZ')"
+log_file="$LOG_DIR/loop-cron-${loop_id}.log"
+tmp_out="$(mktemp)"
+exit_code=0
+
+if loop-engineering run --config "$CONFIG" --root "$WORKDIR" > "$tmp_out" 2>&1; then
+  exit_code=0
+else
+  exit_code=$?
+fi
+
+{
+  printf '[%s] %s exit=%s\n' "$stamp" "$loop_id" "$exit_code"
+  sed -n '1,80p' "$tmp_out"
+  printf '\n'
+} >> "$log_file"
+
+if [[ "$exit_code" == "0" ]]; then
+  rm -f "$tmp_out"
+  exit 0
+fi
+
+summary="$(node -e '
+const fs = require("fs");
+const path = require("path");
+const loopId = process.argv[1];
+const dir = path.join("runtime", "loops", loopId, "runs");
+let latest = null;
+try {
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json")).sort();
+  if (files.length > 0) {
+    const file = path.join(dir, files[files.length - 1]);
+    const run = JSON.parse(fs.readFileSync(file, "utf8"));
+    const failed = Array.isArray(run.checks)
+      ? run.checks.filter((check) => !check.ok).map((check) => check.id).join(", ")
+      : "";
+    latest = [
+      `outcome=${run.outcome || "unknown"}`,
+      `reason=${run.breaker?.reason || run.runtimeError || "runner failed"}`,
+      failed ? `failed_checks=${failed}` : null,
+      `run=${run.runPath || file}`
+    ].filter(Boolean).join("; ");
+  }
+} catch {}
+process.stdout.write(latest || "runner failed before writing a run artifact");
+' "$loop_id")"
+
+message="Loop escalation ($stamp): $loop_id exit=$exit_code. $summary"
+if [[ -n "$SEND_CMD" ]]; then
+  "$SEND_CMD" "$message" || true
+else
+  printf '%s\n' "$message" >&2
+fi
+
+rm -f "$tmp_out"
+exit "$exit_code"