@wenathlan/devthink 2.0.12 → 2.0.14

package/tests/runbudget.test.ts

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,299 @@
+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

@@ -0,0 +1,113 @@
+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);
+  });
+});