@wenathlan/devthink 2.0.15 → 2.0.19

package/tests/runbudget.test.ts

@@ -1,125 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  budgetalertstate,
-  runbudgetof,
-  runpausesforalerts,
-  timeoutcanceldecision,
-  timeoutcanceleventof,
-  timeoutcancelpolicies,
-} from "../run.js";
-import { budgetthresholdsvalid, runbudgetvalid, timeoutboundvalid, timeoutrecordeventgate } from "../policy.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("runbudget tracking", () => {
-  it("tracks the step usage and the memory pressure of one run against the user budgets", () => {
-    const budget = runbudgetof({ runid: "run1", steps: 8, stepbudget: 10, pressure: 0.75, memorybudget: 0.8, now });
-    expect(budget).toEqual({ runid: "run1", steps: 8, stepbudget: 10, pressure: 0.75, memorybudget: 0.8, at: now });
-    expect(runbudgetof({ runid: "run1", steps: 3, pressure: 1.5, now }).pressure).toBe(1);
-    expect(() => runbudgetof({ runid: " ", steps: 1, pressure: 0, now })).toThrow(/run id/i);
-    expect(runbudgetvalid({ stepbudget: 10, memorybudget: 0.8 }).allowed).toBe(true);
-    expect(runbudgetvalid({}).reason).toMatch(/informational/i);
-    expect(runbudgetvalid({ stepbudget: 0 }).allowed).toBe(false);
-    expect(runbudgetvalid({ memorybudget: 2 }).allowed).toBe(false);
-  });
-
-  it("fires budgetalerts at the user thresholds with severity levels and pauses only at the critical level", () => {
-    const budget = runbudgetof({ runid: "run1", steps: 9, stepbudget: 10, pressure: 0.95, memorybudget: 0.8, now });
-    const alerts = budgetalertstate({ budget, thresholds: { warning: 0.8, critical: 0.9 } });
-    expect(alerts).toHaveLength(2);
-    expect(alerts.every((alert) => alert.level === "critical")).toBe(true);
-    expect(alerts.every((alert) => alert.paused)).toBe(true);
-    expect(runpausesforalerts(alerts)).toBe(true);
-    const warning = budgetalertstate({
-      budget: runbudgetof({ runid: "run1", steps: 5, stepbudget: 10, pressure: 0.5, memorybudget: 0.8, now }),
-      thresholds: { warning: 0.8, critical: 0.9 },
-    });
-    expect(warning).toHaveLength(0);
-    const mixed = budgetalertstate({
-      budget: runbudgetof({ runid: "run1", steps: 5, stepbudget: 6, pressure: 0.5, memorybudget: 0.8, now }),
-      thresholds: { warning: 0.8, critical: 0.9 },
-    });
-    expect(mixed).toHaveLength(1);
-    expect(mixed[0]?.level).toBe("warning");
-    expect(mixed[0]?.paused).toBe(false);
-    expect(runpausesforalerts(mixed)).toBe(false);
-    expect(budgetthresholdsvalid({ thresholds: { warning: 0.8, critical: 0.9 } }).allowed).toBe(true);
-    expect(budgetthresholdsvalid({ thresholds: { warning: 0.9, critical: 0.8 } }).allowed).toBe(false);
-    expect(budgetthresholdsvalid({}).reason).toMatch(/informational/i);
-  });
-
-  it("stores the runbudget records and the budgetalerts of the profile workspace", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    const budget = runbudgetof({ runid: "run1", steps: 5, stepbudget: 10, pressure: 0.5, memorybudget: 0.8, now });
-    await store.addrunbudget(budget);
-    await store.addrunbudget(runbudgetof({ runid: "run2", steps: 1, pressure: 0, now }));
-    expect(await store.getrunbudgets()).toHaveLength(2);
-    await store.addrunbudget(
-      runbudgetof({ runid: "run1", steps: 6, stepbudget: 10, pressure: 0.5, memorybudget: 0.8, now }),
-    );
-    const latest = (await store.getrunbudgets()).find((record) => record.runid === "run1");
-    expect(latest?.steps).toBe(6);
-    const alert = budgetalertstate({ budget: latest!, thresholds: { critical: 0.5 } })[0]!;
-    await store.addbudgetalert(alert);
-    expect(await store.getbudgetalerts()).toHaveLength(1);
-    expect((await store.getbudgetalerts())[0]?.paused).toBe(true);
-  });
-});
-
-describe("timeoutcancel", () => {
-  it("aborts a slow step at the user chosen bound and never aborts without one", () => {
-    expect(timeoutcanceldecision({ elapsed: 300, bound: 500 }).abort).toBe(false);
-    const aborted = timeoutcanceldecision({ elapsed: 700, bound: 500 });
-    expect(aborted.abort).toBe(true);
-    expect(aborted.reason).toMatch(/aborts/i);
-    expect(timeoutcanceldecision({ elapsed: 700 }).abort).toBe(false);
-    expect(timeoutboundvalid({ bound: 500 }).reason).toMatch(/immutable log/i);
-    expect(timeoutboundvalid({}).reason).toMatch(/never abort/i);
-    expect(timeoutboundvalid({ bound: 0 }).allowed).toBe(false);
-  });
-
-  it("records the cancel event beside the step outcome and requires its immutable log entry", () => {
-    const event = timeoutcanceleventof({ runid: "run1", stepid: "s1", bound: 500, elapsed: 700, now, logged: true });
-    expect(event.logged).toBe(true);
-    expect(event.bound).toBe(500);
-    expect(() => timeoutcanceleventof({ runid: " ", stepid: "s1", bound: 1, elapsed: 1, now, logged: true })).toThrow(
-      /run id/i,
-    );
-    expect(() => timeoutcanceleventof({ runid: "run1", stepid: " ", bound: 1, elapsed: 1, now, logged: true })).toThrow(
-      /step id/i,
-    );
-    expect(timeoutrecordeventgate({ event: { logged: true, stepid: "s1" } }).allowed).toBe(true);
-    expect(timeoutrecordeventgate({ event: { logged: false, stepid: "s1" } }).allowed).toBe(false);
-    expect(timeoutrecordeventgate({ event: { logged: false, stepid: "s1" } }).reason).toMatch(/immutable log/i);
-    const policies = timeoutcancelpolicies({ steps: ["s1", "s2"], bound: 500 });
-    expect(policies).toEqual([
-      { stepid: "s1", bound: 500 },
-      { stepid: "s2", bound: 500 },
-    ]);
-    expect(timeoutcancelpolicies({ steps: ["s1"] })[0]?.bound).toBeUndefined();
-  });
-
-  it("stores the timeoutcancel events of the profile workspace", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.addtimeoutevent(
-      timeoutcanceleventof({ runid: "run1", stepid: "s1", bound: 500, elapsed: 700, now, logged: true }),
-    );
-    const events = await store.gettimeoutevents();
-    expect(events).toHaveLength(1);
-    expect(events[0]?.stepid).toBe("s1");
-    expect(timeoutrecordeventgate({ event: { logged: events[0]!.logged, stepid: events[0]!.stepid } }).allowed).toBe(
-      true,
-    );
-  });
-});

package/tests/runhistory.test.ts

@@ -1,299 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  appendvisit,
-  auditeventof,
-  buckettimeline,
-  finalurlof,
-  lockblocks,
-  lockwindowof,
-  releasesessionlock,
-  acquiresessionlock,
-  runtimelineof,
-  runwithvisits,
-  sessionwithlock,
-  stepeventof,
-  stalelocks,
-  tabisolate,
-  tabkey,
-  tabnamespace,
-  visitof,
-  visitsummary,
-} from "../run.js";
-import {
-  lockwindowvalid,
-  sessionlockgate,
-  tabisolategate,
-  urlhistorygate,
-  urlhistoryscopegate,
-  timelinereadonlygate,
-} from "../policy.js";
-import { memoryitemframe, parseproposal, requestbody, runtimelinereport, urlvisitscheck } from "../protocol.js";
-import { sessionmemory } from "../memory.js";
-import {
-  protocolversion,
-  type agentplan,
-  type agentsession,
-  type auditevent,
-  type lockrecord,
-  type runrecord,
-  type toolstep,
-  type urlvisit,
-} 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(runid: string): runrecord {
-  return { runid, planid: "plan", sessionid: "session", state: "running", 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("urlhistory", () => {
-  it("appends one urlvisit per navigation, folds consecutive duplicates and stays scoped per run", () => {
-    const first = visitof({ url: "https://example.com/start", title: "Start", runid: "run1", now });
-    expect(first).toEqual({ url: "https://example.com/start", title: "Start", at: now, runid: "run1" });
-    expect(() => visitof({ url: " ", runid: "run1", now })).toThrow(/url/i);
-    expect(() => visitof({ url: "https://example.com", runid: " ", now })).toThrow(/run id/i);
-    const second = visitof({ url: "https://example.com/start", runid: "run1", now: now + 500 });
-    const folded = appendvisit([first], second);
-    expect(folded).toHaveLength(1);
-    expect(folded[0]?.at).toBe(now + 500);
-    const other = visitof({ url: "https://example.com/next", runid: "run1", now: now + 900 });
-    expect(appendvisit(folded, other)).toHaveLength(2);
-    const foreignrun = visitof({ url: "https://example.com/start", runid: "run2", now: now + 901 });
-    expect(appendvisit(folded, foreignrun)).toHaveLength(2);
-    expect(urlhistoryscopegate({ visits: [first, foreignrun], runid: "run1" }).allowed).toBe(false);
-    expect(urlhistoryscopegate({ visits: [first], runid: "run1" }).allowed).toBe(true);
-    expect(
-      urlhistorygate({ visit: { url: "https://example.com/page", runid: "run1" }, origin: "https://example.com" })
-        .allowed,
-    ).toBe(true);
-    expect(
-      urlhistorygate({ visit: { url: "https://evil.example/page", runid: "run1" }, origin: "https://example.com" })
-        .allowed,
-    ).toBe(false);
-    expect(
-      urlhistorygate({
-        visit: { url: "https://other.example/page", runid: "run1" },
-        origin: "https://example.com",
-        grants: ["https://other.example"],
-      }).allowed,
-    ).toBe(true);
-    expect(
-      urlvisitscheck({
-        visits: [first, visitof({ url: "https://evil.example/x", runid: "run1", now })],
-        origin: "https://example.com",
-      }),
-    ).toEqual({ ok: false, refused: ["https://evil.example/x"] });
-    const summary = visitsummary([first, other]);
-    expect(summary).toEqual({ count: 2, origins: ["https://example.com"], first: now, last: now + 900 });
-    const carried = runwithvisits(runof("run1"), [first, other, foreignrun]);
-    expect(carried.visits).toHaveLength(2);
-    expect(finalurlof({ plannedurl: "https://example.com/a" })).toBe("https://example.com/a");
-    expect(finalurlof({ plannedurl: "https://example.com/a", finalurl: "https://example.com/b" })).toBe(
-      "https://example.com/b",
-    );
-  });
-});
-
-describe("runtimeline", () => {
-  it("merges step results, audit events and url visits into one ordered stream and buckets the phases", () => {
-    const steps = [stepeventof({ runid: "run1", stepid: "s1", summary: "clicked", ok: true, now: now + 100 })];
-    const audits: auditevent[] = [
-      {
-        id: "a1",
-        kind: "approval",
-        at: now + 50,
-        summary: "The user approved the plan.",
-        sessionid: "session",
-        planid: "plan",
-      },
-      {
-        id: "a2",
-        kind: "visit",
-        at: now + 150,
-        summary: "The run visited the page.",
-        sessionid: "session",
-        planid: "plan",
-      },
-    ];
-    const visits: urlvisit[] = [visitof({ url: "https://example.com/start", runid: "run1", now: now + 75 })];
-    const merged = runtimelineof({ steps, audits: audits.map(auditeventof), visits, runid: "run1" });
-    expect(merged.map((event) => event.at)).toEqual([now + 50, now + 75, now + 100, now + 150]);
-    expect(merged.map((event) => event.source)).toEqual(["audit", "visit", "step", "audit"]);
-    const buckets = buckettimeline(merged);
-    expect(buckets.map((bucket) => bucket.phase).sort()).toEqual(["audit", "route", "steps"]);
-    expect(buckets.find((bucket) => bucket.phase === "route")?.events).toHaveLength(1);
-    const failed = stepeventof({ runid: "run1", stepid: "s2", summary: "broke", ok: false, now: now + 200 });
-    expect(buckettimeline([failed]).map((bucket) => bucket.phase)).toEqual(["failures"]);
-    const report = runtimelinereport({ runid: "run1", events: merged, buckets });
-    expect(report.version).toBe(protocolversion);
-    expect(report.buckets.find((bucket) => bucket.phase === "steps")?.count).toBe(1);
-    expect(timelinereadonlygate({ operation: "view" }).allowed).toBe(true);
-    expect(timelinereadonlygate({ operation: "execute the step" }).allowed).toBe(false);
-  });
-
-  it("persists the urlhistory and the runtimeline per run through the memory accessors", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    await store.setrunrecord(runof("run1"));
-    const visit = visitof({ url: "https://example.com/start", title: "Start", runid: "run1", now });
-    await store.setvisits("run1", appendvisit([], visit));
-    expect(await store.getvisits("run1")).toEqual([visit]);
-    expect(await store.getvisits("run2")).toEqual([]);
-    const event = stepeventof({ runid: "run1", stepid: "s1", summary: "clicked", ok: true, now });
-    await store.appendtimelineevent(event);
-    await store.appendtimelineevent(
-      stepeventof({ runid: "run1", stepid: "s2", summary: "read", ok: true, now: now + 10 }),
-    );
-    expect((await store.getruntimeline("run1")).map((entry) => entry.stepid)).toEqual(["s1", "s2"]);
-    const record = await store.getexport(now);
-    expect(record.timeline).toHaveLength(2);
-    expect(record.expiryrules).toEqual([]);
-  });
-});
-
-describe("sessionlock", () => {
-  it("acquires, blocks the concurrent run by naming the holder, releases and expires with the user window", () => {
-    const lock = acquiresessionlock({ runid: "run1", sessionid: "session", window: 120_000, now });
-    expect(lock).toEqual({
-      holder: "run1",
-      runid: "run1",
-      sessionid: "session",
-      acquiredat: now,
-      expiresat: now + 120_000,
-    });
-    expect(() => acquiresessionlock({ runid: " ", sessionid: "session", window: 1, now })).toThrow(/run id/i);
-    expect(lockblocks(lock, "run1", now + 1).blocked).toBe(false);
-    const blocked = lockblocks(lock, "run2", now + 1);
-    expect(blocked.blocked).toBe(true);
-    expect(blocked.reason).toContain("run1");
-    expect(lockblocks(lock, "run2", now + 121_000).blocked).toBe(false);
-    expect(lockblocks(undefined, "run2", now).blocked).toBe(false);
-    expect(releasesessionlock(lock, "run1")).toBe(true);
-    expect(releasesessionlock(lock, "run2")).toBe(false);
-    expect(releasesessionlock(undefined, "run1")).toBe(false);
-    expect(
-      stalelocks([lock, { ...lock, runid: "run2", holder: "run2", expiresat: now + 999_999 }], now + 121_000).map(
-        (entry) => entry.runid,
-      ),
-    ).toEqual(["run1"]);
-    expect(lockwindowof(undefined)).toBe(120_000);
-    expect(lockwindowof({ lockwindow: 300_000 })).toBe(300_000);
-    expect(lockwindowvalid({ window: 300_000 }).allowed).toBe(true);
-    expect(lockwindowvalid({ window: 0 }).allowed).toBe(false);
-    expect(sessionlockgate({ lock, runid: "run2", now: now + 1 }).allowed).toBe(false);
-    expect(sessionlockgate({ lock, runid: "run1", now: now + 1 }).allowed).toBe(true);
-    expect(sessionlockgate({ lock, runid: "run2", now: now + 121_000 }).allowed).toBe(true);
-    const locked = sessionwithlock(session, lock.runid);
-    expect(locked.lockid).toBe("run1");
-    expect(sessionwithlock(session, undefined).lockid).toBeUndefined();
-    const lock2: lockrecord = { ...lock, holder: "run1", runid: "run1" };
-    expect(lock2.holder).toBe("run1");
-  });
-
-  it("isolates the memory keys per tabid through the tabisolate namespace", () => {
-    expect(tabnamespace(4)).toBe("tab:4");
-    expect(tabkey(4, "plan")).toBe("tab:4:plan");
-    expect(() => tabkey(4, " ")).toThrow(/key/i);
-    const state = tabisolate({ tabid: 4, config: { planid: "plan" }, runid: "run1", now });
-    expect(state.namespace).toBe("tab:4");
-    expect(state.config).toEqual({ planid: "plan" });
-    expect(state.runid).toBe("run1");
-    expect(() => tabisolate({ tabid: Number.NaN, config: {}, now })).toThrow(/tab id/i);
-    expect(tabisolategate({ namespace: "tab:4", tabid: 4, runid: "run1" }).allowed).toBe(true);
-    expect(tabisolategate({ namespace: "tab:4", tabid: 5, runid: "run1" }).allowed).toBe(false);
-    expect(tabisolategate({ namespace: " ", tabid: 5 }).allowed).toBe(true);
-  });
-
-  it("persists the lockrecord and the tabstate through the memory accessors", async () => {
-    const store = new sessionmemory(new fakeadapter());
-    const lock = acquiresessionlock({ runid: "run1", sessionid: "session", window: 120_000, now });
-    await store.setlock(lock);
-    expect(await store.getlock("session")).toEqual(lock);
-    await store.setlock({ ...lock, runid: "run2", holder: "run2" });
-    expect((await store.listlocks()).map((entry) => entry.runid)).toEqual(["run2"]);
-    await store.clearlock("session");
-    expect(await store.getlock("session")).toBeUndefined();
-    await store.settabstate(tabisolate({ tabid: 4, config: { planid: "plan" }, runid: "run1", now }));
-    expect((await store.gettabstate(4))?.namespace).toBe("tab:4");
-    expect(await store.gettabstate(5)).toBeUndefined();
-  });
-
-  it("preserves the lockid across proposal replays and carries the tab namespace with the observation provenance", () => {
-    const proposal = {
-      version: protocolversion,
-      plan: {
-        id: "plan",
-        objective: "Submit once",
-        origin: "https://example.com",
-        steps: [{ id: "s1", kind: "observe", summary: "Read the page." }],
-      },
-      lockid: "run1",
-    };
-    const parsed = parseproposal(proposal, "https://example.com");
-    expect(parsed.lockid).toBe("run1");
-    expect(
-      parseproposal({ version: protocolversion, plan: proposal.plan }, "https://example.com").lockid,
-    ).toBeUndefined();
-    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: "running",
-        tabnamespace: "tab:4",
-        provenance: [{ origin: "https://example.com", runid: "run1", stepid: "s1", capturedat: now }],
-      }),
-    );
-    expect(body.tabnamespace).toBe("tab:4");
-    expect(body.provenance).toEqual([{ origin: "https://example.com", runid: "run1", stepid: "s1", capturedat: now }]);
-    expect(() =>
-      memoryitemframe({
-        key: "k",
-        value: 1,
-        provenance: { origin: "https://example.com", runid: "run1", capturedat: now },
-      }),
-    ).toThrow(/provenance/i);
-  });
-});

package/tests/runreplay.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { appendlogentry, openrunlog, sealrunlog, verifylogchain } from "../security.js";
-import {
-  replaycursorof,
-  replayjump,
-  replaymove,
-  replayplay,
-  replayrestoredview,
-  replaystepof,
-  replayviewaction,
-  runreplaysessionof,
-} from "../run.js";
-import { runreplaygate } from "../policy.js";
-
-const now = 1_800_000_000_000;
-
-async function sealedlog() {
-  let log = openrunlog({ runid: "run1", sessionid: "run1", now });
-  log = await appendlogentry({
-    log,
-    kind: "step",
-    summary: "The focus step s1 completed on https://example.com with observation 4.",
-    origin: "https://example.com",
-    stepid: "s1",
-    at: now + 1000,
-  });
-  log = await appendlogentry({
-    log,
-    kind: "gate",
-    summary: "The confirmpay gate opened for s2 and resolved after a human action; the capture c-99 evidences it.",
-    origin: "https://example.com",
-    stepid: "s2",
-    at: now + 2000,
-  });
-  log = await appendlogentry({
-    log,
-    kind: "step",
-    summary: "The click step s2 completed.",
-    origin: "https://example.com",
-    stepid: "s2",
-    at: now + 3000,
-  });
-  return sealrunlog(log, now + 4000);
-}
-
-describe("runreplay of sealed runs", () => {
-  it("gates the replay to sealed runs with verified chains", () => {
-    expect(runreplaygate({ sealed: false, chainvalid: true }).allowed).toBe(false);
-    expect(runreplaygate({ sealed: false, chainvalid: true }).reason).toMatch(/sealed runs only/);
-    expect(runreplaygate({ sealed: true, chainvalid: false }).allowed).toBe(false);
-    expect(runreplaygate({ sealed: true, chainvalid: true }).allowed).toBe(true);
-  });
-
-  it("walks the sealed chain step by step and restores observation and capture refs", async () => {
-    const sealed = await sealedlog();
-    const gates = [{ gateid: "s2", kind: "confirmpay", resolution: "approve", at: now + 2500 }];
-    const session = runreplaysessionof({ runid: sealed.seal.runid, entries: sealed.log.entries, gates, now });
-    expect(session.steps).toHaveLength(3);
-    expect(session.cursor).toBe(0);
-    expect(session.playing).toBe(false);
-    expect(session.steps[0]?.observationversion).toBe(4);
-    expect(session.steps[1]?.captureid).toBe("c-99");
-    expect(session.steps[1]?.gateresolutions).toHaveLength(1);
-    expect(session.steps[2]?.gateresolutions).toHaveLength(1);
-    expect(session.steps[0]?.gateresolutions).toHaveLength(0);
-    expect(() => runreplaysessionof({ runid: " ", entries: sealed.log.entries, now })).toThrow(/run id/);
-    expect(() => runreplaysessionof({ runid: "r", entries: [], now })).toThrow(/at least one/);
-    const step = replaystepof(sealed.log.entries[0] as never, 0, gates);
-    expect(step.summary).toMatch(/observation 4/);
-  });
-
-  it("steps forward, backward and jumps to a chosen step with viewer actions recorded", async () => {
-    const sealed = await sealedlog();
-    const session = runreplaysessionof({ runid: sealed.seal.runid, entries: sealed.log.entries, now });
-    const forward = replaymove(session, "forward", now + 10);
-    expect(forward.cursor).toBe(1);
-    expect(forward.actions[forward.actions.length - 1]?.kind).toBe("step");
-    const backward = replaymove(forward, "backward", now + 20);
-    expect(backward.cursor).toBe(0);
-    const jumped = replayjump(backward, "s2", now + 30);
-    expect(jumped.cursor).toBe(1);
-    expect(jumped.actions[jumped.actions.length - 1]?.stepid).toBe("s2");
-    expect(() => replayjump(backward, "unknown", now)).toThrow(/knows no unknown/);
-    const played = replayplay(jumped, true, now + 40);
-    expect(played.playing).toBe(true);
-    const paused = replayplay(played, false, now + 50);
-    expect(paused.playing).toBe(false);
-    const acted = replayviewaction(paused, { kind: "pause", at: now + 60 });
-    expect(acted.actions).toHaveLength(6);
-    const edge = replaymove(session, "backward", now + 70);
-    expect(edge.cursor).toBe(0);
-    const last = replaymove(replaymove(replaymove(session, "forward", now), "forward", now), "forward", now);
-    expect(last.cursor).toBe(2);
-    expect(replaymove(last, "forward", now).cursor).toBe(2);
-  });
-
-  it("reads the restored view and the stored cursor of the viewed run", async () => {
-    const sealed = await sealedlog();
-    const gates = [{ gateid: "s2", kind: "confirmpay", resolution: "approve", at: now + 2500 }];
-    const session = replaymove(
-      runreplaysessionof({ runid: sealed.seal.runid, entries: sealed.log.entries, gates, now }),
-      "forward",
-      now + 10,
-    );
-    const restored = replayrestoredview(session.steps[session.cursor] as never);
-    expect(restored.captureid).toBe("c-99");
-    expect(restored.gateresolutions[0]?.resolution).toBe("approve");
-    const cursor = replaycursorof(session);
-    expect(cursor).toEqual({ runid: sealed.seal.runid, cursor: 1, playing: false });
-    const verification = await verifylogchain(sealed.log.entries);
-    expect(verification.valid).toBe(true);
-  });
-});