@wenathlan/extension 1.1.57 → 1.1.59

package/extension/dist/sidepanel.js

@@ -394,6 +394,7 @@ var workfloweditorroot = document.querySelector("#workfloweditor");
 var triggersroot = document.querySelector("#triggers");
 var agentprotocolroot = document.querySelector("#agentprotocol");
 var modelsroot = document.querySelector("#models");
+var agentsroot = document.querySelector("#agents");
 var commandinput = document.querySelector("#command");
 var commandbutton = document.querySelector("#commandsend");
 var intentbadge = document.querySelector("#intentbadge");
@@ -2881,6 +2882,7 @@ async function refresh() {
   rendertriggers(context);
   renderagentprotocol(context);
   rendermodels(context);
+  renderagents(context);
   renderconsolediff();
   renderaudit(context.audit);
   rendercapabilities(context.capabilities);
@@ -5541,4 +5543,891 @@ function rendermodels(context) {
   }
   modelsroot.append(guardbox);
 }
+function renderagents(context) {
+  if (!agentsroot) return;
+  agentsroot.replaceChildren();
+  const swarm = context.swarm;
+  if (!swarm) {
+    const empty = document.createElement("p");
+    empty.textContent = "The swarm state is unknown.";
+    agentsroot.append(empty);
+    return;
+  }
+  const head = document.createElement("p");
+  head.textContent = `${swarm.overview.agents} agent${swarm.overview.agents === 1 ? "" : "s"} (${swarm.overview.active} active, ${swarm.overview.paused} paused, ${swarm.overview.stopped} stopped) \xB7 ${swarm.overview.tasks} task${swarm.overview.tasks === 1 ? "" : "s"} (${swarm.overview.claimed} claimed, ${swarm.overview.queued} queued, ${swarm.overview.done} done) \xB7 ${swarm.overview.messages} message${swarm.overview.messages === 1 ? "" : "s"} with ${swarm.overview.unread} unread \xB7 queue policy ${swarm.queue.completionpolicy}${swarm.queue.complete ? " \xB7 queue complete" : ""}.`;
+  agentsroot.append(head);
+  const switchbox = document.createElement("div");
+  switchbox.className = "actions";
+  if (swarm.killswitch.engaged) {
+    const state = document.createElement("span");
+    state.className = "muted";
+    state.textContent = `Killswitch engaged${swarm.killswitch.reason !== void 0 ? `: ${swarm.killswitch.reason}` : ""}; every agent halted.`;
+    switchbox.append(state, " ", button("Disarm killswitch", async () => {
+      await request({ kind: "swarmagent", disarm: true });
+      status("The killswitch disarmed; the stopped agents stay stopped until resumed.");
+      await refresh();
+    }));
+  } else {
+    switchbox.append(button("Halt every agent (killswitch)", async () => {
+      if (window.confirm("Halt every agent of the swarm at once?")) {
+        await request({ kind: "swarmagent", killall: true, reason: "The user halted the swarm from the panel." });
+        status("The killswitch engaged: every agent halted at once and the claims returned to the queue.");
+        await refresh();
+      }
+    }));
+  }
+  agentsroot.append(switchbox);
+  const agentsbox = document.createElement("details");
+  agentsbox.className = "sessiongroup";
+  agentsbox.open = true;
+  const agentsummary = document.createElement("summary");
+  agentsummary.textContent = `Agent cards (${swarm.agents.length})`;
+  agentsbox.append(agentsummary);
+  for (const agent of swarm.agents) {
+    const row = document.createElement("div");
+    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` : ""}${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";
+    actions.append(button("Pause", async () => {
+      await request({ kind: "swarmagent", agentid: agent.id, action: "pause" });
+      status(`Paused the agent ${agent.name}; the others keep running.`);
+      await refresh();
+    }), " ", button("Resume", async () => {
+      await request({ kind: "swarmagent", agentid: agent.id, action: "resume" });
+      status(`Resumed the agent ${agent.name}.`);
+      await refresh();
+    }), " ", button("Stop", async () => {
+      await request({ kind: "swarmagent", agentid: agent.id, action: "stop" });
+      status(`Stopped the agent ${agent.name}.`);
+      await refresh();
+    }), " ", button("Claim task", async () => {
+      await request({ kind: "swarmqueue", agentid: agent.id, claim: true });
+      status(`The agent ${agent.name} claimed the highest priority task; the proposal still passes the plan review.`);
+      await refresh();
+    }), " ", button("Heartbeat", async () => {
+      await request({ kind: "swarmagent", agentid: agent.id, heartbeat: true });
+      status(`The agent ${agent.name} refreshed its heartbeat.`);
+      await refresh();
+    }));
+    const budgetrow = document.createElement("div");
+    budgetrow.className = "actions";
+    const tokensinput = document.createElement("input");
+    tokensinput.placeholder = "token ceiling";
+    const costinput = document.createElement("input");
+    costinput.placeholder = "cost ceiling";
+    const stepsinput = document.createElement("input");
+    stepsinput.placeholder = "step ceiling";
+    const currencyinput = document.createElement("input");
+    currencyinput.placeholder = "currency";
+    budgetrow.append(tokensinput, " ", costinput, " ", currencyinput, " ", stepsinput, " ", button("Set budget", async () => {
+      await request({ kind: "swarmagent", agentid: agent.id, budget: { ...tokensinput.value.trim() !== "" ? { maxtokens: Number(tokensinput.value) } : {}, ...costinput.value.trim() !== "" ? { maxcost: Number(costinput.value) } : {}, ...stepsinput.value.trim() !== "" ? { maxsteps: Number(stepsinput.value) } : {}, ...currencyinput.value.trim() !== "" ? { currency: currencyinput.value.trim() } : {} } });
+      status(`Saved the budget of the agent ${agent.name}.`);
+      await refresh();
+    }));
+    row.append(actions, budgetrow);
+    agentsbox.append(row);
+  }
+  const addrow = document.createElement("div");
+  addrow.className = "actions";
+  const nameinput = document.createElement("input");
+  nameinput.placeholder = "new agent name";
+  const roleselect = document.createElement("select");
+  for (const role of ["worker", "planner", "observer", "critic", "verifier"]) {
+    const option = document.createElement("option");
+    option.value = role;
+    option.textContent = role;
+    roleselect.append(option);
+  }
+  const customrole = document.createElement("input");
+  customrole.placeholder = "custom role";
+  const tabinput = document.createElement("input");
+  tabinput.placeholder = "tab id";
+  addrow.append(nameinput, " ", roleselect, " ", customrole, " ", tabinput, " ", button("Register agent", async () => {
+    await request({ kind: "swarmagent", register: { name: nameinput.value, role: customrole.value.trim() !== "" ? customrole.value.trim() : roleselect.value, ...tabinput.value.trim() !== "" ? { tabid: Number(tabinput.value) } : {} } });
+    status(`Registered the agent ${nameinput.value}; one tab holds at most one agent.`);
+    await refresh();
+  }));
+  agentsbox.append(addrow);
+  const spawnrow = document.createElement("div");
+  spawnrow.className = "actions";
+  const parentselect = document.createElement("select");
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    parentselect.append(option);
+  }
+  const spawnrole = document.createElement("select");
+  for (const role of ["worker", "planner", "observer", "critic", "verifier"]) {
+    const option = document.createElement("option");
+    option.value = role;
+    option.textContent = role;
+    spawnrole.append(option);
+  }
+  const spawntask = document.createElement("input");
+  spawntask.placeholder = "sub agent task";
+  const spawndepth = document.createElement("input");
+  spawndepth.placeholder = "depth";
+  spawndepth.value = "1";
+  const spawnname = document.createElement("input");
+  spawnname.placeholder = "sub agent name";
+  spawnrow.append(parentselect, " ", spawnrole, " ", spawntask, " ", spawndepth, " ", spawnname, " ", button("Spawn sub agent", async () => {
+    await request({ kind: "swarmagent", spawn: { parentid: parentselect.value, role: spawnrole.value, task: spawntask.value, depth: Number(spawndepth.value || "1"), ...spawnname.value.trim() !== "" ? { name: spawnname.value } : {} } });
+    status("Spawned the sub agent; the depth history records the recursion.");
+    await refresh();
+  }));
+  agentsbox.append(spawnrow);
+  if (swarm.spawns.length > 0) {
+    const history = document.createElement("p");
+    history.textContent = `Spawn history: ${swarm.spawns.slice(0, 5).map((record) => `${record.parentid} \u2192 ${record.childid} (${record.role}, depth ${record.depth})`).join("; ")}.`;
+    agentsbox.append(history);
+  }
+  agentsroot.append(agentsbox);
+  const queuebox = document.createElement("details");
+  queuebox.className = "sessiongroup";
+  queuebox.open = true;
+  const queuesummary = document.createElement("summary");
+  queuesummary.textContent = `Task queue (${swarm.queue.items.length})`;
+  queuebox.append(queuesummary);
+  for (const lane of swarm.queue.lanesreport) {
+    const row = document.createElement("p");
+    const claims = swarm.queue.claims.filter((claim) => swarm.queue.items.some((item) => item.id === claim.taskid && item.lane === lane.lane && item.state === "claimed"));
+    row.textContent = `Lane ${lane.lane}: ${lane.queued} queued \xB7 ${lane.claimed} claimed \xB7 ${lane.done} done \xB7 ${lane.cancelled} cancelled${claims.length > 0 ? ` \xB7 held by ${claims.map((claim) => claim.agentid).join(", ")}` : ""}.`;
+    queuebox.append(row);
+  }
+  const list = document.createElement("ol");
+  list.className = "audit";
+  for (const item of swarm.queue.items.slice(0, 12)) {
+    const entry = document.createElement("li");
+    entry.textContent = `${item.payload} \u2014 lane ${item.lane}, priority ${item.priority}, ${item.state}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    actions.append(button("Complete", async () => {
+      await request({ kind: "swarmqueue", taskid: item.id, complete: true });
+      status("The task completed and released its claim.");
+      await refresh();
+    }), " ", button("Cancel", async () => {
+      await request({ kind: "swarmqueue", taskid: item.id, cancel: true });
+      status("The task left the queue.");
+      await refresh();
+    }));
+    entry.append(actions);
+    list.append(entry);
+  }
+  queuebox.append(list);
+  const enqueuerow = document.createElement("div");
+  enqueuerow.className = "actions";
+  const laneinput = document.createElement("input");
+  laneinput.placeholder = "lane";
+  const priorityinput = document.createElement("input");
+  priorityinput.placeholder = "priority";
+  const payloadinput = document.createElement("input");
+  payloadinput.placeholder = "task in plain language";
+  const lanesinput = document.createElement("input");
+  lanesinput.placeholder = "configured lanes, comma separated";
+  lanesinput.value = swarm.queue.lanes.join(", ");
+  enqueuerow.append(laneinput, " ", priorityinput, " ", payloadinput, " ", button("Enqueue", async () => {
+    await request({ kind: "swarmqueue", enqueue: { lane: laneinput.value, priority: Number(priorityinput.value || "0"), payload: payloadinput.value } });
+    status("The task entered the lane; nothing runs before the plan review.");
+    await refresh();
+  }), " ", button("Requeue orphans", async () => {
+    await request({ kind: "swarmqueue", requeue: true });
+    status("The requeue pass returned the orphaned tasks to their lanes.");
+    await refresh();
+  }), " ", button("Save lanes", async () => {
+    await request({ kind: "swarmqueue", lanes: lanesinput.value.split(",").map((lane) => lane.trim()).filter((lane) => lane !== "") });
+    status("Saved the configured lanes.");
+    await refresh();
+  }));
+  queuebox.append(enqueuerow);
+  agentsroot.append(queuebox);
+  const mailboxbox = document.createElement("details");
+  mailboxbox.className = "sessiongroup";
+  const mailboxsummary = document.createElement("summary");
+  mailboxsummary.textContent = `Mailboxes (${swarm.mailboxes.length})`;
+  mailboxbox.append(mailboxsummary);
+  for (const mailbox of swarm.mailboxes) {
+    if (mailbox.inbox.length === 0 && mailbox.outbox.length === 0) continue;
+    const row = document.createElement("div");
+    row.className = "sessionrow";
+    const info = document.createElement("p");
+    info.textContent = `Agent ${mailbox.agentid}: ${mailbox.inbox.length} in, ${mailbox.outbox.length} out, ${mailbox.unread} unread.`;
+    row.append(info);
+    const feed = document.createElement("ul");
+    feed.className = "audit";
+    for (const message of [...mailbox.inbox, ...mailbox.outbox].slice(0, 6)) {
+      const entry = document.createElement("li");
+      entry.textContent = `${message.senderid} \u2192 ${message.recipient} (${message.routing}): ${message.payload}`;
+      feed.append(entry);
+    }
+    row.append(feed, button("Receive", async () => {
+      await request({ kind: "swarmmailbox", agentid: mailbox.agentid, receive: true });
+      status(`The agent ${mailbox.agentid} drained its inbox.`);
+      await refresh();
+    }));
+    mailboxbox.append(row);
+  }
+  const composerow = document.createElement("div");
+  composerow.className = "actions";
+  const recipientselect = document.createElement("select");
+  const broadcastoption = document.createElement("option");
+  broadcastoption.value = "*";
+  broadcastoption.textContent = "broadcast (every agent)";
+  recipientselect.append(broadcastoption);
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = `${agent.name} (${agent.id})`;
+    recipientselect.append(option);
+  }
+  const routingselect = document.createElement("select");
+  for (const routing of ["direct", "broadcast", "role"]) {
+    const option = document.createElement("option");
+    option.value = routing;
+    option.textContent = routing;
+    routingselect.append(option);
+  }
+  const messageinput = document.createElement("input");
+  messageinput.placeholder = "message to the agents";
+  composerow.append(recipientselect, " ", routingselect, " ", messageinput, " ", button("Send user message", async () => {
+    await request({ kind: "swarmmailbox", send: { senderid: "user", recipient: recipientselect.value, routing: routingselect.value, payload: messageinput.value } });
+    status("The user message was delivered to the swarm.");
+    await refresh();
+  }));
+  mailboxbox.append(composerow);
+  agentsroot.append(mailboxbox);
+  const boardbox = document.createElement("details");
+  boardbox.className = "sessiongroup";
+  const boardsummary = document.createElement("summary");
+  boardsummary.textContent = "Blackboard";
+  boardbox.append(boardsummary);
+  for (const section of swarm.blackboard.sections) {
+    const row = document.createElement("p");
+    row.textContent = `Section ${section.section}: ${section.entries} live entr${section.entries === 1 ? "y" : "ies"}${section.authors.length > 0 ? ` by ${section.authors.join(", ")}` : ""}${section.freshestat !== void 0 ? ` \xB7 freshest ${new Date(section.freshestat).toLocaleTimeString()}` : ""}.`;
+    boardbox.append(row);
+  }
+  const entries = document.createElement("ol");
+  entries.className = "audit";
+  for (const entry of swarm.blackboard.entries.slice(0, 12)) {
+    const item = document.createElement("li");
+    item.textContent = `[${entry.section}] ${entry.key} = ${entry.value} \u2014 ${entry.author}, ${entry.consentclass}, posted ${new Date(entry.postedat).toLocaleTimeString()}.`;
+    const actions = document.createElement("div");
+    actions.className = "actions";
+    actions.append(button("Retire", async () => {
+      await request({ kind: "swarmblackboard", retire: entry.id });
+      status(`Retired the entry ${entry.key}.`);
+      await refresh();
+    }));
+    item.append(actions);
+    entries.append(item);
+  }
+  boardbox.append(entries);
+  const postrow = document.createElement("div");
+  postrow.className = "actions";
+  const keyinput = document.createElement("input");
+  keyinput.placeholder = "key";
+  const valueinput = document.createElement("input");
+  valueinput.placeholder = "value";
+  const sectionselect = document.createElement("select");
+  for (const section of ["goals", "facts", "findings", "scratch"]) {
+    const option = document.createElement("option");
+    option.value = section;
+    option.textContent = section;
+    sectionselect.append(option);
+  }
+  const authorselect = document.createElement("select");
+  const useroption = document.createElement("option");
+  useroption.value = "user";
+  useroption.textContent = "user";
+  authorselect.append(useroption);
+  for (const agent of swarm.agents) {
+    const option = document.createElement("option");
+    option.value = agent.id;
+    option.textContent = agent.name;
+    authorselect.append(option);
+  }
+  postrow.append(keyinput, " ", valueinput, " ", sectionselect, " ", authorselect, " ", button("Post entry", async () => {
+    await request({ kind: "swarmblackboard", post: { key: keyinput.value, value: valueinput.value, section: sectionselect.value, author: authorselect.value } });
+    status("The entry landed on the shared board; every agent reads it.");
+    await refresh();
+  }), " ", button("Retirement sweep", async () => {
+    await request({ kind: "swarmblackboard", sweep: true });
+    status("The retirement pass expired the stale entries.");
+    await refresh();
+  }));
+  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";
+    const eventsummary = document.createElement("summary");
+    eventsummary.textContent = `Lifecycle events (${swarm.events.length})`;
+    eventbox.append(eventsummary);
+    const feed = document.createElement("ul");
+    feed.className = "audit";
+    for (const event of swarm.events.slice(0, 10)) {
+      const entry = document.createElement("li");
+      entry.textContent = `${event.kind}: ${event.summary}`;
+      feed.append(entry);
+    }
+    eventbox.append(feed);
+    agentsroot.append(eventbox);
+  }
+}
 //# sourceMappingURL=sidepanel.js.map