@wenathlan/extension 1.1.58 → 1.1.60

package/extension/dist/sidepanel.js

@@ -319,6 +319,12 @@ function redoedit(model) {
   return { ...next, redo: redo.slice(0, -1), undo: [...model.undo ?? [], current] };
 }
 
+// progress.ts
+function environmentof(progress, planid, stepid) {
+  if (!progress || progress.planid !== planid) return void 0;
+  return (progress.environments ?? {})[stepid];
+}
+
 // extension/tabscommand.ts
 function switcherlist(tabs, recency, filter) {
   const needle = filter.trim().toLowerCase();
@@ -395,6 +401,7 @@ var triggersroot = document.querySelector("#triggers");
 var agentprotocolroot = document.querySelector("#agentprotocol");
 var modelsroot = document.querySelector("#models");
 var agentsroot = document.querySelector("#agents");
+var environmentsroot = document.querySelector("#environments");
 var commandinput = document.querySelector("#command");
 var commandbutton = document.querySelector("#commandsend");
 var intentbadge = document.querySelector("#intentbadge");
@@ -585,6 +592,13 @@ function stepitem(plan, step, completed, outcomes, retries, progress) {
   const item = document.createElement("li");
   const done = completed.includes(step.id);
   item.textContent = `${done ? "\u2713" : ""} ${step.summary}${holddetail(step)}`;
+  const environmentbadge = progress?.planid === plan.id ? environmentof(progress, plan.id, step.id) ?? step.environment : step.environment;
+  if (environmentbadge !== void 0) {
+    const badge = document.createElement("span");
+    badge.className = "muted";
+    badge.textContent = ` [${environmentbadge}]`;
+    item.append(badge);
+  }
   const outcome = renderoutcome(step, outcomes);
   if (outcome) item.append(outcome);
   const timeline = step.kind === "retryaction" ? retrydetail(step, retries) : quietdetail(step, outcomes);
@@ -2883,6 +2897,7 @@ async function refresh() {
   renderagentprotocol(context);
   rendermodels(context);
   renderagents(context);
+  renderenvironments(context);
   renderconsolediff();
   renderaudit(context.audit);
   rendercapabilities(context.capabilities);
@@ -5543,6 +5558,257 @@ function rendermodels(context) {
   }
   modelsroot.append(guardbox);
 }
+function renderenvironments(context) {
+  if (!environmentsroot) return;
+  environmentsroot.replaceChildren();
+  const view = context.environments;
+  if (!view) {
+    environmentsroot.textContent = "The execution environment state is unknown.";
+    return;
+  }
+  const head = document.createElement("p");
+  head.textContent = `Steps by environment: ${view.report.environments.length} executed \xB7 offscreen ${view.offscreengranted ? "granted" : "not granted"} \xB7 parse offload ${view.parseoffload ? "on" : "off"} \xB7 workers ${view.report.workers} \xB7 sandbox origins ${view.sandboxorigins?.length ?? 0} configured.`;
+  environmentsroot.append(head);
+  const keepalive = view.report.keepalive;
+  const keepbox = document.createElement("div");
+  keepbox.className = "actions";
+  const beatinfo = document.createElement("span");
+  beatinfo.textContent = keepalive ? `Keepalive ${keepalive.state}: ${keepalive.beats} beat${keepalive.beats === 1 ? "" : "s"}, port ${keepalive.portopen ? "open" : "closed"}, last beat ${new Date(keepalive.lastbeatat).toLocaleTimeString()}${view.workerpoolsize !== void 0 ? ` \xB7 pool size ${view.workerpoolsize}` : ""}.` : "No run state holds a keepalive port.";
+  keepbox.append(beatinfo);
+  if (keepalive?.state === "active") {
+    keepbox.append(button("Beat now", async () => {
+      await request({ kind: "runstate", beat: true });
+      await refresh();
+    }), button("Close run state", async () => {
+      await request({ kind: "runstate", stop: true });
+      await refresh();
+    }));
+  }
+  environmentsroot.append(keepbox);
+  const keepnote = document.createElement("p");
+  keepnote.className = "muted";
+  keepnote.textContent = "Keepalive runs only during active reviewed plans: the port opens behind an approved plan of an active session and closes at every terminal state.";
+  environmentsroot.append(keepnote);
+  if (view.restartnotice !== void 0 || view.recovery !== void 0) {
+    const notice = document.createElement("p");
+    notice.textContent = view.restartnotice ?? view.recovery?.reason ?? "";
+    if (view.recovery?.recoverable === true) notice.append(" ", button("Resume pending step", async () => {
+      const result = await request({ kind: "runstate", recover: true });
+      status(result.resumed ?? result.recovery?.reason ?? "The recovery finished.");
+      await refresh();
+    }));
+    environmentsroot.append(notice);
+  }
+  if (view.zombies.length > 0) {
+    const warning = document.createElement("p");
+    warning.textContent = `Zombie run${view.zombies.length === 1 ? "" : "s"} whose heartbeat fell silent: ${view.zombies.join(", ")}.`;
+    warning.append(" ", button("Reap zombie runs", async () => {
+      const result = await request({ kind: "runstate", reap: true });
+      status(`The reaper closed ${result.reaped?.length ?? 0} zombie run${result.reaped?.length === 1 ? "" : "s"}.`);
+      await refresh();
+    }));
+    environmentsroot.append(warning);
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const entry of view.report.environments) grouped.set(entry.environment, [...grouped.get(entry.environment) ?? [], entry.stepid]);
+  const groupbox = document.createElement("details");
+  groupbox.className = "sessiongroup";
+  const groupsummary = document.createElement("summary");
+  groupsummary.textContent = "Steps grouped by execution environment";
+  groupbox.append(groupsummary);
+  if (grouped.size === 0) {
+    const none = document.createElement("p");
+    none.textContent = "No step of the open run has executed yet.";
+    groupbox.append(none);
+  }
+  for (const [environment, stepids] of grouped) {
+    const line = document.createElement("p");
+    line.textContent = `${environment}: ${stepids.length} step${stepids.length === 1 ? "" : "s"}${view.report.turnarounds.filter((entry) => stepids.includes(entry.stepid)).length > 0 ? ` \xB7 worker turnaround ${view.report.turnarounds.filter((entry) => stepids.includes(entry.stepid)).map((entry) => `${entry.stepid}: ${entry.milliseconds} ms`).join(", ")}` : ""}`;
+    groupbox.append(line);
+  }
+  environmentsroot.append(groupbox);
+  const grantbox = document.createElement("div");
+  grantbox.className = "actions";
+  const grantinfo = document.createElement("span");
+  grantinfo.textContent = view.grants !== void 0 ? `Session environment grants: ${view.grants.length > 0 ? view.grants.join(", ") : "the documented default posture"}.` : "Session environment grants: the documented default posture (no grant list configured).";
+  grantbox.append(grantinfo);
+  const allenvironments = ["pagecontext", "isolatedworld", "offscreenworker", "sandboxframe"];
+  for (const environment of allenvironments) {
+    const active = view.grants?.includes(environment) ?? false;
+    grantbox.append(" ", button(`${active ? "Revoke" : "Grant"} ${environment}`, async () => {
+      const current = view.grants ?? [];
+      const next = active ? current.filter((entry) => entry !== environment) : [...current, environment];
+      await request({ kind: "environments", grants: next });
+      await refresh();
+    }));
+  }
+  environmentsroot.append(grantbox);
+  const grantnote = document.createElement("p");
+  grantnote.className = "muted";
+  grantnote.textContent = "Environment grants join the origin grants of the session record: a configured list narrows every step to its entries and the request links to the same consent flow the origins use.";
+  environmentsroot.append(grantnote);
+  const capabilitybox = document.createElement("div");
+  capabilitybox.className = "actions";
+  const capabilityinfo = document.createElement("span");
+  capabilityinfo.textContent = `Offscreen capability: ${view.offscreengranted ? "granted" : "absent \u2014 heavy parses keep their inline fallback inside the page"}.`;
+  capabilitybox.append(capabilityinfo);
+  if (!view.offscreengranted) capabilitybox.append(" ", button("Request offscreen capability", async () => {
+    const result = await request({ kind: "environments", requestcapability: true });
+    status(result.requested === true ? "The offscreen capability was granted; the worker pool may spawn." : "The capability request stayed refused; the inline fallback holds.");
+    await refresh();
+  }));
+  else capabilitybox.append(" ", button("Close offscreen document", async () => {
+    await request({ kind: "environments", offscreenclose: true });
+    await refresh();
+  }));
+  environmentsroot.append(capabilitybox);
+  const optionsbox = document.createElement("details");
+  optionsbox.className = "sessiongroup";
+  const optionssummary = document.createElement("summary");
+  optionssummary.textContent = "Environment options";
+  optionsbox.append(optionssummary);
+  const offloadrow = document.createElement("div");
+  offloadrow.className = "actions";
+  offloadrow.append(button(`Parse offload: ${view.parseoffload ? "on" : "off"}`, async () => {
+    await request({ kind: "environments", settings: { parseoffload: !view.parseoffload } });
+    await refresh();
+  }));
+  const poolinput = document.createElement("input");
+  poolinput.type = "number";
+  poolinput.min = "1";
+  poolinput.placeholder = "worker pool size (no cap)";
+  poolinput.value = view.workerpoolsize !== void 0 ? String(view.workerpoolsize) : "";
+  offloadrow.append(" ", poolinput, " ", button("Set pool size", async () => {
+    const value = poolinput.value.trim();
+    await request({ kind: "environments", settings: { ...value !== "" ? { workerpoolsize: Number(value) } : {} } });
+    await refresh();
+  }));
+  optionsbox.append(offloadrow);
+  const origininput = document.createElement("input");
+  origininput.type = "url";
+  origininput.placeholder = "https://origin.example to allow sandbox renders";
+  const originrow = document.createElement("div");
+  originrow.className = "actions";
+  originrow.append(origininput, " ", button("Add sandbox origin", async () => {
+    const value = origininput.value.trim();
+    if (value === "") return;
+    const next = [...view.sandboxorigins ?? [], value];
+    await request({ kind: "environments", settings: { sandboxorigins: next } });
+    await refresh();
+  }));
+  optionsbox.append(originrow);
+  if ((view.sandboxorigins ?? []).length > 0) {
+    const originlist = document.createElement("ul");
+    originlist.className = "audit";
+    for (const origin of view.sandboxorigins ?? []) {
+      const item = document.createElement("li");
+      item.textContent = origin;
+      item.append(" ", button("Remove", async () => {
+        await request({ kind: "environments", settings: { sandboxorigins: (view.sandboxorigins ?? []).filter((entry) => entry !== origin) } });
+        await refresh();
+      }));
+      originlist.append(item);
+    }
+    optionsbox.append(originlist);
+  }
+  const intervalinput = document.createElement("input");
+  intervalinput.type = "number";
+  intervalinput.min = "1";
+  intervalinput.placeholder = "keepalive interval ms (roadmap: 30000)";
+  const intervalrow = document.createElement("div");
+  intervalrow.className = "actions";
+  intervalrow.append(intervalinput, " ", button("Set interval", async () => {
+    const value = intervalinput.value.trim();
+    if (value === "") return;
+    await request({ kind: "environments", settings: { keepaliveinterval: Number(value) } });
+    await refresh();
+  }));
+  optionsbox.append(intervalrow);
+  environmentsroot.append(optionsbox);
+  if (view.registry.length > 0) {
+    const registrybox = document.createElement("details");
+    registrybox.className = "sessiongroup";
+    const registrysummary = document.createElement("summary");
+    registrysummary.textContent = "Executor registry";
+    registrybox.append(registrysummary);
+    const registrylist = document.createElement("ul");
+    registrylist.className = "audit";
+    for (const adapter of view.registry) {
+      const item = document.createElement("li");
+      item.textContent = `${adapter.environment} \u2192 ${adapter.adapter}: ${adapter.description}`;
+      registrylist.append(item);
+    }
+    registrybox.append(registrylist);
+    environmentsroot.append(registrybox);
+  }
+  if (view.report.offscreen.length > 0) {
+    const offbox = document.createElement("details");
+    offbox.className = "sessiongroup";
+    const offsummary = document.createElement("summary");
+    offsummary.textContent = `Offscreen documents (${view.report.offscreen.length})`;
+    offbox.append(offsummary);
+    const offlist = document.createElement("ul");
+    offlist.className = "audit";
+    for (const entry of view.report.offscreen) {
+      const item = document.createElement("li");
+      item.textContent = `${entry.document} for the run ${entry.runid}: ${entry.reasons.join(", ")}${entry.closedat !== void 0 ? ` \xB7 closed ${new Date(entry.closedat).toLocaleTimeString()}` : " \xB7 open"} \u2014 ${entry.justification}`;
+      offlist.append(item);
+    }
+    offbox.append(offlist);
+    environmentsroot.append(offbox);
+  }
+  if (view.workerevents.length > 0) {
+    const workerbox = document.createElement("details");
+    workerbox.className = "sessiongroup";
+    const workersummary = document.createElement("summary");
+    workersummary.textContent = `Worker activity (${view.workerevents.length})`;
+    workerbox.append(workersummary);
+    const workerlist = document.createElement("ul");
+    workerlist.className = "audit";
+    for (const event of view.workerevents.slice(0, 10)) {
+      const item = document.createElement("li");
+      item.textContent = `${event.kind} ${event.workers} worker${event.workers === 1 ? "" : "s"}: ${event.reason}`;
+      workerlist.append(item);
+    }
+    workerbox.append(workerlist);
+    environmentsroot.append(workerbox);
+  }
+  if (view.urls.length > 0) {
+    const urlbox = document.createElement("details");
+    urlbox.className = "sessiongroup";
+    const urlsummary = document.createElement("summary");
+    urlsummary.textContent = `Url history of the open run (${view.urls.length})`;
+    urlbox.append(urlsummary);
+    const urllist = document.createElement("ol");
+    urllist.className = "audit";
+    for (const entry of view.urls) {
+      const item = document.createElement("li");
+      item.textContent = `${new Date(entry.at).toLocaleTimeString()} ${entry.url} (step ${entry.stepid})`;
+      urllist.append(item);
+    }
+    urlbox.append(urllist);
+    environmentsroot.append(urlbox);
+  }
+  const locksbox = document.createElement("details");
+  locksbox.className = "sessiongroup";
+  const lockssummary = document.createElement("summary");
+  lockssummary.textContent = `Run locks (${view.locks.length})`;
+  locksbox.append(lockssummary);
+  if (view.locks.length === 0) {
+    const none = document.createElement("p");
+    none.textContent = "No session holds a run lock; one session never carries two concurrent runs.";
+    locksbox.append(none);
+  }
+  const locklist = document.createElement("ul");
+  locklist.className = "audit";
+  for (const lock of view.locks) {
+    const item = document.createElement("li");
+    item.textContent = `Session ${lock.sessionid} \u2192 run ${lock.runid} (${lock.holder})${lock.expiresat !== void 0 ? ` \xB7 expires ${new Date(lock.expiresat).toLocaleTimeString()}` : " \xB7 no expiry"}`;
+    locklist.append(item);
+  }
+  locksbox.append(locklist);
+  environmentsroot.append(locksbox);
+}
 function renderagents(context) {
   if (!agentsroot) return;
   agentsroot.replaceChildren();
@@ -5588,7 +5854,7 @@ function renderagents(context) {
     row.className = "sessionrow";
     const info = document.createElement("p");
     const budgettext = agent.budget === void 0 ? "no ceiling" : [agent.budget.maxtokens !== void 0 ? `${agent.usage?.tokens ?? 0}/${agent.budget.maxtokens} tokens` : "", agent.budget.maxcost !== void 0 ? `${agent.usage?.cost ?? 0}/${agent.budget.maxcost} ${agent.budget.currency ?? ""}` : "", agent.budget.maxsteps !== void 0 ? `${agent.usage?.steps ?? 0}/${agent.budget.maxsteps} steps` : ""].filter((part) => part !== "").join(", ") || "no ceiling set";
-    info.textContent = `${agent.name} \xB7 ${agent.role} \xB7 ${agent.state}${agent.tabid !== void 0 ? ` \xB7 tab ${agent.tabid}` : ""}${agent.parentid !== void 0 ? ` \xB7 sub of ${agent.parentid} at depth ${agent.depth}` : ""}${agent.currenttask !== void 0 ? ` \xB7 working: ${agent.currenttask}` : " \xB7 idle"} \xB7 budget ${budgettext}${agent.heartbeatat !== void 0 ? ` \xB7 heartbeat ${new Date(agent.heartbeatat).toLocaleTimeString()}` : ""}${agent.unread > 0 ? ` \xB7 ${agent.unread} unread` : ""}.`;
+    info.textContent = `${agent.name} \xB7 ${agent.role} \xB7 ${agent.state}${agent.tabid !== void 0 ? ` \xB7 tab ${agent.tabid}` : ""}${agent.parentid !== void 0 ? ` \xB7 sub of ${agent.parentid} at depth ${agent.depth}` : ""}${agent.currenttask !== void 0 ? ` \xB7 working: ${agent.currenttask}` : " \xB7 idle"} \xB7 budget ${budgettext}${agent.heartbeatat !== void 0 ? ` \xB7 heartbeat ${new Date(agent.heartbeatat).toLocaleTimeString()}` : ""}${agent.unread > 0 ? ` \xB7 ${agent.unread} unread` : ""}${agent.reviewstatus !== void 0 ? ` \xB7 review: ${agent.reviewstatus}` : ""}${agent.handoffarrows.length > 0 ? ` \xB7 handoffs: ${agent.handoffarrows.join(", ")}` : ""}.`;
     row.append(info);
     const actions = document.createElement("div");
     actions.className = "actions";
@@ -5636,7 +5902,7 @@ function renderagents(context) {
   const nameinput = document.createElement("input");
   nameinput.placeholder = "new agent name";
   const roleselect = document.createElement("select");
-  for (const role of ["worker", "planner", "observer"]) {
+  for (const role of ["worker", "planner", "observer", "critic", "verifier"]) {
     const option = document.createElement("option");
     option.value = role;
     option.textContent = role;
@@ -5662,7 +5928,7 @@ function renderagents(context) {
     parentselect.append(option);
   }
   const spawnrole = document.createElement("select");
-  for (const role of ["worker", "planner", "observer"]) {
+  for (const role of ["worker", "planner", "observer", "critic", "verifier"]) {
     const option = document.createElement("option");
     option.value = role;
     option.textContent = role;
@@ -5861,6 +6127,558 @@ function renderagents(context) {
   }));
   boardbox.append(postrow);
   agentsroot.append(boardbox);
+  const orchestrationbox = document.createElement("details");
+  orchestrationbox.className = "sessiongroup";
+  const orchestrationsummary = document.createElement("summary");
+  orchestrationsummary.textContent = "Leader worker topology";
+  orchestrationbox.append(orchestrationsummary);
+  if (swarm.topology !== void 0) {
+    const lead = swarm.agents.find((agent) => agent.id === swarm.topology?.leaderid);
+    const topinfo = document.createElement("p");
+    topinfo.textContent = `Leader ${swarm.topology.leaderid}${lead !== void 0 ? ` (${lead.name})` : ""} by the ${swarm.topology.rule.kind} rule \xB7 ${swarm.topology.workerids.length} workers, ${swarm.topology.criticids.length} critics, ${swarm.topology.verifierids.length} verifiers \xB7 ${swarm.topology.assignments.length} assignment${swarm.topology.assignments.length === 1 ? "" : "s"}.`;
+    orchestrationbox.append(topinfo);
+    const assignments = document.createElement("ul");
+    assignments.className = "audit";
+    for (const assignment of swarm.topology.assignments.slice(0, 8)) {
+      const entry = document.createElement("li");
+      entry.textContent = `${assignment.workerid} \u2192 task ${assignment.taskid}: ${assignment.slice}.`;
+      assignments.append(entry);
+    }
+    orchestrationbox.append(assignments);
+    for (const split of swarm.splits.slice(0, 4)) {
+      const row = document.createElement("p");
+      row.textContent = `Planner executor split: ${split.planownerid} plans, ${split.runownerid} runs${split.taskid !== void 0 ? ` task ${split.taskid}` : ""} with ${split.stepreports.length} step report${split.stepreports.length === 1 ? "" : "s"} (${split.stepreports.filter((report) => report.outcome === "done").length} done).`;
+      orchestrationbox.append(row);
+    }
+  } else {
+    const none = document.createElement("p");
+    none.textContent = "No leader is elected yet; the user elects one by the first or named rule.";
+    orchestrationbox.append(none);
+  }
+  const electionrow = document.createElement("div");
+  electionrow.className = "actions";
+  const leaderselect = document.createElement("select");
+  const firstoption = document.createElement("option");
+  firstoption.value = "first";
+  firstoption.textContent = "first registration";
+  leaderselect.append(firstoption);
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = `named: ${agent.name}`;
+    leaderselect.append(option);
+  }
+  const splitplan = document.createElement("select");
+  const splitrun = document.createElement("select");
+  const splittask = document.createElement("input");
+  splittask.placeholder = "task id";
+  for (const agent of swarm.agents) {
+    const plan = document.createElement("option");
+    plan.value = agent.id;
+    plan.textContent = agent.name;
+    splitplan.append(plan);
+    const run = document.createElement("option");
+    run.value = agent.id;
+    run.textContent = agent.name;
+    splitrun.append(run);
+  }
+  electionrow.append(leaderselect, " ", button("Elect leader", async () => {
+    await request({ kind: "swarmleader", elect: leaderselect.value === "first" ? { rule: "first" } : { rule: "named", agentid: leaderselect.value } });
+    status("The leader election recorded the topology; the leader only organizes reviewed work.");
+    await refresh();
+  }), " ", button("Assign work", async () => {
+    await request({ kind: "swarmleader", assign: {} });
+    status("The leader sliced the tasks across the workers; every slice still passes the plan review.");
+    await refresh();
+  }), " ", button("Scale workers", async () => {
+    await request({ kind: "swarmleader", scale: { pending: swarm.queue.counts.queued + swarm.queue.counts.claimed } });
+    status("The worker lane scaled by the load under the user configured bound.");
+    await refresh();
+  }), " ", splitplan, " ", splitrun, " ", splittask, " ", button("Split plan and run", async () => {
+    if (splitplan.value === splitrun.value) {
+      status("The planner executor split needs two different agents.");
+      return;
+    }
+    await request({ kind: "swarmleader", split: { planownerid: splitplan.value, runownerid: splitrun.value, ...splittask.value.trim() !== "" ? { taskid: splittask.value } : {} } });
+    status("The task split between the planner and the executor; the executor reports every step back.");
+    await refresh();
+  }));
+  orchestrationbox.append(electionrow);
+  agentsroot.append(orchestrationbox);
+  const boardbox2 = document.createElement("details");
+  boardbox2.className = "sessiongroup";
+  const board2summary = document.createElement("summary");
+  board2summary.textContent = `Progressboard (${swarm.board.lanes.length} lanes)`;
+  boardbox2.append(board2summary);
+  for (const lane of swarm.board.lanes) {
+    const row = document.createElement("p");
+    row.textContent = `${lane.name} (${lane.role}, ${lane.state}) \xB7 lane ${lane.lane}${lane.currenttask !== void 0 ? ` \xB7 working: ${lane.currenttask}` : ""}${lane.milestones.length > 0 ? ` \xB7 ${lane.milestones.filter((milestone) => milestone.done).length}/${lane.milestones.length} milestones (${lane.milestones.map((milestone) => milestone.done ? milestone.label : `${milestone.label} (open)`).join(", ")})` : ""}.`;
+    boardbox2.append(row);
+  }
+  const milestonerow = document.createElement("div");
+  milestonerow.className = "actions";
+  const milestoneagent = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    milestoneagent.append(option);
+  }
+  const milestonelabel = document.createElement("input");
+  milestonelabel.placeholder = "milestone label";
+  milestonerow.append(milestoneagent, " ", milestonelabel, " ", button("Report milestone", async () => {
+    await request({ kind: "swarmleader", milestone: { agentid: milestoneagent.value, label: milestonelabel.value, done: true } });
+    status("The milestone landed on the progressboard snapshot.");
+    await refresh();
+  }), " ", button("Snapshot board", async () => {
+    await request({ kind: "swarmmerge", snapshot: true });
+    status("The progressboard snapshot was stored under the user configured retention.");
+    await refresh();
+  }));
+  boardbox2.append(milestonerow);
+  agentsroot.append(boardbox2);
+  const reviewbox = document.createElement("details");
+  reviewbox.className = "sessiongroup";
+  const reviewsummary = document.createElement("summary");
+  reviewsummary.textContent = `Reviews and verifications (${swarm.reviews.length} verdicts, ${swarm.verifications.length} checks)`;
+  reviewbox.append(reviewsummary);
+  for (const request2 of swarm.reviewrequests.slice(0, 8)) {
+    const row = document.createElement("p");
+    row.textContent = `Review request ${request2.subject}: ${request2.fromagentid} \u2192 ${request2.toagentid}, ${request2.state}${request2.timeoutat !== void 0 ? ` \xB7 deadline ${new Date(request2.timeoutat).toLocaleTimeString()}` : ""}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    actions.append(button("Ack", async () => {
+      await request({ kind: "swarmreview", ack: request2.id });
+      status("The review request was acked.");
+      await refresh();
+    }));
+    row.append(actions);
+    reviewbox.append(row);
+  }
+  for (const review of swarm.reviews.slice(0, 8)) {
+    const row = document.createElement("p");
+    row.textContent = `Critic verdict ${review.verdict} by ${review.reviewerid} over the output of ${review.subjectagentid}${review.issues.length > 0 ? ` \xB7 issues: ${review.issues.join("; ")}` : ""}${review.requiredchanges.length > 0 ? ` \xB7 required: ${review.requiredchanges.join("; ")}` : ""}.`;
+    reviewbox.append(row);
+  }
+  for (const check of swarm.verifications.slice(0, 8)) {
+    const row = document.createElement("p");
+    const badge = document.createElement("strong");
+    badge.textContent = check.outcome === "pass" ? "PASS" : "FAIL";
+    row.append(`Verifier ${check.verifierid} checked the claim of ${check.claimagentid} by the ${check.method} method: `, badge, ` \u2014 ${check.claim}${check.evidence !== void 0 ? ` (${check.evidence})` : ""}.`);
+    reviewbox.append(row);
+  }
+  const reviewrow = document.createElement("div");
+  reviewrow.className = "actions";
+  const reviewfrom = document.createElement("select");
+  const reviewto = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const one = document.createElement("option");
+    one.value = agent.id;
+    one.textContent = agent.name;
+    reviewfrom.append(one);
+    const two = document.createElement("option");
+    two.value = agent.id;
+    two.textContent = agent.name;
+    reviewto.append(two);
+  }
+  const reviewsubject = document.createElement("input");
+  reviewsubject.placeholder = "review subject";
+  const reviewpayload = document.createElement("input");
+  reviewpayload.placeholder = "output payload";
+  const reviewverdict = document.createElement("select");
+  for (const verdict of ["approve", "changes", "reject"]) {
+    const option = document.createElement("option");
+    option.value = verdict;
+    option.textContent = verdict;
+    reviewverdict.append(option);
+  }
+  const reviewchanges = document.createElement("input");
+  reviewchanges.placeholder = "required changes, semicolon separated";
+  reviewrow.append(reviewfrom, " ", reviewto, " ", reviewsubject, " ", reviewpayload, " ", button("Request review", async () => {
+    await request({ kind: "swarmreview", request: { fromagentid: reviewfrom.value, toagentid: reviewto.value, subject: reviewsubject.value, payload: reviewpayload.value } });
+    status("The review request was routed; the critic reads only.");
+    await refresh();
+  }), " ", reviewverdict, " ", reviewchanges, " ", button("Apply verdict", async () => {
+    const open = swarm.reviewrequests.find((entry) => entry.state === "open" && entry.toagentid === reviewto.value);
+    if (open === void 0) {
+      status("No open review request for the selected reviewer; request one first.");
+      return;
+    }
+    await request({ kind: "swarmreview", apply: { id: open.id, reviewerid: reviewto.value, verdict: reviewverdict.value, issues: [], requiredchanges: reviewchanges.value.split(";").map((change) => change.trim()).filter((change) => change !== "") } });
+    status("The critic verdict was applied; the rework still passes the human review.");
+    await refresh();
+  }), " ", button("Sweep timeouts", async () => {
+    await request({ kind: "swarmreview", sweep: true });
+    status("The review sweep timed out the unanswered requests.");
+    await refresh();
+  }));
+  const verifyrow = document.createElement("div");
+  verifyrow.className = "actions";
+  const verifierselect = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    verifierselect.append(option);
+  }
+  const claimagent = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    claimagent.append(option);
+  }
+  const claimtext = document.createElement("input");
+  claimtext.placeholder = "claim to verify";
+  const claimmethod = document.createElement("input");
+  claimmethod.placeholder = "method";
+  const claimoutcome = document.createElement("select");
+  for (const outcome of ["pass", "fail"]) {
+    const option = document.createElement("option");
+    option.value = outcome;
+    option.textContent = outcome;
+    claimoutcome.append(option);
+  }
+  verifyrow.append(verifierselect, " ", claimagent, " ", claimtext, " ", claimmethod, " ", claimoutcome, " ", button("Verify claim", async () => {
+    await request({ kind: "swarmreview", verify: { verifierid: verifierselect.value, claimagentid: claimagent.value, claim: claimtext.value, method: claimmethod.value, outcome: claimoutcome.value } });
+    status(`The verifier marked the claim ${claimoutcome.value} with the method it used.`);
+    await refresh();
+  }));
+  reviewbox.append(reviewrow, verifyrow);
+  agentsroot.append(reviewbox);
+  const escalationbox = document.createElement("details");
+  escalationbox.className = "sessiongroup";
+  const escalationsummary = document.createElement("summary");
+  escalationsummary.textContent = `Escalation inbox (${swarm.escalations.filter((escalation) => escalation.state === "open").length} open)`;
+  escalationbox.append(escalationsummary);
+  for (const escalation of swarm.escalations.slice(0, 8)) {
+    const row = document.createElement("div");
+    row.className = "sessionrow";
+    const info = document.createElement("p");
+    info.textContent = `${escalation.state === "open" ? "AWAITS THE USER" : "decided"} \xB7 ${escalation.agentid} lifted ${escalation.subject} \u2014 ${escalation.context}${escalation.decision !== void 0 ? ` \xB7 decision: ${escalation.decision}` : ""}.`;
+    row.append(info);
+    if (escalation.state === "open") {
+      const actions = document.createElement("div");
+      actions.className = "actions";
+      const decision = document.createElement("input");
+      decision.placeholder = "the decision the user writes";
+      actions.append(decision, " ", button("Decide", async () => {
+        await request({ kind: "swarmreview", decide: { id: escalation.id, decision: decision.value } });
+        status("The user decision was recorded; the agent continues from it.");
+        await refresh();
+      }));
+      row.append(actions);
+    }
+    escalationbox.append(row);
+  }
+  const escalaterow = document.createElement("div");
+  escalaterow.className = "actions";
+  const escalateagent = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    escalateagent.append(option);
+  }
+  const escalatesubject = document.createElement("input");
+  escalatesubject.placeholder = "stalled subject";
+  const escalatecontext = document.createElement("input");
+  escalatecontext.placeholder = "full context for the user";
+  escalaterow.append(escalateagent, " ", escalatesubject, " ", escalatecontext, " ", button("Escalate to user", async () => {
+    await request({ kind: "swarmreview", escalate: { agentid: escalateagent.value, subject: escalatesubject.value, context: escalatecontext.value } });
+    status("The stalled decision was lifted to the user; the agent waits.");
+    await refresh();
+  }));
+  escalationbox.append(escalaterow);
+  agentsroot.append(escalationbox);
+  const consensusbox = document.createElement("details");
+  consensusbox.className = "sessiongroup";
+  const consensussummary = document.createElement("summary");
+  consensussummary.textContent = `Consensus rounds (${swarm.consensus.length})`;
+  consensusbox.append(consensussummary);
+  for (const round of swarm.consensus.slice(0, 6)) {
+    const yes = round.votes.filter((vote) => vote.vote === "yes").length;
+    const no = round.votes.filter((vote) => vote.vote === "no").length;
+    const abstain = round.votes.filter((vote) => vote.vote === "abstain").length;
+    const row = document.createElement("p");
+    row.textContent = `${round.subject}: ${round.state} \xB7 ${yes} yes, ${no} no, ${abstain} abstain against the quorum ${round.quorum}${round.votes.length > 0 ? ` \xB7 voted by ${round.votes.map((vote) => vote.agentid).join(", ")}` : ""}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    const voterselect = document.createElement("select");
+    for (const agent of swarm.agents) {
+      const option = document.createElement("option");
+      option.value = agent.id;
+      option.textContent = agent.name;
+      voterselect.append(option);
+    }
+    const voteselect = document.createElement("select");
+    for (const vote of ["yes", "no", "abstain"]) {
+      const option = document.createElement("option");
+      option.value = vote;
+      option.textContent = vote;
+      voteselect.append(option);
+    }
+    actions.append(voterselect, " ", voteselect, " ", button("Vote", async () => {
+      await request({ kind: "swarmreview", vote: { id: round.id, agentid: voterselect.value, vote: voteselect.value } });
+      status(`The vote landed on the round ${round.subject}.`);
+      await refresh();
+    }));
+    row.append(actions);
+    consensusbox.append(row);
+  }
+  const consensusrow = document.createElement("div");
+  consensusrow.className = "actions";
+  const subjectinput2 = document.createElement("input");
+  subjectinput2.placeholder = "consensus subject";
+  const quoruminput = document.createElement("input");
+  quoruminput.placeholder = "quorum";
+  consensusrow.append(subjectinput2, " ", quoruminput, " ", button("Open round", async () => {
+    await request({ kind: "swarmreview", consensus: { subject: subjectinput2.value, ...quoruminput.value.trim() !== "" ? { quorum: Number(quoruminput.value) } : {} } });
+    status("The consensus round opened with the user configured quorum.");
+    await refresh();
+  }));
+  consensusbox.append(consensusrow);
+  agentsroot.append(consensusbox);
+  const handoffbox = document.createElement("details");
+  handoffbox.className = "sessiongroup";
+  const handoffsummary = document.createElement("summary");
+  handoffsummary.textContent = `Handoffs and locks (${swarm.handoffs.length} handoffs, ${swarm.locks.length} locks)`;
+  handoffbox.append(handoffsummary);
+  for (const record of swarm.handoffs.slice(0, 8)) {
+    const row = document.createElement("p");
+    row.textContent = `${record.fromagentid} \u2192 ${record.toagentid}${record.tabid !== void 0 ? ` \xB7 tab ${record.tabid}` : ""} \xB7 ${record.state} \xB7 packaged state: ${record.taskstate}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    if (record.state === "prepared") actions.append(button("Transfer", async () => {
+      await request({ kind: "swarmhandoff", transfer: record.id });
+      status("The tab moved between the agents under the one agent per tab rule.");
+      await refresh();
+    }), " ");
+    if (record.state === "transferred") actions.append(button("Resume", async () => {
+      await request({ kind: "swarmhandoff", resume: record.id });
+      status("The receiving agent resumed the task from the packaged state.");
+      await refresh();
+    }));
+    row.append(actions);
+    handoffbox.append(row);
+  }
+  const handoffrow = document.createElement("div");
+  handoffrow.className = "actions";
+  const handofffrom = document.createElement("select");
+  const handoffto = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const one = document.createElement("option");
+    one.value = agent.id;
+    one.textContent = agent.name;
+    handofffrom.append(one);
+    const two = document.createElement("option");
+    two.value = agent.id;
+    two.textContent = agent.name;
+    handoffto.append(two);
+  }
+  const handoffstate = document.createElement("input");
+  handoffstate.placeholder = "packaged task state";
+  handoffrow.append(handofffrom, " ", handoffto, " ", handoffstate, " ", button("Prepare handoff", async () => {
+    await request({ kind: "swarmhandoff", prepare: { fromagentid: handofffrom.value, toagentid: handoffto.value, taskstate: handoffstate.value } });
+    status("The handoff was prepared with the packaged task state.");
+    await refresh();
+  }));
+  handoffbox.append(handoffrow);
+  for (const lock of swarm.locks.slice(0, 8)) {
+    const row = document.createElement("p");
+    row.textContent = `Lock ${lock.key} \xB7 ${lock.kind} \xB7 holder ${lock.holder} \xB7 acquired ${new Date(lock.acquiredat).toLocaleTimeString()}${lock.expiresat !== void 0 ? ` \xB7 expires in ${Math.max(Math.round((lock.expiresat - Date.now()) / 1e3), 0)}s` : " \xB7 no expiry"}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    actions.append(button("Release", async () => {
+      await request({ kind: "swarmlocks", release: { key: lock.key, holder: lock.holder } });
+      status("The lock released and the resource returned to the pool.");
+      await refresh();
+    }));
+    row.append(actions);
+    handoffbox.append(row);
+  }
+  const lockrow = document.createElement("div");
+  lockrow.className = "actions";
+  const lockholder = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    lockholder.append(option);
+  }
+  const lockorigin = document.createElement("input");
+  lockorigin.placeholder = "origin";
+  const lockselector = document.createElement("input");
+  lockselector.placeholder = "selector";
+  const lockkindselect = document.createElement("select");
+  for (const kind of ["exclusive", "shared"]) {
+    const option = document.createElement("option");
+    option.value = kind;
+    option.textContent = kind;
+    lockkindselect.append(option);
+  }
+  lockrow.append(lockholder, " ", lockorigin, " ", lockselector, " ", lockkindselect, " ", button("Acquire lock", async () => {
+    await request({ kind: "swarmlocks", acquire: { holder: lockholder.value, origin: lockorigin.value, selector: lockselector.value, kind: lockkindselect.value } });
+    status("The lock went to the holder; it serializes reviewed work only.");
+    await refresh();
+  }), " ", button("Sweep expired", async () => {
+    await request({ kind: "swarmlocks", sweep: true });
+    status("The expiry sweep returned the abandoned locks to the pool.");
+    await refresh();
+  }));
+  handoffbox.append(lockrow);
+  agentsroot.append(handoffbox);
+  const conflictbox = document.createElement("details");
+  conflictbox.className = "sessiongroup";
+  const conflictsummary = document.createElement("summary");
+  conflictsummary.textContent = `Conflicts and merges (${swarm.conflicts.length} scans)`;
+  conflictbox.append(conflictsummary);
+  for (const scan of swarm.conflicts.slice(0, 6)) {
+    const row = document.createElement("p");
+    row.textContent = scan.clean ? `Scan of ${scan.writers.length} writers: clean, no overlapping write.` : `Scan of ${scan.writers.length} writers: ${scan.overlaps.map((overlap) => `${overlap.origin}|${overlap.selector} by ${overlap.writers.join(", ")}`).join("; ")} \u2014 suggested order ${scan.suggestedorder.join(" \u2192 ")}.`;
+    conflictbox.append(row);
+  }
+  const conflictrow = document.createElement("div");
+  conflictrow.className = "actions";
+  const scanorigin = document.createElement("input");
+  scanorigin.placeholder = "origin";
+  const scanselector = document.createElement("input");
+  scanselector.placeholder = "selector";
+  const scanagents = document.createElement("input");
+  scanagents.placeholder = "writer agent ids, comma separated";
+  conflictrow.append(scanorigin, " ", scanselector, " ", scanagents, " ", button("Scan conflicts", async () => {
+    const writers = scanagents.value.split(",").map((id) => id.trim()).filter((id) => id !== "").map((id) => ({ agentid: id, origin: scanorigin.value, selector: scanselector.value }));
+    await request({ kind: "swarmlocks", scan: { writers } });
+    status("The conflict scan checked the overlapping writes before the parallel runs.");
+    await refresh();
+  }));
+  conflictbox.append(conflictrow);
+  if (swarm.report !== void 0) {
+    const reportinfo = document.createElement("p");
+    reportinfo.textContent = `Merged report ${swarm.report.title}: ${swarm.report.sections.length} section${swarm.report.sections.length === 1 ? "" : "s"} from ${swarm.report.sources.join(", ")}${swarm.report.confidence !== void 0 ? ` \xB7 confidence: ${swarm.report.confidence}` : ""}.`;
+    conflictbox.append(reportinfo);
+    const reportlist = document.createElement("ol");
+    reportlist.className = "audit";
+    for (const section of swarm.report.sections.slice(0, 3)) {
+      const item = document.createElement("li");
+      item.textContent = `${section.title}: ${section.entries.slice(0, 5).map((entry) => `${entry.key} = ${entry.value} (${entry.agentid}${entry.conflict !== void 0 ? `; ${entry.conflict}` : ""})`).join("; ")}.`;
+      reportlist.append(item);
+    }
+    conflictbox.append(reportlist);
+    const exportrow = document.createElement("div");
+    exportrow.className = "actions";
+    exportrow.append(button("Export report", async () => {
+      await request({ kind: "swarmmerge", export: { carriespagecontent: true } });
+      status("The merged report was exported; the page content it carries grades as a data egress event.");
+      await refresh();
+    }));
+    conflictbox.append(exportrow);
+  }
+  const mergerow = document.createElement("div");
+  mergerow.className = "actions";
+  const reporttitle = document.createElement("input");
+  reporttitle.placeholder = "report title";
+  const mergeruleselect = document.createElement("select");
+  for (const rule of ["first", "last", "preferagent", "fail"]) {
+    const option = document.createElement("option");
+    option.value = rule;
+    option.textContent = rule;
+    mergeruleselect.append(option);
+  }
+  const mergeoutputs = document.createElement("input");
+  mergeoutputs.placeholder = "agent:task:key:value triples, semicolon separated";
+  mergerow.append(reporttitle, " ", mergeruleselect, " ", mergeoutputs, " ", button("Build report", async () => {
+    const entries2 = mergeoutputs.value.split(";").map((triple) => triple.split(":")).filter((parts) => parts.length === 4).map((parts) => ({ agentid: parts[0]?.trim() ?? "", taskid: parts[1]?.trim(), key: parts[2]?.trim() ?? "", value: parts[3]?.trim() ?? "" }));
+    await request({ kind: "swarmmerge", entries: entries2, report: { title: reporttitle.value, rule: mergeruleselect.value } });
+    status("The parallel outputs folded into one report with their provenance.");
+    await refresh();
+  }));
+  conflictbox.append(mergerow);
+  const comparerow = document.createElement("div");
+  comparerow.className = "actions";
+  const comparesubject = document.createElement("input");
+  comparesubject.placeholder = "compare subject";
+  const comparefirst = document.createElement("select");
+  const comparesecond = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const one = document.createElement("option");
+    one.value = agent.id;
+    one.textContent = agent.name;
+    comparefirst.append(one);
+    const two = document.createElement("option");
+    two.value = agent.id;
+    two.textContent = agent.name;
+    comparesecond.append(two);
+  }
+  const comparevalue = document.createElement("input");
+  comparevalue.placeholder = "output of the first agent";
+  const comparevalue2 = document.createElement("input");
+  comparevalue2.placeholder = "output of the second agent";
+  comparerow.append(comparesubject, " ", comparefirst, " ", comparevalue, " ", comparesecond, " ", comparevalue2, " ", button("Compare outputs", async () => {
+    await request({ kind: "swarmmerge", compare: { subject: comparesubject.value, outputs: [{ agentid: comparefirst.value, value: comparevalue.value }, { agentid: comparesecond.value, value: comparevalue2.value }] } });
+    status("The competing outputs were contrasted for the user.");
+    await refresh();
+  }));
+  conflictbox.append(comparerow);
+  const lessonrow = document.createElement("div");
+  lessonrow.className = "actions";
+  const lessonagent = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    lessonagent.append(option);
+  }
+  const lessonstatement = document.createElement("input");
+  lessonstatement.placeholder = "verified lesson";
+  const lessonverifier = document.createElement("input");
+  lessonverifier.placeholder = "verified by";
+  lessonrow.append(lessonagent, " ", lessonstatement, " ", lessonverifier, " ", button("Share lesson", async () => {
+    await request({ kind: "swarmmerge", lesson: { agentid: lessonagent.value, statement: lessonstatement.value, verifiedby: lessonverifier.value } });
+    status("The verified lesson landed on the findings section for every agent.");
+    await refresh();
+  }), " ", button("Recompute costs", async () => {
+    await request({ kind: "swarmmerge", costs: true });
+    status("The shared cost accounting summed the per agent usage into the swarm totals.");
+    await refresh();
+  }));
+  conflictbox.append(lessonrow);
+  agentsroot.append(conflictbox);
+  const timelinebox = document.createElement("details");
+  timelinebox.className = "sessiongroup";
+  const timelinesummary = document.createElement("summary");
+  timelinesummary.textContent = `Swarm timeline and costs (${swarm.timeline.length} actions)`;
+  timelinebox.append(timelinesummary);
+  const feed2 = document.createElement("ul");
+  feed2.className = "audit";
+  for (const action of swarm.timeline.slice(-12).reverse()) {
+    const entry = document.createElement("li");
+    entry.textContent = `${new Date(action.at).toLocaleTimeString()} ${action.kind}${action.agentid !== void 0 ? ` (${action.agentid})` : ""}: ${action.summary}`;
+    feed2.append(entry);
+  }
+  timelinebox.append(feed2);
+  const replayrow = document.createElement("div");
+  replayrow.className = "actions";
+  const replayselect = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    replayselect.append(option);
+  }
+  replayrow.append(replayselect, " ", button("Replay agent run", async () => {
+    const replayed = await request({ kind: "swarmmerge", replay: replayselect.value });
+    status(replayed.replay !== void 0 && replayed.replay.length > 0 ? `The replay rebuilt ${replayed.replay.length} recorded actions of the agent.` : "The audit trail holds no recorded action of that agent yet.");
+    await refresh();
+  }));
+  timelinebox.append(replayrow);
+  const latestcost = swarm.costs[0];
+  if (latestcost !== void 0) {
+    const costinfo = document.createElement("p");
+    costinfo.textContent = `Shared costs of ${latestcost.agents} agent${latestcost.agents === 1 ? "" : "s"}: ${latestcost.tokens} tokens \xB7 ${latestcost.cost} ${latestcost.currency ?? ""} \xB7 ${latestcost.steps} steps.`;
+    timelinebox.append(costinfo);
+  }
+  agentsroot.append(timelinebox);
   if (swarm.events.length > 0) {
     const eventbox = document.createElement("details");
     eventbox.className = "sessiongroup";
@@ -5878,4 +6696,31 @@ function renderagents(context) {
     agentsroot.append(eventbox);
   }
 }
+{
+  let sandboxframe;
+  chrome.runtime.onMessage.addListener((message, _sender, sendresponse) => {
+    if (!message || message.kind !== "environments" || message.action !== "sandboxhost" || !message.render?.nonce) return false;
+    try {
+      if (!sandboxframe) {
+        sandboxframe = document.createElement("iframe");
+        sandboxframe.src = chrome.runtime.getURL("sandbox.html");
+        sandboxframe.style.display = "none";
+        sandboxframe.setAttribute("aria-hidden", "true");
+        document.body.append(sandboxframe);
+      }
+      sandboxframe.contentWindow?.postMessage({ channel: "devthinksandbox", type: "render", nonce: message.render.nonce, markup: message.render.markup ?? "" }, "*");
+      const waitfor = (event) => {
+        const data = event.data;
+        if (data?.channel !== "devthinksandbox" || data.type !== "renderresult" || data.nonce !== message.render?.nonce) return;
+        window.removeEventListener("message", waitfor);
+        sendresponse({ ok: data.ok !== false, text: data.text ?? "", summary: data.summary ?? "The sandbox frame returned its render result." });
+      };
+      window.addEventListener("message", waitfor);
+      return true;
+    } catch {
+      sendresponse({ ok: false, text: "", summary: "The sandbox host could not open the sandboxed page." });
+      return true;
+    }
+  });
+}
 //# sourceMappingURL=sidepanel.js.map