taskforce-loop-engineering 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+## 0.13.0 - 2026-08-14
+
+- Add versioned OpenClaw, Hermes, and custom runtime adapter contracts with a shared conformance suite.
+- Add a checksummed, fsync-backed durable journal with replay, snapshots, migration, backup/restore, and fail-closed unknown-outcome handling.
+- Add deterministic multi-worker canary and isolated live-runtime soak tooling, a credential-free demo, and a non-destructive customized-Ironman upgrade planner.
+- Add unified production-trust acceptance and an idempotent acceptance refresh command so detached long-running evidence invalidates stale final judgements.
+
 ## 0.12.0 - 2026-08-13
 
 - Add P3 read-only Operator Dashboard, normalized schema, loopback HTTP/JSON API, static export, inspect and health commands.

package/README.md

@@ -1,5 +1,14 @@
 # Taskforce Loop Engineering
 
+## 0.13 production trust
+
+The local production-trust contract, runtime adapter v1, durable journal,
+multi-worker canary, non-destructive Ironman upgrade planner, safe demo and
+unified acceptance are documented in
+[docs/production-trust-contract.md](docs/production-trust-contract.md). Run
+`npm run check:production-trust`; external publishing and deployment remain
+separately authorized actions.
+
 ## Read-only operator dashboard (P3)
 
 Version 0.12 adds a dependency-free operator projection over projects, queues, P0 gates, P1 action reservations and P2 typed todo ownership. Use `dashboard-inspect`, `dashboard-health`, `dashboard-export`, or the loopback-only `dashboard-serve`. See [docs/operator-dashboard.md](docs/operator-dashboard.md) for API, security and schema details.

package/bin/loop-engineering.mjs

@@ -37,6 +37,7 @@ import {
   mergeQueueOptions,
   nextState,
   notifyTerminalTasks,
+  refreshTaskAcceptance,
   notifyHumanInputRequests,
   parkQueueTask,
   resumeParkedTask,
@@ -1637,6 +1638,7 @@ Usage:
   loop-engineering queue-wait-tick --queue name (--notify-command "command" | --dry-run) [--now ISO] [--root <workspace>] [--json]
   loop-engineering queue-wait-resume --queue name --task-id id --verified --recovery-signal "..." [--root <workspace>] [--json]
   loop-engineering queue-terminal-notify --queue name (--notify-command "command" | --dry-run) [--root <workspace>] [--json]
+  loop-engineering queue-acceptance-refresh --queue name --task-id id [--root <workspace>] [--json]
   loop-engineering queue-scheduler-tick --queue name [--config configs/loops/queues/name.json] [--plan-only] [--force-due] [--initial-interval 10m] [--min-interval 1m] [--max-interval 4h] [--jitter 30s] [--no-progress-report] [--progress-report-interval 30m] [--progress-notify-command "command"] [--root <workspace>] [--json]
   loop-engineering queue-init --queue name [--root <workspace>] [--force]
   loop-engineering code-queue-init --queue name [--root <workspace>] [--force]
@@ -2070,6 +2072,14 @@ async function queueTerminalNotifyCommand(args) {
   return result.failed > 0 ? 1 : 0;
 }
 
+async function queueAcceptanceRefreshCommand(args) {
+  if (!args.queue || !args.taskId) throw new Error('queue-acceptance-refresh requires --queue and --task-id.');
+  const result = await refreshTaskAcceptance(args.root, args);
+  if (args.json) console.log(JSON.stringify(result, null, 2));
+  else console.log(`${result.queue}: ${result.taskId} ${result.outcome}${result.status ? ` (${result.status})` : ''}`);
+  return 0;
+}
+
 async function queueHumanInputNotifyCommand(args) {
   if (!args.queue) throw new Error('queue-human-input-notify requires --queue.');
   const result = await notifyHumanInputRequests(args.root, args);
@@ -5619,6 +5629,7 @@ async function main() {
   if (command === 'queue-wait-tick') return queueWaitTickCommand(args);
   if (command === 'queue-wait-resume') return queueWaitResumeCommand(args);
   if (command === 'queue-terminal-notify') return queueTerminalNotifyCommand(args);
+  if (command === 'queue-acceptance-refresh') return queueAcceptanceRefreshCommand(args);
   if (command === 'queue-human-input-notify') return queueHumanInputNotifyCommand(args);
   if (command === 'queue-human-input-resolve') return queueHumanInputResolveCommand(args);
   if (command === 'queue-scheduler-tick') return queueSchedulerTickCommand(args);

package/docs/production-operations.md

@@ -0,0 +1,29 @@
+# Production Trust Operations
+
+Run `npm run check:production-trust` before release review. The safe demo is
+`node examples/safe-canary.mjs`; it uses an in-memory I/O boundary, contains no
+credential, makes no paid call, and performs no external write. The soak command
+writes a local audit report when passed `--output <file>`.
+
+Back up both `events.jsonl` and `snapshot.json` before migration or upgrade.
+Restore into a new directory, replay it, compare event count/checksum and only
+then switch the configured path. Never truncate a checksum error; a malformed
+final partial line may be ignored as a torn write, while corruption elsewhere
+fails closed. Reconcile every `unknown` external outcome against the upstream
+provider before permitting a retry.
+
+Upgrade plans are read-only. A customized dispatcher/config receives
+`preserve_customized`, which is not apply-ready. Review a byte-exact backup and
+merge plan; do not use force overwrite. Publishing, real canary traffic,
+production deployment, credentials, process control and paid services require
+separate operator authorization.
+
+Support boundaries are listed in `production-trust-contract.md`. In particular,
+the custom adapter is an example/contract surface, not an operated runtime, and
+the local journal is not a distributed consensus database.
+
+When detached verification finishes after a task was judged, first write a
+successor checkpoint that revises the blocked checkpoint, then run
+`loop-engineering queue-acceptance-refresh --queue <queue> --task-id <task>`.
+The refresh runs only when a checkpoint is newer than the final judgement;
+repeated calls return `already_current` and do not re-run acceptance.

package/docs/production-trust-backlog.json

@@ -0,0 +1,13 @@
+{
+  "version": 1,
+  "project": "0.13-production-trust",
+  "terminal_contract": "production-trust-contract.md",
+  "items": [
+    {"id":"PT-1","outcome":"versioned runtime adapter contract","evidence":["lib/runtime-adapter-v1.mjs","scripts/runtime-adapter-contract-self-test.mjs"],"required":true},
+    {"id":"PT-2","outcome":"durable journal, replay, migration, backup/restore","evidence":["lib/durable-journal.mjs","scripts/durable-journal-self-test.mjs"],"required":true},
+    {"id":"PT-3","outcome":"multi-agent soak/canary report","evidence":["scripts/production-soak.mjs"],"required":true},
+    {"id":"PT-4","outcome":"non-destructive customized-layout upgrade plan","evidence":["lib/upgrade-planner.mjs","scripts/upgrade-planner-self-test.mjs"],"required":true},
+    {"id":"PT-5","outcome":"safe public demo and operations guide","evidence":["examples/safe-canary.mjs","docs/production-operations.md"],"required":true},
+    {"id":"PT-6","outcome":"unified local release acceptance","evidence":["scripts/production-acceptance.mjs"],"required":true}
+  ]
+}

package/docs/production-trust-contract.md

@@ -0,0 +1,54 @@
+# Production Trust Contract (0.13)
+
+Status: local release candidate. This contract is terminal only when every
+required item in `production-trust-backlog.json` is accepted by recorded local
+evidence. Publishing and production deployment are deliberately outside it.
+
+## Required outcomes
+
+1. Runtime adapters implement contract v1 and pass the same conformance suite.
+   OpenClaw and Hermes are supported integrations; the custom adapter is the
+   reference extension point.
+2. State mutations use a checksummed append-only journal with atomic snapshot
+   checkpoints, replay, migration from version-1 JSON state, backup and restore.
+   A committed external P1 side effect is never inferred from local intent:
+   ambiguous attempts remain `unknown` until reconciled with upstream evidence.
+3. The deterministic multi-worker canary covers heartbeat, claim, lease expiry,
+   fenced handoff, crash/restart replay, concurrent claims, quota, parked gates,
+   and unknown-outcome reconciliation and emits an auditable JSON report.
+4. Upgrade planning detects unmanaged or locally modified Ironman layouts and
+   produces a non-destructive plan. Customized dispatcher/config files are
+   preserved; application requires a separate explicit confirmation and has a
+   backup-based rollback plan.
+5. The public demo is credential-free, loopback/local-only, makes no paid call
+   or external write, and labels support boundaries.
+6. Release acceptance includes threat model, reliability/performance thresholds,
+   full regression, package dry-run, and clean-install verification.
+
+## Release thresholds
+
+- Adapter conformance: all three fixtures pass; incompatible major versions fail.
+- Journal: torn tail is ignored, checksum corruption fails closed, snapshot and
+  replay agree, backup restore agrees, migration is idempotent.
+- Canary: all scenarios pass, duplicate settled side effects = 0, stale fencing
+  tokens accepted = 0, unreconciled unknown outcomes = 0.
+- Regression: `npm run check` and `npm run check:production-trust` pass.
+- Packaging: `npm pack --dry-run` contains all contract, runtime and demo assets.
+
+## Threat model and trust boundaries
+
+Untrusted inputs include adapter responses, task JSON, journal tails, installer
+layouts, and human-gate text. Controls are schema validation, bounded strings,
+checksums, atomic rename, fencing tokens, canonical idempotency keys, path
+containment, fail-closed version negotiation, and explicit confirmation gates.
+The package does not claim Byzantine-worker protection, distributed consensus,
+or exactly-once behavior from an upstream service lacking idempotency/reconcile
+APIs. Host compromise, stolen credentials, and malicious runtime binaries remain
+operator responsibilities.
+
+## Support levels
+
+- OpenClaw: supported, contract-tested adapter and managed installer.
+- Hermes: supported, contract-tested adapter and managed installer.
+- Custom runtime: contract/example support; lifecycle is operator-owned.
+- Distributed database/HA: not provided by the local journal backend.

package/lib/core.mjs

@@ -1956,6 +1956,56 @@ export async function notifyTerminalTasks(root, options = {}) {
   };
 }
 
+export async function refreshTaskAcceptance(root, options = {}) {
+  const queue = normalizeLoopId(options.queue);
+  if (!options.taskId) throw new Error('queue-acceptance-refresh requires --task-id.');
+  await ensureQueueDirs(root, queue);
+  const located = await findTaskFile(root, queue, options.taskId);
+  if (!located) throw new Error(`Queue task not found: ${options.taskId}`);
+  const task = await readJson(located.file);
+  const dir = taskRuntimeDirFor(root, queue, task.id);
+  const checkpointsDir = path.join(dir, 'checkpoints');
+  const checkpointFiles = await listJson(checkpointsDir);
+  if (checkpointFiles.length === 0) return { queue, taskId: task.id, outcome: 'no_checkpoints' };
+  const judgementFile = path.join(dir, 'final_judgement.json');
+  const newestCheckpointMs = Math.max(...await Promise.all(checkpointFiles.map(async (file) => (await stat(path.join(checkpointsDir, file))).mtimeMs)));
+  if (await exists(judgementFile) && (await stat(judgementFile)).mtimeMs >= newestCheckpointMs) {
+    return { queue, taskId: task.id, outcome: 'already_current', judgement: path.relative(root, judgementFile) };
+  }
+
+  const contractFile = path.join(dir, 'task_contract.json');
+  const acceptanceFile = path.join(dir, 'acceptance_plan.json');
+  const devFile = path.join(dir, 'dev_plan.json');
+  const taskContract = { contract: await readJson(contractFile), file: path.relative(root, contractFile) };
+  const acceptancePlan = { plan: await readJson(acceptanceFile), file: path.relative(root, acceptanceFile) };
+  const devPlan = {
+    plan: await readJson(devFile),
+    file: path.relative(root, devFile),
+    checkpointsDir: path.relative(root, checkpointsDir),
+    reviewsDir: path.relative(root, path.join(dir, 'reviews'))
+  };
+  const checkpoints = await checkpointSummary(root, devPlan);
+  const acceptanceReviews = await writeAcceptanceReviews(root, queue, task, taskContract, acceptancePlan, devPlan);
+  const finalJudgement = await writeFinalJudgement(root, queue, task, taskContract, acceptancePlan, devPlan, checkpoints, acceptanceReviews, {
+    dispatchStatus: 'completed'
+  });
+  const status = queueStatusFromFinalJudgement('completed', finalJudgement);
+  const destinationName = status === 'completed' ? 'done' : status === 'project_in_progress' ? 'inbox' : 'failed';
+  const destination = path.join(queueSubdirFor(root, queue, destinationName), path.basename(located.file));
+  await writeJson(destination, { ...task, status: status === 'project_in_progress' ? 'queued' : status, acceptanceRefreshedAt: new Date().toISOString() });
+  if (destination !== located.file) await rm(located.file, { force: true });
+  return {
+    queue,
+    taskId: task.id,
+    outcome: 'refreshed',
+    status,
+    checkpointCount: checkpoints.count,
+    accepted: acceptanceReviews.accepted,
+    judgement: finalJudgement.file,
+    task: path.relative(root, destination)
+  };
+}
+
 function humanInputMessage(queue, task, checkpoint, gateId, language = 'en') {
   const blockers = Array.isArray(checkpoint.blockers) ? checkpoint.blockers : [];
   const blockerText = blockers.length

package/lib/durable-journal.mjs

@@ -0,0 +1,90 @@
+import { appendFile, copyFile, mkdir, open, readFile, rename, writeFile } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import path from 'node:path';
+
+const digest = (value) => createHash('sha256').update(value).digest('hex');
+const canonical = (value) => JSON.stringify(sortValue(value));
+function sortValue(value) {
+  if (Array.isArray(value)) return value.map(sortValue);
+  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortValue(value[key])]));
+  return value;
+}
+
+export class DurableJournal {
+  constructor(directory) {
+    this.directory = directory;
+    this.logFile = path.join(directory, 'events.jsonl');
+    this.snapshotFile = path.join(directory, 'snapshot.json');
+  }
+
+  async append(type, payload, transactionId = randomUUID()) {
+    await mkdir(this.directory, { recursive: true });
+    const previous = (await this.replay()).lastChecksum ?? null;
+    const event = { version: 1, transactionId, type, payload, previous };
+    event.checksum = digest(canonical(event));
+    const handle = await open(this.logFile, 'a');
+    try { await handle.write(`${JSON.stringify(event)}\n`); await handle.sync(); } finally { await handle.close(); }
+    return event;
+  }
+
+  async replay(reducer = (state, event) => ({ ...state, [event.type]: event.payload }), initial = {}) {
+    let raw = '';
+    try { raw = await readFile(this.logFile, 'utf8'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    let state = initial; let lastChecksum = null; let count = 0;
+    const lines = raw.split('\n');
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+      if (!line) continue;
+      let event;
+      try { event = JSON.parse(line); } catch (error) {
+        if (index === lines.length - 1) break;
+        throw new Error(`journal corruption at line ${index + 1}: ${error.message}`);
+      }
+      const checksum = event.checksum; const unsigned = { ...event }; delete unsigned.checksum;
+      if (digest(canonical(unsigned)) !== checksum || event.previous !== lastChecksum) throw new Error(`journal checksum chain invalid at line ${index + 1}`);
+      state = reducer(state, event); lastChecksum = checksum; count++;
+    }
+    return { state, count, lastChecksum };
+  }
+
+  async checkpoint(state) {
+    await mkdir(this.directory, { recursive: true });
+    const replay = await this.replay();
+    const snapshot = { version: 1, eventCount: replay.count, lastChecksum: replay.lastChecksum, state };
+    const temporary = `${this.snapshotFile}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(snapshot, null, 2)}\n`);
+    const handle = await open(temporary, 'r'); try { await handle.sync(); } finally { await handle.close(); }
+    await rename(temporary, this.snapshotFile);
+    return snapshot;
+  }
+
+  async backup(destination) {
+    await mkdir(destination, { recursive: true });
+    for (const name of ['events.jsonl', 'snapshot.json']) {
+      try { await copyFile(path.join(this.directory, name), path.join(destination, name)); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+  }
+
+  static async restore(backup, destination) {
+    await mkdir(destination, { recursive: true });
+    for (const name of ['events.jsonl', 'snapshot.json']) {
+      try { await copyFile(path.join(backup, name), path.join(destination, name)); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    }
+    return new DurableJournal(destination).replay();
+  }
+
+  static async migrateV1(stateFile, directory) {
+    const journal = new DurableJournal(directory);
+    if ((await journal.replay()).count) return journal;
+    const state = JSON.parse(await readFile(stateFile, 'utf8'));
+    await journal.append('legacy_state_imported', { sourceVersion: state.version, state }, 'migration-v1');
+    await journal.checkpoint(state); return journal;
+  }
+}
+
+export function externalEffectBoundary({ status, idempotencyKey, upstreamEvidence }) {
+  if (!idempotencyKey) throw new Error('external side effect requires idempotencyKey');
+  if (status === 'accepted' && !upstreamEvidence) throw new Error('accepted side effect requires upstreamEvidence');
+  if (!['reserved', 'in_flight', 'unknown', 'accepted', 'not_accepted'].includes(status)) throw new Error('invalid side effect status');
+  return { status, idempotencyKey, upstreamEvidence: upstreamEvidence ?? null, replayable: ['reserved', 'not_accepted'].includes(status) };
+}

package/lib/runtime-adapter-v1.mjs

@@ -0,0 +1,36 @@
+export const ADAPTER_CONTRACT = 'loop.runtime-adapter';
+export const ADAPTER_MAJOR = 1;
+
+function requiredFunction(adapter, name) {
+  if (typeof adapter?.[name] !== 'function') throw new Error(`adapter.${name} must be a function`);
+}
+
+export function validateRuntimeAdapter(adapter) {
+  if (adapter?.contract !== ADAPTER_CONTRACT || adapter?.version !== ADAPTER_MAJOR) {
+    throw new Error(`unsupported runtime adapter contract: ${adapter?.contract}@${adapter?.version}`);
+  }
+  if (!['openclaw', 'hermes', 'custom'].includes(adapter.runtime)) throw new Error('unsupported adapter runtime');
+  for (const name of ['dispatch', 'heartbeat', 'reconcile']) requiredFunction(adapter, name);
+  return adapter;
+}
+
+export function defineRuntimeAdapter({ runtime, dispatch, heartbeat, reconcile, capabilities = [] }) {
+  return validateRuntimeAdapter({ contract: ADAPTER_CONTRACT, version: ADAPTER_MAJOR, runtime, capabilities: [...new Set(capabilities)].sort(), dispatch, heartbeat, reconcile });
+}
+
+export const openClawAdapter = defineRuntimeAdapter({
+  runtime: 'openclaw', capabilities: ['dispatch', 'heartbeat', 'reconcile'],
+  dispatch: async (request, io) => io.invoke('openclaw', ['agent', '--agent', request.worker, '--message', request.prompt]),
+  heartbeat: async (_request, io) => io.now(), reconcile: async (request, io) => io.lookup(request.idempotencyKey)
+});
+export const hermesAdapter = defineRuntimeAdapter({
+  runtime: 'hermes', capabilities: ['dispatch', 'heartbeat', 'reconcile'],
+  dispatch: async (request, io) => io.invoke('hermes', ['-z', request.prompt]),
+  heartbeat: async (_request, io) => io.now(), reconcile: async (request, io) => io.lookup(request.idempotencyKey)
+});
+
+export const customAdapterExample = defineRuntimeAdapter({
+  runtime: 'custom', capabilities: ['dispatch', 'heartbeat', 'reconcile'],
+  dispatch: async (request, io) => io.invoke('example-runtime', [request.prompt]),
+  heartbeat: async (_request, io) => io.now(), reconcile: async (request, io) => io.lookup(request.idempotencyKey)
+});

package/lib/upgrade-planner.mjs

@@ -0,0 +1,24 @@
+import { access, readFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+const sha256 = (value) => createHash('sha256').update(value).digest('hex');
+async function exists(file) { try { await access(file); return true; } catch { return false; } }
+
+export async function planIronmanUpgrade(root, desired = []) {
+  const manifestFile = path.join(root, 'runtime', 'loop-engineering-openclaw-install.json');
+  const manifest = await exists(manifestFile) ? JSON.parse(await readFile(manifestFile, 'utf8')) : null;
+  const known = new Map((manifest?.managedFiles ?? []).map((item) => [item.path, item.sha256]));
+  const entries = [];
+  for (const item of desired) {
+    const target = path.join(root, item.path); const present = await exists(target);
+    const current = present ? await readFile(target, 'utf8') : null;
+    const managedClean = present && known.has(item.path) && known.get(item.path) === sha256(current);
+    const customized = present && !managedClean;
+    entries.push({ path: item.path, present, customized, action: !present ? 'create' : managedClean ? 'replace_managed' : 'preserve_customized', desiredSha256: sha256(item.content), currentSha256: present ? sha256(current) : null });
+  }
+  return {
+    version: 1, layout: manifest ? 'managed' : desired.some((item) => item.path.includes('ironman')) ? 'custom_ironman' : 'unmanaged',
+    readOnly: true, entries, destructive: false, readyToApply: entries.every((item) => !item.customized),
+    backupRequired: entries.some((item) => item.present), rollback: { strategy: 'restore_byte_exact_backup', requiredBeforeApply: true }
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",
@@ -17,6 +17,7 @@
     "run-loop-cron.sh": "scripts/run-loop-cron.sh"
   },
   "scripts": {
+    "check:production-trust": "node --check lib/runtime-adapter-v1.mjs && node --check lib/durable-journal.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: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",

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/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/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/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/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 }); }