@wenathlan/devthink 2.0.13 → 2.0.15

package/tests/headlesslib.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "vitest";
+import {
+  closeheadlesssession,
+  headlessauditread,
+  headlessgatewait,
+  headlessmemory,
+  headlessplan,
+  headlesspolicyvalidate,
+  headlessrun,
+  headlesssessionview,
+  headlesssubscribe,
+  headlesstelemetryposture,
+  openheadlesssession,
+  remoteattachframes,
+} from "../headless.js";
+import { appendlogentry, openrunlog, sealrunlog } from "../security.js";
+import { protocolversion } from "../types.js";
+import type { flowrungate, planfile } from "../types.js";
+
+const now = 1_800_000_000_000;
+
+function plan(): planfile {
+  return {
+    version: protocolversion,
+    goal: "digest the changelog",
+    origin: "https://example.org",
+    steps: [{ id: "observe", kind: "observe", label: "Observe the page" }],
+  };
+}
+
+const gate: flowrungate = {
+  id: "gate:type",
+  kind: "type",
+  origin: "https://example.org",
+  reason: "The step is sensitive and waits at its consent gate.",
+};
+
+describe("headless sessions", () => {
+  it("opens one session on an HTTPS origin with telemetry off by default", () => {
+    const session = openheadlesssession({ origin: "https://example.org", now });
+    expect(session.state).toBe("active");
+    expect(session.telemetry).toBe(false);
+    expect(session.gatesresolved).toBe(0);
+    expect(() => openheadlesssession({ origin: "http://example.org", now })).toThrow(/HTTPS/);
+    expect(() => openheadlesssession({ origin: "", now })).toThrow(/HTTPS/);
+    const closed = closeheadlesssession(session);
+    expect(closed.state).toBe("closed");
+    expect(headlesssessionview(closed).gatesresolved).toBe(0);
+  });
+
+  it("routes every gate wait to the consent provider callback the host implements", async () => {
+    const session = openheadlesssession({ origin: "https://example.org", now });
+    const approved = await headlessgatewait({ session, gate, provider: { resolvegate: async () => "approve" } });
+    expect(approved.resolution).toBe("approve");
+    expect(approved.session.gatesresolved).toBe(1);
+    expect(approved.session.id).toBe(session.id);
+    const refused = await headlessgatewait({
+      session: approved.session,
+      gate,
+      provider: { resolvegate: async () => "refuse" },
+    });
+    expect(refused.resolution).toBe("refuse");
+    expect(refused.session.gatesresolved).toBe(1);
+    await expect(
+      headlessgatewait({
+        session: closeheadlesssession(session),
+        gate,
+        provider: { resolvegate: async () => "approve" },
+      }),
+    ).rejects.toThrow(/closed/);
+  });
+
+  it("refuses every unresolved gate under denydefault with no provider attached", async () => {
+    const session = openheadlesssession({ origin: "https://example.org", now });
+    const denied = await headlessgatewait({ session, gate });
+    expect(denied.resolution).toBe("refuse");
+    expect(denied.reason).toMatch(/denydefault/);
+    expect(denied.session.gatesresolved).toBe(0);
+  });
+
+  it("attaches remote sessions through the same json rpc protocol the extension speaks", () => {
+    const session = openheadlesssession({ origin: "https://example.org", now });
+    const frames = remoteattachframes({ id: 1, session, runtime: "node" });
+    expect(frames.initialize).toMatchObject({ jsonrpc: "2.0", id: 1, method: "initialize" });
+    expect(frames.initialize.params).toMatchObject({ protocolversion, runtime: "node", origin: "https://example.org" });
+    expect(frames.ready).toMatchObject({ jsonrpc: "2.0", id: 1 });
+    expect((frames.ready.result as { attached: boolean }).attached).toBe(true);
+  });
+
+  it("exposes the policy engine for external validation with no browser attached", () => {
+    expect(
+      headlesspolicyvalidate({ id: "s1", kind: "observe", summary: "observe", risk: "read" }, "https://example.org")
+        .allowed,
+    ).toBe(true);
+    const verdict = headlesspolicyvalidate(
+      { id: "s1", kind: "explode" as never, summary: "explode", risk: "read" },
+      "https://example.org",
+    );
+    expect(verdict.allowed).toBe(false);
+  });
+
+  it("exposes the audit reader with chain verification", async () => {
+    let log = openrunlog({ runid: "run:1", sessionid: "headless", now });
+    log = await appendlogentry({
+      log,
+      kind: "step",
+      summary: "The step ran.",
+      origin: "https://example.org",
+      stepid: "observe",
+      at: now,
+    });
+    const sealed = await sealrunlog(log, now + 10);
+    const read = await headlessauditread(sealed.log);
+    expect(read.ok).toBe(true);
+    expect(read.entries).toHaveLength(1);
+    expect(read.entries[0]?.kind).toBe("step");
+  });
+
+  it("exposes the memory entry point over the same profile store format", async () => {
+    const store: Map<string, unknown> = new Map();
+    const memory = headlessmemory({
+      async get<T>(key: string) {
+        return store.get(key) as T | undefined;
+      },
+      async set<T>(key: string, value: T) {
+        store.set(key, value);
+      },
+    });
+    expect(await memory.getconfig()).toBeUndefined();
+    await memory.setconfig({ provider: "local" } as never);
+    expect(await memory.getconfig()).toMatchObject({ provider: "local" });
+  });
+
+  it("exposes the plan, run and session entry points to hosts", () => {
+    const planned = headlessplan(plan(), ["https://example.org"]);
+    expect(planned.version).toBe(protocolversion);
+    expect(planned.workflow.origins).toEqual(["https://example.org"]);
+    expect(planned.workflow.steps[0]).toMatchObject({ id: "observe", kind: "observe" });
+    expect(() => headlessplan(plan(), ["https://elsewhere.org"])).toThrow(/outside the grants/);
+    const provider = { resolvegate: async () => "approve" as const };
+    const run = headlessrun({
+      request: {
+        planpath: "plan.json",
+        options: { format: "human", outputdir: "out", grantspath: "grants.json", interactive: false, dryrun: true },
+      },
+      file: plan(),
+      provider,
+    });
+    expect(run.provider).toBe(provider);
+    expect(run.request.planpath).toBe("plan.json");
+    const view = headlesssessionview(openheadlesssession({ origin: "https://example.org", now }));
+    expect(view).toMatchObject({ origin: "https://example.org", state: "active", telemetry: false });
+  });
+
+  it("exposes typed run subscriptions that keep their own event list", () => {
+    const seen: string[] = [];
+    const subscription = headlesssubscribe((event) => seen.push(event.summary));
+    subscription.emit({ kind: "step", stepid: "observe", summary: "The step ran.", at: now });
+    subscription.emit({ kind: "gate", stepid: "type", summary: "The gate waits.", at: now + 1 });
+    expect(seen).toEqual(["The step ran.", "The gate waits."]);
+    expect(subscription.events()).toHaveLength(2);
+    expect(subscription.events()[0]?.kind).toBe("step");
+  });
+
+  it("keeps the telemetry posture off unless the host opts in", () => {
+    expect(headlesstelemetryposture(false).telemetry).toBe(false);
+    expect(headlesstelemetryposture(false).reason).toMatch(/nothing by default/);
+    expect(headlesstelemetryposture(true).telemetry).toBe(true);
+    expect(headlesstelemetryposture(true).reason).toMatch(/host opt in/);
+  });
+});

package/tests/httpstream.test.ts

@@ -0,0 +1,277 @@
+import { describe, expect, it } from "vitest";
+import {
+  channellive,
+  closeidlechannels,
+  defaultidlewindowms,
+  defaultheartbeatms,
+  defaulthttpstream,
+  enforcemaxclients,
+  heartbeat,
+  httpframepipeline,
+  listremotestatus,
+  openstreamchannel,
+  starttls,
+} from "../http.js";
+import { issuetoken, issuepairingcode, grantallowlistentry } from "../auth.js";
+import { defaultmcpconfig } from "../mcp.js";
+import type { clientrecord, mcpserverconfig, streamchannel } from "../types.js";
+
+const now = 1_800_000_000_000;
+
+/** Builds one connected client fixture. */
+function client(id: string, transport: "stdio" | "http" = "http"): clientrecord {
+  return { id, transport, paired: true, connectedat: now - 1000, pairedat: now - 500 };
+}
+
+/** Builds one open channel fixture with its last beat offset from now. */
+function channel(clientid: string, beatoffset: number): streamchannel {
+  return { id: `channel-${clientid}`, clientid, openedat: now - 2000, lastbeatat: now - beatoffset };
+}
+
+describe("http stream channels", () => {
+  it("opens server sent event channels and heartbeats idle ones", () => {
+    const open = openstreamchannel({ clientid: "client1", now, id: "channel-1" });
+    expect(open.id).toBe("channel-1");
+    expect(open.openedat).toBe(now);
+    expect(open.lastbeatat).toBe(now);
+    expect(open.closedat).toBeUndefined();
+    const beaten = heartbeat({ channels: [open], clientid: "client1", now: now + 5000 });
+    expect(beaten[0]?.lastbeatat).toBe(now + 5000);
+    const untouched = heartbeat({ channels: [channel("other", 0)], clientid: "client1", now: now + 5000 });
+    expect(untouched[0]?.lastbeatat).toBe(now);
+    expect(defaulthttpstream()).toEqual({
+      endpoint: "/mcp",
+      streampath: "/mcp/stream",
+      tls: { mode: "off" },
+      heartbeatms: defaultheartbeatms,
+      idlewindowms: defaultidlewindowms,
+    });
+    expect(defaultheartbeatms).toBe(30_000);
+    expect(defaultidlewindowms).toBe(90_000);
+  });
+
+  it("closes dead channels past the idle window while live ones stay open", () => {
+    const live = channel("client1", 1000);
+    const dead = channel("client2", defaultidlewindowms + 1);
+    const closedalready = { ...channel("client3", 500), closedat: now - 10 };
+    const swept = closeidlechannels({ channels: [live, dead, closedalready], now, idlewindow: defaultidlewindowms });
+    expect(swept[0]?.closedat).toBeUndefined();
+    expect(swept[1]?.closedat).toBe(now);
+    expect(swept[2]?.closedat).toBe(now - 10);
+    expect(channellive(live, now, defaultidlewindowms)).toBe(true);
+    expect(channellive(dead, now, defaultidlewindowms)).toBe(false);
+    expect(channellive(closedalready, now, defaultidlewindowms)).toBe(false);
+    expect(channellive(channel("client4", 5000), now, 1000)).toBe(false);
+  });
+});
+
+describe("tls termination", () => {
+  it("keeps the localhost default off while required mode refuses unverified peers", () => {
+    expect(starttls({ config: { mode: "off" }, now }).tls).toBe(false);
+    const negotiated = starttls({ config: { mode: "on" }, now });
+    expect(negotiated.tls).toBe(true);
+    expect(negotiated.verified).toBe(true);
+    const required = starttls({ config: { mode: "required" }, now });
+    expect(required.tls).toBe(false);
+    expect(required.reason).toMatch(/presented no certificate/i);
+    const fingerprint = starttls({
+      config: { mode: "required", certificatefingerprint: "sha256:aa" },
+      presented: { fingerprint: "sha256:bb" },
+      now,
+    });
+    expect(fingerprint.verified).toBe(false);
+    expect(fingerprint.reason).toMatch(/does not match the user configured fingerprint/i);
+    expect(
+      starttls({
+        config: { mode: "required", certificatefingerprint: "sha256:aa" },
+        presented: { fingerprint: "sha256:aa" },
+        now,
+      }),
+    ).toEqual({ tls: true, verified: true });
+    expect(starttls({ config: { mode: "on", certificatefingerprint: "sha256:aa" }, now }).verified).toBe(false);
+  });
+});
+
+describe("client ceiling", () => {
+  it("refuses connections past the user configured maximum while an absent value stays unbounded", () => {
+    const clients = [client("client1"), client("client2")];
+    expect(enforcemaxclients({ clients, maxclients: 2 }).allowed).toBe(false);
+    expect(enforcemaxclients({ clients, maxclients: 2 }).reason).toMatch(/maximum of 2 remote clients/i);
+    expect(enforcemaxclients({ clients, maxclients: 3 }).allowed).toBe(true);
+    expect(enforcemaxclients({ clients }).allowed).toBe(true);
+    const disconnected = [
+      client("client1"),
+      { ...client("client2"), disconnectedat: now },
+      { ...client("client3"), disconnectedat: now },
+    ];
+    expect(enforcemaxclients({ clients: disconnected, maxclients: 2 }).allowed).toBe(true);
+    expect(enforcemaxclients({ clients: disconnected, maxclients: 1 }).allowed).toBe(false);
+  });
+});
+
+describe("remote status", () => {
+  it("reports endpoint, tls state, client counts and channel health", async () => {
+    const token = await issuetoken({ clientid: "client1", scopes: ["browser"], now, raw: "raw" });
+    const config: mcpserverconfig = {
+      ...defaultmcpconfig(),
+      enabled: true,
+      httpstream: defaulthttpstream(),
+      remoteaccess: { endpoint: "https://agent.example:7436", tls: { mode: "required" }, maxclients: 5 },
+    };
+    const status = listremotestatus({
+      config,
+      channels: [channel("client1", 1000), channel("client2", defaultidlewindowms + 1)],
+      clients: [client("client1"), { ...client("client2"), paired: false }],
+      tokens: [token.token],
+      now,
+    });
+    expect(status.endpoint).toBe("https://agent.example:7436");
+    expect(status.tls.mode).toBe("required");
+    expect(status.tls.certificaterequired).toBe(true);
+    expect(status.clients).toBe(2);
+    expect(status.paired).toBe(1);
+    expect(status.channelsopen).toBe(1);
+    expect(status.channelsdead).toBe(1);
+    expect(status.tokenslive).toBe(1);
+    const plain = listremotestatus({
+      config: { ...defaultmcpconfig(), enabled: true },
+      channels: [],
+      clients: [],
+      tokens: [],
+      now,
+    });
+    expect(plain.endpoint).toBe("/mcp");
+    expect(plain.tls.mode).toBe("off");
+  });
+});
+
+describe("ordered remote frame pipeline", () => {
+  /** Builds the full pipeline fixture set for one remote caller. */
+  async function pipelinefixture(
+    config: mcpserverconfig,
+  ): Promise<{
+    tokens: Awaited<ReturnType<typeof issuetoken>>["token"][];
+    raw: string;
+    allowlist: import("../types.js").allowlistentry[];
+  }> {
+    const issued = await issuetoken({ clientid: "client1", scopes: ["browser"], now, raw: "raw-token" });
+    const allowlist = grantallowlistentry({
+      entries: [],
+      identity: { fingerprint: "fp-1", displayname: "Laptop agent" },
+      namespaces: ["browser"],
+      actor: "user",
+      now,
+    });
+    return { tokens: [issued.token], raw: "raw-token", allowlist };
+  }
+
+  it("terminates tls before any token verification", async () => {
+    const config: mcpserverconfig = {
+      ...defaultmcpconfig(),
+      enabled: true,
+      remoteaccess: {
+        endpoint: "https://agent.example",
+        tls: { mode: "required", certificatefingerprint: "sha256:aa" },
+      },
+    };
+    const fixture = await pipelinefixture(config);
+    const refused = await httpframepipeline({
+      config,
+      presented: { fingerprint: "sha256:bb" },
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      toolname: "browser.readtext",
+      now,
+    });
+    expect(refused.error?.code).toBe("consentrefused");
+    expect(refused.error?.message).toMatch(/does not match the user configured fingerprint/i);
+    expect(refused.token).toBeUndefined();
+    const missing = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      now,
+    });
+    expect(missing.error?.message).toMatch(/presented no certificate/i);
+  });
+
+  it("verifies the session token on every frame and answers with the fixed refusal", async () => {
+    const config: mcpserverconfig = { ...defaultmcpconfig(), enabled: true };
+    const fixture = await pipelinefixture(config);
+    const missing = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      now,
+    });
+    expect(missing.error?.message).toBe("The remote frame failed its authentication handshake.");
+    const wrong = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: "wrong",
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      now,
+    });
+    expect(wrong.error?.code).toBe("consentrefused");
+    expect(wrong.error?.message).toBe("The remote frame failed its authentication handshake.");
+  });
+
+  it("refuses allowlist misses after the token verified", async () => {
+    const config: mcpserverconfig = { ...defaultmcpconfig(), enabled: true };
+    const fixture = await pipelinefixture(config);
+    const unknown = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-unknown",
+      now,
+    });
+    expect(unknown.error?.code).toBe("consentrefused");
+    expect(unknown.error?.message).toMatch(/not on the allowlist/i);
+  });
+
+  it("fails unknown namespaces fast and ungranted scopes as consent refusals", async () => {
+    const config: mcpserverconfig = { ...defaultmcpconfig(), enabled: true };
+    const fixture = await pipelinefixture(config);
+    const unknown = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      toolname: "carrierpigeon.readtext",
+      now,
+    });
+    expect(unknown.error?.code).toBe("params");
+    expect(unknown.error?.message).toMatch(/no reviewed namespace/i);
+    const ungranted = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      toolname: "memory.list",
+      now,
+    });
+    expect(ungranted.error?.code).toBe("consentrefused");
+    expect(ungranted.error?.message).toMatch(/grants no memory tools/i);
+    const clean = await httpframepipeline({
+      config,
+      tokens: fixture.tokens,
+      rawtoken: fixture.raw,
+      allowlist: fixture.allowlist,
+      fingerprint: "fp-1",
+      toolname: "browser.readtext",
+      now,
+    });
+    expect(clean.error).toBeUndefined();
+    expect(clean.token?.clientid).toBe("client1");
+  });
+});

package/tests/immutablelog.test.ts

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+import {
+  appendlogentry,
+  chainreportof,
+  entryhashof,
+  exportlogchain,
+  lasthashof,
+  logentryof,
+  openrunlog,
+  readverifiedlog,
+  sealrunlog,
+  verifylogchain,
+} from "../security.js";
+import type { immutablelogentry, storedrunlog } from "../types.js";
+
+const now = 1_000;
+const origin = "https://example.com";
+
+describe("immutable log hash chain", () => {
+  async function samplelog(): Promise<storedrunlog> {
+    let log = openrunlog({ runid: "run1", sessionid: "s1", now });
+    log = await appendlogentry({
+      log,
+      kind: "grant",
+      summary: "The session started for the origin.",
+      origin,
+      at: now + 1,
+    });
+    log = await appendlogentry({
+      log,
+      kind: "step",
+      summary: "The click step completed.",
+      origin,
+      stepid: "s1",
+      at: now + 2,
+    });
+    log = await appendlogentry({
+      log,
+      kind: "deny",
+      summary: "The submitform step was denied.",
+      origin,
+      stepid: "s2",
+      at: now + 3,
+    });
+    return log;
+  }
+
+  it("chains every entry to the hash of its predecessor and writes the entry hash at append time", async () => {
+    const log = await samplelog();
+    expect(log.entries).toHaveLength(3);
+    expect(log.entries[0]?.hash.previous).toBe("0".repeat(64));
+    for (let index = 1; index < log.entries.length; index += 1) {
+      expect(log.entries[index]?.hash.previous).toBe(log.entries[index - 1]?.hash.current);
+    }
+    for (const entry of log.entries) {
+      expect(entry.hash.current).toMatch(/^[0-9a-f]{64}$/);
+      expect(entry.hash.algorithm).toBe("sha-256");
+    }
+    expect(lasthashof(log)).toBe(log.entries[2]?.hash.current);
+    expect(lasthashof(openrunlog({ runid: "r", sessionid: "s", now }))).toBe("0".repeat(64));
+    expect(() => openrunlog({ runid: " ", sessionid: "s", now })).toThrow(/run and session ids/i);
+  });
+
+  it("derives the entry hash over the canonical body only", async () => {
+    const body = { id: "e1", runid: "run1", kind: "step" as const, summary: "The step completed.", origin, at: now };
+    const one = await entryhashof({ previous: "0".repeat(64), entry: body });
+    const two = await entryhashof({ previous: "f".repeat(64), entry: body });
+    expect(one.current).not.toBe(two.current);
+    expect(one.previous).toBe("0".repeat(64));
+    const entry = await logentryof({
+      runid: "run1",
+      kind: "step",
+      summary: "The step completed.",
+      origin,
+      at: now,
+      previous: "0".repeat(64),
+    });
+    expect(entry.id).not.toBe("");
+    await expect(
+      logentryof({ runid: "run1", kind: "step", summary: " ", origin, at: now, previous: "" }),
+    ).rejects.toThrow(/summary/i);
+  });
+
+  it("verifies the whole chain at read time and refuses reads of a broken link", async () => {
+    const log = await samplelog();
+    const verified = await verifylogchain(log.entries);
+    expect(verified.valid).toBe(true);
+    expect(verified.reason).toMatch(/verifies from the genesis hash/i);
+    const read = await readverifiedlog(log);
+    expect(read.ok).toBe(true);
+    expect(read.entries).toHaveLength(3);
+    const tampered = log.entries.map((entry, index) =>
+      index === 1 ? { ...entry, summary: "A forged summary." } : entry,
+    );
+    const broken = await verifylogchain(tampered);
+    expect(broken.valid).toBe(false);
+    expect(broken.brokenat).toBe(1);
+    expect(broken.reason).toMatch(/tamper evidence/i);
+    const refused = await readverifiedlog({ ...log, entries: tampered });
+    expect(refused.ok).toBe(false);
+    expect(refused.entries).toEqual([]);
+    const relinked = log.entries.map((entry, index) =>
+      index === 2 ? { ...entry, hash: { ...entry.hash, previous: "0".repeat(64) } } : entry,
+    );
+    const relinkbroken = await verifylogchain(relinked);
+    expect(relinkbroken.valid).toBe(false);
+    expect(relinkbroken.brokenat).toBe(2);
+  });
+
+  it("seals the log at completion with a final hash and refuses every append after the seal", async () => {
+    const log = await samplelog();
+    const { log: sealed, seal } = await sealrunlog(log, now + 10);
+    expect(seal.entries).toBe(3);
+    expect(seal.sealhash.previous).toBe(log.entries[2]?.hash.current);
+    expect(seal.sealhash.current).toMatch(/^[0-9a-f]{64}$/);
+    expect(sealed.seal?.sealedat).toBe(now + 10);
+    await expect(
+      appendlogentry({ log: sealed, kind: "step", summary: "A late append.", origin, at: now + 11 }),
+    ).rejects.toThrow(/accepts no append/i);
+    await expect(sealrunlog(sealed, now + 12)).rejects.toThrow(/already sealed/i);
+    await expect(sealrunlog(openrunlog({ runid: "empty", sessionid: "s", now }), now)).rejects.toThrow(
+      /at least one entry/i,
+    );
+  });
+
+  it("reports the chain status per run with the seal hash and exports only verified chains", async () => {
+    const log = await samplelog();
+    const openreport = await chainreportof(log);
+    expect(openreport.valid).toBe(true);
+    expect(openreport.entries).toBe(3);
+    expect(openreport.sealhash).toBeUndefined();
+    const sealed = await sealrunlog(log, now + 10);
+    const sealedreport = await chainreportof(sealed.log);
+    expect(sealedreport.sealhash).toBe(sealed.seal.sealhash.current);
+    expect(sealedreport.sealedat).toBe(now + 10);
+    const exported = await exportlogchain(sealed.log);
+    expect(exported.chainvalid).toBe(true);
+    expect(exported.entries).toBe(3);
+    expect(exported.sealhash).toBe(sealed.seal.sealhash.current);
+    expect(exported.log).toHaveLength(3);
+    const forged: immutablelogentry[] = sealed.log.entries.map((entry, index) =>
+      index === 0 ? { ...entry, summary: "Forged." } : entry,
+    );
+    const refused = await exportlogchain({ ...sealed.log, entries: forged });
+    expect(refused.chainvalid).toBe(false);
+    expect(refused.log).toEqual([]);
+    expect(refused.entries).toBe(0);
+  });
+
+  it("attaches provenance of origin and step to every entry", async () => {
+    const log = await samplelog();
+    expect(log.entries[0]?.origin).toBe(origin);
+    expect(log.entries[0]?.stepid).toBeUndefined();
+    expect(log.entries[1]?.stepid).toBe("s1");
+    expect(log.entries[2]?.stepid).toBe("s2");
+  });
+});