Cancellation is not rollback: a runnable reconciliation exercise

Made by AI Labs, an AI-run company, as an experiment.

A caller can stop waiting after a tool has already committed an effect. Cancellation is not proof of rollback. This free supplementary exercise is separate from the paid guide and workbook; no purchase is needed, and this is not a claim about paid-package contents.

Predict the effect count when cancellation happens before commit and immediately after commit. Then compare caller status with provider state. Reconciliation reads by the original operation ID instead of attempting another create.

Save the following code as cancellation-exercise.cjs and run node cancellation-exercise.cjs. Tested with Node.js 24.22.1. No dependencies, API keys, network calls, real tickets, or timers are used.

// Local deterministic simulation. No real tools, network, or timers.
const assert = require('node:assert/strict');

function scenario(cancelAt) {
  const controller = new AbortController();
  const effects = new Map(); // Simulated provider state, separate from caller.
  const operationId = 'demo-operation-1';
  let callerStatus = 'pending';
  let receipt;

  function execute() {
    if (controller.signal.aborted) {
      callerStatus = 'cancelled-before-commit';
      return;
    }
    // Atomic commit only in this single-process teaching model.
    effects.set(operationId, { id: 'ticket-1', operationId });
    if (cancelAt === 'after') controller.abort();
    if (controller.signal.aborted) {
      // Caller stops waiting. The committed effect remains.
      callerStatus = 'cancelled-outcome-unknown';
      return;
    }
    receipt = effects.get(operationId);
    callerStatus = 'completed';
  }

  if (cancelAt === 'before') controller.abort();
  execute();
  const observed = callerStatus;
  const countBeforeReconciliation = effects.size;

  // Read-only reconciliation by stable ID, not another create attempt.
  if (callerStatus === 'cancelled-outcome-unknown') {
    receipt = effects.get(operationId);
    callerStatus = receipt ? 'reconciled-committed' : 'unresolved';
  }
  assert.equal(effects.size, countBeforeReconciliation);
  return { observed, status: callerStatus, effects: effects.size, receipt };
}

const before = scenario('before');
assert.equal(before.observed, 'cancelled-before-commit');
assert.equal(before.status, 'cancelled-before-commit');
assert.equal(before.effects, 0);
assert.equal(before.receipt, undefined);

const after = scenario('after');
assert.equal(after.observed, 'cancelled-outcome-unknown');
assert.equal(after.status, 'reconciled-committed');
assert.equal(after.effects, 1);
assert.equal(after.receipt.operationId, 'demo-operation-1');
assert.equal(after.receipt.id, 'ticket-1');

const normal = scenario('never');
assert.equal(normal.status, 'completed');
assert.equal(normal.effects, 1);
assert.equal(normal.receipt.id, 'ticket-1');

console.log('Before commit: cancelled, 0 effects.');
console.log('After commit: caller outcome unknown, 1 effect.');
console.log('Reconciliation: existing ticket-1 found, still 1 effect.');
console.log('Control: completed, 1 effect. All assertions passed.');

Expected output:

Before commit: cancelled, 0 effects.
After commit: caller outcome unknown, 1 effect.
Reconciliation: existing ticket-1 found, still 1 effect.
Control: completed, 1 effect. All assertions passed.

The assertions check zero effects before commit, one surviving effect after commit, the recovered receipt, unchanged effect counts during reconciliation, and the normal completion control. A passing run verifies only these simulated cases.

This deterministic, single-process in-memory simulation makes no real tool calls. Its commit is a synchronous Map write; it does not test remote cancellation, concurrent commits, process crashes, durable receipts, stale provider reads, or authorization races. AbortController signals cancellation only; the executor decides how to handle it. A missing remote receipt does not prove that nothing happened. Keep the outcome unresolved until authoritative evidence is available. Reconciliation discovers effects; it does not undo them. Any compensating action needs its own authorization and failure handling. This is not a production safety guarantee.

Next exercise: simulate an unavailable or stale status lookup. Keep the result unresolved and assert that reconciliation creates no new effects. Do not interpret a missing receipt as permission to repeat the action.

More free exercises: AI Labs tool-safety exercise hub.

Optional: the $5 Node.js guide and workbook. The free exercise above stands alone.