@wenathlan/devthink 2.0.14 → 2.0.19

package/sync.ts

@@ -1,56 +0,0 @@
-import { getIdentity } from "./identity.js";
-import { listSessions, loadWorkspace, type Session, type Workspace } from "./workbenchsession.js";
-import { isSecureRemoteEndpoint } from "./compatibility.js";
-import type { DevThinkConfig, DevThinkPaths } from "./config.ts";
-
-export type SyncSnapshot = {
-  version: 1;
-  userId: string;
-  deviceId: string;
-  exportedAt: string;
-  workspaces: Workspace[];
-  sessions: Session[];
-};
-export type RemoteSyncStatus = { enabled: boolean; endpoint?: string; ready: boolean; reason?: string };
-
-export function exportLocalSnapshot(paths: DevThinkPaths): SyncSnapshot {
-  const identity = getIdentity(paths);
-  const sessions = listSessions(paths);
-  const workspaces = [...new Set(sessions.map((session) => session.workspaceId))].flatMap((workspaceId) => {
-    const workspace = loadWorkspace(paths, workspaceId);
-    return workspace ? [workspace] : [];
-  });
-  return {
-    version: 1,
-    userId: identity.userId,
-    deviceId: identity.deviceId,
-    exportedAt: new Date().toISOString(),
-    workspaces,
-    sessions,
-  };
-}
-
-export function remoteSyncStatus(config: DevThinkConfig): RemoteSyncStatus {
-  const remote = config.web?.remoteSync;
-  if (!remote?.enabled)
-    return {
-      enabled: false,
-      ready: false,
-      reason: "Remote synchronization is disabled; local pairing remains available.",
-    };
-  if (!remote.endpoint)
-    return {
-      enabled: true,
-      ready: false,
-      reason: "Set web.remoteSync.endpoint to a user-operated HTTPS API that implements the DevThink sync contract.",
-    };
-  if (!isSecureRemoteEndpoint(remote.endpoint)) {
-    return {
-      enabled: true,
-      endpoint: remote.endpoint,
-      ready: false,
-      reason: "Remote synchronization endpoint is not a valid HTTPS URL.",
-    };
-  }
-  return { enabled: true, endpoint: new URL(remote.endpoint).toString(), ready: true };
-}

package/tests/agentcert.test.ts

@@ -1,128 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { promisify } from "node:util";
-
-const execute = promisify(execFile);
-
-/* ── The 1.1.96 multi agent coordination certification coverage. ── */
-
-describe("the agentcert coordination artifact", () => {
-  it("declares every automated entry of the release candidate coordination checklist with its family and module", async () => {
-    const source = await readFile("tests/agentcert.mjs", "utf8");
-    const declarations = [
-      ...source.matchAll(/await entry\(\{ id: (\d+), title: "([^"]+)", family: "([^"]+)", module: "([^"]+)" \}/g),
-    ].map((match) => ({ id: Number(match[1]), title: match[2], family: match[3], module: match[4] }));
-    expect(declarations).toHaveLength(30);
-    expect(declarations.map((entry) => entry.id)).toEqual(Array.from({ length: 30 }, (_, index) => index + 1));
-    const families = new Set(declarations.map((entry) => entry.family));
-    for (const family of [
-      "topology",
-      "roles",
-      "review",
-      "verification",
-      "messaging",
-      "queue",
-      "work stealing",
-      "blackboard",
-      "tab handoff",
-      "locking",
-      "conflicts",
-      "merging",
-      "consensus",
-      "emergency stops",
-      "lifecycle",
-      "sub agents",
-      "escalation",
-      "review flow",
-      "audit replay",
-      "comparison",
-      "lanes",
-      "arbitration",
-      "scaling",
-      "budgets",
-      "scopes",
-      "reporting",
-      "timeline",
-      "lessons",
-      "pool coverage",
-    ])
-      expect(families.has(family)).toBe(true);
-    for (const entry of declarations) expect((entry.title ?? "").length).toBeGreaterThan(10);
-  });
-
-  it("covers every coordination scenario entry with a passing outcome once the gate has run", async () => {
-    const artifactpath = "tests/artifacts/agentcert.json";
-    const built = existsSync("dist/extension/manifest.json");
-    const packagejson = JSON.parse(await readFile("package.json", "utf8")) as { version: string };
-    /* a built tree runs the gate itself when no fresh artifact of this release exists, so every lane that builds before the suite — the bun lane, the deno lane, a local two-pass validate — verifies the coordination artifact without depending on the gate having run before the tests */
-    if (built && !existsSync(artifactpath)) await execute("node", ["tests/agentcert.mjs"]);
-    if (built && existsSync(artifactpath)) {
-      const stored = JSON.parse(await readFile(artifactpath, "utf8")) as { release: string };
-      if (stored.release !== packagejson.version) await execute("node", ["tests/agentcert.mjs"]);
-    }
-    const stored = existsSync(artifactpath);
-    if (built) expect(stored).toBe(true);
-    if (!stored) return;
-    const report = JSON.parse(await readFile(artifactpath, "utf8")) as {
-      release: string;
-      clockmode: string;
-      faketabkinds: string[];
-      entries: Array<{ id: number; title: string; outcome: string; detail: string }>;
-      summary: {
-        total: number;
-        passed: number;
-        failed: number;
-        poolitems: { from: number; to: number; covered: number };
-      };
-    };
-    expect(report.release).toBe(packagejson.version);
-    expect(report.summary.total).toBe(30);
-    expect(report.summary.failed).toBe(0);
-    expect(report.summary.passed).toBe(30);
-    expect(report.entries.map((entry) => entry.id)).toEqual(Array.from({ length: 30 }, (_, index) => index + 1));
-    for (const entry of report.entries) {
-      expect(entry.outcome).toBe("pass");
-      expect(entry.detail.length).toBeGreaterThan(10);
-    }
-  });
-
-  it("records the deterministic run mode, the fake tab kinds of every browser and the pool coverage of 469 through 502", async () => {
-    const artifactpath = "tests/artifacts/agentcert.json";
-    if (!existsSync(artifactpath)) return;
-    const report = JSON.parse(await readFile(artifactpath, "utf8")) as {
-      clockmode: string;
-      faketabkinds: string[];
-      summary: { poolitems: { from: number; to: number; covered: number } };
-    };
-    /* the fake clock mode keeps every coordination scenario deterministic, the fake tab provider covers every browser kind and the pool mapping covers every multi agent coordination item of the feature pool */
-    expect(report.clockmode).toBe("fake");
-    expect(report.faketabkinds).toEqual(["chromium", "firefox", "safari"]);
-    expect(report.summary.poolitems).toEqual({ from: 469, to: 502, covered: 34 });
-  });
-
-  it("exercises the real compiled modules the checklist names and stays deterministic", async () => {
-    const source = await readFile("tests/agentcert.mjs", "utf8");
-    expect(source).toContain('import("../dist/index.js")');
-    expect(source).toContain('import("../dist/policy.js")');
-    expect(source).toContain('import("../dist/dashdone.js")');
-    /* every fixture time flows from the fixed epoch of the fake clock that stays the default mode — the real clock exists only behind the explicit opt in switch the operator drives — and the artifact carries no timestamps so reruns stay byte identical */
-    expect(source).toContain("fakeclock");
-    expect(source).toContain("1_800_000_000_000");
-    expect(source).toContain('clockmode = process.argv.includes("--clock")');
-    const artifactpath = "tests/artifacts/agentcert.json";
-    if (existsSync(artifactpath)) expect(await readFile(artifactpath, "utf8")).not.toContain('"at"');
-    expect(source).toContain("process.exitCode = 1");
-  });
-
-  it("exports the leader worker topology scenario the chromium smoke executes end to end", async () => {
-    const source = await readFile("tests/agentcert.mjs", "utf8");
-    expect(source).toContain("export async function runleaderworkertopologyscenario");
-    expect(source).toContain("faketabprovider.tabof");
-    /* the scenario registers five fake agents across the fake tabs of every browser kind, so the smoke covers one coordination scenario against the shipped bundles */
-    expect(source).toContain('tabof("chromium"');
-    expect(source).toContain('tabof("firefox"');
-    expect(source).toContain('tabof("safari"');
-  });
-});

package/tests/agentfleet.test.ts

@@ -1,214 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  agentbudgetof,
-  agentname,
-  agentscopeof,
-  budgetremaining,
-  engagekillswitch,
-  fleetoverview,
-  pauseagent,
-  readonlyscope,
-  spendbudget,
-  unpauseagent,
-} from "../agent.js";
-import {
-  agentnamevalid,
-  agentscopegate,
-  budgetgate,
-  killswitchgate,
-  pauseagentgate,
-  voteweightvalid,
-} from "../policy.js";
-import type { agentrecord, runrecord, taskqueue } from "../types.js";
-import { emptyqueue } from "../swarm.js";
-
-const now = 1_800_000_000_000;
-
-/** Builds one fleet record fixture with every value user chosen. */
-function record(over: Partial<agentrecord> = {}): agentrecord {
-  return {
-    id: "a1",
-    name: "scout",
-    role: "worker",
-    origin: "https://example.com",
-    state: "active",
-    registeredat: now,
-    lastseenat: now,
-    ...over,
-  };
-}
-
-/** Builds one run record fixture of the fleet attribution. */
-function run(over: Partial<runrecord> = {}): runrecord {
-  return {
-    runid: "run1",
-    planid: "plan1",
-    sessionid: "session1",
-    state: "running",
-    createdat: now,
-    updatedat: now,
-    agentid: "a1",
-    ...over,
-  };
-}
-
-describe("agentfleet naming and scope narrowing", () => {
-  it("assigns unique lowercase names and refuses duplicates, reserved words and out of rule names", () => {
-    const first = agentname({ records: [], id: "a1", proposed: " Scout ", origin: "https://example.com", now });
-    expect(first.name).toBe("scout");
-    expect(first.state).toBe("active");
-    expect(agentnamevalid({ name: "Scout", records: [first] }).allowed).toBe(false);
-    expect(() =>
-      agentname({ records: [first], id: "a2", proposed: "scout", origin: "https://example.com", now }),
-    ).toThrow(/already registered/i);
-    expect(() =>
-      agentname({ records: [first], id: "a2", proposed: "user", origin: "https://example.com", now }),
-    ).toThrow(/reserved/i);
-    expect(() =>
-      agentname({ records: [first], id: "a2", proposed: "Scout Two", origin: "https://example.com", now }),
-    ).toThrow(/lowercase identifier/i);
-    const second = agentname({
-      records: [first],
-      id: "a2",
-      proposed: "verifier",
-      role: "verifier",
-      origin: "https://example.com",
-      now,
-    });
-    expect(second.name).toBe("verifier");
-    expect(second.role).toBe("verifier");
-  });
-
-  it("intersects the requested scope with the session grants and narrows the action kinds", () => {
-    const grants = ["https://example.com", "https://other.example"];
-    const scope = agentscopeof({
-      agentid: "a1",
-      requested: {
-        origins: ["https://example.com", "https://denied.example"],
-        actionkinds: ["observe", "readtext", "click"],
-      },
-      grants,
-      allowedkinds: ["observe", "readtext", "navigate", "click"],
-    });
-    expect(scope.origins).toEqual(["https://example.com"]);
-    expect(scope.actionkinds).toEqual(["observe", "readtext", "click"]);
-    expect(() =>
-      agentscopeof({
-        agentid: "a1",
-        requested: { origins: ["https://denied.example"] },
-        grants,
-        allowedkinds: ["observe"],
-      }),
-    ).toThrow(/outside the session grants/i);
-    expect(() =>
-      agentscopeof({ agentid: "a1", requested: { actionkinds: ["typetime"] }, grants, allowedkinds: ["observe"] }),
-    ).toThrow(/outside the allowed catalog/i);
-    const observer = readonlyscope({ agentid: "a2", readkinds: ["observe", "readtext"] });
-    expect(observer.readonly).toBe(true);
-    expect(observer.toolnamespaces).toEqual(["memory", "system"]);
-    expect(agentscopegate({ scope: observer, kind: "click", risk: "sensitive" }).allowed).toBe(false);
-    expect(agentscopegate({ scope: observer, kind: "observe", risk: "read" }).allowed).toBe(true);
-    expect(agentscopegate({ scope, kind: "observe", origin: "https://example.com", risk: "read" }).allowed).toBe(true);
-    expect(agentscopegate({ scope, kind: "click", origin: "https://denied.example", risk: "sensitive" }).allowed).toBe(
-      false,
-    );
-  });
-});
-
-describe("agentfleet budget grant, spend refusal and reporting", () => {
-  it("grants a budget from user configuration, spends one unit per step and refuses past the ceiling", () => {
-    const grant = agentbudgetof({ agentid: "a1", maxsteps: 2, maxtokens: 100, maxdurationms: 5_000, now });
-    expect(grant.state.spentsteps).toBe(0);
-    expect(grant.budget.maxsteps).toBe(2);
-    const onestep = spendbudget({ state: grant.state, steps: 1, tokens: 40, durationms: 1_000, now });
-    expect(onestep.spentsteps).toBe(1);
-    const twosteps = spendbudget({ state: onestep, steps: 1, tokens: 40, durationms: 1_000, now });
-    expect(twosteps.spentsteps).toBe(2);
-    expect(() => spendbudget({ state: twosteps, steps: 1, now })).toThrow(/budgeted steps/i);
-    expect(() => spendbudget({ state: twosteps, steps: 0, tokens: 40, now })).toThrow(/budgeted tokens/i);
-    expect(() => spendbudget({ state: twosteps, steps: 0, tokens: 0, durationms: 5_000, now })).toThrow(
-      /budgeted milliseconds/i,
-    );
-    const gate = budgetgate({ state: twosteps, steps: 1 });
-    expect(gate.allowed).toBe(false);
-    expect(gate.reason).toMatch(/user configured steps/i);
-    const unbounded = agentbudgetof({ agentid: "a2", now });
-    expect(budgetgate({ state: unbounded.state, steps: 1_000 }).allowed).toBe(true);
-    const remaining = budgetremaining(twosteps);
-    expect(remaining.steps).toBe(0);
-    expect(remaining.reason).toMatch(/0 of 2 steps left/i);
-    expect(() => agentbudgetof({ agentid: "a1", maxsteps: -3, now })).toThrow(/positive number/i);
-  });
-});
-
-describe("agentfleet pause isolation and killswitch completeness", () => {
-  it("pauses one agent without stopping its peers and leaves their run records untouched", () => {
-    const fleet = [record(), record({ id: "a2", name: "mapper" })];
-    const gate = pauseagentgate({ records: fleet, agentid: "a1" });
-    expect(gate.allowed).toBe(true);
-    expect(gate.reason).toMatch(/1 peer/i);
-    const paused = pauseagent({ records: fleet, agentid: "a1", now });
-    expect(paused.find((entry) => entry.id === "a1")?.state).toBe("paused");
-    expect(paused.find((entry) => entry.id === "a2")?.state).toBe("active");
-    expect(() => pauseagent({ records: paused, agentid: "missing", now })).toThrow(/not registered/i);
-    const resumed = unpauseagent({ records: paused, agentid: "a1", now });
-    expect(resumed.find((entry) => entry.id === "a1")?.state).toBe("active");
-  });
-
-  it("engages the killswitch in one call: every record stops, every agent run cancels, every queue clears and each stopped agent counts", () => {
-    const fleet = [
-      record(),
-      record({ id: "a2", name: "mapper" }),
-      record({ id: "a3", name: "watcher", state: "paused" }),
-    ];
-    const userrun: runrecord = {
-      runid: "run3",
-      planid: "plan3",
-      sessionid: "session1",
-      state: "running",
-      createdat: now,
-      updatedat: now,
-    };
-    const runs = [
-      run(),
-      run({ runid: "run2", agentid: "a2", state: "queued" }),
-      userrun,
-      run({ runid: "run4", agentid: "a2", state: "completed" }),
-    ];
-    const queue: taskqueue = {
-      ...emptyqueue({ lanes: ["main"] }),
-      items: [{ id: "t1", lane: "main", priority: 1, payload: "task", state: "queued", enqueuedat: now }],
-      claims: [],
-    };
-    const usergate = killswitchgate({ triggeredby: "user", pausedagents: 1 });
-    expect(usergate.allowed).toBe(true);
-    expect(usergate.reason).toMatch(/stays effective over the 1 paused agent/i);
-    expect(killswitchgate({ triggeredby: "agent" }).allowed).toBe(false);
-    const stop = engagekillswitch({ records: fleet, runs, queues: [queue], reason: "The user halted the fleet.", now });
-    expect(stop.records.every((entry) => entry.state === "stopped")).toBe(true);
-    expect(stop.runs.find((entry) => entry.runid === "run1")?.state).toBe("cancelled");
-    expect(stop.runs.find((entry) => entry.runid === "run2")?.state).toBe("cancelled");
-    expect(stop.runs.find((entry) => entry.runid === "run3")?.state).toBe("running");
-    expect(stop.runs.find((entry) => entry.runid === "run4")?.state).toBe("completed");
-    expect(stop.queues[0]?.items).toHaveLength(0);
-    expect(stop.stopped).toHaveLength(3);
-    expect(stop.stopped.map((entry) => entry.name)).toEqual(["scout", "mapper", "watcher"]);
-    expect(stop.stopped.find((entry) => entry.agentid === "a1")?.runs).toEqual(["run1"]);
-    const overview = fleetoverview({
-      records: stop.records,
-      budgets: [],
-      openescalations: 1,
-      openreviews: 2,
-      killswitchat: now,
-    });
-    expect(overview.stopped).toBe(3);
-    expect(overview.openescalations).toBe(1);
-    expect(overview.lastkillswitchat).toBe(now);
-  });
-
-  it("keeps the vote weight at one per agentrecord", () => {
-    expect(voteweightvalid({ votes: [{ agentid: "a1" }, { agentid: "a2" }] }).allowed).toBe(true);
-    expect(voteweightvalid({ votes: [{ agentid: "a1" }, { agentid: "a1" }] }).reason).toMatch(/voted twice/i);
-    expect(voteweightvalid({ votes: [{ agentid: " " }] }).allowed).toBe(false);
-  });
-});

package/tests/agentreview.test.ts

@@ -1,241 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  consensusrecordof,
-  escalationblock,
-  outputcompare,
-  recordverdict,
-  reconstructreplay,
-  reviewrecordof,
-  runreplay,
-} from "../agent.js";
-import { escalate, resolveescalation } from "../swarm.js";
-import { escalateholdgate, fleetoperationgrade, replayexportgate, reviewrequestgate } from "../policy.js";
-import type { agentrecord, escalationrecord } from "../types.js";
-
-const now = 1_800_000_000_000;
-
-/** Builds one fleet record fixture with every value user chosen. */
-function record(over: Partial<agentrecord> = {}): agentrecord {
-  return {
-    id: "a1",
-    name: "scout",
-    role: "worker",
-    origin: "https://example.com",
-    state: "active",
-    registeredat: now,
-    lastseenat: now,
-    ...over,
-  };
-}
-
-describe("agentreview escalation blocking and review request routing", () => {
-  it("blocks the raising agent until the human answers and lifts the hold with the decision", () => {
-    const raised = escalate({
-      id: "e1",
-      agentid: "a1",
-      subject: "Which pricing table should the extraction target?",
-      context: "The page carries two tables and the plan covers one.",
-      now,
-    });
-    expect(raised.state).toBe("open");
-    const held = escalationblock({ escalations: [raised], agentid: "a1" });
-    expect(held.blocked).toBe(true);
-    expect(held.reason).toMatch(/only the human answer lifts the hold/i);
-    expect(escalateholdgate({ escalations: [raised], agentid: "a1" }).allowed).toBe(false);
-    expect(escalateholdgate({ escalations: [raised], agentid: "a2" }).allowed).toBe(true);
-    expect(escalationblock({ escalations: [raised], agentid: "a2" }).blocked).toBe(false);
-    const decided = resolveescalation({
-      escalation: raised,
-      decision: "Extract the second table; the first one repeats the header row.",
-      now: now + 1_000,
-    });
-    expect(decided.state).toBe("decided");
-    expect(escalateholdgate({ escalations: [decided], agentid: "a1" }).allowed).toBe(true);
-    expect(escalationblock({ escalations: [decided], agentid: "a1" }).blocked).toBe(false);
-  });
-
-  it("routes one review request between two agents of the shared origin and records the verdict beside the original output", () => {
-    const from = record();
-    const to = record({ id: "a2", name: "mapper", role: "critic" });
-    expect(reviewrequestgate({ from, to }).allowed).toBe(true);
-    expect(
-      reviewrequestgate({ from, to: record({ id: "a3", name: "outsider", origin: "https://other.example" }) }).allowed,
-    ).toBe(false);
-    const request = reviewrecordof({
-      id: "r1",
-      fromagentid: "a1",
-      toagentid: "a2",
-      subject: "the extracted pricing rows",
-      output: "rows: 12, columns: 4, currency: brl",
-      now,
-    });
-    expect(request.state).toBe("open");
-    expect(() =>
-      reviewrecordof({ id: "r2", fromagentid: "a1", toagentid: "a1", subject: "self", output: "own", now }),
-    ).toThrow(/never reviews its own/i);
-    expect(() => recordverdict({ records: [request], id: "r1", reviewerid: "a3", verdict: "approve", now })).toThrow(
-      /waits for the agent a2/i,
-    );
-    expect(() => recordverdict({ records: [request], id: "r1", reviewerid: "a2", verdict: "reject", now })).toThrow(
-      /names its issues/i,
-    );
-    const answered = recordverdict({
-      records: [request],
-      id: "r1",
-      reviewerid: "a2",
-      verdict: "changes",
-      issues: ["the currency column missed the second page"],
-      now: now + 1_000,
-    });
-    expect(answered.state).toBe("answered");
-    expect(answered.verdict).toBe("changes");
-    expect(answered.output).toBe("rows: 12, columns: 4, currency: brl");
-    expect(answered.issues).toEqual(["the currency column missed the second page"]);
-    expect(() => recordverdict({ records: [answered], id: "r1", reviewerid: "a2", verdict: "approve", now })).toThrow(
-      /never rewrites/i,
-    );
-  });
-});
-
-describe("agentreview runreplay capture and audit reconstruction", () => {
-  it("captures the ordered steps and results of an agent run", () => {
-    const capture = runreplay({
-      id: "p1",
-      agentid: "a1",
-      runid: "run1",
-      steps: [
-        { stepid: "s2", kind: "extract", summary: "read the pricing table", state: "done", at: now + 200 },
-        { stepid: "s1", kind: "observe", summary: "snapshot the page", state: "done", at: now + 100 },
-      ],
-      now: now + 300,
-    });
-    expect(capture.steps.map((step) => step.stepid)).toEqual(["s1", "s2"]);
-    expect(capture.reconstructed).toBeUndefined();
-    expect(() => runreplay({ id: "p2", agentid: "a1", runid: "run1", steps: [], now })).toThrow(
-      /at least one recorded step/i,
-    );
-  });
-
-  it("reconstructs a run from the audit trail when the run memory is gone and marks the reconstruction", () => {
-    const events = [
-      {
-        id: "ev1",
-        kind: "action",
-        summary: "The observe step s1 completed.",
-        at: now + 100,
-        agentid: "a1",
-        stepid: "s1",
-        planid: "run1",
-      },
-      {
-        id: "ev2",
-        kind: "error",
-        summary: "The extract step s2 failed.",
-        at: now + 200,
-        agentid: "a1",
-        stepid: "s2",
-        planid: "run1",
-      },
-      {
-        id: "ev3",
-        kind: "action",
-        summary: "The navigate step s3 of another agent completed.",
-        at: now + 300,
-        agentid: "a2",
-        stepid: "s3",
-        planid: "run2",
-      },
-    ];
-    const rebuilt = reconstructreplay({ id: "p3", agentid: "a1", runid: "run1", events, now: now + 400 });
-    expect(rebuilt.reconstructed).toBe(true);
-    expect(rebuilt.steps.map((step) => step.stepid)).toEqual(["s1", "s2"]);
-    expect(rebuilt.steps.find((step) => step.stepid === "s2")?.state).toBe("failed");
-    expect(() => reconstructreplay({ id: "p4", agentid: "a9", runid: "run9", events, now })).toThrow(
-      /carries no event/i,
-    );
-    expect(replayexportgate({ consent: false, agentid: "a1" }).allowed).toBe(false);
-    expect(replayexportgate({ consent: true, agentid: "a1" }).allowed).toBe(true);
-  });
-});
-
-describe("agentreview outputcompare alignment and consensusvote tallies", () => {
-  it("aligns two agent outputs field by field with matching, conflicting and missing fields", () => {
-    const comparison = outputcompare({
-      id: "c1",
-      subject: "the extracted totals",
-      left: { agentid: "a1", fields: { rows: "12", currency: "brl", totals: "4" } },
-      right: { agentid: "a2", fields: { rows: "12", currency: "usd" } },
-      now,
-    });
-    expect(comparison.matching).toEqual(["rows"]);
-    expect(comparison.conflicting).toEqual(["currency"]);
-    expect(comparison.missing).toEqual(["totals"]);
-    expect(() =>
-      outputcompare({
-        id: "c2",
-        subject: "self",
-        left: { agentid: "a1", fields: {} },
-        right: { agentid: "a1", fields: {} },
-        now,
-      }),
-    ).toThrow(/never competes with itself/i);
-    expect(fleetoperationgrade("outputcompare").allowed).toBe(true);
-    expect(fleetoperationgrade("consensusvote").allowed).toBe(true);
-    expect(fleetoperationgrade("navigate").allowed).toBe(false);
-  });
-
-  it("collects one vote per agent, computes the outcome by the quorum rule and keeps the dissent", () => {
-    const carried = consensusrecordof({
-      id: "v1",
-      proposal: "the fleet extracts the second pricing table",
-      votes: [
-        { agentid: "a1", vote: "yes", castat: now },
-        { agentid: "a2", vote: "yes", castat: now + 100 },
-        { agentid: "a3", vote: "no", reason: "the first table carries the live prices", castat: now + 200 },
-      ],
-      quorum: 2,
-      voters: 3,
-      now: now + 300,
-    });
-    expect(carried.tally).toEqual({ yes: 2, no: 1, abstain: 0 });
-    expect(carried.outcome).toBe("carried");
-    expect(carried.votes.find((vote) => vote.agentid === "a3")?.reason).toBe("the first table carries the live prices");
-    expect(() =>
-      consensusrecordof({
-        id: "v2",
-        proposal: "duplicate vote",
-        votes: [
-          { agentid: "a1", vote: "yes", castat: now },
-          { agentid: "a1", vote: "no", castat: now + 100 },
-        ],
-        quorum: 1,
-        now,
-      }),
-    ).toThrow(/already voted/i);
-    const failed = consensusrecordof({
-      id: "v3",
-      proposal: "the fleet opens a second tab",
-      votes: [
-        { agentid: "a1", vote: "no", castat: now },
-        { agentid: "a2", vote: "abstain", castat: now + 100 },
-      ],
-      quorum: 2,
-      voters: 2,
-      now: now + 200,
-    });
-    expect(failed.outcome).toBe("failed");
-    const open = consensusrecordof({
-      id: "v4",
-      proposal: "the fleet opens a second tab",
-      votes: [{ agentid: "a1", vote: "yes", castat: now }],
-      quorum: 2,
-      voters: 3,
-      now: now + 100,
-    });
-    expect(open.outcome).toBe("open");
-    expect(open.closedat).toBeUndefined();
-    expect(() => consensusrecordof({ id: "v5", proposal: "no quorum", votes: [], quorum: 0, now })).toThrow(
-      /positive whole number/i,
-    );
-  });
-});