@wenathlan/extension 1.1.58 → 1.1.60

package/extension/dist/background.js

@@ -1824,6 +1824,8 @@ function watchdogpass(input) {
 function roledefaults(role) {
   if (role === "planner") return { toolnamespaces: ["workflow", "memory", "system"], description: "Planners compose reviewed plans and read memory; they never act on the page themselves." };
   if (role === "observer") return { toolnamespaces: ["memory", "system"], description: "Observers read the shared memory and the system reports only." };
+  if (role === "critic") return { toolnamespaces: ["workflow", "memory", "system"], description: "Critics review the outputs of the other agents read only; they never act on the page themselves." };
+  if (role === "verifier") return { toolnamespaces: ["browser", "memory", "system"], description: "Verifiers re-read the page to check the claims of the other agents; their checks stay read side." };
   return { toolnamespaces: ["browser", "workflow", "memory", "system"], description: role === "worker" ? "Workers execute the reviewed steps of approved plans." : `The custom role ${role} carries the worker defaults until the user narrows its scope.` };
 }
 function registeragent(input) {
@@ -1912,6 +1914,170 @@ function swarmoverview(input) {
   };
 }
 
+// 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 [tabid2, count] of counts) if (count > 1) shared.add(tabid2);
+  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) {
@@ -4133,6 +4299,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(window2, now) {
+    if (window2 === 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 > window2 && 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";
@@ -4176,6 +4580,121 @@ function randomid() {
   return crypto.randomUUID();
 }
 
+// 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 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 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 };
+}
+
 // toolcatalog.ts
 var toolcatalogversion = 1;
 var toolnamespaces = ["browser", "workflow", "memory", "system"];
@@ -8940,6 +9459,110 @@ function blackboardconsentgrade(entry) {
   if (entry.consentclass === "sensitive") return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the sensitive class of its source extraction; every agent reads the class beside the value.` };
   return { allowed: true, reason: `The blackboard entry ${entry.key} inherits the ${entry.consentclass} class of its source extraction; every agent reads the class beside the value.` };
 }
+function leaderelectionvalid(input) {
+  if (input.rule.kind !== "first" && input.rule.kind !== "named") return { allowed: false, reason: "The leader election rule stays first or named as the user configured it." };
+  if (input.rule.kind === "named") {
+    if (input.rule.agentid === void 0 || input.rule.agentid.trim() === "") return { allowed: false, reason: "The named leader election rule needs the agent id the user named." };
+    if (!input.agents.some((agent) => agent.id === input.rule.agentid && agent.state !== "stopped")) return { allowed: false, reason: `The named leader election rule names the agent ${input.rule.agentid} which is not a live agent of the swarm.` };
+  }
+  return { allowed: true, reason: input.rule.kind === "first" ? "The first registration rule elects the leader exactly as the user configured." : `The named rule elects the agent ${input.rule.agentid} exactly as the user configured.` };
+}
+function criticreviewgrade(review) {
+  if (review.reviewerid.trim() === "") return { allowed: false, reason: "The critic review needs its reviewing agent." };
+  if (review.subjectagentid.trim() === "") return { allowed: false, reason: "The critic review needs the subject agent whose output it reviews." };
+  if (review.verdict !== "approve" && review.verdict !== "changes" && review.verdict !== "reject") return { allowed: false, reason: "The critic review carries one of the three verdicts approve, changes or reject." };
+  if (review.verdict === "changes" && review.requiredchanges.length === 0) return { allowed: false, reason: "A changes verdict needs its required changes in plain language." };
+  if (review.verdict === "reject" && review.issues.length === 0) return { allowed: false, reason: "A reject verdict needs the issues the critic found." };
+  return { allowed: true, reason: `The critic review of the output of ${review.subjectagentid} stays read only: the critic ${review.reviewerid} returns its ${review.verdict} verdict and never acts on the page; the rework still passes the same human review.` };
+}
+function verifiermethodgrade(input) {
+  if (input.method.trim() === "") return { allowed: false, reason: "The verifier check needs the method it used." };
+  if (input.allowed.length > 0 && !input.allowed.includes(input.method)) return { allowed: false, reason: `The verifier method ${input.method} is not one of the methods the user allowed: ${input.allowed.join(", ")}.` };
+  return { allowed: true, reason: input.allowed.length === 0 ? `The verifier method ${input.method} runs under the documented open method list the user chose not to narrow.` : `The verifier method ${input.method} sits inside the methods the user allowed.` };
+}
+function handoffgrantgate(input) {
+  if (input.record.toagentid.trim() === "" || input.record.fromagentid.trim() === "") return { allowed: false, reason: "The handoff names its transferring and receiving agents." };
+  if (input.toscope === void 0) return { allowed: true, reason: `The receiving agent ${input.record.toagentid} carries no narrowed scope, so the handoff stays unbounded inside the original session grants.` };
+  const outside = input.toscope.origins.filter((origin) => input.sessiongrants.length > 0 && !input.sessiongrants.includes(origin));
+  if (outside.length > 0) return { allowed: false, reason: `The handoff to ${input.record.toagentid} would need the origins ${outside.join(", ")} which the session grant list does not carry; a tab transfer never widens the session grants.` };
+  return { allowed: true, reason: `The handoff from ${input.record.fromagentid} to ${input.record.toagentid} preserves the original session grants; the receiving scope stays inside them.` };
+}
+function lockscopevalid(lock) {
+  if (lock.key.trim() === "") return { allowed: false, reason: "The resource lock needs its key." };
+  if (lock.origin.trim() === "" || lock.selector.trim() === "") return { allowed: false, reason: "The resource lock names exactly one origin and one selector; a lock never spans unrelated origins." };
+  if (lock.key !== `${lock.origin}|${lock.selector}`) return { allowed: false, reason: "The lock key must compose of its one origin and its one selector so the scope never spans unrelated origins." };
+  if (lock.kind !== "exclusive" && lock.kind !== "shared") return { allowed: false, reason: "The lock kind stays exclusive or shared." };
+  return { allowed: true, reason: `The lock ${lock.key} spans exactly one target of one origin for the holder ${lock.holder}.` };
+}
+function conflictresolutiongrade(rule) {
+  if (rule !== "first" && rule !== "last" && rule !== "preferagent" && rule !== "fail") return { allowed: false, reason: "The conflict resolution rule stays first, last, preferagent or fail as the user configured it." };
+  if (rule === "last" || rule === "preferagent") return { allowed: true, reason: `The ${rule} conflict resolution rule overwrites one parallel value with another, so it grades sensitive and the merged report still passes the human review.` };
+  return { allowed: true, reason: `The ${rule} conflict resolution rule keeps or refuses the parallel values without overwriting, so it grades read side.` };
+}
+function escalationgate(escalation) {
+  if (escalation.agentid.trim() === "") return { allowed: false, reason: "The escalation names the agent whose decision it lifts." };
+  if (escalation.subject.trim() === "") return { allowed: false, reason: "The escalation needs its subject." };
+  if (escalation.context.trim() === "") return { allowed: false, reason: "The escalation needs its full context in plain language; the user decides on what the agent saw." };
+  if (escalation.state === "decided" && (escalation.decision === void 0 || escalation.decision.trim() === "")) return { allowed: false, reason: "A decided escalation carries the decision the user wrote." };
+  return { allowed: true, reason: `The escalation of ${escalation.agentid} stays human decided: the agent lifts the stalled decision with its full context and the user alone writes the outcome.` };
+}
+function consensusquorumvalid(input) {
+  if (!Number.isInteger(input.quorum) || input.quorum < 1) return { allowed: false, reason: "The consensus quorum stays a positive whole number the user configured." };
+  if (input.quorum > input.voters) return { allowed: false, reason: `The consensus quorum ${input.quorum} exceeds the ${input.voters} voting agents the user counted; an unreachable quorum never carries.` };
+  return { allowed: true, reason: `The consensus quorum ${input.quorum} of ${input.voters} voting agents stays the user configured value with no engine default.` };
+}
+function workerscalevalid(bound) {
+  if (bound === void 0) return { allowed: true, reason: "No worker bound is configured, so the worker scale stays the user choice alone with no engine cap." };
+  if (!Number.isFinite(bound) || bound < 1) return { allowed: false, reason: "The worker scale bound stays a positive user value; no engine cap exists." };
+  return { allowed: true, reason: `The worker scale bound ${bound} stays the user configured value; the scaling never passes it and no engine cap exists.` };
+}
+function mergeegressgrade(input) {
+  if (input.report.title.trim() === "") return { allowed: false, reason: "The merged report needs its title before any export." };
+  if (input.carriespagecontent) return { allowed: true, reason: `The export of the report ${input.report.title} carries page content from the sources ${input.report.sources.join(", ")} and grades as a data egress event in the audit trail.` };
+  return { allowed: true, reason: `The export of the report ${input.report.title} carries no page content and stays a plain report export.` };
+}
+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]);
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -8954,6 +9577,14 @@ function recordoutcome(progress, planid, outcome, now) {
   const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
   return { ...base, outcomes: [...base.outcomes ?? [], outcome], updatedat: now };
 }
+function recordenvironment2(progress, planid, stepid, environment, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, environments: { ...base.environments ?? {}, [stepid]: environment }, updatedat: now };
+}
+function recordturnaround2(progress, planid, stepid, milliseconds, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, turnarounds: { ...base.turnarounds ?? {}, [stepid]: milliseconds }, updatedat: now };
+}
 function iscomplete(progress, plan) {
   if (!progress || progress.planid !== plan.id) return false;
   const required = plan.steps.map((step) => step.id);
@@ -9119,7 +9750,7 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
 }
 
 // version.ts
-var packageversion = "1.1.58";
+var packageversion = "1.1.60";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10083,6 +10714,16 @@ function runhistoryquery(value) {
 function runhistoryreport(input) {
   return { version: protocolversion, entries: input.entries, query: input.query ?? {} };
 }
+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 } : {}
+  };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -11517,6 +12158,376 @@ function budgetcheck(input) {
   return { allowed: true, halted: false, asksuser: false };
 }
 
+// orchestration.ts
+function electleader(input) {
+  const live = input.agents.filter((agent) => agent.state !== "stopped");
+  if (live.length === 0) throw new Error("The swarm holds no live agent; the leader election waits for the user to register one.");
+  const rule = input.rule ?? { kind: "first" };
+  let leader;
+  if (rule.kind === "named") {
+    if (rule.agentid === void 0 || rule.agentid.trim() === "") throw new Error("The named election rule needs the agent id the user named.");
+    leader = live.find((agent) => agent.id === rule.agentid);
+    if (!leader) throw new Error(`The named election rule names the agent ${rule.agentid} which is not a live agent of the swarm.`);
+  } else {
+    leader = live[live.length - 1];
+  }
+  if (!leader) throw new Error("The leader election found no live agent.");
+  const leaderid = leader.id;
+  const workers = live.filter((agent) => agent.id !== leaderid && agent.role === "worker");
+  const critics = live.filter((agent) => agent.id !== leaderid && agent.role === "critic");
+  const verifiers = live.filter((agent) => agent.id !== leaderid && agent.role === "verifier");
+  return {
+    id: input.id,
+    leaderid: leader.id,
+    workerids: workers.map((agent) => agent.id),
+    criticids: critics.map((agent) => agent.id),
+    verifierids: verifiers.map((agent) => agent.id),
+    assignments: [],
+    rule: { kind: rule.kind, ...rule.agentid !== void 0 ? { agentid: rule.agentid } : {} },
+    electedat: input.now
+  };
+}
+function assignwork(input) {
+  if (input.topology.workerids.length === 0) throw new Error("The topology holds no worker; the user adds workers before the assignment.");
+  const assignments = [];
+  const tasks = input.tasks.filter((task) => task.state === "queued" || task.state === "claimed");
+  tasks.forEach((task, index) => {
+    const workerid = input.topology.workerids[index % input.topology.workerids.length];
+    assignments.push({ workerid, taskid: task.id, slice: `${task.payload} (slice ${Math.floor(index / input.topology.workerids.length) + 1} of lane ${task.lane})`, assignedat: input.now });
+  });
+  return { ...input.topology, assignments };
+}
+function collectresults(input) {
+  const gathered = input.topology.assignments.map((assignment) => {
+    const output = input.outputs.find((entry) => entry.taskid === assignment.taskid && entry.workerid === assignment.workerid);
+    return output ?? { workerid: assignment.workerid, taskid: assignment.taskid, state: "pending", summary: `The worker ${assignment.workerid} has not returned its slice of the task ${assignment.taskid} yet.` };
+  });
+  return { gathered, missing: gathered.filter((entry) => entry.state === "pending").map((entry) => `${entry.workerid}:${entry.taskid}`) };
+}
+function scaleworkers(input) {
+  const live = input.agents.filter((agent) => agent.state === "active" && agent.role === "worker" && agent.id !== input.topology.leaderid);
+  const current = input.topology.workerids.filter((workerid) => live.some((agent) => agent.id === workerid));
+  const ceiling = input.bound;
+  if (input.pending > current.length) {
+    const available = live.filter((agent) => !current.includes(agent.id)).map((agent) => agent.id);
+    const wanted = input.pending - current.length;
+    const addable = ceiling === void 0 ? available.slice(0, wanted) : available.slice(0, Math.min(wanted, Math.max(ceiling - current.length, 0)));
+    if (addable.length === 0) return { topology: input.topology, added: [], retired: [], reason: ceiling === void 0 ? `The load of ${input.pending} pending slices exceeds the ${current.length} workers but the swarm holds no further live worker role agent to add.` : `The load of ${input.pending} pending slices exceeds the ${current.length} workers but the user configured bound of ${ceiling} workers holds.` };
+    return { topology: { ...input.topology, workerids: [...current, ...addable], electedat: input.topology.electedat, assignments: input.topology.assignments }, added: addable, retired: [], reason: `The load of ${input.pending} pending slices added the workers ${addable.join(", ")}; ${ceiling === void 0 ? "no bound is configured so the user scale stands alone" : `the user configured bound of ${ceiling} workers holds`}.` };
+  }
+  const keep = Math.max(input.pending, 0);
+  if (current.length > keep) {
+    const retired = current.slice(keep);
+    return { topology: { ...input.topology, workerids: current.slice(0, keep), electedat: input.topology.electedat, assignments: input.topology.assignments.filter((assignment) => !retired.includes(assignment.workerid)) }, added: [], retired, reason: `The load of ${input.pending} pending slices retired the idle workers ${retired.join(", ")}.` };
+  }
+  return { topology: input.topology, added: [], retired: [], reason: `The load of ${input.pending} pending slices matches the ${current.length} workers; the scale stays unchanged.` };
+}
+function plannersplit(input) {
+  if (input.planownerid.trim() === "" || input.runownerid.trim() === "") throw new Error("The planner executor split needs its plan owner and run owner agent ids.");
+  if (input.planownerid === input.runownerid) throw new Error("The planner executor split keeps plan drafting and execution in different agents; one agent holds both sides never.");
+  return { id: input.id, planownerid: input.planownerid, runownerid: input.runownerid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, stepreports: [], splitat: input.now };
+}
+function reportstep(input) {
+  if (input.stepid.trim() === "") throw new Error("The executor report needs its step id.");
+  if (input.detail.trim() === "") throw new Error("The executor report needs its detail in plain language.");
+  const report = { stepid: input.stepid.trim(), outcome: input.outcome, detail: input.detail, reportedat: input.now };
+  return { ...input.split, stepreports: [...input.split.stepreports.filter((entry) => entry.stepid !== report.stepid), report] };
+}
+function requestreview(input) {
+  if (input.subject.trim() === "") throw new Error("The review request needs its subject.");
+  if (input.payload.trim() === "") throw new Error("The review request needs its payload.");
+  if (input.toagentid.trim() === "" || input.toagentid === input.fromagentid) throw new Error("The review request names another reviewing agent, never its own requester.");
+  const request = { id: input.id, fromagentid: input.fromagentid, toagentid: input.toagentid, subject: input.subject, payload: input.payload, state: "open", requestedat: input.now, ...input.timeoutms !== void 0 ? { timeoutat: input.now + input.timeoutms } : {} };
+  return [request, ...input.requests];
+}
+function ackreview(input) {
+  const request = input.requests.find((entry) => entry.id === input.id);
+  if (!request) throw new Error(`The review request ${input.id} does not exist.`);
+  if (request.state !== "open") throw new Error(`The review request ${input.id} is ${request.state}; only an open request receives its ack.`);
+  return input.requests.map((entry) => entry.id === input.id ? { ...entry, state: "acked", ackedat: input.now } : entry);
+}
+function applyreview(input) {
+  const request = input.requests.find((entry) => entry.id === input.id);
+  if (!request) throw new Error(`The review request ${input.id} does not exist.`);
+  if (request.state === "answered" || request.state === "timeout") throw new Error(`The review request ${input.id} is ${request.state}; an answered or timed out request never reviews again.`);
+  if (request.toagentid !== input.reviewerid) throw new Error(`The review request ${input.id} routes to the agent ${request.toagentid}; the agent ${input.reviewerid} never answers in its place.`);
+  if (input.verdict === "changes" && input.requiredchanges.length === 0) throw new Error("A changes verdict needs its required changes in plain language.");
+  const review = { id: request.id, reviewerid: input.reviewerid, subjectagentid: request.fromagentid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, verdict: input.verdict, issues: input.issues, requiredchanges: input.requiredchanges, reviewedat: input.now };
+  return { review, requests: input.requests.map((entry) => entry.id === input.id ? { ...entry, state: "answered", answeredat: input.now } : entry) };
+}
+function sweepreviews(input) {
+  const expired = input.requests.filter((request) => request.state === "open" || request.state === "acked").filter((request) => request.timeoutat !== void 0 && input.now > request.timeoutat);
+  if (expired.length === 0) return { requests: input.requests, timedout: [] };
+  const ids = new Set(expired.map((request) => request.id));
+  return { requests: input.requests.map((request) => ids.has(request.id) ? { ...request, state: "timeout" } : request), timedout: [...ids] };
+}
+function checkclaim(input) {
+  if (input.claim.trim() === "") throw new Error("The verifier check needs its claim in plain language.");
+  if (input.method.trim() === "") throw new Error("The verifier check needs the method the user configured.");
+  if (input.claimagentid.trim() === "") throw new Error("The verifier check names the agent whose claim it checks.");
+  return { id: input.id, verifierid: input.verifierid, claimagentid: input.claimagentid, ...input.taskid !== void 0 && input.taskid.trim() !== "" ? { taskid: input.taskid } : {}, claim: input.claim, method: input.method, outcome: input.outcome, ...input.evidence !== void 0 && input.evidence.trim() !== "" ? { evidence: input.evidence } : {}, checkedat: input.now };
+}
+function boardstate(input) {
+  const lanes = input.agents.filter((agent) => agent.state !== "stopped").map((agent) => {
+    const assignment = input.topology?.assignments.find((entry) => entry.workerid === agent.id);
+    const claim2 = input.queue.claims.find((record2) => record2.agentid === agent.id && input.queue.items.some((item) => item.id === record2.taskid && item.state === "claimed"));
+    const task = claim2 !== void 0 ? input.queue.items.find((item) => item.id === claim2.taskid) : void 0;
+    const lane = task?.lane ?? (agent.role === "critic" || agent.role === "verifier" ? agent.role : agent.role === "planner" ? "planning" : "idle");
+    return { agentid: agent.id, name: agent.name, role: agent.role, state: agent.state, lane, ...task !== void 0 ? { currenttask: task.payload } : assignment !== void 0 ? { currenttask: assignment.slice } : {}, milestones: input.milestones?.[agent.id] ?? [] };
+  });
+  return { id: `board:${input.now}`, lanes, builtat: input.now };
+}
+function escalate(input) {
+  if (input.subject.trim() === "") throw new Error("The escalation needs its subject.");
+  if (input.context.trim() === "") throw new Error("The escalation needs its full context in plain language; the user decides on what the agent saw.");
+  if (input.agentid.trim() === "") throw new Error("The escalation names the agent whose decision it lifts.");
+  return { id: input.id, agentid: input.agentid, subject: input.subject, context: input.context, state: "open", raisedat: input.now };
+}
+function resolveescalation(input) {
+  if (input.escalation.state === "decided") throw new Error("The escalation already carries its user decision.");
+  if (input.decision.trim() === "") throw new Error("The escalation decision needs the words the user wrote.");
+  return { ...input.escalation, state: "decided", decision: input.decision, decidedat: input.now };
+}
+function arbitrate(input) {
+  if (input.claims.length === 0) return [];
+  if (input.rule.strategy === "priority") {
+    const order = input.rule.priorityorder;
+    return [...input.claims].sort((one, two) => {
+      const oneindex = order.indexOf(one.agentid);
+      const twoindex = order.indexOf(two.agentid);
+      return (oneindex === -1 ? order.length : oneindex) - (twoindex === -1 ? order.length : twoindex) || one.claimedat - two.claimedat;
+    }).map((claim2) => claim2.agentid);
+  }
+  if (input.rule.strategy === "age") return [...input.claims].sort((one, two) => one.claimedat - two.claimedat || (one.agentid < two.agentid ? -1 : 1)).map((claim2) => claim2.agentid);
+  if (input.leaderid === void 0) throw new Error("The leader arbitration strategy needs the elected leader of the topology.");
+  return [...input.claims].sort((one, two) => (one.agentid === input.leaderid ? -1 : 1) - (two.agentid === input.leaderid ? -1 : 1) || one.claimedat - two.claimedat).map((claim2) => claim2.agentid);
+}
+function openconsensus(input) {
+  if (input.subject.trim() === "") throw new Error("The consensus round needs its subject in plain language.");
+  if (!Number.isInteger(input.quorum) || input.quorum < 1) throw new Error("The consensus round needs its quorum as a positive whole number the user configured.");
+  return { id: input.id, subject: input.subject, votes: [], quorum: input.quorum, state: "open", openedat: input.now };
+}
+function castvote(input) {
+  if (input.round.state !== "open") throw new Error(`The consensus round ${input.round.id} is ${input.round.state}; a closed round collects no vote.`);
+  if (input.round.votes.some((entry) => entry.agentid === input.agentid)) throw new Error(`The agent ${input.agentid} already voted in the round ${input.round.id}.`);
+  const votes = [...input.round.votes, { agentid: input.agentid, vote: input.vote, votedat: input.now }];
+  const yes = votes.filter((entry) => entry.vote === "yes").length;
+  const no = votes.filter((entry) => entry.vote === "no").length;
+  if (yes >= input.round.quorum) return { ...input.round, votes, state: "carried", closedat: input.now };
+  if (no >= input.round.quorum) return { ...input.round, votes, state: "failed", closedat: input.now };
+  return { ...input.round, votes };
+}
+function consensusstate(round) {
+  return {
+    yes: round.votes.filter((entry) => entry.vote === "yes").length,
+    no: round.votes.filter((entry) => entry.vote === "no").length,
+    abstain: round.votes.filter((entry) => entry.vote === "abstain").length,
+    quorum: round.quorum,
+    state: round.state
+  };
+}
+
+// blackboard.ts
+var blackboardsections = ["goals", "facts", "findings", "scratch"];
+function emptyboard(sections) {
+  return { sections: sections ?? blackboardsections, entries: [] };
+}
+function postentry(input) {
+  if (input.key.trim() === "") throw new Error("The blackboard entry needs its key.");
+  if (input.value.trim() === "") throw new Error("The blackboard entry needs its value.");
+  if (input.author.trim() === "") throw new Error("The blackboard entry needs its author.");
+  if (!blackboardsections.includes(input.section)) throw new Error(`The section ${input.section} is not one of the shared blackboard sections.`);
+  if (input.board.entries.some((entry2) => entry2.id === input.id)) throw new Error(`The blackboard entry id ${input.id} already exists.`);
+  if (input.valuekind === "json") {
+    try {
+      JSON.parse(input.value);
+    } catch {
+      throw new Error("The json blackboard entry needs a well-formed json value.");
+    }
+  }
+  const entry = { id: input.id, key: input.key.trim(), valuekind: input.valuekind ?? "text", value: input.value, author: input.author, section: input.section, consentclass: input.consentclass ?? "read", postedat: input.now };
+  return { ...input.board, sections: input.board.sections.includes(input.section) ? input.board.sections : [...input.board.sections, input.section], entries: [entry, ...input.board.entries] };
+}
+function entryfresh(entry, now, window2) {
+  if (entry.retiredat !== void 0) return false;
+  if (window2 === void 0) return true;
+  return now - entry.postedat <= window2;
+}
+function readentries(input) {
+  return input.board.entries.filter((entry) => entry.retiredat === void 0).filter((entry) => input.section === void 0 || entry.section === input.section).filter((entry) => entryfresh(entry, input.now, input.freshness)).sort((one, two) => two.postedat - one.postedat);
+}
+function retireentries(input) {
+  if (input.board.retirementwindow === void 0) return { board: input.board, retired: [] };
+  const stale = input.board.entries.filter((entry) => entry.retiredat === void 0 && input.now - entry.postedat > input.board.retirementwindow);
+  if (stale.length === 0) return { board: input.board, retired: [] };
+  const staleids = new Set(stale.map((entry) => entry.id));
+  return {
+    board: { ...input.board, entries: input.board.entries.map((entry) => staleids.has(entry.id) ? { ...entry, retiredat: input.now } : entry) },
+    retired: [...staleids]
+  };
+}
+function retireentry(input) {
+  const entry = input.board.entries.find((candidate) => candidate.id === input.entryid);
+  if (!entry) throw new Error(`The blackboard entry ${input.entryid} does not exist.`);
+  if (entry.retiredat !== void 0) throw new Error(`The blackboard entry ${entry.key} is already retired.`);
+  return { ...input.board, entries: input.board.entries.map((candidate) => candidate.id === input.entryid ? { ...candidate, retiredat: input.now } : candidate) };
+}
+function boardsummary(board, now) {
+  return board.sections.map((section) => {
+    const live = board.entries.filter((entry) => entry.section === section && entry.retiredat === void 0);
+    return { section, entries: live.length, authors: [...new Set(live.map((entry) => entry.author))], ...live.length > 0 ? { freshestat: Math.max(...live.map((entry) => entry.postedat)) } : {} };
+  });
+}
+
+// coordination.ts
+function lockkey(origin, selector) {
+  return `${origin}|${selector}`;
+}
+function preparehandoff(input) {
+  if (!input.agents.some((agent) => agent.id === input.fromagentid)) throw new Error(`The handoff names the transferring agent ${input.fromagentid} which is not registered.`);
+  if (!input.agents.some((agent) => agent.id === input.toagentid)) throw new Error(`The handoff names the receiving agent ${input.toagentid} which is not registered.`);
+  if (input.fromagentid === input.toagentid) throw new Error("A handoff moves a task between two different agents; an agent never hands off to itself.");
+  if (input.taskstate.trim() === "") throw new Error("The handoff needs its packaged task state in plain language; the resume continues exactly from it.");
+  const from = input.agents.find((agent) => agent.id === input.fromagentid);
+  const tabid2 = input.tabid ?? from.tabid;
+  if (tabid2 === void 0) throw new Error("The handoff needs its tab id; the transferring agent holds no tab to hand off.");
+  return { id: input.id, fromagentid: input.fromagentid, toagentid: input.toagentid, tabid: tabid2, taskstate: input.taskstate, state: "prepared", ...input.reason !== void 0 && input.reason.trim() !== "" ? { reason: input.reason } : {}, createdat: input.now };
+}
+function transferhandoff(input) {
+  const record2 = input.handoffs.find((entry) => entry.id === input.id);
+  if (!record2) throw new Error(`The handoff ${input.id} does not exist.`);
+  if (record2.state !== "prepared") throw new Error(`The handoff ${record2.id} is ${record2.state}; only a prepared handoff transfers.`);
+  const receiver = input.agents.find((agent) => agent.id === record2.toagentid);
+  if (!receiver) throw new Error(`The receiving agent ${record2.toagentid} is not registered.`);
+  if (receiver.state === "stopped") throw new Error(`The receiving agent ${receiver.name} is stopped; the handoff waits for its resume or another receiver.`);
+  const holder = input.agents.find((agent) => agent.tabid === record2.tabid && agent.id !== record2.fromagentid && agent.state !== "stopped");
+  if (holder) throw new Error(`Tab ${record2.tabid} already holds the agent ${holder.name}; one tab binds one agent.`);
+  const agents = input.agents.map((agent) => {
+    if (agent.id === record2.fromagentid) {
+      const { tabid: tabid2, ...rest } = agent;
+      void tabid2;
+      return rest;
+    }
+    if (agent.id === record2.toagentid && record2.tabid !== void 0) return { ...agent, tabid: record2.tabid };
+    return agent;
+  });
+  return { agents, handoffs: input.handoffs.map((entry) => entry.id === input.id ? { ...entry, state: "transferred", transferredat: input.now } : entry) };
+}
+function resumehandoff(input) {
+  const record2 = input.handoffs.find((entry) => entry.id === input.id);
+  if (!record2) throw new Error(`The handoff ${input.id} does not exist.`);
+  if (record2.state !== "transferred") throw new Error(`The handoff ${record2.id} is ${record2.state}; only a transferred handoff resumes.`);
+  return { ...record2, state: "resumed", resumedat: input.now };
+}
+function acquirelock(input) {
+  if (input.holder.trim() === "") throw new Error("The lock needs its holder agent id.");
+  if (input.origin.trim() === "") throw new Error("The lock needs its origin; a lock never spans unrelated origins.");
+  if (input.selector.trim() === "") throw new Error("The lock needs its selector of the origin.");
+  const kind = input.kind ?? "exclusive";
+  const key = lockkey(input.origin.trim(), input.selector.trim());
+  const held = input.locks.filter((lock2) => lock2.key === key);
+  if (held.some((lock2) => lock2.holder === input.holder)) return { locks: input.locks, acquired: false, reason: `The agent ${input.holder} already holds the lock ${key}.` };
+  if (held.length > 0) {
+    if (held.some((lock2) => lock2.kind === "exclusive") || kind === "exclusive") return { locks: input.locks, acquired: false, reason: `The lock ${key} is held ${held.some((lock2) => lock2.kind === "exclusive") ? "exclusively" : "shared"}; the ${kind} request of ${input.holder} refuses.` };
+  }
+  const lock = { key, holder: input.holder, kind, origin: input.origin.trim(), selector: input.selector.trim(), acquiredat: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+  return { locks: [...input.locks, lock], acquired: true, reason: `The ${kind} lock ${key} went to the agent ${input.holder}.` };
+}
+function releaselock(input) {
+  const lock = input.locks.find((entry) => entry.key === input.key && entry.holder === input.holder);
+  if (!lock) return { locks: input.locks, released: false };
+  return { locks: input.locks.filter((entry) => entry.key !== input.key || entry.holder !== input.holder), released: true };
+}
+function expirelocks(input) {
+  const stale = input.locks.filter((lock) => lock.expiresat !== void 0 && input.now > lock.expiresat);
+  if (stale.length === 0) return { locks: input.locks, expired: [] };
+  const keys = new Set(stale.map((lock) => `${lock.key}:${lock.holder}`));
+  return { locks: input.locks.filter((lock) => !keys.has(`${lock.key}:${lock.holder}`)), expired: [...keys] };
+}
+function scanconflicts(input) {
+  const targets = /* @__PURE__ */ new Map();
+  for (const writer of input.writers) {
+    const key = lockkey(writer.origin, writer.selector);
+    targets.set(key, [...targets.get(key) ?? [], writer]);
+  }
+  const overlaps = [...targets.entries()].filter(([, writers]) => writers.length > 1).map(([key, writers]) => ({ origin: writers[0].origin, selector: writers[0].selector, writers: writers.map((writer) => writer.agentid) }));
+  const overlappingagents = new Set(overlaps.flatMap((entry) => entry.writers));
+  return {
+    id: input.id,
+    writers: input.writers,
+    overlaps,
+    suggestedorder: input.writers.filter((writer) => overlappingagents.has(writer.agentid)).map((writer) => writer.agentid).filter((agentid, index, all) => all.indexOf(agentid) === index).sort((one, two) => one < two ? -1 : 1),
+    clean: overlaps.length === 0,
+    scannedat: input.now
+  };
+}
+function mergeresults(input) {
+  const keys = /* @__PURE__ */ new Map();
+  for (const entry of input.entries) {
+    keys.set(entry.key, [...keys.get(entry.key) ?? [], entry]);
+  }
+  const conflicts = [];
+  const merged = [];
+  for (const [key, entries] of keys) {
+    const ordered = [...entries].sort((one, two) => one.mergedat - two.mergedat);
+    if (ordered.length === 1) {
+      merged.push(ordered[0]);
+      continue;
+    }
+    if (input.rule === "fail") {
+      conflicts.push(`The key ${key} carries ${ordered.length} parallel values from ${ordered.map((entry) => entry.agentid).join(", ")}; the fail rule refuses the fold.`);
+      continue;
+    }
+    const winner = input.rule === "first" ? ordered[0] : input.rule === "last" ? ordered[ordered.length - 1] : ordered.find((entry) => entry.agentid === input.preferagent) ?? ordered[ordered.length - 1];
+    const note = input.rule === "preferagent" && input.preferagent !== void 0 && !ordered.some((entry) => entry.agentid === input.preferagent) ? `The preferagent rule names the agent ${input.preferagent} which wrote no value; the latest value of ${winner.agentid} stayed.` : `The ${input.rule} rule kept the value of ${winner.agentid} from ${ordered.map((entry) => entry.agentid).join(", ")}.`;
+    conflicts.push(`The key ${key}: ${note}`);
+    merged.push({ ...winner, id: `${winner.id}:merged`, conflict: note });
+  }
+  return { entries: merged, conflicts, refused: input.rule === "fail" && conflicts.length > 0 };
+}
+function swarmreport(input) {
+  if (input.title.trim() === "") throw new Error("The report needs its title.");
+  const fold = mergeresults({ entries: input.outputs, rule: input.rule, ...input.preferagent !== void 0 ? { preferagent: input.preferagent } : {}, now: input.now });
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of fold.entries) {
+    const group = entry.taskid ?? "general";
+    groups.set(group, [...groups.get(group) ?? [], entry]);
+  }
+  const sections = [...groups.entries()].map(([taskid, entries]) => ({ title: `Task ${taskid}`, entries, sources: [...new Set(input.outputs.filter((output) => (output.taskid ?? "general") === taskid).map((output) => output.agentid))] }));
+  return {
+    report: { id: input.id, title: input.title.trim(), sections, sources: [...new Set(input.outputs.map((output) => output.agentid))], ...input.confidence !== void 0 && input.confidence.trim() !== "" ? { confidence: input.confidence } : {}, createdat: input.now },
+    conflicts: fold.conflicts,
+    refused: fold.refused
+  };
+}
+function compareoutputs(input) {
+  if (input.subject.trim() === "") throw new Error("The comparison needs its subject.");
+  if (input.outputs.length < 2) throw new Error("The comparison contrasts at least two competing outputs.");
+  const differences = input.outputs.filter((output) => output.value !== input.outputs[0]?.value).map((output) => `The agent ${output.agentid} answers ${output.value} while the agent ${input.outputs[0].agentid} answers ${input.outputs[0].value}.`);
+  return { id: input.id, subject: input.subject, outputs: input.outputs, differences, comparedat: input.now };
+}
+function interleavetimeline(actions) {
+  return [...actions].sort((one, two) => one.at - two.at || (one.id < two.id ? -1 : 1));
+}
+function sharelesson(input) {
+  if (input.statement.trim() === "") throw new Error("The lesson needs its statement in plain language.");
+  if (input.verifiedby.trim() === "") throw new Error("The lesson needs its verifier; only a verified lesson lands on the board.");
+  return postentry({ board: input.board, id: input.id, key: `lesson:${input.statement.trim().slice(0, 40)}`, value: `${input.statement.trim()} (verified by ${input.verifiedby.trim()})`, section: input.section ?? "findings", author: input.agentid.trim() === "" ? "user" : input.agentid, consentclass: input.consentclass ?? "read", now: input.now });
+}
+function swarmcosts(input) {
+  return {
+    agents: input.usage.length,
+    tokens: input.usage.reduce((total, usage) => total + usage.tokens, 0),
+    cost: input.usage.reduce((total, usage) => total + usage.cost, 0),
+    steps: input.usage.reduce((total, usage) => total + usage.steps, 0),
+    ...input.currency !== void 0 && input.currency.trim() !== "" ? { currency: input.currency } : {},
+    computedat: input.now
+  };
+}
+function replayagentrun(input) {
+  return interleavetimeline(input.events.filter((event) => event.agentid === input.agentid).map((event) => ({ id: event.id, kind: event.kind, summary: event.summary, at: event.at, ...event.agentid !== void 0 ? { agentid: event.agentid } : {} })));
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -11612,58 +12623,6 @@ function taskcounts(queue) {
   };
 }
 
-// blackboard.ts
-var blackboardsections = ["goals", "facts", "findings", "scratch"];
-function emptyboard(sections) {
-  return { sections: sections ?? blackboardsections, entries: [] };
-}
-function postentry(input) {
-  if (input.key.trim() === "") throw new Error("The blackboard entry needs its key.");
-  if (input.value.trim() === "") throw new Error("The blackboard entry needs its value.");
-  if (input.author.trim() === "") throw new Error("The blackboard entry needs its author.");
-  if (!blackboardsections.includes(input.section)) throw new Error(`The section ${input.section} is not one of the shared blackboard sections.`);
-  if (input.board.entries.some((entry2) => entry2.id === input.id)) throw new Error(`The blackboard entry id ${input.id} already exists.`);
-  if (input.valuekind === "json") {
-    try {
-      JSON.parse(input.value);
-    } catch {
-      throw new Error("The json blackboard entry needs a well-formed json value.");
-    }
-  }
-  const entry = { id: input.id, key: input.key.trim(), valuekind: input.valuekind ?? "text", value: input.value, author: input.author, section: input.section, consentclass: input.consentclass ?? "read", postedat: input.now };
-  return { ...input.board, sections: input.board.sections.includes(input.section) ? input.board.sections : [...input.board.sections, input.section], entries: [entry, ...input.board.entries] };
-}
-function entryfresh(entry, now, window2) {
-  if (entry.retiredat !== void 0) return false;
-  if (window2 === void 0) return true;
-  return now - entry.postedat <= window2;
-}
-function readentries(input) {
-  return input.board.entries.filter((entry) => entry.retiredat === void 0).filter((entry) => input.section === void 0 || entry.section === input.section).filter((entry) => entryfresh(entry, input.now, input.freshness)).sort((one, two) => two.postedat - one.postedat);
-}
-function retireentries(input) {
-  if (input.board.retirementwindow === void 0) return { board: input.board, retired: [] };
-  const stale = input.board.entries.filter((entry) => entry.retiredat === void 0 && input.now - entry.postedat > input.board.retirementwindow);
-  if (stale.length === 0) return { board: input.board, retired: [] };
-  const staleids = new Set(stale.map((entry) => entry.id));
-  return {
-    board: { ...input.board, entries: input.board.entries.map((entry) => staleids.has(entry.id) ? { ...entry, retiredat: input.now } : entry) },
-    retired: [...staleids]
-  };
-}
-function retireentry(input) {
-  const entry = input.board.entries.find((candidate) => candidate.id === input.entryid);
-  if (!entry) throw new Error(`The blackboard entry ${input.entryid} does not exist.`);
-  if (entry.retiredat !== void 0) throw new Error(`The blackboard entry ${entry.key} is already retired.`);
-  return { ...input.board, entries: input.board.entries.map((candidate) => candidate.id === input.entryid ? { ...candidate, retiredat: input.now } : candidate) };
-}
-function boardsummary(board, now) {
-  return board.sections.map((section) => {
-    const live = board.entries.filter((entry) => entry.section === section && entry.retiredat === void 0);
-    return { section, entries: live.length, authors: [...new Set(live.map((entry) => entry.author))], ...live.length > 0 ? { freshestat: Math.max(...live.map((entry) => entry.postedat)) } : {} };
-  });
-}
-
 // agentmailbox.ts
 function mailboxof(mailboxes, agentid) {
   return mailboxes.find((mailbox) => mailbox.agentid === agentid) ?? { agentid, inbox: [], outbox: [], unread: 0 };
@@ -11706,6 +12665,41 @@ function unreadcount(mailboxes, agentid) {
   return mailboxof(mailboxes, agentid).unread;
 }
 
+// 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.` };
+}
+
 // modelroute.ts
 function routevalid(route) {
   if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
@@ -13011,6 +14005,260 @@ async function dispatchpagestep(step, tabid2, origin, plan) {
   await harvestdialogs(session, activeplan, step.id, tabid2);
   return result[0]?.result;
 }
+var roadmapheartbeat = 3e4;
+var roadmapzombieintervals = 3;
+var runstateprofile = "default";
+var keepaliveport;
+var workerpoolcounts = /* @__PURE__ */ new Map();
+async function offscreengranted() {
+  try {
+    return await chrome.permissions.contains({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function offscreendeclaration() {
+  try {
+    const response = await fetch(chrome.runtime.getURL("manifest.json"));
+    const manifest = await response.json();
+    if (!manifest.offscreen?.document || !manifest.offscreen.reasons?.length || !manifest.offscreen.justification?.trim()) return void 0;
+    return { document: manifest.offscreen.document, reasons: manifest.offscreen.reasons, justification: manifest.offscreen.justification };
+  } catch {
+    return void 0;
+  }
+}
+async function requestoffscreengrant() {
+  try {
+    return await chrome.permissions.request({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function ensureoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  if (!offscreen) return false;
+  const declaration = await offscreendeclaration();
+  if (!declaration) return false;
+  const opened = openoffscreen({ registry: await memory.getoffscreenentries(), document: declaration.document, runid, reasons: declaration.reasons, justification: declaration.justification, now: Date.now() });
+  if (!opened.reused) {
+    await memory.addoffscreenentry(opened.entry);
+    await audit("worker", `The offscreen document ${declaration.document} spawned for the run ${runid} under the reasons ${declaration.reasons.join(", ")} with the reviewed justification.`, {});
+  }
+  try {
+    if (!await offscreen.hasDocument()) await offscreen.createDocument({ url: chrome.runtime.getURL(declaration.document), reasons: declaration.reasons, justification: declaration.justification });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function closeoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  const outcome = closeoffscreen(await memory.getoffscreenentries(), runid, Date.now());
+  if (!outcome.closed) return;
+  const entry = outcome.registry.find((candidate) => candidate.runid === runid && candidate.closedat !== void 0);
+  if (entry) await memory.updateoffscreenentry(entry);
+  try {
+    if (offscreen && await offscreen.hasDocument()) await offscreen.closeDocument();
+  } catch {
+  }
+  await audit("worker", `The offscreen document of the run ${runid} closed with its worker pool; the registry keeps the reasons and justification of the spawn for the audit.`, {});
+}
+function startkeepaliveport(runid) {
+  if (keepaliveport) return;
+  try {
+    keepaliveport = chrome.runtime.connect({ name: `devthinkkeepalive:${runid}` });
+    keepaliveport.onDisconnect.addListener(() => {
+      keepaliveport = void 0;
+    });
+  } catch {
+  }
+}
+async function openplanrun(session, plan) {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const gate = keepalivegate({ session, plan, now: Date.now() });
+  if (!gate.allowed) return;
+  const existing = await memory.getrunstate(runstateprofile);
+  if (existing && existing.keepalive.state === "active") return;
+  const state = openrun({ runid: plan.id, sessionid: session.id, planid: plan.id, profileid: runstateprofile, interval, now: Date.now() });
+  await memory.setrunstate(runstateprofile, state);
+  const lock = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: plan.id, holder: "planrun", now: Date.now() });
+  if (lock.acquired) await memory.setrunlocks(lock.locks);
+  startkeepaliveport(plan.id);
+  await audit("environment", `The run state of the plan ${plan.id} opened with its keepalive port beating every ${interval} milliseconds${lock.acquired ? " and the session locked against concurrent runs" : ""}.`, { sessionid: session.id, planid: plan.id });
+}
+async function markpendingstep(plan, stepid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== plan.id || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, markpending(state, stepid, Date.now()));
+}
+async function recordstepenvironment(step, environment, session, plan, origin, turnaround) {
+  if (session && plan) {
+    await memory.setprogress(recordenvironment2(await memory.getprogress(), plan.id, step.id, environment, Date.now()));
+    const state = await memory.getrunstate(runstateprofile);
+    if (state && state.runid === plan.id) {
+      let next = recordenvironment(state, { stepid: step.id, environment, origin, now: Date.now() });
+      if (turnaround !== void 0) next = recordturnaround(next, { stepid: step.id, milliseconds: turnaround, now: Date.now() });
+      if (["navigate", "openlink", "followlink", "back", "forward"].includes(step.kind) && step.value) next = recordurl(next, { url: step.value, stepid: step.id, now: Date.now() });
+      await memory.setrunstate(runstateprofile, next);
+    }
+  }
+  if (plan && turnaround !== void 0) await memory.setprogress(recordturnaround2(await memory.getprogress(), plan.id, step.id, turnaround, Date.now()));
+}
+async function closeplanrun(planid, sessionid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== planid || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, closerun(state, Date.now()));
+  const release = releaserunlock({ locks: await memory.getrunlocks(), sessionid, runid: planid, now: Date.now() });
+  if (release.released) await memory.setrunlocks(release.locks);
+  try {
+    keepaliveport?.disconnect();
+  } catch {
+  }
+  keepaliveport = void 0;
+  await closeoffscreendocument(planid);
+  await audit("environment", `The run state of the plan ${planid} closed at its terminal state and the keepalive port released.`, { ...sessionid !== "" ? { sessionid } : {}, planid });
+}
+async function executeisolatedevaluate(step, tabid2, origin) {
+  const injection = isolatedinjection(step);
+  const result = await chrome.scripting.executeScript({ target: { tabId: tabid2 }, world: "ISOLATED", func: (code, args, expectedorigin) => {
+    if (location.origin !== expectedorigin) return { ok: false, summary: "Page origin changed before the evaluate step ran." };
+    try {
+      let outcome;
+      try {
+        outcome = new Function(`"use strict"; return (${code});`)(...args);
+      } catch {
+        outcome = new Function(`"use strict"; ${code}`)(...args);
+      }
+      return { ok: true, summary: `Reviewed expression returned ${outcome === void 0 ? "no value" : "a value"} inside the isolated world.`, details: { result: String(outcome) } };
+    } catch (error) {
+      return { ok: false, summary: `Reviewed expression failed inside the isolated world: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }, args: [injection.code, injection.args, origin] });
+  return result[0]?.result ?? { ok: false, summary: "The isolated world returned no result." };
+}
+async function executesandboxrender(step, session, plan, origin) {
+  const options = stepoptions2(step);
+  const markup = typeof options.markup === "string" ? options.markup : "";
+  const sourceorigin = typeof options.sourceorigin === "string" ? options.sourceorigin : origin;
+  const settings = await memory.getsettings();
+  const origingate = sandboxorigingate({ origin: sourceorigin, allowed: settings?.sandboxorigins ?? [] });
+  if (!origingate.allowed) throw new Error(origingate.reason);
+  const render = sandboxrenderof({ id: randomid(), markup, sourceorigin, stepid: step.id, now: Date.now() });
+  await memory.addsandboxrender(render);
+  const hostready = await ensureoffscreendocument(plan?.id ?? step.id);
+  let answer;
+  if (hostready) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "sandboxrender", render: { id: render.id, nonce: render.nonce, markup: render.markup, sourceorigin: render.sourceorigin, stepid: render.stepid } });
+    } catch {
+    }
+  }
+  if (!answer) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "environments", action: "sandboxhost", render: rendermessage(render) });
+    } catch {
+    }
+  }
+  if (!answer) throw new Error("The sandbox frame needs an open host surface: grant the offscreen capability or keep the review panel open so the sandboxed page can render the untrusted markup.");
+  const accepted = acceptrenderresult({ renders: [render], message: { channel: "devthinksandbox", type: "renderresult", nonce: render.nonce, ok: answer.ok, ...answer.text !== void 0 ? { text: answer.text } : {}, summary: answer.summary }, now: Date.now() });
+  if (!accepted.accepted || !accepted.result) throw new Error(accepted.reason);
+  await audit("sandbox", `The step ${step.id} rendered untrusted markup from ${sourceorigin} inside the sandbox frame under the nonce ${render.nonce}; scripts and handlers were stripped before the render and the text never reentered the dom outside the frame.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  await recordstepenvironment(step, "sandboxframe", session, plan, sourceorigin, void 0);
+  return { ok: accepted.result.ok, summary: accepted.result.summary, details: { text: accepted.result.text, nonce: render.nonce, sourceorigin } };
+}
+async function offloadparsetoworker(step, output, session, plan, origin) {
+  const runid = plan?.id ?? step.id;
+  const ready = await ensureoffscreendocument(runid);
+  if (!ready) return { output, turnaround: void 0 };
+  const payload = JSON.stringify({ summary: output?.summary ?? "", details: output?.details ?? {} });
+  const request = workerrequestof({ id: randomid(), runid, stepid: step.id, kind: step.kind, payload, options: stepoptions2(step), sentat: Date.now() });
+  const started = Date.now();
+  let answer;
+  try {
+    answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "parse", request: { id: request.id, runid: request.runid, stepid: request.stepid, task: request.task, payload: request.payload, transferables: request.transferables } });
+  } catch {
+  }
+  const turnaround = Date.now() - started;
+  if (!answer) return { output, turnaround: void 0 };
+  const provenance = { origin, stepid: step.id, environment: "offscreenworker" };
+  await memory.addworkerevent({ id: randomid(), runid, kind: "spawn", workers: workerpoolcounts.get(runid) ?? 1, reason: `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool with the transferable keys ${request.transferables.length > 0 ? request.transferables.join(", ") : "none"}.`, provenance, at: Date.now() });
+  await audit("worker", `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool and answered in ${turnaround} milliseconds${answer.ok === false ? " with a refusal the inline parse covers" : ""}.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  const parsed = { ok: answer.ok !== false && (output?.ok ?? true), summary: answer.summary ?? output?.summary ?? "The offscreen worker answered the parse.", details: { ...output?.details ?? {}, workerparse: answer.result ?? "", task: request.task, turnaround } };
+  return { output: parsed, turnaround };
+}
+async function environmentviewof() {
+  const session = await memory.getsession();
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  const swept = zombiesweep({ states, now: Date.now(), interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+  const open = states.find((state) => state.keepalive.state === "active") ?? states[0];
+  const workers = (await chrome.runtime.sendMessage({ kind: "offscreen", action: "pool" }).catch(() => void 0))?.workers ?? 0;
+  return {
+    report: environmentreport({ environments: open?.environments ?? {}, turnarounds: open?.turnarounds ?? {}, offscreen: await memory.getoffscreenentries(), workers, ...open !== void 0 ? { keepalive: { runid: open.keepalive.runid, state: open.keepalive.state, beats: open.keepalive.beats, lastbeatat: open.keepalive.lastbeatat, portopen: open.keepalive.portopen } } : {} }),
+    ...session?.environmentgrants !== void 0 ? { grants: session.environmentgrants } : {},
+    requirements: environmentrequirements(),
+    registry: executorregistry(),
+    offscreengranted: await offscreengranted(),
+    parseoffload: settings?.parseoffload === true,
+    ...settings?.workerpoolsize !== void 0 ? { workerpoolsize: settings.workerpoolsize } : {},
+    ...settings?.sandboxorigins !== void 0 ? { sandboxorigins: settings.sandboxorigins } : {},
+    workerevents: (await memory.getworkerevents()).map((event) => ({ id: event.id, runid: event.runid, kind: event.kind, workers: event.workers, reason: event.reason, at: event.at })),
+    runstates: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, ...state.pendingstepid !== void 0 ? { pendingstepid: state.pendingstepid } : {}, urls: state.urlhistory.length })),
+    locks: await memory.getrunlocks(),
+    zombies: swept.reaped,
+    urls: (open?.urlhistory ?? []).slice(-50),
+    ...open !== void 0 ? { recovery: recoveryplan(open) } : {},
+    ...open !== void 0 && open.state === "recovered" ? { restartnotice: `The service worker restarted and the run ${open.runid} reattached from its persisted run state; the pending step ${open.pendingstepid ?? "none"} waits for the user.` } : {}
+  };
+}
+async function keepalivetick() {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const tolerance = settings?.zombieintervals ?? roadmapzombieintervals;
+  for (const state of await memory.listrunstates()) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, beatrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+  }
+  const swept = zombiesweep({ states: await memory.listrunstates(), now: Date.now(), interval, missedlimit: tolerance });
+  for (const runid of swept.reaped) {
+    await closeoffscreendocument(runid);
+    await audit("environment", `The zombie reaper closed the run ${runid} whose heartbeat fell silent past the ${tolerance} tolerated interval${tolerance === 1 ? "" : "s"}; the popup offers the reap action.`, {});
+  }
+  for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+  await memory.expirerunstates(settings?.runstateretention, Date.now());
+  const locks = expirerunlocks(await memory.getrunlocks(), Date.now());
+  if (locks.expired.length > 0) await memory.setrunlocks(locks.locks);
+  try {
+    const estimate = await navigator.storage.estimate();
+    if (estimate.usage !== void 0) await memory.trackrunstatequota(estimate.usage);
+    if (settings?.runstatebytes !== void 0) {
+      const quota = await memory.getrunstatequota();
+      if (quota && quota.used > settings.runstatebytes) {
+        const pruned = prunerunstates({ states: await memory.listrunstates(), used: quota.used, ceiling: settings.runstatebytes });
+        for (const runid of pruned.pruned) {
+          const state = await memory.listrunstates();
+          const target = state.find((entry) => entry.runid === runid);
+          if (target) await memory.removerunstate(target.profileid);
+        }
+        if (pruned.pruned.length > 0) await audit("environment", pruned.reason, {});
+      }
+    }
+  } catch {
+  }
+}
+async function restorerunstates() {
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  for (const state of states) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, reattachrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+    await audit("environment", `The service worker restarted and the run ${state.runid} reattached its keepalive port from the persisted run state; ${recoveryplan(state).reason}`, {});
+  }
+  void settings;
+}
 async function startsession() {
   const { tab, origin } = await activecontext();
   const session = { id: randomid(), tabid: tab.id, origin, startedat: Date.now(), expiresat: Date.now() + sessionduration, grants: [origin] };
@@ -17889,6 +19137,18 @@ async function executestep(stepid) {
 async function executeaction(step, session, plan, tabid2, origin, settings, verdicts, mode) {
   const gate = canexecute({ session, plan, step, tabid: tabid2, origin, ...verdicts !== void 0 && verdicts.length > 0 ? { verdicts } : {}, ...settings !== void 0 ? { settings } : {} });
   if (!gate.allowed) throw new Error(gate.reason);
+  const environmentverdict = stepenvironmentvalid(step);
+  if (!environmentverdict.allowed) throw new Error(environmentverdict.reason);
+  const environmentgrantverdict = environmentgrantgate(step, session?.environmentgrants);
+  if (!environmentgrantverdict.allowed) throw new Error(environmentgrantverdict.reason);
+  const offgranted = await offscreengranted();
+  const routing = routeenvironment(step, { offload: settings?.parseoffload === true, granted: offgranted });
+  const capabilityverdict = offscreencapabilitygate({ environment: routing.environment, granted: offgranted });
+  if (!capabilityverdict.allowed) throw new Error(capabilityverdict.reason);
+  if (routing.fallback && plan) await audit("environment", `The ${step.kind} step ${step.id} fell back to inline parsing inside the page because the offscreen capability grant stays absent.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  if (session && plan && plan.state === "approved" && mode === "plan") await openplanrun(session, plan);
+  if (plan && plan.state === "approved") await markpendingstep(plan, step.id);
+  if (routing.environment === "sandboxframe") return executesandboxrender(step, session, plan, origin);
   const capability = requiredcapability(step.kind);
   if (capability) {
     const granted = await chrome.permissions.contains({ permissions: [capability] });
@@ -17976,8 +19236,12 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
     return output;
   };
   const runplan = plan;
+  const isolatedresult = routing.environment === "isolatedworld" ? await executeisolatedevaluate(step, tabid2, origin) : void 0;
+  let workerturnaround;
   const capturepolicystate = await runcapturepolicy();
-  if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
+  if (isolatedresult !== void 0) {
+    output = isolatedresult;
+  } else if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
     const before = await grabstateshot(step, session, runplan, tabid2, "before");
     output = await dispatchreviewedstep();
     if (output?.ok) {
@@ -17993,8 +19257,14 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   } else {
     output = await dispatchreviewedstep();
   }
+  if (routing.environment === "offscreenworker" && workerturnaround === void 0) {
+    const offloaded = await offloadparsetoworker(step, output, session, plan, origin);
+    output = offloaded.output ?? output;
+    workerturnaround = offloaded.turnaround;
+  }
   if (["navigate", "back", "forward"].includes(step.kind)) await recordnavigation(step, session, tabid2);
   await recordevidence(step, output, session, plan, origin);
+  await recordstepenvironment(step, routing.environment, session, plan, origin, workerturnaround);
   if (output?.ok && plan && typeof output.details?.tabid === "number") {
     await memory.setprogress(assigntasktab(await memory.getprogress(), plan.id, output.details.tabid, Date.now()));
   }
@@ -18003,7 +19273,7 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   if (resolved) {
     await memory.addresolution({ stepid: step.id, mode: resolved.mode, selector: resolved.selector, label: resolved.label, at: Date.now() });
   }
-  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, ...output?.details ? { details: output.details } : {}, at: Date.now() };
+  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, environment: routing.environment, ...output?.details ? { details: output.details } : {}, at: Date.now() };
   const auditkind = stepauditkind(step, Boolean(output?.ok));
   await audit(auditkind, summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
   await memory.addoutcome(outcome);
@@ -18035,6 +19305,7 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
       });
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
+      await closeplanrun(done.id, session?.id ?? "");
       await audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
     }
   }
@@ -18220,7 +19491,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof() };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof(), environments: await environmentviewof() };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -20820,6 +22091,7 @@ async function handlerequest(message, sender) {
           const context = agentruncontext({ agent, task: claimed.task, now });
           await memory.addagentevent(agenteventof({ id: randomid(), kind: "claimed", agentid, taskid: claimed.task.id, summary: `The agent ${agent.name} claimed the task ${claimed.task.payload} from the lane ${claimed.task.lane}; the run context ${context.run.id} reuses the workflow engine.`, now }));
           await audit("swarm", `The agent ${agent.name} claimed the highest priority task of the lane ${claimed.task.lane}; the per agent run context ${context.run.id} reuses the workflow engine and the proposal still passes the human review.`, {});
+          await memory.addswarmaction({ id: randomid(), kind: "claim", agentid, summary: `The agent ${agent.name} claimed the task ${claimed.task.payload} from the lane ${claimed.task.lane}.`, at: now });
         }
         return swarmstateof();
       }
@@ -20835,6 +22107,7 @@ async function handlerequest(message, sender) {
         if (stolen.task !== void 0) {
           await memory.addagentevent(agenteventof({ id: randomid(), kind: "stole", agentid, taskid: stolen.task.id, summary: `The ${input2.role} agent ${agentid} stole the task ${stolen.task.payload} from the lane ${stolen.task.lane}; ${grade.reason ?? ""}`, now }));
           await audit("swarm", `The ${input2.role} agent ${agentid} stole a task from the lane ${stolen.task.lane} inside the approved swarm; the lane ownership rules the user configured held.`, {});
+          await memory.addswarmaction({ id: randomid(), kind: "steal", agentid, summary: `The ${input2.role} agent ${agentid} stole the task ${stolen.task.payload} from the lane ${stolen.task.lane}.`, at: now });
         }
         return swarmstateof();
       }
@@ -20849,6 +22122,7 @@ async function handlerequest(message, sender) {
         await memory.setagentusage(nextusage);
         await memory.addagentevent(agenteventof({ id: randomid(), kind: "completed", taskid, ...holder !== void 0 ? { agentid: holder.agentid } : {}, summary: `The task ${completedtask?.payload ?? taskid} completed and its claim released.`, now }));
         await audit("swarm", `The task ${taskid} completed${holder !== void 0 ? ` under the agent ${holder.agentid}` : ""} and released its claim; the per agent usage counters moved with it.`, {});
+        await memory.addswarmaction({ id: randomid(), kind: "complete", ...holder !== void 0 ? { agentid: holder.agentid } : {}, summary: `The task ${completedtask?.payload ?? taskid} completed and its claim released.`, at: now });
         return swarmstateof();
       }
       if (input2.cancel === true && input2.taskid !== void 0) {
@@ -20930,6 +22204,483 @@ async function handlerequest(message, sender) {
       }
       throw new Error("The swarm blackboard request carries no post, retire or sweep action.");
     }
+    case "swarmleader": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.elect !== void 0) {
+        const agents = await memory.getagents();
+        const rule = input2.elect.rule === "named" ? { kind: "named", agentid: input2.elect.agentid ?? "" } : { kind: "first" };
+        const verdict = leaderelectionvalid({ rule, agents });
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const topology2 = electleader({ agents, id: randomid(), rule, now });
+        await memory.settopology(topology2);
+        await memory.addswarmaction({ id: randomid(), kind: "elect", agentid: topology2.leaderid, summary: `The ${rule.kind} election rule the user configured elected the agent ${topology2.leaderid} leader of the swarm with ${topology2.workerids.length} workers, ${topology2.criticids.length} critics and ${topology2.verifierids.length} verifiers.`, at: now });
+        await memory.addagentevent(agenteventof({ id: randomid(), kind: "assign", agentid: topology2.leaderid, summary: `The leader election picked ${topology2.leaderid} by the ${rule.kind} rule; the topology records the lanes.`, now }));
+        await audit("swarm", `The user elected the agent ${topology2.leaderid} leader by the ${rule.kind} rule; the topology holds ${topology2.workerids.length} workers, ${topology2.criticids.length} critics and ${topology2.verifierids.length} verifiers, and the leader only organizes work that still passes the same review.`, {});
+        return swarmstateof();
+      }
+      const topology = await memory.gettopology();
+      if (input2.assign !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the assignment.");
+        const queue = await queueof();
+        const wanted = input2.assign.taskids ?? [];
+        const tasks = queue.items.filter((task) => wanted.length === 0 || wanted.includes(task.id));
+        const next = assignwork({ topology, tasks, now });
+        await memory.settopology(next);
+        await memory.addswarmaction({ id: randomid(), kind: "assign", agentid: next.leaderid, summary: `The leader sliced ${next.assignments.length} task${next.assignments.length === 1 ? "" : "s"} across the ${next.workerids.length} workers of the topology.`, at: now });
+        await audit("swarm", `The leader ${next.leaderid} assigned ${next.assignments.length} task slice${next.assignments.length === 1 ? "" : "s"} across the ${next.workerids.length} workers; every slice still passes the same plan review before anything executes.`, {});
+        return swarmstateof();
+      }
+      if (input2.collect !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the collection.");
+        const gathered = collectresults({ topology, outputs: input2.collect.outputs ?? [] });
+        await memory.addswarmaction({ id: randomid(), kind: "collect", agentid: topology.leaderid, summary: `The leader gathered ${gathered.gathered.length - gathered.missing.length} worker output${gathered.gathered.length - gathered.missing.length === 1 ? "" : "s"} with ${gathered.missing.length} still pending.`, at: now });
+        await audit("swarm", `The leader ${topology.leaderid} collected ${gathered.gathered.length} worker outputs with ${gathered.missing.length} pending; the missing slices stay visible to the user.`, {});
+        return { ...await swarmstateof(), collected: gathered.gathered, missing: gathered.missing };
+      }
+      if (input2.scale !== void 0) {
+        if (!topology) throw new Error("The swarm holds no topology; the user elects a leader before the scaling.");
+        const settings = await memory.getsettings();
+        const bound = input2.scale.bound ?? settings?.swarmworkers;
+        const verdict = workerscalevalid(bound);
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const agents = await memory.getagents();
+        const outcome = scaleworkers({ topology, agents, pending: input2.scale.pending ?? 0, ...bound !== void 0 ? { bound } : {}, now });
+        await memory.settopology(outcome.topology);
+        await memory.addswarmaction({ id: randomid(), kind: "scale", agentid: topology.leaderid, summary: outcome.reason, at: now });
+        await audit("swarm", `The worker lane scaled: ${outcome.reason}`, {});
+        return { ...await swarmstateof(), scaleadded: outcome.added, scaleretired: outcome.retired };
+      }
+      if (input2.split !== void 0) {
+        const split = plannersplit({ id: randomid(), planownerid: input2.split.planownerid?.trim() ?? "", runownerid: input2.split.runownerid?.trim() ?? "", ...input2.split.taskid !== void 0 && input2.split.taskid.trim() !== "" ? { taskid: input2.split.taskid.trim() } : {}, now });
+        await memory.setplannersplits([...(await memory.getplannersplits()).filter((entry) => entry.id !== split.id), split]);
+        await memory.addswarmaction({ id: randomid(), kind: "split", summary: `The task ${split.taskid ?? "of the swarm"} split between the planner ${split.planownerid} and the executor ${split.runownerid}; the executor reports every step outcome back.`, at: now });
+        await audit("swarm", `The user split the task ${split.taskid ?? ""} between the planner agent ${split.planownerid} and the executor agent ${split.runownerid}; the executor reports every step outcome back to the planner.`, {});
+        return swarmstateof();
+      }
+      if (input2.stepreport !== void 0) {
+        const splitid = input2.stepreport.splitid?.trim() ?? "";
+        const split = (await memory.getplannersplits()).find((entry) => entry.id === splitid);
+        if (!split) throw new Error(`The planner executor split ${splitid} does not exist.`);
+        const outcome = input2.stepreport.outcome === "failed" ? "failed" : "done";
+        const next = reportstep({ split, stepid: input2.stepreport.stepid?.trim() ?? "", outcome, detail: input2.stepreport.detail?.trim() ?? "", now });
+        await memory.setplannersplits((await memory.getplannersplits()).map((entry) => entry.id === split.id ? next : entry));
+        await memory.addswarmaction({ id: randomid(), kind: "stepreport", agentid: split.runownerid, summary: `The executor ${split.runownerid} reported the step ${next.stepreports[next.stepreports.length - 1]?.stepid ?? ""} ${outcome} back to the planner ${split.planownerid}.`, at: now });
+        await audit("swarm", `The executor ${split.runownerid} reported the step ${input2.stepreport.stepid ?? ""} ${outcome} back to the planner ${split.planownerid}; the split record keeps every step outcome.`, {});
+        return swarmstateof();
+      }
+      if (input2.milestone !== void 0) {
+        const agentid = input2.milestone.agentid?.trim() ?? "";
+        if (agentid === "" || input2.milestone.label === void 0 || input2.milestone.label.trim() === "") throw new Error("The milestone needs its agent and its label.");
+        const board = boardstate({ agents: await memory.getagents(), queue: await queueof(), ...topology !== void 0 ? { topology } : {}, now });
+        const milestone = { label: input2.milestone.label.trim(), done: input2.milestone.done !== false, ...input2.milestone.done !== false ? { at: now } : {} };
+        await memory.addboardsnapshot({ ...board, lanes: board.lanes.map((lane) => lane.agentid === agentid ? { ...lane, milestones: [...lane.milestones.filter((entry) => entry.label !== milestone.label), milestone] } : lane) });
+        await memory.addswarmaction({ id: randomid(), kind: "milestone", agentid, summary: `The agent ${agentid} reached the milestone ${milestone.label}.`, at: now });
+        await audit("swarm", `The agent ${agentid} reported the milestone ${milestone.label}; the progressboard snapshot stores it under the user configured retention.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm leader request carries no elect, assign, collect, scale, split, stepreport or milestone action.");
+    }
+    case "swarmreview": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.request !== void 0) {
+        const requests = requestreview({ requests: await memory.getreviewrequests(), id: randomid(), fromagentid: input2.request.fromagentid?.trim() ?? "", toagentid: input2.request.toagentid?.trim() ?? "", subject: input2.request.subject ?? "", payload: input2.request.payload ?? "", ...input2.request.timeoutms !== void 0 ? { timeoutms: input2.request.timeoutms } : {}, now });
+        await memory.setreviewrequests(requests);
+        const requesterid = input2.request.fromagentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "review", ...requesterid !== "" ? { agentid: requesterid } : {}, summary: `The agent ${input2.request.fromagentid?.trim() ?? ""} routed the review of ${input2.request.subject ?? ""} to the agent ${input2.request.toagentid?.trim() ?? ""}.`, at: now });
+        await audit("swarm", `The review request of ${input2.request.subject ?? ""} was routed from ${input2.request.fromagentid ?? ""} to ${input2.request.toagentid ?? ""}${input2.request.timeoutms !== void 0 ? ` with the user configured answer window ${input2.request.timeoutms}ms` : ""}; the review stays read only over the agent output.`, {});
+        return swarmstateof();
+      }
+      if (input2.ack !== void 0) {
+        const requests = ackreview({ requests: await memory.getreviewrequests(), id: input2.ack.trim(), now });
+        await memory.setreviewrequests(requests);
+        await audit("swarm", `The review request ${input2.ack} was acked; the answer still waits.`, {});
+        return swarmstateof();
+      }
+      if (input2.apply !== void 0) {
+        const verdict = input2.apply.verdict === "approve" || input2.apply.verdict === "reject" ? input2.apply.verdict : "changes";
+        const outcome = applyreview({ requests: await memory.getreviewrequests(), id: input2.apply.id?.trim() ?? "", reviewerid: input2.apply.reviewerid?.trim() ?? "", verdict, issues: input2.apply.issues ?? [], requiredchanges: input2.apply.requiredchanges ?? [], ...input2.apply.taskid !== void 0 && input2.apply.taskid.trim() !== "" ? { taskid: input2.apply.taskid.trim() } : {}, now });
+        const grade = criticreviewgrade(outcome.review);
+        if (!grade.allowed) throw new Error(grade.reason);
+        await memory.setreviewrequests(outcome.requests);
+        await memory.addcriticreview(outcome.review);
+        await memory.addswarmaction({ id: randomid(), kind: "review", agentid: outcome.review.reviewerid, summary: `The critic ${outcome.review.reviewerid} returned the ${verdict} verdict over the output of ${outcome.review.subjectagentid}.`, at: now });
+        await audit("swarm", `The critic ${outcome.review.reviewerid} reviewed the output of ${outcome.review.subjectagentid} with the ${verdict} verdict${outcome.review.requiredchanges.length > 0 ? ` and ${outcome.review.requiredchanges.length} required change${outcome.review.requiredchanges.length === 1 ? "" : "s"}` : ""}; the critic reads only and the rework still passes the same human review.`, {});
+        return swarmstateof();
+      }
+      if (input2.sweep === true) {
+        const swept = sweepreviews({ requests: await memory.getreviewrequests(), now });
+        await memory.setreviewrequests(swept.requests);
+        if (swept.timedout.length > 0) await audit("swarm", `The review sweep timed out ${swept.timedout.length} unanswered request${swept.timedout.length === 1 ? "" : "s"} past the user configured window.`, {});
+        return swarmstateof();
+      }
+      if (input2.verify !== void 0) {
+        const settings = await memory.getsettings();
+        const check = checkclaim({ id: randomid(), verifierid: input2.verify.verifierid?.trim() ?? "", claimagentid: input2.verify.claimagentid?.trim() ?? "", claim: input2.verify.claim ?? "", method: input2.verify.method?.trim() ?? "", outcome: input2.verify.outcome === "fail" ? "fail" : "pass", ...input2.verify.evidence !== void 0 && input2.verify.evidence.trim() !== "" ? { evidence: input2.verify.evidence } : {}, ...input2.verify.taskid !== void 0 && input2.verify.taskid.trim() !== "" ? { taskid: input2.verify.taskid.trim() } : {}, now });
+        const grade = verifiermethodgrade({ method: check.method, allowed: settings?.verifiermethods ?? [] });
+        if (!grade.allowed) throw new Error(grade.reason);
+        await memory.addverifiercheck(check);
+        await memory.addswarmaction({ id: randomid(), kind: "verify", agentid: check.verifierid, summary: `The verifier ${check.verifierid} marked the claim of ${check.claimagentid} ${check.outcome} by the ${check.method} method.`, at: now });
+        await audit("swarm", `The verifier ${check.verifierid} checked the claim of ${check.claimagentid} by the ${check.method} method and marked it ${check.outcome}${check.evidence !== void 0 ? ` with the evidence ${check.evidence}` : ""}; the verifier check reads the page and never writes.`, {});
+        return swarmstateof();
+      }
+      if (input2.escalate !== void 0) {
+        const record2 = escalate({ id: randomid(), agentid: input2.escalate.agentid?.trim() ?? "", subject: input2.escalate.subject ?? "", context: input2.escalate.context ?? "", now });
+        const gate = escalationgate(record2);
+        if (!gate.allowed) throw new Error(gate.reason);
+        await memory.addescalation(record2);
+        await memory.addswarmaction({ id: randomid(), kind: "escalate", agentid: record2.agentid, summary: `The agent ${record2.agentid} lifted the stalled decision ${record2.subject} to the user with its full context.`, at: now });
+        await audit("swarm", `The agent ${record2.agentid} escalated the decision ${record2.subject} to the user; the escalation stays human decided and the agent waits.`, {});
+        return swarmstateof();
+      }
+      if (input2.decide !== void 0) {
+        const record2 = (await memory.getescalations()).find((entry) => entry.id === input2.decide?.id?.trim());
+        if (!record2) throw new Error(`The escalation ${input2.decide?.id ?? ""} does not exist.`);
+        const resolved = resolveescalation({ escalation: record2, decision: input2.decide.decision ?? "", now });
+        await memory.updateescalation(resolved);
+        await memory.addswarmaction({ id: randomid(), kind: "escalate", agentid: record2.agentid, summary: `The user decided the escalation ${record2.subject}: ${resolved.decision}.`, at: now });
+        await audit("swarm", `The user decided the escalation ${record2.subject} of the agent ${record2.agentid}; the decision is recorded and the agent continues from it.`, {});
+        return swarmstateof();
+      }
+      if (input2.consensus !== void 0) {
+        const settings = await memory.getsettings();
+        const agents = await memory.getagents();
+        const quorum = input2.consensus.quorum ?? settings?.swarmquorum;
+        if (quorum === void 0) throw new Error("The consensus round needs its quorum; the user configures it or sets the swarmquorum run setting.");
+        const voters = agents.filter((agent) => agent.state !== "stopped").length;
+        const verdict = consensusquorumvalid({ quorum, voters });
+        if (!verdict.allowed) throw new Error(verdict.reason);
+        const round = openconsensus({ id: randomid(), subject: input2.consensus.subject ?? "", quorum, now });
+        await memory.setconsensusround(round);
+        await memory.addswarmaction({ id: randomid(), kind: "consensus", summary: `The consensus round on ${round.subject} opened with the user configured quorum ${quorum}.`, at: now });
+        await audit("swarm", `The consensus round on ${round.subject} opened with the user configured quorum ${quorum} of ${voters} voting agents; the round carries when the yes votes reach it.`, {});
+        return swarmstateof();
+      }
+      if (input2.vote !== void 0) {
+        const round = (await memory.getconsensusrounds()).find((entry) => entry.id === input2.vote?.id?.trim());
+        if (!round) throw new Error(`The consensus round ${input2.vote?.id ?? ""} does not exist.`);
+        const vote = input2.vote.vote === "no" ? "no" : input2.vote.vote === "abstain" ? "abstain" : "yes";
+        const next = castvote({ round, agentid: input2.vote.agentid?.trim() ?? "", vote, now });
+        await memory.setconsensusround(next);
+        const voterid = input2.vote.agentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "consensus", ...voterid !== "" ? { agentid: voterid } : {}, summary: `The agent ${input2.vote.agentid?.trim() ?? ""} voted ${vote} on ${round.subject}; the round is ${next.state}.`, at: now });
+        await audit("swarm", `The agent ${input2.vote.agentid ?? ""} voted ${vote} on ${round.subject}; the round reads ${consensusstate(next).yes} yes, ${consensusstate(next).no} no and ${consensusstate(next).abstain} abstain against the quorum ${round.quorum}.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm review request carries no request, ack, apply, sweep, verify, escalate, decide, consensus or vote action.");
+    }
+    case "swarmhandoff": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.prepare !== void 0) {
+        const agents = await memory.getagents();
+        const record2 = preparehandoff({ agents, id: randomid(), fromagentid: input2.prepare.fromagentid?.trim() ?? "", toagentid: input2.prepare.toagentid?.trim() ?? "", taskstate: input2.prepare.taskstate ?? "", ...input2.prepare.tabid !== void 0 ? { tabid: input2.prepare.tabid } : {}, ...input2.prepare.reason !== void 0 && input2.prepare.reason.trim() !== "" ? { reason: input2.prepare.reason } : {}, now });
+        await memory.addhandoff(record2);
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: record2.fromagentid, summary: `The tab ${record2.tabid} handoff from ${record2.fromagentid} to ${record2.toagentid} was prepared with the packaged task state.`, at: now });
+        await audit("swarm", `The handoff of tab ${record2.tabid} from ${record2.fromagentid} to ${record2.toagentid} was prepared with the packaged task state; the transfer preserves the original session grants.`, {});
+        return swarmstateof();
+      }
+      if (input2.transfer !== void 0) {
+        const record2 = (await memory.gethandoffs()).find((entry) => entry.id === input2.transfer?.trim());
+        if (!record2) throw new Error(`The handoff ${input2.transfer ?? ""} does not exist.`);
+        const agents = await memory.getagents();
+        const receiver = agents.find((agent) => agent.id === record2.toagentid);
+        const session = await memory.getsession();
+        const gate = handoffgrantgate({ record: record2, toscope: receiver?.scope, sessiongrants: session?.grants ?? [] });
+        if (!gate.allowed) throw new Error(gate.reason);
+        const outcome = transferhandoff({ agents, handoffs: await memory.gethandoffs(), id: record2.id, now });
+        await memory.setagents(outcome.agents);
+        await memory.updatehandoff(outcome.handoffs.find((entry) => entry.id === record2.id));
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: record2.toagentid, summary: `The tab ${record2.tabid} moved from ${record2.fromagentid} to ${record2.toagentid}; the task state stays packaged until the resume.`, at: now });
+        await audit("swarm", `The tab ${record2.tabid} moved from ${record2.fromagentid} to ${record2.toagentid} under the one agent per tab rule; ${gate.reason ?? ""}`, {});
+        return swarmstateof();
+      }
+      if (input2.resume !== void 0) {
+        const record2 = (await memory.gethandoffs()).find((entry) => entry.id === input2.resume?.trim());
+        if (!record2) throw new Error(`The handoff ${input2.resume ?? ""} does not exist.`);
+        const resumed = resumehandoff({ handoffs: await memory.gethandoffs(), id: record2.id, now });
+        await memory.updatehandoff(resumed);
+        await memory.addswarmaction({ id: randomid(), kind: "handoff", agentid: resumed.toagentid, summary: `The agent ${resumed.toagentid} resumed the task from the packaged state of the handoff ${resumed.id}.`, at: now });
+        await audit("swarm", `The agent ${resumed.toagentid} resumed the handed off task from its packaged state; the run continues behind the same session, plan and origin gates.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm handoff request carries no prepare, transfer or resume action.");
+    }
+    case "swarmlocks": {
+      const input2 = message;
+      const now = Date.now();
+      if (input2.acquire !== void 0) {
+        const holder = input2.acquire.holder?.trim() ?? "";
+        const origin = input2.acquire.origin?.trim() ?? "";
+        const selector = input2.acquire.selector?.trim() ?? "";
+        if (holder === "" || origin === "" || selector === "") throw new Error("The lock acquisition needs its holder, origin and selector.");
+        const kind = input2.acquire.kind === "shared" ? "shared" : "exclusive";
+        const locks = await memory.getlocks();
+        const grade = lockscopevalid({ key: lockkey(origin, selector), holder, kind, origin, selector, acquiredat: now, ...input2.acquire.expiresat !== void 0 ? { expiresat: input2.acquire.expiresat } : {} });
+        if (!grade.allowed) throw new Error(grade.reason);
+        const outcome = acquirelock({ locks, holder, origin, selector, kind, ...input2.acquire.expiresat !== void 0 ? { expiresat: input2.acquire.expiresat } : {}, now });
+        if (!outcome.acquired) throw new Error(outcome.reason);
+        await memory.setlocks(outcome.locks);
+        await memory.addswarmaction({ id: randomid(), kind: "lock", agentid: holder, summary: outcome.reason, at: now });
+        await audit("swarm", `The ${kind} lock ${origin}|${selector} went to the agent ${holder}${input2.acquire.expiresat !== void 0 ? ` with the user configured expiry ${new Date(input2.acquire.expiresat).toISOString()}` : " with no expiry"}; the lock serializes work the same review already approved.`, {});
+        return swarmstateof();
+      }
+      if (input2.release !== void 0) {
+        const locks = await memory.getlocks();
+        const outcome = releaselock({ locks, key: input2.release.key?.trim() ?? "", holder: input2.release.holder?.trim() ?? "", now });
+        if (!outcome.released) throw new Error(`The agent ${input2.release.holder ?? ""} holds no lock ${input2.release.key ?? ""}.`);
+        await memory.setlocks(outcome.locks);
+        const releaserid = input2.release.holder?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "lock", ...releaserid !== "" ? { agentid: releaserid } : {}, summary: `The agent ${input2.release.holder?.trim() ?? ""} released the lock ${input2.release.key ?? ""}; the resource returned to the pool.`, at: now });
+        await audit("swarm", `The agent ${input2.release.holder ?? ""} released the lock ${input2.release.key ?? ""}; the resource returned to the pool for the next agent.`, {});
+        return swarmstateof();
+      }
+      if (input2.sweep === true) {
+        const outcome = expirelocks({ locks: await memory.getlocks(), now });
+        await memory.setlocks(outcome.locks);
+        if (outcome.expired.length > 0) {
+          await memory.addswarmaction({ id: randomid(), kind: "lock", summary: `The expiry sweep returned ${outcome.expired.length} abandoned lock${outcome.expired.length === 1 ? "" : "s"} to the pool.`, at: now });
+          await audit("swarm", `The lock sweep expired ${outcome.expired.length} abandoned lock${outcome.expired.length === 1 ? "" : "s"} past their user configured expiry; the keys returned to the pool.`, {});
+        }
+        return swarmstateof();
+      }
+      if (input2.scan !== void 0) {
+        const writers = (input2.scan.writers ?? []).map((writer) => ({ agentid: writer.agentid?.trim() ?? "", origin: writer.origin?.trim() ?? "", selector: writer.selector?.trim() ?? "", ...writer.taskid !== void 0 && writer.taskid.trim() !== "" ? { taskid: writer.taskid.trim() } : {} })).filter((writer) => writer.agentid !== "" && writer.origin !== "" && writer.selector !== "");
+        const scan = scanconflicts({ id: randomid(), writers, now });
+        await memory.addconflictscan(scan);
+        await memory.addswarmaction({ id: randomid(), kind: "conflict", summary: scan.clean ? `The conflict scan found no overlapping write among ${writers.length} writers.` : `The conflict scan found ${scan.overlaps.length} overlapping target${scan.overlaps.length === 1 ? "" : "s"} among ${writers.length} writers with the suggested order ${scan.suggestedorder.join(" \u2192 ")}.`, at: now });
+        await audit("swarm", scan.clean ? `The conflict scan of ${writers.length} parallel writers found no overlapping write; the runs stay safe side by side.` : `The conflict scan found ${scan.overlaps.length} overlapping target${scan.overlaps.length === 1 ? "" : "s"} (${scan.overlaps.map((overlap) => `${overlap.origin}|${overlap.selector} by ${overlap.writers.join(", ")}`).join("; ")}) and suggested the order ${scan.suggestedorder.join(" \u2192 ")}.`, {});
+        return { ...await swarmstateof(), scan };
+      }
+      if (input2.arbitrate !== void 0) {
+        const strategy = input2.arbitrate.strategy === "age" ? "age" : input2.arbitrate.strategy === "leader" ? "leader" : "priority";
+        const rule = { id: randomid(), strategy, priorityorder: input2.arbitrate.priorityorder ?? [], configuredat: now };
+        const topology = await memory.gettopology();
+        const claims = (input2.arbitrate.claims ?? []).map((claim2) => ({ agentid: claim2.agentid?.trim() ?? "", claimedat: claim2.claimedat ?? now })).filter((claim2) => claim2.agentid !== "");
+        const order = arbitrate({ rule, ...topology !== void 0 ? { leaderid: topology.leaderid } : {}, claims });
+        await memory.addswarmaction({ id: randomid(), kind: "arbitrate", summary: `The ${strategy} arbitration rule ordered the competing claims ${order.join(" \u2192 ")}.`, at: now });
+        await audit("swarm", `The user configured ${strategy} arbitration ordered the competing resource claims ${order.join(" \u2192 ")}; the ordering stays a user rule.`, {});
+        return { ...await swarmstateof(), arbitration: order };
+      }
+      throw new Error("The swarm locks request carries no acquire, release, sweep, scan or arbitrate action.");
+    }
+    case "swarmmerge": {
+      const input2 = message;
+      const now = Date.now();
+      const toentries = () => (input2.entries ?? []).map((entry, index) => ({ id: `${now}:${index}`, agentid: entry.agentid?.trim() ?? "", ...entry.taskid !== void 0 && entry.taskid.trim() !== "" ? { taskid: entry.taskid.trim() } : {}, key: entry.key?.trim() ?? "", value: entry.value ?? "", mergedat: now })).filter((entry) => entry.key !== "" && entry.agentid !== "");
+      const ruleof = (value) => value === "last" ? "last" : value === "preferagent" ? "preferagent" : value === "fail" ? "fail" : "first";
+      if (input2.merge !== void 0) {
+        const fold = mergeresults({ entries: toentries(), rule: ruleof(input2.merge.rule), ...input2.merge.preferagent !== void 0 && input2.merge.preferagent.trim() !== "" ? { preferagent: input2.merge.preferagent.trim() } : {}, now });
+        const grade = conflictresolutiongrade(ruleof(input2.merge.rule));
+        if (!grade.allowed) throw new Error(grade.reason);
+        await audit("swarm", `The merge folded ${input2.entries?.length ?? 0} parallel results under the ${ruleof(input2.merge.rule)} rule with ${fold.conflicts.length} conflict${fold.conflicts.length === 1 ? "" : "s"} resolved and every merged value keeping its provenance; ${grade.reason ?? ""}`, {});
+        return { ...await swarmstateof(), merged: fold.entries, mergeconflicts: fold.conflicts, mergerefused: fold.refused };
+      }
+      if (input2.report !== void 0) {
+        const rule = ruleof(input2.report.rule);
+        const grade = conflictresolutiongrade(rule);
+        if (!grade.allowed) throw new Error(grade.reason);
+        const built = swarmreport({ id: randomid(), title: input2.report.title ?? "", outputs: toentries(), rule, ...input2.report.preferagent !== void 0 && input2.report.preferagent.trim() !== "" ? { preferagent: input2.report.preferagent.trim() } : {}, ...input2.report.confidence !== void 0 && input2.report.confidence.trim() !== "" ? { confidence: input2.report.confidence } : {}, now });
+        if (built.refused) throw new Error(`The report refused the fold: ${built.conflicts.join("; ")}`);
+        await memory.setreport(built.report);
+        await memory.addswarmaction({ id: randomid(), kind: "merge", summary: `The report ${built.report.title} merged the outputs of ${built.report.sources.length} agent${built.report.sources.length === 1 ? "" : "s"} into ${built.report.sections.length} section${built.report.sections.length === 1 ? "" : "s"}.`, at: now });
+        await audit("swarm", `The aggregate report ${built.report.title} folded the parallel outputs of ${built.report.sources.join(", ")} into ${built.report.sections.length} section${built.report.sections.length === 1 ? "" : "s"} under the ${rule} rule; every merged value keeps its provenance.`, {});
+        return swarmstateof();
+      }
+      if (input2.export !== void 0) {
+        const report = await memory.getreport();
+        if (!report) throw new Error("No merged report is stored; the user builds the report before any export.");
+        const grade = mergeegressgrade({ report, carriespagecontent: input2.export.carriespagecontent === true });
+        if (!grade.allowed) throw new Error(grade.reason);
+        await audit("swarm", `The merged report ${report.title} was exported; ${grade.reason ?? ""}`, {});
+        return swarmstateof();
+      }
+      if (input2.compare !== void 0) {
+        const outputs = (input2.compare.outputs ?? []).map((output) => ({ agentid: output.agentid?.trim() ?? "", value: output.value ?? "" })).filter((output) => output.agentid !== "");
+        const comparison = compareoutputs({ id: randomid(), subject: input2.compare.subject ?? "", outputs, now });
+        await audit("swarm", `The user compared ${outputs.length} competing agent outputs on ${comparison.subject}; the differences name where the agents disagree.`, {});
+        return { ...await swarmstateof(), comparison };
+      }
+      if (input2.lesson !== void 0) {
+        const board = await memory.getblackboard() ?? emptyboard();
+        const next = sharelesson({ board, id: randomid(), agentid: input2.lesson.agentid?.trim() ?? "", statement: input2.lesson.statement ?? "", verifiedby: input2.lesson.verifiedby?.trim() ?? "", ...input2.lesson.section !== void 0 ? { section: ["goals", "facts", "findings", "scratch"].includes(input2.lesson.section) ? input2.lesson.section : "findings" } : {}, ...input2.lesson.consentclass !== void 0 ? { consentclass: input2.lesson.consentclass === "interaction" || input2.lesson.consentclass === "sensitive" ? input2.lesson.consentclass : "read" } : {}, now });
+        await memory.setblackboard(next);
+        const lessonauthor = input2.lesson.agentid?.trim() ?? "";
+        await memory.addswarmaction({ id: randomid(), kind: "lesson", ...lessonauthor !== "" ? { agentid: lessonauthor } : {}, summary: `The verified lesson of ${input2.lesson.agentid?.trim() ?? "user"} landed on the findings section for every agent to read.`, at: now });
+        await audit("swarm", `The verified lesson of the agent ${input2.lesson.agentid ?? ""} was shared to the blackboard findings section; only a verified lesson lands on the board.`, {});
+        return swarmstateof();
+      }
+      if (input2.costs === true) {
+        const usage = await memory.getagentusage();
+        const cost = swarmcosts({ usage, now });
+        await memory.addswarmcost(cost);
+        await audit("swarm", `The shared cost accounting summed the usage of ${cost.agents} agent${cost.agents === 1 ? "" : "s"} into the swarm totals of ${cost.tokens} tokens, ${cost.cost} cost and ${cost.steps} steps.`, {});
+        return swarmstateof();
+      }
+      if (input2.timeline !== void 0) {
+        return { ...await swarmstateof(), timelinefiltered: await memory.getswarmtimeline({ ...input2.timeline.agentid !== void 0 && input2.timeline.agentid.trim() !== "" ? { agentid: input2.timeline.agentid.trim() } : {}, ...input2.timeline.kind !== void 0 && input2.timeline.kind.trim() !== "" ? { kind: input2.timeline.kind.trim() } : {} }) };
+      }
+      if (input2.replay !== void 0) {
+        const agentid = input2.replay.trim();
+        if (agentid === "") throw new Error("The replay needs its agent id.");
+        const events = await memory.getagentevents();
+        const actions = await memory.getswarmtimeline();
+        const replay = replayagentrun({ events: [...events.map((event) => ({ id: event.id, kind: event.kind, summary: event.summary, at: event.at, ...event.agentid !== void 0 ? { agentid: event.agentid } : {} })), ...actions.map((action) => ({ id: action.id, kind: action.kind, summary: action.summary, at: action.at, ...action.agentid !== void 0 ? { agentid: action.agentid } : {} }))], agentid });
+        await audit("swarm", `The replay rebuilt the run of the agent ${agentid} from the audit trail with ${replay.length} recorded action${replay.length === 1 ? "" : "s"}.`, {});
+        return { ...await swarmstateof(), replay };
+      }
+      if (input2.snapshot === true) {
+        const state = await swarmstateof();
+        await memory.addboardsnapshot(state.board);
+        await audit("swarm", `The progressboard snapshot was stored with ${state.board.lanes.length} lane${state.board.lanes.length === 1 ? "" : "s"} under the user configured retention.`, {});
+        return swarmstateof();
+      }
+      throw new Error("The swarm merge request carries no merge, report, export, compare, lesson, costs, timeline, replay or snapshot action.");
+    }
+    case "environments": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const settings = await memory.getsettings();
+      if (input2.requestcapability === true) {
+        const granted = await requestoffscreengrant();
+        await audit("environment", granted ? "The user granted the optional offscreen capability through the permissions api; the worker pool may spawn under the manifest declaration." : "The offscreen capability request stayed refused; the parse offload keeps its inline fallback inside the page.", { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), requested: granted };
+      }
+      if (input2.grants !== void 0) {
+        if (!session) throw new Error("The environment grants need an active session to join.");
+        const valid = /* @__PURE__ */ new Set(["pagecontext", "isolatedworld", "offscreenworker", "sandboxframe"]);
+        const requested = input2.grants.filter((environment) => valid.has(environment));
+        const unknown = input2.grants.filter((environment) => !valid.has(environment));
+        if (unknown.length > 0) throw new Error(`The environments ${unknown.join(", ")} sit outside the four execution environments.`);
+        await memory.setenvironmentgrants(requested);
+        await audit("environment", `The user set the environment grants of the session to ${requested.length > 0 ? requested.join(", ") : "the documented default posture"}; no step ever widens them.`, { sessionid: session.id });
+        return environmentviewof();
+      }
+      if (input2.pool !== void 0) {
+        const sizegate = workerpoolsizevalid(input2.pool.size ?? settings?.workerpoolsize);
+        if (!sizegate.allowed) throw new Error(sizegate.reason);
+        const runid = (await memory.getplan())?.id ?? "pool";
+        const current = workerpoolcounts.get(runid) ?? 0;
+        const plan = poolplan({ pending: input2.pool.pending ?? 0, current, ...input2.pool.size !== void 0 ? { size: input2.pool.size } : {} });
+        workerpoolcounts.set(runid, plan.workers);
+        const provenance = { origin: session?.origin ?? "", stepid: "", environment: "offscreenworker" };
+        await memory.addworkerevent({ id: randomid(), runid, kind: plan.added > 0 ? "spawn" : "teardown", workers: plan.workers, reason: plan.reason, provenance, at: now });
+        await audit("worker", `The worker pool of the run ${runid} holds ${plan.workers} worker${plan.workers === 1 ? "" : "s"}: ${plan.reason}`, { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), pool: plan };
+      }
+      if (input2.offscreenclose === true) {
+        const runid = (await memory.getplan())?.id ?? "pool";
+        await closeoffscreendocument(runid);
+        return environmentviewof();
+      }
+      if (input2.settings !== void 0) {
+        const patch = { ...settings };
+        if (input2.settings.parseoffload !== void 0) patch.parseoffload = input2.settings.parseoffload === true;
+        if (input2.settings.workerpoolsize !== void 0) {
+          const sizegate = workerpoolsizevalid(input2.settings.workerpoolsize);
+          if (!sizegate.allowed) throw new Error(sizegate.reason);
+          patch.workerpoolsize = input2.settings.workerpoolsize;
+        }
+        if (input2.settings.sandboxorigins !== void 0) patch.sandboxorigins = input2.settings.sandboxorigins.map((origin) => origin.trim()).filter((origin) => origin !== "");
+        if (input2.settings.keepaliveinterval !== void 0) {
+          const intervalgate = keepaliveintervalvalid(input2.settings.keepaliveinterval);
+          if (!intervalgate.allowed) throw new Error(intervalgate.reason);
+          patch.keepaliveinterval = input2.settings.keepaliveinterval;
+        }
+        if (input2.settings.zombieintervals !== void 0) patch.zombieintervals = input2.settings.zombieintervals;
+        if (input2.settings.runstateretention !== void 0) patch.runstateretention = input2.settings.runstateretention;
+        if (input2.settings.runstatebytes !== void 0) patch.runstatebytes = input2.settings.runstatebytes;
+        await memory.setsettings(patch);
+        await audit("environment", `The user updated the environment settings: parse offload ${patch.parseoffload === true ? "on" : "off"}, worker pool size ${patch.workerpoolsize ?? "queue driven"}, sandbox origins ${patch.sandboxorigins?.length ?? 0} configured, keepalive interval ${patch.keepaliveinterval ?? "the roadmap thirty seconds"}, zombie tolerance ${patch.zombieintervals ?? "the roadmap three intervals"}.`, {});
+        return environmentviewof();
+      }
+      if (input2.render !== void 0) {
+        const result = await executesandboxrender({ id: input2.render.stepid ?? randomid(), kind: "setattribute", summary: "Render untrusted markup inside the sandbox frame.", risk: "sensitive", ...input2.render.markup !== void 0 ? { value: input2.render.markup } : {}, options: JSON.stringify({ markup: input2.render.markup ?? "", ...input2.render.origin !== void 0 ? { sourceorigin: input2.render.origin } : {} }) }, session, await memory.getplan(), input2.render.origin ?? session?.origin ?? "");
+        return { ...await environmentviewof(), render: result };
+      }
+      return environmentviewof();
+    }
+    case "runstate": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const plan = await memory.getplan();
+      const settings = await memory.getsettings();
+      const states = await memory.listrunstates();
+      if (input2.start === true) {
+        if (!session || !plan) throw new Error("The run state opens behind an active session with an approved plan.");
+        const gate = keepalivegate({ session, plan, now });
+        if (!gate.allowed) throw new Error(gate.reason);
+        await openplanrun(session, plan);
+        return { ...await environmentviewof(), opened: plan.id };
+      }
+      if (input2.stop === true) {
+        const open = states.find((state) => state.keepalive.state === "active");
+        if (open) await closeplanrun(open.runid, open.sessionid);
+        return environmentviewof();
+      }
+      if (input2.beat === true) {
+        await keepalivetick();
+        return environmentviewof();
+      }
+      if (input2.recover === true) {
+        const open = states.find((state) => state.keepalive.state === "active" || state.state === "recovered");
+        if (!open) throw new Error("No interrupted run waits for its recovery.");
+        const recovery = recoveryplan(open);
+        await memory.setrunstate(open.profileid, reattachrun(open, now));
+        await audit("environment", recovery.reason, { sessionid: open.sessionid });
+        if (recovery.recoverable && recovery.pendingstepid !== void 0 && plan && plan.id === open.planid && plan.state === "approved") {
+          const outcome = await executestep(recovery.pendingstepid);
+          return { ...await environmentviewof(), recovery, resumed: outcome.summary };
+        }
+        return { ...await environmentviewof(), recovery };
+      }
+      if (input2.reap === true) {
+        const swept = zombiesweep({ states, now, interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+        for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+        for (const runid of swept.reaped) await closeoffscreendocument(runid);
+        if (swept.reaped.length > 0) await audit("environment", `The user reaped the zombie run${swept.reaped.length === 1 ? "" : "s"} ${swept.reaped.join(", ")} from the popup warning.`, {});
+        return { ...await environmentviewof(), reaped: swept.reaped };
+      }
+      if (input2.lock !== void 0) {
+        if (input2.lock.acquire !== void 0) {
+          if (!session) throw new Error("The run lock needs its active session.");
+          const runid = input2.lock.acquire.runid?.trim() ?? plan?.id ?? "";
+          const outcome = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid, holder: input2.lock.acquire.holder?.trim() ?? "user", ...input2.lock.acquire.expiresat !== void 0 ? { expiresat: input2.lock.acquire.expiresat } : {}, now });
+          if (!outcome.acquired) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+        if (input2.lock.release !== void 0) {
+          if (!session) throw new Error("The run lock release needs its active session.");
+          const outcome = releaserunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: input2.lock.release.runid?.trim() ?? plan?.id ?? "", now });
+          if (!outcome.released) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+      }
+      if (input2.serialize !== void 0) {
+        const branches = (input2.serialize.branches ?? []).map((branch) => ({ branchid: branch.branchid?.trim() ?? "", steps: (branch.steps ?? []).filter((step) => step.stepid !== void 0 && step.tabid !== void 0).map((step) => ({ stepid: step.stepid, tabid: step.tabid })) })).filter((branch) => branch.branchid !== "");
+        const order = serializesteps({ branches });
+        await audit("environment", `The executor serialized ${order.length} step${order.length === 1 ? "" : "s"} across parallel branches so steps sharing one tab never run inside the same beat; every other step keeps its branch order.`, {});
+        return { order };
+      }
+      if (input2.export === true) {
+        const exported = await memory.exportrunstates();
+        await audit("environment", `The run states were exported as one audit record: ${exported.runs} run${exported.runs === 1 ? "" : "s"}, ${exported.urls} url entr${exported.urls === 1 ? "y" : "ies"}, ${exported.environments} environment record${exported.environments === 1 ? "" : "s"} and ${exported.offloaded} worker turnaround${exported.offloaded === 1 ? "" : "s"}.`, {});
+        return { export: exported, states: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, pendingstepid: state.pendingstepid, urlhistory: state.urlhistory, environments: state.environments, turnarounds: state.turnarounds })) };
+      }
+      if (input2.profileid !== void 0) {
+        const state = await memory.getrunstate(input2.profileid);
+        if (!state) throw new Error(`No run state exists for the profile ${input2.profileid}.`);
+        return { state };
+      }
+      return environmentviewof();
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -21111,20 +22862,42 @@ async function swarmstateof() {
   const killswitch = await memory.getkillswitch() ?? { engaged: false };
   const usage = await memory.getagentusage();
   const board = await memory.getblackboard() ?? emptyboard();
+  const topology = await memory.gettopology();
+  const reviewrequests = await memory.getreviewrequests();
+  const reviews = await memory.getcriticreviews();
+  const handoffs = await memory.gethandoffs();
+  const report = await memory.getreport();
   return {
     overview: swarmoverview({ agents, queue, mailboxes }),
     agents: agents.map((agent) => {
       const claim2 = queue.claims.find((record2) => record2.agentid === agent.id);
       const task = claim2 !== void 0 ? queue.items.find((item) => item.id === claim2.taskid) : void 0;
       const agentusage = usage.find((entry) => entry.agentid === agent.id);
-      return { id: agent.id, name: agent.name, role: agent.role, state: agent.state, depth: agent.depth, ...agent.tabid !== void 0 ? { tabid: agent.tabid } : {}, ...agent.sessionid !== void 0 ? { sessionid: agent.sessionid } : {}, ...agent.parentid !== void 0 ? { parentid: agent.parentid } : {}, registeredat: agent.registeredat, ...agent.heartbeatat !== void 0 ? { heartbeatat: agent.heartbeatat } : {}, ...agent.budget !== void 0 ? { budget: agent.budget } : {}, ...agent.scope !== void 0 ? { scope: agent.scope } : {}, ...agentusage !== void 0 ? { usage: agentusage } : {}, ...task !== void 0 ? { currenttask: task.payload } : {}, unread: unreadcount(mailboxes, agent.id) };
+      const openreview = reviewrequests.find((request) => request.fromagentid === agent.id && (request.state === "open" || request.state === "acked"));
+      const receivedreview = reviews.find((review) => review.subjectagentid === agent.id);
+      const arrows = handoffs.filter((record2) => record2.fromagentid === agent.id || record2.toagentid === agent.id).map((record2) => `${record2.fromagentid}\u2192${record2.toagentid}`);
+      return { id: agent.id, name: agent.name, role: agent.role, state: agent.state, depth: agent.depth, ...agent.tabid !== void 0 ? { tabid: agent.tabid } : {}, ...agent.sessionid !== void 0 ? { sessionid: agent.sessionid } : {}, ...agent.parentid !== void 0 ? { parentid: agent.parentid } : {}, registeredat: agent.registeredat, ...agent.heartbeatat !== void 0 ? { heartbeatat: agent.heartbeatat } : {}, ...agent.budget !== void 0 ? { budget: agent.budget } : {}, ...agent.scope !== void 0 ? { scope: agent.scope } : {}, ...agentusage !== void 0 ? { usage: agentusage } : {}, ...task !== void 0 ? { currenttask: task.payload } : {}, unread: unreadcount(mailboxes, agent.id), ...openreview !== void 0 ? { reviewstatus: `awaiting the review of ${openreview.toagentid}` } : receivedreview !== void 0 ? { reviewstatus: `last critic verdict ${receivedreview.verdict}` } : {}, handoffarrows: [...new Set(arrows)] };
     }),
     queue: { lanes: queue.lanes, priorities: queue.priorities, completionpolicy: queue.completionpolicy, items: queue.items, claims: queue.claims, lanesreport: lanereport(queue), counts: taskcounts(queue), complete: queuecomplete(queue) },
     mailboxes: mailboxes.map((mailbox) => ({ agentid: mailbox.agentid, unread: mailbox.unread, inbox: mailbox.inbox, outbox: mailbox.outbox })),
     blackboard: { sections: boardsummary(board, now), entries: readentries({ board, now }) },
     spawns: await memory.getspawnrecords(),
     events: await memory.getagentevents(),
-    killswitch
+    killswitch,
+    ...topology !== void 0 ? { topology } : {},
+    splits: await memory.getplannersplits(),
+    reviews,
+    verifications: await memory.getverifierchecks(),
+    reviewrequests,
+    handoffs,
+    locks: await memory.getlocks(),
+    conflicts: await memory.getconflictscans(),
+    ...report !== void 0 ? { report } : {},
+    board: boardstate({ agents, queue, ...topology !== void 0 ? { topology } : {}, now }),
+    escalations: await memory.getescalations(),
+    consensus: await memory.getconsensusrounds(),
+    timeline: interleavetimeline(await memory.getswarmtimeline()),
+    costs: await memory.getswarmcosts()
   };
 }
 async function llmstateof() {
@@ -21701,6 +23474,10 @@ setInterval(() => {
   void evaluatelistedtriggers().then(() => draintriggerqueue()).then(() => runwatchdog()).then(() => restorebackgroundruns()).catch(() => {
   });
 }, 3e4);
+setInterval(() => {
+  void keepalivetick().catch(() => {
+  });
+}, roadmapheartbeat);
 async function restoretriggers() {
   await registermenurules();
   await evaluatelistedtriggers();
@@ -21712,4 +23489,6 @@ async function restoretriggers() {
 }
 restoretriggers().catch(() => {
 });
+restorerunstates().catch(() => {
+});
 //# sourceMappingURL=background.js.map