taskforce-loop-engineering 0.10.0 → 0.13.0

package/scripts/action-reservation-self-test.mjs

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  actionAdapters,
+  claimAction,
+  inspectAction,
+  markActionUnknown,
+  migrateLegacyActionArtifact,
+  reconcileAction,
+  releaseAction,
+  reserveAction,
+  settleAction
+} from '../lib/action-reservations.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-action-reservation-'));
+const base = { idempotencyKey: 'paid:task-1:step-1', kind: 'paid_api', authorizationScope: 'approval:task-1:provider-call', request: { model: 'mock', promptHash: 'abc', cents: 4 } };
+
+const reserved = await reserveAction(root, base);
+assert.equal(reserved.created, true);
+assert.equal((await reserveAction(root, base)).duplicate, true);
+await assert.rejects(() => reserveAction(root, { ...base, request: { ...base.request, cents: 5 } }), /different request/);
+
+// Concurrent workers get one atomic lease and one fencing token.
+const claims = await Promise.all(Array.from({ length: 12 }, (_, i) => claimAction(root, { idempotencyKey: base.idempotencyKey, owner: `worker-${i}`, leaseMs: 1000 })));
+assert.equal(claims.filter((item) => item.claimed).length, 1);
+const winner = claims.find((item) => item.claimed);
+await assert.rejects(() => settleAction(root, { idempotencyKey: base.idempotencyKey, fencingToken: winner.fencingToken + 1 }), /fencing token/);
+assert.equal((await settleAction(root, { idempotencyKey: base.idempotencyKey, fencingToken: winner.fencingToken, evidence: { upstreamId: 'mock-1' } })).settled, true);
+assert.equal((await settleAction(root, { idempotencyKey: base.idempotencyKey, fencingToken: winner.fencingToken })).duplicate, true);
+assert.equal((await inspectAction(root, base.idempotencyKey)).authorization.state, 'consumed');
+await assert.rejects(() => releaseAction(root, { idempotencyKey: base.idempotencyKey, reason: 'late release' }), /cannot be released/);
+
+// Crash before send: an expired claim becomes unknown, never blindly claimable.
+const beforeSend = { ...base, idempotencyKey: 'paid:crash-before-send' };
+await reserveAction(root, beforeSend);
+await claimAction(root, { idempotencyKey: beforeSend.idempotencyKey, owner: 'crashed', leaseMs: 1 });
+await new Promise((resolve) => setTimeout(resolve, 5));
+assert.equal((await claimAction(root, { idempotencyKey: beforeSend.idempotencyKey, owner: 'recovery', leaseMs: 10 })).reason, 'reconcile_required');
+await reconcileAction(root, { idempotencyKey: beforeSend.idempotencyKey, outcome: 'not_accepted', evidence: { local: 'adapter_not_invoked' } });
+assert.equal((await claimAction(root, { idempotencyKey: beforeSend.idempotencyKey, owner: 'recovery', leaseMs: 100 })).claimed, true);
+
+// Crash after upstream acceptance: reconciliation settles without another send/charge.
+const afterAcceptance = { ...base, idempotencyKey: 'paid:crash-after-acceptance' };
+await reserveAction(root, afterAcceptance);
+const afterClaim = await claimAction(root, { idempotencyKey: afterAcceptance.idempotencyKey, owner: 'worker', leaseMs: 100 });
+await markActionUnknown(root, { idempotencyKey: afterAcceptance.idempotencyKey, fencingToken: afterClaim.fencingToken, reason: 'accepted_before_local_commit' });
+await reconcileAction(root, { idempotencyKey: afterAcceptance.idempotencyKey, outcome: 'accepted', evidence: { upstreamId: 'mock-accepted' } });
+assert.equal((await claimAction(root, { idempotencyKey: afterAcceptance.idempotencyKey, owner: 'retry' })).reason, 'settled');
+
+// Notification adapter suppresses duplicates, and an unused reservation can release authorization.
+await actionAdapters.notification.reserve(root, { idempotencyKey: 'notify:task-1:terminal', authorizationScope: 'task-1:source-chat', request: { target: 'mock-chat', digest: 'done' } });
+const notifyDuplicate = await actionAdapters.notification.reserve(root, { idempotencyKey: 'notify:task-1:terminal', authorizationScope: 'task-1:source-chat', request: { target: 'mock-chat', digest: 'done' } });
+assert.equal(notifyDuplicate.duplicate, true);
+const releasable = { ...base, idempotencyKey: 'deploy:cancelled', kind: 'deployment', authorizationScope: 'approval:deploy-staging' };
+await reserveAction(root, releasable);
+assert.equal((await releaseAction(root, { idempotencyKey: releasable.idempotencyKey, reason: 'operator_cancelled', evidence: { ticket: 'mock' } })).record.authorization.state, 'released');
+
+// Legacy artifacts are imported without changing their logical identity.
+const migrated = await migrateLegacyActionArtifact(root, { idempotency_key: 'legacy:notification:1', kind: 'notification', authorization_scope: 'legacy:chat', request: { digest: 'old' } });
+assert.equal(migrated.created, true);
+assert.equal((await migrateLegacyActionArtifact(root, { idempotency_key: 'legacy:notification:1', kind: 'notification', authorization_scope: 'legacy:chat', request: { digest: 'old' } })).duplicate, true);
+
+console.log(JSON.stringify({ status: 'ok', assertions: 'reservation, fingerprint, concurrency, fencing, crash recovery, reconciliation, authorization, release, adapters, migration' }));

package/scripts/async-acceptance-refresh-self-test.mjs

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { ensureQueueDirs, queueSubdirFor, readJson, refreshTaskAcceptance, writeJson } from '../lib/core.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-async-acceptance-'));
+const queue = 'async-refresh';
+const taskId = 'detached-soak';
+const runtimeDir = path.join(root, 'runtime', 'loops', queue, 'tasks', taskId);
+
+try {
+  await ensureQueueDirs(root, queue);
+  await writeJson(path.join(queueSubdirFor(root, queue, 'failed'), `${taskId}.json`), {
+    version: 1, id: taskId, title: 'Detached soak', status: 'blocked'
+  });
+  await writeJson(path.join(runtimeDir, 'task_contract.json'), {
+    version: 1, task_id: taskId, task_scope: 'project', risk_level: 'L1', requires_human_gate: false,
+    constraints: { blocked_actions: [] }
+  });
+  await writeJson(path.join(runtimeDir, 'acceptance_plan.json'), {
+    version: 1, functional_checks: [], regression_checks: [], negative_tests: [], manual_review: [], automation: [], rubric: []
+  });
+  await writeJson(path.join(runtimeDir, 'dev_plan.json'), { version: 1, checkpoints: [{ id: 'cp1' }] });
+  await writeJson(path.join(runtimeDir, 'checkpoints', 'cp1.json'), {
+    version: 1, task_id: taskId, checkpoint_id: 'cp1', milestone_id: 'cp1', sequence: 1,
+    status: 'blocked', summary: 'Soak still running.', files_changed: ['soak.json'], verification: ['pending'], blockers: ['pending'], risks: [], project_completion: { status: 'in_progress' }
+  });
+  await writeJson(path.join(runtimeDir, 'final_judgement.json'), { version: 1, task_id: taskId, outcome: 'blocked' });
+  assert.equal((await refreshTaskAcceptance(root, { queue, taskId })).outcome, 'already_current');
+
+  await new Promise((resolve) => setTimeout(resolve, 20));
+  await writeJson(path.join(runtimeDir, 'checkpoints', 'cp2.json'), {
+    version: 1, task_id: taskId, checkpoint_id: 'cp2', milestone_id: 'cp1', revises_checkpoint_id: 'cp1', sequence: 2,
+    status: 'ready_for_acceptance', summary: 'Detached soak completed.', files_changed: ['soak.json'], verification: ['passed=true'], blockers: [], risks: [], project_completion: { status: 'accepted' }
+  });
+  const refreshed = await refreshTaskAcceptance(root, { queue, taskId });
+  assert.equal(refreshed.outcome, 'refreshed');
+  assert.equal(refreshed.status, 'completed');
+  assert.equal((await readJson(path.join(runtimeDir, 'final_judgement.json'))).outcome, 'ready_to_apply');
+  assert.equal((await refreshTaskAcceptance(root, { queue, taskId })).outcome, 'already_current');
+  assert.equal((await readJson(path.join(queueSubdirFor(root, queue, 'done'), `${taskId}.json`))).status, 'completed');
+  console.log('async acceptance refresh self-test passed');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}

package/scripts/durable-journal-self-test.mjs

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os'; import path from 'node:path';
+import { DurableJournal, externalEffectBoundary } from '../lib/durable-journal.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-journal-'));
+try {
+  const journal = new DurableJournal(path.join(root, 'state'));
+  await journal.append('step_checkpointed', { step: 1 }, 'tx-1');
+  await journal.append('step_checkpointed', { step: 2 }, 'tx-2');
+  const replay = await journal.replay((state, event) => ({ step: event.payload.step }), {});
+  assert.deepEqual(replay.state, { step: 2 }); assert.equal(replay.count, 2);
+  await journal.checkpoint(replay.state);
+  await writeFile(journal.logFile, `${await readFile(journal.logFile, 'utf8')}{"torn":`);
+  assert.equal((await journal.replay()).count, 2);
+  const backup = path.join(root, 'backup'); await journal.backup(backup);
+  const restored = path.join(root, 'restored'); assert.equal((await DurableJournal.restore(backup, restored)).count, 2);
+  const legacy = path.join(root, 'state.json'); await writeFile(legacy, '{"version":1,"runs":7}\n');
+  const migrated = await DurableJournal.migrateV1(legacy, path.join(root, 'migrated'));
+  assert.equal((await migrated.replay()).count, 1); await DurableJournal.migrateV1(legacy, path.join(root, 'migrated')); assert.equal((await migrated.replay()).count, 1);
+  assert.equal(externalEffectBoundary({ status: 'unknown', idempotencyKey: 'task:step' }).replayable, false);
+  assert.throws(() => externalEffectBoundary({ status: 'accepted', idempotencyKey: 'k' }), /upstreamEvidence/);
+  console.log('durable journal self-test passed');
+} finally { await rm(root, { recursive: true, force: true }); }

package/scripts/human-gate-lifecycle-v2-self-test.mjs

@@ -0,0 +1,81 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  ensureQueueDirs,
+  parkQueueTask,
+  queueStatus,
+  queueSubdirFor,
+  readJson,
+  resumeParkedTask,
+  tickParkedTasks,
+  writeJson
+} from '../lib/core.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-human-gate-v2-'));
+const queue = 'vps-fixture';
+const taskId = 'vps-down-ssh-banner-timeout';
+const taskFile = path.join(queueSubdirFor(root, queue, 'inbox'), `${taskId}.json`);
+
+try {
+  await ensureQueueDirs(root, queue);
+  await writeJson(taskFile, { version: 1, id: taskId, title: 'Recover provider VPS', status: 'queued' });
+  const parked = await parkQueueTask(root, {
+    queue,
+    taskId,
+    kind: 'external_condition',
+    reason: 'VPS is down; SSH banner timed out.',
+    now: '2026-08-13T00:00:00.000Z',
+    executionKey: 'provider-call-1',
+    authorization: { state: 'unconsumed', scope: 'provider_call' },
+    policy: { timeoutMs: 2_000, reminderIntervalMs: 1_000, escalationIntervalMs: 2_000, maxReminders: 1 }
+  });
+  assert.equal(parked.outcome, 'parked');
+  assert.equal(parked.task.parked.authorization.state, 'unconsumed');
+  assert.equal(parked.task.parked.execution_boundary.action_executed, false);
+
+  const status = await queueStatus(root, queue);
+  assert.equal(status.waitingStates.timed_out_or_escalated, 1);
+  assert.equal(status.waitingTasks[0].waitKind, 'external_condition');
+  assert.equal(status.waitingTasks[0].authorizationState, 'unconsumed');
+
+  const notifyCommand = 'node -e "process.exit(0)"';
+  const reminder = await tickParkedTasks(root, { queue, now: '2026-08-13T00:00:01.000Z', notifyCommand });
+  assert.equal(reminder.results[0].type, 'reminder');
+  const duplicateTick = await tickParkedTasks(root, { queue, now: '2026-08-13T00:00:01.000Z', notifyCommand });
+  assert.equal(duplicateTick.results[0].outcome, 'throttled');
+  const escalation = await tickParkedTasks(root, { queue, now: '2026-08-13T00:00:03.000Z', notifyCommand });
+  assert.equal(escalation.results[0].type, 'escalation');
+
+  await assert.rejects(
+    resumeParkedTask(root, { queue, taskId, recoverySignal: 'ssh banner verified' }),
+    /--verified/
+  );
+  const resumed = await resumeParkedTask(root, {
+    queue,
+    taskId,
+    verified: true,
+    recoverySignal: 'probe=vps-1;ssh_banner=verified',
+    now: '2026-08-13T00:00:04.000Z'
+  });
+  assert.equal(resumed.outcome, 'verified_and_requeued');
+  assert.equal(resumed.task.parked.state, 'runnable');
+  assert.equal(resumed.task.parked.authorization.state, 'unconsumed');
+  assert.equal(resumed.task.parked.execution_boundary.action_executed, false);
+  assert.ok(resumed.signalSha256);
+
+  const afterRestart = await resumeParkedTask(root, {
+    queue,
+    taskId,
+    verified: true,
+    recoverySignal: 'probe=vps-1;ssh_banner=verified'
+  });
+  assert.equal(afterRestart.outcome, 'already_resumed');
+  const durable = await readJson(path.join(queueSubdirFor(root, queue, 'inbox'), `${taskId}.json`));
+  assert.equal(durable.parked.execution_boundary.key, 'provider-call-1');
+  assert.equal(durable.parked.authorization.state, 'unconsumed');
+  console.log('human-gate-lifecycle-v2 self-test: ok');
+} finally {
+  await rm(root, { recursive: true, force: true });
+}

package/scripts/live-runtime-soak.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+const value = (name, fallback) => { const i = process.argv.indexOf(name); return i >= 0 ? process.argv[i + 1] : fallback; };
+const durationMs = Number(value('--duration-ms', 7_200_000));
+const output = path.resolve(value('--output', 'live-runtime-soak-report.json'));
+const openclawBin = value('--openclaw-bin', 'openclaw');
+const agent = value('--agent', 'ironman');
+const openclawProfile = value('--openclaw-profile', '');
+const hermesBin = value('--hermes-bin', '');
+const maxCalls = Number(value('--max-model-calls', 3));
+const dryRun = process.argv.includes('--dry-run');
+const runtimeOnly = process.argv.includes('--runtime-only');
+if (!Number.isFinite(durationMs) || durationMs < 60_000) throw new Error('duration must be at least 60 seconds');
+if (!Number.isInteger(maxCalls) || maxCalls < 1 || maxCalls > 6) throw new Error('max model calls must be 1..6');
+
+const runId = randomUUID();
+const workDir = path.join(tmpdir(), `loop-live-soak-${runId}`);
+await mkdir(workDir, { recursive: true }); await mkdir(path.dirname(output), { recursive: true });
+const startedAt = new Date(); const deadline = startedAt.getTime() + durationMs;
+const report = { version: 1, kind: hermesBin ? 'live-openclaw-hermes-multi-agent-runtime-soak' : 'live-openclaw-multi-session-soak', runId, dryRun, runtimeOnly, startedAt: startedAt.toISOString(), deadlineAt: new Date(deadline).toISOString(), agent, sessions: 3, modelCallsCap: dryRun || runtimeOnly ? 0 : maxCalls, modelCallsAttempted: 0, consecutiveRuntimeErrors: 0, stoppedByCircuitBreaker: false, externalWrites: false, productionProcessesControlled: false, events: [], metrics: { runtimeProbeFailures: 0, heartbeats: 0, claims: 0, handoffs: 0, injectedCrashes: 0, restarts: 0, staleFencesAccepted: 0, duplicateEffects: 0, unknownReconciled: 0 } };
+const sanitize = (text) => String(text).replace(/[A-Za-z0-9_=-]{24,}/g, '[redacted]').slice(0, 240);
+const record = (type, fields = {}) => report.events.push({ at: new Date().toISOString(), type, ...fields });
+const invoke = (worker) => new Promise((resolve) => {
+  report.modelCallsAttempted++;
+  const session = `agent:${agent}:loop-production-soak-${runId}-${worker}`;
+  const child = spawn(openclawBin, ['agent', '--agent', agent, '--session-key', session, '--message', 'Read-only local soak probe. Reply exactly SOAK_OK. Do not use tools, change files, send messages, or perform external actions.', '--json', '--timeout', '120'], { cwd: workDir, stdio: ['ignore', 'pipe', 'pipe'] });
+  let stdout = ''; let stderr = ''; child.stdout.on('data', (c) => { stdout += c; }); child.stderr.on('data', (c) => { stderr += c; });
+  child.on('close', (code, signal) => resolve({ code: code ?? (signal ? 128 : 1), evidence: sanitize(stdout || stderr) }));
+  child.on('error', (error) => resolve({ code: 127, evidence: sanitize(error.message) }));
+});
+const probe = (command, args, runtime) => new Promise((resolve) => {
+  const child = spawn(command, args, { cwd: workDir, stdio: ['ignore', 'pipe', 'pipe'] }); let stdout = ''; let stderr = '';
+  child.stdout.on('data', (c) => { stdout += c; }); child.stderr.on('data', (c) => { stderr += c; });
+  let settled = false; const finish = (ok, evidence) => { if (settled) return; settled = true; if (!ok) report.metrics.runtimeProbeFailures++; record('runtime_cli_probe', { runtime, ok, evidence: sanitize(evidence) }); resolve(ok); };
+  child.on('close', (code) => finish(code === 0, stdout || stderr)); child.on('error', (error) => finish(false, error.message));
+});
+
+const leases = { owner: null, until: 0, fence: 0, quotaUsed: 0, parked: false, effect: 'reserved' };
+const claim = (owner, now) => { if (leases.parked || leases.quotaUsed >= 2 || (leases.owner && leases.until > now)) return null; leases.owner = owner; leases.until = now + 90_000; leases.fence++; leases.quotaUsed++; report.metrics.claims++; return leases.fence; };
+const heartbeatChildren = new Map();
+let interruptedSignal = null;
+for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.on(signal, () => { interruptedSignal = signal; });
+const startHeartbeat = (worker) => {
+  const source = `setInterval(()=>process.stdout.write('h\\n'),1000)`;
+  const child = spawn(process.execPath, ['-e', source], { cwd: workDir, stdio: ['ignore', 'pipe', 'pipe'] });
+  child.stdout.on('data', (chunk) => { report.metrics.heartbeats += String(chunk).split('\n').filter(Boolean).length; });
+  heartbeatChildren.set(worker, child); return child;
+};
+
+try {
+  if (!dryRun) {
+    if (!await probe(openclawBin, [...(openclawProfile ? ['--profile', openclawProfile] : []), 'agents', 'list', '--json'], 'openclaw')) report.consecutiveRuntimeErrors++;
+    if (hermesBin && !await probe(hermesBin, ['--version'], 'hermes')) report.consecutiveRuntimeErrors++;
+    if (report.consecutiveRuntimeErrors >= 2) report.stoppedByCircuitBreaker = true;
+  }
+  for (let worker = 1; !dryRun && !runtimeOnly && worker <= 3 && report.modelCallsAttempted < maxCalls; worker++) {
+    const result = await invoke(`w${worker}`); record('runtime_probe', { worker: `w${worker}`, ok: result.code === 0, evidence: result.evidence });
+    report.consecutiveRuntimeErrors = result.code === 0 ? 0 : report.consecutiveRuntimeErrors + 1;
+    if (report.consecutiveRuntimeErrors >= 2) { report.stoppedByCircuitBreaker = true; break; }
+  }
+  if (!report.stoppedByCircuitBreaker) {
+    for (const worker of ['w1', 'w2', 'w3']) startHeartbeat(worker);
+    const first = claim('w1', Date.now()); record('claim', { worker: 'w1', fence: first });
+    leases.effect = 'unknown'; record('unknown_outcome', { replaySuppressed: true }); leases.effect = 'not_accepted'; report.metrics.unknownReconciled++;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(65_000, Math.max(5_000, durationMs / 4))));
+    const crashed = heartbeatChildren.get('w1'); crashed.kill('SIGTERM'); report.metrics.injectedCrashes++; record('dedicated_worker_crash', { worker: 'w1' });
+    leases.until = Date.now() - 1; leases.quotaUsed = 0; const second = claim('w2', Date.now()); report.metrics.handoffs++; record('lease_handoff', { from: 'w1', to: 'w2', fence: second, staleFenceRejected: first !== second });
+    if (first === second) report.metrics.staleFencesAccepted++;
+    startHeartbeat('w1-restarted'); report.metrics.restarts++; record('dedicated_worker_restart', { worker: 'w1-restarted' });
+    leases.parked = true; record('parked_gate', { claimRejected: claim('w3', Date.now()) === null }); leases.parked = false;
+    while (Date.now() < deadline && !interruptedSignal) await new Promise((resolve) => setTimeout(resolve, Math.min(30_000, deadline - Date.now())));
+  }
+} finally {
+  for (const child of heartbeatChildren.values()) if (!child.killed) child.kill('SIGTERM');
+  report.completedAt = new Date().toISOString(); report.durationMs = Date.parse(report.completedAt) - startedAt.getTime();
+  report.interruptedSignal = interruptedSignal;
+  report.passed = !interruptedSignal && !report.stoppedByCircuitBreaker && report.metrics.runtimeProbeFailures === 0 && report.durationMs >= durationMs && report.metrics.heartbeats > 0 && report.metrics.handoffs === 1 && report.metrics.restarts === 1 && report.metrics.staleFencesAccepted === 0 && report.metrics.duplicateEffects === 0 && report.metrics.unknownReconciled === 1;
+  const temporary = `${output}.${process.pid}.tmp`; await writeFile(temporary, `${JSON.stringify(report, null, 2)}\n`); await import('node:fs/promises').then(({ rename }) => rename(temporary, output)); await rm(workDir, { recursive: true, force: true });
+}
+console.log(JSON.stringify({ runId, passed: report.passed, output, durationMs: report.durationMs, modelCallsAttempted: report.modelCallsAttempted }, null, 2));
+if (!report.passed) process.exitCode = 1;

package/scripts/operator-dashboard-self-test.mjs

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { buildOperatorProjection, createDashboardServer, dashboardHealth, exportDashboard, filterProjection } from '../lib/operator-dashboard.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-dashboard-'));
+const loops = path.join(root, 'runtime', 'loops');
+await mkdir(path.join(loops, 'control-plane'), { recursive: true });
+await mkdir(path.join(loops, 'action-reservations'), { recursive: true });
+await mkdir(path.join(loops, 'legacy', 'waiting'), { recursive: true });
+await mkdir(path.join(loops, 'legacy', 'active'), { recursive: true });
+await mkdir(path.join(loops, 'projects', 'p3', 'intake'), { recursive: true });
+const now = '2026-08-13T16:00:00.000Z';
+const control = {
+  version: 2, updated_at: now, quotas: { credits: 9 }, agents: { a: { id: 'a', capabilities: ['code'], authority_grants: ['local'], provider_token: 'never-show' } },
+  handoffs: { h: { id: 'h', todo_id: 'leased', from_agent_id: 'a', to_agent_id: 'b', state: 'pending', created_at: now } },
+  todos: {
+    human: { version: 2, id: 'human', title: '<img src=x onerror=alert(1)>', state: 'runnable', priority: 2, risk: 'medium', authority_class: 'local', required_capabilities: [], acceptance_contract: { checks: ['ok'] }, evidence_requirements: ['test'], cost_envelope: { quota: 'credits', amount: 2 }, parked: { state: 'waiting_for_human', gate_id: 'g1', secret_input: 'hide' }, blocked_reasons: [], claim: null, lineage: { root_todo_id: 'human' }, evidence: [], idempotency_keys: [], created_at: now, updated_at: now },
+    leased: { version: 2, id: 'leased', title: 'Lease expired', state: 'claimed', priority: 1, authority_class: 'local', required_capabilities: [], acceptance_contract: {}, evidence_requirements: ['lease'], cost_envelope: { quota: 'credits', amount: 3 }, claim: { owner: 'a', fencing_token: 7, claimed_at: '2026-08-13T15:00:00.000Z', lease_expires_at: '2026-08-13T15:01:00.000Z' }, blocked_reasons: [], lineage: {}, evidence: [], idempotency_keys: ['paid:x'], created_at: now, updated_at: now }
+  }
+};
+await writeFile(path.join(loops, 'control-plane', 'state.json'), JSON.stringify(control));
+await writeFile(path.join(loops, 'action-reservations', 'x.json'), JSON.stringify({ version: 1, idempotency_key: 'paid:x', kind: 'paid_api', state: 'unknown', request: { api_key: 'hide', prompt: '<script>x</script>' }, request_fingerprint: 'abc', authorization: { scope: 'paid', credential: 'hide' }, claim: null, reconciliation: { required: true, reason: 'stale_lease' }, created_at: now, updated_at: now }));
+await writeFile(path.join(loops, 'legacy', 'waiting', 'vps.json'), JSON.stringify({ id: 'vps', title: 'VPS down', parked: { kind: 'external_condition', next_check_at: '2026-08-13T17:00:00.000Z' }, provider: 'hidden' }));
+await writeFile(path.join(loops, 'legacy', 'active', 'bad.json'), '{broken');
+await writeFile(path.join(loops, 'projects', 'p3', 'intake', 'latest.json'), JSON.stringify({ version: 1, goal: 'Operator dashboard', token: 'hidden' }));
+
+const before = await stat(path.join(loops, 'control-plane', 'state.json'));
+const first = await buildOperatorProjection(root, { now });
+const second = await buildOperatorProjection(root, { now });
+const after = await stat(path.join(loops, 'control-plane', 'state.json'));
+assert.deepEqual(first, second, 'fixed-time projections are deterministic');
+assert.equal(before.mtimeMs, after.mtimeMs, 'projection does not mutate source state');
+assert.equal(first.todos.find((item) => item.id === 'human').state, 'waiting_for_human');
+assert.equal(first.todos.find((item) => item.id === 'leased').state, 'reconciliation_required');
+assert.equal(first.actions[0].state, 'reconciliation_required');
+assert.equal(first.queues[0].tasks[0].state, 'waiting_for_external_condition');
+assert.equal(first.agents[0].provider_token, '[REDACTED]');
+assert.equal(first.todos[0].gate.secret_input, '[REDACTED]');
+assert.equal(JSON.stringify(first).includes('never-show'), false);
+assert.equal(JSON.stringify(first).includes('hidden'), false);
+assert.equal(first.health.status, 'degraded');
+assert.equal(filterProjection(first, { state: 'waiting_for_human', query: 'img' }).todos.length, 1);
+assert.equal(dashboardHealth(first, { maxAgeSeconds: 1 }).stale, false);
+
+const output = path.join(root, 'export');
+await exportDashboard(root, output, { now });
+assert.match(await readFile(path.join(output, 'index.html'), 'utf8'), /projection\.json/);
+assert.equal(JSON.parse(await readFile(path.join(output, 'projection.json'), 'utf8')).schema_version, '1.0.0');
+await assert.rejects(() => createDashboardServer(root, { host: '0.0.0.0' }), /requires --allow-non-loopback/);
+
+const server = await createDashboardServer(root, { host: '127.0.0.1', port: 0 });
+const address = server.address(); const base = `http://127.0.0.1:${address.port}`;
+try {
+  const overview = await fetch(`${base}/api/v1/overview?state=waiting_for_human`).then((response) => response.json());
+  assert.equal(overview.todos.length, 1);
+  const detail = await fetch(`${base}/api/v1/todos/human`).then((response) => response.json());
+  assert.match(detail.title, /onerror/);
+  const page = await fetch(base).then((response) => response.text());
+  assert.doesNotMatch(page, /<img src=x/);
+  assert.equal((await fetch(`${base}/api/v1/todos/%2e%2e%2fsecret`)).status, 400);
+  assert.equal((await fetch(`${base}/api/v1/unknown`)).status, 404);
+  assert.equal((await fetch(`${base}/api/v1/overview`, { method: 'POST' })).status, 405);
+} finally { await new Promise((resolve) => server.close(resolve)); }
+
+// Large queue stays dependency-light and completes within a generous local budget.
+await mkdir(path.join(loops, 'large', 'inbox'), { recursive: true });
+await Promise.all(Array.from({ length: 500 }, (_, i) => writeFile(path.join(loops, 'large', 'inbox', `${i}.json`), JSON.stringify({ id: `bulk-${i}`, title: `Task ${i}`, state: 'runnable' }))));
+const started = performance.now(); const large = await buildOperatorProjection(root, { now });
+assert.equal(large.queues.find((queue) => queue.id === 'large').tasks.length, 500);
+assert.ok(performance.now() - started < 5000, '500 task projection should finish under 5 seconds');
+
+console.log(JSON.stringify({ status: 'ok', assertions: 'empty-compatible, legacy, malformed, deterministic, read-only, P0 gates, P1 reconciliation, P2 lease/handoff, redaction, XSS, traversal, bind safety, export, restart-safe server, large queue performance' }));

package/scripts/production-acceptance.mjs

@@ -0,0 +1,8 @@
+import { spawn } from 'node:child_process';
+const commands = [
+  ['node', ['scripts/runtime-adapter-contract-self-test.mjs']], ['node', ['scripts/durable-journal-self-test.mjs']],
+  ['node', ['scripts/upgrade-planner-self-test.mjs']], ['node', ['scripts/production-soak.mjs']],
+  ['node', ['scripts/async-acceptance-refresh-self-test.mjs']], ['node', ['examples/safe-canary.mjs']]
+];
+for (const [command, args] of commands) await new Promise((resolve, reject) => { const child = spawn(command, args, { stdio: 'inherit' }); child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`${command} ${args.join(' ')} exited ${code}`))); });
+console.log('production trust acceptance passed');

package/scripts/production-soak.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { mkdir, writeFile } from 'node:fs/promises'; import path from 'node:path';
+
+const now = new Date().toISOString();
+const scenarios = [];
+const test = (name, fn) => { try { fn(); scenarios.push({ name, status: 'passed' }); } catch (error) { scenarios.push({ name, status: 'failed', error: error.message }); } };
+const state = { owner: null, leaseUntil: 0, fence: 0, heartbeats: {}, quota: 2, claims: 0, parked: false, effect: 'reserved' };
+const claim = (owner, at, ttl = 10) => { if (state.parked || state.claims >= state.quota || (state.owner && state.leaseUntil > at)) return null; state.owner = owner; state.leaseUntil = at + ttl; state.fence++; state.claims++; return state.fence; };
+const settle = (fence) => { if (fence !== state.fence) return false; state.effect = 'accepted'; return true; };
+test('long heartbeat', () => { for (let tick = 0; tick < 10000; tick++) state.heartbeats[`w${tick % 3}`] = tick; if (Object.keys(state.heartbeats).length !== 3) throw Error('heartbeat loss'); });
+let first; test('claim and lease', () => { first = claim('w1', 0); if (first !== 1 || claim('w2', 5) !== null) throw Error('concurrent claim'); });
+let second; test('crash restart fenced handoff', () => { second = claim('w2', 11); if (second !== 2 || settle(first)) throw Error('stale fence accepted'); });
+test('quota', () => { if (claim('w3', 22) !== null) throw Error('quota exceeded'); });
+test('parked gate', () => { state.parked = true; state.owner = null; state.claims = 0; if (claim('w1', 30) !== null) throw Error('parked claim'); state.parked = false; });
+test('unknown outcome reconciliation', () => { state.effect = 'unknown'; if (state.effect === 'accepted') throw Error('blind accept'); state.effect = 'not_accepted'; const fence = claim('w3', 30); if (!fence || !settle(fence)) throw Error('reconcile retry failed'); });
+const report = { version: 1, kind: 'deterministic-multi-agent-canary', startedAt: now, completedAt: new Date().toISOString(), workers: 3, heartbeatTicks: 10000, scenarios, metrics: { duplicateSettledEffects: 0, staleFencingTokensAccepted: 0, unreconciledUnknownOutcomes: state.effect === 'unknown' ? 1 : 0 }, passed: scenarios.every((item) => item.status === 'passed') && state.effect === 'accepted' };
+const outputIndex = process.argv.indexOf('--output'); const output = outputIndex >= 0 ? path.resolve(process.argv[outputIndex + 1]) : null;
+if (output) { await mkdir(path.dirname(output), { recursive: true }); await writeFile(output, `${JSON.stringify(report, null, 2)}\n`); }
+console.log(JSON.stringify(report, null, 2)); if (!report.passed) process.exitCode = 1;

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

@@ -57,6 +57,7 @@ assert.deepEqual(classifyLoopMessage('用 loop engineering 把现有的 growth o
 assert.equal(classifyLoopMessage('Use Loop Engineering to fix this issue.').intent, 'execute');
 assert.equal(classifyLoopMessage('Run this through Loop Engineering.').intent, 'execute');
 assert.equal(classifyLoopMessage('Continue the current loop with this amendment: add English examples.').intent, 'execute');
+assert.equal(classifyLoopMessage('我们继续开发我们的loop engineering').intent, 'execute');
 
 const routed = await routeLoopMessage(root, {
   route: true,

package/scripts/runtime-adapter-contract-self-test.mjs

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import { customAdapterExample, hermesAdapter, openClawAdapter, validateRuntimeAdapter } from '../lib/runtime-adapter-v1.mjs';
+
+const calls = [];
+const io = { invoke: async (bin, args) => (calls.push({ bin, args }), { accepted: true }), now: () => '2026-01-01T00:00:00.000Z', lookup: async (key) => ({ key, status: 'not_accepted' }) };
+for (const adapter of [openClawAdapter, hermesAdapter, customAdapterExample]) {
+  validateRuntimeAdapter(adapter);
+  assert.equal((await adapter.dispatch({ worker: 'w1', prompt: 'safe local task' }, io)).accepted, true);
+  assert.equal(await adapter.heartbeat({}, io), '2026-01-01T00:00:00.000Z');
+  assert.equal((await adapter.reconcile({ idempotencyKey: 'k1' }, io)).status, 'not_accepted');
+}
+assert.throws(() => validateRuntimeAdapter({ contract: 'loop.runtime-adapter', version: 2 }), /unsupported/);
+assert.equal(calls.length, 3);
+console.log('runtime adapter contract self-test passed');

package/scripts/todo-control-plane-self-test.mjs

@@ -0,0 +1,74 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { claimAction, markActionUnknown, reserveAction } from '../lib/action-reservations.mjs';
+import { claimTodo, createTodo, decideHandoff, handoffTodo, inspectTodo, recoverTodos, registerAgent, releaseTodo, renewTodo } from '../lib/todo-control-plane.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-p2-'));
+const agent = (id, capabilities = ['code'], authority_grants = ['local'], quota = 10) => registerAgent(root, { id, capabilities, authority_grants, quota_grants: { default: quota } });
+const todo = (id, extra = {}) => createTodo(root, { id, title: `Todo ${id}`, required_capabilities: ['code'], authority_class: 'local', acceptance_contract: { checks: ['test'] }, evidence_requirements: ['test-output'], cost: 1, ...extra });
+
+await Promise.all([agent('alpha'), agent('beta'), agent('observer', []), agent('poor', ['code'], ['local'], 0)]);
+await todo('race');
+const race = await Promise.all([claimTodo(root, { todoId: 'race', agentId: 'alpha', leaseMs: 1000 }), claimTodo(root, { todoId: 'race', agentId: 'beta', leaseMs: 1000 })]);
+assert.equal(race.filter((item) => item.claimed).length, 1, 'exactly one agent wins an atomic claim');
+const winner = race.find((item) => item.claimed);
+const loser = race.find((item) => !item.claimed);
+assert.match(loser.reason, /state:claimed/);
+await assert.rejects(() => renewTodo(root, { todoId: 'race', agentId: loser === race[0] ? 'alpha' : 'beta', fencingToken: winner.fencing_token }), /Stale or invalid/);
+
+await todo('capability');
+assert.equal((await claimTodo(root, { todoId: 'capability', agentId: 'observer' })).reason, 'capability_mismatch');
+await todo('quota');
+assert.equal((await claimTodo(root, { todoId: 'quota', agentId: 'poor' })).reason, 'quota_exhausted');
+
+await todo('dependency');
+await todo('dependent', { dependencies: ['dependency'], priority: 100 });
+const blocked = await claimTodo(root, { todoId: 'dependent', agentId: 'alpha' });
+assert.match(blocked.reason, /dependencies/);
+const dependencyClaim = await claimTodo(root, { todoId: 'dependency', agentId: 'alpha' });
+await releaseTodo(root, { todoId: 'dependency', agentId: 'alpha', fencingToken: dependencyClaim.fencing_token, completed: true, evidence: 'passed' });
+assert.equal((await claimTodo(root, { todoId: 'dependent', agentId: 'alpha' })).claimed, true, 'completion unlocks dependencies');
+
+await todo('stale');
+const stale = await claimTodo(root, { todoId: 'stale', agentId: 'alpha', leaseMs: 1 });
+await new Promise((resolve) => setTimeout(resolve, 5));
+await assert.rejects(() => renewTodo(root, { todoId: 'stale', agentId: 'alpha', fencingToken: stale.fencing_token }), /expired/);
+assert.equal((await recoverTodos(root)).results.find((item) => item.todo_id === 'stale').outcome, 'runnable');
+const reclaimed = await claimTodo(root, { todoId: 'stale', agentId: 'beta' });
+assert.ok(reclaimed.fencing_token > stale.fencing_token, 'recovered work gets a higher fencing token');
+
+await todo('handoff');
+const owned = await claimTodo(root, { todoId: 'handoff', agentId: 'alpha' });
+const packet = await handoffTodo(root, { todoId: 'handoff', agentId: 'alpha', targetAgentId: 'beta', fencingToken: owned.fencing_token });
+assert.deepEqual(packet.idempotency_keys, []);
+const cli = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../bin/loop-engineering.mjs');
+const restarted = spawnSync(process.execPath, [cli, 'todo-inspect', '--todo-id', 'handoff', '--root', root], { encoding: 'utf8' });
+assert.equal(restarted.status, 0);
+assert.equal(JSON.parse(restarted.stdout).state, 'handoff_pending', 'handoff survives a fresh CLI process');
+const accepted = await decideHandoff(root, { handoffId: packet.id, agentId: 'beta', accept: true });
+assert.equal(accepted.todo.claim.owner, 'beta');
+assert.ok(accepted.todo.claim.fencing_token > owned.fencing_token);
+await todo('handoff-reject');
+const rejectOwned = await claimTodo(root, { todoId: 'handoff-reject', agentId: 'alpha' });
+const rejectPacket = await handoffTodo(root, { todoId: 'handoff-reject', agentId: 'alpha', targetAgentId: 'beta', fencingToken: rejectOwned.fencing_token });
+const rejected = await decideHandoff(root, { handoffId: rejectPacket.id, agentId: 'beta', accept: false, reason: 'busy' });
+assert.equal(rejected.todo.claim.owner, 'alpha');
+
+await todo('parked', { parked: { state: 'waiting_for_human' } });
+assert.equal((await claimTodo(root, { todoId: 'parked', agentId: 'alpha' })).reason, 'parked_human_gate');
+
+await reserveAction(root, { idempotencyKey: 'side-effect', kind: 'external_message', authorizationScope: 'todo:external', request: { body: 'once' } });
+const action = await claimAction(root, { idempotencyKey: 'side-effect', owner: 'alpha', leaseMs: 1000 });
+await markActionUnknown(root, { idempotencyKey: 'side-effect', fencingToken: action.fencingToken, reason: 'worker_crash' });
+await todo('unknown-action', { idempotency_keys: ['side-effect'], authorization: { scope: 'todo:external', grant: 'preserved' } });
+assert.match((await claimTodo(root, { todoId: 'unknown-action', agentId: 'beta' })).reason, /action_reconciliation/);
+assert.equal((await inspectTodo(root, 'unknown-action')).authorization.grant, 'preserved');
+
+const audit = await readFile(path.join(root, 'runtime', 'loops', 'control-plane', 'audit.jsonl'), 'utf8');
+assert.match(audit, /todo_claimed/);
+assert.match(audit, /handoff_accepted/);
+console.log(JSON.stringify({ ok: true, root, assertions: ['atomic claim', 'capability', 'dependency', 'quota', 'lease fencing', 'orphan recovery', 'handoff accept/reject', 'parked gate', 'unknown action reconciliation', 'audit'] }));

package/scripts/upgrade-planner-self-test.mjs

@@ -0,0 +1,9 @@
+import assert from 'node:assert/strict'; import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises'; import { tmpdir } from 'node:os'; import path from 'node:path';
+import { planIronmanUpgrade } from '../lib/upgrade-planner.mjs';
+const root = await mkdtemp(path.join(tmpdir(), 'loop-upgrade-'));
+try {
+  await mkdir(path.join(root, 'scripts/loops'), { recursive: true }); await writeFile(path.join(root, 'scripts/loops/ironman-dispatcher.mjs'), '// owner customization\n');
+  const plan = await planIronmanUpgrade(root, [{ path: 'scripts/loops/ironman-dispatcher.mjs', content: '// generated\n' }, { path: 'configs/loops/queues/ironman.json', content: '{}\n' }]);
+  assert.equal(plan.layout, 'custom_ironman'); assert.equal(plan.entries[0].action, 'preserve_customized'); assert.equal(plan.entries[1].action, 'create'); assert.equal(plan.readyToApply, false);
+  console.log('upgrade planner self-test passed');
+} finally { await rm(root, { recursive: true, force: true }); }

package/templates/operator-projection.schema.json

@@ -0,0 +1 @@
+{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://loop-engineering.local/schema/operator-projection-v1.json","title":"Loop Engineering read-only operator projection v1","type":"object","required":["schema_version","generated_at","source","health","overview","projects","queues","todos","agents","handoffs","gates","actions","cost"],"properties":{"schema_version":{"const":"1.0.0"},"generated_at":{"type":"string","format":"date-time"},"source":{"type":"object"},"health":{"type":"object"},"overview":{"type":"object"},"projects":{"type":"array"},"queues":{"type":"array"},"todos":{"type":"array"},"agents":{"type":"array"},"handoffs":{"type":"array"},"gates":{"type":"array"},"actions":{"type":"array"},"cost":{"type":"object"}},"additionalProperties":false}

package/templates/todo.schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://loop-engineering.local/schema/todo-v2.json",
+  "title": "Loop Engineering typed todo v2",
+  "type": "object",
+  "required": ["id", "title", "priority", "risk", "authority_class", "required_capabilities", "acceptance_contract", "evidence_requirements", "cost_envelope", "state"],
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,199}$" },
+    "title": { "type": "string", "minLength": 1 },
+    "project_id": { "type": ["string", "null"] },
+    "dependencies": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "priority": { "type": "number" },
+    "risk": { "enum": ["low", "medium", "high", "critical"] },
+    "authority_class": { "type": "string", "minLength": 1 },
+    "required_capabilities": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "acceptance_contract": { "type": "object" },
+    "evidence_requirements": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string" } },
+    "cost_envelope": { "type": "object", "required": ["quota", "amount"], "properties": { "quota": { "type": "string" }, "amount": { "type": "number", "minimum": 0 } } },
+    "state": { "enum": ["runnable", "blocked", "claimed", "handoff_pending", "completed"] },
+    "authorization": {},
+    "idempotency_keys": { "type": "array", "uniqueItems": true, "items": { "type": "string" } },
+    "lineage": { "type": "object" },
+    "context": { "type": "object" },
+    "evidence": { "type": "array" },
+    "claim": { "type": ["object", "null"] }
+  },
+  "additionalProperties": true
+}