@wenathlan/devthink 2.0.14 → 2.0.19

package/tests/progress.test.ts

@@ -1,1036 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  assigntasktab,
-  callentries,
-  captureentries,
-  channelentries,
-  controlentries,
-  downloadentries,
-  downloadshare,
-  emptyprogress,
-  environmentof,
-  evententries,
-  exchangeentries,
-  extractionentries,
-  extractionshare,
-  fetchretryentries,
-  iscomplete,
-  mediaentries,
-  naventries,
-  pairentries,
-  pollentries,
-  recordcapture,
-  recordcall,
-  recordchannel,
-  recorddownload,
-  recordevent,
-  recordenvironment,
-  recordexchange,
-  recordextraction,
-  recordfetchretry,
-  recordmedia,
-  recordnaventry,
-  recordoutcome,
-  recordpair,
-  recordpoll,
-  recordcdp,
-  recordcontrol,
-  recordstep,
-  recordtimeline,
-  recordturnaround,
-  recordupload,
-  recordwatchcompletion,
-  recordwizardstep,
-  releasetasktab,
-  resetforplan,
-  tasktabs,
-  timelineevidences,
-  turnaroundof,
-  uploadentries,
-  watchclosed,
-  wizardcompletion,
-  cdpevidences,
-  profileevidences,
-  recordprofile,
-  emulationevidences,
-  recordemulation,
-  recordtoolcall,
-  toolcallevidences,
-  recorddenied,
-  deniedevidences,
-  recordrevocation,
-  revocationevidences,
-} from "../progress.js";
-import type { agentplan, shotpair, shotrecord } from "../types.js";
-
-const now = 1_800_000_000_000;
-const plan: agentplan = {
-  id: "plan",
-  objective: "Finish the review",
-  origin: "https://example.com",
-  steps: [
-    { id: "one", kind: "observe", summary: "Observe the page.", risk: "read" },
-    { id: "two", kind: "click", target: "#submit", summary: "Click submit.", risk: "sensitive" },
-  ],
-  createdat: now,
-  expiresat: now + 1000,
-  state: "approved",
-};
-
-describe("plan progress", () => {
-  it("starts empty and records reviewed steps without duplication", () => {
-    const empty = emptyprogress("plan", now);
-    expect(empty.completedsteps).toEqual([]);
-    const first = recordstep(empty, "plan", "one", now);
-    expect(first.completedsteps).toEqual(["one"]);
-    const repeated = recordstep(first, "plan", "one", now + 5);
-    expect(repeated.completedsteps).toEqual(["one"]);
-    expect(repeated.updatedat).toBe(now + 5);
-  });
-
-  it("starts fresh tracking when recorded progress belongs to a different plan", () => {
-    const foreign = { planid: "other", completedsteps: ["one", "two"], updatedat: now };
-    const fresh = recordstep(foreign, "plan", "one", now);
-    expect(fresh.planid).toBe("plan");
-    expect(fresh.completedsteps).toEqual(["one"]);
-    expect(iscomplete(foreign, plan)).toBe(false);
-  });
-
-  it("marks completion only after every reviewed step executed", () => {
-    const partial = recordstep(emptyprogress("plan", now), "plan", "one", now);
-    expect(iscomplete(partial, plan)).toBe(false);
-    const complete = recordstep(partial, "plan", "two", now + 10);
-    expect(iscomplete(complete, plan)).toBe(true);
-    expect(iscomplete(undefined, plan)).toBe(false);
-  });
-
-  it("records structured outcomes beside completions without truncation", () => {
-    let progress = recordstep(emptyprogress("plan", now), "plan", "one", now);
-    progress = recordoutcome(
-      progress,
-      "plan",
-      { stepid: "one", ok: true, summary: "Observe completed.", details: { textlength: 42 }, at: now + 1 },
-      now + 1,
-    );
-    progress = recordoutcome(
-      progress,
-      "plan",
-      { stepid: "one", ok: false, summary: "Second attempt failed.", at: now + 2 },
-      now + 2,
-    );
-    expect(progress.outcomes).toHaveLength(2);
-    expect(progress.outcomes?.[0]?.details?.textlength).toBe(42);
-    expect(progress.completedsteps).toEqual(["one"]);
-  });
-
-  it("records verifyvisible and verifyenabled outcomes as step evidence", () => {
-    let progress = recordstep(emptyprogress("plan", now), "plan", "one", now);
-    progress = recordoutcome(
-      progress,
-      "plan",
-      {
-        stepid: "one",
-        ok: true,
-        summary: "Target is rendered at 10,20 with size 300x40.",
-        details: { visible: true, geometry: { x: 10, y: 20, width: 300, height: 40 } },
-        at: now + 1,
-      },
-      now + 1,
-    );
-    progress = recordoutcome(
-      progress,
-      "plan",
-      {
-        stepid: "two",
-        ok: false,
-        summary: "Target is disabled.",
-        details: { enabled: false, disabled: true, readonly: false },
-        at: now + 2,
-      },
-      now + 2,
-    );
-    expect(progress.outcomes).toHaveLength(2);
-    expect(progress.outcomes?.[0]?.details?.visible).toBe(true);
-    expect(progress.outcomes?.[1]?.details?.disabled).toBe(true);
-    const failed = progress.outcomes?.find((outcome) => !outcome.ok);
-    expect(failed?.summary).toBe("Target is disabled.");
-  });
-
-  it("resets tracked progress when a new plan replaces the tracked one and preserves history", () => {
-    const previous = recordoutcome(
-      recordstep(emptyprogress("old", now), "old", "one", now),
-      "old",
-      { stepid: "one", ok: true, summary: "Old step done.", at: now },
-      now,
-    );
-    const reset = resetforplan(previous, plan, now);
-    expect(reset.planid).toBe("plan");
-    expect(reset.completedsteps).toEqual([]);
-    expect(reset.prior?.[0]?.planid).toBe("old");
-    expect(reset.prior?.[0]?.completedsteps).toEqual(["one"]);
-    const kept = resetforplan(recordstep(emptyprogress("plan", now), "plan", "one", now), plan, now);
-    expect(kept.completedsteps).toEqual(["one"]);
-    expect(kept.prior).toBeUndefined();
-  });
-
-  it("counts watch steps as completed only when their reviewed lifetime window closes", () => {
-    expect(watchclosed(1000, 2500, 3499)).toBe(false);
-    expect(watchclosed(1000, 2500, 3500)).toBe(true);
-    expect(watchclosed(1000, 2500, 9000)).toBe(true);
-    let progress = recordwatchcompletion(emptyprogress("plan", now), "plan", "two", 1000, 2500, 2000);
-    expect(progress.completedsteps).toEqual([]);
-    progress = recordwatchcompletion(progress, "plan", "two", 1000, 2500, 3500);
-    expect(progress.completedsteps).toEqual(["two"]);
-    const repeated = recordwatchcompletion(progress, "plan", "two", 1000, 2500, 9000);
-    expect(repeated.completedsteps).toEqual(["two"]);
-    expect(recordwatchcompletion(undefined, "plan", "two", 1000, 2500, 3500).completedsteps).toEqual(["two"]);
-  });
-
-  it("records each navlist entry as it completes and reads the entries back", () => {
-    let progress = emptyprogress("plan", now);
-    progress = recordnaventry(
-      progress,
-      "plan",
-      "list",
-      { index: 0, url: "https://example.com/a", ok: true },
-      now + 100,
-    );
-    progress = recordnaventry(
-      progress,
-      "plan",
-      "list",
-      { index: 1, url: "https://example.com/b", ok: true },
-      now + 200,
-    );
-    progress = recordnaventry(
-      progress,
-      "plan",
-      "list",
-      { index: 2, url: "https://stranger.example/c", ok: false },
-      now + 300,
-    );
-    expect(progress.outcomes).toHaveLength(3);
-    expect(progress.completedsteps).toEqual([]);
-    const entries = naventries(progress, "plan", "list");
-    expect(entries).toHaveLength(3);
-    expect(entries[0]).toMatchObject({ index: 0, url: "https://example.com/a", ok: true });
-    expect(entries[2]).toMatchObject({ index: 2, url: "https://stranger.example/c", ok: false });
-    expect(naventries(progress, "plan", "other")).toEqual([]);
-    expect(naventries(undefined, "plan", "list")).toEqual([]);
-    expect(naventries(recordstep(progress, "plan", "one", now), "plan", "one")).toEqual([]);
-  });
-});
-
-describe("plan progress task tabs", () => {
-  it("assigns and releases task tabs so progress tracks work across its tabs", () => {
-    const first = assigntasktab(undefined, "plan", 4, now);
-    expect(first.tasktabs).toEqual([4]);
-    const second = assigntasktab(first, "plan", 5, now + 1);
-    expect(second.tasktabs).toEqual([4, 5]);
-    expect(assigntasktab(second, "plan", 4, now + 2).tasktabs).toEqual([4, 5]);
-    const released = releasetasktab(second, "plan", 4, now + 3);
-    expect(released.tasktabs).toEqual([5]);
-    expect(releasetasktab(released, "plan", 5, now + 4).tasktabs).toBeUndefined();
-    expect(tasktabs(released, "plan")).toEqual([5]);
-    expect(tasktabs(released, "other")).toEqual([]);
-    expect(tasktabs(undefined, "plan")).toEqual([]);
-  });
-
-  it("keeps task tabs tracked only for the running plan", () => {
-    const tracked = assigntasktab(
-      { planid: "other", completedsteps: ["one"], tasktabs: [9], updatedat: now },
-      "plan",
-      4,
-      now,
-    );
-    expect(tracked.planid).toBe("plan");
-    expect(tracked.tasktabs).toEqual([4]);
-    expect(tracked.completedsteps).toEqual([]);
-  });
-
-  it("tracks extraction progress as rows collected over the estimated total and records page outcomes", () => {
-    expect(extractionshare(50, 200)).toBeCloseTo(0.25);
-    expect(extractionshare(400, 200)).toBe(1);
-    expect(extractionshare(-5, 200)).toBe(0);
-    expect(extractionshare(50, 0)).toBe(0);
-    let tracked = recordextraction(
-      emptyprogress("plan", now),
-      "plan",
-      "extract",
-      { page: 1, rows: 10, cursor: 1 },
-      now,
-    );
-    tracked = recordextraction(tracked, "plan", "extract", { page: 2, rows: 15, cursor: 2 }, now + 1);
-    expect(extractionentries(tracked, "plan", "extract")).toEqual([
-      { page: 1, rows: 10, cursor: 1 },
-      { page: 2, rows: 15, cursor: 2 },
-    ]);
-    expect(extractionentries(tracked, "other", "extract")).toEqual([]);
-    expect(tracked.outcomes?.[0]).toMatchObject({
-      stepid: "extract",
-      ok: true,
-      details: { extraction: { page: 1, rows: 10 } },
-    });
-  });
-
-  it("tracks wizard completion as executed steps over total steps", () => {
-    const state = { index: 2, steps: 3, completed: [true, true, false], at: now };
-    expect(wizardcompletion(state)).toBeCloseTo(2 / 3);
-    expect(wizardcompletion({ index: 3, steps: 3, completed: [true, true, true], at: now })).toBe(1);
-    expect(wizardcompletion({ index: 0, steps: 0, completed: [], at: now })).toBe(0);
-    const tracked = recordwizardstep(emptyprogress("plan", now), "plan", "wizard", state, now);
-    expect(tracked.outcomes?.[0]).toMatchObject({
-      stepid: "wizard",
-      ok: false,
-      details: { wizard: { index: 2, steps: 3 } },
-    });
-    const finished = recordwizardstep(
-      tracked,
-      "plan",
-      "wizard",
-      { index: 3, steps: 3, completed: [true, true, true], at: now + 1 },
-      now + 1,
-    );
-    expect(finished.outcomes?.[1]).toMatchObject({ stepid: "wizard", ok: true });
-  });
-});
-
-describe("batch download progress", () => {
-  it("tracks batch downloads as files completed over total and records per file outcomes", () => {
-    expect(downloadshare(3, 10)).toBeCloseTo(0.3);
-    expect(downloadshare(10, 10)).toBe(1);
-    expect(downloadshare(12, 10)).toBe(1);
-    expect(downloadshare(-1, 10)).toBe(0);
-    expect(downloadshare(5, 0)).toBe(0);
-    let tracked = recorddownload(
-      emptyprogress("plan", now),
-      "plan",
-      "batch",
-      { index: 0, url: "https://example.com/a.pdf", state: "complete" },
-      now,
-    );
-    tracked = recorddownload(
-      tracked,
-      "plan",
-      "batch",
-      { index: 1, url: "https://example.com/b.zip", state: "failed" },
-      now + 1,
-    );
-    expect(downloadentries(tracked, "plan", "batch")).toEqual([
-      { index: 0, url: "https://example.com/a.pdf", state: "complete" },
-      { index: 1, url: "https://example.com/b.zip", state: "failed" },
-    ]);
-    expect(downloadentries(tracked, "plan", "other")).toEqual([]);
-    expect(downloadentries(tracked, "other", "batch")).toEqual([]);
-    expect(tracked.outcomes?.[0]).toMatchObject({
-      stepid: "batch",
-      ok: true,
-      details: { download: { index: 0, state: "complete" } },
-    });
-    expect(tracked.outcomes?.[1]).toMatchObject({
-      stepid: "batch",
-      ok: false,
-      details: { download: { index: 1, state: "failed" } },
-    });
-  });
-});
-
-describe("capture progress", () => {
-  const now = 1_800_000_000_000;
-
-  it("records capture completions and shotpair ids as reviewable evidence", () => {
-    const capture: shotrecord = {
-      id: "cap-1",
-      runid: "plan",
-      stepid: "shot",
-      kind: "shotview",
-      format: "png",
-      width: 1280,
-      height: 800,
-      capturedat: now,
-      bytes: "data:image/png;base64,xyz",
-    };
-    let tracked = recordcapture(emptyprogress("plan", now), "plan", "shot", capture, now);
-    tracked = recordcapture(
-      tracked,
-      "plan",
-      "shot",
-      { ...capture, id: "cap-2", kind: "shotfullpage", width: 1280, height: 3200 },
-      now + 1,
-    );
-    expect(captureentries(tracked, "plan", "shot")).toEqual([
-      { id: "cap-1", kind: "shotview", format: "png", width: 1280, height: 800, bytes: 25 },
-      { id: "cap-2", kind: "shotfullpage", format: "png", width: 1280, height: 3200, bytes: 25 },
-    ]);
-    expect(captureentries(tracked, "plan", "other")).toEqual([]);
-    expect(captureentries(tracked, "other", "shot")).toEqual([]);
-    expect(tracked.outcomes?.[0]).toMatchObject({
-      stepid: "shot",
-      ok: true,
-      details: { capture: { id: "cap-1", bytes: 25 } },
-    });
-    const pair: shotpair = {
-      id: "pair-1",
-      beforeid: "cap-1",
-      afterid: "cap-2",
-      actionkind: "click",
-      target: "#submit",
-      domsnapshotid: "7",
-      at: now + 2,
-    };
-    tracked = recordpair(tracked, "plan", "click", pair, now + 2);
-    expect(pairentries(tracked, "plan", "click")).toEqual([
-      { id: "pair-1", beforeid: "cap-1", afterid: "cap-2", actionkind: "click", target: "#submit", domsnapshotid: "7" },
-    ]);
-    expect(pairentries(tracked, "plan", "shot")).toEqual([]);
-    expect(tracked.outcomes?.[2]).toMatchObject({
-      stepid: "click",
-      ok: true,
-      details: { shotpair: { beforeid: "cap-1", afterid: "cap-2" } },
-    });
-  });
-});
-
-describe("media progress", () => {
-  const now = 1_800_000_000_000;
-
-  it("records media capture completions with kind, scope and byte size as reviewable evidence", () => {
-    let tracked = recordmedia(
-      emptyprogress("plan", now),
-      "plan",
-      "pdf-1",
-      { id: "pdf-1", kind: "pdf", scope: "tab", bytes: 4200 },
-      now,
-    );
-    tracked = recordmedia(
-      tracked,
-      "plan",
-      "rec-1",
-      { id: "rec-1", kind: "recording", scope: "run", bytes: 300 },
-      now + 1,
-    );
-    tracked = recordmedia(
-      tracked,
-      "plan",
-      "img-1",
-      { id: "batch-1", kind: "images", scope: "main img", bytes: 1200 },
-      now + 2,
-    );
-    expect(mediaentries(tracked, "plan", "pdf-1")).toEqual([{ id: "pdf-1", kind: "pdf", scope: "tab", bytes: 4200 }]);
-    expect(mediaentries(tracked, "plan", "rec-1")).toEqual([
-      { id: "rec-1", kind: "recording", scope: "run", bytes: 300 },
-    ]);
-    expect(mediaentries(tracked, "plan", "img-1")).toEqual([
-      { id: "batch-1", kind: "images", scope: "main img", bytes: 1200 },
-    ]);
-    expect(mediaentries(tracked, "plan", "other")).toEqual([]);
-    expect(mediaentries(tracked, "other", "pdf-1")).toEqual([]);
-    expect(tracked.outcomes?.[0]).toMatchObject({
-      stepid: "pdf-1",
-      ok: true,
-      details: { media: { kind: "pdf", bytes: 4200 } },
-    });
-    expect(tracked.outcomes?.[1]?.summary).toContain("recording media record of run scope");
-  });
-});
-
-describe("network observation progress", () => {
-  it("records outbound call completions with transport facts as reviewable evidence", () => {
-    let progress = emptyprogress("plan-1", 1);
-    progress = recordcall(
-      progress,
-      "plan-1",
-      "f1",
-      {
-        id: "c1",
-        kind: "rest",
-        origin: "https://api.example",
-        method: "POST",
-        status: 201,
-        statusclass: "success",
-        duration: 340,
-        retries: 1,
-        bytes: 512,
-      },
-      2,
-    );
-    progress = recordcall(
-      progress,
-      "plan-1",
-      "f1",
-      {
-        id: "c2",
-        kind: "fetch",
-        origin: "https://api.example",
-        method: "GET",
-        status: 503,
-        statusclass: "servererror",
-        duration: 40,
-        retries: 0,
-        bytes: 0,
-      },
-      3,
-    );
-    const entries = callentries(progress, "plan-1", "f1");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]).toMatchObject({ id: "c1", statusclass: "success", retries: 1 });
-    expect(entries[1]).toMatchObject({ id: "c2", statusclass: "servererror" });
-    expect(callentries(progress, "plan-1", "other")).toHaveLength(0);
-    expect(callentries(progress, "plan-2", "f1")).toHaveLength(0);
-  });
-
-  it("records fetch retries as progress so the panel reports fetch progress on each retry", () => {
-    let progress = emptyprogress("plan-1", 1);
-    progress = recordfetchretry(
-      progress,
-      "plan-1",
-      "f1",
-      { attempt: 1, url: "https://api.example/data", wait: 100, reason: "network down" },
-      2,
-    );
-    progress = recordfetchretry(
-      progress,
-      "plan-1",
-      "f1",
-      { attempt: 2, url: "https://api.example/data", wait: 200, reason: "timed out" },
-      3,
-    );
-    const retries = fetchretryentries(progress, "plan-1", "f1");
-    expect(retries).toHaveLength(2);
-    expect(retries[0]).toMatchObject({ attempt: 1, wait: 100, reason: "network down" });
-    expect(retries[1]).toMatchObject({ attempt: 2, wait: 200 });
-    expect(fetchretryentries(progress, "plan-1", "missing")).toHaveLength(0);
-  });
-});
-
-describe("network observation part two progress", () => {
-  const now = 1_800_000_000_000;
-
-  it("records channel lifecycle transitions with message counters", () => {
-    let progress = emptyprogress("plan1", now);
-    progress = recordchannel(
-      progress,
-      "plan1",
-      "s1",
-      { id: "ch1", kind: "websocket", state: "open", url: "wss://api.example/live", sent: 2, received: 5 },
-      now + 10,
-    );
-    progress = recordchannel(
-      progress,
-      "plan1",
-      "s1",
-      { id: "ch1", kind: "websocket", state: "closed", url: "wss://api.example/live", sent: 2, received: 7 },
-      now + 20,
-    );
-    const entries = channelentries(progress, "plan1", "s1");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]).toMatchObject({ id: "ch1", state: "open", sent: 2, received: 5 });
-    expect(entries[1]?.state).toBe("closed");
-    expect((progress.outcomes ?? [])[0]?.ok).toBe(true);
-    expect(channelentries(progress, "other", "s1")).toHaveLength(0);
-  });
-
-  it("records observed exchanges with correlation ids and error classes", () => {
-    let progress = emptyprogress("plan1", now);
-    progress = recordexchange(
-      progress,
-      "plan1",
-      "s1",
-      {
-        id: "e1",
-        correlationid: "run-1",
-        method: "GET",
-        origin: "https://api.example",
-        url: "https://api.example/items",
-        status: 200,
-        statusclass: "success",
-        duration: 42,
-        bytes: 128,
-      },
-      now,
-    );
-    progress = recordexchange(
-      progress,
-      "plan1",
-      "s1",
-      {
-        id: "e2",
-        correlationid: "run-2",
-        method: "GET",
-        origin: "https://api.example",
-        url: "https://api.example/gone",
-        status: 0,
-        statusclass: "unknown",
-        duration: 30,
-        bytes: 0,
-        errorclass: "networkerror",
-      },
-      now,
-    );
-    const entries = exchangeentries(progress, "plan1", "s1");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]?.correlationid).toBe("run-1");
-    expect((progress.outcomes ?? [])[0]?.ok).toBe(true);
-    expect((progress.outcomes ?? [])[1]?.ok).toBe(false);
-    expect((progress.outcomes ?? [])[1]?.summary).toContain("networkerror");
-  });
-
-  it("records event stream observations and long poll iterations", () => {
-    let progress = emptyprogress("plan1", now);
-    progress = recordevent(
-      progress,
-      "plan1",
-      "s1",
-      { url: "https://api.example/stream", name: "userjoin", events: 9, lasteventid: "41" },
-      now,
-    );
-    expect(evententries(progress, "plan1", "s1")[0]).toMatchObject({ name: "userjoin", events: 9, lasteventid: "41" });
-    progress = recordpoll(
-      progress,
-      "plan1",
-      "s2",
-      { poll: 1, cursor: "7", status: 200, stopped: false, reason: "The long poll loop continues." },
-      now,
-    );
-    progress = recordpoll(
-      progress,
-      "plan1",
-      "s2",
-      { poll: 2, status: 200, stopped: true, reason: "The stop condition matched done yes." },
-      now + 100,
-    );
-    const polls = pollentries(progress, "plan1", "s2");
-    expect(polls).toHaveLength(2);
-    expect(polls[0]).toMatchObject({ poll: 1, cursor: "7", stopped: false });
-    expect(polls[1]?.stopped).toBe(true);
-    expect(polls[1]?.reason).toContain("stop condition");
-    expect(pollentries(progress, "plan1", "s1")).toHaveLength(0);
-  });
-});
-
-describe("network control progress", () => {
-  const now = 1_800_000_000_000;
-
-  it("records traffic control evidence with applied, blocked, mocked and reverted counts", () => {
-    let progress = emptyprogress("plan1", now);
-    progress = recordcontrol(
-      progress,
-      "plan1",
-      "s1",
-      { applied: 2, blocked: 3, mocked: 1, reverts: 0, reason: "The block rules registered" },
-      now + 10,
-    );
-    progress = recordcontrol(
-      progress,
-      "plan1",
-      "s1",
-      { applied: 0, blocked: 3, mocked: 1, reverts: 2, reason: "The traffic rules reverted at run end" },
-      now + 20,
-    );
-    const entries = controlentries(progress, "plan1", "s1");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]).toMatchObject({ applied: 2, blocked: 3 });
-    expect(entries[1]?.reverts).toBe(2);
-    expect((progress.outcomes ?? [])[1]?.summary).toContain("reverted");
-    expect(controlentries(progress, "other", "s1")).toHaveLength(0);
-  });
-
-  it("records multipart upload progress chunk by chunk", () => {
-    let progress = emptyprogress("plan1", now);
-    progress = recordupload(progress, "plan1", "s2", { chunk: 1, chunks: 3, uploaded: 40, bytes: 120 }, now);
-    progress = recordupload(progress, "plan1", "s2", { chunk: 3, chunks: 3, uploaded: 120, bytes: 120 }, now + 5);
-    const entries = uploadentries(progress, "plan1", "s2");
-    expect(entries).toHaveLength(2);
-    expect(entries[1]).toMatchObject({ chunk: 3, chunks: 3, uploaded: 120 });
-    expect((progress.outcomes ?? [])[0]?.ok).toBe(true);
-  });
-});
-
-describe("run timeline progress", () => {
-  it("records timeline capture evidence with entry, error, rejection and long task counts", () => {
-    const now = 1_800_000_000_000;
-    let progress = recordtimeline(
-      undefined,
-      "plan1",
-      "s1",
-      { entries: 12, collapsed: 4, errors: 2, rejections: 1, longtasks: 3 },
-      now,
-    );
-    progress = recordtimeline(
-      progress,
-      "plan1",
-      "s1",
-      { entries: 5, collapsed: 0, errors: 1, rejections: 0, longtasks: 1 },
-      now + 5,
-    );
-    const entries = timelineevidences(progress, "plan1", "s1");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]).toMatchObject({ entries: 12, collapsed: 4, errors: 2, rejections: 1, longtasks: 3 });
-    expect(entries[1]).toMatchObject({ entries: 5, errors: 1 });
-    expect((progress.outcomes ?? [])[0]?.ok).toBe(true);
-    expect(timelineevidences(progress, "plan1", "s2")).toEqual([]);
-  });
-});
-
-describe("devtools protocol progress", () => {
-  it("records cdp evidence with the family, method, domain, duration and error class", () => {
-    const now = 1_800_000_000_000;
-    let progress = recordcdp(undefined, "plan1", "a1", { family: "attach", domains: 2 }, now);
-    progress = recordcdp(
-      progress,
-      "plan1",
-      "c1",
-      { family: "command", method: "Runtime.evaluate", domain: "Runtime", duration: 12 },
-      now + 1,
-    );
-    progress = recordcdp(
-      progress,
-      "plan1",
-      "c2",
-      { family: "command", method: "DOM.getSnapshot", domain: "DOM", duration: 4, errorclass: "uninstrumented" },
-      now + 2,
-    );
-    progress = recordcdp(progress, "plan1", "w1", { family: "watch", events: 5, domain: "Log" }, now + 3);
-    progress = recordcdp(progress, "plan1", "s1", { family: "step", frames: 3 }, now + 4);
-    const attachentries = cdpevidences(progress, "plan1", "a1");
-    expect(attachentries).toHaveLength(1);
-    expect(attachentries[0]).toMatchObject({ family: "attach", domains: 2 });
-    const commands = cdpevidences(progress, "plan1", "c1");
-    expect(commands[0]).toMatchObject({ family: "command", method: "Runtime.evaluate", duration: 12 });
-    const failed = cdpevidences(progress, "plan1", "c2");
-    expect(failed[0]?.errorclass).toBe("uninstrumented");
-    expect((progress.outcomes ?? []).find((outcome) => outcome.stepid === "c2")?.ok).toBe(false);
-    expect((progress.outcomes ?? []).find((outcome) => outcome.stepid === "c1")?.ok).toBe(true);
-    expect(cdpevidences(progress, "plan1", "w1")[0]).toMatchObject({ family: "watch", events: 5 });
-    expect(cdpevidences(progress, "plan1", "s1")[0]).toMatchObject({ family: "step", frames: 3 });
-    expect(cdpevidences(progress, "plan1", "missing")).toEqual([]);
-    expect(cdpevidences(progress, "other", "c1")).toEqual([]);
-  });
-});
-
-describe("profiling progress", () => {
-  const now = 1_800_000_000_000;
-
-  it("records profiling evidence with the instrument family, the counts and the record ids", () => {
-    let progress = recordprofile(
-      undefined,
-      "plan",
-      "m1",
-      { family: "flow", metrics: 4, recordids: ["f1", "f2", "f3", "f4"] },
-      now,
-    );
-    progress = recordprofile(
-      progress,
-      "plan",
-      "hs",
-      { family: "heap", nodes: 1450, bytes: 12_000_000, recordids: ["h1"] },
-      now + 1,
-    );
-    progress = recordprofile(progress, "plan", "tm", { family: "memory", samples: 3, flagged: 1 }, now + 2);
-    const flow = profileevidences(progress, "plan", "m1");
-    expect(flow).toEqual([{ family: "flow", metrics: 4, recordids: ["f1", "f2", "f3", "f4"] }]);
-    const heap = profileevidences(progress, "plan", "hs");
-    expect(heap[0]).toMatchObject({ family: "heap", nodes: 1450, bytes: 12_000_000 });
-    expect((progress.outcomes ?? [])[2]?.summary).toContain("3 samples, 1 flagged step");
-    expect(profileevidences(progress, "plan", "missing")).toEqual([]);
-    expect(profileevidences(progress, "other", "m1")).toEqual([]);
-  });
-});
-
-describe("emulation progress", () => {
-  it("records the applied and reverted layer names of every emulation step", () => {
-    let progress = recordemulation(
-      undefined,
-      "plan",
-      "s1",
-      { applied: ["phone"], reverted: [], reason: "Emulation layer applied" },
-      1,
-    );
-    progress = recordemulation(
-      progress,
-      "plan",
-      "s2",
-      { applied: [], reverted: ["phone", "slow3g"], reason: "Emulation reverted on run cancel" },
-      2,
-    );
-    expect(emulationevidences(progress, "plan", "s1")[0]?.applied).toEqual(["phone"]);
-    expect(emulationevidences(progress, "plan", "s2")[0]?.reverted).toEqual(["phone", "slow3g"]);
-    expect((progress.outcomes ?? [])[1]?.summary).toContain("2 reverted layers (phone, slow3g)");
-    expect(emulationevidences(progress, "plan", "missing")).toEqual([]);
-    expect(emulationevidences(undefined, "plan", "s1")).toEqual([]);
-  });
-});
-
-describe("agent protocol progress", () => {
-  it("records tool call evidence with the client, tool and outcome", () => {
-    const started = emptyprogress("plan", now);
-    const ran = recordtoolcall(
-      started,
-      "plan",
-      "two",
-      { clientid: "client1", tool: "browser.click", ok: true },
-      now + 10,
-    );
-    const refused = recordtoolcall(
-      ran,
-      "plan",
-      "two",
-      { clientid: "client1", tool: "browser.readtext", ok: false, code: "consentrefused" },
-      now + 20,
-    );
-    const entries = toolcallevidences(refused, "plan", "two");
-    expect(entries).toHaveLength(2);
-    expect(entries[0]?.tool).toBe("browser.click");
-    expect(entries[1]?.code).toBe("consentrefused");
-    const outcome = refused.outcomes?.[0];
-    expect(outcome?.summary).toContain("ran behind the consent gates");
-    expect(refused.outcomes?.[1]?.summary).toContain("refused");
-    expect(toolcallevidences(refused, "plan", "one")).toEqual([]);
-    expect(toolcallevidences(started, "otherplan", "two")).toEqual([]);
-  });
-});
-
-describe("execution environment progress evidence", () => {
-  it("records the environment of each completed step and the worker turnaround for later profiling", () => {
-    let progress = emptyprogress("plan1", 1);
-    progress = recordenvironment(progress, "plan1", "s1", "pagecontext", 2);
-    progress = recordenvironment(progress, "plan1", "s2", "offscreenworker", 3);
-    progress = recordturnaround(progress, "plan1", "s2", 42, 4);
-    expect(environmentof(progress, "plan1", "s1")).toBe("pagecontext");
-    expect(environmentof(progress, "plan1", "s2")).toBe("offscreenworker");
-    expect(environmentof(progress, "plan1", "missing")).toBeUndefined();
-    expect(environmentof(progress, "other", "s1")).toBeUndefined();
-    expect(turnaroundof(progress, "plan1", "s2")).toBe(42);
-    expect(turnaroundof(progress, "plan1", "s1")).toBeUndefined();
-    const latest = recordenvironment(progress, "plan1", "s2", "pagecontext", 5);
-    expect(environmentof(latest, "plan1", "s2")).toBe("pagecontext");
-    expect(latest.environments?.s1).toBe("pagecontext");
-  });
-});
-
-describe("security evidence", () => {
-  it("records denied steps with their deny reason", () => {
-    let progress = recorddenied(
-      undefined,
-      "plan",
-      "two",
-      { origin: "https://other.example", kind: "submitform", reason: "The denydefault posture refuses the origin." },
-      now,
-    );
-    progress = recorddenied(
-      progress,
-      "plan",
-      "two",
-      { origin: "https://other.example", kind: "submitform", reason: "The fresh class consent is missing." },
-      now + 1,
-    );
-    const denied = deniedevidences(progress, "plan", "two");
-    expect(denied).toHaveLength(2);
-    expect(denied[0]?.origin).toBe("https://other.example");
-    expect(denied[1]?.reason).toMatch(/fresh class consent/i);
-    expect((progress.outcomes ?? []).every((outcome) => outcome.ok === false)).toBe(true);
-    expect(deniedevidences(progress, "plan", "one")).toEqual([]);
-  });
-
-  it("records revoked runs as halted with the revoked step", () => {
-    const progress = recordrevocation(
-      undefined,
-      "plan",
-      "two",
-      { haltedstepids: ["two", "three"], revokedstepid: "two", reason: "The user revoked the consent mid run." },
-      now,
-    );
-    const revoked = revocationevidences(progress, "plan", "two");
-    expect(revoked).toHaveLength(1);
-    expect(revoked[0]?.haltedstepids).toEqual(["two", "three"]);
-    expect(revoked[0]?.revokedstepid).toBe("two");
-    expect((progress.outcomes ?? [])[0]?.summary).toMatch(/halted at the step two/i);
-    expect(revocationevidences(progress, "plan", "one")).toEqual([]);
-  });
-});
-
-import { gatewaitof, recordgatewait } from "../progress.js";
-
-describe("progress gate waits", () => {
-  it("records the gate wait of one gated step beside its step durations", () => {
-    const wait = { gateid: "gate", kind: "confirmpay", openedat: now, resolvedat: now + 1500, waitedms: 1500 };
-    const progress = recordgatewait(undefined, "plan", "paystep", wait, now + 1500);
-    expect(gatewaitof(progress, "plan", "paystep")).toEqual(wait);
-    expect(gatewaitof(progress, "plan", "other")).toBeUndefined();
-    expect(gatewaitof(progress, "otherplan", "paystep")).toBeUndefined();
-    const updated = recordgatewait(
-      progress,
-      "plan",
-      "paystep",
-      { gateid: "gate2", kind: "confirmpay", openedat: now, resolvedat: now + 2000, waitedms: 2000 },
-      now + 2000,
-    );
-    expect(gatewaitof(updated, "plan", "paystep")?.gateid).toBe("gate2");
-  });
-});
-
-/* ── The 1.1.96 multi agent certification: the interleaved timeline ordering of the fleet. ── */
-import { interleave, interleavetimeline } from "../agent.js";
-import type { swarmaction } from "../types.js";
-
-describe("interleaved timeline progress", () => {
-  it("orders the concurrent actions of every agent into one time ordered timeline", () => {
-    const events = [
-      { agentid: "w2", kind: "readtext", summary: "The background agent read the table.", at: now + 300 },
-      { agentid: "w1", kind: "click", summary: "The interactive agent opened the pricing page.", at: now + 100 },
-      { agentid: "w2", kind: "observe", summary: "The background agent observed the hero.", at: now + 200 },
-      { agentid: "w1", kind: "readtext", summary: "The interactive agent read the footer.", at: now + 400 },
-    ];
-    const timeline = interleavetimeline(
-      events.map((event) => ({
-        id: `x-${event.at - now}`,
-        kind: event.kind,
-        summary: event.summary,
-        at: event.at,
-        agentid: event.agentid,
-      })),
-    );
-    expect(timeline.map((event) => event.kind)).toEqual(["click", "observe", "readtext", "readtext"]);
-    expect(timeline.every((event, index) => index === 0 || timeline[index - 1]!.at <= event.at)).toBe(true);
-    expect(interleavetimeline([])).toEqual([]);
-  });
-
-  it("interleaves the lane events with the lane attribution the dashboard timeline reads", () => {
-    const lanes = [
-      { name: "interactive", priority: 10, interactive: true, agentids: ["w1"] },
-      { name: "background", priority: 1, agentids: ["w2"] },
-    ];
-    const events = [
-      { agentid: "w2", kind: "readtext", summary: "The background agent read the table.", at: now + 300 },
-      { agentid: "w1", kind: "click", summary: "The interactive agent opened the pricing page.", at: now + 100 },
-      { agentid: "w2", kind: "observe", summary: "The background agent observed the hero.", at: now + 200 },
-    ];
-    const merged = interleave({ events, lanes });
-    expect(merged.map((event) => event.kind)).toEqual(["click", "observe", "readtext"]);
-    expect(merged[0]?.lane).toBe("interactive");
-    expect(merged[1]?.lane).toBe("background");
-    expect(merged[2]?.lane).toBe("background");
-    /* the fleet view never interleaves an empty stream */
-    expect(() => interleave({ events: [], lanes })).toThrow(/empty/i);
-  });
-
-  it("breaks the time ties deterministically by the event id", () => {
-    const actions: swarmaction[] = [
-      { id: "x-b", kind: "click", summary: "The later id.", at: now + 100 },
-      { id: "x-a", kind: "readtext", summary: "The earlier id.", at: now + 100 },
-    ];
-    expect(interleavetimeline(actions).map((action) => action.id)).toEqual(["x-a", "x-b"]);
-  });
-});
-
-/* ── The 2.0.0 release candidate provenance stamps of the audit trail (roadmap rc.2 items 54 and 87): every progress record and step stamp carries the release that produced it, and the progress replay path replays the stamps. ── */
-import {
-  emptyprogress as freshprogress,
-  provenancestampof,
-  recordoutcome as stampoutcome,
-  recordstep as stampstep,
-  recordnaventry as stampnaventry,
-  replayprogress,
-  resetforplan as stampreset,
-} from "../progress.js";
-import { packageversion, protocolmajor } from "../version.js";
-
-describe("release candidate provenance stamps", () => {
-  const stamp = { release: packageversion, protocolmajor };
-
-  it("stamps every fresh progress record with the release that created it", () => {
-    expect(freshprogress("plan", now).provenance).toEqual(stamp);
-    expect(stampstep(undefined, "plan", "one", now).provenance).toEqual(stamp);
-    const foreign = stampstep({ planid: "other", completedsteps: ["gone"], updatedat: now }, "plan", "one", now);
-    expect(foreign.provenance).toEqual(stamp);
-    expect(foreign.completedsteps).toEqual(["one"]);
-    expect(provenancestampof()).toEqual({ release: packageversion, protocolmajor: protocolmajor });
-    expect(provenancestampof().release).toMatch(/^\d+\.\d+\.\d+$/);
-  });
-
-  it("stamps every recorded outcome while the prior fields stay untouched", () => {
-    let progress = stampstep(freshprogress("plan", now), "plan", "one", now);
-    progress = stampoutcome(
-      progress,
-      "plan",
-      { stepid: "one", ok: true, summary: "Observe completed.", details: { textlength: 42 }, at: now + 1 },
-      now + 1,
-    );
-    const outcome = progress.outcomes?.[0];
-    expect(outcome).toMatchObject({
-      stepid: "one",
-      ok: true,
-      summary: "Observe completed.",
-      details: { textlength: 42 },
-      at: now + 1,
-    });
-    expect(outcome?.provenance).toEqual(stamp);
-    const replayed = stampnaventry(
-      progress,
-      "plan",
-      "list",
-      { index: 0, url: "https://example.com/a", ok: true },
-      now + 2,
-    );
-    expect(replayed.outcomes?.[1]?.provenance).toEqual(stamp);
-    expect(replayed.outcomes?.[1]?.summary).toContain("Navigation list entry 1");
-  });
-
-  it("stamps the reset record while the preserved prior snapshot keeps its own stamp", () => {
-    const previous = stampoutcome(
-      stampstep(freshprogress("old", now), "old", "one", now),
-      "old",
-      { stepid: "one", ok: true, summary: "Old step done.", at: now },
-      now,
-    );
-    const reset = stampreset(previous, plan, now);
-    expect(reset.provenance).toEqual(stamp);
-    expect(reset.prior?.[0]?.outcomes?.[0]?.provenance).toEqual(stamp);
-    const repeated = stampstep(stampstep(freshprogress("plan", now), "plan", "one", now), "plan", "one", now + 5);
-    expect(repeated.completedsteps).toEqual(["one"]);
-    expect(repeated.provenance).toEqual(stamp);
-  });
-});
-
-describe("progress replay provenance stamps", () => {
-  const stamp = { release: packageversion, protocolmajor };
-
-  it("replays the recorded step stamps with their provenance beside the record level stamp", () => {
-    let progress = stampstep(undefined, "plan", "one", now);
-    progress = stampoutcome(
-      progress,
-      "plan",
-      { stepid: "one", ok: true, summary: "The observe step completed.", at: now + 1 },
-      now + 1,
-    );
-    progress = stampoutcome(
-      progress,
-      "plan",
-      { stepid: "two", ok: false, summary: "The click step failed.", at: now + 2 },
-      now + 2,
-    );
-    const replayed = replayprogress(progress, "plan");
-    expect(replayed.planid).toBe("plan");
-    expect(replayed.provenance).toEqual(stamp);
-    expect(replayed.entries).toHaveLength(2);
-    expect(replayed.entries[0]).toMatchObject({
-      index: 0,
-      stepid: "one",
-      ok: true,
-      summary: "The observe step completed.",
-      at: now + 1,
-    });
-    expect(replayed.entries[0]?.provenance).toEqual(stamp);
-    expect(replayed.entries[1]).toMatchObject({ index: 1, stepid: "two", ok: false });
-    expect(replayed.entries[1]?.provenance).toEqual(stamp);
-    expect(replayed.entries.map((entry) => entry.provenance?.release)).toEqual([packageversion, packageversion]);
-    expect(replayed.entries.map((entry) => entry.provenance?.protocolmajor)).toEqual([protocolmajor, protocolmajor]);
-  });
-
-  it("replays a foreign or empty progress record as an empty entry list without a stamp", () => {
-    expect(replayprogress(undefined, "plan")).toEqual({ planid: "plan", entries: [] });
-    const foreign = stampstep(freshprogress("other", now), "other", "gone", now);
-    expect(replayprogress(foreign, "plan")).toEqual({ planid: "plan", entries: [] });
-    expect(replayprogress({ planid: "plan", completedsteps: [], updatedat: now }, "plan").provenance).toBeUndefined();
-  });
-});