taskforce-loop-engineering 0.15.10 → 0.15.11

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.15.11 - 2026-08-28
+
+- Add a transactional state kernel with typed effects, receipt chaining, CAS/fencing, exact-effect replay, crash recovery, and completion fencing.
+- Add the public Goal API and five-command primary CLI while preserving advanced commands.
+- Add public CI and seven competitive acceptance fixtures.
+
 ## 0.15.10 - 2026-08-28
 
 - Materialize human-input gates only for permissions or external conditions that are explicitly missing and needed now; preserve authorized, consumed, future, and conditional boundaries as audit context instead of repeatedly blocking project progress.

package/MIGRATING.md

@@ -1,5 +1,9 @@
 # Migrating to Taskforce Loop Engineering 0.12.0
 
+## Goal API and primary CLI
+
+The five-command Goal interface is additive. Existing advanced commands and artifact formats are not removed or automatically rewritten. New integrations should prefer `init/run/status/review/doctor --id`; existing integrations may migrate incrementally. See `docs/transactional-kernel-and-goal-api.md`.
+
 ## Operator projection
 
 No runtime artifact migration is required. P3 reads P0/P1/P2 and legacy queue/project artifacts in place and emits projection schema `1.0.0`; existing writers remain authoritative. Consumers should use `schema_version`, tolerate additive fields, and treat degraded health as a refresh/investigation signal. `dashboard-serve` is loopback-only unless `--allow-non-loopback` is explicit.

package/README.md

@@ -1,5 +1,19 @@
 # Taskforce Loop Engineering
 
+## Primary Goal interface
+
+The ordinary public surface is `init`, `run`, `status`, `review`, and `doctor`:
+
+```sh
+loop-engineering init --id demo --goal "Deliver the complete verified result"
+loop-engineering run --id demo
+loop-engineering status --id demo
+loop-engineering review --id demo --decision revise --reason "change strategy"
+loop-engineering doctor --id demo
+```
+
+Node.js callers can use `Goal.init/run/status/review/doctor`. Existing queue, project, revision, human-gate, reservation, dashboard, and worktree commands remain supported as advanced commands. See [the transactional kernel and migration guide](docs/transactional-kernel-and-goal-api.md).
+
 [![production trust](https://github.com/ambitioncn/taskforce-loop-engineering/actions/workflows/production-trust.yml/badge.svg)](https://github.com/ambitioncn/taskforce-loop-engineering/actions/workflows/production-trust.yml)
 
 ## Platform-neutral adapter SDK

package/bin/loop-engineering.mjs

@@ -100,6 +100,7 @@ import {
   exportDashboard,
   filterProjection
 } from '../lib/operator-dashboard.mjs';
+import { doctorGoal, initGoal, reviewGoal, runGoal, statusGoal } from '../lib/goal-api.mjs';
 
 function parseArgs(argv) {
   const args = { _: [], root: process.cwd(), json: false, force: false };
@@ -1605,9 +1606,16 @@ async function writeRevisionDriftAllowTemplateOutput(root, template, output, opt
   return { file: path.relative(root, outputFile), format: 'json' };
 }
 
-const HELP = `loop-engineering - verifiable agent work loops
+const HELP = `loop-engineering - durable Goal loops
 
 Usage:
+  loop-engineering init --id goal-id --goal "Terminal goal" [--root <workspace>] [--json]
+  loop-engineering run --id goal-id [--root <workspace>] [--json]
+  loop-engineering status --id goal-id [--root <workspace>] [--json]
+  loop-engineering review --id goal-id --decision accept|revise|wait [--reason text] [--root <workspace>] [--json]
+  loop-engineering doctor [--id goal-id] [--root <workspace>] [--json]
+
+Advanced compatibility commands:
   loop-engineering init [--root <workspace>] [--force]
   loop-engineering run --config configs/loops/name.json [--root <workspace>] [--json]
   loop-engineering verify [--config configs/loops/name.json] [--root <workspace>]
@@ -1694,6 +1702,11 @@ Exit codes:
   1 invalid spec, command error outside a check, or runtime failure`;
 
 async function runCommand(args) {
+  if (args.id && !args.config) {
+    const result = await runGoal(args.root, args.id, { triggerId: args.sourceMessageId ?? 'manual' });
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+  }
   if (!args.config) throw new Error('run requires --config.');
   const root = args.root;
   const { spec, file: specPath } = await loadSpec(root, args.config);
@@ -1787,6 +1800,10 @@ async function verifyCommand(args) {
 }
 
 async function statusCommand(args) {
+  if (args.id && !args.config) {
+    console.log(JSON.stringify(await statusGoal(args.root, args.id), null, 2));
+    return 0;
+  }
   const files = await configFilesFromArgs(args.root, args.config ? ['--config', args.config] : []);
   if (files.length === 0) throw new Error('No loop configs found.');
   const reports = [];
@@ -1854,6 +1871,11 @@ async function summarizeCommand(args) {
 }
 
 async function doctorCommand(args) {
+  if (args.id) {
+    const report = await doctorGoal(args.root, args.id);
+    console.log(JSON.stringify(report, null, 2));
+    return report.ok ? 0 : 1;
+  }
   const report = await doctorReport(args.root, { limit: args.limit ?? 10 });
   if (args.json) {
     console.log(JSON.stringify(report, null, 2));
@@ -1897,12 +1919,28 @@ async function repairPlanCommand(args) {
 }
 
 async function initCommand(args) {
+  if (args.id || args.goal) {
+    if (!args.id || !args.goal) throw new Error('Goal init requires both --id and --goal.');
+    console.log(JSON.stringify(await initGoal(args.root, { id: args.id, goal: args.goal }), null, 2));
+    return 0;
+  }
   const config = await initWorkspace(args.root, { force: args.force });
   console.log(`initialized loop engineering at ${args.root}`);
   console.log(`config: ${config}`);
   return 0;
 }
 
+async function reviewCommand(args) {
+  if (!args.id) throw new Error('review requires --id.');
+  const result = await reviewGoal(args.root, args.id, {
+    decision: args.decision,
+    reason: args.reason ?? args.comment ?? '',
+    revision: args.revision ?? 0
+  });
+  console.log(JSON.stringify(result, null, 2));
+  return 0;
+}
+
 async function queueInitCommand(args) {
   if (!args.queue) throw new Error('queue-init requires --queue.');
   const config = await initQueueConfig(args.root, args.queue, { force: args.force });
@@ -5611,6 +5649,7 @@ async function main() {
   if (command === 'run') return runCommand(args);
   if (command === 'verify') return verifyCommand(args);
   if (command === 'status') return statusCommand(args);
+  if (command === 'review') return reviewCommand(args);
   if (command === 'summarize') return summarizeCommand(args);
   if (command === 'doctor') return doctorCommand(args);
   if (command.startsWith('dashboard-')) return dashboardCommand(command, args);

package/docs/transactional-kernel-and-goal-api.md

@@ -0,0 +1,25 @@
+# Transactional kernel and Goal API
+
+The public API is `Goal.init`, `Goal.run`, `Goal.status`, `Goal.review`, and `Goal.doctor` from `lib/goal-api.mjs`. The matching primary CLI is:
+
+```sh
+loop-engineering init --id demo --goal "Ship the complete verified result"
+loop-engineering run --id demo
+loop-engineering status --id demo
+loop-engineering review --id demo --decision revise --reason "change strategy"
+loop-engineering doctor --id demo
+```
+
+## Transaction model
+
+Every mutation enters `TransactionalStateKernel.transact` with typed effects. Writers hold an exclusive lease, receive a monotonically increasing fencing token, and may provide `expectedGeneration` for compare-and-swap. Each new effect produces a receipt containing its digest and the previous receipt hash. State records the receipt head and exact effect keys, so replay applies the same logical effect zero or one times.
+
+Completion is fenced. Its validator must accept the complete terminal contract; a successful milestone alone cannot set `completed`. Human gates, revisions, action reservations, evidence, and completion are effect types rather than replacement state machines, so existing queue and reservation artifacts remain compatible.
+
+External adapters must use the effect key as their upstream idempotency key. For uncertain provider outcomes, reconcile that key before retrying; do not invent a new effect key.
+
+## Compatibility and migration
+
+All pre-0.16 advanced commands remain available. Existing `run --config`, `status --config`, queue, project, action-reservation, revision, human-gate, dashboard, and code-worktree commands retain their behavior.
+
+The five-command surface is additive. Keep existing automation unchanged, create new goals through `init --id --goal`, use `run/status/review/doctor --id` ordinarily, and retain advanced commands for administration and diagnostics. No automatic migration rewrites legacy state. Adapters may project terminal contracts, revision lineage, human gates, and action reservations as typed effects while keeping authoritative legacy artifacts intact.

package/lib/goal-api.mjs

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { TransactionalStateKernel } from './transactional-state-kernel.mjs';
+
+const goalDir = (root, id) => path.join(root, 'runtime', 'loops', 'goals', id);
+const requireId = (id) => {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(id ?? '')) throw new Error('Goal id is invalid.');
+  return id;
+};
+
+export async function initGoal(root, input) {
+  const id = requireId(input.id);
+  if (typeof input.goal !== 'string' || input.goal.trim().length < 8) throw new Error('Goal must be a meaningful string.');
+  const directory = goalDir(root, id); await mkdir(directory, { recursive: true });
+  const contract = { version: 1, id, goal: input.goal, terminal_contract: input.terminalContract ?? null, created_at: new Date().toISOString() };
+  const file = path.join(directory, 'goal.json');
+  await writeFile(file, `${JSON.stringify(contract, null, 2)}\n`, { flag: 'wx' }).catch((error) => { if (error.code !== 'EEXIST') throw error; });
+  return statusGoal(root, id);
+}
+
+export async function statusGoal(root, id) {
+  requireId(id); const directory = goalDir(root, id);
+  const contract = JSON.parse(await readFile(path.join(directory, 'goal.json'), 'utf8'));
+  const kernel = new TransactionalStateKernel(path.join(directory, 'kernel'));
+  return { contract, runtime: await kernel.inspect(), receipt_chain: await kernel.verifyReceiptChain() };
+}
+
+export async function runGoal(root, id, input = {}) {
+  requireId(id); const directory = goalDir(root, id);
+  await readFile(path.join(directory, 'goal.json'), 'utf8');
+  const kernel = new TransactionalStateKernel(path.join(directory, 'kernel'));
+  return kernel.transact({
+    expectedGeneration: input.expectedGeneration,
+    effects: input.effects ?? [{ type: 'state_transition', key: `run:${input.triggerId ?? 'manual'}`, payload: { trigger: input.triggerId ?? 'manual' } }],
+    status: input.status ?? 'running',
+    reduce: input.reduce ?? ((state, effects) => ({ ...state, last_effects: effects.map((item) => item.key) })),
+    complete: input.complete
+  });
+}
+
+export async function reviewGoal(root, id, review) {
+  if (!['accept', 'revise', 'wait'].includes(review.decision)) throw new Error('Review decision must be accept, revise, or wait.');
+  return runGoal(root, id, {
+    expectedGeneration: review.expectedGeneration,
+    effects: [{
+      type: review.decision === 'wait' ? 'human_gate' : review.decision === 'revise' ? 'revision' : 'evidence',
+      key: review.key ?? `review:${review.decision}:${review.revision ?? 0}`,
+      payload: review
+    }],
+    status: review.decision === 'wait' ? 'waiting_for_human' : review.decision === 'revise' ? 'revision_pending' : 'accepted'
+  });
+}
+
+export async function doctorGoal(root, id) {
+  try { const status = await statusGoal(root, id); return { ok: true, id, generation: status.runtime.generation, receipt_chain: status.receipt_chain }; }
+  catch (error) { return { ok: false, id, error: error.message }; }
+}
+
+export const Goal = Object.freeze({ init: initGoal, run: runGoal, status: statusGoal, review: reviewGoal, doctor: doctorGoal });

package/lib/transactional-state-kernel.mjs

@@ -0,0 +1,158 @@
+import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import path from 'node:path';
+
+export const EFFECT_TYPES = Object.freeze([
+  'state_transition', 'human_gate', 'revision', 'action_reservation',
+  'external_action', 'evidence', 'completion'
+]);
+
+const allowedTypes = new Set(EFFECT_TYPES);
+const canonical = (value) => JSON.stringify(sort(value));
+const hash = (value) => createHash('sha256').update(value).digest('hex');
+function sort(value) {
+  if (Array.isArray(value)) return value.map(sort);
+  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sort(value[key])]));
+  return value;
+}
+
+async function readJson(file, fallback = null) {
+  try { return JSON.parse(await readFile(file, 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return fallback; throw error; }
+}
+
+async function atomicWrite(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { flag: 'wx' });
+  await rename(temporary, file);
+}
+
+export function typedEffect(type, payload, options = {}) {
+  if (!allowedTypes.has(type)) throw new Error(`Unsupported effect type: ${type}`);
+  if (payload === undefined) throw new Error('Effect payload is required.');
+  const effect = {
+    version: 1,
+    type,
+    key: options.key ?? hash(canonical({ type, payload })),
+    payload: sort(payload)
+  };
+  effect.digest = hash(canonical(effect));
+  return Object.freeze(effect);
+}
+
+export class TransactionalStateKernel {
+  constructor(directory) {
+    this.directory = directory;
+    this.stateFile = path.join(directory, 'state.json');
+    this.receiptFile = path.join(directory, 'receipts.jsonl');
+    this.lockFile = path.join(directory, 'writer.lock');
+  }
+
+  async inspect() {
+    return await readJson(this.stateFile, {
+      version: 1, generation: 0, fencing_token: 0, status: 'initialized',
+      state: {}, applied_effects: {}, receipts: [], last_receipt: null, completion: null
+    });
+  }
+
+  async acquire(owner = `pid:${process.pid}`) {
+    await mkdir(this.directory, { recursive: true });
+    let handle;
+    try { handle = await open(this.lockFile, 'wx'); }
+    catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+      const stale = await readJson(this.lockFile, null);
+      const pid = Number(String(stale?.owner ?? '').match(/^pid:(\d+)$/)?.[1]);
+      let alive = Number.isInteger(pid) && pid > 0;
+      if (alive) { try { process.kill(pid, 0); } catch (probe) { if (probe.code === 'ESRCH') alive = false; else throw probe; } }
+      if (alive || !pid) throw new Error('Transactional writer lease is active or has an unverifiable owner.');
+      await rm(this.lockFile, { force: true });
+      handle = await open(this.lockFile, 'wx');
+    }
+    const current = await this.inspect();
+    const lease = { owner, fencingToken: current.fencing_token + 1, generation: current.generation, handle };
+    await handle.writeFile(JSON.stringify({ owner, fencing_token: lease.fencingToken }));
+    return lease;
+  }
+
+  async release(lease) {
+    await lease.handle.close();
+    await rm(this.lockFile, { force: true });
+  }
+
+  async transact(input) {
+    const lease = input.lease ?? await this.acquire(input.owner);
+    const owned = !input.lease;
+    try {
+      const current = await this.inspect();
+      if (lease.fencingToken <= current.fencing_token) throw new Error('Stale fencing token.');
+      if (input.expectedGeneration !== undefined && input.expectedGeneration !== current.generation) {
+        throw new Error(`CAS generation mismatch: expected ${input.expectedGeneration}, actual ${current.generation}.`);
+      }
+      const effects = (input.effects ?? []).map((effect) => typedEffect(effect.type, effect.payload, { key: effect.key }));
+      const fresh = effects.filter((effect) => !current.applied_effects[effect.key]);
+      const nextState = input.reduce ? await input.reduce(structuredClone(current.state), fresh) : current.state;
+      const next = {
+        ...current,
+        generation: current.generation + 1,
+        fencing_token: lease.fencingToken,
+        status: input.status ?? current.status,
+        state: nextState,
+        applied_effects: { ...current.applied_effects },
+        updated_at: new Date().toISOString()
+      };
+      const receipts = [];
+      let previous = current.last_receipt;
+      for (const effect of fresh) {
+        const receipt = {
+          version: 1, transaction_id: input.transactionId ?? randomUUID(),
+          generation: next.generation, fencing_token: lease.fencingToken,
+          effect_key: effect.key, effect_digest: effect.digest, effect_type: effect.type,
+          previous, created_at: new Date().toISOString()
+        };
+        receipt.receipt = hash(canonical(receipt));
+        previous = receipt.receipt;
+        next.applied_effects[effect.key] = { receipt: receipt.receipt, generation: next.generation, effect };
+        receipts.push(receipt);
+      }
+      next.last_receipt = previous;
+      next.receipts = [...(current.receipts ?? []), ...receipts];
+      if (input.complete) {
+        const verdict = await input.complete.validate({ current, next, freshEffects: fresh });
+        if (!verdict?.ok) throw new Error(`Completion fence rejected: ${verdict?.reason ?? 'validation failed'}`);
+        next.status = 'completed';
+        next.completion = { fenced_at_generation: next.generation, evidence: verdict.evidence ?? [], terminal_contract: input.complete.terminalContract ?? null };
+      }
+      await atomicWrite(this.stateFile, next);
+      if (receipts.length) await writeFile(this.receiptFile, receipts.map((item) => JSON.stringify(item)).join('\n') + '\n', { flag: 'a' });
+      return { state: next, receipts, replayed: effects.length - fresh.length };
+    } finally { if (owned) await this.release(lease); }
+  }
+
+  async replayEffect(effect, execute) {
+    const normalized = typedEffect(effect.type, effect.payload, { key: effect.key });
+    const current = await this.inspect();
+    const existing = current.applied_effects[normalized.key];
+    if (existing) return { executed: false, replayed: true, receipt: existing.receipt };
+    const outcome = await execute(normalized);
+    const committed = await this.transact({
+      expectedGeneration: current.generation,
+      effects: [normalized],
+      reduce: (state) => ({ ...state, effect_outcomes: { ...(state.effect_outcomes ?? {}), [normalized.key]: outcome } })
+    });
+    return { executed: true, replayed: false, outcome, receipt: committed.receipts[0]?.receipt };
+  }
+
+  async verifyReceiptChain() {
+    const state = await this.inspect();
+    let previous = null; let count = 0;
+    for (const item of state.receipts ?? []) {
+      const claimed = item.receipt; const unsigned = { ...item }; delete unsigned.receipt;
+      if (item.previous !== previous || hash(canonical(unsigned)) !== claimed) throw new Error(`Receipt chain invalid at ${count + 1}.`);
+      previous = claimed; count++;
+    }
+    if (state.last_receipt !== previous) throw new Error('Receipt head does not match state.');
+    return { ok: true, count, head: previous };
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskforce-loop-engineering",
-  "version": "0.15.10",
+  "version": "0.15.11",
   "private": false,
   "description": "OpenClaw-native loop engineering CLI, templates, and skill for verifiable agent work loops.",
   "type": "module",
@@ -17,6 +17,8 @@
     "run-loop-cron.sh": "scripts/run-loop-cron.sh"
   },
   "scripts": {
+    "test": "npm run check && npm run check:competitive",
+    "check:competitive": "node --check lib/transactional-state-kernel.mjs && node --check lib/goal-api.mjs && node scripts/competitive-acceptance.mjs",
     "check:adapters": "node --check lib/runtime-adapter-sdk.mjs && node scripts/runtime-adapter-conformance.mjs",
     "demo:adapter": "node examples/adapter-sdk-demo.mjs",
     "check:production-trust": "node --check lib/runtime-adapter-v1.mjs && node --check lib/durable-journal.mjs && node --check lib/execution-ledger.mjs && node --check lib/production-evidence.mjs && node --check lib/upgrade-planner.mjs && node scripts/production-acceptance.mjs",
@@ -27,6 +29,12 @@
     "check": "npm run check:config-drift && npm run check:openclaw-install && npm run check:hermes-install && node --check bin/loop-engineering.mjs && node --check lib/core.mjs && node --check lib/action-reservations.mjs && node --check lib/todo-control-plane.mjs && node --check lib/operator-dashboard.mjs && node scripts/action-reservation-self-test.mjs && node scripts/todo-control-plane-self-test.mjs && node scripts/operator-dashboard-self-test.mjs && node scripts/final-judgement-self-test.mjs && node scripts/route-notify-self-test.mjs && node scripts/scheduler-heartbeat-self-test.mjs && node scripts/human-gate-lifecycle-v2-self-test.mjs && node bin/loop-engineering.mjs verify --config templates/workspace-health.json --root . && node bin/loop-engineering.mjs queue-status --queue smoke --root . --json >/dev/null && node bin/loop-engineering.mjs project-intake --root /tmp/loop-engineering-check --name smoke-project --brief \"Build a small website project\" --type auto --check \"npm test\" --json >/dev/null && node bin/loop-engineering.mjs project-plan --root /tmp/loop-engineering-check --project smoke-project --force --json >/dev/null && node bin/loop-engineering.mjs project-status --root /tmp/loop-engineering-check --project smoke-project --json >/dev/null && node bin/loop-engineering.mjs queue-scheduler-tick --queue smoke --root /tmp/loop-engineering-check --plan-only --force-due --json >/dev/null && node bin/loop-engineering.mjs queue-scheduler-tick --queue smoke-progress --root /tmp/loop-engineering-check --plan-only --force-due --progress-report --progress-report-when-not-due --json >/dev/null && node bin/loop-engineering.mjs workflow-metrics --queue smoke --root . --json >/dev/null && node bin/loop-engineering.mjs workflow-tune-plan --queue smoke --root . --json >/dev/null && node bin/loop-engineering.mjs code-queue-init --queue smoke-code --root /tmp/loop-engineering-check --force >/dev/null && node bin/loop-engineering.mjs code-worktree-list --queue smoke-code --root /tmp/loop-engineering-check --json >/dev/null && node bin/loop-engineering.mjs code-task-status --queue smoke-code --root /tmp/loop-engineering-check --json >/dev/null && node bin/loop-engineering.mjs code-task-dashboard --queue smoke-code --root /tmp/loop-engineering-check --json >/dev/null && node bin/loop-engineering.mjs code-worktree-cleanup-plan --queue smoke-code --root /tmp/loop-engineering-check --json >/dev/null && node bin/loop-engineering.mjs code-worktree-cleanup --queue smoke-code --root /tmp/loop-engineering-check --confirm-cleanup --json >/dev/null && node bin/loop-engineering.mjs code-patch-verify --patch README.md --root . --json >/dev/null && node bin/loop-engineering.mjs code-patch-apply-plan --patch README.md --json >/dev/null && node bin/loop-engineering.mjs queue-revision-ci-self-test --queue smoke-ci --root /tmp/loop-engineering-check --json >/dev/null && node bin/loop-engineering.mjs summarize --root . --json >/dev/null && node bin/loop-engineering.mjs dashboard-health --root . --max-age-seconds 999999999 --json >/dev/null && node bin/loop-engineering.mjs doctor --root . --json >/dev/null",
     "pack:dry": "npm pack --dry-run"
   },
+  "exports": {
+    ".": "./lib/goal-api.mjs",
+    "./goal": "./lib/goal-api.mjs",
+    "./transactional-kernel": "./lib/transactional-state-kernel.mjs",
+    "./runtime-adapter-sdk": "./lib/runtime-adapter-sdk.mjs"
+  },
   "engines": {
     "node": ">=22"
   },

package/scripts/competitive-acceptance.mjs

@@ -0,0 +1,65 @@
+import assert from 'node:assert/strict';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { Goal, initGoal, reviewGoal, runGoal, statusGoal } from '../lib/goal-api.mjs';
+import { TransactionalStateKernel } from '../lib/transactional-state-kernel.mjs';
+
+const root = await mkdtemp(path.join(tmpdir(), 'loop-competitive-'));
+const results = [];
+const fixture = async (id, run) => { try { await run(); results.push({ id, ok: true }); } catch (error) { results.push({ id, ok: false, error: error.message }); } };
+
+await fixture('crash_recovery', async () => {
+  await initGoal(root, { id: 'crash', goal: 'Recover durable progress after process interruption.' });
+  await runGoal(root, 'crash', { triggerId: 'before-crash' });
+  const kernelDir = path.join(root, 'runtime', 'loops', 'goals', 'crash', 'kernel');
+  await rm(path.join(kernelDir, 'receipts.jsonl'), { force: true });
+  await mkdir(kernelDir, { recursive: true });
+  await writeFile(path.join(kernelDir, 'writer.lock'), JSON.stringify({ owner: 'pid:2147483647' }));
+  await runGoal(root, 'crash', { triggerId: 'after-crash' });
+  const reopened = await statusGoal(root, 'crash');
+  assert.equal(reopened.runtime.generation, 2); assert.equal(reopened.receipt_chain.ok, true);
+});
+await fixture('duplicate_trigger', async () => {
+  await initGoal(root, { id: 'duplicate', goal: 'Apply each duplicate trigger at most once.' });
+  await runGoal(root, 'duplicate', { triggerId: 'same' });
+  const duplicate = await runGoal(root, 'duplicate', { triggerId: 'same' });
+  assert.equal(duplicate.replayed, 1); assert.equal(duplicate.receipts.length, 0);
+});
+await fixture('human_wait_resume', async () => {
+  await initGoal(root, { id: 'human', goal: 'Wait for and resume from a human decision.' });
+  await reviewGoal(root, 'human', { decision: 'wait', key: 'gate:1', reason: 'choose' });
+  assert.equal((await statusGoal(root, 'human')).runtime.status, 'waiting_for_human');
+  await reviewGoal(root, 'human', { decision: 'accept', key: 'gate:1:resume' });
+  assert.equal((await statusGoal(root, 'human')).runtime.status, 'accepted');
+});
+await fixture('standing_authorization', async () => {
+  await initGoal(root, { id: 'standing', goal: 'Respect bounded standing authorization scopes.' });
+  const result = await runGoal(root, 'standing', { effects: [{ type: 'action_reservation', key: 'auth:deploy:1', payload: { authorization: { kind: 'standing', scope: 'staging', limit: 1 }, action: 'deploy' } }] });
+  assert.equal(result.receipts[0].effect_type, 'action_reservation');
+  assert.equal(result.state.applied_effects['auth:deploy:1'].effect.payload.authorization.scope, 'staging');
+});
+await fixture('idempotent_external_action', async () => {
+  const kernel = new TransactionalStateKernel(path.join(root, 'external-kernel')); let calls = 0;
+  const effect = { type: 'external_action', key: 'provider:request-1', payload: { idempotency_key: 'request-1' } };
+  const execute = ({ key }) => { calls++; return { accepted: true, upstream_key: key }; };
+  await kernel.replayEffect(effect, execute); const replay = await kernel.replayEffect(effect, execute);
+  assert.equal(calls, 1); assert.equal(replay.replayed, true);
+});
+await fixture('false_milestone_completion', async () => {
+  const kernel = new TransactionalStateKernel(path.join(root, 'completion-kernel'));
+  await assert.rejects(kernel.transact({ effects: [{ type: 'completion', key: 'milestone:1', payload: { milestone: true } }], complete: { terminalContract: { required: ['m1', 'm2'] }, validate: async () => ({ ok: false, reason: 'required backlog remains' }) } }), /Completion fence rejected/);
+  assert.notEqual((await kernel.inspect()).status, 'completed');
+});
+await fixture('repeated_revision', async () => {
+  await initGoal(root, { id: 'revision', goal: 'Preserve repeated revision lineage without collision.' });
+  await reviewGoal(root, 'revision', { decision: 'revise', revision: 1, key: 'revision:1', parent: null });
+  await reviewGoal(root, 'revision', { decision: 'revise', revision: 2, key: 'revision:2', parent: 'revision:1' });
+  const status = await statusGoal(root, 'revision');
+  assert.equal(status.runtime.applied_effects['revision:2'].effect.payload.parent, 'revision:1'); assert.equal(status.receipt_chain.count, 2);
+});
+
+assert.deepEqual(Object.keys(Goal), ['init', 'run', 'status', 'review', 'doctor']);
+await rm(root, { recursive: true, force: true });
+console.log(JSON.stringify({ ok: results.every((item) => item.ok), fixtures: results }, null, 2));
+if (results.some((item) => !item.ok)) process.exitCode = 1;

package/scripts/competitive-final-judgement.mjs

@@ -0,0 +1,27 @@
+import { access, readFile } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+const root = path.resolve(import.meta.dirname, '..');
+const checks = [];
+const record = (id, ok, evidence) => checks.push({ id, ok, evidence });
+const requiredFiles = ['lib/transactional-state-kernel.mjs', 'lib/goal-api.mjs', '.github/workflows/ci.yml', 'scripts/competitive-acceptance.mjs', 'docs/transactional-kernel-and-goal-api.md'];
+for (const file of requiredFiles) {
+  try { await access(path.join(root, file)); record(`file:${file}`, true, file); }
+  catch { record(`file:${file}`, false, 'missing'); }
+}
+const source = await readFile(path.join(root, 'lib/transactional-state-kernel.mjs'), 'utf8');
+for (const token of ['state_transition', 'human_gate', 'revision', 'action_reservation', 'external_action', 'completion', 'fencingToken', 'expectedGeneration', 'verifyReceiptChain', 'replayEffect']) {
+  record(`kernel:${token}`, source.includes(token), token);
+}
+const cli = await readFile(path.join(root, 'bin/loop-engineering.mjs'), 'utf8');
+for (const command of ['init', 'run', 'status', 'review', 'doctor']) record(`cli:${command}`, cli.includes(`command === '${command}'`), command);
+const fixture = await new Promise((resolve) => {
+  const child = spawn(process.execPath, ['scripts/competitive-acceptance.mjs'], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+  let stdout = ''; let stderr = ''; child.stdout.on('data', (chunk) => { stdout += chunk; }); child.stderr.on('data', (chunk) => { stderr += chunk; });
+  child.on('close', (code) => resolve({ code, stdout, stderr }));
+});
+record('competitive_fixtures', fixture.code === 0, fixture.code === 0 ? '7/7 passed' : fixture.stderr);
+const outcome = checks.every((item) => item.ok) ? 'accept' : 'reject';
+console.log(JSON.stringify({ version: 1, scope: 'complete_project_terminal_contract', independent_from_runtime_implementation: true, outcome, checks, residual_risks: ['Filesystem durability depends on the host filesystem honoring atomic rename and fsync semantics.', 'External exactly-once behavior requires providers to honor the supplied idempotency key.'] }, null, 2));
+if (outcome !== 'accept') process.exitCode = 1;