@wenathlan/extension 1.1.58 → 1.1.60

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) {
@@ -2012,6 +2014,170 @@ function swarmstateof(input) {
   return { agents: input.agents, queue: input.queue, mailboxes: input.mailboxes, killswitch: input.killswitch };
 }
 
+// runstate.ts
+function openrun(input) {
+  if (input.runid.trim() === "" || input.sessionid.trim() === "") throw new Error("The run state needs its run and session ids.");
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The keepalive heartbeat interval stays a positive user value in milliseconds.");
+  return {
+    runid: input.runid,
+    sessionid: input.sessionid,
+    planid: input.planid,
+    profileid: input.profileid,
+    state: "active",
+    urlhistory: [],
+    environments: {},
+    turnarounds: {},
+    keepalive: { runid: input.runid, sessionid: input.sessionid, state: "active", startedat: input.now, interval: input.interval, beats: 0, lastbeatat: input.now, portopen: true, events: [{ kind: "start", at: input.now, detail: `The keepalive port opens for the run ${input.runid} and beats every ${input.interval} milliseconds.` }] },
+    updatedat: input.now
+  };
+}
+function beatrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run emits no heartbeat.`);
+  return {
+    ...state,
+    keepalive: { ...state.keepalive, beats: state.keepalive.beats + 1, lastbeatat: now, events: [...state.keepalive.events, { kind: "heartbeat", at: now }].slice(-200) },
+    updatedat: now
+  };
+}
+function closerun(state, now) {
+  if (state.keepalive.state === "stopped") throw new Error(`The run ${state.runid} already stopped its keepalive port.`);
+  return {
+    ...state,
+    state: "completed",
+    keepalive: { ...state.keepalive, state: "stopped", stoppedat: now, portopen: false, events: [...state.keepalive.events, { kind: "stop", at: now, detail: "The run reached a terminal state and the keepalive port closed." }].slice(-200) },
+    updatedat: now
+  };
+}
+function reattachrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run never reattaches.`);
+  return {
+    ...state,
+    state: "recovered",
+    keepalive: { ...state.keepalive, portopen: true, events: [...state.keepalive.events, { kind: "reattach", at: now, detail: "The service worker restarted and the keepalive port reattached from the persisted run state." }].slice(-200) },
+    updatedat: now
+  };
+}
+function recordurl(state, entry) {
+  if (entry.url.trim() === "") throw new Error("The url history entry needs its url.");
+  const record2 = { url: entry.url, stepid: entry.stepid, at: entry.now };
+  return { ...state, urlhistory: [...state.urlhistory.filter((item) => !(item.url === record2.url && item.stepid === record2.stepid)), record2], updatedat: entry.now };
+}
+function recordenvironment(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The environment record needs its step id.");
+  const provenance = { origin: input.origin, stepid: input.stepid, environment: input.environment };
+  return { ...state, environments: { ...state.environments, [input.stepid]: input.environment }, lastprovenance: provenance, updatedat: input.now };
+}
+function recordturnaround(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The turnaround record needs its step id.");
+  if (!Number.isFinite(input.milliseconds) || input.milliseconds < 0) throw new Error("The worker turnaround stays a non-negative duration in milliseconds.");
+  return { ...state, turnarounds: { ...state.turnarounds, [input.stepid]: input.milliseconds }, updatedat: input.now };
+}
+function markpending(state, stepid, now) {
+  return { ...state, ...stepid !== void 0 && stepid.trim() !== "" ? { pendingstepid: stepid } : {}, updatedat: now };
+}
+function recoveryplan(state) {
+  if (state.state === "completed") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} completed before the restart; nothing resumes.` };
+  if (state.state === "reaped") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} was reaped as a zombie; the user starts a fresh reviewed run.` };
+  if (state.pendingstepid === void 0 || state.pendingstepid.trim() === "") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} carries no pending step; a fresh reviewed run starts over instead of guessing.` };
+  return { runid: state.runid, pendingstepid: state.pendingstepid, recoverable: true, reason: `The executor resumes the pending step ${state.pendingstepid} of the run ${state.runid} from the persisted run state.` };
+}
+function zombiesweep(input) {
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The zombie sweep needs its heartbeat interval as a positive user value.");
+  if (!Number.isInteger(input.missedlimit) || input.missedlimit < 1) throw new Error("The zombie tolerance stays a positive whole number of silent intervals.");
+  const silentfor = input.interval * input.missedlimit;
+  const zombies = input.states.filter((state) => state.keepalive.state === "active" && input.now - state.keepalive.lastbeatat > silentfor);
+  if (zombies.length === 0) return { states: input.states, reaped: [] };
+  const ids = new Set(zombies.map((state) => state.runid));
+  return { states: input.states.map((state) => ids.has(state.runid) ? { ...state, state: "reaped", keepalive: { ...state.keepalive, state: "stopped", portopen: false, ...state.keepalive.stoppedat === void 0 ? { stoppedat: input.now } : {}, events: [...state.keepalive.events, { kind: "stop", at: input.now, detail: "The zombie reaper closed the silent run." }] } } : state), reaped: [...ids] };
+}
+function acquirerunlock(input) {
+  if (input.sessionid.trim() === "" || input.runid.trim() === "") throw new Error("The run lock needs its session and run ids.");
+  const live = input.locks.filter((lock2) => lock2.sessionid === input.sessionid && (lock2.expiresat === void 0 || lock2.expiresat > input.now));
+  const held = live.find((lock2) => lock2.runid !== input.runid);
+  if (held) return { locks: input.locks, acquired: false, reason: `The session ${input.sessionid} already holds the run ${held.runid}; a session never carries two concurrent runs.` };
+  const own = input.locks.find((lock2) => lock2.sessionid === input.sessionid && lock2.runid === input.runid);
+  if (own) return { locks: input.locks, acquired: true, reason: `The run ${input.runid} of the session ${input.sessionid} already holds its lock.` };
+  const lock = { sessionid: input.sessionid, runid: input.runid, holder: input.holder, acquiredat: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+  return { locks: [...input.locks.filter((entry) => entry.sessionid !== input.sessionid), lock], acquired: true, reason: `The run ${input.runid} locked the session ${input.sessionid} against concurrent runs.` };
+}
+function releaserunlock(input) {
+  const lock = input.locks.find((entry) => entry.sessionid === input.sessionid);
+  if (!lock || lock.runid !== input.runid) return { locks: input.locks, released: false, reason: `The run ${input.runid} holds no lock of the session ${input.sessionid}.` };
+  return { locks: input.locks.filter((entry) => entry.sessionid !== input.sessionid), released: true, reason: `The run ${input.runid} released the run lock of the session ${input.sessionid}.` };
+}
+function expirerunlocks(locks, now) {
+  const expired = locks.filter((lock) => lock.expiresat !== void 0 && now > lock.expiresat);
+  if (expired.length === 0) return { locks, expired: [] };
+  const ids = new Set(expired.map((lock) => lock.sessionid));
+  return { locks: locks.filter((lock) => !ids.has(lock.sessionid)), expired: [...ids] };
+}
+function serializesteps(input) {
+  const shared = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  for (const branch of input.branches) for (const step of branch.steps) counts.set(step.tabid, (counts.get(step.tabid) ?? 0) + 1);
+  for (const [tabid, count] of counts) if (count > 1) shared.add(tabid);
+  const order = [];
+  let cursor = 0;
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (!shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  return order;
+}
+async function sealrunstate(state) {
+  const payload = JSON.stringify(state);
+  const digest = await sha256(payload);
+  return { payload, algorithm: "sha-256", digest, sealedat: state.updatedat };
+}
+async function openseal(sealed) {
+  const digest = await sha256(sealed.payload);
+  if (digest !== sealed.digest) throw new Error("The sealed run state fails its integrity digest; a tampered run state never reaches the recovery.");
+  const parsed = JSON.parse(sealed.payload);
+  if (typeof parsed.runid !== "string" || typeof parsed.sessionid !== "string") throw new Error("The sealed run state carries no run record.");
+  return parsed;
+}
+async function sha256(value) {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function prunerunstates(input) {
+  if (!Number.isFinite(input.ceiling) || input.ceiling <= 0) return { states: input.states, pruned: [], reason: "No storage ceiling is configured, so the run states stay under the user choice alone." };
+  if (input.used <= input.ceiling) return { states: input.states, pruned: [], reason: `The run state storage sits at ${input.used} of the ${input.ceiling} bytes the user configured; no pressure exists.` };
+  const removable = input.states.filter((state) => state.state === "completed" || state.state === "reaped").sort((one, two) => one.updatedat - two.updatedat);
+  const states = [...input.states];
+  const pruned = [];
+  for (const candidate of removable) {
+    pruned.push(candidate.runid);
+    const index = states.findIndex((state) => state.runid === candidate.runid);
+    if (index >= 0) states.splice(index, 1);
+    if (pruned.length >= Math.max(1, Math.ceil(input.states.length / 2))) break;
+  }
+  return { states, pruned, reason: `The storage pressure at ${input.used} of ${input.ceiling} bytes pruned the ${pruned.length} oldest finished run state${pruned.length === 1 ? "" : "s"} while every active run keeps its state.` };
+}
+function exportrunstate(states, now) {
+  return {
+    runs: states.length,
+    urls: states.reduce((total, state) => total + state.urlhistory.length, 0),
+    environments: states.reduce((total, state) => total + Object.keys(state.environments).length, 0),
+    offloaded: states.reduce((total, state) => total + Object.values(state.turnarounds).length, 0),
+    beats: states.reduce((total, state) => total + state.keepalive.beats, 0),
+    exportedat: now
+  };
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -4233,6 +4399,244 @@ 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") ?? [];
+  }
+  /**
+   * Execution environment persistence of the 1.1.60 family.
+   * The run state store seals every persisted run state with its sha-256 integrity digest through the storage api (the browser offers no at-rest encryption for its storage areas, so the honest derivation is the integrity seal that makes tampering detectable before any recovery uses the record), scopes every run state per profile so parallel profiles never share it, expires stale run state past the user configured window while the keepalive summaries survive, tracks the storage quota usage of the run state and prunes the oldest finished run states under pressure.
+   * The adapter seam keeps every accessor a one line storage delegation so a future worker state backend replaces the adapter only.
+   */
+  /** Returns the environment grant list of the active session; an absent list keeps the documented default posture. */
+  async getenvironmentgrants() {
+    return (await this.getsession())?.environmentgrants;
+  }
+  /** Replaces the environment grant list of the active session so the environment grants join the origin grants in the session record. */
+  async setenvironmentgrants(grants) {
+    const session = await this.getsession();
+    if (!session) throw new Error("The environment grants need an active session to join.");
+    await this.setsession({ ...session, environmentgrants: grants });
+  }
+  /** Seals and stores the run state of one profile: the payload travels beside its sha-256 digest so a tampered record at rest stays detectable before any recovery uses it. */
+  async setrunstate(profileid, state) {
+    const sealed = await sealrunstate(state);
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set(`runstate:${profileid}`, sealed);
+    if (!index.includes(profileid)) await this.adapter.set("runstateindex", [...index, profileid]);
+  }
+  /** Opens the sealed run state of one profile; a missing or tampered seal returns undefined so the recovery never trusts a broken record. */
+  async getrunstate(profileid) {
+    const sealed = await this.adapter.get(`runstate:${profileid}`);
+    if (!sealed) return void 0;
+    try {
+      return await openseal(sealed);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Removes the run state of one profile from the store and the index: the per profile key takes an empty seal that never opens, so the quota pruning drops the pruned records whole. */
+  async removerunstate(profileid) {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set("runstateindex", index.filter((entry) => entry !== profileid));
+    await this.adapter.set(`runstate:${profileid}`, { payload: "", algorithm: "sha-256", digest: "", sealedat: 0 });
+  }
+  /** Lists the stored run state records of every profile, oldest update first. */
+  async listrunstates() {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const states = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (state) states.push(state);
+    }
+    return states.sort((one, two) => one.updatedat - two.updatedat);
+  }
+  /** Expires the stale run states past the user configured window: the expired records reduce to their keepalive summaries while an absent window keeps every run state whole. */
+  async expirerunstates(window, now) {
+    if (window === void 0) return await this.listrunstates();
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const kept = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (!state) continue;
+      if (now - state.updatedat > window && state.keepalive.state === "stopped") {
+        const summary = { runid: state.runid, sessionid: state.sessionid, planid: state.planid, profileid: state.profileid, state: "expired", urlhistory: [], environments: {}, turnarounds: {}, keepalive: state.keepalive, updatedat: now };
+        const sealed = await sealrunstate(summary);
+        await this.adapter.set(`runstate:${profileid}`, sealed);
+      } else {
+        kept.push(state);
+      }
+    }
+    return kept;
+  }
+  /** Records one worker spawn or teardown event with its provenance beside the step outcomes. */
+  async addworkerevent(event) {
+    await this.adapter.set("workerevents", [event, ...await this.adapter.get("workerevents") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded worker spawn and teardown events, newest first. */
+  async getworkerevents() {
+    return await this.adapter.get("workerevents") ?? [];
+  }
+  /** Records one spawned offscreen document with its reasons and justification in the registry. */
+  async addoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", [entry, ...await this.adapter.get("offscreenregistry") ?? []]);
+  }
+  /** Replaces one registry entry after its offscreen document closes. */
+  async updateoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", (await this.adapter.get("offscreenregistry") ?? []).map((candidate) => candidate.runid === entry.runid ? entry : candidate));
+  }
+  /** Returns the offscreen document registry with the reasons and justification of every spawn. */
+  async getoffscreenentries() {
+    return await this.adapter.get("offscreenregistry") ?? [];
+  }
+  /** Records one sandbox render with its provenance, source origin and nonce. */
+  async addsandboxrender(render) {
+    await this.adapter.set("sandboxrenders", [render, ...await this.adapter.get("sandboxrenders") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded sandbox renders with their provenance, newest first. */
+  async getsandboxrenders() {
+    return await this.adapter.get("sandboxrenders") ?? [];
+  }
+  /** Replaces the stored run locks after one acquisition, release or expiry sweep. */
+  async setrunlocks(locks) {
+    return this.adapter.set("runlocks", locks);
+  }
+  /** Returns the held run locks with their sessions, runs and expiries. */
+  async getrunlocks() {
+    return await this.adapter.get("runlocks") ?? [];
+  }
+  /** Tracks the storage quota usage of the run state: the last measured bytes stay beside the user configured ceiling so the pruning reads both. */
+  async trackrunstatequota(used) {
+    const settings = await this.getsettings();
+    await this.adapter.set("runstatequota", { used, ...settings?.runstatebytes !== void 0 ? { ceiling: settings.runstatebytes } : {}, trackedat: Date.now() });
+  }
+  /** Returns the last tracked storage quota usage of the run state with its ceiling when the user configured one. */
+  async getrunstatequota() {
+    return this.adapter.get("runstatequota");
+  }
+  /** Exports every stored run state as one single audit record through the runstate export envelope. */
+  async exportrunstates() {
+    return exportrunstate(await this.listrunstates(), Date.now());
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -4873,6 +5277,282 @@ 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 } : {} })));
+}
+
+// environments.ts
+var offloadfamilies = [
+  { task: "htmlsnapshot", kinds: ["readhtml", "parsehtml", "readertree", "readoutline", "classifypage"] },
+  { task: "jsonpayload", kinds: ["readjson", "parsejson"] },
+  { task: "tablerows", kinds: ["readtable", "scrapetable", "detecttables", "deduperows", "transformvalues"] },
+  { task: "a11ytree", kinds: ["a11ytree"] },
+  { task: "complexselector", kinds: ["resolvexpath", "deriveselector", "detectvirtual"] },
+  { task: "stitchshots", kinds: ["contactsheet", "timelapse", "makethumbs"] }
+];
+function offfamilyof(kind) {
+  return offloadfamilies.find((family) => family.kinds.includes(kind))?.task;
+}
+function environmentsof(step) {
+  if (markuprenderstep(step)) return ["sandboxframe"];
+  if (step.kind === "evaluate") return ["isolatedworld"];
+  if (offfamilyof(step.kind) !== void 0) return ["pagecontext", "offscreenworker"];
+  return ["pagecontext"];
+}
+function defaultenvironment(step) {
+  if (markuprenderstep(step)) return "sandboxframe";
+  if (step.kind === "evaluate") return "isolatedworld";
+  return "pagecontext";
+}
+function offamilyeligible(kind) {
+  return offloadfamilies.some((family) => family.kinds.includes(kind));
+}
+function offloadkinds() {
+  return offloadfamilies.map((family) => ({ task: family.task, kinds: [...family.kinds] }));
+}
+function markuprenderstep(step) {
+  if (!step.options) return false;
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.markup === "string" && parsed.markup.trim() !== "");
+  } catch {
+    return false;
+  }
+}
+function environmentrequirementsof(kinds) {
+  return kinds.map((kind) => {
+    const bare = { kind };
+    const environments = environmentsof(bare);
+    return { kind, environments, defaultenvironment: defaultenvironment(bare) };
+  });
+}
+function executorregistry() {
+  return [
+    { environment: "pagecontext", adapter: "pagebridge", description: "The page bridge executes dom actions inside the live page because page events only fire there." },
+    { environment: "isolatedworld", adapter: "scriptingapi", description: "The scripting api injects step logic inside the isolated world where page globals stay unreachable from step code." },
+    { environment: "offscreenworker", adapter: "offscreendocument", description: "The offscreen document hosts the worker pool that parses heavy payloads away from the page; the capability gate keeps it behind the optional offscreen grant with an inline fallback." },
+    { environment: "sandboxframe", adapter: "sandboxpage", description: "The sandboxed page renders untrusted markup with scripts and handlers stripped before render and posts its result back through a per render nonce." }
+  ];
+}
+function routeenvironment(step, input) {
+  const allowed = environmentsof(step);
+  const named = step.environment;
+  if (named !== void 0) {
+    if (!allowed.includes(named)) return { environment: defaultenvironment(step), fallback: false, reason: `The ${named} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits, so the executor routes to the ${defaultenvironment(step)} default.` };
+    return { environment: named, fallback: false, reason: `The reviewed step names its ${named} environment and the ${step.kind} kind permits it.` };
+  }
+  if (markuprenderstep(step)) return { environment: "sandboxframe", fallback: false, reason: `The ${step.kind} step carries untrusted markup, so it renders inside the sandboxframe only.` };
+  if (step.kind === "evaluate") return { environment: "isolatedworld", fallback: false, reason: "The evaluate kind runs inside the isolated world where page globals stay unreachable from step code." };
+  if (offamilyeligible(step.kind)) {
+    if (!input.offload) return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step stays inside the page because the user keeps the parse offload off.` };
+    if (!input.granted) return { environment: "pagecontext", fallback: true, reason: `The ${step.kind} step falls back to inline parsing inside the page because the offscreen capability grant stays absent.` };
+    return { environment: "offscreenworker", fallback: false, reason: `The ${step.kind} step offloads into the offscreen worker pool under the granted capability.` };
+  }
+  return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step keeps the pagecontext because page events only fire inside the live page.` };
+}
+function workerrequestof(input) {
+  const task = offfamilyof(input.kind);
+  if (task === void 0) throw new Error(`The ${input.kind} kind stays outside the offscreen worker pool families.`);
+  if (input.payload.trim() === "") throw new Error("The worker request needs its payload reference.");
+  return { id: input.id, runid: input.runid, stepid: input.stepid, task, payload: input.payload, transferables: transferablekeys(input.options ?? {}), sentat: input.sentat };
+}
+function transferablekeys(options) {
+  return Object.keys(options).filter((key) => options[key] instanceof ArrayBuffer);
+}
+function workerresponseof(input) {
+  if (input.summary.trim() === "") throw new Error("The worker answer needs its summary in plain language.");
+  return { id: input.id, requestid: input.requestid, ok: input.ok, ...input.result !== void 0 ? { result: input.result } : {}, ...input.partial !== void 0 ? { partial: input.partial } : {}, summary: input.summary, receivedat: input.receivedat };
+}
+function acceptworkerresponse(response) {
+  if (!response.ok) return { done: true, partial: false, reason: `The worker refused the request ${response.requestid}: ${response.summary}` };
+  if (response.partial !== void 0) return { done: false, partial: true, reason: `The partial ${response.partial} of the request ${response.requestid} streams back to the executor.` };
+  return { done: true, partial: false, ...response.result !== void 0 ? { result: response.result } : {}, reason: `The request ${response.requestid} completed inside the offscreen worker pool.` };
+}
+function poolplan(input) {
+  if (input.size !== void 0) {
+    if (!Number.isFinite(input.size) || input.size < 1 || !Number.isInteger(input.size)) return { workers: input.current, added: 0, retired: 0, reason: "The configured pool size stays a positive whole number the user chose; the pool keeps its current workers." };
+    const target = input.size;
+    if (target > input.current) return { workers: target, added: target - input.current, retired: 0, reason: `The user configured pool size ${target} adds ${target - input.current} worker${target - input.current === 1 ? "" : "s"} to the pool.` };
+    if (target < input.current) return { workers: target, added: 0, retired: input.current - target, reason: `The user configured pool size ${target} retires ${input.current - target} worker${input.current - target === 1 ? "" : "s"} from the pool.` };
+    return { workers: target, added: 0, retired: 0, reason: `The pool holds the ${target} workers the user configured.` };
+  }
+  if (input.pending > input.current) return { workers: input.pending, added: input.pending - input.current, retired: 0, reason: `The ${input.pending} pending parses grow the pool by ${input.pending - input.current} worker${input.pending - input.current === 1 ? "" : "s"}; no engine cap exists.` };
+  if (input.current > input.pending) return { workers: input.pending, added: 0, retired: input.current - input.pending, reason: `The ${input.current - input.pending} idle worker${input.current - input.pending === 1 ? "" : "s"} retire down to the ${input.pending} pending parse${input.pending === 1 ? "" : "s"}.` };
+  return { workers: input.current, added: 0, retired: 0, reason: `The ${input.current} workers match the ${input.pending} pending parses; the pool stays unchanged.` };
+}
+function openoffscreen(input) {
+  if (input.document.trim() === "") throw new Error("The offscreen document needs its user configured path.");
+  if (input.reasons.length === 0) throw new Error("The offscreen document needs the reasons the user reviewed.");
+  if (input.justification.trim() === "") throw new Error("The offscreen document needs its justification in plain language.");
+  const open = input.registry.find((entry2) => entry2.runid === input.runid && entry2.closedat === void 0);
+  if (open) return { registry: input.registry, entry: open, reused: true };
+  const entry = { document: input.document, runid: input.runid, reasons: [...input.reasons], justification: input.justification, createdat: input.now };
+  return { registry: [entry, ...input.registry], entry, reused: false };
+}
+function closeoffscreen(registry, runid, now) {
+  const open = registry.find((entry) => entry.runid === runid && entry.closedat === void 0);
+  if (!open) return { registry, closed: false };
+  return { registry: registry.map((entry) => entry === open ? { ...entry, closedat: now } : entry), closed: true };
+}
+function isolatedinjection(step) {
+  if (step.kind !== "evaluate") throw new Error("The isolated world injection serves the evaluate kind only.");
+  if (!step.value || step.value.trim() === "") throw new Error("The evaluate step needs its reviewed expression.");
+  let args = [];
+  if (step.options) {
+    try {
+      const parsed = JSON.parse(step.options);
+      if (Array.isArray(parsed)) args = parsed.filter((item) => typeof item === "string");
+    } catch {
+    }
+  }
+  return { world: "ISOLATED", code: step.value, args };
+}
+
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
 var redirectstatuses = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -9495,6 +10175,48 @@ 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 stepenvironmentvalid(step) {
+  if (step.environment !== void 0 && step.environment !== "pagecontext" && step.environment !== "isolatedworld" && step.environment !== "offscreenworker" && step.environment !== "sandboxframe") return { allowed: false, reason: "The step environment stays one of pagecontext, isolatedworld, offscreenworker and sandboxframe." };
+  const allowed = environmentsof(step);
+  if (step.environment !== void 0 && !allowed.includes(step.environment)) return { allowed: false, reason: `The ${step.environment} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits; the review sees the environment of every step.` };
+  return { allowed: true, reason: step.environment === void 0 ? `The ${step.kind} step carries no environment field and routes to its ${defaultenvironment(step)} default.` : `The ${step.environment} environment of the ${step.kind} step sits inside the ${allowed.join(", ")} the kind permits.` };
+}
+function environmentgrantgate(step, grants) {
+  if (grants === void 0 || grants.length === 0) return { allowed: true, reason: `The session carries no environment grant list, so the ${defaultenvironment(step)} default of the ${step.kind} step stays the documented posture behind the same review.` };
+  const environment = step.environment ?? defaultenvironment(step);
+  if (!grants.includes(environment)) return { allowed: false, reason: `The ${environment} environment sits outside the ${grants.join(", ")} the session granted; no step ever widens the environment grants.` };
+  return { allowed: true, reason: `The ${environment} environment of the ${step.kind} step sits inside the ${grants.join(", ")} the session granted.` };
+}
+function offscreencapabilitygate(input) {
+  if (input.environment !== "offscreenworker") return { allowed: true, reason: `The ${input.environment} environment needs no offscreen capability grant.` };
+  if (!input.granted) return { allowed: false, reason: "The offscreen worker pool runs only under the user granted offscreen capability; the step falls back to inline parsing inside the page." };
+  return { allowed: true, reason: "The offscreen worker pool runs under the user granted offscreen capability." };
+}
+function keepalivegate(input) {
+  if (!input.session) return { allowed: false, reason: "The keepalive port opens only inside an active session." };
+  if (input.session.stoppedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed for a stopped session." };
+  if (input.session.pausedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed while the session pauses; a resumed run reattaches it." };
+  if (input.now > input.session.expiresat) return { allowed: false, reason: "The keepalive port stays closed for an expired session." };
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "The keepalive port opens only behind an active reviewed plan; unreviewed work never holds the service worker alive." };
+  return { allowed: true, reason: `The approved plan ${input.plan.id} of the active session holds the keepalive port open for its whole run.` };
+}
+function keepaliveintervalvalid(interval) {
+  if (!Number.isFinite(interval) || interval <= 0) return { allowed: false, reason: "The keepalive heartbeat interval stays a positive user value in milliseconds." };
+  return { allowed: true, reason: `The keepalive heartbeat interval ${interval} milliseconds stays the user configured value; the roadmap documents thirty seconds while the choice stays the user's.` };
+}
+function workerpoolsizevalid(size) {
+  if (size === void 0) return { allowed: true, reason: "No worker pool size is configured, so the pool follows the pending parse queue alone with no engine cap." };
+  if (!Number.isInteger(size) || size < 1) return { allowed: false, reason: "The worker pool size stays a positive whole number the user configured; no engine cap exists." };
+  return { allowed: true, reason: `The worker pool size ${size} stays the user configured value; no engine cap exists.` };
+}
+function sandboxorigingate(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The sandbox render needs the source origin of its untrusted markup." };
+  if (input.allowed.length > 0 && !input.allowed.includes(input.origin)) return { allowed: false, reason: `The origin ${input.origin} sits outside the origins the user allows to render untrusted markup: ${input.allowed.join(", ")}.` };
+  return { allowed: true, reason: input.allowed.length === 0 ? `The origin ${input.origin} renders untrusted markup under the documented open origin list the user chose not to narrow.` : `The origin ${input.origin} sits inside the origins the user allows to render untrusted markup.` };
+}
+function environmentrequirements() {
+  return environmentrequirementsof([...allowedactions]);
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -9855,7 +10577,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.58";
+var packageversion = "1.1.60";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10495,6 +11217,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 = [];
@@ -10537,6 +11428,44 @@ function removetemplate(templates, name) {
   return templates.filter((template) => template.name !== name);
 }
 
+// sandboxframe.ts
+function stripscripts(markup) {
+  return markup.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\/>/gi, "").replace(/\son[a-z]+\s*=\s*"[^"]*"/gi, "").replace(/\son[a-z]+\s*=\s*'[^']*'/gi, "").replace(/\son[a-z]+\s*=\s*[^\s>]+/gi, "").replace(/javascript:/gi, "").trim();
+}
+function nonceof(seed) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let hash = 0;
+  for (let index = 0; index < seed.length; index += 1) hash = hash * 31 + seed.charCodeAt(index) >>> 0;
+  let nonce = "";
+  let state = hash === 0 ? 2654435769 : hash;
+  for (let index = 0; index < 16; index += 1) {
+    state = state * 1664525 + 1013904223 >>> 0;
+    nonce += alphabet[state % alphabet.length];
+  }
+  return nonce;
+}
+function sandboxrenderof(input) {
+  if (input.markup.trim() === "") throw new Error("The sandbox render needs its untrusted markup.");
+  if (input.sourceorigin.trim() === "") throw new Error("The sandbox render needs the source origin of its untrusted markup.");
+  if (input.stepid.trim() === "") throw new Error("The sandbox render names the reviewed step it renders for.");
+  return { id: input.id, nonce: nonceof(`${input.id}:${input.now}`), markup: stripscripts(input.markup), sourceorigin: input.sourceorigin, stepid: input.stepid, renderedat: input.now };
+}
+function rendermessage(render) {
+  return { channel: "devthinksandbox", type: "render", nonce: render.nonce, markup: render.markup };
+}
+function acceptrenderresult(input) {
+  if (input.message.channel !== "devthinksandbox") return { accepted: false, reason: "The sandbox message travels the devthinksandbox channel only." };
+  if (input.message.type !== "renderresult") return { accepted: false, reason: "The sandbox message answers with the renderresult type only." };
+  const render = input.renders.find((entry) => entry.nonce === input.message.nonce && entry.renderedat <= input.now);
+  if (!render) return { accepted: false, reason: "The sandbox message carries no nonce of a known render; a stale or replayed message never passes." };
+  const text2 = (input.message.text ?? "").replace(/<[^>]*>/g, "");
+  const result = { nonce: render.nonce, ok: input.message.ok !== false, text: text2, summary: input.message.summary?.trim() || `The sandbox frame rendered the markup of the step ${render.stepid} and returned its inert text.`, at: input.now };
+  return { accepted: true, result, reason: `The render result of the step ${render.stepid} answers the nonce of its render; the text stays inside the frame.` };
+}
+function renderprovenance(render) {
+  return { origin: render.sourceorigin, stepid: render.stepid, environment: "sandboxframe" };
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -11367,6 +12296,70 @@ 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 } : {}
+    }
+  };
+}
+function environmentgrammar() {
+  return {
+    version: protocolversion,
+    kinds: environmentrequirements(),
+    notes: [
+      "The evaluate kind runs inside the isolated world only where page globals stay unreachable from step code.",
+      "A step whose reviewed options carry untrusted markup renders inside the sandboxframe only, with scripts and event handlers stripped before the render.",
+      "The parse heavy read kinds offload into the offscreen worker pool only under the user granted offscreen capability and the parse offload toggle, with an inline fallback inside the page.",
+      "Every environment executes only reviewed steps against granted origins; the session environment grant list narrows the steps of one session and no environment ever bypasses the human review."
+    ]
+  };
+}
+function environmentreport(input) {
+  return {
+    version: protocolversion,
+    environments: Object.entries(input.environments).map(([stepid, environment]) => ({ stepid, environment })),
+    turnarounds: Object.entries(input.turnarounds ?? {}).map(([stepid, milliseconds]) => ({ stepid, milliseconds })),
+    offscreen: input.offscreen ?? [],
+    workers: input.workers ?? 0,
+    ...input.keepalive !== void 0 ? { keepalive: input.keepalive } : {}
+  };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -12072,6 +13065,11 @@ function yamlscalarvalue(text2) {
   return text2;
 }
 export {
+  acceptrenderresult,
+  acceptworkerresponse,
+  ackreview,
+  acquirelock,
+  acquirerunlock,
   activelayers,
   addedge,
   addnode,
@@ -12099,14 +13097,17 @@ export {
   applylayer,
   applyoverride,
   applyretry,
+  applyreview,
   applyruntimeout,
   applytimeout,
   approvalframes,
   approvalprompt,
+  arbitrate,
   argkind,
   armrule,
   assetentries,
   assignrole,
+  assignwork,
   attachcdpsession,
   attachtargetof,
   attachtimeline,
@@ -12117,6 +13118,7 @@ export {
   autointervalof,
   backoffdelay,
   batchreport,
+  beatrun,
   bindlocalhost,
   bindparam,
   bindvariables,
@@ -12130,6 +13132,8 @@ export {
   blockingduration,
   blockinvocationof,
   blockruleof,
+  boardstate,
+  boardstatesnapshot,
   boardsummary,
   bodyfilterof,
   bodymatches,
@@ -12174,6 +13178,7 @@ export {
   capturestitched,
   capturetargets,
   capturevisible,
+  castvote,
   cdpallowlistof,
   cdpdomains,
   cdpeventruleof,
@@ -12183,19 +13188,25 @@ export {
   channeloptionsof,
   channelorigin,
   checkallowlist,
+  checkclaim,
   choosebranch,
   claim,
   claimheartbeat,
   classifyintent,
   closechannel,
   closeidlechannels,
+  closeoffscreen,
+  closerun,
   collectmessages,
+  collectresults,
   commandguard,
+  compareoutputs,
   complete,
   composeworkflow,
   conditionof,
   confirmmanualrun,
   connectclient,
+  consensusstate,
   consolecapture,
   consoleconsentcovers,
   consolediff,
@@ -12227,6 +13238,7 @@ export {
   dedupeimages,
   defaultapprovalwindowms,
   defaultchallengelifetimems,
+  defaultenvironment,
   defaultheartbeatms,
   defaulthttpstream,
   defaultidlewindowms,
@@ -12259,6 +13271,7 @@ export {
   editorstate,
   editstep,
   egressconsentgate,
+  electleader,
   emptyboard,
   emptyqueue,
   emugate,
@@ -12271,23 +13284,34 @@ export {
   enqueue,
   enqueuerequest,
   entryfresh,
+  environmentgrammar,
+  environmentgrantgate,
+  environmentreport,
+  environmentrequirements,
+  environmentrequirementsof,
+  environmentsof,
   errorcapture,
   errorreportresponse,
+  escalate,
   evaluatecondition,
   evaluatetrigger,
   eventnotification,
   eventresponse,
   eventrulematches,
   exchangesreport,
+  executorregistry,
   expandblocks,
   expandtemplate,
   expireapprovals,
   expirelayers,
+  expirelocks,
   expireprofilerecords,
+  expirerunlocks,
   expiresessions,
   expiretokens,
   exportcontentreview,
   exportpresetlibrary,
+  exportrunstate,
   exportsessionfile,
   exportworkflow,
   expressioneval,
@@ -12322,6 +13346,7 @@ export {
   guardoutput,
   guardverdictgate,
   handleframe,
+  handoffframe,
   headerfilterof,
   headeruleof,
   heapintervalallowed,
@@ -12346,6 +13371,7 @@ export {
   inflightreport,
   inheritconsent,
   initialize,
+  interleavetimeline,
   iscdpkind,
   iscontrolflowkind,
   iscontrolkind,
@@ -12354,6 +13380,7 @@ export {
   isformkind,
   islocalorigin,
   isnetwatchkind,
+  isolatedinjection,
   isprofilekind,
   issessionkind,
   issocketkind,
@@ -12366,6 +13393,8 @@ export {
   isworkflowkind,
   joinbranches,
   jsonpathrulesof,
+  keepalivegate,
+  keepaliveintervalvalid,
   killall,
   killswitchgate,
   lanereport,
@@ -12387,6 +13416,7 @@ export {
   locationconsentgate,
   locationpresetof,
   locationrangevalid,
+  lockkey,
   loglevels,
   longtaskcapture,
   loopof,
@@ -12396,7 +13426,9 @@ export {
   mapresponse,
   mapurlof,
   markbreakpoint,
+  markpending,
   markprovider,
+  markuprenderstep,
   matchmessage,
   matchurl,
   matchurlpattern,
@@ -12404,6 +13436,7 @@ export {
   mediaentries,
   mediakinds,
   mediareport,
+  mergeresults,
   messageegressgrade,
   messagefilterof,
   methoddomain,
@@ -12434,12 +13467,20 @@ export {
   newsessionrecord,
   newworkflowrun,
   nextrequest,
+  nonceof,
   normalizeendpoint,
   oauthflowof,
   observationmodeof,
   observationresponse,
   observeevents,
+  offfamilyof,
+  offloadkinds,
+  offscreencapabilitygate,
   openchannel,
+  openconsensus,
+  openoffscreen,
+  openrun,
+  openseal,
   openstreamchannel,
   opentabagent,
   outcomeresponse,
@@ -12485,11 +13526,14 @@ export {
   planallowlist,
   plandraftreviewgate,
   planlint,
+  plannersplit,
   pollcursorof,
   polldecision,
   pollurl,
+  poolplan,
   popscope,
   postentry,
+  preparehandoff,
   privatemime,
   profilegrantgranted,
   profilereport,
@@ -12504,6 +13548,7 @@ export {
   providervalid,
   proxygate,
   proxyrouteof,
+  prunerunstates,
   publishmessage,
   pushscope,
   quarantinereport,
@@ -12519,12 +13564,17 @@ export {
   readentries,
   readpath,
   readstream,
+  reattachrun,
   receivemessage,
   receivemessages,
   reconnectwaits,
   recordagentusage,
+  recordenvironment,
   recordingoptionsof,
+  recordturnaround,
+  recordurl,
   recordwatchvalue,
+  recoveryplan,
   redactconsoletext,
   redactedcookies,
   redactparams,
@@ -12538,24 +13588,32 @@ export {
   registeragent,
   rejectioncapture,
   relayframe,
+  releaselock,
+  releaserunlock,
   removeedge,
   removenode,
   removetemplate,
+  rendermessage,
   renderminimap,
+  renderprovenance,
   rendertemplate,
   rendertoolbriefs,
   reordersteps,
   repeatuntilof,
   replannonfail,
   replanreviewgate,
+  replayagentrun,
   replaytrace,
   replayurl,
+  reportstep,
   requestbody,
+  requestreview,
   requeue,
   requireapproval,
   resolutionverdict,
   resolveapproval,
   resolvedrisk,
+  resolveescalation,
   resolverecipients,
   resolveroute,
   resolvetool,
@@ -12568,6 +13626,7 @@ export {
   restoreplanof,
   restorereviewgranted,
   resumeall,
+  resumehandoff,
   resumeone,
   retireentries,
   retireentry,
@@ -12577,6 +13636,7 @@ export {
   revertplanof,
   revertrule,
   reviewedkinds,
+  reviewframe,
   revocationruleof,
   revokeclient,
   rewritesourcelocation,
@@ -12584,6 +13644,7 @@ export {
   roledefaults,
   rotatelogs,
   rotationruleof,
+  routeenvironment,
   routesfor,
   routevalid,
   rpcerrorcodeof,
@@ -12608,13 +13669,18 @@ export {
   runworkflow,
   safetyresponse,
   samplingframes,
+  sandboxorigingate,
+  sandboxrenderof,
   savetemplate,
   saveworkflow,
   scaledrect,
+  scaleworkers,
+  scanconflicts,
   schedulecron,
   scheduleinterval,
   scopecheck,
   scopegate,
+  sealrunstate,
   seamweights,
   searchfields,
   searchqueryof,
@@ -12630,6 +13696,7 @@ export {
   serializearg,
   serializecdpcommand,
   serializeframe,
+  serializesteps,
   serverbindgate,
   servercapabilities,
   serverenablementgate,
@@ -12644,6 +13711,7 @@ export {
   sessionrestoregate,
   sessiontabof,
   setvariable,
+  sharelesson,
   shareworkflow,
   shiftentryof,
   signalsreport,
@@ -12665,6 +13733,7 @@ export {
   starttls,
   statusclassof,
   steal,
+  stepenvironmentvalid,
   stepmodeof,
   steptemplateof,
   stepwindows,
@@ -12675,13 +13744,17 @@ export {
   streamsummaries,
   streamwindowof,
   stripguardrails,
+  stripscripts,
   structurederrorreport,
   submitreviewgranted,
   subscriptionframes,
   subscriptionoptionsof,
+  swarmcosts,
   swarmoverview,
+  swarmreport,
   swarmstateof,
   swarmstatereport,
+  sweepreviews,
   tabreportresponse,
   targetgate,
   taskcounts,
@@ -12726,6 +13799,8 @@ export {
   tracestart,
   tracetofile,
   trailreport,
+  transferablekeys,
+  transferhandoff,
   transformgrammar,
   triggereventcatalog,
   triggerfamilies,
@@ -12771,6 +13846,9 @@ export {
   whileof,
   wireformat,
   wizardreport,
+  workerpoolsizevalid,
+  workerrequestof,
+  workerresponseof,
   workflowblockof,
   workflowfileversion,
   workflowgate,
@@ -12779,6 +13857,7 @@ export {
   workflowreport,
   workflowstepof,
   workstealgrade,
+  zombiesweep,
   zoomcanvas
 };
 //# sourceMappingURL=index.js.map