@wenathlan/extension 1.1.35 → 1.1.36

package/extension/dist/background.js

@@ -352,19 +352,105 @@ var sessionmemory = class {
   async setnavstate(tabid2, state) {
     return this.adapter.set(`navstate${tabid2}`, state);
   }
+  /** Stores one named tab layout with its window bounds and group states, replacing the previous layout of that name. */
+  async setlayout(layout) {
+    const records = (await this.getlayouts()).filter((item) => item.name !== layout.name);
+    await this.adapter.set("layouts", [layout, ...records]);
+  }
+  /** Returns one saved tab layout by name with its timestamp. */
+  async getlayout(name) {
+    return (await this.getlayouts()).find((item) => item.name === name);
+  }
+  /** Returns every saved tab layout with its window bounds and group states. */
+  async getlayouts() {
+    return await this.adapter.get("layouts") ?? [];
+  }
+  /** Stores one tab group definition with its color choice and member tabs, replacing the previous definition of that name. */
+  async settabgroup(group) {
+    const records = (await this.gettabgroups()).filter((item) => item.name !== group.name);
+    await this.adapter.set("tabgroups", [...records, group]);
+  }
+  /** Returns every stored tab group definition with its color choice, newest first. */
+  async gettabgroups() {
+    return await this.adapter.get("tabgroups") ?? [];
+  }
+  /** Records one tabmeta record with task provenance, replacing the previous metadata of that tab. */
+  async settabmeta(meta) {
+    const records = (await this.gettabmetas()).filter((item) => item.tabid !== meta.tabid);
+    await this.adapter.set("tabmetas", [...records, meta]);
+  }
+  /** Returns every stored tabmeta record with task provenance. */
+  async gettabmetas() {
+    return await this.adapter.get("tabmetas") ?? [];
+  }
+  /** Records one session snapshot of tabs and windows for later restore. */
+  async addsnapshot(snapshot2) {
+    const records = await this.getsnapshots();
+    await this.adapter.set("snapshots", [snapshot2, ...records]);
+  }
+  /** Returns every stored session snapshot, newest first. */
+  async getsnapshots() {
+    return await this.adapter.get("snapshots") ?? [];
+  }
+  /** Records one closed tab in the history kept for restoretab and reopenrun. */
+  async addclosedtab(tab) {
+    const records = await this.getclosedtabs();
+    await this.adapter.set("closedtabs", [tab, ...records]);
+  }
+  /** Returns the closed tab history, newest first. */
+  async getclosedtabs() {
+    return await this.adapter.get("closedtabs") ?? [];
+  }
+  /** Stores one badge state per task, replacing the previous badge of that task. */
+  async setbadge(badge) {
+    const records = (await this.getbadges()).filter((item) => item.taskid !== badge.taskid);
+    await this.adapter.set("badges", [...records, badge]);
+  }
+  /** Returns every stored badge state per task. */
+  async getbadges() {
+    return await this.adapter.get("badges") ?? [];
+  }
+  /** Records one tab event observed inside a reviewed watchtab registration. */
+  async addtabwatchevent(event) {
+    const records = await this.gettabwatchevents();
+    await this.adapter.set("tabwatchevents", [event, ...records]);
+  }
+  /** Returns the tab event stream of every reviewed watchtab registration, newest first. */
+  async gettabwatchevents() {
+    return await this.adapter.get("tabwatchevents") ?? [];
+  }
+  /** Returns the ids of the scratch windows opened for split work. */
+  async getscratchwindows() {
+    return await this.adapter.get("scratchwindows") ?? [];
+  }
+  /** Replaces the scratch window id list after one scratch window opens or closes. */
+  async setscratchwindows(ids) {
+    return this.adapter.set("scratchwindows", ids);
+  }
+  /** Returns the pinned control tab state with the live task feed. */
+  async getcontroltab() {
+    return this.adapter.get("controltab");
+  }
+  /** Replaces the pinned control tab state. */
+  async setcontroltab(state) {
+    return this.adapter.set("controltab", state);
+  }
 };
 function randomid() {
   return crypto.randomUUID();
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen"]);
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
+var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
 var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow"]);
+var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
+var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
+var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
 function normalizeendpoint(value) {
   const endpoint = new URL(value.trim());
   if (endpoint.protocol !== "https:") throw new Error("Devthink accepts HTTPS endpoints only.");
@@ -397,8 +483,27 @@ function requiredcapability(kind) {
   if (kind === "downloadfile") return "downloads";
   if (kind === "openclipboard") return "clipboardRead";
   if (kind === "openlink" || kind === "openprivate" || kind === "navlist" || kind === "batchopen" || kind === "reopentab" || kind === "deeplink") return "tabs";
+  if (tabscommandactions.has(kind)) return "tabs";
   return void 0;
 }
+function istabscommandkind(kind) {
+  return tabscommandactions.has(kind);
+}
+function islayoutkind(kind) {
+  return layoutmutationactions.has(kind);
+}
+function layoutmutationgranted(session, now) {
+  if (!session || session.stoppedat || session.expiresat <= now) return { allowed: false, reason: "Group and layout mutations stay inside the active session." };
+  return { allowed: true };
+}
+function windowclosegate(tasktabcount, reviewed) {
+  if (tasktabcount > 1 && !reviewed) return { allowed: false, reason: `The window holds ${tasktabcount} task tabs and needs explicit review before it closes.` };
+  return { allowed: true };
+}
+function tasktabceiling(settings) {
+  const ceiling = settings?.tasktabceiling;
+  return typeof ceiling === "number" && Number.isFinite(ceiling) && ceiling >= 0 ? ceiling : void 0;
+}
 function waitduration(step) {
   const requested = step.value ? Number.parseInt(step.value, 10) : 250;
   if (!Number.isFinite(requested) || requested < 0) throw new Error("Wait duration must be zero or a positive number of milliseconds.");
@@ -561,6 +666,104 @@ function validateratelimit(value) {
   if (typeof limit.ceiling !== "number" || !Number.isInteger(limit.ceiling) || limit.ceiling < 1) return { allowed: false, reason: "The reviewed ratelimit ceiling must be a positive integer with no code ceiling." };
   return { allowed: true };
 }
+function validatetabquery(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed tabquery with at least one matcher is required in options." };
+  const query = value;
+  const hasmatcher = query.url !== void 0 || query.title !== void 0 || query.id !== void 0 || query.pattern !== void 0;
+  if (!hasmatcher) return { allowed: false, reason: "The reviewed tabquery needs a url, title, id or pattern matcher." };
+  if (query.url !== void 0 && !isnonempty(query.url)) return { allowed: false, reason: "The reviewed tabquery url matcher must be a non-empty string." };
+  if (query.title !== void 0 && !isnonempty(query.title)) return { allowed: false, reason: "The reviewed tabquery title matcher must be a non-empty string." };
+  if (query.pattern !== void 0 && !isnonempty(query.pattern)) return { allowed: false, reason: "The reviewed tabquery pattern matcher must be a non-empty string." };
+  if (query.id !== void 0 && (typeof query.id !== "number" || !Number.isInteger(query.id) || query.id < 0)) return { allowed: false, reason: "The reviewed tabquery id matcher must be a non-negative integer tab id." };
+  return { allowed: true };
+}
+function validategroupcolor(value) {
+  return typeof value === "string" && groupcolors.includes(value);
+}
+function validateidlist(options, key) {
+  const ids = options[key];
+  return Array.isArray(ids) && ids.length > 0 && ids.every((id) => typeof id === "number" && Number.isInteger(id) && id >= 0);
+}
+function validatetabsgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "querytabs" || kind === "closepattern") {
+    const querycheck = validatetabquery(options.tabquery);
+    if (!querycheck.allowed) return querycheck;
+    if (kind === "closepattern" && options.reviewed !== true) return { allowed: false, reason: "The close pattern needs the explicit reviewed flag before any tab closes." };
+  }
+  if (kind === "duplicatetab" || kind === "pintab" || kind === "mutetab" || kind === "movetab" || kind === "movetabwindow" || kind === "badgetab" || kind === "attachmeta") {
+    if (!isnumericid(step.value)) return { allowed: false, reason: "A numeric browser tab id is required." };
+  }
+  if (kind === "focuswindow" || kind === "maximizewindow" || kind === "minimizewindow" || kind === "restorewindow") {
+    if (!isnumericid(step.value)) return { allowed: false, reason: "A numeric browser window id is required." };
+  }
+  if (kind === "pintab" && typeof options.pinned !== "boolean") return { allowed: false, reason: "A reviewed pinned flag is required in options." };
+  if (kind === "mutetab" && typeof options.muted !== "boolean") return { allowed: false, reason: "A reviewed muted flag is required in options." };
+  if (kind === "movetab") {
+    if (typeof options.index !== "number" || !Number.isInteger(options.index) || options.index < 0) return { allowed: false, reason: "A reviewed non-negative target index is required in options." };
+  }
+  if (kind === "movetabwindow") {
+    if (typeof options.windowid !== "number" || !Number.isInteger(options.windowid) || options.windowid < 0) return { allowed: false, reason: "A reviewed target window id is required in options." };
+  }
+  if (kind === "grouptabs") {
+    const group = options.group;
+    if (!group || typeof group !== "object" || Array.isArray(group)) return { allowed: false, reason: "A reviewed group with a name is required in options." };
+    const spec = group;
+    if (!isnonempty(spec.name)) return { allowed: false, reason: "The reviewed group needs a non-empty name." };
+    if (!validategroupcolor(spec.color)) return { allowed: false, reason: "The reviewed group color must be a Chromium tab group color." };
+    if (!validateidlist(spec, "tabids")) return { allowed: false, reason: "The reviewed group needs a non-empty list of member tab ids." };
+  }
+  if (kind === "colorgroup") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed group name is required in options." };
+    if (!validategroupcolor(options.color)) return { allowed: false, reason: "The reviewed group color must be a Chromium tab group color." };
+  }
+  if (kind === "collapsegroup") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed group name is required in options." };
+    if (typeof options.collapsed !== "boolean") return { allowed: false, reason: "A reviewed collapsed flag is required in options." };
+  }
+  if (kind === "discardtab" || kind === "reloadtabs") {
+    if (!isnumericid(step.value) && !validateidlist(options, "tabs")) return { allowed: false, reason: "A numeric tab id or a reviewed list of tab ids is required." };
+  }
+  if (kind === "zoomin" || kind === "zoomout") {
+    if (options.step !== void 0 && (typeof options.step !== "number" || !Number.isFinite(options.step) || options.step <= 0)) return { allowed: false, reason: "The reviewed zoom step must be a positive number with no code ceiling." };
+    if (step.value !== void 0 && step.value !== "" && !isnumericid(step.value)) return { allowed: false, reason: "The reviewed zoom target must be a numeric tab id." };
+  }
+  if (kind === "switchtab") {
+    if (options.direction !== "next" && options.direction !== "previous") return { allowed: false, reason: "A reviewed switch direction of next or previous is required in options." };
+  }
+  if (kind === "restorewindow") {
+    const bounds = options.bounds;
+    if (bounds !== void 0) {
+      if (!bounds || typeof bounds !== "object" || Array.isArray(bounds)) return { allowed: false, reason: "The reviewed window bounds must be an object." };
+      const shape = bounds;
+      for (const field of ["left", "top", "width", "height"]) {
+        if (typeof shape[field] !== "number" || !Number.isFinite(shape[field])) return { allowed: false, reason: "The reviewed window bounds need numeric left, top, width and height." };
+      }
+    }
+  }
+  if (kind === "scratchwindow") {
+    if (step.value !== void 0 && step.value !== "" && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed scratch window url must use HTTPS." };
+  }
+  if (kind === "incognitowindow" && !ishttpsurl(step.value)) return { allowed: false, reason: "A reviewed HTTPS url is required to open an incognito window." };
+  if (kind === "restoretab" && step.value !== void 0 && step.value !== "" && !ishttpsurl(step.value)) return { allowed: false, reason: "The reviewed restore url must use HTTPS." };
+  if (kind === "savelayout" || kind === "restorelayout") {
+    if (!isnonempty(options.name)) return { allowed: false, reason: "A reviewed layout name is required in options." };
+  }
+  if (kind === "badgetab") {
+    if (!isnonempty(options.label)) return { allowed: false, reason: "A reviewed badge label is required in options." };
+    if (options.taskid !== void 0 && !isnonempty(options.taskid)) return { allowed: false, reason: "The reviewed badge task id must be a non-empty string." };
+  }
+  if (kind === "attachmeta") {
+    const labels = options.labels;
+    const taskrefs = options.taskrefs;
+    const haslabels = Array.isArray(labels) && labels.length > 0 && labels.every((label) => isnonempty(label));
+    const hastaskrefs = Array.isArray(taskrefs) && taskrefs.length > 0 && taskrefs.every((ref) => isnonempty(ref));
+    if (!haslabels && !hastaskrefs) return { allowed: false, reason: "Reviewed labels or task refs are required in options to attach metadata." };
+    if (options.provenance !== void 0 && !isnonempty(options.provenance)) return { allowed: false, reason: "The reviewed provenance must be a non-empty string." };
+  }
+  if (kind === "reopenrun" && !isnonempty(options.run)) return { allowed: false, reason: "A reviewed run id is required in options to reopen its tabs." };
+  return { allowed: true };
+}
 function validatestep(step, origin) {
   if (!allowedactions.has(step.kind)) return { allowed: false, reason: "Unsupported action kind." };
   if (!step.summary.trim()) return { allowed: false, reason: "A human-readable action summary is required." };
@@ -762,6 +965,20 @@ function validatestep(step, origin) {
     const listcheck = validateurllist(options, "urls");
     if (!listcheck.allowed) return listcheck;
   }
+  if (istabscommandkind(step.kind)) {
+    const tabscheck = validatetabsgrammar(step, options);
+    if (!tabscheck.allowed) return tabscheck;
+  }
+  if (step.kind === "tabcreate") {
+    if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
+    if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
+  }
+  if (step.kind === "windowcreate") {
+    for (const field of ["left", "top", "width", "height"]) {
+      if (options[field] !== void 0 && (typeof options[field] !== "number" || !Number.isFinite(options[field]))) return { allowed: false, reason: `The reviewed window ${field} must be a number.` };
+    }
+    if (options.state !== void 0 && !["normal", "maximized", "minimized", "fullscreen"].includes(options.state)) return { allowed: false, reason: "The reviewed window state must be normal, maximized, minimized or fullscreen." };
+  }
   return { allowed: true };
 }
 function sessiongate(input) {
@@ -792,6 +1009,7 @@ function canexecute(input) {
       if (!navigation.allowed) return navigation;
     }
   }
+  if (islayoutkind(input.step.kind) && !layoutmutationgranted(input.session, now).allowed) return { allowed: false, reason: "Group and layout mutations stay inside the active session." };
   if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
     let options = {};
     try {
@@ -864,9 +1082,18 @@ function recordnaventry(progress, planid, stepid, entry, now) {
   const outcome = { stepid, ok: entry.ok, summary: `Navigation list entry ${entry.index + 1} of ${entry.url} ${entry.ok ? "completed" : "failed"}.`, details: { naventry: entry }, at: now };
   return recordoutcome(base, planid, outcome, now);
 }
+function assigntasktab(progress, planid, tabid2, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  if ((base.tasktabs ?? []).includes(tabid2)) return { ...base, updatedat: now };
+  return { ...base, tasktabs: [...base.tasktabs ?? [], tabid2], updatedat: now };
+}
+function tasktabs(progress, planid) {
+  if (!progress || progress.planid !== planid) return [];
+  return progress.tasktabs ?? [];
+}
 
 // version.ts
-var packageversion = "1.1.35";
+var packageversion = "1.1.36";
 
 // types.ts
 var protocolversion = packageversion;
@@ -955,6 +1182,9 @@ function trailreport(input) {
 function safetyresponse(input) {
   return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, verdicts: input.verdicts });
 }
+function layoutreport(input) {
+  return { version: protocolversion, layouts: input.layouts };
+}
 
 // extension/browsertabs.ts
 var browserkinds = /* @__PURE__ */ new Set(["tablist", "tabcreate", "tabactivate", "tabclose", "tabreload", "tabsnapshot", "windowlist", "windowcreate", "windowclose", "zoomset", "windowresize", "downloadfile"]);
@@ -990,8 +1220,9 @@ async function runbrowseraction(step, sessiontabid, windowid) {
       return { ok: true, summary: `Listed ${tabs.length} open tab${tabs.length === 1 ? "" : "s"}.`, details: { tabs: tabs.map((tab) => ({ id: tab.id ?? 0, index: tab.index, title: tab.title ?? "", url: tab.url ?? "", active: tab.active, pinned: tab.pinned, audible: tab.audible ?? false })) } };
     }
     case "tabcreate": {
-      const created = await chrome.tabs.create({ url: step.value, active: options.active !== false, pinned: options.pinned === true });
-      return { ok: true, summary: `Opened a new tab for ${step.value}.`, details: { tabid: created?.id ?? 0 } };
+      const targetwindow = typeof options.window === "number" && Number.isFinite(options.window) ? options.window : void 0;
+      const created = await chrome.tabs.create({ url: step.value, active: options.active !== false && options.background !== true, pinned: options.pinned === true, ...targetwindow !== void 0 ? { windowId: targetwindow } : {} });
+      return { ok: true, summary: `Opened a new tab for ${step.value}${options.background === true ? " in the background without activating it" : ""}.`, details: { tabid: created?.id ?? 0, ...targetwindow !== void 0 ? { windowid: targetwindow } : {}, ...options.background === true ? { background: true } : {} } };
     }
     case "tabactivate": {
       await chrome.tabs.update(tabid(step), { active: true });
@@ -1014,8 +1245,11 @@ async function runbrowseraction(step, sessiontabid, windowid) {
       return { ok: true, summary: `Listed ${windows.length} open window${windows.length === 1 ? "" : "s"}.`, details: { windows: windows.map((item) => ({ id: item.id ?? 0, type: item.type, state: item.state ?? "", focused: item.focused })) } };
     }
     case "windowcreate": {
-      const created = await chrome.windows.create({ url: step.value ?? "about:blank", ...typeof options.width === "number" ? { width: options.width } : {}, ...typeof options.height === "number" ? { height: options.height } : {} });
-      return { ok: true, summary: `Opened a new window for ${step.value}.`, details: { windowid: created?.id ?? 0 } };
+      const bounds = ["left", "top", "width", "height"].filter((field) => typeof options[field] === "number");
+      const geometry = Object.fromEntries(bounds.map((field) => [field, options[field]]));
+      const state = typeof options.state === "string" && ["normal", "maximized", "minimized", "fullscreen"].includes(options.state) ? options.state : void 0;
+      const created = await chrome.windows.create({ url: step.value ?? "about:blank", ...Object.keys(geometry).length > 0 ? geometry : {}, ...state !== void 0 ? { state } : {} });
+      return { ok: true, summary: `Opened a new window for ${step.value}.`, details: { windowid: created?.id ?? 0, ...Object.keys(geometry).length > 0 ? { bounds: geometry } : {}, ...state !== void 0 ? { state } : {} } };
     }
     case "windowclose": {
       await chrome.windows.remove(tabid(step));
@@ -1039,6 +1273,125 @@ async function runbrowseraction(step, sessiontabid, windowid) {
   }
 }
 
+// extension/tabscommand.ts
+function parsetabquery(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const value = options.tabquery;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const query = value;
+  return {
+    ...typeof query.url === "string" && query.url ? { url: query.url } : {},
+    ...typeof query.title === "string" && query.title ? { title: query.title } : {},
+    ...typeof query.id === "number" && Number.isInteger(query.id) && query.id >= 0 ? { id: query.id } : {},
+    ...typeof query.pattern === "string" && query.pattern ? { pattern: query.pattern } : {}
+  };
+}
+function tabpatternmatches(pattern, url) {
+  const source = pattern.split("**").map((part) => part.split("*").map((piece) => piece.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^/]*")).join(".*");
+  return new RegExp(`^${source}$`).test(url);
+}
+function querymatches(query, tabs) {
+  return tabs.filter((tab) => {
+    if (query.id !== void 0 && tab.tabid !== query.id) return false;
+    if (query.url !== void 0 && tab.url !== query.url) return false;
+    if (query.title !== void 0 && !tab.title.toLowerCase().includes(query.title.toLowerCase())) return false;
+    if (query.pattern !== void 0 && !tabpatternmatches(query.pattern, tab.url)) return false;
+    return true;
+  });
+}
+function normalizedtaburl(url) {
+  let normalized = url;
+  const hash = normalized.indexOf("#");
+  if (hash >= 0) normalized = normalized.slice(0, hash);
+  while (normalized.length > 1 && normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return normalized;
+}
+function clonetabs(tabs) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tab of tabs) {
+    if (!tab.url) continue;
+    const key = normalizedtaburl(tab.url);
+    groups.set(key, [...groups.get(key) ?? [], tab.tabid]);
+  }
+  return [...groups.entries()].filter(([, tabids]) => tabids.length > 1).map(([url, tabids]) => ({ url, tabids }));
+}
+function searchtabmatches(tabs, text2) {
+  const needle = text2.trim().toLowerCase();
+  if (!needle) return [];
+  return tabs.filter((tab) => tab.title.toLowerCase().includes(needle) || tab.url.toLowerCase().includes(needle));
+}
+function audiotabs(tabs) {
+  return tabs.filter((tab) => tab.audible || tab.muted && tab.audible);
+}
+function discardcandidates(tabs) {
+  return tabs.filter((tab) => !tab.active && !tab.pinned && !tab.discarded && tab.url.length > 0);
+}
+function buildlayout(name, tabs, windows, groups, scratchwindowids, at) {
+  return {
+    name,
+    tabs: tabs.map((tab) => ({ url: tab.url, title: tab.title, pinned: tab.pinned, index: tab.index, windowid: tab.windowid })),
+    groups: groups.map((group) => ({ name: group.name, color: group.color, tabids: group.tabids.filter((tabid2) => tabs.some((tab) => tab.tabid === tabid2)), collapsed: group.collapsed })),
+    windows: windows.map((item) => ({ windowid: item.windowid, state: { bounds: { left: item.left, top: item.top, width: item.width, height: item.height }, maximized: item.state === "maximized", profile: item.incognito ? "incognito" : scratchwindowids.includes(item.windowid) ? "scratch" : "normal" } })),
+    savedat: at
+  };
+}
+function layoutrestoreplan(layout, openurls) {
+  const open = new Set(openurls.map((url) => normalizedtaburl(url)));
+  return layout.tabs.map((tab) => tab.url).filter((url) => url.length > 0 && !open.has(normalizedtaburl(url)));
+}
+function regroupaftermoves(groups, tabs, at) {
+  const order = new Map(tabs.map((tab) => [tab.tabid, tab.index]));
+  return groups.map((group) => {
+    const members = group.tabids.filter((tabid2) => order.has(tabid2));
+    if (members.length === 0) return group;
+    const ordered = [...members].sort((left, right) => (order.get(left) ?? 0) - (order.get(right) ?? 0));
+    return ordered.length === group.tabids.length && ordered.every((tabid2, index) => tabid2 === group.tabids[index]) ? group : { ...group, tabids: ordered, savedat: at };
+  });
+}
+function tasktabsinwindow(tabs, windowid, tasktabids) {
+  const tasks = new Set(tasktabids);
+  return tabs.filter((tab) => tab.windowid === windowid && tasks.has(tab.tabid)).length;
+}
+function closeselection(query, tabs, sessiontabid) {
+  const matches = querymatches(query, tabs);
+  return {
+    targets: matches.filter((tab) => tab.tabid !== sessiontabid),
+    refused: matches.filter((tab) => tab.tabid === sessiontabid)
+  };
+}
+function zoomstep(current, direction, step) {
+  const next = direction === "in" ? current + step : current - step;
+  return next > 0 ? Number(next.toFixed(4)) : current;
+}
+function switchtarget(tabs, direction, currentindex) {
+  if (tabs.length === 0) return void 0;
+  const offset = direction === "next" ? 1 : -1;
+  return (currentindex + offset + tabs.length) % tabs.length;
+}
+function watchtabdispatch(events, watchid, filters) {
+  const allowed = filters.length > 0 ? new Set(filters) : void 0;
+  return events.filter((event) => event.watchid === watchid && (allowed === void 0 || allowed.has(event.event)));
+}
+function badgefromprogress(completed, total) {
+  if (total <= 0) return { label: "idle", done: false };
+  if (completed >= total) return { label: "done", done: true };
+  return { label: `${completed}/${total}`, done: false };
+}
+function tasktabgauge(used, ceiling) {
+  return { used, ceiling, over: ceiling !== void 0 && used > ceiling };
+}
+function windowprofilegrants(profile) {
+  return profile !== "incognito";
+}
+function trackedtasktabs(progress, planid) {
+  return tasktabs(progress, planid);
+}
+
 // extension/pagedialogs.ts
 function parsedialogpolicy(step) {
   let options = {};
@@ -1661,6 +2014,15 @@ function browserauditkind(step) {
 }
 function stepauditkind(step, ok) {
   if (isbrowserkind(step.kind)) return browserauditkind(step);
+  if (istabscommandkind(step.kind)) {
+    if (step.kind === "grouptabs" || step.kind === "colorgroup" || step.kind === "collapsegroup") return "group";
+    if (step.kind === "savelayout" || step.kind === "restorelayout" || step.kind === "snapshotsession" || step.kind === "reopenrun") return "layout";
+    if (step.kind === "discardtab") return "discard";
+    if (step.kind === "badgetab") return "badge";
+    if (step.kind === "watchtab") return "watch";
+    if (step.kind === "maximizewindow" || step.kind === "minimizewindow" || step.kind === "restorewindow" || step.kind === "focuswindow" || step.kind === "scratchwindow" || step.kind === "incognitowindow") return "window";
+    return "tab";
+  }
   if (step.kind === "dismissdialog") return "dialog";
   if (step.kind === "keyhold" || step.kind === "keyrelease") return "hold";
   if (step.kind === "retryaction") return "retry";
@@ -1900,6 +2262,10 @@ async function tracktabupdate(tabid2, changeinfo) {
   const now = Date.now();
   const url = typeof changeinfo.url === "string" ? changeinfo.url : void 0;
   const status = changeinfo.status;
+  if (typeof changeinfo.title === "string" && changeinfo.title) {
+    lastknowntitles.set(tabid2, changeinfo.title);
+    await recordtabwatchevent("title", tabid2, changeinfo.title);
+  }
   const previous = lastknownurls.get(tabid2);
   if (status === "loading" && url) {
     navbuffers.set(tabid2, [{ event: "beforenavigate", url, timestamp: now }]);
@@ -1924,10 +2290,20 @@ async function tracktabupdate(tabid2, changeinfo) {
 chrome.tabs.onUpdated.addListener((tabid2, changeinfo) => {
   void tracktabupdate(tabid2, changeinfo);
 });
+chrome.tabs.onActivated.addListener((activeinfo) => {
+  void recordtabwatchevent("activated", activeinfo.tabId);
+});
 chrome.tabs.onRemoved.addListener((tabid2) => {
   const url = lastknownurls.get(tabid2);
-  if (url) void memory.addrecenttab({ url, tabid: tabid2, closedat: Date.now() });
+  const title = lastknowntitles.get(tabid2) ?? "";
+  const windowid = 0;
+  if (url) {
+    void memory.addrecenttab({ url, tabid: tabid2, closedat: Date.now() });
+    void memory.addclosedtab({ url, title, tabid: tabid2, windowid, closedat: Date.now() });
+  }
+  void recordtabwatchevent("closed", tabid2, url);
   lastknownurls.delete(tabid2);
+  lastknowntitles.delete(tabid2);
   navbuffers.delete(tabid2);
 });
 async function recordnavigation(step, session, tabid2) {
@@ -2351,9 +2727,382 @@ async function executenavigationkind(step, session, plan, tabid2, origin) {
     }
   }
 }
+async function livetabs() {
+  const tabs = await chrome.tabs.query({}).catch(() => []);
+  return tabs.map((tab) => ({
+    tabid: tab.id ?? 0,
+    url: tab.url ?? "",
+    title: tab.title ?? "",
+    index: tab.index,
+    windowid: tab.windowId ?? 0,
+    active: tab.active,
+    pinned: tab.pinned,
+    audible: tab.audible ?? false,
+    muted: tab.mutedInfo?.muted ?? false,
+    discarded: tab.discarded ?? false
+  }));
+}
+async function livewindows() {
+  const windows = await chrome.windows.getAll().catch(() => []);
+  return windows.map((item) => ({
+    windowid: item.id ?? 0,
+    left: item.left ?? 0,
+    top: item.top ?? 0,
+    width: item.width ?? 0,
+    height: item.height ?? 0,
+    state: item.state === "maximized" || item.state === "minimized" || item.state === "fullscreen" ? item.state : "normal",
+    incognito: item.incognito ?? false,
+    focused: item.focused
+  }));
+}
+var tabwatchbuffers = /* @__PURE__ */ new Map();
+var lastknowntitles = /* @__PURE__ */ new Map();
+async function recordtabwatchevent(event, tabid2, detail) {
+  const now = Date.now();
+  for (const watch of await memory.getwatches()) {
+    if (watch.closedat !== void 0 || watch.kind !== "watchtab") continue;
+    if (watchclosed(watch.startedat, watch.lifetime, now)) continue;
+    if (watch.events.length > 0 && !watch.events.includes(event)) continue;
+    const record2 = { watchid: watch.watchid, event, tabid: tabid2, ...detail !== void 0 ? { detail } : {}, at: now };
+    await memory.addtabwatchevent(record2);
+    tabwatchbuffers.set(watch.watchid, [...tabwatchbuffers.get(watch.watchid) ?? [], record2]);
+  }
+}
+async function buildtabreport(matches) {
+  const [groups, badges, metas] = await Promise.all([memory.gettabgroups(), memory.getbadges(), memory.gettabmetas()]);
+  const metabytab = new Map(metas.map((meta) => [meta.tabid, meta]));
+  const entries = matches.map((tab) => ({
+    tabid: tab.tabid,
+    url: tab.url,
+    title: tab.title,
+    index: tab.index,
+    windowid: tab.windowid,
+    active: tab.active,
+    pinned: tab.pinned,
+    audible: tab.audible,
+    muted: tab.muted,
+    discarded: tab.discarded,
+    ...metabytab.has(tab.tabid) ? { meta: metabytab.get(tab.tabid) } : {}
+  }));
+  return { matches: entries, groups: groups.map((group) => ({ name: group.name, color: group.color, tabids: group.tabids, collapsed: group.collapsed })), badges };
+}
+function commandtabids(step, options) {
+  const listed = Array.isArray(options.tabs) ? options.tabs.filter((item) => typeof item === "number" && Number.isInteger(item) && item >= 0) : [];
+  const single = step.value && /^\d+$/.test(step.value) ? [Number.parseInt(step.value, 10)] : [];
+  return listed.length > 0 ? listed : single;
+}
+async function executetabscommand(step, session, plan, sessiontabid) {
+  const options = stepoptions2(step);
+  const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
+  const windowid = step.value && /^\d+$/.test(step.value) ? Number.parseInt(step.value, 10) : 0;
+  const layoutgate = layoutmutationgranted(session, Date.now());
+  if (islayoutkind(step.kind) && !layoutgate.allowed) throw new Error(layoutgate.reason ?? "Group and layout mutations stay inside the active session.");
+  switch (step.kind) {
+    case "querytabs": {
+      const query = parsetabquery(step);
+      if (!query) throw new Error("A reviewed tabquery is required.");
+      const matches = querymatches(query, await livetabs());
+      const report = await buildtabreport(matches);
+      await audit("tab", `Queried the live tab set and matched ${matches.length} tab${matches.length === 1 ? "" : "s"}.`, extra);
+      return { ok: true, summary: `Matched ${matches.length} open tab${matches.length === 1 ? "" : "s"} by the reviewed tabquery.`, details: { report, matches: matches.length } };
+    }
+    case "duplicatetab": {
+      const source = Number.parseInt(step.value ?? "", 10);
+      const created = await chrome.tabs.duplicate(source);
+      await audit("tab", `Duplicated tab ${source} with its history into tab ${created?.id ?? 0}.`, extra);
+      return { ok: true, summary: `Duplicated tab ${source} with its history.`, details: { sourcetab: source, tabid: created?.id ?? 0 } };
+    }
+    case "closepattern": {
+      const query = parsetabquery(step);
+      if (!query) throw new Error("A reviewed tabquery is required.");
+      const tabs = await livetabs();
+      const selection = closeselection(query, tabs, session?.tabid ?? sessiontabid);
+      if (selection.refused.length > 0) throw new Error("The close pattern matches the session tab itself; review the pattern so the session tab survives.");
+      if (selection.targets.length === 0) return { ok: true, summary: "The reviewed close pattern matched no tab outside the session tab.", details: { closed: 0 } };
+      for (const target of selection.targets) await chrome.tabs.remove(target.tabid).catch(() => void 0);
+      await audit("tab", `Closed ${selection.targets.length} tab${selection.targets.length === 1 ? "" : "s"} matching the reviewed close pattern.`, extra);
+      return { ok: true, summary: `Closed ${selection.targets.length} tab${selection.targets.length === 1 ? "" : "s"} matching the reviewed pattern.`, details: { closed: selection.targets.length, urls: selection.targets.map((tab) => tab.url) } };
+    }
+    case "pintab": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      await chrome.tabs.update(target, { pinned: options.pinned === true });
+      await audit("tab", `${options.pinned === true ? "Pinned" : "Unpinned"} tab ${target} by the reviewed flag.`, extra);
+      return { ok: true, summary: `${options.pinned === true ? "Pinned" : "Unpinned"} tab ${target}.`, details: { tabid: target, pinned: options.pinned === true } };
+    }
+    case "mutetab": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      await chrome.tabs.update(target, { muted: options.muted === true });
+      await audit("tab", `${options.muted === true ? "Muted" : "Unmuted"} tab ${target} by the reviewed flag.`, extra);
+      return { ok: true, summary: `${options.muted === true ? "Muted" : "Unmuted"} tab ${target}.`, details: { tabid: target, muted: options.muted === true } };
+    }
+    case "movetab": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      await chrome.tabs.move(target, { index: options.index });
+      const groups = regroupaftermoves(await memory.gettabgroups(), await livetabs(), Date.now());
+      for (const group of groups) await memory.settabgroup(group);
+      await audit("tab", `Moved tab ${target} to index ${options.index} inside its window; group membership is kept.`, extra);
+      return { ok: true, summary: `Moved tab ${target} to index ${options.index}.`, details: { tabid: target, index: options.index } };
+    }
+    case "movetabwindow": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      await chrome.tabs.move(target, { windowId: options.windowid, index: -1 });
+      const groups = regroupaftermoves(await memory.gettabgroups(), await livetabs(), Date.now());
+      for (const group of groups) await memory.settabgroup(group);
+      await audit("tab", `Moved tab ${target} across windows into window ${options.windowid}; group membership is kept.`, extra);
+      return { ok: true, summary: `Moved tab ${target} into window ${options.windowid}.`, details: { tabid: target, windowid: options.windowid } };
+    }
+    case "grouptabs": {
+      const group = options.group;
+      const record2 = { groupid: randomid(), name: String(group.name ?? ""), color: String(group.color ?? "grey"), tabids: Array.isArray(group.tabids) ? group.tabids.filter((item) => typeof item === "number") : [], collapsed: false, savedat: Date.now() };
+      await memory.settabgroup(record2);
+      await audit("group", `Grouped ${record2.tabids.length} tab${record2.tabids.length === 1 ? "" : "s"} under the reviewed name ${record2.name} with color ${record2.color}; membership lives in the Devthink group registry.`, extra);
+      return { ok: true, summary: `Grouped ${record2.tabids.length} tab${record2.tabids.length === 1 ? "" : "s"} under ${record2.name}.`, details: { group: record2 } };
+    }
+    case "colorgroup": {
+      const groups = await memory.gettabgroups();
+      const target = groups.find((group) => group.name === options.name);
+      if (!target) throw new Error(`No tab group named ${options.name} is stored yet.`);
+      const updated = { ...target, color: String(options.color), savedat: Date.now() };
+      await memory.settabgroup(updated);
+      await audit("group", `Set the color of tab group ${updated.name} to ${updated.color}.`, extra);
+      return { ok: true, summary: `Set the color of group ${updated.name} to ${updated.color}.`, details: { group: updated } };
+    }
+    case "collapsegroup": {
+      const groups = await memory.gettabgroups();
+      const target = groups.find((group) => group.name === options.name);
+      if (!target) throw new Error(`No tab group named ${options.name} is stored yet.`);
+      const updated = { ...target, collapsed: options.collapsed === true, savedat: Date.now() };
+      await memory.settabgroup(updated);
+      await audit("group", `${updated.collapsed ? "Collapsed" : "Expanded"} tab group ${updated.name}.`, extra);
+      return { ok: true, summary: `${updated.collapsed ? "Collapsed" : "Expanded"} group ${updated.name}.`, details: { group: updated } };
+    }
+    case "discardtab": {
+      const ids = commandtabids(step, options);
+      if (ids.length === 0) throw new Error("A numeric tab id or a reviewed list of tab ids is required.");
+      const candidates = discardcandidates(await livetabs()).filter((tab) => ids.includes(tab.tabid));
+      const discarded = [];
+      const urls = [];
+      for (const candidate of candidates) {
+        const result = await chrome.tabs.discard(candidate.tabid).catch(() => void 0);
+        if (result) {
+          discarded.push(candidate.tabid);
+          urls.push({ tabid: candidate.tabid, url: candidate.url });
+        }
+      }
+      await audit("discard", `Discarded ${discarded.length} inactive tab${discarded.length === 1 ? "" : "s"} to save memory; the urls survive for on demand restore.`, extra);
+      return { ok: discarded.length > 0, summary: `Discarded ${discarded.length} inactive tab${discarded.length === 1 ? "" : "s"}; their urls stay available for restore.`, details: { discarded, urls, refused: ids.filter((id) => !discarded.includes(id)) } };
+    }
+    case "reloadtabs": {
+      const ids = commandtabids(step, options);
+      if (ids.length === 0) throw new Error("A numeric tab id or a reviewed list of tab ids is required.");
+      for (const id of ids) await chrome.tabs.reload(id).catch(() => void 0);
+      await audit("tab", `Reloaded ${ids.length} reviewed tab${ids.length === 1 ? "" : "s"}.`, extra);
+      return { ok: true, summary: `Reloaded ${ids.length} tab${ids.length === 1 ? "" : "s"}.`, details: { tabs: ids } };
+    }
+    case "zoomin":
+    case "zoomout": {
+      const target = step.value && /^\d+$/.test(step.value) ? Number.parseInt(step.value, 10) : sessiontabid;
+      const current = await chrome.tabs.getZoom(target);
+      const next = zoomstep(current, step.kind === "zoomin" ? "in" : "out", typeof options.step === "number" && options.step > 0 ? options.step : 0.1);
+      await chrome.tabs.setZoom(target, next);
+      await audit("tab", `Zoomed tab ${target} ${step.kind === "zoomin" ? "in" : "out"} from ${current} to ${next} by the reviewed step.`, extra);
+      return { ok: true, summary: `Zoomed tab ${target} ${step.kind === "zoomin" ? "in" : "out"} to ${next}.`, details: { tabid: target, from: current, to: next, step: typeof options.step === "number" ? options.step : 0.1 } };
+    }
+    case "switchtab": {
+      const direction = options.direction === "previous" ? "previous" : "next";
+      const focusedwindow = (await livewindows()).find((item) => item.focused)?.windowid ?? 0;
+      const windowtabs = (await livetabs()).filter((tab) => tab.windowid === focusedwindow);
+      const active = windowtabs.find((tab) => tab.active);
+      const target = switchtarget(windowtabs, direction, active?.index ?? 0);
+      const totab = windowtabs.find((tab) => tab.index === target);
+      if (!totab) throw new Error("No neighbor tab is available to switch to.");
+      await chrome.tabs.update(totab.tabid, { active: true });
+      await audit("tab", `Switched to the ${direction} tab ${totab.tabid}.`, extra);
+      return { ok: true, summary: `Switched to the ${direction} tab.`, details: { tabid: totab.tabid, direction } };
+    }
+    case "maximizewindow": {
+      await chrome.windows.update(windowid, { state: "maximized" });
+      await audit("window", `Maximized window ${windowid}.`, extra);
+      return { ok: true, summary: `Maximized window ${windowid}.`, details: { windowid, state: "maximized" } };
+    }
+    case "minimizewindow": {
+      await chrome.windows.update(windowid, { state: "minimized" });
+      await audit("window", `Minimized window ${windowid}.`, extra);
+      return { ok: true, summary: `Minimized window ${windowid}.`, details: { windowid, state: "minimized" } };
+    }
+    case "restorewindow": {
+      const bounds = options.bounds;
+      await chrome.windows.update(windowid, { state: "normal", ...bounds && typeof bounds.left === "number" ? { left: bounds.left } : {}, ...bounds && typeof bounds.top === "number" ? { top: bounds.top } : {}, ...bounds && typeof bounds.width === "number" ? { width: bounds.width } : {}, ...bounds && typeof bounds.height === "number" ? { height: bounds.height } : {} });
+      await audit("window", `Restored window ${windowid} to its reviewed bounds.`, extra);
+      return { ok: true, summary: `Restored window ${windowid} to its reviewed bounds.`, details: { windowid, bounds: bounds ?? null } };
+    }
+    case "focuswindow": {
+      await chrome.windows.update(windowid, { focused: true });
+      await audit("window", `Focused window ${windowid}.`, extra);
+      return { ok: true, summary: `Focused window ${windowid}.`, details: { windowid } };
+    }
+    case "scratchwindow": {
+      const url = typeof step.value === "string" && step.value ? step.value : "about:blank";
+      const created = await chrome.windows.create({ url });
+      const window2 = created?.id ?? 0;
+      await memory.setscratchwindows([...await memory.getscratchwindows(), window2]);
+      await audit("window", `Opened a scratch window ${window2} for split work.`, extra);
+      return { ok: true, summary: `Opened a scratch window for split work.`, details: { windowid: window2, url } };
+    }
+    case "incognitowindow": {
+      const created = await chrome.windows.create({ url: step.value ?? "", incognito: true });
+      await audit("window", `Opened an incognito window ${created?.id ?? 0} for ${step.value} on the explicit reviewed request; the window stays separated from the session grant inheritance.`, extra);
+      return { ok: true, summary: `Opened an incognito window for ${step.value} on explicit request.`, details: { windowid: created?.id ?? 0, url: step.value, grantsinherited: windowprofilegrants("incognito") } };
+    }
+    case "restoretab": {
+      const open = (await livetabs()).map((tab) => tab.url).filter(Boolean);
+      let url = step.value && /^https:\/\//.test(step.value) ? step.value : void 0;
+      if (!url) {
+        const closed = (await memory.getclosedtabs()).find((entry) => !open.includes(entry.url));
+        if (!closed) throw new Error("No closed tab is available to restore from the session history.");
+        url = closed.url;
+      }
+      const created = await chrome.tabs.create({ url, active: true });
+      await audit("tab", `Restored the closed tab ${url} from the session history.`, extra);
+      return { ok: true, summary: `Restored ${url} from the closed tab history.`, details: { url, tabid: created?.id ?? 0 } };
+    }
+    case "savelayout": {
+      const name = typeof options.name === "string" ? options.name : "";
+      const [tabs, windows, groups, scratch] = await Promise.all([livetabs(), livewindows(), memory.gettabgroups(), memory.getscratchwindows()]);
+      const layout = buildlayout(name, tabs, windows, groups, scratch, Date.now());
+      await memory.setlayout(layout);
+      await audit("layout", `Saved the tab layout ${name} with ${layout.tabs.length} tab${layout.tabs.length === 1 ? "" : "s"}, ${layout.groups.length} group${layout.groups.length === 1 ? "" : "s"} and ${layout.windows.length} window bound${layout.windows.length === 1 ? "" : "s"}.`, extra);
+      return { ok: true, summary: `Saved the tab layout ${name}.`, details: { layout } };
+    }
+    case "restorelayout": {
+      const name = typeof options.name === "string" ? options.name : "";
+      const layout = await memory.getlayout(name);
+      if (!layout) throw new Error(`No tab layout named ${name} is stored yet.`);
+      const open = (await livetabs()).map((tab) => tab.url).filter(Boolean);
+      const urls = layoutrestoreplan(layout, open);
+      const created = [];
+      for (const url of urls) {
+        const tab = await chrome.tabs.create({ url, active: created.length === 0 });
+        created.push(tab?.id ?? 0);
+      }
+      await audit("layout", `Restored the tab layout ${name}: ${created.length} tab${created.length === 1 ? "" : "s"} reopened, ${layout.tabs.length - created.length} already open.`, extra);
+      return { ok: true, summary: `Restored the tab layout ${name}.`, details: { name, reopened: created.length, alreadyopen: layout.tabs.length - created.length, tabs: created } };
+    }
+    case "findclones": {
+      const clones = clonetabs(await livetabs());
+      await audit("tab", `Detected ${clones.length} duplicate url group${clones.length === 1 ? "" : "s"} across the open tabs.`, extra);
+      return { ok: true, summary: clones.length === 0 ? "No duplicate tab was detected by normalized url comparison." : `Detected ${clones.length} duplicate url group${clones.length === 1 ? "" : "s"}.`, details: { clones } };
+    }
+    case "searchtabs": {
+      const matches = searchtabmatches(await livetabs(), step.value ?? "");
+      await audit("tab", `Searched the open tabs and matched ${matches.length} tab${matches.length === 1 ? "" : "s"} for "${step.value}".`, extra);
+      return { ok: true, summary: `Matched ${matches.length} open tab${matches.length === 1 ? "" : "s"} for "${step.value}".`, details: { matches } };
+    }
+    case "badgetab": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      const badge = { tabid: target, taskid: typeof options.taskid === "string" && options.taskid ? options.taskid : plan.id, label: typeof options.label === "string" ? options.label : "", setat: Date.now() };
+      await memory.setbadge(badge);
+      await refreshbadge();
+      await audit("badge", `Set the task badge of tab ${target} to ${badge.label} for task ${badge.taskid}.`, extra);
+      return { ok: true, summary: `Set the badge of tab ${target} to ${badge.label}.`, details: { badge } };
+    }
+    case "attachmeta": {
+      const target = Number.parseInt(step.value ?? "", 10);
+      const meta = {
+        tabid: target,
+        taskrefs: Array.isArray(options.taskrefs) ? options.taskrefs.filter((item) => typeof item === "string" && item.trim().length > 0) : [],
+        provenance: typeof options.provenance === "string" && options.provenance ? options.provenance : "plan step",
+        labels: Array.isArray(options.labels) ? options.labels.filter((item) => typeof item === "string" && item.trim().length > 0) : [],
+        at: Date.now()
+      };
+      await memory.settabmeta(meta);
+      await memory.setprogress(assigntasktab(await memory.getprogress(), plan.id, target, Date.now()));
+      await audit("tab", `Attached metadata to tab ${target} with ${meta.labels.length} label${meta.labels.length === 1 ? "" : "s"} and ${meta.taskrefs.length} task ref${meta.taskrefs.length === 1 ? "" : "s"}; the tab joins the task progress.`, extra);
+      return { ok: true, summary: `Attached metadata to tab ${target} for task routing.`, details: { meta } };
+    }
+    case "listaudio": {
+      const playing = audiotabs(await livetabs());
+      await audit("tab", `Listed ${playing.length} tab${playing.length === 1 ? "" : "s"} that are playing audio.`, extra);
+      return { ok: true, summary: `${playing.length} tab${playing.length === 1 ? " is" : "s are"} playing audio.`, details: { audio: playing } };
+    }
+    case "reopenrun": {
+      const run = typeof options.run === "string" ? options.run : "";
+      const snapshots = await memory.getsnapshots();
+      const snapshot2 = snapshots.find((item) => item.sessionid === run) ?? snapshots.find((item) => item.id === run);
+      if (!snapshot2) throw new Error(`No stored session snapshot exists for the run ${run}.`);
+      const open = (await livetabs()).map((tab) => tab.url).filter(Boolean);
+      const urls = layoutrestoreplan(snapshot2.layout, open);
+      const created = [];
+      for (const url of urls) {
+        const tab = await chrome.tabs.create({ url, active: created.length === 0 });
+        created.push(tab?.id ?? 0);
+      }
+      await audit("layout", `Reopened ${created.length} tab${created.length === 1 ? "" : "s"} of the previous run ${run}.`, extra);
+      return { ok: true, summary: `Reopened ${created.length} tab${created.length === 1 ? "" : "s"} of the previous run.`, details: { run, reopened: created.length, tabs: created } };
+    }
+    case "snapshotsession": {
+      const [tabs, windows, groups, scratch] = await Promise.all([livetabs(), livewindows(), memory.gettabgroups(), memory.getscratchwindows()]);
+      const layout = buildlayout(`session ${(/* @__PURE__ */ new Date()).toISOString()}`, tabs, windows, groups, scratch, Date.now());
+      const snapshot2 = { id: randomid(), ...session ? { sessionid: session.id } : {}, layout, capturedat: Date.now() };
+      await memory.addsnapshot(snapshot2);
+      await audit("layout", `Captured the full session snapshot with ${layout.tabs.length} tab${layout.tabs.length === 1 ? "" : "s"} and ${layout.windows.length} window${layout.windows.length === 1 ? "" : "s"}.`, extra);
+      return { ok: true, summary: `Captured the session snapshot of ${layout.tabs.length} tabs and ${layout.windows.length} windows.`, details: { snapshot: snapshot2 } };
+    }
+    case "watchtab": {
+      const lifetime = typeof options.lifetime === "number" && Number.isFinite(options.lifetime) && options.lifetime > 0 ? options.lifetime : 0;
+      if (lifetime <= 0) throw new Error("A reviewed watch lifetime window in milliseconds is required in options.");
+      const events = Array.isArray(options.events) ? options.events.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
+      const watchid = typeof options.watchid === "string" && options.watchid.trim() ? options.watchid : randomid();
+      const watch = { watchid, kind: "watchtab", stepid: step.id, sessionid: session?.id ?? plan.id, origin: session?.origin ?? plan.origin, scopes: [], events, startedat: Date.now(), lifetime };
+      await memory.addwatch(watch);
+      await audit("watch", `Watchtab registered under id ${watchid} for the reviewed lifetime of ${lifetime} milliseconds${events.length > 0 ? ` over events ${events.join(", ")}` : " over title, activation and closure events"}.`, extra);
+      await new Promise((resolve) => setTimeout(resolve, lifetime));
+      const observed = watchtabdispatch(tabwatchbuffers.get(watchid) ?? [], watchid, events);
+      await memory.closewatch(watchid, Date.now());
+      tabwatchbuffers.delete(watchid);
+      await audit("watch", `Watchtab ${watchid} closed after its reviewed lifetime of ${lifetime} milliseconds with ${observed.length} observed event${observed.length === 1 ? "" : "s"}.`, extra);
+      return { ok: true, summary: `Observed ${observed.length} tab event${observed.length === 1 ? "" : "s"} inside the reviewed lifetime.`, details: { watchid, events: observed } };
+    }
+    default:
+      return { ok: false, summary: "Unsupported tabs and windows command." };
+  }
+}
+async function enforcewindowreview(step, session, plan) {
+  const windowid = step.value && /^\d+$/.test(step.value) ? Number.parseInt(step.value, 10) : 0;
+  const progress = plan ? await memory.getprogress() : void 0;
+  const tasktabids = plan ? trackedtasktabs(progress, plan.id) : [];
+  const count = tasktabsinwindow(await livetabs(), windowid, tasktabids);
+  const gate = windowclosegate(count, stepoptions2(step).reviewed === true);
+  if (!gate.allowed) throw new Error(gate.reason ?? "The window close needs explicit review.");
+  if (session && count > 0) await audit("window", `Window ${windowid} closes while holding ${count} task tab${count === 1 ? "" : "s"} under the explicit reviewed flag.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+}
+async function updatetaskbadges(plan, progress) {
+  if (!plan || !progress || progress.planid !== plan.id) return;
+  const state = badgefromprogress(progress.completedsteps.length, plan.steps.length);
+  for (const tabid2 of tasktabs(progress, plan.id)) {
+    await memory.setbadge({ tabid: tabid2, taskid: plan.id, label: state.label, setat: Date.now() });
+  }
+}
+async function togglecontroltab(enabled) {
+  const current = await memory.getcontroltab();
+  if (current && current.tabid) await chrome.tabs.remove(current.tabid).catch(() => void 0);
+  if (!enabled) {
+    const closed = { tabid: 0, enabled: false, updatedat: Date.now() };
+    await memory.setcontroltab(closed);
+    await audit("tab", "The pinned control tab was closed.");
+    return closed;
+  }
+  const created = await chrome.tabs.create({ url: chrome.runtime.getURL("sidepanel.html"), pinned: true, active: false });
+  const state = { tabid: created?.id ?? 0, enabled: true, updatedat: Date.now() };
+  await memory.setcontroltab(state);
+  await audit("tab", `The pinned control tab ${state.tabid} was opened with the live task feed.`);
+  return state;
+}
 async function refreshbadge() {
   const queues = await memory.getnavqueues();
-  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0);
+  const badges = await memory.getbadges();
+  const tasktabs2 = new Set(badges.map((badge) => badge.tabid)).size;
+  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2;
   await chrome.action.setBadgeText({ text: total > 0 ? String(total) : "" }).catch(() => {
   });
 }
@@ -2372,7 +3121,12 @@ async function executestep(stepid) {
   }
   let output;
   let watchwindow;
-  if (isbrowserkind(step.kind)) {
+  if (step.kind === "windowclose") {
+    await enforcewindowreview(step, session, plan);
+  }
+  if (istabscommandkind(step.kind)) {
+    output = await executetabscommand(step, session, plan, tab.id);
+  } else if (isbrowserkind(step.kind)) {
     output = await runbrowseraction(step, tab.id, tab.windowId ?? chrome.windows.WINDOW_ID_CURRENT);
   } else if (step.kind === "keyhold") {
     output = await executekeyhold(step, session, plan, tab.id, origin);
@@ -2404,6 +3158,9 @@ async function executestep(stepid) {
   }
   if (["navigate", "back", "forward"].includes(step.kind)) await recordnavigation(step, session, tab.id);
   await recordevidence(step, output, session, plan, origin);
+  if (output?.ok && plan && typeof output.details?.tabid === "number") {
+    await memory.setprogress(assigntasktab(await memory.getprogress(), plan.id, output.details.tabid, Date.now()));
+  }
   const summary = output?.summary ?? "The page action returned no result.";
   const resolved = output?.details?.resolvedtarget;
   if (resolved) {
@@ -2418,6 +3175,8 @@ async function executestep(stepid) {
     const completed = watchwindow ? recordwatchcompletion(base, plan.id, stepid, watchwindow.startedat, watchwindow.lifetime, Date.now()) : recordstep(base, plan.id, stepid, Date.now());
     const tracked = recordoutcome(completed, plan.id, outcome, Date.now());
     await memory.setprogress(tracked);
+    await updatetaskbadges(plan, tracked);
+    await refreshbadge();
     if (iscomplete(tracked, plan) && plan.state === "approved") {
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
@@ -2506,10 +3265,23 @@ async function handlerequest(message, sender) {
       const navcontrol = await memory.getnavcontrol();
       const navqueues = await memory.getnavqueues();
       const artifacts = await memory.getartifacts();
+      const tabs = await livetabs().catch(() => []);
+      const windows = await livewindows().catch(() => []);
+      const layouts = await memory.getlayouts();
+      const tabgroups = await memory.gettabgroups();
+      const tabmetas = await memory.gettabmetas();
+      const badges = await memory.getbadges();
+      const snapshots = await memory.getsnapshots();
+      const closedtabs = await memory.getclosedtabs();
+      const controltab = await memory.getcontroltab();
+      const tabwatchevents = await memory.gettabwatchevents();
+      const clones = clonetabs(tabs);
+      const taskgauge = tasktabgauge(tabs.filter((tab) => badges.some((badge) => badge.tabid === tab.tabid)).length, tasktabceiling(await memory.getsettings()));
+      const report = await buildtabreport(tabs);
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -2607,6 +3379,104 @@ async function handlerequest(message, sender) {
       if (!plan) throw new Error("No plan is available for a safety envelope.");
       return JSON.parse(safetyresponse({ verdicts: await memory.getsafeties(), plan }));
     }
+    case "jumptotab": {
+      const inputtab = message;
+      if (typeof inputtab.tabid !== "number") throw new Error("A numeric tab id is required to jump.");
+      await chrome.tabs.update(inputtab.tabid, { active: true }).catch(() => {
+        throw new Error("The tab to jump to is no longer open.");
+      });
+      await audit("tab", `The review panel jumped to tab ${inputtab.tabid}.`);
+      return { tabid: inputtab.tabid };
+    }
+    case "tabsearch": {
+      const inputsearch = message;
+      const granted = await chrome.permissions.contains({ permissions: ["tabs"] });
+      if (!granted) throw new Error("The tabs capability has not been granted; request it from the review panel.");
+      const matches = searchtabmatches(await livetabs(), inputsearch.text ?? "");
+      await audit("tab", `The review panel searched the open tabs for "${inputsearch.text ?? ""}" and matched ${matches.length} tab${matches.length === 1 ? "" : "s"}.`);
+      return { matches };
+    }
+    case "savelayout": {
+      const session = await memory.getsession();
+      const gate = layoutmutationgranted(session, Date.now());
+      if (!gate.allowed) throw new Error(gate.reason);
+      const inputlayout = message;
+      if (!inputlayout.name?.trim()) throw new Error("A layout name is required.");
+      const [tabs, windows, groups, scratch] = await Promise.all([livetabs(), livewindows(), memory.gettabgroups(), memory.getscratchwindows()]);
+      const layout = buildlayout(inputlayout.name.trim(), tabs, windows, groups, scratch, Date.now());
+      await memory.setlayout(layout);
+      await audit("layout", `The review panel saved the tab layout ${layout.name} with ${layout.tabs.length} tabs and ${layout.windows.length} window bounds.`, { ...session ? { sessionid: session.id } : {} });
+      return layout;
+    }
+    case "restorelayout": {
+      const session = await memory.getsession();
+      const gate = layoutmutationgranted(session, Date.now());
+      if (!gate.allowed) throw new Error(gate.reason);
+      const inputlayout = message;
+      const layout = await memory.getlayout(inputlayout.name ?? "");
+      if (!layout) throw new Error(`No tab layout named ${inputlayout.name ?? ""} is stored yet.`);
+      const open = (await livetabs()).map((tab) => tab.url).filter(Boolean);
+      const urls = layoutrestoreplan(layout, open);
+      const opened = [];
+      for (const url of urls) {
+        const created = await chrome.tabs.create({ url, active: opened.length === 0 });
+        opened.push(created?.id ?? 0);
+      }
+      await audit("layout", `The review panel restored the tab layout ${layout.name}: ${opened.length} tab${opened.length === 1 ? "" : "s"} reopened.`, { ...session ? { sessionid: session.id } : {} });
+      return { name: layout.name, reopened: opened.length };
+    }
+    case "restoresnapshot": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Snapshot restore stays behind the consent gate of an active session.");
+      const inputsnapshot = message;
+      const snapshot2 = (await memory.getsnapshots()).find((item) => item.id === inputsnapshot.id);
+      if (!snapshot2) throw new Error("No stored session snapshot matches the requested id.");
+      const open = (await livetabs()).map((tab) => tab.url).filter(Boolean);
+      const urls = layoutrestoreplan(snapshot2.layout, open);
+      const opened = [];
+      for (const url of urls) {
+        const created = await chrome.tabs.create({ url, active: opened.length === 0 });
+        opened.push(created?.id ?? 0);
+      }
+      await audit("layout", `The review panel restored the session snapshot ${snapshot2.id}: ${opened.length} tab${opened.length === 1 ? "" : "s"} reopened.`, { sessionid: session.id });
+      return { id: snapshot2.id, reopened: opened.length };
+    }
+    case "controltab": {
+      const inputcontrol = message;
+      const state = await togglecontroltab(inputcontrol.enabled === true);
+      const settings = await memory.getsettings();
+      await memory.setsettings({ ...settings, controltab: state.enabled });
+      return state;
+    }
+    case "settasktabceiling": {
+      const inputceiling = message;
+      const settings = await memory.getsettings();
+      const ceiling = typeof inputceiling.ceiling === "number" && Number.isFinite(inputceiling.ceiling) && inputceiling.ceiling >= 0 ? inputceiling.ceiling : void 0;
+      await memory.setsettings({ ...settings, ...ceiling !== void 0 ? { tasktabceiling: ceiling } : {} });
+      await audit("configure", `The user set the concurrent task tab ceiling to ${ceiling === void 0 ? "no ceiling" : ceiling}; the value stays a user choice with no code cap.`);
+      return { tasktabceiling: ceiling };
+    }
+    case "windowstate": {
+      const inputwindow = message;
+      if (typeof inputwindow.windowid !== "number" || !inputwindow.state || !["normal", "maximized", "minimized", "fullscreen"].includes(inputwindow.state)) throw new Error("A numeric window id and a known window state are required.");
+      await chrome.windows.update(inputwindow.windowid, { state: inputwindow.state });
+      await audit("window", `The popup set window ${inputwindow.windowid} to the ${inputwindow.state} state.`);
+      return { windowid: inputwindow.windowid, state: inputwindow.state };
+    }
+    case "closewindow": {
+      const inputclose = message;
+      if (typeof inputclose.windowid !== "number") throw new Error("A numeric window id is required.");
+      const session = await memory.getsession();
+      const plan = await memory.getplan();
+      const progress = plan ? await memory.getprogress() : void 0;
+      const tasktabids = plan && progress ? trackedtasktabs(progress, plan.id) : [];
+      const count = tasktabsinwindow(await livetabs(), inputclose.windowid, tasktabids);
+      const gate = windowclosegate(count, inputclose.reviewed === true);
+      if (!gate.allowed) throw new Error(gate.reason);
+      await chrome.windows.remove(inputclose.windowid);
+      await audit("window", `The review panel closed window ${inputclose.windowid}${count > 0 ? ` while holding ${count} task tab${count === 1 ? "" : "s"} under explicit review` : ""}.`, { ...session ? { sessionid: session.id } : {} });
+      return { windowid: inputclose.windowid, closed: true };
+    }
     case "stop": {
       const session = await memory.getsession();
       if (session) await memory.setsession({ ...session, stoppedat: Date.now() });