@wenathlan/devthink 2.0.15 → 2.0.19

package/tests/torture-run.test.ts

@@ -1,626 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  acquirerunlock,
-  advancerun,
-  beatrun,
-  budgetalertstate,
-  cancelrollback,
-  checkpointisvalid,
-  closerun,
-  dequeueoffline,
-  enqueueoffline,
-  expirerunlocks,
-  heartbeatwindowof,
-  heartbeatisstale,
-  initialrun,
-  makecheckpoint,
-  openrun,
-  reattachrun,
-  recordenvironment,
-  recordturnaround,
-  recordurl,
-  recoveryplan,
-  releaserunlock,
-  replayqueue,
-  resumecheckpoint,
-  rollbackrun,
-  runbudgetof,
-  runcomplete,
-  runfail,
-  runfromplan,
-  runheartbeat,
-  runpausesforalerts,
-  runstatemachine,
-  serializesteps,
-  sideeffects,
-  stepkey,
-  timeoutcanceldecision,
-  transitionislegal,
-  zombiecheck,
-  zombiesweep,
-} from "../run.js";
-import type { agentplan, heartbeatrecord, planprogress, runrecord, runsettings, toolstep } from "../types.js";
-
-const now = 1_800_000_000_000;
-
-/** Builds one minimal approved plan fixture. */
-function plan(over: Partial<agentplan> = {}): agentplan {
-  return {
-    id: "p1",
-    objective: "Check the pricing page",
-    origin: "https://example.com",
-    steps: [],
-    createdat: now - 1000,
-    expiresat: now + 60_000,
-    state: "approved",
-    ...over,
-  };
-}
-
-/** Builds one queued run fixture. */
-function run(over: Partial<runrecord> = {}): runrecord {
-  return { runid: "r1", planid: "p1", sessionid: "s1", state: "queued", createdat: now, updatedat: now, ...over };
-}
-
-/** Builds one heartbeat fixture. */
-function beat(over: Partial<heartbeatrecord> = {}): heartbeatrecord {
-  return { runid: "r1", beat: 1, at: now, ...over };
-}
-
-/** Builds one read only step fixture. */
-function readstep(id: string, over: Partial<toolstep> = {}): toolstep {
-  return { id, kind: "readtext", summary: `read ${id}`, risk: "read", ...over };
-}
-
-/** Builds one mutating step fixture. */
-function writestep(id: string, over: Partial<toolstep> = {}): toolstep {
-  return { id, kind: "type", target: "#field", value: "x", summary: `type ${id}`, risk: "interaction", ...over };
-}
-
-describe("torture: run lifecycle state machine", () => {
-  it("refuses every illegal transition from every terminal state", () => {
-    for (const to of [
-      "queued",
-      "running",
-      "paused",
-      "awaitingapproval",
-      "completed",
-      "failed",
-      "cancelled",
-      "rolledback",
-    ] as const) {
-      expect(() => advancerun(run({ state: "completed" }), to, now)).toThrow(/cannot move/i);
-      expect(() => advancerun(run({ state: "rolledback" }), to, now)).toThrow(/cannot move/i);
-    }
-    expect(() => advancerun(run({ state: "failed" }), "completed", now)).toThrow(/cannot move/i);
-    expect(() => advancerun(run({ state: "cancelled" }), "running", now)).toThrow(/cannot move/i);
-    expect(() => advancerun(run({ state: "failed" }), "failed", now)).toThrow(/cannot move/i);
-  });
-
-  it("accepts every legal transition the machine declares and only those", () => {
-    const machine = runstatemachine();
-    for (const [from, targets] of Object.entries(machine)) {
-      for (const to of targets) {
-        expect(transitionislegal({ from: from as never, to: to as never })).toBe(true);
-        const moved = advancerun(run({ state: from as never }), to, now);
-        expect(moved.state).toBe(to);
-        expect(moved.updatedat).toBe(now);
-      }
-    }
-  });
-
-  it("keeps the record immutable through transitions", () => {
-    const original = run();
-    const moved = advancerun(original, "running", now);
-    expect(original.state).toBe("queued");
-    expect(moved.runid).toBe("r1");
-    expect(moved).not.toBe(original);
-  });
-
-  it("refuses blank ids when creating runs and steps", () => {
-    expect(() => initialrun({ planid: "", sessionid: "s1", now })).toThrow(/plan id/i);
-    expect(() => initialrun({ planid: "  ", sessionid: "s1", now })).toThrow(/plan id/i);
-    expect(() => initialrun({ planid: "p1", sessionid: "", now })).toThrow(/session id/i);
-    expect(() => stepkey({ planid: "", stepid: "s1", kind: "click" })).toThrow(/plan and step ids/i);
-    expect(() => stepkey({ planid: "p1", stepid: "", kind: "click" })).toThrow(/plan and step ids/i);
-    expect(() => stepkey({ planid: "p1", stepid: "s1", kind: " " })).toThrow(/step kind/i);
-    expect(stepkey({ planid: "p1", stepid: "s1", kind: "click" })).toBe("p1:s1:click");
-    expect(stepkey({ planid: "p:1", stepid: "s:1", kind: "navigate" })).toBe("p:1:s:1:navigate");
-  });
-
-  it("derives unique step keys across plans, steps and kinds", () => {
-    const keys = new Set<string>();
-    for (const planid of ["p1", "p2"]) {
-      for (const stepid of ["s1", "s2"]) {
-        for (const kind of ["click", "readtext"]) {
-          keys.add(stepkey({ planid, stepid, kind }));
-        }
-      }
-    }
-    expect(keys.size).toBe(8);
-  });
-});
-
-describe("torture: keepalive lifecycle and zombie reaping", () => {
-  it("refuses heartbeats and reattachment on stopped runs while closed runs stay frozen", () => {
-    const state = openrun({ runid: "r1", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    const closed = closerun(state, now + 5_000);
-    expect(() => beatrun(closed, now + 6_000)).toThrow(/stopped/i);
-    expect(() => reattachrun(closed, now + 6_000)).toThrow(/stopped/i);
-    expect(() => closerun(closed, now + 7_000)).toThrow(/already stopped/i);
-    expect(closed.state).toBe("completed");
-    expect(closed.keepalive.portopen).toBe(false);
-  });
-
-  it("refuses negative and non finite intervals at open time", () => {
-    for (const interval of [0, -1, Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY]) {
-      expect(() => openrun({ runid: "r1", sessionid: "s1", planid: "p1", profileid: "u1", interval, now })).toThrow(
-        /positive user value/i,
-      );
-    }
-    expect(() => openrun({ runid: "", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now })).toThrow(
-      /run and session ids/i,
-    );
-  });
-
-  it("caps the heartbeat event trail at two hundred beats", () => {
-    let state = openrun({ runid: "r1", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    for (let index = 0; index < 250; index += 1) state = beatrun(state, now + index * 1_000);
-    expect(state.keepalive.beats).toBe(250);
-    expect(state.keepalive.events.length).toBe(200);
-    expect(state.keepalive.lastbeatat).toBe(now + 249_000);
-  });
-
-  it("reaps exactly the runs whose silence passed the tolerance and only active ones", () => {
-    const base = openrun({ runid: "base", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    const alive = { ...base, runid: "alive", keepalive: { ...base.keepalive, runid: "alive", lastbeatat: now } };
-    const silent = {
-      ...base,
-      runid: "silent",
-      keepalive: { ...base.keepalive, runid: "silent", lastbeatat: now - 10_000 },
-    };
-    const stopped = closerun({ ...base, runid: "stopped", keepalive: { ...base.keepalive, runid: "stopped" } }, now);
-    const alreadyreaped = { ...base, runid: "reapedalready", state: "reaped" as const };
-    const result = zombiesweep({
-      states: [alive, silent, stopped, alreadyreaped],
-      now,
-      interval: 1_000,
-      missedlimit: 3,
-    });
-    expect(result.reaped).toEqual(["silent"]);
-    expect(result.states.find((state) => state.runid === "silent")?.state).toBe("reaped");
-    expect(result.states.find((state) => state.runid === "alive")?.state).toBe("active");
-    expect(result.states.find((state) => state.runid === "stopped")?.state).toBe("completed");
-    expect(result.states.find((state) => state.runid === "reapedalready")?.state).toBe("reaped");
-  });
-
-  it("reaps at exactly the tolerated boundary plus one and never at the boundary", () => {
-    const base = openrun({ runid: "base", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    const atboundary = { ...base, runid: "r1", keepalive: { ...base.keepalive, runid: "r1", lastbeatat: now - 3_000 } };
-    const overboundary = {
-      ...base,
-      runid: "over",
-      keepalive: { ...base.keepalive, runid: "over", lastbeatat: now - 3_001 },
-    };
-    const exactly = zombiesweep({ states: [atboundary], now, interval: 1_000, missedlimit: 3 });
-    expect(exactly.reaped).toEqual([]);
-    const over = zombiesweep({ states: [overboundary], now, interval: 1_000, missedlimit: 3 });
-    expect(over.reaped).toEqual(["over"]);
-  });
-
-  it("refuses invalid sweep parameters", () => {
-    expect(() => zombiesweep({ states: [], now, interval: 0, missedlimit: 3 })).toThrow(/positive user value/i);
-    expect(() => zombiesweep({ states: [], now, interval: 1_000, missedlimit: 0 })).toThrow(/positive whole number/i);
-    expect(() => zombiesweep({ states: [], now, interval: Number.NaN, missedlimit: 3 })).toThrow(
-      /positive user value/i,
-    );
-    expect(() => zombiesweep({ states: [], now, interval: 1_000, missedlimit: 1.5 })).toThrow(/positive whole number/i);
-  });
-
-  it("answers recovery for every terminal state and the pending step rule", () => {
-    const base = openrun({ runid: "r1", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    expect(recoveryplan(closerun(base, now + 1)).recoverable).toBe(false);
-    expect(recoveryplan({ ...base, state: "reaped" }).recoverable).toBe(false);
-    expect(recoveryplan(base).recoverable).toBe(false);
-    expect(recoveryplan(base).reason).toMatch(/no pending step/i);
-    const pending = { ...base, pendingstepid: "s5" };
-    const recovery = recoveryplan(pending);
-    expect(recovery.recoverable).toBe(true);
-    expect(recovery.pendingstepid).toBe("s5");
-  });
-
-  it("records urls, environments and turnarounds with validation", () => {
-    let state = openrun({ runid: "r1", sessionid: "s1", planid: "p1", profileid: "u1", interval: 1_000, now });
-    expect(() => recordurl(state, { url: " ", stepid: "s1", now })).toThrow(/needs its url/i);
-    state = recordurl(state, { url: "https://example.com/a", stepid: "s1", now });
-    state = recordurl(state, { url: "https://example.com/a", stepid: "s1", now: now + 1 });
-    expect(state.urlhistory.length).toBe(1);
-    state = recordurl(state, { url: "https://example.com/a", stepid: "s2", now: now + 2 });
-    expect(state.urlhistory.length).toBe(2);
-    expect(() =>
-      recordenvironment(state, { stepid: "", environment: "pagecontext", origin: "https://example.com", now }),
-    ).toThrow(/step id/i);
-    state = recordenvironment(state, {
-      stepid: "s1",
-      environment: "offscreenworker",
-      origin: "https://example.com",
-      now,
-    });
-    expect(state.environments["s1"]).toBe("offscreenworker");
-    expect(state.lastprovenance?.environment).toBe("offscreenworker");
-    expect(() => recordturnaround(state, { stepid: "s1", milliseconds: -1, now })).toThrow(/non-negative/i);
-    expect(() => recordturnaround(state, { stepid: "s1", milliseconds: Number.NaN, now })).toThrow(/non-negative/i);
-    state = recordturnaround(state, { stepid: "s1", milliseconds: 0, now });
-    expect(state.turnarounds["s1"]).toBe(0);
-  });
-});
-
-describe("torture: run locks and concurrency refusal", () => {
-  it("refuses a second concurrent run of the same session while the same run renews", () => {
-    const first = acquirerunlock({ locks: [], sessionid: "s1", runid: "r1", holder: "executor", now });
-    expect(first.acquired).toBe(true);
-    const second = acquirerunlock({
-      locks: first.locks,
-      sessionid: "s1",
-      runid: "r2",
-      holder: "executor",
-      now: now + 1,
-    });
-    expect(second.acquired).toBe(false);
-    expect(second.reason).toMatch(/never carries two concurrent runs/i);
-    expect(second.locks).toBe(first.locks);
-    const renew = acquirerunlock({
-      locks: first.locks,
-      sessionid: "s1",
-      runid: "r1",
-      holder: "executor",
-      now: now + 2,
-    });
-    expect(renew.acquired).toBe(true);
-    expect(renew.locks.length).toBe(1);
-  });
-
-  it("expires the locks past their expiry naming their sessions and never at the boundary", () => {
-    const { locks } = acquirerunlock({
-      locks: [],
-      sessionid: "s1",
-      runid: "r1",
-      holder: "executor",
-      expiresat: now + 1_000,
-      now,
-    });
-    expect(expirerunlocks(locks, now).expired).toEqual([]);
-    expect(expirerunlocks(locks, now + 999).expired).toEqual([]);
-    expect(expirerunlocks(locks, now + 1_000).expired).toEqual([]);
-    expect(expirerunlocks(locks, now + 1_001).expired).toEqual(["s1"]);
-    expect(expirerunlocks(locks, now + 1_001).locks).toEqual([]);
-    const takenover = acquirerunlock({ locks, sessionid: "s1", runid: "r2", holder: "executor", now: now + 1_001 });
-    expect(takenover.acquired).toBe(true);
-  });
-
-  it("releases the run lock exactly for its own run", () => {
-    const { locks } = acquirerunlock({ locks: [], sessionid: "s1", runid: "r1", holder: "executor", now });
-    const released = releaserunlock({ locks, sessionid: "s1", runid: "r1", now });
-    expect(released.released).toBe(true);
-    expect(released.locks.length).toBe(0);
-    const missing = releaserunlock({ locks: released.locks, sessionid: "s1", runid: "other", now });
-    expect(missing.released).toBe(false);
-    expect(missing.reason).toMatch(/holds no lock/i);
-  });
-
-  it("serializes steps that share one tab across parallel branches", () => {
-    const order = serializesteps({
-      branches: [
-        {
-          branchid: "b1",
-          steps: [
-            { stepid: "a1", tabid: 7 },
-            { stepid: "a2", tabid: 8 },
-          ],
-        },
-        {
-          branchid: "b2",
-          steps: [
-            { stepid: "b1", tabid: 7 },
-            { stepid: "b2", tabid: 9 },
-          ],
-        },
-      ],
-    });
-    const tabseven = order.filter((entry) => entry.tabid === 7).map((entry) => entry.stepid);
-    expect(tabseven).toEqual(["a1", "b1"]);
-    const unique = new Set(order.map((entry) => entry.order));
-    expect(unique.size).toBe(order.length);
-    expect(order.length).toBe(4);
-  });
-});
-
-describe("torture: offline queue ordering and replay", () => {
-  it("queues only approved plans with monotonic sequence and drains in order", () => {
-    const queue = [
-      enqueueoffline([], { plan: plan({ id: "p1" }), sessionid: "s1", now }),
-      enqueueoffline(enqueueoffline([], { plan: plan({ id: "p1" }), sessionid: "s1", now }), {
-        plan: plan({ id: "p2" }),
-        sessionid: "s2",
-        now: now + 1,
-      }),
-    ];
-    expect(() => enqueueoffline(queue[0]!, { plan: plan({ id: "px", state: "draft" }), sessionid: "s1", now })).toThrow(
-      /only an approved plan/i,
-    );
-    const drained: string[] = [];
-    let rest = queue[1]!;
-    for (let index = 0; index < 3; index += 1) {
-      const next = dequeueoffline(rest);
-      if (next.task) drained.push(next.task.planid);
-      rest = next.queue;
-    }
-    expect(drained).toEqual(["p1", "p2"]);
-    expect(dequeueoffline(rest).task).toBeUndefined();
-  });
-
-  it("expires exactly the plans whose window passed while draining offline (the expiry tick is exclusive)", () => {
-    const early = enqueueoffline([], { plan: plan({ id: "p1", expiresat: now + 1_000 }), sessionid: "s1", now });
-    const late = enqueueoffline(early, { plan: plan({ id: "p2", expiresat: now + 60_000 }), sessionid: "s1", now });
-    const before = replayqueue(late, now + 999);
-    expect(before.expired.map((task) => task.planid)).toEqual([]);
-    expect(before.ready.map((task) => task.planid)).toEqual(["p1", "p2"]);
-    const atboundary = replayqueue(late, now + 1_000);
-    expect(atboundary.expired.map((task) => task.planid)).toEqual(["p1"]);
-    expect(atboundary.ready.map((task) => task.planid)).toEqual(["p2"]);
-    const after = replayqueue(late, now + 1_001);
-    expect(after.expired.map((task) => task.planid)).toEqual(["p1"]);
-    expect(after.ready.map((task) => task.planid)).toEqual(["p2"]);
-  });
-
-  it("keeps sequence order under interleaved enqueue bursts", () => {
-    let queue: ReturnType<typeof enqueueoffline> = [];
-    for (let index = 0; index < 50; index += 1) {
-      queue = enqueueoffline(queue, { plan: plan({ id: `p${index}` }), sessionid: "s1", now: now + index });
-    }
-    const order: number[] = [];
-    let rest = queue;
-    while (rest.length > 0) {
-      const next = dequeueoffline(rest);
-      if (next.task) order.push(next.task.sequence);
-      rest = next.queue;
-    }
-    expect(order).toEqual([...order].sort((one, two) => one - two));
-    expect(order.length).toBe(50);
-  });
-});
-
-describe("torture: checkpoints, digests and resume", () => {
-  it("refuses checkpoints without their ids and digest", () => {
-    expect(() => makecheckpoint({ runid: "", stepid: "s1", completed: [], digest: "d", now })).toThrow(/run id/i);
-    expect(() => makecheckpoint({ runid: "r1", stepid: "", completed: [], digest: "d", now })).toThrow(/step id/i);
-    expect(() => makecheckpoint({ runid: "r1", stepid: "s1", completed: [], digest: " ", now })).toThrow(
-      /page digest/i,
-    );
-    const checkpoint = makecheckpoint({ runid: "r1", stepid: "s3", completed: ["s1", "s2"], digest: "digest-a", now });
-    expect(checkpoint.completed).toEqual(["s1", "s2"]);
-    expect(checkpoint.completed).not.toBe(["s1", "s2"]);
-  });
-
-  it("validates only the checkpoint of its own run and unchanged digest", () => {
-    const checkpoint = makecheckpoint({ runid: "r1", stepid: "s3", completed: ["s1"], digest: "digest-a", now });
-    expect(checkpointisvalid({ checkpoint, runid: "r1", digest: "digest-a" })).toBe(true);
-    expect(checkpointisvalid({ checkpoint, runid: "r2", digest: "digest-a" })).toBe(false);
-    expect(checkpointisvalid({ checkpoint, runid: "r1", digest: "digest-b" })).toBe(false);
-  });
-
-  it("resumes from the first open step while a foreign checkpoint skips only named steps", () => {
-    const steps = ["s1", "s2", "s3", "s4"];
-    expect(resumecheckpoint({ checkpoint: undefined, steps })).toEqual(steps);
-    const checkpoint = makecheckpoint({ runid: "r1", stepid: "s2", completed: ["s1", "s2"], digest: "d", now });
-    expect(resumecheckpoint({ checkpoint, steps })).toEqual(["s3", "s4"]);
-    expect(resumecheckpoint({ checkpoint, steps: [] })).toEqual([]);
-    const foreign = makecheckpoint({ runid: "r2", stepid: "s9", completed: ["s1", "s9"], digest: "d", now });
-    expect(resumecheckpoint({ checkpoint: foreign, steps })).toEqual(["s2", "s3", "s4"]);
-  });
-
-  it("freezes progress on failure with the run id stamped", () => {
-    const moving = advancerun(run(), "running", now);
-    const failed = runfail({
-      run: moving,
-      progress: { planid: "p1", completedsteps: ["s1"], updatedat: now },
-      now: now + 1,
-    });
-    expect(failed.run.state).toBe("failed");
-    expect(failed.frozen?.runid).toBe("r1");
-    expect(failed.frozen?.updatedat).toBe(now + 1);
-    const bare = runfail({ run: moving, now: now + 2 });
-    expect(bare.frozen).toBeUndefined();
-  });
-
-  it("completes only a run whose plan finished every step", () => {
-    const planfixture = plan({ steps: [readstep("s1"), readstep("s2")] });
-    const moving = advancerun(run(), "running", now);
-    expect(() =>
-      runcomplete({
-        run: moving,
-        plan: planfixture,
-        progress: { planid: "p1", completedsteps: ["s1"], updatedat: now },
-        now,
-      }),
-    ).toThrow(/never completes/i);
-    const done = runcomplete({
-      run: moving,
-      plan: planfixture,
-      progress: { planid: "p1", completedsteps: ["s1", "s2"], updatedat: now },
-      now: now + 1,
-    });
-    expect(done.state).toBe("completed");
-  });
-
-  it("rebuilds a failed run from an expired or unapproved plan and a running one otherwise", () => {
-    expect(runfromplan(plan({ state: "draft" }), "s1", now).state).toBe("failed");
-    expect(runfromplan(plan({ expiresat: now }), "s1", now).state).toBe("failed");
-    expect(runfromplan(plan({ expiresat: now + 1 }), "s1", now).state).toBe("running");
-    expect(runfromplan(plan(), "s1", now).runid).toBe("p1");
-  });
-});
-
-describe("torture: heartbeats and the zombie check", () => {
-  it("stale heartbeat sits exactly past the window and never at it", () => {
-    const beat = runheartbeat({ runid: "r1", beat: 5, now });
-    expect(beat.beat).toBe(6);
-    expect(heartbeatisstale({ heartbeat: beat, now: now + 10_000, window: 10_000 })).toBe(false);
-    expect(heartbeatisstale({ heartbeat: beat, now: now + 10_001, window: 10_000 })).toBe(true);
-    expect(heartbeatisstale({ heartbeat: undefined, now, window: 1 })).toBe(true);
-  });
-
-  it("refuses blank run ids on heartbeats", () => {
-    expect(() => runheartbeat({ runid: " ", now })).toThrow(/run id/i);
-    expect(() => runheartbeat({ runid: "", now })).toThrow(/run id/i);
-  });
-
-  it("zombiecheck names only running runs with stale heartbeats", () => {
-    const runs = [
-      run({ runid: "alive", state: "running" }),
-      run({ runid: "zombie", state: "running" }),
-      run({ runid: "queued", state: "queued" }),
-      run({ runid: "done", state: "completed" }),
-    ];
-    const heartbeats: Record<string, heartbeatrecord> = {
-      alive: { runid: "alive", beat: 1, at: now - 5_000 },
-      zombie: { runid: "zombie", beat: 1, at: now - 50_000 },
-      queued: { runid: "queued", beat: 1, at: now - 50_000 },
-      done: { runid: "done", beat: 1, at: now - 50_000 },
-    };
-    const zombies = zombiecheck({ runs, heartbeats, now, window: 10_000 });
-    expect(zombies.map((entry) => entry.runid)).toEqual(["zombie"]);
-  });
-
-  it("reads the heartbeat window from settings with the roadmap default", () => {
-    expect(heartbeatwindowof(undefined)).toBe(60_000);
-    const settings: runsettings = {};
-    expect(heartbeatwindowof(settings)).toBe(60_000);
-  });
-});
-
-describe("torture: side effects and rollback compensations", () => {
-  it("compensates only the executed mutating steps while read steps carry none", () => {
-    const steps = [readstep("r1"), writestep("w1"), writestep("w2"), writestep("w3")];
-    const executed = ["r1", "w1", "w3"];
-    const effects = sideeffects(steps, executed);
-    expect(effects.map((step) => step.id)).toEqual(["w1", "w3"]);
-    const items = rollbackrun({ runid: "r1", steps, executedstepids: executed, origin: "https://example.com", now });
-    expect(items.map((item) => item.stepid)).toEqual(["w1", "w3"]);
-    expect(items.every((item) => item.compensation.length > 0)).toBe(true);
-    expect(items.every((item) => item.origin === "https://example.com")).toBe(true);
-    expect(rollbackrun({ runid: "r1", steps, executedstepids: [], origin: "https://example.com", now })).toEqual([]);
-  });
-
-  it("reports the fallback compensation for an unknown mutating kind", () => {
-    const alien = { id: "x1", kind: "dimensionhop", summary: "unknown", risk: "sensitive" } as unknown as toolstep;
-    const items = rollbackrun({
-      runid: "r1",
-      steps: [alien],
-      executedstepids: ["x1"],
-      origin: "https://example.com",
-      now,
-    });
-    expect(items[0]?.compensation).toMatch(/dimensionhop step stays executed/i);
-  });
-
-  it("cancel pairs the rollback choice with compensations only under the explicit user choice", () => {
-    const steps = [writestep("w1"), readstep("r1")];
-    const moving = advancerun(run(), "running", now);
-    const none = cancelrollback({
-      run: moving,
-      steps,
-      executedstepids: ["w1", "r1"],
-      origin: "https://example.com",
-      choice: "none",
-      now: now + 1,
-    });
-    expect(none.run.state).toBe("cancelled");
-    expect(none.compensations).toEqual([]);
-    expect(none.reason).toMatch(/without a rollback/i);
-    const fresh = advancerun(run({ runid: "r2" }), "running", now);
-    const rollback = cancelrollback({
-      run: fresh,
-      steps,
-      executedstepids: ["w1", "r1"],
-      origin: "https://example.com",
-      choice: "rollback",
-      now: now + 1,
-    });
-    expect(rollback.run.state).toBe("rolledback");
-    expect(rollback.compensations.map((item) => item.stepid)).toEqual(["w1"]);
-    expect(rollback.reason).toMatch(/explicit user choice/i);
-    expect(() =>
-      cancelrollback({
-        run: rollback.run,
-        steps,
-        executedstepids: ["w1"],
-        origin: "https://example.com",
-        choice: "none",
-        now: now + 2,
-      }),
-    ).toThrow(/cannot move/i);
-    expect(() =>
-      cancelrollback({
-        run: none.run,
-        steps,
-        executedstepids: [],
-        origin: "https://example.com",
-        choice: "none",
-        now: now + 2,
-      }),
-    ).toThrow(/cannot move/i);
-  });
-});
-
-describe("torture: budget alerts and timeout cancels", () => {
-  it("budget alerts fire at their reached severity with critical pausing and warnings informational", () => {
-    const atwarning = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 80, stepbudget: 100, pressure: 0.5, now }),
-      thresholds: { warning: 0.8, critical: 0.95 },
-    });
-    expect(atwarning.map((alert) => alert.level)).toEqual(["warning"]);
-    expect(runpausesforalerts(atwarning)).toBe(false);
-    const atcritical = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 100, stepbudget: 100, pressure: 0.5, now }),
-      thresholds: { warning: 0.8, critical: 0.95 },
-    });
-    expect(atcritical.map((alert) => alert.level)).toEqual(["critical"]);
-    expect(runpausesforalerts(atcritical)).toBe(true);
-    const over = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 101, stepbudget: 100, pressure: 0.5, now }),
-      thresholds: { warning: 0.5, critical: 0.5 },
-    });
-    expect(runpausesforalerts(over)).toBe(true);
-    const under = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 10, stepbudget: 100, pressure: 0.5, now }),
-      thresholds: { warning: 0.8, critical: 0.95 },
-    });
-    expect(under).toEqual([]);
-    const nobudget = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 10, pressure: 0.5, now }),
-      thresholds: { warning: 0.5, critical: 0.5 },
-    });
-    expect(nobudget).toEqual([]);
-  });
-
-  it("timeout cancels at exactly the bound and one past it while memory pressure alerts beside the steps", () => {
-    expect(timeoutcanceldecision({ elapsed: 999, bound: 1_000 }).abort).toBe(false);
-    expect(timeoutcanceldecision({ elapsed: 1_000, bound: 1_000 }).abort).toBe(false);
-    expect(timeoutcanceldecision({ elapsed: 1_001, bound: 1_000 }).abort).toBe(true);
-    expect(timeoutcanceldecision({ elapsed: 0, bound: 0 }).abort).toBe(false);
-    expect(timeoutcanceldecision({ elapsed: -5, bound: 1_000 }).abort).toBe(false);
-    const unbound = timeoutcanceldecision({ elapsed: 10_000_000 });
-    expect(unbound.abort).toBe(false);
-    expect(unbound.reason).toMatch(/no timeout bound/i);
-    const gap = timeoutcanceldecision({ elapsed: Number.NaN, bound: 1_000 });
-    expect(gap.abort).toBe(false);
-    expect(gap.reason).toMatch(/no finite elapsed/i);
-    const memory = budgetalertstate({
-      budget: runbudgetof({ runid: "r1", steps: 1, pressure: 1, memorybudget: 1, now }),
-      thresholds: { warning: 0.5, critical: 0.9 },
-    });
-    expect(memory.map((alert) => alert.kind)).toEqual(["memory"]);
-    expect(runpausesforalerts(memory)).toBe(true);
-  });
-});