@wenathlan/extension 1.1.58 → 1.1.59

package/extension/dist/background.js

@@ -1824,6 +1824,8 @@ function watchdogpass(input) {
 function roledefaults(role) {
   if (role === "planner") return { toolnamespaces: ["workflow", "memory", "system"], description: "Planners compose reviewed plans and read memory; they never act on the page themselves." };
   if (role === "observer") return { toolnamespaces: ["memory", "system"], description: "Observers read the shared memory and the system reports only." };
+  if (role === "critic") return { toolnamespaces: ["workflow", "memory", "system"], description: "Critics review the outputs of the other agents read only; they never act on the page themselves." };
+  if (role === "verifier") return { toolnamespaces: ["browser", "memory", "system"], description: "Verifiers re-read the page to check the claims of the other agents; their checks stay read side." };
   return { toolnamespaces: ["browser", "workflow", "memory", "system"], description: role === "worker" ? "Workers execute the reviewed steps of approved plans." : `The custom role ${role} carries the worker defaults until the user narrows its scope.` };
 }
 function registeragent(input) {
@@ -4133,6 +4135,129 @@ var sessionmemory = class {
     const mailboxes = await this.getmailboxes();
     return swarmoverview({ agents, queue: queue ?? { lanes: [], priorities: [], completionpolicy: "all", items: [], claims: [] }, mailboxes });
   }
+  /** Returns the leader worker topology of the 1.1.59 swarm with its leader, worker, critic and verifier lanes and its worker assignments. */
+  async gettopology() {
+    return this.adapter.get("swarmtopology");
+  }
+  /** Replaces the stored leader worker topology after one election, assignment, collection or scaling change. */
+  async settopology(topology) {
+    return this.adapter.set("swarmtopology", topology);
+  }
+  /** Returns the stored planner executor splits of the 1.1.59 swarm with their step reports. */
+  async getplannersplits() {
+    return await this.adapter.get("swarmsplits") ?? [];
+  }
+  /** Replaces the stored planner executor splits after one split or one executor step report. */
+  async setplannersplits(splits) {
+    return this.adapter.set("swarmsplits", splits);
+  }
+  /** Records one critic review of an agent output, newest first. */
+  async addcriticreview(review) {
+    await this.adapter.set("swarmreviews", [review, ...await this.adapter.get("swarmreviews") ?? []]);
+  }
+  /** Returns the recorded critic reviews, newest first. */
+  async getcriticreviews() {
+    return await this.adapter.get("swarmreviews") ?? [];
+  }
+  /** Records one verifier check of a result claim, newest first. */
+  async addverifiercheck(check) {
+    await this.adapter.set("swarmverifierchecks", [check, ...await this.adapter.get("swarmverifierchecks") ?? []]);
+  }
+  /** Returns the recorded verifier checks with their pass and fail outcomes, newest first. */
+  async getverifierchecks() {
+    return await this.adapter.get("swarmverifierchecks") ?? [];
+  }
+  /** Replaces the stored review requests routed between agents after one request, ack, answer or timeout. */
+  async setreviewrequests(requests) {
+    return this.adapter.set("swarmreviewrequests", requests);
+  }
+  /** Returns the stored review requests routed between agents. */
+  async getreviewrequests() {
+    return await this.adapter.get("swarmreviewrequests") ?? [];
+  }
+  /** Records one tab handoff with its packaged task state and its resumed state. */
+  async addhandoff(record2) {
+    await this.adapter.set("swarmhandoffs", [record2, ...await this.adapter.get("swarmhandoffs") ?? []].filter((entry, index, all) => all.findIndex((candidate) => candidate.id === entry.id) === index));
+  }
+  /** Replaces one stored handoff record after its transfer or resume. */
+  async updatehandoff(record2) {
+    await this.adapter.set("swarmhandoffs", (await this.adapter.get("swarmhandoffs") ?? []).map((entry) => entry.id === record2.id ? record2 : entry));
+  }
+  /** Returns the handoff log of tab transfers between agents, newest first. */
+  async gethandoffs() {
+    return await this.adapter.get("swarmhandoffs") ?? [];
+  }
+  /** Replaces the stored resource locks after one acquire, release or expiry sweep. */
+  async setlocks(locks) {
+    return this.adapter.set("swarmlocks", locks);
+  }
+  /** Returns the held resource locks with their holders and expiries. */
+  async getlocks() {
+    return await this.adapter.get("swarmlocks") ?? [];
+  }
+  /** Records one conflict scan report of overlapping writes, newest first. */
+  async addconflictscan(scan) {
+    await this.adapter.set("swarmconflicts", [scan, ...await this.adapter.get("swarmconflicts") ?? []]);
+  }
+  /** Returns the recorded conflict scan reports, newest first. */
+  async getconflictscans() {
+    return await this.adapter.get("swarmconflicts") ?? [];
+  }
+  /** Stores the merged result report with its mergeentry provenance. */
+  async setreport(report) {
+    return this.adapter.set("swarmreport", report);
+  }
+  /** Returns the stored merged result report across agents. */
+  async getreport() {
+    return this.adapter.get("swarmreport");
+  }
+  /** Records one progressboard snapshot under the user configured retention window; an absent window keeps every snapshot. */
+  async addboardsnapshot(board) {
+    const retention = (await this.getsettings())?.boardretention;
+    await this.adapter.set("swarmboards", [board, ...await this.adapter.get("swarmboards") ?? []].slice(0, retention ?? 100));
+  }
+  /** Returns the stored progressboard snapshots, newest first. */
+  async getboardsnapshots() {
+    return await this.adapter.get("swarmboards") ?? [];
+  }
+  /** Records one escalation lifted to the user, newest first. */
+  async addescalation(escalation) {
+    await this.adapter.set("swarmescalations", [escalation, ...await this.adapter.get("swarmescalations") ?? []]);
+  }
+  /** Replaces one stored escalation after its user decision. */
+  async updateescalation(escalation) {
+    await this.adapter.set("swarmescalations", (await this.adapter.get("swarmescalations") ?? []).map((entry) => entry.id === escalation.id ? escalation : entry));
+  }
+  /** Returns the escalations awaiting the user and the decided ones, newest first. */
+  async getescalations() {
+    return await this.adapter.get("swarmescalations") ?? [];
+  }
+  /** Records one consensus round or replaces the stored one after a vote. */
+  async setconsensusround(round) {
+    const rounds = await this.adapter.get("swarmconsensus") ?? [];
+    await this.adapter.set("swarmconsensus", rounds.some((entry) => entry.id === round.id) ? rounds.map((entry) => entry.id === round.id ? round : entry) : [round, ...rounds]);
+  }
+  /** Returns the consensus rounds with their votes and quorum states, newest first. */
+  async getconsensusrounds() {
+    return await this.adapter.get("swarmconsensus") ?? [];
+  }
+  /** Appends one action to the interleaved timeline of swarm actions, oldest first under a window of 500. */
+  async addswarmaction(action) {
+    await this.adapter.set("swarmtimeline", [...await this.adapter.get("swarmtimeline") ?? [], action].slice(-500));
+  }
+  /** Returns the interleaved timeline of swarm actions with the optional agent and kind filters, oldest first. */
+  async getswarmtimeline(filters) {
+    const actions = await this.adapter.get("swarmtimeline") ?? [];
+    return actions.filter((action) => filters?.agentid === void 0 || action.agentid === filters.agentid).filter((action) => filters?.kind === void 0 || action.kind === filters.kind).filter((action) => filters?.since === void 0 || action.at >= filters.since);
+  }
+  /** Stores one shared cost accounting snapshot of the swarm, newest first. */
+  async addswarmcost(cost) {
+    await this.adapter.set("swarmcosts", [cost, ...await this.adapter.get("swarmcosts") ?? []].slice(0, 100));
+  }
+  /** Returns the stored shared cost accounting snapshots of the swarm, newest first. */
+  async getswarmcosts() {
+    return await this.adapter.get("swarmcosts") ?? [];
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -8940,6 +9065,68 @@ function blackboardconsentgrade(entry) {
   if (entry.consentclass === "sensitive") return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the sensitive class of its source extraction; every agent reads the class beside the value.` };
   return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the ${entry.consentclass} class of its source extraction; every agent reads the class beside the value.` };
 }
+function leaderelectionvalid(input) {
+  if (input.rule.kind !== "first" && input.rule.kind !== "named") return { allowed: false, reason: "The leader election rule stays first or named as the user configured it." };
+  if (input.rule.kind === "named") {
+    if (input.rule.agentid === void 0 || input.rule.agentid.trim() === "") return { allowed: false, reason: "The named leader election rule needs the agent id the user named." };
+    if (!input.agents.some((agent) => agent.id === input.rule.agentid && agent.state !== "stopped")) return { allowed: false, reason: `The named leader election rule names the agent ${input.rule.agentid} which is not a live agent of the swarm.` };
+  }
+  return { allowed: true, reason: input.rule.kind === "first" ? "The first registration rule elects the leader exactly as the user configured." : `The named rule elects the agent ${input.rule.agentid} exactly as the user configured.` };
+}
+function criticreviewgrade(review) {
+  if (review.reviewerid.trim() === "") return { allowed: false, reason: "The critic review needs its reviewing agent." };
+  if (review.subjectagentid.trim() === "") return { allowed: false, reason: "The critic review needs the subject agent whose output it reviews." };
+  if (review.verdict !== "approve" && review.verdict !== "changes" && review.verdict !== "reject") return { allowed: false, reason: "The critic review carries one of the three verdicts approve, changes or reject." };
+  if (review.verdict === "changes" && review.requiredchanges.length === 0) return { allowed: false, reason: "A changes verdict needs its required changes in plain language." };
+  if (review.verdict === "reject" && review.issues.length === 0) return { allowed: false, reason: "A reject verdict needs the issues the critic found." };
+  return { allowed: true, reason: `The critic review of the output of ${review.subjectagentid} stays read only: the critic ${review.reviewerid} returns its ${review.verdict} verdict and never acts on the page; the rework still passes the same human review.` };
+}
+function verifiermethodgrade(input) {
+  if (input.method.trim() === "") return { allowed: false, reason: "The verifier check needs the method it used." };
+  if (input.allowed.length > 0 && !input.allowed.includes(input.method)) return { allowed: false, reason: `The verifier method ${input.method} is not one of the methods the user allowed: ${input.allowed.join(", ")}.` };
+  return { allowed: true, reason: input.allowed.length === 0 ? `The verifier method ${input.method} runs under the documented open method list the user chose not to narrow.` : `The verifier method ${input.method} sits inside the methods the user allowed.` };
+}
+function handoffgrantgate(input) {
+  if (input.record.toagentid.trim() === "" || input.record.fromagentid.trim() === "") return { allowed: false, reason: "The handoff names its transferring and receiving agents." };
+  if (input.toscope === void 0) return { allowed: true, reason: `The receiving agent ${input.record.toagentid} carries no narrowed scope, so the handoff stays unbounded inside the original session grants.` };
+  const outside = input.toscope.origins.filter((origin) => input.sessiongrants.length > 0 && !input.sessiongrants.includes(origin));
+  if (outside.length > 0) return { allowed: false, reason: `The handoff to ${input.record.toagentid} would need the origins ${outside.join(", ")} which the session grant list does not carry; a tab transfer never widens the session grants.` };
+  return { allowed: true, reason: `The handoff from ${input.record.fromagentid} to ${input.record.toagentid} preserves the original session grants; the receiving scope stays inside them.` };
+}
+function lockscopevalid(lock) {
+  if (lock.key.trim() === "") return { allowed: false, reason: "The resource lock needs its key." };
+  if (lock.origin.trim() === "" || lock.selector.trim() === "") return { allowed: false, reason: "The resource lock names exactly one origin and one selector; a lock never spans unrelated origins." };
+  if (lock.key !== `${lock.origin}|${lock.selector}`) return { allowed: false, reason: "The lock key must compose of its one origin and its one selector so the scope never spans unrelated origins." };
+  if (lock.kind !== "exclusive" && lock.kind !== "shared") return { allowed: false, reason: "The lock kind stays exclusive or shared." };
+  return { allowed: true, reason: `The lock ${lock.key} spans exactly one target of one origin for the holder ${lock.holder}.` };
+}
+function conflictresolutiongrade(rule) {
+  if (rule !== "first" && rule !== "last" && rule !== "preferagent" && rule !== "fail") return { allowed: false, reason: "The conflict resolution rule stays first, last, preferagent or fail as the user configured it." };
+  if (rule === "last" || rule === "preferagent") return { allowed: true, reason: `The ${rule} conflict resolution rule overwrites one parallel value with another, so it grades sensitive and the merged report still passes the human review.` };
+  return { allowed: true, reason: `The ${rule} conflict resolution rule keeps or refuses the parallel values without overwriting, so it grades read side.` };
+}
+function escalationgate(escalation) {
+  if (escalation.agentid.trim() === "") return { allowed: false, reason: "The escalation names the agent whose decision it lifts." };
+  if (escalation.subject.trim() === "") return { allowed: false, reason: "The escalation needs its subject." };
+  if (escalation.context.trim() === "") return { allowed: false, reason: "The escalation needs its full context in plain language; the user decides on what the agent saw." };
+  if (escalation.state === "decided" && (escalation.decision === void 0 || escalation.decision.trim() === "")) return { allowed: false, reason: "A decided escalation carries the decision the user wrote." };
+  return { allowed: true, reason: `The escalation of ${escalation.agentid} stays human decided: the agent lifts the stalled decision with its full context and the user alone writes the outcome.` };
+}
+function consensusquorumvalid(input) {
+  if (!Number.isInteger(input.quorum) || input.quorum < 1) return { allowed: false, reason: "The consensus quorum stays a positive whole number the user configured." };
+  if (input.quorum > input.voters) return { allowed: false, reason: `The consensus quorum ${input.quorum} exceeds the ${input.voters} voting agents the user counted; an unreachable quorum never carries.` };
+  return { allowed: true, reason: `The consensus quorum ${input.quorum} of ${input.voters} voting agents stays the user configured value with no engine default.` };
+}
+function workerscalevalid(bound) {
+  if (bound === void 0) return { allowed: true, reason: "No worker bound is configured, so the worker scale stays the user choice alone with no engine cap." };
+  if (!Number.isFinite(bound) || bound < 1) return { allowed: false, reason: "The worker scale bound stays a positive user value; no engine cap exists." };
+  return { allowed: true, reason: `The worker scale bound ${bound} stays the user configured value; the scaling never passes it and no engine cap exists.` };
+}
+function mergeegressgrade(input) {
+  if (input.report.title.trim() === "") return { allowed: false, reason: "The merged report needs its title before any export." };
+  if (input.carriespagecontent) return { allowed: true, reason: `The export of the report ${input.report.title} carries page content from the sources ${input.report.sources.join(", ")} and grades as a data egress event in the audit trail.` };
+  return { allowed: true, reason: `The export of the report ${input.report.title} carries no page content and stays a plain report export.` };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -9119,7 +9306,7 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
 }
 
 // version.ts
-var packageversion = "1.1.58";
+var packageversion = "1.1.59";
 
 // types.ts
 var protocolversion = packageversion;
@@ -11517,6 +11704,376 @@ function budgetcheck(input) {
   return { allowed: true, halted: false, asksuser: false };
 }
 
+// orchestration.ts
+function electleader(input) {
+  const live = input.agents.filter((agent) => agent.state !== "stopped");
+  if (live.length === 0) throw new Error("The swarm holds no live agent; the leader election waits for the user to register one.");
+  const rule = input.rule ?? { kind: "first" };
+  let leader;
+  if (rule.kind === "named") {
+    if (rule.agentid === void 0 || rule.agentid.trim() === "") throw new Error("The named election rule needs the agent id the user named.");
+    leader = live.find((agent) => agent.id === rule.agentid);
+    if (!leader) throw new Error(`The named election rule names the agent ${rule.agentid} which is not a live agent of the swarm.`);
+  } else {
+    leader = live[live.length - 1];
+  }
+  if (!leader) throw new Error("The leader election found no live agent.");
+  const leaderid = leader.id;
+  const workers = live.filter((agent) => agent.id !== leaderid && agent.role === "worker");
+  const critics = live.filter((agent) => agent.id !== leaderid && agent.role === "critic");
+  const verifiers = live.filter((agent) => agent.id !== leaderid && agent.role === "verifier");
+  return {
+    id: input.id,
+    leaderid: leader.id,
+    workerids: workers.map((agent) => agent.id),
+    criticids: critics.map((agent) => agent.id),
+    verifierids: verifiers.map((agent) => agent.id),
+    assignments: [],
+    rule: { kind: rule.kind, ...rule.agentid !== void 0 ? { agentid: rule.agentid } : {} },
+    electedat: input.now
+  };
+}
+function assignwork(input) {
+  if (input.topology.workerids.length === 0) throw new Error("The topology holds no worker; the user adds workers before the assignment.");
+  const assignments = [];
+  const tasks = input.tasks.filter((task) => task.state === "queued" || task.state === "claimed");
+  tasks.forEach((task, index) => {
+    const workerid = input.topology.workerids[index % input.topology.workerids.length];
+    assignments.push({ workerid, taskid: task.id, slice: `${task.payload} (slice ${Math.floor(index / input.topology.workerids.length) + 1} of lane ${task.lane})`, assignedat: input.now });
+  });
+  return { ...input.topology, assignments };
+}
+function collectresults(input) {
+  const gathered = input.topology.assignments.map((assignment) => {
+    const output = input.outputs.find((entry) => entry.taskid === assignment.taskid && entry.workerid === assignment.workerid);
+    return output ?? { workerid: assignment.workerid, taskid: assignment.taskid, state: "pending", summary: `The worker ${assignment.workerid} has not returned its slice of the task ${assignment.taskid} yet.` };
+  });
+  return { gathered, missing: gathered.filter((entry) => entry.state === "pending").map((entry) => `${entry.workerid}:${entry.taskid}`) };
+}
+function scaleworkers(input) {
+  const live = input.agents.filter((agent) => agent.state === "active" && agent.role === "worker" && agent.id !== input.topology.leaderid);
+  const current = input.topology.workerids.filter((workerid) => live.some((agent) => agent.id === workerid));
+  const ceiling = input.bound;
+  if (input.pending > current.length) {
+    const available = live.filter((agent) => !current.includes(agent.id)).map((agent) => agent.id);
+    const wanted = input.pending - current.length;
+    const addable = ceiling === void 0 ? available.slice(0, wanted) : available.slice(0, Math.min(wanted, Math.max(ceiling - current.length, 0)));
+    if (addable.length === 0) return { topology: input.topology, added: [], retired: [], reason: ceiling === void 0 ? `The load of ${input.pending} pending slices exceeds the ${current.length} workers but the swarm holds no further live worker role agent to add.` : `The load of ${input.pending} pending slices exceeds the ${current.length} workers but the user configured bound of ${ceiling} workers holds.` };
+    return { topology: { ...input.topology, workerids: [...current, ...addable], electedat: input.topology.electedat, assignments: input.topology.assignments }, added: addable, retired: [], reason: `The load of ${input.pending} pending slices added the workers ${addable.join(", ")}; ${ceiling === void 0 ? "no bound is configured so the user scale stands alone" : `the user configured bound of ${ceiling} workers holds`}.` };
+  }
+  const keep = Math.max(input.pending, 0);
+  if (current.length > keep) {
+    const retired = current.slice(keep);
+    return { topology: { ...input.topology, workerids: current.slice(0, keep), electedat: input.topology.electedat, assignments: input.topology.assignments.filter((assignment) => !retired.includes(assignment.workerid)) }, added: [], retired, reason: `The load of ${input.pending} pending slices retired the idle workers ${retired.join(", ")}.` };
+  }
+  return { topology: input.topology, added: [], retired: [], reason: `The load of ${input.pending} pending slices matches the ${current.length} workers; the scale stays unchanged.` };
+}
+function plannersplit(input) {
+  if (input.planownerid.trim() === "" || input.runownerid.trim() === "") throw new Error("The planner executor split needs its plan owner and run owner agent ids.");
+  if (input.planownerid === input.runownerid) throw new Error("The planner executor split keeps plan drafting and execution in different agents; one agent holds both sides never.");
+  return { id: input.id, planownerid: input.planownerid, runownerid: input.runownerid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, stepreports: [], splitat: input.now };
+}
+function reportstep(input) {
+  if (input.stepid.trim() === "") throw new Error("The executor report needs its step id.");
+  if (input.detail.trim() === "") throw new Error("The executor report needs its detail in plain language.");
+  const report = { stepid: input.stepid.trim(), outcome: input.outcome, detail: input.detail, reportedat: input.now };
+  return { ...input.split, stepreports: [...input.split.stepreports.filter((entry) => entry.stepid !== report.stepid), report] };
+}
+function requestreview(input) {
+  if (input.subject.trim() === "") throw new Error("The review request needs its subject.");
+  if (input.payload.trim() === "") throw new Error("The review request needs its payload.");
+  if (input.toagentid.trim() === "" || input.toagentid === input.fromagentid) throw new Error("The review request names another reviewing agent, never its own requester.");
+  const request = { id: input.id, fromagentid: input.fromagentid, toagentid: input.toagentid, subject: input.subject, payload: input.payload, state: "open", requestedat: input.now, ...input.timeoutms !== void 0 ? { timeoutat: input.now + input.timeoutms } : {} };
+  return [request, ...input.requests];
+}
+function ackreview(input) {
+  const request = input.requests.find((entry) => entry.id === input.id);
+  if (!request) throw new Error(`The review request ${input.id} does not exist.`);
+  if (request.state !== "open") throw new Error(`The review request ${input.id} is ${request.state}; only an open request receives its ack.`);
+  return input.requests.map((entry) => entry.id === input.id ? { ...entry, state: "acked", ackedat: input.now } : entry);
+}
+function applyreview(input) {
+  const request = input.requests.find((entry) => entry.id === input.id);
+  if (!request) throw new Error(`The review request ${input.id} does not exist.`);
+  if (request.state === "answered" || request.state === "timeout") throw new Error(`The review request ${input.id} is ${request.state}; an answered or timed out request never reviews again.`);
+  if (request.toagentid !== input.reviewerid) throw new Error(`The review request ${input.id} routes to the agent ${request.toagentid}; the agent ${input.reviewerid} never answers in its place.`);
+  if (input.verdict === "changes" && input.requiredchanges.length === 0) throw new Error("A changes verdict needs its required changes in plain language.");
+  const review = { id: request.id, reviewerid: input.reviewerid, subjectagentid: request.fromagentid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, verdict: input.verdict, issues: input.issues, requiredchanges: input.requiredchanges, reviewedat: input.now };
+  return { review, requests: input.requests.map((entry) => entry.id === input.id ? { ...entry, state: "answered", answeredat: input.now } : entry) };
+}
+function sweepreviews(input) {
+  const expired = input.requests.filter((request) => request.state === "open" || request.state === "acked").filter((request) => request.timeoutat !== void 0 && input.now > request.timeoutat);
+  if (expired.length === 0) return { requests: input.requests, timedout: [] };
+  const ids = new Set(expired.map((request) => request.id));
+  return { requests: input.requests.map((request) => ids.has(request.id) ? { ...request, state: "timeout" } : request), timedout: [...ids] };
+}
+function checkclaim(input) {
+  if (input.claim.trim() === "") throw new Error("The verifier check needs its claim in plain language.");
+  if (input.method.trim() === "") throw new Error("The verifier check needs the method the user configured.");
+  if (input.claimagentid.trim() === "") throw new Error("The verifier check names the agent whose claim it checks.");
+  return { id: input.id, verifierid: input.verifierid, claimagentid: input.claimagentid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, claim: input.claim, method: input.method, outcome: input.outcome, ...input.evidence !== void 0 && input.evidence.trim() !== "" ? { evidence: input.evidence } : {}, checkedat: input.now };
+}
+function boardstate(input) {
+  const lanes = input.agents.filter((agent) => agent.state !== "stopped").map((agent) => {
+    const assignment = input.topology?.assignments.find((entry) => entry.workerid === agent.id);
+    const claim2 = input.queue.claims.find((record2) => record2.agentid === agent.id && input.queue.items.some((item) => item.id === record2.taskid && item.state === "claimed"));
+    const task = claim2 !== void 0 ? input.queue.items.find((item) => item.id === claim2.taskid) : void 0;
+    const lane = task?.lane ?? (agent.role === "critic" || agent.role === "verifier" ? agent.role : agent.role === "planner" ? "planning" : "idle");
+    return { agentid: agent.id, name: agent.name, role: agent.role, state: agent.state, lane, ...task !== void 0 ? { currenttask: task.payload } : assignment !== void 0 ? { currenttask: assignment.slice } : {}, milestones: input.milestones?.[agent.id] ?? [] };
+  });
+  return { id: `board:${input.now}`, lanes, builtat: input.now };
+}
+function escalate(input) {
+  if (input.subject.trim() === "") throw new Error("The escalation needs its subject.");
+  if (input.context.trim() === "") throw new Error("The escalation needs its full context in plain language; the user decides on what the agent saw.");
+  if (input.agentid.trim() === "") throw new Error("The escalation names the agent whose decision it lifts.");
+  return { id: input.id, agentid: input.agentid, subject: input.subject, context: input.context, state: "open", raisedat: input.now };
+}
+function resolveescalation(input) {
+  if (input.escalation.state === "decided") throw new Error("The escalation already carries its user decision.");
+  if (input.decision.trim() === "") throw new Error("The escalation decision needs the words the user wrote.");
+  return { ...input.escalation, state: "decided", decision: input.decision, decidedat: input.now };
+}
+function arbitrate(input) {
+  if (input.claims.length === 0) return [];
+  if (input.rule.strategy === "priority") {
+    const order = input.rule.priorityorder;
+    return [...input.claims].sort((one, two) => {
+      const oneindex = order.indexOf(one.agentid);
+      const twoindex = order.indexOf(two.agentid);
+      return (oneindex === -1 ? order.length : oneindex) - (twoindex === -1 ? order.length : twoindex) || one.claimedat - two.claimedat;
+    }).map((claim2) => claim2.agentid);
+  }
+  if (input.rule.strategy === "age") return [...input.claims].sort((one, two) => one.claimedat - two.claimedat || (one.agentid < two.agentid ? -1 : 1)).map((claim2) => claim2.agentid);
+  if (input.leaderid === void 0) throw new Error("The leader arbitration strategy needs the elected leader of the topology.");
+  return [...input.claims].sort((one, two) => (one.agentid === input.leaderid ? -1 : 1) - (two.agentid === input.leaderid ? -1 : 1) || one.claimedat - two.claimedat).map((claim2) => claim2.agentid);
+}
+function openconsensus(input) {
+  if (input.subject.trim() === "") throw new Error("The consensus round needs its subject in plain language.");
+  if (!Number.isInteger(input.quorum) || input.quorum < 1) throw new Error("The consensus round needs its quorum as a positive whole number the user configured.");
+  return { id: input.id, subject: input.subject, votes: [], quorum: input.quorum, state: "open", openedat: input.now };
+}
+function castvote(input) {
+  if (input.round.state !== "open") throw new Error(`The consensus round ${input.round.id} is ${input.round.state}; a closed round collects no vote.`);
+  if (input.round.votes.some((entry) => entry.agentid === input.agentid)) throw new Error(`The agent ${input.agentid} already voted in the round ${input.round.id}.`);
+  const votes = [...input.round.votes, { agentid: input.agentid, vote: input.vote, votedat: input.now }];
+  const yes = votes.filter((entry) => entry.vote === "yes").length;
+  const no = votes.filter((entry) => entry.vote === "no").length;
+  if (yes >= input.round.quorum) return { ...input.round, votes, state: "carried", closedat: input.now };
+  if (no >= input.round.quorum) return { ...input.round, votes, state: "failed", closedat: input.now };
+  return { ...input.round, votes };
+}
+function consensusstate(round) {
+  return {
+    yes: round.votes.filter((entry) => entry.vote === "yes").length,
+    no: round.votes.filter((entry) => entry.vote === "no").length,
+    abstain: round.votes.filter((entry) => entry.vote === "abstain").length,
+    quorum: round.quorum,
+    state: round.state
+  };
+}
+
+// blackboard.ts
+var blackboardsections = ["goals", "facts", "findings", "scratch"];
+function emptyboard(sections) {
+  return { sections: sections ?? blackboardsections, entries: [] };
+}
+function postentry(input) {
+  if (input.key.trim() === "") throw new Error("The blackboard entry needs its key.");
+  if (input.value.trim() === "") throw new Error("The blackboard entry needs its value.");
+  if (input.author.trim() === "") throw new Error("The blackboard entry needs its author.");
+  if (!blackboardsections.includes(input.section)) throw new Error(`The section ${input.section} is not one of the shared blackboard sections.`);
+  if (input.board.entries.some((entry2) => entry2.id === input.id)) throw new Error(`The blackboard entry id ${input.id} already exists.`);
+  if (input.valuekind === "json") {
+    try {
+      JSON.parse(input.value);
+    } catch {
+      throw new Error("The json blackboard entry needs a well-formed json value.");
+    }
+  }
+  const entry = { id: input.id, key: input.key.trim(), valuekind: input.valuekind ?? "text", value: input.value, author: input.author, section: input.section, consentclass: input.consentclass ?? "read", postedat: input.now };
+  return { ...input.board, sections: input.board.sections.includes(input.section) ? input.board.sections : [...input.board.sections, input.section], entries: [entry, ...input.board.entries] };
+}
+function entryfresh(entry, now, window2) {
+  if (entry.retiredat !== void 0) return false;
+  if (window2 === void 0) return true;
+  return now - entry.postedat <= window2;
+}
+function readentries(input) {
+  return input.board.entries.filter((entry) => entry.retiredat === void 0).filter((entry) => input.section === void 0 || entry.section === input.section).filter((entry) => entryfresh(entry, input.now, input.freshness)).sort((one, two) => two.postedat - one.postedat);
+}
+function retireentries(input) {
+  if (input.board.retirementwindow === void 0) return { board: input.board, retired: [] };
+  const stale = input.board.entries.filter((entry) => entry.retiredat === void 0 && input.now - entry.postedat > input.board.retirementwindow);
+  if (stale.length === 0) return { board: input.board, retired: [] };
+  const staleids = new Set(stale.map((entry) => entry.id));
+  return {
+    board: { ...input.board, entries: input.board.entries.map((entry) => staleids.has(entry.id) ? { ...entry, retiredat: input.now } : entry) },
+    retired: [...staleids]
+  };
+}
+function retireentry(input) {
+  const entry = input.board.entries.find((candidate) => candidate.id === input.entryid);
+  if (!entry) throw new Error(`The blackboard entry ${input.entryid} does not exist.`);
+  if (entry.retiredat !== void 0) throw new Error(`The blackboard entry ${entry.key} is already retired.`);
+  return { ...input.board, entries: input.board.entries.map((candidate) => candidate.id === input.entryid ? { ...candidate, retiredat: input.now } : candidate) };
+}
+function boardsummary(board, now) {
+  return board.sections.map((section) => {
+    const live = board.entries.filter((entry) => entry.section === section && entry.retiredat === void 0);
+    return { section, entries: live.length, authors: [...new Set(live.map((entry) => entry.author))], ...live.length > 0 ? { freshestat: Math.max(...live.map((entry) => entry.postedat)) } : {} };
+  });
+}
+
+// coordination.ts
+function lockkey(origin, selector) {
+  return `${origin}|${selector}`;
+}
+function preparehandoff(input) {
+  if (!input.agents.some((agent) => agent.id === input.fromagentid)) throw new Error(`The handoff names the transferring agent ${input.fromagentid} which is not registered.`);
+  if (!input.agents.some((agent) => agent.id === input.toagentid)) throw new Error(`The handoff names the receiving agent ${input.toagentid} which is not registered.`);
+  if (input.fromagentid === input.toagentid) throw new Error("A handoff moves a task between two different agents; an agent never hands off to itself.");
+  if (input.taskstate.trim() === "") throw new Error("The handoff needs its packaged task state in plain language; the resume continues exactly from it.");
+  const from = input.agents.find((agent) => agent.id === input.fromagentid);
+  const tabid2 = input.tabid ?? from.tabid;
+  if (tabid2 === void 0) throw new Error("The handoff needs its tab id; the transferring agent holds no tab to hand off.");
+  return { id: input.id, fromagentid: input.fromagentid, toagentid: input.toagentid, tabid: tabid2, taskstate: input.taskstate, state: "prepared", ...input.reason !== void 0 && input.reason.trim() !== "" ? { reason: input.reason } : {}, createdat: input.now };
+}
+function transferhandoff(input) {
+  const record2 = input.handoffs.find((entry) => entry.id === input.id);
+  if (!record2) throw new Error(`The handoff ${input.id} does not exist.`);
+  if (record2.state !== "prepared") throw new Error(`The handoff ${record2.id} is ${record2.state}; only a prepared handoff transfers.`);
+  const receiver = input.agents.find((agent) => agent.id === record2.toagentid);
+  if (!receiver) throw new Error(`The receiving agent ${record2.toagentid} is not registered.`);
+  if (receiver.state === "stopped") throw new Error(`The receiving agent ${receiver.name} is stopped; the handoff waits for its resume or another receiver.`);
+  const holder = input.agents.find((agent) => agent.tabid === record2.tabid && agent.id !== record2.fromagentid && agent.state !== "stopped");
+  if (holder) throw new Error(`Tab ${record2.tabid} already holds the agent ${holder.name}; one tab binds one agent.`);
+  const agents = input.agents.map((agent) => {
+    if (agent.id === record2.fromagentid) {
+      const { tabid: tabid2, ...rest } = agent;
+      void tabid2;
+      return rest;
+    }
+    if (agent.id === record2.toagentid && record2.tabid !== void 0) return { ...agent, tabid: record2.tabid };
+    return agent;
+  });
+  return { agents, handoffs: input.handoffs.map((entry) => entry.id === input.id ? { ...entry, state: "transferred", transferredat: input.now } : entry) };
+}
+function resumehandoff(input) {
+  const record2 = input.handoffs.find((entry) => entry.id === input.id);
+  if (!record2) throw new Error(`The handoff ${input.id} does not exist.`);
+  if (record2.state !== "transferred") throw new Error(`The handoff ${record2.id} is ${record2.state}; only a transferred handoff resumes.`);
+  return { ...record2, state: "resumed", resumedat: input.now };
+}
+function acquirelock(input) {
+  if (input.holder.trim() === "") throw new Error("The lock needs its holder agent id.");
+  if (input.origin.trim() === "") throw new Error("The lock needs its origin; a lock never spans unrelated origins.");
+  if (input.selector.trim() === "") throw new Error("The lock needs its selector of the origin.");
+  const kind = input.kind ?? "exclusive";
+  const key = lockkey(input.origin.trim(), input.selector.trim());
+  const held = input.locks.filter((lock2) => lock2.key === key);
+  if (held.some((lock2) => lock2.holder === input.holder)) return { locks: input.locks, acquired: false, reason: `The agent ${input.holder} already holds the lock ${key}.` };
+  if (held.length > 0) {
+    if (held.some((lock2) => lock2.kind === "exclusive") || kind === "exclusive") return { locks: input.locks, acquired: false, reason: `The lock ${key} is held ${held.some((lock2) => lock2.kind === "exclusive") ? "exclusively" : "shared"}; the ${kind} request of ${input.holder} refuses.` };
+  }
+  const lock = { key, holder: input.holder, kind, origin: input.origin.trim(), selector: input.selector.trim(), acquiredat: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+  return { locks: [...input.locks, lock], acquired: true, reason: `The ${kind} lock ${key} went to the agent ${input.holder}.` };
+}
+function releaselock(input) {
+  const lock = input.locks.find((entry) => entry.key === input.key && entry.holder === input.holder);
+  if (!lock) return { locks: input.locks, released: false };
+  return { locks: input.locks.filter((entry) => entry.key !== input.key || entry.holder !== input.holder), released: true };
+}
+function expirelocks(input) {
+  const stale = input.locks.filter((lock) => lock.expiresat !== void 0 && input.now > lock.expiresat);
+  if (stale.length === 0) return { locks: input.locks, expired: [] };
+  const keys = new Set(stale.map((lock) => `${lock.key}:${lock.holder}`));
+  return { locks: input.locks.filter((lock) => !keys.has(`${lock.key}:${lock.holder}`)), expired: [...keys] };
+}
+function scanconflicts(input) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const writer of input.writers) {
+    const key = lockkey(writer.origin, writer.selector);
+    targets.set(key, [...targets.get(key) ?? [], writer]);
+  }
+  const overlaps = [...targets.entries()].filter(([, writers]) => writers.length > 1).map(([key, writers]) => ({ origin: writers[0].origin, selector: writers[0].selector, writers: writers.map((writer) => writer.agentid) }));
+  const overlappingagents = new Set(overlaps.flatMap((entry) => entry.writers));
+  return {
+    id: input.id,
+    writers: input.writers,
+    overlaps,
+    suggestedorder: input.writers.filter((writer) => overlappingagents.has(writer.agentid)).map((writer) => writer.agentid).filter((agentid, index, all) => all.indexOf(agentid) === index).sort((one, two) => one < two ? -1 : 1),
+    clean: overlaps.length === 0,
+    scannedat: input.now
+  };
+}
+function mergeresults(input) {
+  const keys = /* @__PURE__ */ new Map();
+  for (const entry of input.entries) {
+    keys.set(entry.key, [...keys.get(entry.key) ?? [], entry]);
+  }
+  const conflicts = [];
+  const merged = [];
+  for (const [key, entries] of keys) {
+    const ordered = [...entries].sort((one, two) => one.mergedat - two.mergedat);
+    if (ordered.length === 1) {
+      merged.push(ordered[0]);
+      continue;
+    }
+    if (input.rule === "fail") {
+      conflicts.push(`The key ${key} carries ${ordered.length} parallel values from ${ordered.map((entry) => entry.agentid).join(", ")}; the fail rule refuses the fold.`);
+      continue;
+    }
+    const winner = input.rule === "first" ? ordered[0] : input.rule === "last" ? ordered[ordered.length - 1] : ordered.find((entry) => entry.agentid === input.preferagent) ?? ordered[ordered.length - 1];
+    const note = input.rule === "preferagent" && input.preferagent !== void 0 && !ordered.some((entry) => entry.agentid === input.preferagent) ? `The preferagent rule names the agent ${input.preferagent} which wrote no value; the latest value of ${winner.agentid} stayed.` : `The ${input.rule} rule kept the value of ${winner.agentid} from ${ordered.map((entry) => entry.agentid).join(", ")}.`;
+    conflicts.push(`The key ${key}: ${note}`);
+    merged.push({ ...winner, id: `${winner.id}:merged`, conflict: note });
+  }
+  return { entries: merged, conflicts, refused: input.rule === "fail" && conflicts.length > 0 };
+}
+function swarmreport(input) {
+  if (input.title.trim() === "") throw new Error("The report needs its title.");
+  const fold = mergeresults({ entries: input.outputs, rule: input.rule, ...input.preferagent !== void 0 ? { preferagent: input.preferagent } : {}, now: input.now });
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of fold.entries) {
+    const group = entry.taskid ?? "general";
+    groups.set(group, [...groups.get(group) ?? [], entry]);
+  }
+  const sections = [...groups.entries()].map(([taskid, entries]) => ({ title: `Task ${taskid}`, entries, sources: [...new Set(input.outputs.filter((output) => (output.taskid ?? "general") === taskid).map((output) => output.agentid))] }));
+  return {
+    report: { id: input.id, title: input.title.trim(), sections, sources: [...new Set(input.outputs.map((output) => output.agentid))], ...input.confidence !== void 0 && input.confidence.trim() !== "" ? { confidence: input.confidence } : {}, createdat: input.now },
+    conflicts: fold.conflicts,
+    refused: fold.refused
+  };
+}
+function compareoutputs(input) {
+  if (input.subject.trim() === "") throw new Error("The comparison needs its subject.");
+  if (input.outputs.length < 2) throw new Error("The comparison contrasts at least two competing outputs.");
+  const differences = input.outputs.filter((output) => output.value !== input.outputs[0]?.value).map((output) => `The agent ${output.agentid} answers ${output.value} while the agent ${input.outputs[0].agentid} answers ${input.outputs[0].value}.`);
+  return { id: input.id, subject: input.subject, outputs: input.outputs, differences, comparedat: input.now };
+}
+function interleavetimeline(actions) {
+  return [...actions].sort((one, two) => one.at - two.at || (one.id < two.id ? -1 : 1));
+}
+function sharelesson(input) {
+  if (input.statement.trim() === "") throw new Error("The lesson needs its statement in plain language.");
+  if (input.verifiedby.trim() === "") throw new Error("The lesson needs its verifier; only a verified lesson lands on the board.");
+  return postentry({ board: input.board, id: input.id, key: `lesson:${input.statement.trim().slice(0, 40)}`, value: `${input.statement.trim()} (verified by ${input.verifiedby.trim()})`, section: input.section ?? "findings", author: input.agentid.trim() === "" ? "user" : input.agentid, consentclass: input.consentclass ?? "read", now: input.now });
+}
+function swarmcosts(input) {
+  return {
+    agents: input.usage.length,
+    tokens: input.usage.reduce((total, usage) => total + usage.tokens, 0),
+    cost: input.usage.reduce((total, usage) => total + usage.cost, 0),
+    steps: input.usage.reduce((total, usage) => total + usage.steps, 0),
+    ...input.currency !== void 0 && input.currency.trim() !== "" ? { currency: input.currency } : {},
+    computedat: input.now
+  };
+}
+function replayagentrun(input) {
+  return interleavetimeline(input.events.filter((event) => event.agentid === input.agentid).map((event) => ({ id: event.id, kind: event.kind, summary: event.summary, at: event.at, ...event.agentid !== void 0 ? { agentid: event.agentid } : {} })));
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -11612,58 +12169,6 @@ function taskcounts(queue) {
   };
 }
 
-// blackboard.ts
-var blackboardsections = ["goals", "facts", "findings", "scratch"];
-function emptyboard(sections) {
-  return { sections: sections ?? blackboardsections, entries: [] };
-}
-function postentry(input) {
-  if (input.key.trim() === "") throw new Error("The blackboard entry needs its key.");
-  if (input.value.trim() === "") throw new Error("The blackboard entry needs its value.");
-  if (input.author.trim() === "") throw new Error("The blackboard entry needs its author.");
-  if (!blackboardsections.includes(input.section)) throw new Error(`The section ${input.section} is not one of the shared blackboard sections.`);
-  if (input.board.entries.some((entry2) => entry2.id === input.id)) throw new Error(`The blackboard entry id ${input.id} already exists.`);
-  if (input.valuekind === "json") {
-    try {
-      JSON.parse(input.value);
-    } catch {
-      throw new Error("The json blackboard entry needs a well-formed json value.");
-    }
-  }
-  const entry = { id: input.id, key: input.key.trim(), valuekind: input.valuekind ?? "text", value: input.value, author: input.author, section: input.section, consentclass: input.consentclass ?? "read", postedat: input.now };
-  return { ...input.board, sections: input.board.sections.includes(input.section) ? input.board.sections : [...input.board.sections, input.section], entries: [entry, ...input.board.entries] };
-}
-function entryfresh(entry, now, window2) {
-  if (entry.retiredat !== void 0) return false;
-  if (window2 === void 0) return true;
-  return now - entry.postedat <= window2;
-}
-function readentries(input) {
-  return input.board.entries.filter((entry) => entry.retiredat === void 0).filter((entry) => input.section === void 0 || entry.section === input.section).filter((entry) => entryfresh(entry, input.now, input.freshness)).sort((one, two) => two.postedat - one.postedat);
-}
-function retireentries(input) {
-  if (input.board.retirementwindow === void 0) return { board: input.board, retired: [] };
-  const stale = input.board.entries.filter((entry) => entry.retiredat === void 0 && input.now - entry.postedat > input.board.retirementwindow);
-  if (stale.length === 0) return { board: input.board, retired: [] };
-  const staleids = new Set(stale.map((entry) => entry.id));
-  return {
-    board: { ...input.board, entries: input.board.entries.map((entry) => staleids.has(entry.id) ? { ...entry, retiredat: input.now } : entry) },
-    retired: [...staleids]
-  };
-}
-function retireentry(input) {
-  const entry = input.board.entries.find((candidate) => candidate.id === input.entryid);
-  if (!entry) throw new Error(`The blackboard entry ${input.entryid} does not exist.`);
-  if (entry.retiredat !== void 0) throw new Error(`The blackboard entry ${entry.key} is already retired.`);
-  return { ...input.board, entries: input.board.entries.map((candidate) => candidate.id === input.entryid ? { ...candidate, retiredat: input.now } : candidate) };
-}
-function boardsummary(board, now) {
-  return board.sections.map((section) => {
-    const live = board.entries.filter((entry) => entry.section === section && entry.retiredat === void 0);
-    return { section, entries: live.length, authors: [...new Set(live.map((entry) => entry.author))], ...live.length > 0 ? { freshestat: Math.max(...live.map((entry) => entry.postedat)) } : {} };
-  });
-}
-
 // agentmailbox.ts
 function mailboxof(mailboxes, agentid) {
   return mailboxes.find((mailbox) => mailbox.agentid === agentid) ?? { agentid, inbox: [], outbox: [], unread: 0 };
@@ -20820,6 +21325,7 @@ async function handlerequest(message, sender) {
           const context = agentruncontext({ agent, task: claimed.task, now });
           await memory.addagentevent(agenteventof({ id: randomid(), kind: "claimed", agentid, taskid: claimed.task.id, summary: `The agent ${agent.name} claimed the task ${claimed.task.payload} from the lane ${claimed.task.lane}; the run context ${context.run.id} reuses the workflow engine.`, now }));
           await audit("swarm", `The agent ${agent.name} claimed the highest priority task of the lane ${claimed.task.lane}; the per agent run context ${context.run.id} reuses the workflow engine and the proposal still passes the human review.`, {});
+          await memory.addswarmaction({ id: randomid(), kind: "claim", agentid, summary: `The agent ${agent.name} claimed the task ${claimed.task.payload} from the lane ${claimed.task.lane}.`, at: now });
         }
         return swarmstateof();
       }
@@ -20835,6 +21341,7 @@ async function handlerequest(message, sender) {
         if (stolen.task !== void 0) {
           await memory.addagentevent(agenteventof({ id: randomid(), kind: "stole", agentid, taskid: stolen.task.id, summary: `The ${input2.role} agent ${agentid} stole the task ${stolen.task.payload} from the lane ${stolen.task.lane}; ${grade.reason ?? ""}`, now }));
           await audit("swarm", `The ${input2.role} agent ${agentid} stole a task from the lane ${stolen.task.lane} inside the approved swarm; the lane ownership rules the user configured held.`, {});
+          await memory.addswarmaction({ id: randomid(), kind: "steal", agentid, summary: `The ${input2.role} agent ${agentid} stole the task ${stolen.task.payload} from the lane ${stolen.task.lane}.`, at: now });
         }
         return swarmstateof();
       }
@@ -20849,6 +21356,7 @@ async function handlerequest(message, sender) {
         await memory.setagentusage(nextusage);
         await memory.addagentevent(agenteventof({ id: randomid(), kind: "completed", taskid, ...holder !== void 0 ? { agentid: holder.agentid } : {}, summary: `The task ${completedtask?.payload ?? taskid} completed and its claim released.`, now }));
         await audit("swarm", `The task ${taskid} completed${holder !== void 0 ? ` under the agent ${holder.agentid}` : ""} and released its claim; the per agent usage counters moved with it.`, {});
+        await memory.addswarmaction({ id: randomid(), kind: "complete", ...holder !== void 0 ? { agentid: holder.agentid } : {}, summary: `The task ${completedtask?.payload ?? taskid} completed and its claim released.`, at: now });
         return swarmstateof();
       }
       if (input2.cancel === true && input2.taskid !== void 0) {
@@ -20930,6 +21438,340 @@ async function handlerequest(message, sender) {
       }
       throw new Error("The swarm blackboard request carries no post, retire or sweep action.");
     }
+    case "swarmleader": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.elect !== void 0) {
+        const agents = await memory.getagents();
+        const rule = input2.elect.rule === "named" ? { kind: "named", agentid: input2.elect.agentid ?? "" } : { kind: "first" };
+        const verdict = leaderelectionvalid({ rule, agents });
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const topology2 = electleader({ agents, id: randomid(), rule, now });
+        await memory.settopology(topology2);
+        await memory.addswarmaction({ id: randomid(), kind: "elect", agentid: topology2.leaderid, summary: `The ${rule.kind} election rule the user configured elected the agent ${topology2.leaderid} leader of the swarm with ${topology2.workerids.length} workers, ${topology2.criticids.length} critics and ${topology2.verifierids.length} verifiers.`, at: now });
+        await memory.addagentevent(agenteventof({ id: randomid(), kind: "assign", agentid: topology2.leaderid, summary: `The leader election picked ${topology2.leaderid} by the ${rule.kind} rule; the topology records the lanes.`, now }));
+        await audit("swarm", `The user elected the agent ${topology2.leaderid} leader by the ${rule.kind} rule; the topology holds ${topology2.workerids.length} workers, ${topology2.criticids.length} critics and ${topology2.verifierids.length} verifiers, and the leader only organizes work that still passes the same review.`, {});
+        return swarmstateof();
+      }
+      const topology = await memory.gettopology();
+      if (input2.assign !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the assignment.");
+        const queue = await queueof();
+        const wanted = input2.assign.taskids ?? [];
+        const tasks = queue.items.filter((task) => wanted.length === 0 || wanted.includes(task.id));
+        const next = assignwork({ topology, tasks, now });
+        await memory.settopology(next);
+        await memory.addswarmaction({ id: randomid(), kind: "assign", agentid: next.leaderid, summary: `The leader sliced ${next.assignments.length} task${next.assignments.length === 1 ? "" : "s"} across the ${next.workerids.length} workers of the topology.`, at: now });
+        await audit("swarm", `The leader ${next.leaderid} assigned ${next.assignments.length} task slice${next.assignments.length === 1 ? "" : "s"} across the ${next.workerids.length} workers; every slice still passes the same plan review before anything executes.`, {});
+        return swarmstateof();
+      }
+      if (input2.collect !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the collection.");
+        const gathered = collectresults({ topology, outputs: input2.collect.outputs ?? [] });
+        await memory.addswarmaction({ id: randomid(), kind: "collect", agentid: topology.leaderid, summary: `The leader gathered ${gathered.gathered.length - gathered.missing.length} worker output${gathered.gathered.length - gathered.missing.length === 1 ? "" : "s"} with ${gathered.missing.length} still pending.`, at: now });
+        await audit("swarm", `The leader ${topology.leaderid} collected ${gathered.gathered.length} worker outputs with ${gathered.missing.length} pending; the missing slices stay visible to the user.`, {});
+        return { ...await swarmstateof(), collected: gathered.gathered, missing: gathered.missing };
+      }
+      if (input2.scale !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the scaling.");
+        const settings = await memory.getsettings();
+        const bound = input2.scale.bound ?? settings?.swarmworkers;
+        const verdict = workerscalevalid(bound);
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const agents = await memory.getagents();
+        const outcome = scaleworkers({ topology, agents, pending: input2.scale.pending ?? 0, ...bound !== void 0 ? { bound } : {}, now });
+        await memory.settopology(outcome.topology);
+        await memory.addswarmaction({ id: randomid(), kind: "scale", agentid: topology.leaderid, summary: outcome.reason, at: now });
+        await audit("swarm", `The worker lane scaled: ${outcome.reason}`, {});
+        return { ...await swarmstateof(), scaleadded: outcome.added, scaleretired: outcome.retired };
+      }
+      if (input2.split !== void 0) {
+        const split = plannersplit({ id: randomid(), planownerid: input2.split.planownerid?.trim() ?? "", runownerid: input2.split.runownerid?.trim() ?? "", ...input2.split.taskid !== void 0 && input2.split.taskid.trim() !== "" ? { taskid: input2.split.taskid.trim() } : {}, now });
+        await memory.setplannersplits([...(await memory.getplannersplits()).filter((entry) => entry.id !== split.id), split]);
+        await memory.addswarmaction({ id: randomid(), kind: "split", summary: `The task ${split.taskid ?? "of the swarm"} split between the planner ${split.planownerid} and the executor ${split.runownerid}; the executor reports every step outcome back.`, at: now });
+        await audit("swarm", `The user split the task ${split.taskid ?? ""} between the planner agent ${split.planownerid} and the executor agent ${split.runownerid}; the executor reports every step outcome back to the planner.`, {});
+        return swarmstateof();
+      }
+      if (input2.stepreport !== void 0) {
+        const splitid = input2.stepreport.splitid?.trim() ?? "";
+        const split = (await memory.getplannersplits()).find((entry) => entry.id === splitid);
+        if (!split) throw new Error(`The planner executor split ${splitid} does not exist.`);
+        const outcome = input2.stepreport.outcome === "failed" ? "failed" : "done";
+        const next = reportstep({ split, stepid: input2.stepreport.stepid?.trim() ?? "", outcome, detail: input2.stepreport.detail?.trim() ?? "", now });
+        await memory.setplannersplits((await memory.getplannersplits()).map((entry) => entry.id === split.id ? next : entry));
+        await memory.addswarmaction({ id: randomid(), kind: "stepreport", agentid: split.runownerid, summary: `The executor ${split.runownerid} reported the step ${next.stepreports[next.stepreports.length - 1]?.stepid ?? ""} ${outcome} back to the planner ${split.planownerid}.`, at: now });
+        await audit("swarm", `The executor ${split.runownerid} reported the step ${input2.stepreport.stepid ?? ""} ${outcome} back to the planner ${split.planownerid}; the split record keeps every step outcome.`, {});
+        return swarmstateof();
+      }
+      if (input2.milestone !== void 0) {
+        const agentid = input2.milestone.agentid?.trim() ?? "";
+        if (agentid === "" || input2.milestone.label === void 0 || input2.milestone.label.trim() === "") throw new Error("The milestone needs its agent and its label.");
+        const board = boardstate({ agents: await memory.getagents(), queue: await queueof(), ...topology !== void 0 ? { topology } : {}, now });
+        const milestone = { label: input2.milestone.label.trim(), done: input2.milestone.done !== false, ...input2.milestone.done !== false ? { at: now } : {} };
+        await memory.addboardsnapshot({ ...board, lanes: board.lanes.map((lane) => lane.agentid === agentid ? { ...lane, milestones: [...lane.milestones.filter((entry) => entry.label !== milestone.label), milestone] } : lane) });
+        await memory.addswarmaction({ id: randomid(), kind: "milestone", agentid, summary: `The agent ${agentid} reached the milestone ${milestone.label}.`, at: now });
+        await audit("swarm", `The agent ${agentid} reported the milestone ${milestone.label}; the progressboard snapshot stores it under the user configured retention.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm leader request carries no elect, assign, collect, scale, split, stepreport or milestone action.");
+    }
+    case "swarmreview": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.request !== void 0) {
+        const requests = requestreview({ requests: await memory.getreviewrequests(), id: randomid(), fromagentid: input2.request.fromagentid?.trim() ?? "", toagentid: input2.request.toagentid?.trim() ?? "", subject: input2.request.subject ?? "", payload: input2.request.payload ?? "", ...input2.request.timeoutms !== void 0 ? { timeoutms: input2.request.timeoutms } : {}, now });
+        await memory.setreviewrequests(requests);
+        const requesterid = input2.request.fromagentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "review", ...requesterid !== "" ? { agentid: requesterid } : {}, summary: `The agent ${input2.request.fromagentid?.trim() ?? ""} routed the review of ${input2.request.subject ?? ""} to the agent ${input2.request.toagentid?.trim() ?? ""}.`, at: now });
+        await audit("swarm", `The review request of ${input2.request.subject ?? ""} was routed from ${input2.request.fromagentid ?? ""} to ${input2.request.toagentid ?? ""}${input2.request.timeoutms !== void 0 ? ` with the user configured answer window ${input2.request.timeoutms}ms` : ""}; the review stays read only over the agent output.`, {});
+        return swarmstateof();
+      }
+      if (input2.ack !== void 0) {
+        const requests = ackreview({ requests: await memory.getreviewrequests(), id: input2.ack.trim(), now });
+        await memory.setreviewrequests(requests);
+        await audit("swarm", `The review request ${input2.ack} was acked; the answer still waits.`, {});
+        return swarmstateof();
+      }
+      if (input2.apply !== void 0) {
+        const verdict = input2.apply.verdict === "approve" || input2.apply.verdict === "reject" ? input2.apply.verdict : "changes";
+        const outcome = applyreview({ requests: await memory.getreviewrequests(), id: input2.apply.id?.trim() ?? "", reviewerid: input2.apply.reviewerid?.trim() ?? "", verdict, issues: input2.apply.issues ?? [], requiredchanges: input2.apply.requiredchanges ?? [], ...input2.apply.taskid !== void 0 && input2.apply.taskid.trim() !== "" ? { taskid: input2.apply.taskid.trim() } : {}, now });
+        const grade = criticreviewgrade(outcome.review);
+        if (!grade.allowed) throw new Error(grade.reason);
+        await memory.setreviewrequests(outcome.requests);
+        await memory.addcriticreview(outcome.review);
+        await memory.addswarmaction({ id: randomid(), kind: "review", agentid: outcome.review.reviewerid, summary: `The critic ${outcome.review.reviewerid} returned the ${verdict} verdict over the output of ${outcome.review.subjectagentid}.`, at: now });
+        await audit("swarm", `The critic ${outcome.review.reviewerid} reviewed the output of ${outcome.review.subjectagentid} with the ${verdict} verdict${outcome.review.requiredchanges.length > 0 ? ` and ${outcome.review.requiredchanges.length} required change${outcome.review.requiredchanges.length === 1 ? "" : "s"}` : ""}; the critic reads only and the rework still passes the same human review.`, {});
+        return swarmstateof();
+      }
+      if (input2.sweep === true) {
+        const swept = sweepreviews({ requests: await memory.getreviewrequests(), now });
+        await memory.setreviewrequests(swept.requests);
+        if (swept.timedout.length > 0) await audit("swarm", `The review sweep timed out ${swept.timedout.length} unanswered request${swept.timedout.length === 1 ? "" : "s"} past the user configured window.`, {});
+        return swarmstateof();
+      }
+      if (input2.verify !== void 0) {
+        const settings = await memory.getsettings();
+        const check = checkclaim({ id: randomid(), verifierid: input2.verify.verifierid?.trim() ?? "", claimagentid: input2.verify.claimagentid?.trim() ?? "", claim: input2.verify.claim ?? "", method: input2.verify.method?.trim() ?? "", outcome: input2.verify.outcome === "fail" ? "fail" : "pass", ...input2.verify.evidence !== void 0 && input2.verify.evidence.trim() !== "" ? { evidence: input2.verify.evidence } : {}, ...input2.verify.taskid !== void 0 && input2.verify.taskid.trim() !== "" ? { taskid: input2.verify.taskid.trim() } : {}, now });
+        const grade = verifiermethodgrade({ method: check.method, allowed: settings?.verifiermethods ?? [] });
+        if (!grade.allowed) throw new Error(grade.reason);
+        await memory.addverifiercheck(check);
+        await memory.addswarmaction({ id: randomid(), kind: "verify", agentid: check.verifierid, summary: `The verifier ${check.verifierid} marked the claim of ${check.claimagentid} ${check.outcome} by the ${check.method} method.`, at: now });
+        await audit("swarm", `The verifier ${check.verifierid} checked the claim of ${check.claimagentid} by the ${check.method} method and marked it ${check.outcome}${check.evidence !== void 0 ? ` with the evidence ${check.evidence}` : ""}; the verifier check reads the page and never writes.`, {});
+        return swarmstateof();
+      }
+      if (input2.escalate !== void 0) {
+        const record2 = escalate({ id: randomid(), agentid: input2.escalate.agentid?.trim() ?? "", subject: input2.escalate.subject ?? "", context: input2.escalate.context ?? "", now });
+        const gate = escalationgate(record2);
+        if (!gate.allowed) throw new Error(gate.reason);
+        await memory.addescalation(record2);
+        await memory.addswarmaction({ id: randomid(), kind: "escalate", agentid: record2.agentid, summary: `The agent ${record2.agentid} lifted the stalled decision ${record2.subject} to the user with its full context.`, at: now });
+        await audit("swarm", `The agent ${record2.agentid} escalated the decision ${record2.subject} to the user; the escalation stays human decided and the agent waits.`, {});
+        return swarmstateof();
+      }
+      if (input2.decide !== void 0) {
+        const record2 = (await memory.getescalations()).find((entry) => entry.id === input2.decide?.id?.trim());
+        if (!record2) throw new Error(`The escalation ${input2.decide?.id ?? ""} does not exist.`);
+        const resolved = resolveescalation({ escalation: record2, decision: input2.decide.decision ?? "", now });
+        await memory.updateescalation(resolved);
+        await memory.addswarmaction({ id: randomid(), kind: "escalate", agentid: record2.agentid, summary: `The user decided the escalation ${record2.subject}: ${resolved.decision}.`, at: now });
+        await audit("swarm", `The user decided the escalation ${record2.subject} of the agent ${record2.agentid}; the decision is recorded and the agent continues from it.`, {});
+        return swarmstateof();
+      }
+      if (input2.consensus !== void 0) {
+        const settings = await memory.getsettings();
+        const agents = await memory.getagents();
+        const quorum = input2.consensus.quorum ?? settings?.swarmquorum;
+        if (quorum === void 0) throw new Error("The consensus round needs its quorum; the user configures it or sets the swarmquorum run setting.");
+        const voters = agents.filter((agent) => agent.state !== "stopped").length;
+        const verdict = consensusquorumvalid({ quorum, voters });
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const round = openconsensus({ id: randomid(), subject: input2.consensus.subject ?? "", quorum, now });
+        await memory.setconsensusround(round);
+        await memory.addswarmaction({ id: randomid(), kind: "consensus", summary: `The consensus round on ${round.subject} opened with the user configured quorum ${quorum}.`, at: now });
+        await audit("swarm", `The consensus round on ${round.subject} opened with the user configured quorum ${quorum} of ${voters} voting agents; the round carries when the yes votes reach it.`, {});
+        return swarmstateof();
+      }
+      if (input2.vote !== void 0) {
+        const round = (await memory.getconsensusrounds()).find((entry) => entry.id === input2.vote?.id?.trim());
+        if (!round) throw new Error(`The consensus round ${input2.vote?.id ?? ""} does not exist.`);
+        const vote = input2.vote.vote === "no" ? "no" : input2.vote.vote === "abstain" ? "abstain" : "yes";
+        const next = castvote({ round, agentid: input2.vote.agentid?.trim() ?? "", vote, now });
+        await memory.setconsensusround(next);
+        const voterid = input2.vote.agentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "consensus", ...voterid !== "" ? { agentid: voterid } : {}, summary: `The agent ${input2.vote.agentid?.trim() ?? ""} voted ${vote} on ${round.subject}; the round is ${next.state}.`, at: now });
+        await audit("swarm", `The agent ${input2.vote.agentid ?? ""} voted ${vote} on ${round.subject}; the round reads ${consensusstate(next).yes} yes, ${consensusstate(next).no} no and ${consensusstate(next).abstain} abstain against the quorum ${round.quorum}.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm review request carries no request, ack, apply, sweep, verify, escalate, decide, consensus or vote action.");
+    }
+    case "swarmhandoff": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.prepare !== void 0) {
+        const agents = await memory.getagents();
+        const record2 = preparehandoff({ agents, id: randomid(), fromagentid: input2.prepare.fromagentid?.trim() ?? "", toagentid: input2.prepare.toagentid?.trim() ?? "", taskstate: input2.prepare.taskstate ?? "", ...input2.prepare.tabid !== void 0 ? { tabid: input2.prepare.tabid } : {}, ...input2.prepare.reason !== void 0 && input2.prepare.reason.trim() !== "" ? { reason: input2.prepare.reason } : {}, now });
+        await memory.addhandoff(record2);
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: record2.fromagentid, summary: `The tab ${record2.tabid} handoff from ${record2.fromagentid} to ${record2.toagentid} was prepared with the packaged task state.`, at: now });
+        await audit("swarm", `The handoff of tab ${record2.tabid} from ${record2.fromagentid} to ${record2.toagentid} was prepared with the packaged task state; the transfer preserves the original session grants.`, {});
+        return swarmstateof();
+      }
+      if (input2.transfer !== void 0) {
+        const record2 = (await memory.gethandoffs()).find((entry) => entry.id === input2.transfer?.trim());
+        if (!record2) throw new Error(`The handoff ${input2.transfer ?? ""} does not exist.`);
+        const agents = await memory.getagents();
+        const receiver = agents.find((agent) => agent.id === record2.toagentid);
+        const session = await memory.getsession();
+        const gate = handoffgrantgate({ record: record2, toscope: receiver?.scope, sessiongrants: session?.grants ?? [] });
+        if (!gate.allowed) throw new Error(gate.reason);
+        const outcome = transferhandoff({ agents, handoffs: await memory.gethandoffs(), id: record2.id, now });
+        await memory.setagents(outcome.agents);
+        await memory.updatehandoff(outcome.handoffs.find((entry) => entry.id === record2.id));
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: record2.toagentid, summary: `The tab ${record2.tabid} moved from ${record2.fromagentid} to ${record2.toagentid}; the task state stays packaged until the resume.`, at: now });
+        await audit("swarm", `The tab ${record2.tabid} moved from ${record2.fromagentid} to ${record2.toagentid} under the one agent per tab rule; ${gate.reason ?? ""}`, {});
+        return swarmstateof();
+      }
+      if (input2.resume !== void 0) {
+        const record2 = (await memory.gethandoffs()).find((entry) => entry.id === input2.resume?.trim());
+        if (!record2) throw new Error(`The handoff ${input2.resume ?? ""} does not exist.`);
+        const resumed = resumehandoff({ handoffs: await memory.gethandoffs(), id: record2.id, now });
+        await memory.updatehandoff(resumed);
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: resumed.toagentid, summary: `The agent ${resumed.toagentid} resumed the task from the packaged state of the handoff ${resumed.id}.`, at: now });
+        await audit("swarm", `The agent ${resumed.toagentid} resumed the handed off task from its packaged state; the run continues behind the same session, plan and origin gates.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm handoff request carries no prepare, transfer or resume action.");
+    }
+    case "swarmlocks": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.acquire !== void 0) {
+        const holder = input2.acquire.holder?.trim() ?? "";
+        const origin = input2.acquire.origin?.trim() ?? "";
+        const selector = input2.acquire.selector?.trim() ?? "";
+        if (holder === "" || origin === "" || selector === "") throw new Error("The lock acquisition needs its holder, origin and selector.");
+        const kind = input2.acquire.kind === "shared" ? "shared" : "exclusive";
+        const locks = await memory.getlocks();
+        const grade = lockscopevalid({ key: lockkey(origin, selector), holder, kind, origin, selector, acquiredat: now, ...input2.acquire.expiresat !== void 0 ? { expiresat: input2.acquire.expiresat } : {} });
+        if (!grade.allowed) throw new Error(grade.reason);
+        const outcome = acquirelock({ locks, holder, origin, selector, kind, ...input2.acquire.expiresat !== void 0 ? { expiresat: input2.acquire.expiresat } : {}, now });
+        if (!outcome.acquired) throw new Error(outcome.reason);
+        await memory.setlocks(outcome.locks);
+        await memory.addswarmaction({ id: randomid(), kind: "lock", agentid: holder, summary: outcome.reason, at: now });
+        await audit("swarm", `The ${kind} lock ${origin}|${selector} went to the agent ${holder}${input2.acquire.expiresat !== void 0 ? ` with the user configured expiry ${new Date(input2.acquire.expiresat).toISOString()}` : " with no expiry"}; the lock serializes work the same review already approved.`, {});
+        return swarmstateof();
+      }
+      if (input2.release !== void 0) {
+        const locks = await memory.getlocks();
+        const outcome = releaselock({ locks, key: input2.release.key?.trim() ?? "", holder: input2.release.holder?.trim() ?? "", now });
+        if (!outcome.released) throw new Error(`The agent ${input2.release.holder ?? ""} holds no lock ${input2.release.key ?? ""}.`);
+        await memory.setlocks(outcome.locks);
+        const releaserid = input2.release.holder?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "lock", ...releaserid !== "" ? { agentid: releaserid } : {}, summary: `The agent ${input2.release.holder?.trim() ?? ""} released the lock ${input2.release.key ?? ""}; the resource returned to the pool.`, at: now });
+        await audit("swarm", `The agent ${input2.release.holder ?? ""} released the lock ${input2.release.key ?? ""}; the resource returned to the pool for the next agent.`, {});
+        return swarmstateof();
+      }
+      if (input2.sweep === true) {
+        const outcome = expirelocks({ locks: await memory.getlocks(), now });
+        await memory.setlocks(outcome.locks);
+        if (outcome.expired.length > 0) {
+          await memory.addswarmaction({ id: randomid(), kind: "lock", summary: `The expiry sweep returned ${outcome.expired.length} abandoned lock${outcome.expired.length === 1 ? "" : "s"} to the pool.`, at: now });
+          await audit("swarm", `The lock sweep expired ${outcome.expired.length} abandoned lock${outcome.expired.length === 1 ? "" : "s"} past their user configured expiry; the keys returned to the pool.`, {});
+        }
+        return swarmstateof();
+      }
+      if (input2.scan !== void 0) {
+        const writers = (input2.scan.writers ?? []).map((writer) => ({ agentid: writer.agentid?.trim() ?? "", origin: writer.origin?.trim() ?? "", selector: writer.selector?.trim() ?? "", ...writer.taskid !== void 0 && writer.taskid.trim() !== "" ? { taskid: writer.taskid.trim() } : {} })).filter((writer) => writer.agentid !== "" && writer.origin !== "" && writer.selector !== "");
+        const scan = scanconflicts({ id: randomid(), writers, now });
+        await memory.addconflictscan(scan);
+        await memory.addswarmaction({ id: randomid(), kind: "conflict", summary: scan.clean ? `The conflict scan found no overlapping write among ${writers.length} writers.` : `The conflict scan found ${scan.overlaps.length} overlapping target${scan.overlaps.length === 1 ? "" : "s"} among ${writers.length} writers with the suggested order ${scan.suggestedorder.join(" \u2192 ")}.`, at: now });
+        await audit("swarm", scan.clean ? `The conflict scan of ${writers.length} parallel writers found no overlapping write; the runs stay safe side by side.` : `The conflict scan found ${scan.overlaps.length} overlapping target${scan.overlaps.length === 1 ? "" : "s"} (${scan.overlaps.map((overlap) => `${overlap.origin}|${overlap.selector} by ${overlap.writers.join(", ")}`).join("; ")}) and suggested the order ${scan.suggestedorder.join(" \u2192 ")}.`, {});
+        return { ...await swarmstateof(), scan };
+      }
+      if (input2.arbitrate !== void 0) {
+        const strategy = input2.arbitrate.strategy === "age" ? "age" : input2.arbitrate.strategy === "leader" ? "leader" : "priority";
+        const rule = { id: randomid(), strategy, priorityorder: input2.arbitrate.priorityorder ?? [], configuredat: now };
+        const topology = await memory.gettopology();
+        const claims = (input2.arbitrate.claims ?? []).map((claim2) => ({ agentid: claim2.agentid?.trim() ?? "", claimedat: claim2.claimedat ?? now })).filter((claim2) => claim2.agentid !== "");
+        const order = arbitrate({ rule, ...topology !== void 0 ? { leaderid: topology.leaderid } : {}, claims });
+        await memory.addswarmaction({ id: randomid(), kind: "arbitrate", summary: `The ${strategy} arbitration rule ordered the competing claims ${order.join(" \u2192 ")}.`, at: now });
+        await audit("swarm", `The user configured ${strategy} arbitration ordered the competing resource claims ${order.join(" \u2192 ")}; the ordering stays a user rule.`, {});
+        return { ...await swarmstateof(), arbitration: order };
+      }
+      throw new Error("The swarm locks request carries no acquire, release, sweep, scan or arbitrate action.");
+    }
+    case "swarmmerge": {
+      const input2 = message;
+      const now = Date.now();
+      const toentries = () => (input2.entries ?? []).map((entry, index) => ({ id: `${now}:${index}`, agentid: entry.agentid?.trim() ?? "", ...entry.taskid !== void 0 && entry.taskid.trim() !== "" ? { taskid: entry.taskid.trim() } : {}, key: entry.key?.trim() ?? "", value: entry.value ?? "", mergedat: now })).filter((entry) => entry.key !== "" && entry.agentid !== "");
+      const ruleof = (value) => value === "last" ? "last" : value === "preferagent" ? "preferagent" : value === "fail" ? "fail" : "first";
+      if (input2.merge !== void 0) {
+        const fold = mergeresults({ entries: toentries(), rule: ruleof(input2.merge.rule), ...input2.merge.preferagent !== void 0 && input2.merge.preferagent.trim() !== "" ? { preferagent: input2.merge.preferagent.trim() } : {}, now });
+        const grade = conflictresolutiongrade(ruleof(input2.merge.rule));
+        if (!grade.allowed) throw new Error(grade.reason);
+        await audit("swarm", `The merge folded ${input2.entries?.length ?? 0} parallel results under the ${ruleof(input2.merge.rule)} rule with ${fold.conflicts.length} conflict${fold.conflicts.length === 1 ? "" : "s"} resolved and every merged value keeping its provenance; ${grade.reason ?? ""}`, {});
+        return { ...await swarmstateof(), merged: fold.entries, mergeconflicts: fold.conflicts, mergerefused: fold.refused };
+      }
+      if (input2.report !== void 0) {
+        const rule = ruleof(input2.report.rule);
+        const grade = conflictresolutiongrade(rule);
+        if (!grade.allowed) throw new Error(grade.reason);
+        const built = swarmreport({ id: randomid(), title: input2.report.title ?? "", outputs: toentries(), rule, ...input2.report.preferagent !== void 0 && input2.report.preferagent.trim() !== "" ? { preferagent: input2.report.preferagent.trim() } : {}, ...input2.report.confidence !== void 0 && input2.report.confidence.trim() !== "" ? { confidence: input2.report.confidence } : {}, now });
+        if (built.refused) throw new Error(`The report refused the fold: ${built.conflicts.join("; ")}`);
+        await memory.setreport(built.report);
+        await memory.addswarmaction({ id: randomid(), kind: "merge", summary: `The report ${built.report.title} merged the outputs of ${built.report.sources.length} agent${built.report.sources.length === 1 ? "" : "s"} into ${built.report.sections.length} section${built.report.sections.length === 1 ? "" : "s"}.`, at: now });
+        await audit("swarm", `The aggregate report ${built.report.title} folded the parallel outputs of ${built.report.sources.join(", ")} into ${built.report.sections.length} section${built.report.sections.length === 1 ? "" : "s"} under the ${rule} rule; every merged value keeps its provenance.`, {});
+        return swarmstateof();
+      }
+      if (input2.export !== void 0) {
+        const report = await memory.getreport();
+        if (!report) throw new Error("No merged report is stored; the user builds the report before any export.");
+        const grade = mergeegressgrade({ report, carriespagecontent: input2.export.carriespagecontent === true });
+        if (!grade.allowed) throw new Error(grade.reason);
+        await audit("swarm", `The merged report ${report.title} was exported; ${grade.reason ?? ""}`, {});
+        return swarmstateof();
+      }
+      if (input2.compare !== void 0) {
+        const outputs = (input2.compare.outputs ?? []).map((output) => ({ agentid: output.agentid?.trim() ?? "", value: output.value ?? "" })).filter((output) => output.agentid !== "");
+        const comparison = compareoutputs({ id: randomid(), subject: input2.compare.subject ?? "", outputs, now });
+        await audit("swarm", `The user compared ${outputs.length} competing agent outputs on ${comparison.subject}; the differences name where the agents disagree.`, {});
+        return { ...await swarmstateof(), comparison };
+      }
+      if (input2.lesson !== void 0) {
+        const board = await memory.getblackboard() ?? emptyboard();
+        const next = sharelesson({ board, id: randomid(), agentid: input2.lesson.agentid?.trim() ?? "", statement: input2.lesson.statement ?? "", verifiedby: input2.lesson.verifiedby?.trim() ?? "", ...input2.lesson.section !== void 0 ? { section: ["goals", "facts", "findings", "scratch"].includes(input2.lesson.section) ? input2.lesson.section : "findings" } : {}, ...input2.lesson.consentclass !== void 0 ? { consentclass: input2.lesson.consentclass === "interaction" || input2.lesson.consentclass === "sensitive" ? input2.lesson.consentclass : "read" } : {}, now });
+        await memory.setblackboard(next);
+        const lessonauthor = input2.lesson.agentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "lesson", ...lessonauthor !== "" ? { agentid: lessonauthor } : {}, summary: `The verified lesson of ${input2.lesson.agentid?.trim() ?? "user"} landed on the findings section for every agent to read.`, at: now });
+        await audit("swarm", `The verified lesson of the agent ${input2.lesson.agentid ?? ""} was shared to the blackboard findings section; only a verified lesson lands on the board.`, {});
+        return swarmstateof();
+      }
+      if (input2.costs === true) {
+        const usage = await memory.getagentusage();
+        const cost = swarmcosts({ usage, now });
+        await memory.addswarmcost(cost);
+        await audit("swarm", `The shared cost accounting summed the usage of ${cost.agents} agent${cost.agents === 1 ? "" : "s"} into the swarm totals of ${cost.tokens} tokens, ${cost.cost} cost and ${cost.steps} steps.`, {});
+        return swarmstateof();
+      }
+      if (input2.timeline !== void 0) {
+        return { ...await swarmstateof(), timelinefiltered: await memory.getswarmtimeline({ ...input2.timeline.agentid !== void 0 && input2.timeline.agentid.trim() !== "" ? { agentid: input2.timeline.agentid.trim() } : {}, ...input2.timeline.kind !== void 0 && input2.timeline.kind.trim() !== "" ? { kind: input2.timeline.kind.trim() } : {} }) };
+      }
+      if (input2.replay !== void 0) {
+        const agentid = input2.replay.trim();
+        if (agentid === "") throw new Error("The replay needs its agent id.");
+        const events = await memory.getagentevents();
+        const actions = await memory.getswarmtimeline();
+        const replay = replayagentrun({ events: [...events.map((event) => ({ id: event.id, kind: event.kind, summary: event.summary, at: event.at, ...event.agentid !== void 0 ? { agentid: event.agentid } : {} })), ...actions.map((action) => ({ id: action.id, kind: action.kind, summary: action.summary, at: action.at, ...action.agentid !== void 0 ? { agentid: action.agentid } : {} }))], agentid });
+        await audit("swarm", `The replay rebuilt the run of the agent ${agentid} from the audit trail with ${replay.length} recorded action${replay.length === 1 ? "" : "s"}.`, {});
+        return { ...await swarmstateof(), replay };
+      }
+      if (input2.snapshot === true) {
+        const state = await swarmstateof();
+        await memory.addboardsnapshot(state.board);
+        await audit("swarm", `The progressboard snapshot was stored with ${state.board.lanes.length} lane${state.board.lanes.length === 1 ? "" : "s"} under the user configured retention.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm merge request carries no merge, report, export, compare, lesson, costs, timeline, replay or snapshot action.");
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -21111,20 +21953,42 @@ async function swarmstateof() {
   const killswitch = await memory.getkillswitch() ?? { engaged: false };
   const usage = await memory.getagentusage();
   const board = await memory.getblackboard() ?? emptyboard();
+  const topology = await memory.gettopology();
+  const reviewrequests = await memory.getreviewrequests();
+  const reviews = await memory.getcriticreviews();
+  const handoffs = await memory.gethandoffs();
+  const report = await memory.getreport();
   return {
     overview: swarmoverview({ agents, queue, mailboxes }),
     agents: agents.map((agent) => {
       const claim2 = queue.claims.find((record2) => record2.agentid === agent.id);
       const task = claim2 !== void 0 ? queue.items.find((item) => item.id === claim2.taskid) : void 0;
       const agentusage = usage.find((entry) => entry.agentid === agent.id);
-      return { id: agent.id, name: agent.name, role: agent.role, state: agent.state, depth: agent.depth, ...agent.tabid !== void 0 ? { tabid: agent.tabid } : {}, ...agent.sessionid !== void 0 ? { sessionid: agent.sessionid } : {}, ...agent.parentid !== void 0 ? { parentid: agent.parentid } : {}, registeredat: agent.registeredat, ...agent.heartbeatat !== void 0 ? { heartbeatat: agent.heartbeatat } : {}, ...agent.budget !== void 0 ? { budget: agent.budget } : {}, ...agent.scope !== void 0 ? { scope: agent.scope } : {}, ...agentusage !== void 0 ? { usage: agentusage } : {}, ...task !== void 0 ? { currenttask: task.payload } : {}, unread: unreadcount(mailboxes, agent.id) };
+      const openreview = reviewrequests.find((request) => request.fromagentid === agent.id && (request.state === "open" || request.state === "acked"));
+      const receivedreview = reviews.find((review) => review.subjectagentid === agent.id);
+      const arrows = handoffs.filter((record2) => record2.fromagentid === agent.id || record2.toagentid === agent.id).map((record2) => `${record2.fromagentid}\u2192${record2.toagentid}`);
+      return { id: agent.id, name: agent.name, role: agent.role, state: agent.state, depth: agent.depth, ...agent.tabid !== void 0 ? { tabid: agent.tabid } : {}, ...agent.sessionid !== void 0 ? { sessionid: agent.sessionid } : {}, ...agent.parentid !== void 0 ? { parentid: agent.parentid } : {}, registeredat: agent.registeredat, ...agent.heartbeatat !== void 0 ? { heartbeatat: agent.heartbeatat } : {}, ...agent.budget !== void 0 ? { budget: agent.budget } : {}, ...agent.scope !== void 0 ? { scope: agent.scope } : {}, ...agentusage !== void 0 ? { usage: agentusage } : {}, ...task !== void 0 ? { currenttask: task.payload } : {}, unread: unreadcount(mailboxes, agent.id), ...openreview !== void 0 ? { reviewstatus: `awaiting the review of ${openreview.toagentid}` } : receivedreview !== void 0 ? { reviewstatus: `last critic verdict ${receivedreview.verdict}` } : {}, handoffarrows: [...new Set(arrows)] };
     }),
     queue: { lanes: queue.lanes, priorities: queue.priorities, completionpolicy: queue.completionpolicy, items: queue.items, claims: queue.claims, lanesreport: lanereport(queue), counts: taskcounts(queue), complete: queuecomplete(queue) },
     mailboxes: mailboxes.map((mailbox) => ({ agentid: mailbox.agentid, unread: mailbox.unread, inbox: mailbox.inbox, outbox: mailbox.outbox })),
     blackboard: { sections: boardsummary(board, now), entries: readentries({ board, now }) },
     spawns: await memory.getspawnrecords(),
     events: await memory.getagentevents(),
-    killswitch
+    killswitch,
+    ...topology !== void 0 ? { topology } : {},
+    splits: await memory.getplannersplits(),
+    reviews,
+    verifications: await memory.getverifierchecks(),
+    reviewrequests,
+    handoffs,
+    locks: await memory.getlocks(),
+    conflicts: await memory.getconflictscans(),
+    ...report !== void 0 ? { report } : {},
+    board: boardstate({ agents, queue, ...topology !== void 0 ? { topology } : {}, now }),
+    escalations: await memory.getescalations(),
+    consensus: await memory.getconsensusrounds(),
+    timeline: interleavetimeline(await memory.getswarmtimeline()),
+    costs: await memory.getswarmcosts()
   };
 }
 async function llmstateof() {