@wenathlan/devthink 2.0.15 → 2.0.19

package/tests/resilience.test.ts

@@ -1,467 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  advancerun,
-  cancelrollback,
-  cancelrunrecord,
-  checkpointisvalid,
-  dequeueoffline,
-  enqueueoffline,
-  heartbeatisstale,
-  heartbeatwindowof,
-  initialrun,
-  makecheckpoint,
-  queuesize,
-  reaprun,
-  replayqueue,
-  resumecheckpoint,
-  rollbackrun,
-  runcomplete,
-  runfail,
-  runfromplan,
-  runheartbeat,
-  runstatemachine,
-  runsummaryof,
-  sideeffects,
-  stepkey,
-  transitionislegal,
-  zombiecheck,
-} from "../run.js";
-import {
-  canexecute,
-  checkpointgate,
-  heartbeatwindowvalid,
-  offlinegate,
-  queuedepthvalid,
-  queuedtaskexpirygate,
-  replaycheck,
-  rollbackgate,
-  rollbackorigingate,
-  zombiegate,
-} from "../policy.js";
-import { parseproposal, requestbody, rollbacksummarycheck } from "../protocol.js";
-import { sessionmemory } from "../memory.js";
-import {
-  protocolversion,
-  type agentplan,
-  type agentsession,
-  type heartbeatrecord,
-  type runrecord,
-  type toolstep,
-} from "../types.js";
-
-const now = 1_800_000_000_000;
-const session: agentsession = {
-  id: "session",
-  tabid: 4,
-  origin: "https://example.com",
-  startedat: now,
-  expiresat: now + 1_000_000,
-};
-const clickstep: toolstep = {
-  id: "s1",
-  kind: "click",
-  target: "#submit",
-  summary: "Click the reviewed submit control.",
-  risk: "sensitive",
-};
-const plan: agentplan = {
-  id: "plan",
-  objective: "Submit once",
-  origin: "https://example.com",
-  steps: [clickstep, { id: "s2", kind: "observe", summary: "Read the page.", risk: "read" }],
-  createdat: now,
-  expiresat: now + 1_000_000,
-  state: "approved",
-};
-
-function runof(state: runrecord["state"]): runrecord {
-  return { runid: "run1", planid: "plan", sessionid: "session", state, createdat: now, updatedat: now };
-}
-
-class fakeadapter {
-  private readonly data = new Map<string, unknown>();
-  async get<T>(key: string): Promise<T | undefined> {
-    return this.data.get(key) as T | undefined;
-  }
-  async set<T>(key: string, value: T): Promise<void> {
-    this.data.set(key, value);
-  }
-}
-
-describe("runstatemachine", () => {
-  it("covers every legal and illegal transition of the run lifecycle", () => {
-    const machine = runstatemachine();
-    expect(machine.queued).toContain("running");
-    expect(machine.running).toContain("awaitingapproval");
-    expect(machine.failed).toEqual(["rolledback"]);
-    expect(machine.cancelled).toEqual(["rolledback"]);
-    expect(machine.completed).toEqual([]);
-    expect(machine.rolledback).toEqual([]);
-    expect(transitionislegal({ from: "queued", to: "running" })).toBe(true);
-    expect(transitionislegal({ from: "running", to: "completed" })).toBe(true);
-    expect(transitionislegal({ from: "completed", to: "running" })).toBe(false);
-    expect(transitionislegal({ from: "rolledback", to: "running" })).toBe(false);
-    expect(transitionislegal({ from: "queued", to: "rolledback" })).toBe(false);
-    expect(transitionislegal({ from: "running", to: "queued" })).toBe(false);
-    expect(() => advancerun(runof("completed"), "running", now)).toThrow(/legal transitions/i);
-    const advanced = advancerun(runof("queued"), "running", now + 5);
-    expect(advanced).toEqual({
-      runid: "run1",
-      planid: "plan",
-      sessionid: "session",
-      state: "running",
-      createdat: now,
-      updatedat: now + 5,
-    });
-  });
-
-  it("creates the initial queued run for an approved plan and rebuilds one after a restart", () => {
-    const initial = initialrun({ planid: "plan", sessionid: "session", now });
-    expect(initial.state).toBe("queued");
-    expect(() => initialrun({ planid: " ", sessionid: "session", now })).toThrow(/plan id/i);
-    const rebuilt = runfromplan(plan, "session", now + 1);
-    expect(rebuilt.state).toBe("running");
-    expect(rebuilt.planid).toBe("plan");
-    const expired = runfromplan({ ...plan, expiresat: now }, "session", now + 1);
-    expect(expired.state).toBe("failed");
-  });
-});
-
-describe("checkpoints", () => {
-  it("captures, validates and orders one checkpoint", () => {
-    const checkpoint = makecheckpoint({ runid: "run1", stepid: "s1", completed: ["s1"], digest: "digest1", now });
-    expect(checkpoint).toEqual({ runid: "run1", stepid: "s1", completed: ["s1"], digest: "digest1", createdat: now });
-    expect(() => makecheckpoint({ runid: "run1", stepid: "s1", completed: [], digest: " ", now })).toThrow(/digest/i);
-    expect(checkpointisvalid({ checkpoint, runid: "run1", digest: "digest1" })).toBe(true);
-    expect(checkpointisvalid({ checkpoint, runid: "run1", digest: "digest2" })).toBe(false);
-    expect(checkpointisvalid({ checkpoint, runid: "run2", digest: "digest1" })).toBe(false);
-    expect(resumecheckpoint({ checkpoint: undefined, steps: ["s1", "s2"] })).toEqual(["s1", "s2"]);
-    expect(resumecheckpoint({ checkpoint, steps: ["s1", "s2"] })).toEqual(["s2"]);
-    expect(checkpointgate({ checkpoint, runid: "run1", digest: "digest2" }).allowed).toBe(false);
-    expect(checkpointgate({ checkpoint, runid: "run1", digest: "digest1" }).allowed).toBe(true);
-  });
-});
-
-describe("rollback", () => {
-  it("builds one compensating step for each mutating kind and none for read only steps", () => {
-    const steps: toolstep[] = [
-      { id: "s1", kind: "click", summary: "Click", risk: "sensitive" },
-      { id: "s2", kind: "observe", summary: "Read", risk: "read" },
-      { id: "s3", kind: "type", target: "#field", value: "typed", summary: "Type", risk: "sensitive" },
-      { id: "s4", kind: "setcookies", summary: "Set cookies", risk: "sensitive" },
-      { id: "s5", kind: "blockrequest", summary: "Block", risk: "sensitive" },
-      { id: "s6", kind: "evaluate", summary: "Evaluate", risk: "sensitive" },
-      { id: "s7", kind: "submitform", summary: "Submit", risk: "sensitive" },
-    ];
-    expect(sideeffects(steps, ["s1", "s2", "s3", "s4", "s5", "s6", "s7"]).map((step) => step.id)).toEqual([
-      "s1",
-      "s3",
-      "s4",
-      "s5",
-      "s6",
-      "s7",
-    ]);
-    const items = rollbackrun({
-      runid: "run1",
-      steps,
-      executedstepids: ["s1", "s2", "s3", "s4", "s5", "s6", "s7"],
-      origin: "https://example.com",
-      now,
-    });
-    expect(items).toHaveLength(6);
-    expect(items.find((item) => item.stepid === "s3")?.compensation).toMatch(/restore the field value/i);
-    expect(items.find((item) => item.stepid === "s4")?.compensation).toMatch(/delete the cookies/i);
-    expect(items.find((item) => item.stepid === "s5")?.compensation).toMatch(/remove the block rule/i);
-    expect(items.find((item) => item.stepid === "s6")?.compensation).toMatch(/reports its effect/i);
-    expect(items.find((item) => item.stepid === "s7")?.compensation).toMatch(/stays submitted/i);
-    expect(items.every((item) => item.origin === "https://example.com")).toBe(true);
-    const failed = runfail({
-      run: runof("running"),
-      progress: { planid: "plan", completedsteps: ["s1"], updatedat: now },
-      now,
-    });
-    expect(failed.run.state).toBe("failed");
-    expect(failed.frozen?.runid).toBe("run1");
-    const completed = runcomplete({
-      run: runof("running"),
-      plan,
-      progress: { planid: "plan", completedsteps: ["s1", "s2"], updatedat: now },
-      now,
-    });
-    expect(completed.state).toBe("completed");
-    expect(() =>
-      runcomplete({
-        run: runof("running"),
-        plan,
-        progress: { planid: "plan", completedsteps: ["s1"], updatedat: now },
-        now,
-      }),
-    ).toThrow(/never completes/i);
-  });
-
-  it("pairs one cancellation with its optional rollback behind the explicit user choice", () => {
-    const cancelled = cancelrunrecord(runof("running"), now);
-    expect(cancelled.state).toBe("cancelled");
-    const plain = cancelrollback({
-      run: runof("running"),
-      steps: plan.steps,
-      executedstepids: ["s1"],
-      origin: "https://example.com",
-      choice: "none",
-      now,
-    });
-    expect(plain.run.state).toBe("cancelled");
-    expect(plain.compensations).toHaveLength(0);
-    const rolled = cancelrollback({
-      run: runof("running"),
-      steps: plan.steps,
-      executedstepids: ["s1"],
-      origin: "https://example.com",
-      choice: "rollback",
-      now,
-    });
-    expect(rolled.run.state).toBe("rolledback");
-    expect(rolled.compensations).toHaveLength(1);
-    expect(rollbackgate({ choice: "none" }).allowed).toBe(false);
-    expect(rollbackgate({ choice: "rollback" }).allowed).toBe(false);
-    expect(rollbackgate({ choice: "rollback", failed: true }).allowed).toBe(true);
-    expect(rollbackorigingate({ items: rolled.compensations, origin: "https://example.com" }).allowed).toBe(true);
-    expect(
-      rollbackorigingate({
-        items: [{ ...rolled.compensations[0]!, origin: "https://evil.example" }],
-        origin: "https://example.com",
-      }).allowed,
-    ).toBe(false);
-    expect(rollbacksummarycheck("restore the field value the form carried").ok).toBe(true);
-    expect(rollbacksummarycheck("  padded  ").ok).toBe(false);
-    expect(rollbacksummarycheck("").ok).toBe(false);
-    expect(rollbacksummarycheck("bad\u0007summary").ok).toBe(false);
-  });
-});
-
-describe("zombies and heartbeats", () => {
-  it("reaps the running runs whose heartbeat fell stale", () => {
-    const beat: heartbeatrecord = runheartbeat({ runid: "run1", now });
-    expect(beat).toEqual({ runid: "run1", beat: 1, at: now });
-    expect(runheartbeat({ runid: "run1", beat: 4, now: now + 1 }).beat).toBe(5);
-    expect(heartbeatisstale({ heartbeat: beat, now: now + 59_000, window: 60_000 })).toBe(false);
-    expect(heartbeatisstale({ heartbeat: beat, now: now + 61_000, window: 60_000 })).toBe(true);
-    expect(heartbeatisstale({ heartbeat: undefined, now, window: 60_000 })).toBe(true);
-    expect(heartbeatwindowof(undefined)).toBe(60_000);
-    expect(heartbeatwindowof({ heartbeatwindow: 120_000 })).toBe(120_000);
-    expect(heartbeatwindowvalid({ window: 120_000 }).allowed).toBe(true);
-    expect(heartbeatwindowvalid({ window: 0 }).allowed).toBe(false);
-    const stale = { runid: "run1", beat: 1, at: now - 120_000 };
-    const live = { runid: "run2", beat: 1, at: now - 10 };
-    const zombies = zombiecheck({
-      runs: [runof("running"), { ...runof("running"), runid: "run2" }],
-      heartbeats: { run1: stale, run2: live },
-      now,
-      window: 60_000,
-    });
-    expect(zombies.map((run) => run.runid)).toEqual(["run1"]);
-    const reaped = reaprun(runof("running"), now);
-    expect(reaped.run.state).toBe("failed");
-    expect(reaped.event.kind).toBe("reap");
-    expect(() => reaprun(runof("completed"), now)).toThrow(/only a running run/i);
-    expect(zombiegate({ zombies: ["run1"] }).allowed).toBe(false);
-    expect(zombiegate({ zombies: [] }).allowed).toBe(true);
-  });
-});
-
-describe("offlinequeue", () => {
-  it("enqueues, dequeues, replays and expires the approved plans in sequence order", () => {
-    expect(queuesize([])).toBe(0);
-    expect(() => enqueueoffline([], { plan: { ...plan, state: "pending" }, sessionid: "session", now })).toThrow(
-      /approved/i,
-    );
-    const queue = enqueueoffline([], { plan, sessionid: "session", now });
-    const second = enqueueoffline(queue, {
-      plan: { ...plan, id: "plan2", steps: [{ id: "s9", kind: "observe", summary: "Read", risk: "read" }] },
-      sessionid: "session",
-      now,
-    });
-    expect(queuesize(second)).toBe(2);
-    expect(second.map((task) => task.sequence)).toEqual([1, 2]);
-    const next = dequeueoffline(second);
-    expect(next.task?.planid).toBe("plan");
-    expect(next.queue).toHaveLength(1);
-    const empty = dequeueoffline([]);
-    expect(empty.task).toBeUndefined();
-    const replayable = replayqueue(second, now + 10);
-    expect(replayable.ready.map((task) => task.planid)).toEqual(["plan", "plan2"]);
-    expect(replayable.expired).toHaveLength(0);
-    const expiredtask = second[0]!;
-    expect(
-      queuedtaskexpirygate({
-        task: { planid: expiredtask.planid, expiresat: expiredtask.expiresat },
-        now: expiredtask.expiresat + 1,
-      }).allowed,
-    ).toBe(false);
-    const expired = replayqueue(second, now + 2_000_000);
-    expect(expired.ready).toHaveLength(0);
-    expect(expired.expired.map((task) => task.planid)).toEqual(["plan", "plan2"]);
-    expect(offlinegate({ reachable: false }).action).toBe("queue");
-    expect(offlinegate({ reachable: true }).action).toBe("execute");
-    expect(queuedepthvalid({ depth: 5 }).allowed).toBe(true);
-    expect(queuedepthvalid({ depth: -1 }).allowed).toBe(false);
-    expect(queuedepthvalid({}).allowed).toBe(true);
-  });
-});
-
-describe("idempotent replays", () => {
-  it("deduplicates the replays of one step through its stepkey", () => {
-    const key = stepkey({ planid: "plan", stepid: "s1", kind: "click" });
-    expect(key).toBe("plan:s1:click");
-    expect(stepkey({ planid: "plan", stepid: "s1", kind: "click" })).toBe(key);
-    expect(stepkey({ planid: "plan", stepid: "s2", kind: "click" })).not.toBe(key);
-    expect(() => stepkey({ planid: " ", stepid: "s1", kind: "click" })).toThrow(/plan and step ids/i);
-    expect(replaycheck({ key, executedkeys: [] }).allowed).toBe(true);
-    expect(replaycheck({ key, executedkeys: [key] }).allowed).toBe(false);
-    expect(replaycheck({ key: " ", executedkeys: [] }).allowed).toBe(false);
-  });
-
-  it("refuses the steps of queued, cancelled and rolledback runs and stale sensitive heartbeats inside canexecute", () => {
-    const base = { session, plan, step: clickstep, tabid: 4, origin: "https://example.com", now };
-    const fresh = { run: runof("running"), heartbeat: { runid: "run1", beat: 2, at: now - 1_000 } };
-    expect(canexecute(base).allowed).toBe(true);
-    expect(canexecute({ ...base, run: runof("queued") }).allowed).toBe(false);
-    expect(canexecute({ ...base, run: runof("cancelled") }).allowed).toBe(false);
-    expect(canexecute({ ...base, run: runof("rolledback") }).allowed).toBe(false);
-    expect(canexecute({ ...base, ...fresh }).allowed).toBe(true);
-    expect(canexecute({ ...base, run: runof("running") }).allowed).toBe(false);
-    expect(
-      canexecute({ ...base, run: runof("running"), heartbeat: { runid: "run1", beat: 2, at: now - 120_000 } }).allowed,
-    ).toBe(false);
-    expect(
-      canexecute({
-        ...base,
-        run: runof("running"),
-        heartbeat: { runid: "run1", beat: 2, at: now - 120_000 },
-        settings: { heartbeatwindow: 300_000 },
-      }).allowed,
-    ).toBe(true);
-  });
-});
-
-describe("resilience protocol", () => {
-  it("parses the resumedfrom marker, refuses colliding idempotencykeys and carries the run context", () => {
-    const proposal = {
-      version: protocolversion,
-      plan: {
-        id: "plan",
-        objective: "Submit once",
-        origin: "https://example.com",
-        steps: [
-          {
-            id: "s1",
-            kind: "click",
-            target: "#submit",
-            summary: "Click the reviewed submit control.",
-            idempotencykey: "plan:s1:click",
-          },
-          { id: "s2", kind: "observe", summary: "Read the page.", idempotencykey: "plan:s2:observe" },
-        ],
-      },
-    };
-    const parsed = parseproposal(proposal, "https://example.com");
-    expect(parsed.resumedfrom).toBeUndefined();
-    expect(parsed.plan.steps[0]?.idempotencykey).toBe("plan:s1:click");
-    const resumed = parseproposal({ ...proposal, resumedfrom: ["s1"] }, "https://example.com");
-    expect(resumed.resumedfrom).toEqual(["s1"]);
-    expect(() => parseproposal({ ...proposal, resumedfrom: ["sX"] }, "https://example.com")).toThrow(/does not carry/i);
-    expect(() =>
-      parseproposal(
-        {
-          ...proposal,
-          plan: {
-            ...proposal.plan,
-            steps: [
-              { id: "s1", kind: "click", target: "#submit", summary: "Click", idempotencykey: "same" },
-              { id: "s2", kind: "observe", summary: "Read", idempotencykey: "same" },
-            ],
-          },
-        },
-        "https://example.com",
-      ),
-    ).toThrow(/idempotencykey/i);
-    const body = JSON.parse(
-      requestbody({
-        objective: "o",
-        session,
-        observation: {
-          schemaversion: 1,
-          url: "https://example.com",
-          title: "t",
-          textpreview: "",
-          textlength: 0,
-          forms: [],
-          interactive: [],
-          capturedat: now,
-        },
-        capabilities: { tabs: false, downloads: false, clipboardread: false, clipboardwrite: false, reportedat: now },
-        runstate: "queued",
-        queuedepth: 2,
-      }),
-    );
-    expect(body.runstate).toBe("queued");
-    expect(body.queuedepth).toBe(2);
-  });
-});
-
-describe("resilience memory", () => {
-  it("persists runs, checkpoints, heartbeats, the queue, the rollbacks, the executed keys and the user choices", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.setrunrecord(runof("running"));
-    await store.setrunrecord({ ...runof("running"), runid: "run2", updatedat: now - 5 });
-    expect((await store.getrunrecord("run1"))?.state).toBe("running");
-    expect((await store.listruns()).map((run) => run.runid)).toEqual(["run1", "run2"]);
-    await store.setcheckpoint(
-      makecheckpoint({ runid: "run1", stepid: "s1", completed: ["s1"], digest: "digest1", now }),
-    );
-    expect((await store.getcheckpoint("run1"))?.stepid).toBe("s1");
-    expect(await store.getcheckpoint("run2")).toBeUndefined();
-    await store.setheartbeat(runheartbeat({ runid: "run1", now }));
-    expect((await store.getheartbeat("run1"))?.beat).toBe(1);
-    await store.setqueue(enqueueoffline([], { plan, sessionid: "session", now }));
-    expect(queuesize(await store.getqueue())).toBe(1);
-    await store.addrollback({
-      runid: "run1",
-      stepid: "s1",
-      kind: "click",
-      origin: "https://example.com",
-      compensation: "report the outcome",
-      at: now,
-    });
-    expect(await store.listrollbacks("run1")).toHaveLength(1);
-    await store.addexecutedkey("run1", "plan:s1:click");
-    expect(await store.getexecutedkeys("run1")).toEqual(["plan:s1:click"]);
-    await store.setheartbeatwindow(120_000);
-    expect(await store.getheartbeatwindow()).toBe(120_000);
-    await store.setqueuedepthsetting(7);
-    expect(await store.getqueuedepthsetting()).toBe(7);
-    await store.setrunrecord({ ...runof("failed"), updatedat: now - 500_000 });
-    const pruned = await store.pruneruns(60_000, now);
-    expect(pruned.pruned).toEqual(["run1"]);
-    expect(pruned.kept.map((run) => run.runid)).toEqual(["run2"]);
-    expect((await store.pruneruns(undefined, now)).pruned).toHaveLength(0);
-  });
-
-  it("summarizes one run with its state, step counts and checkpoint position", () => {
-    const summary = runsummaryof({
-      run: runof("running"),
-      plan,
-      progress: { planid: "plan", completedsteps: ["s1"], updatedat: now },
-      checkpoint: makecheckpoint({ runid: "run1", stepid: "s1", completed: ["s1"], digest: "digest1", now }),
-    });
-    expect(summary).toEqual({
-      runid: "run1",
-      state: "running",
-      steps: 2,
-      completed: 1,
-      checkpointstep: "s1",
-      updatedat: now,
-    });
-    expect(runsummaryof({ run: runof("queued"), plan }).completed).toBe(0);
-  });
-});

package/tests/resourceaware.test.ts

@@ -1,187 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  artifactcompressof,
-  artifactreadplan,
-  batteryawarestateof,
-  logpruneplan,
-  networkbackoff,
-  suspendplan,
-  tabsuspendrestoreplan,
-  tabsuspendstateof,
-} from "../perf.js";
-import { logprunegate, suspendwindowvalid } from "../policy.js";
-import { carrywarmselector, joinlanes, openlanes, readparallelgroupof, warmselectorcarryvalid } from "../run.js";
-import { sessionmemory } from "../memory.js";
-
-const now = 1_800_000_000_000;
-
-class fakeadapter {
-  private readonly data = new Map<string, unknown>();
-  async get<T>(key: string): Promise<T | undefined> {
-    return this.data.get(key) as T | undefined;
-  }
-  async set<T>(key: string, value: T): Promise<void> {
-    this.data.set(key, value);
-  }
-}
-
-describe("tabsuspend", () => {
-  it("discards idle tabs only during waits longer than the user window", () => {
-    expect(suspendplan({ waitduration: 9000, window: 5000 }).suspend).toBe(true);
-    expect(suspendplan({ waitduration: 4000, window: 5000 }).suspend).toBe(false);
-    expect(suspendplan({ waitduration: 9000 }).suspend).toBe(false);
-    expect(suspendplan({ waitduration: 9000 }).reason).toMatch(/no suspend window/i);
-    expect(suspendwindowvalid({ window: 5000 }).allowed).toBe(true);
-    expect(suspendwindowvalid({}).reason).toMatch(/never suspend/i);
-    expect(suspendwindowvalid({ window: 0 }).allowed).toBe(false);
-  });
-
-  it("restores a tab before the next step that needs it and preserves the run state across the suspend and restore", () => {
-    const state = tabsuspendstateof({
-      tabid: 7,
-      runid: "run1",
-      restoreurl: "https://example.com/a",
-      discarded: true,
-      now,
-    });
-    expect(state.discarded).toBe(true);
-    expect(() =>
-      tabsuspendstateof({ tabid: 7, runid: " ", restoreurl: "https://example.com/a", discarded: false, now }),
-    ).toThrow(/run id/i);
-    const restore = tabsuspendrestoreplan({ state, nextneedsurl: "https://example.com/a" });
-    expect(restore.restore).toBe(true);
-    expect(restore.reload).toBe(true);
-    const other = tabsuspendrestoreplan({ state, nextneedsurl: "https://example.com/b" });
-    expect(other.restore).toBe(false);
-    const intact = tabsuspendrestoreplan({
-      state: { ...state, discarded: false },
-      nextneedsurl: "https://example.com/a",
-    });
-    expect(intact.reload).toBe(false);
-    expect(tabsuspendrestoreplan({ state, nextneedsurl: "" }).restore).toBe(true);
-  });
-
-  it("stores and clears the tabsuspend states per run", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.setsuspendstate(
-      tabsuspendstateof({ tabid: 7, runid: "run1", restoreurl: "https://example.com/a", discarded: false, now }),
-    );
-    expect(await store.getsuspendstates()).toHaveLength(1);
-    await store.clearsuspendstate("run1");
-    expect(await store.getsuspendstates()).toHaveLength(0);
-  });
-});
-
-describe("artifactcompress", () => {
-  it("compresses captures and logs at rest and decompresses them lazily on read", () => {
-    const record = artifactcompressof({ artifactid: "cap1", codec: "deflate", now });
-    expect(record.lazy).toBe(true);
-    expect(artifactreadplan(record).decode).toBe("lazy");
-    expect(artifactreadplan(record).reason).toMatch(/lazily on read/i);
-    expect(artifactcompressof({ artifactid: "cap1", now }).codec).toBe("store");
-    expect(artifactreadplan(artifactcompressof({ artifactid: "cap1", codec: "store", lazy: false, now })).decode).toBe(
-      "immediate",
-    );
-    expect(() => artifactcompressof({ artifactid: " ", now })).toThrow(/artifact id/i);
-  });
-
-  it("stores the artifactcompress records of the profile workspace", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.addartifactcompress(artifactcompressof({ artifactid: "cap1", codec: "deflate", now }));
-    expect(await store.getartifactcompress()).toHaveLength(1);
-    await store.addartifactcompress(artifactcompressof({ artifactid: "cap1", codec: "store", now }));
-    expect(await store.getartifactcompress()).toHaveLength(1);
-  });
-});
-
-describe("logprune", () => {
-  it("removes sealed logs past the user retention window while it prunes whole sealed runs only", () => {
-    const sealed = [
-      { runid: "old1", sealedat: now - 20_000, bytes: 100, sealed: true },
-      { runid: "fresh", sealedat: now - 100, bytes: 100, sealed: true },
-      { runid: "big", sealedat: now - 100, bytes: 900, sealed: true },
-      { runid: "open", sealedat: now - 20_000, bytes: 100, sealed: false },
-    ];
-    const plan = logpruneplan({ sealed, rule: { retention: 10_000, sizewindow: 500 }, now });
-    expect(plan.prune).toEqual(["old1", "big"]);
-    expect(plan.keep).toEqual(["fresh"]);
-    expect(plan.refused).toEqual(["open"]);
-    expect(logprunegate({ plan: { prune: plan.prune, refused: plan.refused }, sealed }).allowed).toBe(true);
-    expect(logprunegate({ plan: { prune: ["open"], refused: [] }, sealed }).allowed).toBe(false);
-    expect(logprunegate({ plan: { prune: ["open"], refused: [] }, sealed }).reason).toMatch(/whole sealed runs only/i);
-    expect(logpruneplan({ sealed, rule: {}, now }).prune).toEqual([]);
-  });
-});
-
-describe("batteryaware", () => {
-  it("defers non urgent scheduled runs on low battery and never cancels a run", () => {
-    const low = batteryawarestateof({ level: 0.15, charging: false, floor: 0.3, scheduled: ["r1", "r2"], now });
-    expect(low.deferred).toEqual(["r1", "r2"]);
-    const charged = batteryawarestateof({ level: 0.15, charging: true, floor: 0.3, scheduled: ["r1"], now });
-    expect(charged.deferred).toEqual([]);
-    const high = batteryawarestateof({ level: 0.8, charging: false, floor: 0.3, scheduled: ["r1"], now });
-    expect(high.deferred).toEqual([]);
-    expect(batteryawarestateof({ level: 2, charging: false, scheduled: [], now }).level).toBe(1);
-    expect(batteryawarestateof({ level: 0.1, charging: false, scheduled: ["r1"], now }).deferred).toEqual([]);
-  });
-});
-
-describe("networkaware", () => {
-  it("adapts the retry backoff to the failure kind and honors the server signals when present", () => {
-    const rules = [
-      { failurekind: "ratelimit", backoff: 5000 },
-      { failurekind: "servererror", backoff: 2000 },
-    ];
-    expect(networkbackoff({ failurekind: "ratelimit", rules })).toBe(5000);
-    expect(networkbackoff({ failurekind: "servererror", rules })).toBe(2000);
-    expect(networkbackoff({ failurekind: "unknown", rules })).toBe(0);
-    expect(networkbackoff({ failurekind: "ratelimit", rules, serversignal: 30_000 })).toBe(30_000);
-  });
-});
-
-describe("readparallel", () => {
-  it("groups independent page reads into parallel lanes and joins them before the dependent steps", () => {
-    const group = readparallelgroupof({
-      runid: "run1",
-      reads: [
-        { stepid: "s1", origin: "https://a.example" },
-        { stepid: "s2", origin: "https://b.example" },
-        { stepid: "s3", origin: "https://c.example" },
-      ],
-      lanes: 2,
-    });
-    expect(group.lanes).toHaveLength(2);
-    expect(group.joined).toBe(false);
-    expect(openlanes(group)).toHaveLength(2);
-    const joined = joinlanes(group);
-    expect(joined.joined).toBe(true);
-    expect(
-      readparallelgroupof({ runid: "run1", reads: [{ stepid: "s1", origin: "https://a.example" }] }).lanes,
-    ).toHaveLength(1);
-    expect(() => readparallelgroupof({ runid: " ", reads: [] })).toThrow(/run id/i);
-  });
-});
-
-describe("warmselectors", () => {
-  it("carries validated selectors between adjacent steps and revalidates on a fingerprint change only", () => {
-    const record = carrywarmselector({
-      selector: "#button",
-      resolution: "resolved:#button",
-      fingerprint: "fp1",
-      from: "s1",
-    });
-    expect(record.carriedfrom).toBe("s1");
-    expect(() => carrywarmselector({ selector: " ", resolution: "r", fingerprint: "fp1", from: "s1" })).toThrow(
-      /selector/i,
-    );
-    expect(() => carrywarmselector({ selector: "#button", resolution: "r", fingerprint: " ", from: "s1" })).toThrow(
-      /fingerprint/i,
-    );
-    const valid = warmselectorcarryvalid({ record, fingerprint: "fp1" });
-    expect(valid.carry).toBe(true);
-    expect(valid.reason).toMatch(/no revalidation/i);
-    const changed = warmselectorcarryvalid({ record, fingerprint: "fp2" });
-    expect(changed.carry).toBe(false);
-    expect(changed.reason).toMatch(/revalidates/i);
-  });
-});