@wenathlan/extension 1.1.35 → 1.1.37

package/extension/dist/background.js

@@ -352,19 +352,192 @@ 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);
+  }
+  /** Stores one saved form profile under its reviewed name, replacing the previous profile of that name. */
+  async setprofile(profile) {
+    const records = (await this.getprofiles()).filter((item) => item.name !== profile.name);
+    await this.adapter.set("formprofiles", [profile, ...records]);
+  }
+  /** Returns one saved form profile by its reviewed name. */
+  async getprofile(name) {
+    return (await this.getprofiles()).find((item) => item.name === name);
+  }
+  /** Returns every saved form profile with its origin grants, newest first. */
+  async getprofiles() {
+    return await this.adapter.get("formprofiles") ?? [];
+  }
+  /** Removes one saved form profile by its reviewed name. */
+  async removeprofile(name) {
+    const records = (await this.getprofiles()).filter((item) => item.name !== name);
+    await this.adapter.set("formprofiles", records);
+  }
+  /** Records one wizard state with its step history. */
+  async addwizard(state) {
+    const records = await this.getwizards();
+    await this.adapter.set("wizards", [state, ...records]);
+  }
+  /** Returns every stored wizard state with its step history, newest first. */
+  async getwizards() {
+    return await this.adapter.get("wizards") ?? [];
+  }
+  /** Stores one submission ticket with its values hash, replacing the previous ticket of that id. */
+  async setticket(ticket) {
+    const records = (await this.gettickets()).filter((item) => item.id !== ticket.id);
+    await this.adapter.set("submittickets", [ticket, ...records]);
+  }
+  /** Returns every stored submission ticket with its values hash, newest first. */
+  async gettickets() {
+    return await this.adapter.get("submittickets") ?? [];
+  }
+  /** Records one collected error report for correction loops. */
+  async adderrorreport(report) {
+    const records = await this.geterrorreports();
+    await this.adapter.set("errorreports", [report, ...records]);
+  }
+  /** Returns every stored error report, newest first. */
+  async geterrorreports() {
+    return await this.adapter.get("errorreports") ?? [];
+  }
+  /** Records one typeahead pick observed when a reviewed suggestion entry was chosen. */
+  async addpick(pick) {
+    const records = await this.getpicks();
+    await this.adapter.set("typeaheadpicks", [pick, ...records]);
+  }
+  /** Returns every recorded typeahead pick, newest first. */
+  async getpicks() {
+    return await this.adapter.get("typeaheadpicks") ?? [];
+  }
+  /** Records one captcha handoff while the plan waits for the user. */
+  async addcaptcha(handoff) {
+    const records = await this.getcaptchas();
+    await this.adapter.set("captchas", [handoff, ...records]);
+  }
+  /** Returns every captcha handoff record with its resolution state, newest first. */
+  async getcaptchas() {
+    return await this.adapter.get("captchas") ?? [];
+  }
+  /** Resolves one captcha handoff by id once the user finished it. */
+  async resolvecaptcha(id, resolvedat) {
+    const records = await this.getcaptchas();
+    await this.adapter.set("captchas", records.map((handoff) => handoff.id === id && !handoff.resolved ? { ...handoff, resolved: true, resolvedat } : handoff));
+  }
+  /** Records one login or template detection for its origin. */
+  async adddetection(record2) {
+    const records = await this.getdetections();
+    await this.adapter.set("detections", [record2, ...records]);
+  }
+  /** Returns every stored login and template detection per origin, newest first. */
+  async getdetections() {
+    return await this.adapter.get("detections") ?? [];
+  }
+  /** Stores the reviewed one time code behind the consent gate of an active session. */
+  async setcodevalue(value) {
+    return this.adapter.set("codevalue", value);
+  }
+  /** Returns the reviewed one time code, if the user stored one behind the consent gate. */
+  async getcodevalue() {
+    return this.adapter.get("codevalue");
+  }
 };
 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", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword"]);
 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", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
-var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus"]);
-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 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", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword"]);
+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", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword"]);
+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 formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
+var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
+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 +570,168 @@ 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 isformkind(kind) {
+  return formactions.has(kind);
+}
+function validatefieldmatch(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed field match is required in options." };
+  const match = value;
+  if (match.mode !== "label" && match.mode !== "placeholder" && match.mode !== "arialabel" && match.mode !== "name") return { allowed: false, reason: "The reviewed field match mode must be label, placeholder, arialabel or name." };
+  const key = match.mode === "label" ? "label" : match.mode === "placeholder" ? "placeholder" : match.mode === "arialabel" ? "arialabel" : "name";
+  if (!isnonempty(match[key])) return { allowed: false, reason: `The reviewed ${match.mode} field match needs a non-empty ${key}.` };
+  return { allowed: true };
+}
+function validateformrecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed form record with entries is required in options." };
+  const record2 = value;
+  if (record2.form !== void 0 && !isnonempty(record2.form)) return { allowed: false, reason: "The reviewed form record form selector must be a non-empty string." };
+  if (!Array.isArray(record2.entries) || record2.entries.length === 0) return { allowed: false, reason: "The reviewed form record needs a non-empty list of entries." };
+  for (const item of record2.entries) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return { allowed: false, reason: "Every reviewed form record entry must be an object." };
+    const entry = item;
+    const matchcheck = validatefieldmatch(entry.match);
+    if (!matchcheck.allowed) return matchcheck;
+    if (typeof entry.kind !== "string" || !fieldkinds.includes(entry.kind)) return { allowed: false, reason: "Every reviewed form record entry needs a known field kind." };
+    if (typeof entry.value !== "string") return { allowed: false, reason: "Every reviewed form record entry needs a string value." };
+    if (entry.kind === "password") return { allowed: false, reason: "Password entries are refused inside form records; use consentpassword with a reviewed consent ref." };
+  }
+  return { allowed: true };
+}
+function validatevaluegen(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed valuegen rule with a field kind is required in options." };
+  const rule = value;
+  if (typeof rule.kind !== "string" || !fieldkinds.includes(rule.kind)) return { allowed: false, reason: "The reviewed valuegen kind must be a known field kind." };
+  if (rule.locale !== void 0 && !isnonempty(rule.locale)) return { allowed: false, reason: "The reviewed valuegen locale must be a non-empty string." };
+  if (rule.seed !== void 0 && (typeof rule.seed !== "number" || !Number.isFinite(rule.seed))) return { allowed: false, reason: "The reviewed valuegen seed must be a finite number." };
+  return { allowed: true };
+}
+function validatefieldpairs(options, mode) {
+  const pairs = options.fields;
+  if (!Array.isArray(pairs) || pairs.length === 0) return { allowed: false, reason: "A reviewed non-empty list of field pairs is required in options." };
+  for (const item of pairs) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return { allowed: false, reason: "Every reviewed field pair must be an object." };
+    const pair = item;
+    if (!isnonempty(pair[mode])) return { allowed: false, reason: `Every reviewed field pair needs a non-empty ${mode}.` };
+    if (typeof pair.value !== "string" || !pair.value.trim()) return { allowed: false, reason: "Every reviewed field pair needs a non-empty value." };
+  }
+  return { allowed: true };
+}
+function validatecardsegments(value) {
+  if (!Array.isArray(value) || value.length === 0) return { allowed: false, reason: "A reviewed non-empty list of card segments is required in options." };
+  for (const item of value) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return { allowed: false, reason: "Every reviewed card segment must be an object." };
+    const segment = item;
+    const matchcheck = validatefieldmatch(segment.match);
+    if (!matchcheck.allowed) return matchcheck;
+    if (typeof segment.value !== "string" || !segment.value.trim()) return { allowed: false, reason: "Every reviewed card segment needs a non-empty value." };
+  }
+  return { allowed: true };
+}
+function validateformgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "fillform" || kind === "saveprofiles" && options.formrecord !== void 0) {
+    const recordcheck = validateformrecord(options.formrecord);
+    if (!recordcheck.allowed) return recordcheck;
+  }
+  if (kind === "filllabel" || kind === "fillplaceholder") {
+    const paircheck = validatefieldpairs(options, kind === "filllabel" ? "label" : "placeholder");
+    if (!paircheck.allowed) return paircheck;
+  }
+  if (kind === "generatevalues" && options.valuegen !== void 0) {
+    const rulecheck = validatevaluegen(options.valuegen);
+    if (!rulecheck.allowed) return rulecheck;
+  }
+  if (kind === "saveprofiles" && !isnonempty(options.name)) return { allowed: false, reason: "A reviewed profile name is required in options." };
+  if (kind === "submitform" && !isnonempty(options.consentref)) return { allowed: false, reason: "A reviewed consent ref of an approved asksubmit ticket is required in options." };
+  if (kind === "retryform") {
+    const backoff = options.backoff;
+    if (!backoff || typeof backoff !== "object" || Array.isArray(backoff)) return { allowed: false, reason: "A reviewed backoff rule with wait and factor is required in options." };
+    const rule = backoff;
+    if (typeof rule.wait !== "number" || !Number.isFinite(rule.wait) || rule.wait <= 0) return { allowed: false, reason: "The reviewed retry backoff wait must be a positive number of milliseconds with no code ceiling." };
+    if (typeof rule.factor !== "number" || !Number.isFinite(rule.factor) || rule.factor < 1) return { allowed: false, reason: "The reviewed retry backoff factor must be one or greater with no code ceiling." };
+    if (options.attempts !== void 0 && (typeof options.attempts !== "number" || !Number.isInteger(options.attempts) || options.attempts < 1)) return { allowed: false, reason: "The reviewed retry attempts must be a positive integer with no code ceiling." };
+  }
+  if (kind === "runwizard" && options.steps !== void 0 && (typeof options.steps !== "number" || !Number.isInteger(options.steps) || options.steps < 1)) return { allowed: false, reason: "The reviewed wizard step count must be a positive integer with no code ceiling." };
+  if (kind === "selectchain") {
+    if (!isnonempty(options.child)) return { allowed: false, reason: "A reviewed child selector of the dependent control is required in options." };
+    if (!nonnegativeoption(options, "wait")) return { allowed: false, reason: "The reviewed dependent wait must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "picktypeahead") {
+    if (!isnonempty(options.pick)) return { allowed: false, reason: "A reviewed suggestion entry to pick is required in options." };
+    if (!nonnegativeoption(options, "timeout")) return { allowed: false, reason: "The reviewed typeahead timeout must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "pickdate" && !/^\d{4}-\d{2}-\d{2}$/.test(step.value ?? "")) return { allowed: false, reason: "The reviewed date must use the yyyy-mm-dd form." };
+  if (kind === "fillcard") {
+    const segmentcheck = validatecardsegments(options.segments);
+    if (!segmentcheck.allowed) return segmentcheck;
+    if (!nonnegativeoption(options, "pause")) return { allowed: false, reason: "The reviewed card typing pause must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "fillcode" && !isnonempty(options.source)) return { allowed: false, reason: "A reviewed one time code source is required in options." };
+  if (kind === "consentpassword" && !isnonempty(options.consentref)) return { allowed: false, reason: "A reviewed consent ref is required in options before any password is filled." };
+  return { allowed: true };
+}
+function submitreviewgranted(steps, submitid) {
+  const position = steps.findIndex((candidate) => candidate.id === submitid);
+  const asked = steps.some((candidate, index) => candidate.kind === "asksubmit" && (position === -1 || index < position));
+  return asked ? { allowed: true } : { allowed: false, reason: "Form submission requires an asksubmit review step before it." };
+}
+function passwordconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "A password fill requires a reviewed consent ref in options." };
+  return { allowed: true };
+}
+function luhnvalid(digits) {
+  let sum = 0;
+  let double = false;
+  for (let index = digits.length - 1; index >= 0; index -= 1) {
+    let value = Number.parseInt(digits[index] ?? "", 10);
+    if (!Number.isFinite(value)) return false;
+    if (double) {
+      value *= 2;
+      if (value > 9) value -= 9;
+    }
+    sum += value;
+    double = !double;
+  }
+  return sum % 10 === 0;
+}
+function generatedvalueallowed(value) {
+  const compact = value.replace(/[\s-]/g, "");
+  if (/^\d{13,19}$/.test(compact) && luhnvalid(compact) && !compact.startsWith("4111")) return { allowed: false, reason: "The generated value looks like a real card number and is refused; generated card values use the 4111 test prefix." };
+  if (/^\d{3}-\d{2}-\d{4}$/.test(value.trim())) return { allowed: false, reason: "The generated value looks like a personal identifier and is refused." };
+  return { allowed: true };
+}
+function profilegrantgranted(profile, origin) {
+  if (!profile.grants.includes(origin)) return { allowed: false, reason: `The saved profile ${profile.name} is not granted to ${origin}; add the origin to the profile grants first.` };
+  return { allowed: true };
+}
+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 +894,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 +1193,24 @@ 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 (isformkind(step.kind)) {
+    const formcheck = validateformgrammar(step, options);
+    if (!formcheck.allowed) return formcheck;
+  }
+  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 +1241,16 @@ 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 === "submitform" || input.step.kind === "retryform") {
+    if (!input.plan) return { allowed: false, reason: "Form submission requires an asksubmit review step before it." };
+    const reviewgate = submitreviewgranted(input.plan.steps, input.step.id);
+    if (!reviewgate.allowed) return reviewgate;
+  }
+  if (input.step.kind === "consentpassword") {
+    const consentgate = passwordconsentgranted(input.step);
+    if (!consentgate.allowed) return consentgate;
+  }
   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 +1323,29 @@ 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 ?? [];
+}
+function wizardcompletion(state) {
+  if (state.steps <= 0) return 0;
+  return Math.min(1, state.completed.filter(Boolean).length / state.steps);
+}
+function recordwizardstep(progress, planid, stepid, state, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const executed = Math.min(state.index, state.steps);
+  const done = executed >= state.steps;
+  const outcome = { stepid, ok: done, summary: `Wizard step ${executed} of ${state.steps} ${done ? "completed the wizard" : "executed"}.`, details: { wizard: { index: state.index, steps: state.steps, completed: [...state.completed] } }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
 
 // version.ts
-var packageversion = "1.1.35";
+var packageversion = "1.1.37";
 
 // types.ts
 var protocolversion = packageversion;
@@ -907,6 +1386,11 @@ function parseproposal(value, origin) {
     const options = parseoptions(step);
     if (typeof options.stepid === "string" && !steps.some((candidate) => candidate.id === options.stepid)) throw new Error("A retry or frame wrapper references an unknown step id.");
   }
+  for (const step of steps) {
+    if (step.kind !== "submitform" && step.kind !== "retryform") continue;
+    const review = submitreviewgranted(steps, step.id);
+    if (!review.allowed) throw new Error(review.reason);
+  }
   const createdat = Date.now();
   const expiresat = typeof planinput.expiresat === "number" ? planinput.expiresat : createdat + 10 * 60 * 1e3;
   const plan = {
@@ -955,6 +1439,18 @@ 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 };
+}
+function formreportresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, report: input.report });
+}
+function errorreportresponse(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, report: input.report });
+}
+function wizardreport(input) {
+  return { version: protocolversion, ...input.sessionid ? { sessionid: input.sessionid } : {}, wizards: input.wizards, picks: input.picks };
+}
 
 // extension/browsertabs.ts
 var browserkinds = /* @__PURE__ */ new Set(["tablist", "tabcreate", "tabactivate", "tabclose", "tabreload", "tabsnapshot", "windowlist", "windowcreate", "windowclose", "zoomset", "windowresize", "downloadfile"]);
@@ -990,8 +1486,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 +1511,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 +1539,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 = {};
@@ -1487,6 +2106,113 @@ function authfor(auths, url) {
   return auths.find((record2) => record2.origin === origin);
 }
 
+// extension/pageforms.ts
+var firstnames = { en: ["alex", "jordan", "taylor", "morgan", "casey"], pt: ["ana", "bruno", "carla", "diego", "helena"] };
+var lastnames = { en: ["brooks", "carter", "diaz", "evans", "reyes"], pt: ["alves", "costa", "lima", "souza", "moraes"] };
+function localekey(locale) {
+  const normalized = locale.toLowerCase();
+  if (normalized.startsWith("pt")) return "pt";
+  return "en";
+}
+function generatevalue(kind, rule) {
+  const seed = typeof rule.seed === "number" && Number.isFinite(rule.seed) ? Math.abs(Math.floor(rule.seed)) : 1;
+  const names = firstnames[localekey(rule.locale ?? "en")] ?? firstnames.en ?? ["alex"];
+  const surnames = lastnames[localekey(rule.locale ?? "en")] ?? lastnames.en ?? ["brooks"];
+  let state = seed * 1103515245 + 12345;
+  const next = () => {
+    state = (state * 1103515245 + 12345) % 2147483648;
+    return state / 2147483648;
+  };
+  const pick = (items) => items[Math.floor(next() * items.length) % items.length] ?? items[0];
+  const digits = (count) => Array.from({ length: count }, () => String(Math.floor(next() * 10))).join("");
+  const person = `${pick(names)} ${pick(surnames)}`;
+  switch (kind) {
+    case "email":
+      return `${person.replace(" ", ".")}${digits(2)}@example.com`;
+    case "phone":
+      return localekey(rule.locale ?? "en") === "pt" ? `+55 (11) 9${digits(4)}-${digits(4)}` : `+1 (555) 010-${digits(4)}`;
+    case "date":
+      return `${2024 + Math.floor(next() * 2)}-${String(1 + Math.floor(next() * 12)).padStart(2, "0")}-${String(1 + Math.floor(next() * 28)).padStart(2, "0")}`;
+    case "number":
+      return String(Math.floor(next() * 1e3));
+    case "select":
+      return `option ${1 + Math.floor(next() * 5)}`;
+    case "check":
+      return next() > 0.5 ? "true" : "false";
+    case "radio":
+      return `choice ${1 + Math.floor(next() * 4)}`;
+    case "file":
+      return `sample${digits(2)}.pdf`;
+    case "password":
+      return `pw-${digits(6)}-${pick(names)}`;
+    case "card":
+      return `4111 ${digits(4)} ${digits(4)} ${digits(4)}`;
+    case "code":
+      return digits(6);
+    default:
+      return person;
+  }
+}
+function valueshash(values) {
+  const source = values.map((entry) => `${entry.label}=${entry.value}`).join("|");
+  let hash = 5381;
+  for (let index = 0; index < source.length; index += 1) hash = (hash * 33 ^ source.charCodeAt(index)) >>> 0;
+  return hash.toString(16);
+}
+function parseformrecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record2 = value;
+  if (!Array.isArray(record2.entries)) return null;
+  const entries = [];
+  for (const item of record2.entries) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const entry = item;
+    const match = entry.match;
+    if (!match || typeof match !== "object" || Array.isArray(match)) continue;
+    const shapes = match;
+    if (typeof shapes.mode !== "string") continue;
+    const fieldmatch = {
+      mode: shapes.mode,
+      ...typeof shapes.label === "string" ? { label: shapes.label } : {},
+      ...typeof shapes.placeholder === "string" ? { placeholder: shapes.placeholder } : {},
+      ...typeof shapes.arialabel === "string" ? { arialabel: shapes.arialabel } : {},
+      ...typeof shapes.name === "string" ? { name: shapes.name } : {}
+    };
+    if (typeof entry.kind !== "string" || typeof entry.value !== "string") continue;
+    entries.push({ match: fieldmatch, kind: entry.kind, value: entry.value });
+  }
+  if (entries.length === 0) return null;
+  return { ...typeof record2.form === "string" && record2.form ? { form: record2.form } : {}, entries };
+}
+
+// extension/pagewizards.ts
+function parsebackoff(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const backoff = options.backoff;
+  if (!backoff || typeof backoff !== "object" || Array.isArray(backoff)) return null;
+  const rule = backoff;
+  const wait = rule.wait;
+  const factor = rule.factor;
+  if (typeof wait !== "number" || !Number.isFinite(wait) || wait <= 0) return null;
+  if (typeof factor !== "number" || !Number.isFinite(factor) || factor < 1) return null;
+  const attempts = typeof options.attempts === "number" && Number.isInteger(options.attempts) && options.attempts >= 1 ? options.attempts : 2;
+  return { attempts, wait, factor };
+}
+function backoffwaits(attempts, wait, factor) {
+  const windows = [];
+  let current = wait;
+  for (let index = 1; index < attempts; index += 1) {
+    windows.push(current);
+    current *= factor;
+  }
+  return windows;
+}
+
 // extension/background.ts
 var sessionduration = 15 * 60 * 1e3;
 var freshcheckkinds = /* @__PURE__ */ new Set(["focus", "inspect", "click", "type", "scroll", "select", "hover"]);
@@ -1496,6 +2222,7 @@ var observationstepkinds = /* @__PURE__ */ new Set(["a11ytree", "readvisible", "
 var navigationstepkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "reloadcache", "stopnav", "waitload", "waiturl", "followlink", "spanav", "spawait", "rewritequery", "setfragment", "navlist", "navprofile", "detecthttp", "readredirects", "readfinalurl", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "trailaudit", "pausenav", "navintent", "navrate", "openclipboard", "checksafe", "batchopen"]);
 var pausenavkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "followlink", "spanav", "navlist", "openclipboard", "batchopen", "prefetch", "preconnect", "deeplink", "reopentab"]);
 var ratecheckedkinds = /* @__PURE__ */ new Set(["openlink", "openprivate", "followlink", "spanav", "navlist", "openclipboard", "batchopen", "deeplink", "reopentab"]);
+var formfillkinds = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "fillcard", "fillcode", "attachfile", "saveprofiles", "runwizard", "selectchain", "picktypeahead", "pickdate"]);
 var evidencepoll = 100;
 var evidencesettle = 5e3;
 var chromestorage = {
@@ -1661,9 +2388,22 @@ 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";
+  if (step.kind === "retryaction" || step.kind === "retryform") return "retry";
+  if (step.kind === "submitform" || step.kind === "asksubmit") return "submit";
+  if (step.kind === "consentpassword") return "consent";
+  if (step.kind === "handoffcaptcha") return "handoff";
+  if (formfillkinds.has(step.kind)) return "fill";
   if (pointerkinds.has(step.kind)) return "pointer";
   if (watchstepkinds.has(step.kind)) return "watch";
   if (step.kind === "diffsnapshots") return "diff";
@@ -1900,6 +2640,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 +2668,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 +3105,523 @@ 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 executesaveprofiles(step, session, origin) {
+  const options = stepoptions2(step);
+  const record2 = parseformrecord(options.formrecord);
+  const name = typeof options.name === "string" ? options.name : "";
+  if (!name || !record2) throw new Error("A reviewed profile name and form record are required.");
+  const grants = session?.grants ?? (session ? [session.origin] : [origin]);
+  const profile = { name, fields: record2.entries, grants, savedat: Date.now() };
+  await memory.setprofile(profile);
+  await audit("fill", `Form profile ${name} stored locally with ${profile.fields.length} field entries behind the origin grants of ${grants.join(", ")}; password entries are refused.`, { ...session ? { sessionid: session.id } : {} });
+  return { ok: true, summary: `Stored the form profile ${name} locally with ${profile.fields.length} field entries.`, details: { profile: { name: profile.name, fields: profile.fields.length, grants: profile.grants } } };
+}
+async function executeasksubmit(step, session, plan, tabid2, origin) {
+  const output = await dispatchpagestep(step, tabid2, origin, plan);
+  const values = Array.isArray(output?.details?.values) ? output?.details?.values : [];
+  const ticket = { id: randomid(), form: step.value ?? "", valueshash: valueshash(values), consentref: step.id, at: Date.now() };
+  await memory.setticket(ticket);
+  await audit("submit", `Asksubmit prompt opened for form ${ticket.form || "the reviewed form"} with the values hash ${ticket.valueshash}; the submission waits for the user approval.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  await refreshbadge();
+  return { ok: true, summary: `Asksubmit prompt opened for form ${ticket.form || "the reviewed form"}; the submission waits for your approval.`, details: { ticket, values } };
+}
+async function executesubmitform(step, session, plan, tabid2, origin) {
+  const consentref = typeof stepoptions2(step).consentref === "string" ? stepoptions2(step).consentref : "";
+  const ticket = (await memory.gettickets()).find((item) => item.approved === true && (item.consentref === consentref || item.id === consentref));
+  if (!ticket) throw new Error("No approved asksubmit ticket matches the reviewed consent ref; approve the submission in the review panel first.");
+  const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The form submission returned no result." };
+  await audit("submit", `Form ${ticket.form || "the reviewed form"} submitted through its owning form under ticket ${ticket.id} with values hash ${ticket.valueshash} and outcome ${output.ok ? "delivered" : "refused"}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ...output, details: { ...output.details ?? {}, ticket: { id: ticket.id, valueshash: ticket.valueshash, consentref: ticket.consentref } } };
+}
+async function executeretryform(step, session, plan, tabid2, origin) {
+  const rule = parsebackoff(step);
+  if (!rule) throw new Error("A reviewed backoff rule with wait and factor is required.");
+  const windows = backoffwaits(rule.attempts, rule.wait, rule.factor);
+  let attempts = 0;
+  let output;
+  while (attempts < rule.attempts) {
+    attempts += 1;
+    output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The retried submission returned no result." };
+    if (output.ok) break;
+    const waitwindow = windows[attempts - 1];
+    if (waitwindow !== void 0 && attempts < rule.attempts) await new Promise((resolve) => setTimeout(resolve, waitwindow));
+  }
+  await audit("retry", `Form submission retried ${attempts} time${attempts === 1 ? "" : "s"} with the reviewed backoff windows ${windows.join(", ") || "none"} milliseconds; outcome ${output?.ok ? "delivered" : "refused"}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ok: Boolean(output?.ok), summary: output?.summary ?? "The retried submission returned no result.", details: { attempts, windows, ok: Boolean(output?.ok) } };
+}
+async function executeconsentpassword(step, session, plan, tabid2, origin) {
+  const consentref = typeof stepoptions2(step).consentref === "string" ? stepoptions2(step).consentref : "";
+  const gate = passwordconsentgranted(step);
+  if (!gate.allowed) throw new Error(gate.reason ?? "A password fill requires a reviewed consent ref.");
+  const output = await dispatchpagestep(step, tabid2, origin, plan);
+  await audit("consent", `Password field filled after the explicit consent ref ${consentref}; the value never appears in the audit trail.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return output ?? { ok: false, summary: "The password fill returned no result." };
+}
+async function executeattachfile(step, session, plan, tabid2, origin) {
+  const name = step.value ?? "";
+  const artifacts = await memory.getartifacts();
+  const artifact = artifacts.find((item) => item.name === name || item.id === name);
+  if (!artifact) throw new Error(`No generated artifact named ${name} exists in the run store yet.`);
+  const derived = { ...step, options: JSON.stringify({ ...stepoptions2(step), artifact: artifact.id, artifactname: artifact.name }) };
+  const output = await dispatchpagestep(derived, tabid2, origin, plan);
+  await audit("fill", `Artifact ${artifact.name} of kind ${artifact.kind} attached to the reviewed file input inside the form submission.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  return { ...output ?? { ok: false, summary: "The artifact attachment returned no result." }, details: { ...output?.details ?? {}, artifact } };
+}
+async function executecaptchahandoff(step, session, plan, tabid2, origin) {
+  const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The captcha probe returned no result." };
+  if (output.details?.captcha !== true) return { ok: true, summary: "No captcha was detected; the plan continues.", details: { captcha: false } };
+  const handoff = { id: randomid(), origin, resolved: false, openedat: Date.now() };
+  await memory.addcaptcha(handoff);
+  if (session && !session.pausedat && !session.stoppedat) await memory.setsession({ ...session, pausedat: Date.now() });
+  await audit("handoff", `Captcha detected on ${origin}; control handed back to the user and the plan pauses until the handoff ${handoff.id} resolves.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  await refreshbadge();
+  return { ok: true, summary: "Captcha detected; control is yours and the plan waits until you resolve the handoff.", details: { captcha: true, handoff } };
+}
+async function executeformstep(step, session, plan, tabid2, origin) {
+  switch (step.kind) {
+    case "saveprofiles":
+      return executesaveprofiles(step, session, origin);
+    case "asksubmit":
+      return executeasksubmit(step, session, plan, tabid2, origin);
+    case "submitform":
+      return executesubmitform(step, session, plan, tabid2, origin);
+    case "retryform":
+      return executeretryform(step, session, plan, tabid2, origin);
+    case "consentpassword":
+      return executeconsentpassword(step, session, plan, tabid2, origin);
+    case "attachfile":
+      return executeattachfile(step, session, plan, tabid2, origin);
+    case "handoffcaptcha":
+      return executecaptchahandoff(step, session, plan, tabid2, origin);
+    case "fillcode": {
+      const stored = await memory.getcodevalue();
+      const source = typeof stepoptions2(step).source === "string" ? stepoptions2(step).source : "";
+      const derived = stored !== void 0 && source === "reviewed" ? { ...step, value: stored } : step;
+      const output = await dispatchpagestep(derived, tabid2, origin, plan);
+      await audit("fill", `One time code typed from the reviewed source ${source}${stored !== void 0 ? " through the consent gated code entry" : ""}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+      return output ?? { ok: false, summary: "The one time code fill returned no result." };
+    }
+    default: {
+      const output = await dispatchpagestep(step, tabid2, origin, plan);
+      const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
+      if (step.kind === "runwizard" && output?.details?.wizard && typeof output.details.wizard === "object") {
+        const state = output.details.wizard;
+        await memory.addwizard(state);
+        await memory.setprogress(recordwizardstep(await memory.getprogress(), plan.id, step.id, state, Date.now()));
+        await audit("fill", `Wizard advanced to step ${Math.min(state.index, state.steps)} of ${state.steps} with a completion share of ${Math.round(wizardcompletion(state) * 100)} percent.`, extra);
+      }
+      if (step.kind === "picktypeahead" && typeof output?.details?.pick === "string") {
+        const pick = { field: step.target ?? "", query: step.value ?? "", pick: output.details.pick, at: Date.now() };
+        await memory.addpick(pick);
+      }
+      if (step.kind === "readerrors" && Array.isArray(output?.details?.errors)) {
+        const report = { form: step.target ?? "", errors: output?.details?.errors, at: Date.now() };
+        await memory.adderrorreport(report);
+        await audit("fill", `Collected ${report.errors.length} inline validation message${report.errors.length === 1 ? "" : "s"} for the correction loop.`, extra);
+      }
+      if ((step.kind === "detectlogin" || step.kind === "detecttemplate") && output?.ok) {
+        const detected = step.kind === "detectlogin" ? output.details?.login === true : output.details?.template === "signup" || output.details?.template === "checkout";
+        if (detected) {
+          const kind = step.kind === "detectlogin" ? "login" : output.details?.template === "checkout" ? "checkout" : "signup";
+          const markers = Array.isArray(output.details?.markers) ? output.details?.markers : [];
+          const record2 = { origin, kind, markers, at: Date.now() };
+          await memory.adddetection(record2);
+          await audit("fill", `${kind} shape detected on ${origin} with markers ${markers.join(", ") || "none"}; sensitive work stays behind the consent gates.`, extra);
+        }
+      }
+      if (step.kind === "skiphoneypot" && Array.isArray(output?.details?.skipped)) {
+        await audit("fill", `Honeypot survey flagged ${output.details.skipped.length} field${output.details.skipped.length === 1 ? "" : "s"} as skipped so fills never trip them.`, extra);
+      }
+      if (step.kind === "fillform" || step.kind === "filllabel" || step.kind === "fillplaceholder") {
+        const filled = typeof output?.details?.filled === "number" ? output.details.filled : 0;
+        const skipped = Array.isArray(output?.details?.skipped) ? output.details.skipped.length : 0;
+        await audit("fill", `Filled ${filled} reviewed field${filled === 1 ? "" : "s"}${skipped > 0 ? ` and skipped ${skipped} honeypot field${skipped === 1 ? "" : "s"}` : ""}.`, extra);
+      }
+      if (step.kind === "generatevalues") {
+        const count = Array.isArray(output?.details?.values) ? output.details.values.length : 0;
+        await audit("fill", `Generated ${count} realistic value${count === 1 ? "" : "s"} with the reviewed seed and locale; real looking card numbers and personal identifiers are refused.`, extra);
+      }
+      return output ?? { ok: false, summary: "The forms and data step returned no result." };
+    }
+  }
+}
+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 prompts = (await memory.gettickets()).filter((ticket) => ticket.approved === void 0).length;
+  const tasktabs2 = new Set(badges.map((badge) => badge.tabid)).size;
+  const total = (queues?.prefetch ?? 0) + (queues?.batchopen ?? 0) + tasktabs2 + prompts;
   await chrome.action.setBadgeText({ text: total > 0 ? String(total) : "" }).catch(() => {
   });
 }
@@ -2372,7 +3640,14 @@ 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 (isformkind(step.kind)) {
+    output = await executeformstep(step, session, plan, tab.id, origin);
+  } 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 +3679,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 +3696,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 +3786,31 @@ 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 profiles = await memory.getprofiles();
+      const tickets = await memory.gettickets();
+      const wizards = await memory.getwizards();
+      const picks = await memory.getpicks();
+      const errorreports = await memory.geterrorreports();
+      const captchas = await memory.getcaptchas();
+      const detections = await memory.getdetections();
+      const codeentry = await memory.getcodevalue();
+      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, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {} };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -2607,6 +3908,184 @@ 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 "applyprofile": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("Profile application stays inside the consent gate of an active session.");
+      const inputprofile = message;
+      const profile = await memory.getprofile(inputprofile.name ?? "");
+      if (!profile) throw new Error(`No form profile named ${inputprofile.name ?? ""} is stored yet.`);
+      const gate = profilegrantgranted(profile, session.origin);
+      if (!gate.allowed) throw new Error(gate.reason);
+      await audit("fill", `Form profile ${profile.name} applied as the reviewed field map for ${session.origin} under its origin grants.`, { sessionid: session.id });
+      return { profile: { name: profile.name, fields: profile.fields, grants: profile.grants } };
+    }
+    case "approvesubmit": {
+      const inputticket = message;
+      const tickets = await memory.gettickets();
+      const ticket = tickets.find((item) => item.id === inputticket.id);
+      if (!ticket) throw new Error("No submission ticket matches the requested id.");
+      const updated = { ...ticket, approved: inputticket.approved !== false };
+      await memory.setticket(updated);
+      const session = await memory.getsession();
+      await audit("submit", `Submission ticket ${ticket.id} for form ${ticket.form} ${updated.approved ? "approved" : "declined"} by the user with values hash ${ticket.valueshash}.`, { ...session ? { sessionid: session.id } : {} });
+      await refreshbadge();
+      return updated;
+    }
+    case "resolvecaptcha": {
+      const open = (await memory.getcaptchas()).find((item) => !item.resolved);
+      if (!open) throw new Error("No open captcha handoff exists.");
+      await memory.resolvecaptcha(open.id, Date.now());
+      const session = await memory.getsession();
+      if (session?.pausedat && !session.stoppedat) {
+        const resumed = { id: session.id, tabid: session.tabid, origin: session.origin, startedat: session.startedat, expiresat: session.expiresat, ...session.grants ? { grants: session.grants } : {} };
+        await memory.setsession(resumed);
+      }
+      await audit("handoff", `Captcha handoff ${open.id} resolved by the user after ${Date.now() - open.openedat} milliseconds; the plan continues.`, { ...session ? { sessionid: session.id } : {} });
+      await refreshbadge();
+      return { resolved: true, id: open.id };
+    }
+    case "storecode": {
+      const session = await memory.getsession();
+      if (!session || session.stoppedat || session.expiresat <= Date.now()) throw new Error("The one time code entry stays behind the consent gate of an active session.");
+      const inputcode = message;
+      if (!inputcode.code?.trim()) throw new Error("A non-empty one time code is required.");
+      await memory.setcodevalue(inputcode.code.trim());
+      await audit("consent", `A one time code was stored behind the consent gate of the active session; the value never appears in the audit trail.`, { sessionid: session.id });
+      return { stored: true };
+    }
+    case "regeneratevalue": {
+      const inputvalue = message;
+      if (typeof inputvalue.field !== "string" || !inputvalue.field) throw new Error("A field kind is required to regenerate a value.");
+      const rule = {};
+      if (typeof inputvalue.locale === "string" && inputvalue.locale) rule.locale = inputvalue.locale;
+      if (typeof inputvalue.seed === "number" && Number.isFinite(inputvalue.seed)) rule.seed = inputvalue.seed;
+      const value = generatevalue(inputvalue.field, rule);
+      const verdict = generatedvalueallowed(value);
+      if (!verdict.allowed) throw new Error(verdict.reason ?? "The regenerated value was refused.");
+      return { kind: inputvalue.field, value, locale: rule.locale ?? "en", seed: rule.seed ?? 1 };
+    }
+    case "removeprofile": {
+      const inputprofile = message;
+      const profile = await memory.getprofile(inputprofile.name ?? "");
+      if (!profile) throw new Error(`No form profile named ${inputprofile.name ?? ""} is stored yet.`);
+      await memory.removeprofile(profile.name);
+      const session = await memory.getsession();
+      await audit("fill", `Form profile ${profile.name} removed from local memory by the user.`, { ...session ? { sessionid: session.id } : {} });
+      return { removed: true, name: profile.name };
+    }
+    case "formreport": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for a form report envelope.");
+      const outcome = (await memory.getoutcomes()).find((candidate) => plan.steps.some((step) => step.id === candidate.stepid && step.kind === "detectfields"));
+      const report = outcome?.details?.report;
+      if (!report) throw new Error("No form report has been captured yet.");
+      return JSON.parse(formreportresponse({ report, plan }));
+    }
+    case "errorreport": {
+      const plan = await memory.getplan();
+      if (!plan) throw new Error("No plan is available for an error report envelope.");
+      const report = (await memory.geterrorreports())[0];
+      if (!report) throw new Error("No error report has been collected yet.");
+      return JSON.parse(errorreportresponse({ report, plan }));
+    }
     case "stop": {
       const session = await memory.getsession();
       if (session) await memory.setsession({ ...session, stoppedat: Date.now() });