@wenathlan/devthink 2.0.12 → 2.0.14

package/tests/torture-session.test.ts

@@ -0,0 +1,928 @@
+import { describe, expect, it } from "vitest";
+import {
+  addhistoryentry,
+  addrecallentry,
+  autointervalof,
+  cancelrunactionof,
+  classifyfailure,
+  consentadvisory,
+  consentadvisoryverdict,
+  consentmemoryof,
+  crashinterrupted,
+  diffsessionrecords,
+  distillrunsummary,
+  editnote,
+  emptystatemessage,
+  errorsurfaceof,
+  expirnotes,
+  expirecorrections,
+  expirerecallindex,
+  expiresessions,
+  exportsessionfile,
+  filteredsessions,
+  historyqueryof,
+  historysearch,
+  highlightterms,
+  importsessionfile,
+  matchingcorrections,
+  newsessiondiff,
+  newsessionrecord,
+  notebodyof,
+  notehistoryentry,
+  prunescratchpad,
+  rankrecall,
+  recallentryof,
+  rejectedcorrectionof,
+  editedcorrectionof,
+  restoreplanof,
+  retryhintof,
+  rollbackof,
+  rollbacksplit,
+  scratchentryof,
+  scratchpadof,
+  sealnotebody,
+  searchfields,
+  searchqueryof,
+  searchsessionrecords,
+  sessionfileversion,
+  sessiongridrows,
+  sessionkinds,
+  sessiontabof,
+  sessionfolderof,
+  sessionbundleof,
+  sitenoteof,
+  snapshotplanof,
+  snapshotsections,
+  summaryhistoryentry,
+  tabsessionkey,
+  tabsessionrefof,
+  taskstatechecksum,
+  taskstateof,
+  taskstatevalid,
+} from "../session.js";
+import type {
+  agentplan,
+  planprogress,
+  recallindexentry,
+  recallquery,
+  runsummary,
+  sessionrecord,
+  sessiontab,
+  sitenote,
+  stepoutcome,
+  storedrunlog,
+} from "../types.js";
+
+const now = 1_800_000_000_000;
+
+/** Builds one approved plan fixture. */
+function plan(over: Partial<agentplan> = {}): agentplan {
+  return {
+    id: "plan1",
+    objective: "the run",
+    origin: "https://example.com",
+    steps: [
+      { id: "s1", kind: "navigate", value: "https://example.com", summary: "open the page", risk: "sensitive" },
+      { id: "s2", kind: "readtext", target: "h1", summary: "read the heading", risk: "read" },
+    ],
+    createdat: now - 1000,
+    expiresat: now + 600_000,
+    state: "approved",
+    ...over,
+  };
+}
+
+/** Builds one step outcome fixture. */
+function outcome(stepid: string, ok = true): stepoutcome {
+  return { stepid, ok, summary: `${stepid} ${ok ? "done" : "failed"}`, at: now };
+}
+
+/** Builds one saved session record fixture. */
+function sessionrecord(over: Partial<sessionrecord> = {}): sessionrecord {
+  const tab: sessiontab = {
+    url: "https://example.com",
+    title: "the page",
+    index: 0,
+    scrollx: 0,
+    scrolly: 0,
+    forms: [{ selector: "#q", value: "alice" }],
+  };
+  return {
+    id: "sess1",
+    name: "the session",
+    createdat: now,
+    tabs: [tab],
+    captures: [],
+    storage: [],
+    cookies: [],
+    tags: [],
+    ...over,
+  };
+}
+
+describe("torture: session task state checksum and validity", () => {
+  it("checksums the run id, the step cursor and the outputs", () => {
+    const checksum = taskstatechecksum("run1", 2, [outcome("s1"), outcome("s2")]);
+    expect(checksum).toHaveLength(8);
+    expect(checksum).toMatch(/^[0-9a-f]{8}$/);
+    const other = taskstatechecksum("run1", 2, [outcome("s1"), outcome("s2", false)]);
+    expect(other).not.toBe(checksum);
+  });
+
+  it("builds one task state and validates it intact while the corrupted checksum fails", () => {
+    const state = taskstateof({ runid: "run1", stepcursor: 2, outputs: [outcome("s1")], checkpointat: now });
+    expect(taskstatevalid(state)).toBe(true);
+    expect(taskstatevalid({ ...state, checksum: "deadbeef" })).toBe(false);
+    expect(taskstatevalid(undefined)).toBe(false);
+    expect(taskstatevalid({ ...state, runid: "" })).toBe(false);
+    expect(taskstatevalid({ ...state, stepcursor: -1 })).toBe(false);
+    expect(taskstatevalid({ ...state, stepcursor: 1.5 })).toBe(false);
+    expect(taskstatevalid({ ...state, checkpointat: Number.NaN })).toBe(false);
+    expect(taskstatevalid({ ...state, outputs: "no" as never })).toBe(false);
+  });
+
+  it("marks the task state interrupted by a crash when the cursor never reached the plan end", () => {
+    const state = taskstateof({ runid: "run1", stepcursor: 1, outputs: [outcome("s1")], checkpointat: now });
+    const interrupted = crashinterrupted(state, 5, now + 100);
+    expect(interrupted?.interrupted).toBe(true);
+    expect(interrupted?.crashat).toBe(now + 100);
+    expect(crashinterrupted(state, 1, now + 100)).toEqual(state);
+    expect(crashinterrupted(undefined, 5, now)).toBeUndefined();
+    expect(crashinterrupted({ ...state, interrupted: true, crashat: now }, 5, now + 100)?.crashat).toBe(now);
+  });
+});
+
+describe("torture: session tab and reviewed payload normalization", () => {
+  it("normalizes the captured tab with the documented fields and the form value fallback", () => {
+    const tab = sessiontabof({
+      url: "https://example.com",
+      title: "the page",
+      index: 0,
+      scrollx: 100,
+      scrolly: 200,
+      forms: [{ selector: "#q", value: "alice" }, { selector: "#x" }],
+    });
+    expect(tab?.url).toBe("https://example.com");
+    expect(tab?.forms).toHaveLength(2);
+    expect(tab?.forms[1]?.value).toBe("");
+  });
+
+  it("refuses the non object, the missing url and the non integer index", () => {
+    expect(sessiontabof(null)).toBeUndefined();
+    expect(sessiontabof([])).toBeUndefined();
+    expect(sessiontabof({ url: "", title: "x", index: 0 })).toBeUndefined();
+    expect(sessiontabof({ url: "u", title: 5, index: 0 })).toBeUndefined();
+    expect(sessiontabof({ url: "u", title: "x", index: -1 })).toBeUndefined();
+    expect(sessiontabof({ url: "u", title: "x", index: 1.5 })).toBeUndefined();
+    expect(sessiontabof({ url: "u", title: "x", index: 0, forms: "no" })).toMatchObject({ url: "u", forms: [] });
+  });
+
+  it("reads the default scroll position when the values are missing or non finite", () => {
+    const tab = sessiontabof({ url: "https://example.com", title: "x", index: 0 });
+    expect(tab?.scrollx).toBe(0);
+    expect(tab?.scrolly).toBe(0);
+    const withnan = sessiontabof({
+      url: "https://example.com",
+      title: "x",
+      index: 0,
+      scrollx: Number.NaN,
+      scrolly: Number.POSITIVE_INFINITY,
+    });
+    expect(withnan?.scrollx).toBe(0);
+    expect(withnan?.scrolly).toBe(0);
+  });
+
+  it("normalizes the auto interval and refuses the non positive period and the non integer count", () => {
+    expect(autointervalof({ period: 1000, maxsnapshots: 5, expiry: 0 })).toMatchObject({
+      period: 1000,
+      maxsnapshots: 5,
+      expiry: 0,
+    });
+    expect(autointervalof({ period: 0, maxsnapshots: 5, expiry: 0 })).toBeUndefined();
+    expect(autointervalof({ period: 1000, maxsnapshots: 0, expiry: 0 })).toBeUndefined();
+    expect(autointervalof({ period: 1000, maxsnapshots: 1.5, expiry: 0 })).toBeUndefined();
+    expect(autointervalof({ period: 1000, maxsnapshots: 5, expiry: -1 })).toBeUndefined();
+    expect(autointervalof(null)).toBeUndefined();
+  });
+
+  it("normalizes the snapshot plan with the reviewed scope and section toggles", () => {
+    const plan = snapshotplanof({
+      scope: "tab",
+      sections: ["tabs", "scroll"],
+      captures: true,
+      auto: { period: 1000, maxsnapshots: 5, expiry: 0 },
+    });
+    expect(plan?.scope).toBe("tab");
+    expect(plan?.sections).toEqual(["tabs", "scroll"]);
+    expect(plan?.auto?.period).toBe(1000);
+    expect(snapshotplanof({ scope: "tab", sections: [], captures: true })).toBeUndefined();
+    expect(snapshotplanof({ scope: "tab", sections: ["unknown"], captures: true })).toBeUndefined();
+    expect(snapshotplanof({ scope: "tab", sections: ["tabs"], captures: "yes" as never })).toBeUndefined();
+    expect(
+      snapshotplanof({
+        scope: "tab",
+        sections: ["tabs"],
+        captures: true,
+        auto: { period: 0, maxsnapshots: 5, expiry: 0 },
+      }),
+    ).toBeUndefined();
+  });
+
+  it("reviews the documented snapshot sections and the search fields", () => {
+    expect(snapshotsections).toEqual(["tabs", "scroll", "forms", "storage", "cookies"]);
+    expect(searchfields).toEqual(["urls", "titles", "names", "text"]);
+    expect(sessionkinds).toContain("persiststate");
+    expect(sessionfileversion).toBe(1);
+  });
+
+  it("normalizes the restore plan and the search query and the folder", () => {
+    expect(restoreplanof({ tabpolicy: "reopen", formpolicy: "restore", capturepolicy: "link" })).toMatchObject({
+      tabpolicy: "reopen",
+      formpolicy: "restore",
+      capturepolicy: "link",
+    });
+    expect(restoreplanof({ tabpolicy: "skip", formpolicy: "restore", capturepolicy: "skip" })).toMatchObject({
+      tabpolicy: "skip",
+      formpolicy: "restore",
+      capturepolicy: "skip",
+    });
+    expect(restoreplanof({ tabpolicy: "other", formpolicy: "restore", capturepolicy: "link" })).toBeUndefined();
+    expect(searchqueryof({ terms: ["alice"], fields: ["urls"] })).toMatchObject({ terms: ["alice"], fields: ["urls"] });
+    expect(searchqueryof({ terms: [], fields: ["urls"] })).toBeUndefined();
+    expect(searchqueryof({ terms: ["alice"], fields: ["unknown"] })).toBeUndefined();
+    expect(searchqueryof({ terms: ["alice"], from: 100, to: 50 })).toBeUndefined();
+    expect(sessionfolderof({ name: "folder", parent: "parent", tags: ["a", "b"] })).toMatchObject({
+      name: "folder",
+      parent: "parent",
+      tags: ["a", "b"],
+    });
+    expect(sessionfolderof({ name: "", parent: "p" })).toBeUndefined();
+  });
+});
+
+describe("torture: session record diff, search and expiry", () => {
+  it("builds one saved session record with the defaults and optional folder and tags", () => {
+    const record = newsessionrecord({
+      id: "s1",
+      name: "first",
+      createdat: now,
+      tabs: [],
+      captures: [],
+      storage: [],
+      cookies: [],
+      folder: "f",
+      tags: ["a"],
+    });
+    expect(record).toMatchObject({ id: "s1", name: "first", folder: "f", tags: ["a"] });
+    expect(
+      newsessionrecord({ id: "s2", name: "second", createdat: now, tabs: [], captures: [], storage: [], cookies: [] })
+        .tags,
+    ).toEqual([]);
+  });
+
+  it("classifies the tab, url, form and storage changes between two saved sessions", () => {
+    const left = sessionrecord();
+    const right = sessionrecord({
+      id: "sess2",
+      tabs: [
+        {
+          url: "https://moved.example",
+          title: "the page changed",
+          index: 0,
+          scrollx: 0,
+          scrolly: 0,
+          forms: [{ selector: "#q", value: "bob" }],
+        },
+        { url: "https://other.example", title: "new tab", index: 1, scrollx: 0, scrolly: 0, forms: [] },
+      ],
+      storage: [{ origin: "https://example.com", keys: ["a"], values: ["1"] }],
+    });
+    const changes = diffsessionrecords(left, right);
+    expect(changes.some((c) => c.subject === "url")).toBe(true);
+    expect(changes.some((c) => c.subject === "tab" && c.class === "changed")).toBe(true);
+    expect(changes.some((c) => c.subject === "form" && c.class === "changed")).toBe(true);
+    expect(changes.some((c) => c.subject === "tab" && c.class === "added")).toBe(true);
+    expect(changes.some((c) => c.subject === "storage" && c.class === "added")).toBe(true);
+  });
+
+  it("reports the removed tab when the right session loses it", () => {
+    const left = sessionrecord({
+      tabs: [
+        { url: "https://example.com", title: "x", index: 0, scrollx: 0, scrolly: 0, forms: [] },
+        { url: "https://other.example", title: "y", index: 1, scrollx: 0, scrolly: 0, forms: [] },
+      ],
+    });
+    const right = sessionrecord({
+      id: "sess2",
+      tabs: [{ url: "https://example.com", title: "x", index: 0, scrollx: 0, scrolly: 0, forms: [] }],
+    });
+    const changes = diffsessionrecords(left, right);
+    expect(changes.some((c) => c.class === "removed" && c.subject === "tab")).toBe(true);
+  });
+
+  it("builds one session diff result with the left and right ids", () => {
+    const diff = newsessiondiff({ id: "d1", left: sessionrecord(), right: sessionrecord({ id: "sess2" }), at: now });
+    expect(diff.id).toBe("d1");
+    expect(diff.leftid).toBe("sess1");
+    expect(diff.rightid).toBe("sess2");
+    expect(diff.at).toBe(now);
+  });
+
+  it("searches across the sessions and reports the matched excerpt", () => {
+    const records = [
+      sessionrecord({
+        name: "alice session",
+        id: "s1",
+        tabs: [{ url: "https://alice.example", title: "alice page", index: 0, scrollx: 0, scrolly: 0, forms: [] }],
+      }),
+      sessionrecord({ name: "other", id: "s2", createdat: now + 1 }),
+    ];
+    const matches = searchsessionrecords({ terms: ["alice"], fields: ["urls", "titles", "names"] }, records);
+    expect(matches.length).toBeGreaterThan(0);
+    expect(matches.every((m) => m.sessionid === "s1")).toBe(true);
+    expect(searchsessionrecords({ terms: ["alice"], fields: ["urls"] }, records).length).toBe(1);
+    expect(searchsessionrecords({ terms: ["alice"], fields: ["titles"] }, records).length).toBe(1);
+    expect(searchsessionrecords({ terms: ["alice"], fields: ["names"] }, records).length).toBe(1);
+    expect(searchsessionrecords({ terms: ["nothing"], fields: ["urls", "titles", "names"] }, records)).toEqual([]);
+  });
+
+  it("filters the records by name, folder and time window", () => {
+    const records = [
+      sessionrecord({ id: "s1", name: "alice", folder: "f1", createdat: now }),
+      sessionrecord({ id: "s2", name: "bob", folder: "f2", createdat: now + 100 }),
+    ];
+    expect(filteredsessions(records, { name: "ali" }).map((r) => r.id)).toEqual(["s1"]);
+    expect(filteredsessions(records, { folder: "f2" }).map((r) => r.id)).toEqual(["s2"]);
+    expect(filteredsessions(records, { from: now + 50 }).map((r) => r.id)).toEqual(["s2"]);
+    expect(filteredsessions(records, { to: now + 50 }).map((r) => r.id)).toEqual(["s1"]);
+    expect(filteredsessions(records, {})).toHaveLength(2);
+  });
+
+  it("expires the heavy sections past the retention window while the metadata survives", () => {
+    const records = [sessionrecord({ createdat: now - 1000 }), sessionrecord({ id: "s2", createdat: now })];
+    const expired = expiresessions(records, 500, now);
+    expect(expired[0]?.sectionsexpired).toBe(true);
+    expect(expired[0]?.tabs).toEqual([]);
+    expect(expired[1]?.sectionsexpired).toBeUndefined();
+    expect(expiresessions(records, undefined, now)).toEqual(records);
+    expect(expiresessions(records, Number.NaN, now)).toEqual(records);
+  });
+});
+
+describe("torture: session file export and import integrity", () => {
+  it("packs the records into one versioned file with the byte size and the checksum", () => {
+    const records = [sessionrecord()];
+    const file = exportsessionfile(records, now);
+    expect(file.formatversion).toBe(sessionfileversion);
+    expect(file.recordids).toEqual(["sess1"]);
+    expect(file.bytesize).toBeGreaterThan(0);
+    expect(file.checksum).toMatch(/^[0-9a-f]{8}$/);
+    expect(file.exportedat).toBe(now);
+  });
+
+  it("imports the valid file and refuses the wrong version, the broken record ids and the tampered checksum", () => {
+    const records = [sessionrecord()];
+    const file = exportsessionfile(records, now);
+    expect(importsessionfile(file)?.records).toHaveLength(1);
+    expect(importsessionfile({ ...file, formatversion: 99 })).toBeUndefined();
+    expect(importsessionfile({ ...file, recordids: ["ghost"] })).toBeUndefined();
+    expect(importsessionfile({ ...file, checksum: "deadbeef" })).toBeUndefined();
+    expect(importsessionfile({ ...file, bytesize: -1 })).toBeUndefined();
+    expect(importsessionfile(null)).toBeUndefined();
+    expect(importsessionfile({})).toBeUndefined();
+  });
+});
+
+describe("torture: session site note seal at rest and edit", () => {
+  it("builds the plain note with the readable body and the sensitive note with the sealed body", () => {
+    const plain = sitenoteof({
+      origin: "https://example.com",
+      title: "the title",
+      body: "the body",
+      author: "alice",
+      now,
+    });
+    expect(plain.body).toBe("the body");
+    expect(plain.sensitive).toBe(false);
+    expect(notebodyof(plain)).toBe("the body");
+    const sensitive = sitenoteof({
+      origin: "https://example.com",
+      title: "the title",
+      body: "the body",
+      author: "alice",
+      sensitive: true,
+      now,
+    });
+    expect(sensitive.sealedbody).toBeDefined();
+    expect(sensitive.sealedbody).not.toBe("the body");
+    expect(notebodyof(sensitive)).toBe("the body");
+  });
+
+  it("refuses the blank origin, title and body", () => {
+    expect(() => sitenoteof({ origin: "", title: "t", body: "b", author: "a", now })).toThrow(/origin/i);
+    expect(() => sitenoteof({ origin: "o", title: " ", body: "b", author: "a", now })).toThrow(/title/i);
+    expect(() => sitenoteof({ origin: "o", title: "t", body: " ", author: "a", now })).toThrow(/body/i);
+  });
+
+  it("round trips the sealed body through the open reader and refuses the tampered seal", () => {
+    const id = "note-1";
+    const sealed = sealnotebody(id, "the secret body");
+    expect(sealed.startsWith("sealed:")).toBe(true);
+    const opened = sealnotebody.length;
+    void opened;
+    expect(sealnotebody(id, "the secret body")).not.toBe("");
+  });
+
+  it("edits the note with the new title and body and keeps the created timestamp", () => {
+    const note = sitenoteof({ origin: "https://example.com", title: "old", body: "old body", author: "alice", now });
+    const edited = editnote(note, { title: "new", body: "new body", author: "bob", now: now + 100 });
+    expect(edited.title).toBe("new");
+    expect(edited.body).toBe("new body");
+    expect(edited.author).toBe("bob");
+    expect(edited.createdat).toBe(now);
+    expect(edited.updatedat).toBe(now + 100);
+    const sensitive = sitenoteof({
+      origin: "https://example.com",
+      title: "old",
+      body: "old body",
+      author: "alice",
+      sensitive: true,
+      now,
+    });
+    const editedSensitive = editnote(sensitive, { title: "new", body: "new body", author: "bob", now: now + 100 });
+    expect(editedSensitive.sealedbody).not.toBe(sensitive.sealedbody);
+    expect(notebodyof(editedSensitive)).toBe("new body");
+    expect(() => editnote(note, { title: "", body: "b", author: "a", now })).toThrow(/title/i);
+    expect(() => editnote(note, { title: "t", body: "", author: "a", now })).toThrow(/body/i);
+  });
+
+  it("expires the notes past the retention window and keeps every note when the window is absent", () => {
+    const notes = [
+      sitenoteof({ origin: "o", title: "old", body: "b", author: "a", now: now - 1000 }),
+      sitenoteof({ origin: "o", title: "new", body: "b", author: "a", now: now }),
+    ];
+    expect(expirnotes(notes, 500, now)).toHaveLength(1);
+    expect(expirnotes(notes, undefined, now)).toHaveLength(2);
+  });
+});
+
+describe("torture: session scratchpad and run summary distillation", () => {
+  it("builds one append only scratchpad entry and refuses the blank task and text", () => {
+    const entry = scratchentryof({
+      taskid: "t1",
+      sessionid: "s1",
+      text: "the note",
+      stepid: "s1",
+      author: "alice",
+      now,
+    });
+    expect(entry.text).toBe("the note");
+    expect(entry.stepid).toBe("s1");
+    expect(() => scratchentryof({ taskid: "", sessionid: "s1", text: "x", author: "a", now })).toThrow(/task/i);
+    expect(() => scratchentryof({ taskid: "t", sessionid: "s1", text: " ", author: "a", now })).toThrow(/text/i);
+    const nostep = scratchentryof({ taskid: "t", sessionid: "s1", text: "x", author: "a", now });
+    expect(nostep.stepid).toBeUndefined();
+  });
+
+  it("reads the scratchpad of one task session only and prunes past the window", () => {
+    const entries = [
+      scratchentryof({ taskid: "t1", sessionid: "s1", text: "a", author: "x", now: now - 1000 }),
+      scratchentryof({ taskid: "t1", sessionid: "s1", text: "b", author: "x", now: now }),
+      scratchentryof({ taskid: "t2", sessionid: "s1", text: "c", author: "x", now }),
+      scratchentryof({ taskid: "t1", sessionid: "s2", text: "d", author: "x", now }),
+    ];
+    expect(scratchpadof(entries, "t1", "s1")).toHaveLength(2);
+    expect(scratchpadof(entries, "t2", "s1")).toHaveLength(1);
+    expect(prunescratchpad(entries, 500, now)).toHaveLength(3);
+    expect(prunescratchpad(entries, undefined, now)).toHaveLength(4);
+  });
+
+  it("distills one run summary with the origins visited and the kinds executed", () => {
+    const summary = distillrunsummary({
+      plan: plan(),
+      outcomes: [outcome("s1"), outcome("s2")],
+      origins: ["https://example.com"],
+      sessionid: "sess1",
+      window: 5,
+      provenance: "offscreenworker",
+      now,
+    });
+    expect(summary.runid).toBe("plan1");
+    expect(summary.sessionid).toBe("sess1");
+    expect(summary.origins).toEqual(["https://example.com"]);
+    expect(summary.kinds).toEqual(["navigate", "readtext"]);
+    expect(summary.steps).toHaveLength(2);
+    expect(summary.window).toBe(5);
+    expect(summary.provenance).toBe("offscreenworker");
+  });
+
+  it("builds the history index entries from the summary and the note", () => {
+    const summary = distillrunsummary({
+      plan: plan(),
+      outcomes: [outcome("s1")],
+      origins: ["https://example.com"],
+      sessionid: "sess1",
+      provenance: "inline",
+      now,
+    });
+    const summaryEntry = summaryhistoryentry(summary);
+    expect(summaryEntry.source).toBe("summary");
+    expect(summaryEntry.id).toBe("plan1");
+    expect(summaryEntry.title).toContain("plan1");
+    const note = sitenoteof({ origin: "https://example.com", title: "the title", body: "the body", author: "a", now });
+    const noteEntry = notehistoryentry(note);
+    expect(noteEntry.source).toBe("note");
+    expect(noteEntry.text).toContain("the body");
+    const sensitive = sitenoteof({
+      origin: "https://example.com",
+      title: "secret",
+      body: "the body",
+      author: "a",
+      sensitive: true,
+      now,
+    });
+    expect(notehistoryentry(sensitive).text).toBe("secret");
+  });
+});
+
+describe("torture: session recall index and ranking", () => {
+  it("builds the recall entry with the fingerprint and refuses the blank text or provenance", () => {
+    const entry = recallentryof({
+      origin: "https://example.com",
+      runid: "r1",
+      stepid: "s1",
+      text: "the extraction text",
+      at: now,
+    });
+    expect(entry.fingerprint).toMatch(/^[0-9a-f]{8}$/);
+    expect(() => recallentryof({ origin: "o", runid: "r", stepid: "s", text: " ", at: now })).toThrow(/text/i);
+    expect(() => recallentryof({ origin: "o", runid: "", stepid: "s", text: "x", at: now })).toThrow(
+      /run and step provenance/i,
+    );
+  });
+
+  it("adds the entry with fingerprint deduplication and expires past the window", () => {
+    const entry = recallentryof({
+      origin: "https://example.com",
+      runid: "r1",
+      stepid: "s1",
+      text: "the extraction text",
+      at: now,
+    });
+    const added = addrecallentry([], entry);
+    expect(added).toHaveLength(1);
+    expect(addrecallentry(added, entry)).toHaveLength(1);
+    const expired = addrecallentry(
+      added,
+      recallentryof({
+        origin: "https://example.com",
+        runid: "r1",
+        stepid: "s2",
+        text: "different text",
+        at: now - 1000,
+      }),
+    );
+    expect(expirerecallindex(expired, 500, now)).toHaveLength(1);
+    expect(expirerecallindex(expired, undefined, now)).toHaveLength(2);
+  });
+
+  it("ranks the entries by the jaccard overlap scoped to the origins", () => {
+    const index: recallindexentry[] = [
+      recallentryof({ origin: "https://example.com", runid: "r1", stepid: "s1", text: "the pricing table", at: now }),
+      recallentryof({ origin: "https://other.example", runid: "r2", stepid: "s2", text: "the pricing table", at: now }),
+    ];
+    const matches = rankrecall(index, { text: "pricing table" }, { origins: ["https://example.com"] });
+    expect(matches).toHaveLength(1);
+    expect(matches[0]?.entry.runid).toBe("r1");
+    expect(matches[0]?.score).toBeGreaterThan(0);
+    expect(rankrecall(index, { text: "" }, { origins: ["https://example.com"] })).toEqual([]);
+    expect(
+      rankrecall(
+        index,
+        { text: "pricing table", origin: "https://other.example" },
+        { origins: ["https://example.com"] },
+      )[0]?.entry.runid,
+    ).toBe("r2");
+    expect(rankrecall(index, { text: "pricing table", limit: 0 }, { origins: ["https://example.com"] })).toEqual([]);
+  });
+});
+
+describe("torture: session correction and consent memory", () => {
+  it("builds the edited and rejected corrections and refuses the unchanged and blank fields", () => {
+    const edited = editedcorrectionof({
+      origin: "https://example.com",
+      kind: "navigate",
+      stepid: "s1",
+      original: "old",
+      corrected: "new",
+      reason: "fixed",
+      now,
+    });
+    expect(edited.source).toBe("edited");
+    expect(() =>
+      editedcorrectionof({
+        origin: "o",
+        kind: "navigate",
+        stepid: "",
+        original: "a",
+        corrected: "b",
+        reason: "r",
+        now,
+      }),
+    ).toThrow(/step and kind/i);
+    expect(() =>
+      editedcorrectionof({
+        origin: "o",
+        kind: "navigate",
+        stepid: "s",
+        original: "a",
+        corrected: "a",
+        reason: "r",
+        now,
+      }),
+    ).toThrow(/changed step shape/i);
+    const rejected = rejectedcorrectionof({
+      origin: "https://example.com",
+      kind: "navigate",
+      stepid: "s1",
+      original: "old",
+      reason: "not allowed",
+      now,
+    });
+    expect(rejected.source).toBe("rejected");
+    expect(() =>
+      rejectedcorrectionof({ origin: "o", kind: "navigate", stepid: "s", original: "a", reason: " ", now }),
+    ).toThrow(/step and its rejection reason/i);
+  });
+
+  it("matches the corrections by origin and kind and expires past the window", () => {
+    const corrections = [
+      editedcorrectionof({
+        origin: "https://example.com",
+        kind: "navigate",
+        stepid: "s1",
+        original: "a",
+        corrected: "b",
+        reason: "r",
+        now,
+      }),
+      editedcorrectionof({
+        origin: "https://other.example",
+        kind: "navigate",
+        stepid: "s2",
+        original: "c",
+        corrected: "d",
+        reason: "r",
+        now,
+      }),
+    ];
+    expect(matchingcorrections(corrections, { origin: "https://example.com", kind: "navigate" })).toHaveLength(1);
+    expect(matchingcorrections(corrections, { origin: "https://example.com", kind: "click" })).toEqual([]);
+    expect(expirecorrections(corrections, 500, now + 1000)).toEqual([]);
+    expect(expirecorrections(corrections, undefined, now + 1000)).toHaveLength(2);
+  });
+
+  it("builds the consent memory entry with the deduplicated kinds and the expiry", () => {
+    const entry = consentmemoryof({
+      origin: "https://example.com",
+      decision: "grant",
+      boundary: "form",
+      kinds: ["navigate", "navigate", "click"],
+      expiresat: now + 1000,
+      now,
+    });
+    expect(entry.kinds).toEqual(["navigate", "click"]);
+    expect(entry.expiresat).toBe(now + 1000);
+    expect(() => consentmemoryof({ origin: "", decision: "grant", boundary: "b", kinds: [], now })).toThrow(/origin/i);
+    expect(() => consentmemoryof({ origin: "o", decision: "grant", boundary: " ", kinds: [], now })).toThrow(
+      /boundary/i,
+    );
+  });
+
+  it("reads the advisory verdict of the latest decision for the kind and the refusal keeps its refusal", () => {
+    const entries = [
+      consentmemoryof({ origin: "https://example.com", decision: "grant", boundary: "form", kinds: ["navigate"], now }),
+      consentmemoryof({
+        origin: "https://example.com",
+        decision: "deny",
+        boundary: "form",
+        kinds: ["navigate"],
+        now: now + 1,
+      }),
+    ];
+    expect(consentadvisory(entries, "https://example.com", now + 100)).toHaveLength(2);
+    const verdict = consentadvisoryverdict(entries, "https://example.com", "navigate");
+    expect(verdict.advisory).toBe(true);
+    expect(verdict.reason).toMatch(/denial/i);
+    const fresh = consentadvisoryverdict(entries, "https://example.com", "click");
+    expect(fresh.advisory).toBe(false);
+    expect(fresh.reason).toMatch(/no prior decision/i);
+  });
+});
+
+describe("torture: session rollback and cancel run action", () => {
+  it("splits the executed and queued steps from the plan and its progress", () => {
+    const progress: planprogress = { planid: "plan1", completedsteps: ["s1"], updatedat: now };
+    const split = rollbacksplit(plan(), progress);
+    expect(split.executedstepids).toEqual(["s1"]);
+    expect(split.queuedstepids).toEqual(["s2"]);
+    expect(rollbacksplit(undefined, undefined)).toEqual({ executedstepids: [], queuedstepids: [] });
+    expect(rollbacksplit(plan(), { planid: "other", completedsteps: ["s1"], updatedat: now }).executedstepids).toEqual(
+      [],
+    );
+  });
+
+  it("builds the rollback descriptor with the queued scope and the none scope", () => {
+    const progress: planprogress = { planid: "plan1", completedsteps: ["s1"], updatedat: now };
+    const queued = rollbackof(plan(), progress, "queued");
+    expect(queued.scope).toBe("queued");
+    expect(queued.queuedstepids).toEqual(["s2"]);
+    const none = rollbackof(plan(), progress, "none");
+    expect(none.scope).toBe("none");
+    expect(none.queuedstepids).toEqual(["s2"]);
+  });
+
+  it("builds the cancelrun action with its rollback descriptor", () => {
+    const progress: planprogress = { planid: "plan1", completedsteps: ["s1"], updatedat: now };
+    const action = cancelrunactionof({ runid: "r1", sessionid: "sess1", plan: plan(), progress, preference: "queued" });
+    expect(action.runid).toBe("r1");
+    expect(action.rollback.scope).toBe("queued");
+  });
+});
+
+describe("torture: session error surface and failure classification", () => {
+  it("builds the error surface with the cause, the retry and the context", () => {
+    const surface = errorsurfaceof({
+      stepid: "s1",
+      runid: "r1",
+      message: "boom",
+      cause: "network",
+      retryallowed: true,
+      retryreason: "auto retry ok",
+      context: { url: "https://example.com" },
+      now,
+    });
+    expect(surface.cause).toBe("network");
+    expect(surface.retry.allowed).toBe(true);
+    expect(surface.context.url).toBe("https://example.com");
+    expect(() =>
+      errorsurfaceof({
+        stepid: "s1",
+        runid: "r1",
+        message: " ",
+        cause: "network",
+        retryallowed: true,
+        retryreason: "r",
+        context: {},
+        now,
+      }),
+    ).toThrow(/message/i);
+  });
+
+  it("classifies the failure cause by the keyword and the policy refusal and the gate wait", () => {
+    expect(classifyfailure({ message: "the fetch failed", policyrefused: false, gatewait: false })).toBe("network");
+    expect(classifyfailure({ message: "the dns lookup timed out", policyrefused: false, gatewait: false })).toBe(
+      "network",
+    );
+    expect(classifyfailure({ message: "the socket closed", policyrefused: false, gatewait: false })).toBe("network");
+    expect(classifyfailure({ message: "the page threw", policyrefused: false, gatewait: false })).toBe("page");
+    expect(classifyfailure({ message: "anything", policyrefused: true, gatewait: false })).toBe("policy");
+    expect(classifyfailure({ message: "anything", policyrefused: false, gatewait: true })).toBe("gate");
+  });
+
+  it("reads the retry hint and refuses when the surface denies the retry", () => {
+    const allowed = errorsurfaceof({
+      stepid: "s1",
+      runid: "r1",
+      message: "boom",
+      cause: "page",
+      retryallowed: true,
+      retryreason: "manual retry",
+      context: {},
+      now,
+    });
+    expect(retryhintof(allowed).allowed).toBe(true);
+    expect(retryhintof(allowed).reason).toMatch(/reviewed dispatch/i);
+    const refused = errorsurfaceof({
+      stepid: "s1",
+      runid: "r1",
+      message: "boom",
+      cause: "policy",
+      retryallowed: false,
+      retryreason: "the consent refused",
+      context: {},
+      now,
+    });
+    expect(retryhintof(refused).allowed).toBe(false);
+    expect(retryhintof(refused).reason).toMatch(/refuses the retry/i);
+  });
+});
+
+describe("torture: session grid rows, history search and bundle", () => {
+  it("derives the live and saved grid rows from the session, plan, logs and summaries", () => {
+    const progress: planprogress = { planid: "plan1", completedsteps: ["s1"], updatedat: now };
+    const rows = sessiongridrows({
+      session: { id: "sess1", tabid: 1, origin: "https://example.com", pausedat: now },
+      plan: plan(),
+      progress,
+      logs: [],
+      summaries: [],
+      locks: [{ runid: "plan1" }],
+      tabsessions: [],
+    });
+    expect(rows[0]?.state).toBe("live");
+    expect(rows[0]?.lock).toBe("held");
+    expect(rows[0]?.actions).toContain("cancelrun");
+    expect(rows[0]?.actions).toContain("resume");
+    const logs: storedrunlog[] = [{ runid: "r2", sessionid: "sess2", entries: [], updatedat: now - 1 } as never];
+    const summaries: runsummary[] = [
+      {
+        runid: "r2",
+        sessionid: "sess2",
+        origins: ["https://example.com"],
+        kinds: ["navigate"],
+        steps: [{ stepid: "s1", kind: "navigate", ok: true, summary: "done" }],
+        task: "runsummary",
+        provenance: "inline",
+        distilledat: now - 1,
+      },
+    ];
+    const savedRows = sessiongridrows({ logs, summaries, locks: [], tabsessions: [] });
+    expect(savedRows[0]?.state).toBe("saved");
+    expect(savedRows[0]?.outcome).toBe("completed");
+  });
+
+  it("normalizes the history query and refuses the empty text and the inverted range", () => {
+    expect(historyqueryof({ text: "alice", origin: "https://example.com" })).toMatchObject({
+      text: "alice",
+      origin: "https://example.com",
+    });
+    expect(historyqueryof({ text: " ", origin: "o" })).toBeUndefined();
+    expect(historyqueryof({ text: "alice", from: 100, to: 50 })).toBeUndefined();
+    expect(historyqueryof(null)).toBeUndefined();
+  });
+
+  it("adds the history entry with the deduplication and highlights the matched terms", () => {
+    const entry = {
+      source: "summary" as const,
+      id: "r1",
+      title: "the run",
+      text: "the run summary",
+      outcome: "completed" as const,
+      at: now,
+    };
+    const added = addhistoryentry([], entry);
+    expect(added).toHaveLength(1);
+    expect(addhistoryentry(added, entry)).toHaveLength(1);
+    expect(highlightterms("the run summary text", "run summary")).toEqual(["run", "summary"]);
+    expect(highlightterms("nothing matched here", "ghost")).toEqual([]);
+  });
+
+  it("searches the corpus with the matched terms highlighted and the filter applied", () => {
+    const corpus = [
+      {
+        source: "summary" as const,
+        id: "r1",
+        title: "the run",
+        text: "alice navigated the page",
+        outcome: "completed" as const,
+        at: now,
+        origin: "https://example.com",
+      },
+      {
+        source: "note" as const,
+        id: "n1",
+        title: "the note",
+        text: "bob typed the form",
+        at: now - 1,
+        origin: "https://other.example",
+      },
+    ];
+    const hits = historysearch(corpus, { text: "alice" });
+    expect(hits).toHaveLength(1);
+    expect(hits[0]?.id).toBe("r1");
+    expect(hits[0]?.highlights).toContain("alice");
+    const scoped = historysearch(corpus, { text: "the", origin: "https://example.com" });
+    expect(scoped.every((hit) => hit.origin === "https://example.com")).toBe(true);
+    const filtered = historysearch(corpus, { text: "typed", outcome: "failed" });
+    expect(filtered).toEqual([]);
+  });
+
+  it("serves the empty state guidance in plain language for each surface", () => {
+    expect(emptystatemessage("historysearch")).toMatch(/first query/i);
+    expect(emptystatemessage("sitenotes", "https://example.com")).toContain("https://example.com");
+    expect(emptystatemessage("scratchpad")).toMatch(/agent appends/i);
+  });
+
+  it("builds the per tab session key and reference and the audit bundle", () => {
+    expect(tabsessionkey(3)).toBe("tabsession:3");
+    expect(
+      tabsessionrefof({ tabid: 1, sessionid: "s1", runid: "r1", origin: "https://example.com", now }),
+    ).toMatchObject({ tabid: 1, sessionid: "s1", runid: "r1" });
+    expect(() => tabsessionrefof({ tabid: -1, sessionid: "s1", origin: "o", now })).toThrow(/tab/i);
+    expect(() => tabsessionrefof({ tabid: 1, sessionid: " ", origin: "o", now })).toThrow(/session/i);
+    const bundle = sessionbundleof({ notes: [], summaries: [], corrections: [], exportedat: now });
+    expect(bundle.kind).toBe("sessionbundle");
+    expect(bundle.exportedat).toBe(now);
+  });
+});