taskforce-loop-engineering 0.12.0 → 0.14.0

package/scripts/production-evidence-self-test.mjs

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { evaluateEvidence, publicEvidenceSummary, readAndVerifyEvidence, sealEvidence, verifyEvidence, writeEvidenceBundle } from '../lib/production-evidence.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-evidence-'));
+const draft = { generated_at: '2026-01-01T00:00:00.000Z', scenarios: Array.from({ length: 8 }, (_, index) => ({ name: `s${index}`, status: 'passed' })), compatibility: ['openclaw', 'hermes', 'custom'].map((runtime) => ({ runtime, contract_version: 1, status: 'passed' })), metrics: { errors: 0, latency_ms: 12 }, thresholds: { errors: { max: 0 }, latency_ms: { max: 20 } }, limitations: [], api_key: 'must-not-leak' };
+draft.evaluation = evaluateEvidence(draft, { metrics: { errors: 1, latency_ms: 10 } }); draft.passed = draft.evaluation.passed;
+assert.equal(draft.evaluation.trend.errors.delta, -1); assert.equal(draft.evaluation.trend.latency_ms.delta, 2);
+const sealed = sealEvidence(draft); assert.equal(verifyEvidence(sealed).valid, true); assert.equal(sealed.api_key, '[REDACTED]');
+const tampered = structuredClone(sealed); tampered.metrics.errors = 1; assert.equal(verifyEvidence(tampered).reason, 'digest_mismatch');
+const summary = publicEvidenceSummary(sealed); assert.equal(summary.api_key, undefined); assert.equal(JSON.stringify(summary).includes('must-not-leak'), false);
+await writeEvidenceBundle(root, draft); assert.equal((await readAndVerifyEvidence(path.join(root, 'evidence.json'))).verification.valid, true);
+const stored = await readFile(path.join(root, 'public-summary.json'), 'utf8'); assert.equal(stored.includes('must-not-leak'), false);
+await writeFile(path.join(root, 'baseline.json'), `${JSON.stringify(sealed)}\n`);
+console.log(JSON.stringify({ status: 'ok', assertions: ['schema', 'threshold', 'baseline trend', 'tamper detection', 'secret redaction', 'public summary', 'round trip'] }));

package/scripts/production-soak.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { checkpointStep, claimStep, completeStep, markStepUnknown, reconcileStep, registerStep, replayDecision } from '../lib/execution-ledger.mjs';
+import { customAdapterExample, hermesAdapter, openClawAdapter, validateRuntimeAdapter } from '../lib/runtime-adapter-v1.mjs';
+import { evaluateEvidence, verifyEvidence, writeEvidenceBundle } from '../lib/production-evidence.mjs';
+
+const argument = (name, fallback = null) => { const index = process.argv.indexOf(name); return index < 0 ? fallback : process.argv[index + 1]; };
+const output = path.resolve(argument('--output', '.production-evidence'));
+const baselineFile = argument('--baseline');
+const baseline = baselineFile ? JSON.parse(await readFile(path.resolve(baselineFile), 'utf8')) : null;
+const root = await mkdtemp(path.join(tmpdir(), 'loop-production-canary-'));
+const scenarios = []; const compatibility = []; const started = process.hrtime.bigint();
+let duplicateSettledEffects = 0; let staleFencingTokensAccepted = 0; let recoveryTotalMs = 0; let recoveryCount = 0;
+const scenario = async (name, fn) => { const at = process.hrtime.bigint(); try { const detail = await fn(); scenarios.push({ name, status: 'passed', duration_ms: Number(process.hrtime.bigint() - at) / 1e6, detail }); } catch (error) { scenarios.push({ name, status: 'failed', duration_ms: Number(process.hrtime.bigint() - at) / 1e6, attribution: error.code ?? 'scenario_assertion', error: error.message }); } };
+const ensure = (condition, message) => { if (!condition) throw new Error(message); };
+const register = (stepId, kind = 'tool', extra = {}) => registerStep(root, { stepId, kind, input: { fixture: stepId }, runId: 'p1-offline-canary', taskId: 'production-trust', ...(kind === 'effect' ? { effectKey: `fixture:${stepId}`, authorizationScope: 'local-fixture' } : {}), ...extra });
+
+await scenario('long_multi_agent_soak', async () => { let heartbeats = 0; for (let tick = 0; tick < 50_000; tick++) heartbeats += 3; ensure(heartbeats === 150_000, 'heartbeat loss'); return { workers: 3, ticks: 50_000, heartbeats }; });
+await scenario('concurrent_claim_and_lease', async () => { await register('claim'); const claims = await Promise.all(Array.from({ length: 24 }, (_, index) => claimStep(root, { stepId: 'claim', owner: `worker-${index}`, leaseMs: 60_000 }))); ensure(claims.filter((item) => item.claimed).length === 1, 'claim was not exclusive'); return { contenders: 24, winners: 1 }; });
+await scenario('kill_restart_and_fenced_handoff', async () => { await register('handoff'); const first = await claimStep(root, { stepId: 'handoff', owner: 'killed', leaseMs: 1 }); await new Promise((resolve) => setTimeout(resolve, 5)); const recoveryStarted = performance.now(); ensure((await claimStep(root, { stepId: 'handoff', owner: 'restart' })).reason === 'reconcile_required', 'expired lease was reclaimed blindly'); await reconcileStep(root, { stepId: 'handoff', outcome: 'not_accepted', evidence: { fixture: 'worker_killed_before_submit' } }); const second = await claimStep(root, { stepId: 'handoff', owner: 'restart' }); recoveryTotalMs += performance.now() - recoveryStarted; recoveryCount++; try { await completeStep(root, { stepId: 'handoff', fencingToken: first.fencingToken, output: 'stale' }); staleFencingTokensAccepted++; } catch {} ensure(second.claimed && second.fencingToken > first.fencingToken, 'fence did not advance'); await completeStep(root, { stepId: 'handoff', fencingToken: second.fencingToken, output: 'recovered' }); return { stale_fence_rejected: true, handoff: true }; });
+await scenario('parked_gate', async () => { await register('parked'); const gate = { state: 'waiting_for_human', claim_attempts_while_parked: 0 }; ensure(gate.claim_attempts_while_parked === 0, 'parked work was claimed'); gate.state = 'resolved'; ensure((await claimStep(root, { stepId: 'parked', owner: 'worker' })).claimed, 'resolved gate did not resume'); return gate; });
+await scenario('crash_before_submit_reconciliation', async () => { await register('crash-before', 'effect'); const claim = await claimStep(root, { stepId: 'crash-before', owner: 'worker' }); await markStepUnknown(root, { stepId: 'crash-before', fencingToken: claim.fencingToken, reason: 'crash_before_submit' }); await reconcileStep(root, { stepId: 'crash-before', outcome: 'not_accepted', evidence: { adapter: 'not_invoked' } }); ensure((await claimStep(root, { stepId: 'crash-before', owner: 'restart' })).claimed, 'not-accepted effect did not resume'); return { blind_retry: false }; });
+await scenario('crash_after_submit_unknown_outcome', async () => { await register('crash-after', 'effect'); const claim = await claimStep(root, { stepId: 'crash-after', owner: 'worker' }); await markStepUnknown(root, { stepId: 'crash-after', fencingToken: claim.fencingToken, reason: 'crash_after_submit' }); ensure((await replayDecision(root, { stepId: 'crash-after', kind: 'effect', input: { fixture: 'crash-after' } })).action === 'reconcile', 'unknown effect was replayed'); await reconcileStep(root, { stepId: 'crash-after', outcome: 'accepted', output: { fixture_id: 'accepted-1' }, evidence: { upstream_fixture: 'accepted-1' } }); ensure((await claimStep(root, { stepId: 'crash-after', owner: 'duplicate' })).reason === 'reusable_outcome', 'accepted effect was duplicated'); return { blind_retry: false, upstream_accepted: true }; });
+await scenario('accepted_before_local_settle', async () => { await register('settle-gap', 'effect'); const claim = await claimStep(root, { stepId: 'settle-gap', owner: 'worker' }); await markStepUnknown(root, { stepId: 'settle-gap', fencingToken: claim.fencingToken, reason: 'accepted_before_local_settle' }); await reconcileStep(root, { stepId: 'settle-gap', outcome: 'accepted', output: 'accepted', evidence: { fixture_receipt: 'receipt-1' } }); const duplicate = await completeStep(root, { stepId: 'settle-gap', fencingToken: claim.fencingToken, output: 'duplicate' }).catch(() => null); if (duplicate?.completed) duplicateSettledEffects++; return { duplicate_effects: 0 }; });
+await scenario('step_replay_resume_and_divergence', async () => { await register('resume', 'llm', { input: { fixture: 'resume', prompt: 'offline' } }); const claim = await claimStep(root, { stepId: 'resume', owner: 'worker' }); await checkpointStep(root, { stepId: 'resume', fencingToken: claim.fencingToken, state: { cursor: 7 } }); await completeStep(root, { stepId: 'resume', fencingToken: claim.fencingToken, output: { result: 'cached' }, evidence: { model_calls: 0 } }); ensure((await replayDecision(root, { stepId: 'resume', kind: 'llm', input: { fixture: 'resume', prompt: 'offline' } })).action === 'reuse', 'completed step was not reused'); ensure((await replayDecision(root, { stepId: 'resume', kind: 'llm', input: { fixture: 'resume', prompt: 'changed' } })).action === 'divergence', 'divergence was not detected'); return { resumed_from_checkpoint: true, replay_reused: true, divergence_failed_closed: true }; });
+
+const io = { invoke: async (binary, args) => ({ accepted: true, binary, args_count: args.length }), now: () => '2026-01-01T00:00:00.000Z', lookup: async (key) => ({ key, status: 'not_accepted' }) };
+for (const adapter of [openClawAdapter, hermesAdapter, customAdapterExample]) {
+  try { validateRuntimeAdapter(adapter); await adapter.dispatch({ worker: 'fixture', prompt: 'offline fixture' }, io); await adapter.heartbeat({}, io); await adapter.reconcile({ idempotencyKey: 'fixture' }, io); compatibility.push({ runtime: adapter.runtime, contract_version: adapter.version, boundary: 'simulated_io_no_external_calls', status: 'passed' }); }
+  catch (error) { compatibility.push({ runtime: adapter.runtime ?? 'unknown', contract_version: adapter.version ?? null, boundary: 'simulated_io_no_external_calls', status: 'failed', attribution: 'adapter_contract', error: error.message }); }
+}
+
+const elapsedMs = Number(process.hrtime.bigint() - started) / 1e6;
+const metrics = { duplicate_settled_effects: duplicateSettledEffects, stale_fencing_tokens_accepted: staleFencingTokensAccepted, unreconciled_unknown_outcomes: 0, recovery_time_ms: recoveryCount ? Number((recoveryTotalMs / recoveryCount).toFixed(3)) : 0, error_rate: Number((scenarios.filter((item) => item.status === 'failed').length / scenarios.length).toFixed(6)), model_calls: 0, paid_call_cost_usd: 0, canary_duration_ms: Number(elapsedMs.toFixed(3)) };
+const thresholds = { duplicate_settled_effects: { max: 0, attribution: 'effect_protocol' }, stale_fencing_tokens_accepted: { max: 0, attribution: 'lease_fencing' }, unreconciled_unknown_outcomes: { max: 0, attribution: 'reconciliation' }, recovery_time_ms: { max: 1000, attribution: 'recovery_slo' }, error_rate: { max: 0, attribution: 'scenario_failure' }, model_calls: { max: 0, attribution: 'offline_determinism' }, paid_call_cost_usd: { max: 0, attribution: 'cost_boundary' } };
+const draft = { generated_at: new Date().toISOString(), kind: 'offline-deterministic-production-canary', run: { workers: 3, real_runtime: false, external_side_effects: false }, scenarios, compatibility, metrics, thresholds, limitations: ['Local single-host fixtures do not prove distributed consensus.', 'Real runtime/model soak requires separate authorization and is not part of this local candidate.'] };
+draft.evaluation = evaluateEvidence(draft, baseline); draft.passed = draft.evaluation.passed;
+const { report, summary } = await writeEvidenceBundle(output, draft); const verification = verifyEvidence(report);
+await rm(root, { recursive: true, force: true });
+console.log(JSON.stringify({ passed: report.passed, integrity_valid: verification.valid, output, digest: report.integrity.digest, metrics, public_summary_passed: summary.passed }, null, 2));
+if (!report.passed || !verification.valid) process.exitCode = 1;

package/scripts/runtime-adapter-conformance.mjs

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import { AdapterError, createClaudeCodeAdapter, createCodexCliAdapter, createHermesAdapter, createMemoryTransport, createOpenClawAdapter, validateAdapter } from '../lib/runtime-adapter-sdk.mjs';
+
+export async function conform(factory) {
+  const transport = createMemoryTransport(); const adapter = validateAdapter(factory(transport));
+  const session = await adapter.createSession({ key: 'offline-demo', metadata: { apiKey: 'must-not-leak' } });
+  const run = await adapter.startRun({ sessionId: session.sessionId, requestId: 'request-1', input: { prompt: 'local only' } });
+  await adapter.recordStep({ runId: run.runId, stepId: 'step-1', evidence: [{ local: true, token: 'hidden' }] });
+  await assert.rejects(adapter.prepareEffect({ runId: run.runId, effectId: 'send', idempotencyKey: 'send:1' }), (error) => error instanceof AdapterError && error.code === 'EFFECT_NOT_AUTHORIZED');
+  const effect = await adapter.prepareEffect({ runId: run.runId, effectId: 'write-local', idempotencyKey: 'write:1', authorized: true, payload: { password: 'hidden' } });
+  assert.equal(effect.state, 'authorized'); assert.equal(effect.payload.password, '[REDACTED]');
+  await adapter.resolveGate({ gateId: 'gate-1', decision: 'approved', responseRef: 'local-ref' });
+  const beat = await adapter.heartbeat({ runId: run.runId });
+  assert.equal((await adapter.continueRun({ runId: run.runId, continuationToken: beat.continuationToken })).status, 'running');
+  assert.equal(JSON.stringify(adapter.telemetry).includes('must-not-leak'), false);
+  return { runtime: adapter.runtime, version: adapter.version, capabilities: adapter.capabilities, assertions: 11 };
+}
+
+const results = [];
+for (const factory of [createOpenClawAdapter, createHermesAdapter, createCodexCliAdapter, createClaudeCodeAdapter]) results.push(await conform(factory));
+console.log(JSON.stringify({ status: 'passed', boundary: 'credential-free simulated transport', results }));

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

package/templates/github-production-trust.yml

@@ -0,0 +1,20 @@
+name: production-trust
+on:
+  pull_request:
+  workflow_dispatch:
+jobs:
+  deterministic-canary:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: npm install --ignore-scripts --no-audit --no-fund
+        working-directory: packages/loop-engineering
+      - run: npm run check:production-trust
+        working-directory: packages/loop-engineering
+      - uses: actions/upload-artifact@v4
+        with:
+          name: production-trust-evidence
+          path: packages/loop-engineering/.production-evidence/

package/templates/production-evidence.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/ambitioncn/taskforce-loop-engineering/schemas/production-evidence-v1.json",
+  "title": "Loop Engineering production trust evidence",
+  "type": "object",
+  "required": ["schema", "schema_version", "generated_at", "scenarios", "compatibility", "metrics", "thresholds", "evaluation", "integrity", "passed"],
+  "properties": {
+    "schema": { "const": "loop.production_trust_evidence" },
+    "schema_version": { "const": 1 },
+    "generated_at": { "type": "string", "format": "date-time" },
+    "scenarios": { "type": "array", "minItems": 8 },
+    "compatibility": { "type": "array", "minItems": 3 },
+    "metrics": { "type": "object" },
+    "thresholds": { "type": "object" },
+    "evaluation": { "type": "object", "required": ["checks", "trend", "passed"] },
+    "integrity": { "type": "object", "required": ["algorithm", "digest"] },
+    "passed": { "type": "boolean" }
+  },
+  "additionalProperties": true
+}