@wenathlan/extension 1.1.58 → 1.1.59

package/dist/index.js

@@ -1908,6 +1908,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) {
@@ -4233,6 +4235,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";
@@ -4873,6 +4998,155 @@ function tlsstateof(tls) {
   return { mode: tls.mode, certificaterequired: tls.mode === "required" || tls.certificatefingerprint !== void 0, verified: tls.verifiedat !== void 0 };
 }
 
+// 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 tabid = input.tabid ?? from.tabid;
+  if (tabid === 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, 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, ...rest } = agent;
+      void tabid;
+      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 } : {} })));
+}
+
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
 var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -9855,7 +10129,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.58";
+var packageversion = "1.1.59";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10495,6 +10769,175 @@ function bumprevision(route, now) {
   return { ...route, revision: route.revision + 1, updatedat: now };
 }
 
+// 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
+  };
+}
+
 // promptlibrary.ts
 function templatevariables(body) {
   const names = [];
@@ -11367,6 +11810,48 @@ function swarmstatereport(state) {
 function agenteventframe(event) {
   return { jsonrpc: "2.0", method: "agents/notify", params: { eventid: event.id, kind: event.kind, ...event.agentid !== void 0 ? { agentid: event.agentid } : {}, ...event.taskid !== void 0 ? { taskid: event.taskid } : {}, summary: event.summary, at: event.at } };
 }
+function boardstatesnapshot(board) {
+  return {
+    version: protocolversion,
+    board: {
+      id: board.id,
+      builtat: board.builtat,
+      lanes: board.lanes.map((lane) => ({ agentid: lane.agentid, name: lane.name, role: lane.role, state: lane.state, lane: lane.lane, ...lane.currenttask !== void 0 ? { currenttask: lane.currenttask } : {}, milestones: lane.milestones.map((milestone) => ({ label: milestone.label, done: milestone.done, ...milestone.at !== void 0 ? { at: milestone.at } : {} })) }))
+    }
+  };
+}
+function handoffframe(record2) {
+  return {
+    jsonrpc: "2.0",
+    method: "agents/handoff",
+    params: {
+      id: record2.id,
+      from: record2.fromagentid,
+      to: record2.toagentid,
+      ...record2.tabid !== void 0 ? { tabid: record2.tabid } : {},
+      taskstate: record2.taskstate,
+      state: record2.state,
+      ...record2.transferredat !== void 0 ? { transferredat: record2.transferredat } : {},
+      ...record2.resumedat !== void 0 ? { resumedat: record2.resumedat } : {}
+    }
+  };
+}
+function reviewframe(input) {
+  return {
+    jsonrpc: "2.0",
+    method: "agents/review",
+    params: {
+      id: input.request.id,
+      from: input.request.fromagentid,
+      to: input.request.toagentid,
+      subject: input.request.subject,
+      state: input.request.state,
+      ...input.request.ackedat !== void 0 ? { ackedat: input.request.ackedat } : {},
+      ...input.request.answeredat !== void 0 ? { answeredat: input.request.answeredat } : {},
+      ...input.review !== void 0 ? { verdict: input.review.verdict, issues: input.review.issues, requiredchanges: input.review.requiredchanges } : {}
+    }
+  };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -12072,6 +12557,8 @@ function yamlscalarvalue(text2) {
   return text2;
 }
 export {
+  ackreview,
+  acquirelock,
   activelayers,
   addedge,
   addnode,
@@ -12099,14 +12586,17 @@ export {
   applylayer,
   applyoverride,
   applyretry,
+  applyreview,
   applyruntimeout,
   applytimeout,
   approvalframes,
   approvalprompt,
+  arbitrate,
   argkind,
   armrule,
   assetentries,
   assignrole,
+  assignwork,
   attachcdpsession,
   attachtargetof,
   attachtimeline,
@@ -12130,6 +12620,8 @@ export {
   blockingduration,
   blockinvocationof,
   blockruleof,
+  boardstate,
+  boardstatesnapshot,
   boardsummary,
   bodyfilterof,
   bodymatches,
@@ -12174,6 +12666,7 @@ export {
   capturestitched,
   capturetargets,
   capturevisible,
+  castvote,
   cdpallowlistof,
   cdpdomains,
   cdpeventruleof,
@@ -12183,6 +12676,7 @@ export {
   channeloptionsof,
   channelorigin,
   checkallowlist,
+  checkclaim,
   choosebranch,
   claim,
   claimheartbeat,
@@ -12190,12 +12684,15 @@ export {
   closechannel,
   closeidlechannels,
   collectmessages,
+  collectresults,
   commandguard,
+  compareoutputs,
   complete,
   composeworkflow,
   conditionof,
   confirmmanualrun,
   connectclient,
+  consensusstate,
   consolecapture,
   consoleconsentcovers,
   consolediff,
@@ -12259,6 +12756,7 @@ export {
   editorstate,
   editstep,
   egressconsentgate,
+  electleader,
   emptyboard,
   emptyqueue,
   emugate,
@@ -12273,6 +12771,7 @@ export {
   entryfresh,
   errorcapture,
   errorreportresponse,
+  escalate,
   evaluatecondition,
   evaluatetrigger,
   eventnotification,
@@ -12283,6 +12782,7 @@ export {
   expandtemplate,
   expireapprovals,
   expirelayers,
+  expirelocks,
   expireprofilerecords,
   expiresessions,
   expiretokens,
@@ -12322,6 +12822,7 @@ export {
   guardoutput,
   guardverdictgate,
   handleframe,
+  handoffframe,
   headerfilterof,
   headeruleof,
   heapintervalallowed,
@@ -12346,6 +12847,7 @@ export {
   inflightreport,
   inheritconsent,
   initialize,
+  interleavetimeline,
   iscdpkind,
   iscontrolflowkind,
   iscontrolkind,
@@ -12387,6 +12889,7 @@ export {
   locationconsentgate,
   locationpresetof,
   locationrangevalid,
+  lockkey,
   loglevels,
   longtaskcapture,
   loopof,
@@ -12404,6 +12907,7 @@ export {
   mediaentries,
   mediakinds,
   mediareport,
+  mergeresults,
   messageegressgrade,
   messagefilterof,
   methoddomain,
@@ -12440,6 +12944,7 @@ export {
   observationresponse,
   observeevents,
   openchannel,
+  openconsensus,
   openstreamchannel,
   opentabagent,
   outcomeresponse,
@@ -12485,11 +12990,13 @@ export {
   planallowlist,
   plandraftreviewgate,
   planlint,
+  plannersplit,
   pollcursorof,
   polldecision,
   pollurl,
   popscope,
   postentry,
+  preparehandoff,
   privatemime,
   profilegrantgranted,
   profilereport,
@@ -12538,6 +13045,7 @@ export {
   registeragent,
   rejectioncapture,
   relayframe,
+  releaselock,
   removeedge,
   removenode,
   removetemplate,
@@ -12548,14 +13056,18 @@ export {
   repeatuntilof,
   replannonfail,
   replanreviewgate,
+  replayagentrun,
   replaytrace,
   replayurl,
+  reportstep,
   requestbody,
+  requestreview,
   requeue,
   requireapproval,
   resolutionverdict,
   resolveapproval,
   resolvedrisk,
+  resolveescalation,
   resolverecipients,
   resolveroute,
   resolvetool,
@@ -12568,6 +13080,7 @@ export {
   restoreplanof,
   restorereviewgranted,
   resumeall,
+  resumehandoff,
   resumeone,
   retireentries,
   retireentry,
@@ -12577,6 +13090,7 @@ export {
   revertplanof,
   revertrule,
   reviewedkinds,
+  reviewframe,
   revocationruleof,
   revokeclient,
   rewritesourcelocation,
@@ -12611,6 +13125,8 @@ export {
   savetemplate,
   saveworkflow,
   scaledrect,
+  scaleworkers,
+  scanconflicts,
   schedulecron,
   scheduleinterval,
   scopecheck,
@@ -12644,6 +13160,7 @@ export {
   sessionrestoregate,
   sessiontabof,
   setvariable,
+  sharelesson,
   shareworkflow,
   shiftentryof,
   signalsreport,
@@ -12679,9 +13196,12 @@ export {
   submitreviewgranted,
   subscriptionframes,
   subscriptionoptionsof,
+  swarmcosts,
   swarmoverview,
+  swarmreport,
   swarmstateof,
   swarmstatereport,
+  sweepreviews,
   tabreportresponse,
   targetgate,
   taskcounts,
@@ -12726,6 +13246,7 @@ export {
   tracestart,
   tracetofile,
   trailreport,
+  transferhandoff,
   transformgrammar,
   triggereventcatalog,
   triggerfamilies,