@wenathlan/extension 1.1.64 → 1.1.66

package/extension/dist/background.js

@@ -5159,6 +5159,173 @@ var sessionmemory = class {
   async addstepapproveresolution(resolution) {
     await this.adapter.set("stepapproveresolutions", [resolution, ...await this.getstepapproveresolutions()]);
   }
+  /**
+   * Interface surface stores of the 1.1.65 family live here, scoped per profile workspace: the siteprofiles with the per site interface preferences, the shortcutkeys bindings and the theme preference per profile, the recenttray entries with their configurable depth and the notification consent and preference per profile.
+   */
+  /** Returns the siteprofile of one origin; an absent profile keeps the global interface preferences. */
+  async getsiteprofile(origin) {
+    return this.adapter.get(`siteprofile:${origin}`);
+  }
+  /** Stores the siteprofile of one origin with its theme, shortcutkeys and default view; the profile never adjusts a policy gate. */
+  async setsiteprofile(profile) {
+    return this.adapter.set(`siteprofile:${profile.origin}`, profile);
+  }
+  /** Returns every stored siteprofile keyed by origin. */
+  async listsiteprofiles() {
+    const entries = Object.entries(await this.adapter.get("siteprofiles") ?? {});
+    return entries.map(([, profile]) => profile);
+  }
+  /** Stores every siteprofile keyed by origin so the list view reads them in one call. */
+  async setsiteprofiles(profiles) {
+    await this.adapter.set("siteprofiles", Object.fromEntries(profiles.map((profile) => [profile.origin, profile])));
+  }
+  /** Returns the stored shortcutkeys bindings of the profile; an absent set keeps the shipped editable defaults. */
+  async getshortcutbindings() {
+    return await this.adapter.get("shortcutbindings") ?? [];
+  }
+  /** Stores the shortcutkeys bindings the user edited in the optionspage. */
+  async setshortcutbindings(bindings) {
+    return this.adapter.set("shortcutbindings", bindings);
+  }
+  /** Returns the stored darklight theme preference of the profile; an absent preference follows the os preference alone. */
+  async getthemepreference() {
+    return this.adapter.get("themepreference");
+  }
+  /** Stores the darklight theme preference of the profile with its manual override. */
+  async setthemepreference(preference) {
+    return this.adapter.set("themepreference", preference);
+  }
+  /** Returns the recenttray entries, newest first, with their resume and reopen offers. */
+  async getrecenttray() {
+    return await this.adapter.get("recenttray") ?? [];
+  }
+  /** Adds one recenttray entry with the user configured depth; an absent depth keeps every run. */
+  async addrecenttrayentry(entry) {
+    const depth = (await this.getsettings())?.recenttraydepth;
+    const appended = [entry, ...(await this.getrecenttray()).filter((candidate) => candidate.runid !== entry.runid)];
+    await this.adapter.set("recenttray", depth !== void 0 && Number.isInteger(depth) && depth > 0 ? appended.slice(0, depth) : appended);
+  }
+  /** Returns the notification consent and preference of the profile; an absent record keeps the notifications content free and on. */
+  async getnotificationprefs() {
+    return this.adapter.get("notificationprefs");
+  }
+  /** Stores the notification consent and preference of the profile; the content consent gates every page content bearing body. */
+  async setnotificationprefs(prefs) {
+    return this.adapter.set("notificationprefs", prefs);
+  }
+  /** Returns the notification payloads the surface history keeps for the user to open after a do not disturb quiet. */
+  async getnotificationhistory() {
+    return await this.adapter.get("notificationhistory") ?? [];
+  }
+  /** Records one notification payload in the history so its deep link stays reachable while the notifications permission stays outside the manifest. */
+  async addnotificationhistory(payload) {
+    await this.adapter.set("notificationhistory", [payload, ...await this.getnotificationhistory()]);
+  }
+  /**
+   * Ecosystem stores of the 1.1.66 family live here, scoped per profile workspace: the flowlibrary entries with their manifest digests and provenance, the library install and removal events, the syncbridge hooks with their conflict records, the attentionfeed entries with their configurable retention, the runreplay cursors per viewed run, the outputcompare sessions with their metric results and the background run queue state for restart recovery.
+   * The flowlibrary store deduplicates entries by manifest digest, every entry carries its publisher provenance, and the manifest list exports for audit; the memory adapter seam stays the documented marketplace backend boundary because a future remote registry replaces the adapter only.
+   */
+  /** Returns every flowlibrary entry of the profile workspace, newest first. */
+  async getflowlibrary() {
+    return await this.adapter.get("flowlibrary") ?? [];
+  }
+  /** Replaces the flowlibrary entries of the profile workspace. */
+  async setflowlibrary(entries) {
+    return this.adapter.set("flowlibrary", entries);
+  }
+  /** Adds one flowlibrary entry deduplicated by manifest digest: an entry whose digest already exists replaces its predecessor while its provenance keeps both records. */
+  async addlibraryentry(entry) {
+    const entries = await this.getflowlibrary();
+    const deduped = entries.filter((candidate) => candidate.digest !== entry.digest);
+    await this.setflowlibrary([entry, ...deduped]);
+    return [entry, ...deduped];
+  }
+  /** Removes one flowlibrary entry by its id while the library events keep their record for the audit trail. */
+  async removelibraryentry(entryid) {
+    await this.setflowlibrary((await this.getflowlibrary()).filter((candidate) => candidate.id !== entryid));
+  }
+  /** Returns every library install, update and removal event, newest first. */
+  async getlibraryevents() {
+    return await this.adapter.get("libraryevents") ?? [];
+  }
+  /** Records one library lifecycle event beside the flowlibrary store. */
+  async addlibraryevent(event) {
+    await this.adapter.set("libraryevents", [event, ...await this.getlibraryevents()]);
+  }
+  /** Exports the manifest list of the flowlibrary for audit: one row per entry with its digest, publisher, version, state and provenance and no step payload. */
+  async exportlibrarymanifests() {
+    return (await this.getflowlibrary()).map((entry) => ({ id: entry.id, title: entry.manifest.title, publisher: entry.manifest.publisher, version: entry.manifest.version, digest: entry.digest, state: entry.state, provenance: entry.provenance, addedat: entry.addedat }));
+  }
+  /** Returns every syncbridge hook of the profile workspace; every hook keeps its explicit opt in with no default on. */
+  async getsyncbridgehooks() {
+    return await this.adapter.get("syncbridgehooks") ?? [];
+  }
+  /** Replaces the syncbridge hooks of the profile workspace. */
+  async setsyncbridgehooks(hooks) {
+    return this.adapter.set("syncbridgehooks", hooks);
+  }
+  /** Returns every syncbridge conflict record, newest first, with both versions instead of a silent overwrite. */
+  async getsyncbridgeconflicts() {
+    return await this.adapter.get("syncbridgeconflicts") ?? [];
+  }
+  /** Records one syncbridge conflict with both manifest versions. */
+  async addsyncbridgeconflict(conflict) {
+    await this.adapter.set("syncbridgeconflicts", [conflict, ...await this.getsyncbridgeconflicts()]);
+  }
+  /** Resolves one syncbridge conflict by its id with the resolution the user picked; one conflict resolves exactly once. */
+  async resolvesyncbridgeconflict(id, resolution, now) {
+    const conflicts = await this.getsyncbridgeconflicts();
+    await this.adapter.set("syncbridgeconflicts", conflicts.map((conflict) => conflict.id === id && conflict.resolution === void 0 ? { ...conflict, resolution, resolvedat: now } : conflict));
+    return this.getsyncbridgeconflicts();
+  }
+  /** Returns every attentionfeed entry, newest first, with its cause, refs and deep link. */
+  async getattentionentries() {
+    return await this.adapter.get("attentionfeed") ?? [];
+  }
+  /** Records one attentionfeed entry deduplicated by its cause, run and gate refs while the retention window stays a user setting. */
+  async addattentionentry(entry) {
+    const existing = (await this.getattentionentries()).filter((candidate) => candidate.id !== entry.id);
+    await this.adapter.set("attentionfeed", [entry, ...existing]);
+  }
+  /** Dismisses one attentionfeed entry by its id: the dismissal removes the feed row only while the waiting cause keeps its own resolution path. */
+  async dismissattentionentry(id) {
+    const entries = (await this.getattentionentries()).filter((candidate) => candidate.id !== id);
+    await this.adapter.set("attentionfeed", entries);
+    return entries;
+  }
+  /** Prunes the attentionfeed entries past their retention window; an absent window keeps every entry while the pruned ids return for the audit note. */
+  async pruneattentionentries(now) {
+    const retention = (await this.getsettings())?.attentionretention;
+    const entries = await this.getattentionentries();
+    if (retention === void 0) return { kept: entries, pruned: [] };
+    const kept = entries.filter((entry) => now - entry.at < retention);
+    await this.adapter.set("attentionfeed", kept);
+    return { kept, pruned: entries.filter((entry) => now - entry.at >= retention).map((entry) => entry.id) };
+  }
+  /** Returns the runreplay cursors per viewed run so a reopened replay stands where the viewer left it. */
+  async getreplaycursors() {
+    return await this.adapter.get("replaycursors") ?? {};
+  }
+  /** Stores one runreplay cursor for its viewed run. */
+  async setreplaycursor(runid, cursor) {
+    await this.adapter.set("replaycursors", { ...await this.getreplaycursors(), [runid]: cursor });
+  }
+  /** Returns every outputcompare session with its metric results, newest first. */
+  async getcomparesessions() {
+    return await this.adapter.get("comparesessions") ?? [];
+  }
+  /** Records one outputcompare session with the metric set it used. */
+  async addcomparesession(session) {
+    await this.adapter.set("comparesessions", [session, ...await this.getcomparesessions()]);
+  }
+  /** Returns the background run queue state for restart recovery: every entry with its state and its keepalive hold. */
+  async getbackgroundqueue() {
+    return await this.adapter.get("backgroundqueue") ?? [];
+  }
+  /** Replaces the background run queue state after every transition so the restart recovery reads it in one call. */
+  async setbackgroundqueue(queue) {
+    return this.adapter.set("backgroundqueue", queue);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -10712,6 +10879,97 @@ function logstreamegressgate(input) {
   if (!input.verified) return { allowed: false, reason: "The logstream chain failed its live verification; the audit excerpt refuses the copy because only a verified range leaves the stream." };
   return { allowed: true, reason: `The logstream chain verifies across the ${input.entries} event${input.entries === 1 ? "" : "s"} of the range; the audit excerpt copies as one verified record.` };
 }
+function quickactiongate(input) {
+  if (input.action.origin.trim() === "") return { allowed: false, reason: `The ${input.action.command} quickaction needs the origin of the clicked tab; an originless entry never registers.` };
+  if (!input.granted.includes(input.action.origin)) return { allowed: false, reason: `The ${input.action.command} quickaction stays off the ${input.action.origin} tab because its origin holds no allowlist entry; only permitted actions surface.` };
+  if (input.action.session === true && !input.sessionactive) return { allowed: false, reason: `The ${input.action.command} quickaction needs an active browser session before it registers; the context menu never offers a run action without its session.` };
+  if (input.action.permission !== void 0 && !(input.capabilities ?? []).includes(input.action.permission)) return { allowed: false, reason: `The ${input.action.command} quickaction needs the ${input.action.permission} capability granted before it registers; the context menu never offers an action the current capability set refuses.` };
+  return { allowed: true, reason: `The ${input.action.command} quickaction rides the origin allowlist of the clicked ${input.action.origin} tab and registers.` };
+}
+function omniboxtaskgate(input) {
+  if (input.direct) return { allowed: false, reason: "The omnibox keyword never executes a goal directly; every keyword goal routes through the same proposal and review flow as the api and becomes a reviewed plan first." };
+  if (input.text.trim() === "") return { allowed: false, reason: "The omnibox task needs its natural language goal after the keyword; an empty goal never reaches the proposal flow." };
+  if (input.origin.trim() === "") return { allowed: false, reason: "The omnibox task needs its active origin scope; a goal without an origin never reaches the proposal flow." };
+  return { allowed: true, reason: `The omnibox goal for ${input.origin} rides the same proposal flow as the api: the observation, the capabilities and the plan review all recheck it.` };
+}
+function notificationcontentgate(input) {
+  if (!input.content) return { allowed: true, reason: "The notification body carries no page content, so no content consent is needed and it shows." };
+  if (!input.consent) return { allowed: false, reason: "The notification body carries page content and no content consent exists; a content bearing notification never shows without its consent." };
+  return { allowed: true, reason: "The notification body carries page content and its consent exists, so it shows with the content the user agreed to." };
+}
+function pickeroverlaygate(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The pickeroverlay session needs its origin; an originless read never starts." };
+  if (!input.granted.includes(input.origin)) return { allowed: false, reason: `The pickeroverlay reads no element candidate of ${input.origin} because the origin holds no allowlist entry; picker reads stay inside the granted origins.` };
+  return { allowed: true, reason: `The pickeroverlay lists the element candidates of the granted origin ${input.origin} with their stability scored selectors.` };
+}
+function shotpanelgate(input) {
+  if (input.captureorigin.trim() === "") return { allowed: false, reason: "The shotpanel view needs the origin of its capture; an originless capture never opens." };
+  if (!input.granted.includes(input.captureorigin)) return { allowed: false, reason: `The shotpanel opens no capture of ${input.captureorigin} because the origin holds no allowlist entry; capture views stay inside the granted origins.` };
+  return { allowed: true, reason: `The shotpanel previews the capture of the granted origin ${input.captureorigin} with its redaction verdicts.` };
+}
+function siteprofilegate(input) {
+  const origin = input.origin.trim();
+  if (origin === "") return { allowed: false, reason: "The siteprofile needs its origin; an originless profile never stores." };
+  if (!origin.startsWith("https://") || origin.length <= "https://".length) return { allowed: false, reason: `The siteprofile stores per site interface preferences of https origins only; ${origin} holds no https origin shape.` };
+  return { allowed: true, reason: `The siteprofile of ${origin} stores its theme, shortcutkeys and default view beside the originprofiles policy preferences; no profile ever adjusts a policy gate.` };
+}
+function importexportgate(input) {
+  if (input.containssecrets) return { allowed: false, reason: "The importexport bundle carries a secretvault value shape; secret values never leave the browser under any flag, so the bundle refuses in full." };
+  if (input.unmaskedlogs) return { allowed: false, reason: "The importexport bundle carries unmasked log entries; only masked summaries ever move between profiles, so the bundle refuses in full." };
+  return { allowed: true, reason: "The importexport bundle carries no secretvault value and no unmasked log; the originprofiles, the siteprofiles, the notes and the preferences move with their honest exclusion list." };
+}
+function librarymanifestgate(input) {
+  if (input.errors.length > 0) return { allowed: false, reason: `The flowlibrary manifest fails schemastrict with ${input.errors.length} error${input.errors.length === 1 ? "" : "s"}: ${input.errors.slice(0, 3).map((error) => `${error.path} expected ${error.expected}`).join("; ")}; the import refuses before anything else.` };
+  return { allowed: true, reason: "The flowlibrary manifest passes schemastrict with no shape error; the validation names every field it checked." };
+}
+function librarycapabilitygate(input) {
+  const missing = [...new Set(input.kinds)].filter((kind) => !input.capabilities.includes(kind));
+  if (missing.length > 0) return { allowed: false, reason: `The flowlibrary manifest uses the kind${missing.length === 1 ? "" : "s"} ${missing.join(", ")} the installed capability set lacks; the import refuses in full.` };
+  return { allowed: true, reason: `Every kind of the flowlibrary manifest sits inside the installed capability set of ${input.capabilities.length} kind${input.capabilities.length === 1 ? "" : "s"}.` };
+}
+function librarygrantgate(input) {
+  const missing = [...new Set(input.requiredgrants)].filter((origin) => !input.heldgrants.includes(origin));
+  if (missing.length > 0) return { allowed: false, reason: `The flowlibrary manifest requires the grant${missing.length === 1 ? "" : "s"} ${missing.join(", ")} the profile does not hold; the grant diff shows them and the user grants them before the import completes.` };
+  return { allowed: true, reason: `The profile holds every grant the flowlibrary manifest requires${input.requiredgrants.length === 0 ? " and the manifest requires none" : ""}.` };
+}
+function librarysensitivegate(input) {
+  if (!input.sensitive) return { allowed: true, reason: "The flowlibrary manifest carries no sensitive mark, so no fresh consent prompt stands before its import." };
+  if (!input.freshconsent) return { allowed: false, reason: "The flowlibrary manifest is marked sensitive; its import needs a fresh consent prompt the user answers before anything lands." };
+  return { allowed: true, reason: "The user answered the fresh consent prompt of the sensitive flowlibrary manifest; the import proceeds behind the same review." };
+}
+function libraryquarantinegate(input) {
+  if (!input.signaturepresent && !input.verified) return { allowed: false, reason: "The flowlibrary entry carries no publisher signature; the entry quarantines until the user verifies its publisher, and a quarantined entry never installs on its own." };
+  if (input.signaturepresent && !input.signaturevalid) return { allowed: false, reason: "The publisher signature of the flowlibrary entry failed its verification; the entry quarantines and never installs under any flag." };
+  return { allowed: true, reason: "The publisher signature of the flowlibrary entry verified over its manifest digest; the entry stays available for the grant diff and the import." };
+}
+function syncbridgeoptingate(input) {
+  if (!input.optin) return { allowed: false, reason: "The syncbridge hook stays off because no explicit opt in exists; no hook ever defaults on and no manifest moves without the user turning the hook on." };
+  return { allowed: true, reason: "The user explicitly opted the syncbridge hook in; the hook moves manifests only and never secrets or logs." };
+}
+function syncbridgescopegate(input) {
+  if (input.carriessecrets) return { allowed: false, reason: "The syncbridge payload carries a secretvault value shape; the bridge moves manifests only, so the payload refuses in full." };
+  if (input.carrieslogs) return { allowed: false, reason: "The syncbridge payload carries log entries; the bridge moves manifests only, so the payload refuses in full." };
+  return { allowed: true, reason: "The syncbridge payload carries manifests only; secrets and logs never ride the bridge under any flag." };
+}
+function runreplaygate(input) {
+  if (!input.sealed) return { allowed: false, reason: "The runreplay walks sealed runs only; an open run keeps moving and its replay would show a chain that still grows." };
+  if (!input.chainvalid) return { allowed: false, reason: "The sealed chain of the run failed its verification; the replay refuses the walk because only a verified chain stands as audit evidence." };
+  return { allowed: true, reason: "The run sealed and its chain verified from the genesis hash to the seal; the replay walks it read only, restoring the observation and capture of each step." };
+}
+function outputcomparegate(input) {
+  if (input.signaturea.trim() === "" || input.signatureb.trim() === "") return { allowed: false, reason: "The outputcompare needs the task input signature of both runs; a signatureless run never compares." };
+  if (input.signaturea !== input.signatureb) return { allowed: false, reason: "The two runs carry different task input signatures; only runs that started from the same input compare their outcomes." };
+  return { allowed: true, reason: "The two runs share their task input signature, so their step outcomes compare under the recorded metric set." };
+}
+function outputcomparereadonlygate(input) {
+  if (input.executessteps) return { allowed: false, reason: "The outputcompare never executes a step; it reads the stored outcomes of both runs only, so any executing path refuses in full." };
+  return { allowed: true, reason: "The outputcompare joins the stored outcomes of both runs without touching the page; no step executes inside a comparison." };
+}
+function backgroundrungate(input) {
+  if (!input.reviewed) return { allowed: false, reason: "The background run queue executes reviewed workflows only; an unreviewed workflow never starts, with or without an open surface." };
+  if (!input.keepaliveheld) return { allowed: false, reason: "A background run holds the keepalive signal for its whole duration; a run that releases the signal early stops being a background run." };
+  return { allowed: true, reason: "The reviewed workflow runs in the background with the keepalive signal held and every checkpoint restoring it on each worker wake." };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -10962,7 +11220,7 @@ function maskexport(record2, shapes) {
 }
 
 // version.ts
-var packageversion = "1.1.64";
+var packageversion = "1.1.66";
 
 // types.ts
 var protocolversion = packageversion;
@@ -11942,6 +12200,9 @@ function transparencyreport(input) {
 function surfacesnapshot(input) {
   return { version: protocolversion, surface: input.surface, palette: input.palette, timeline: input.timeline, logstream: input.logstream, plancards: input.plancards, ...input.onboarding !== void 0 ? { onboarding: input.onboarding } : {} };
 }
+function ecosystemviews(input) {
+  return { version: protocolversion, library: input.library, installed: input.installed, syncbridge: input.syncbridge, attention: input.attention, backgroundruns: input.backgroundruns, ...input.replay !== void 0 ? { replay: input.replay } : {}, ...input.compare !== void 0 ? { compare: input.compare } : {} };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -13367,7 +13628,8 @@ function onboardingsteps() {
     { id: "origingrants", surface: "popup", title: "Origin grants", body: "Devthink denies automation by default; grant one exact origin at a time from the popup and every run stays inside the granted origins.", completion: "origingrantscompleted" },
     { id: "planreview", surface: "sidepanel", title: "Plan review", body: "Every task becomes a plan of reviewed steps; read the plancards of each risk class and approve, reject or edit one step at a time.", completion: "planreviewcompleted" },
     { id: "runcontrol", surface: "sidepanel", title: "Run control", body: "Runs start, pause, resume and cancel under your hand; a cancelled run rolls only its queued steps back while the executed steps stay sealed.", completion: "runcontrolcompleted" },
-    { id: "logaudit", surface: "dashboardpage", title: "Log audit", body: "The immutable log chains every step transition with masked values; open the dashboard, verify the chain and copy a verified range as an audit excerpt.", completion: "logauditcompleted" }
+    { id: "logaudit", surface: "dashboardpage", title: "Log audit", body: "The immutable log chains every step transition with masked values; open the dashboard, verify the chain and copy a verified range as an audit excerpt.", completion: "logauditcompleted" },
+    { id: "library", surface: "dashboardpage", title: "Flow library", body: "The flowlibrary shares reviewed workflow templates: browse an entry, read its step list and grant diff, and every install still lands as a proposal behind the same review.", completion: "librarycompleted", optional: true }
   ];
 }
 function onboardingstart(previous, now) {
@@ -13378,7 +13640,7 @@ function onboardingcomplete(state, stepid, now) {
   const step = steps.find((candidate) => candidate.id === stepid);
   if (step === void 0) throw new Error(`The onboarding knows no ${stepid} step.`);
   const completed = state.stepscompleted.includes(stepid) ? state.stepscompleted : [...state.stepscompleted, stepid];
-  const done = steps.every((candidate) => completed.includes(candidate.id));
+  const done = steps.filter((candidate) => candidate.optional !== true).every((candidate) => completed.includes(candidate.id));
   if (!done) return { state: { ...state, stepscompleted: completed, done: false } };
   const consentevent = "onboardingconsentgranted";
   return { state: { stepscompleted: completed, done: true, ...state.startedat !== void 0 ? { startedat: state.startedat } : {}, consentevent, completedat: now }, consentevent };
@@ -13538,6 +13800,469 @@ function loglevelof(kind) {
   return "info";
 }
 
+// datagrid.ts
+function infercolumntype(values) {
+  const present = values.filter((value) => value.trim() !== "");
+  if (present.length === 0) return "empty";
+  if (present.every((value) => /^-?\d+(?:\.\d+)?$/.test(value.trim()))) return "number";
+  if (present.every((value) => value.trim() === "true" || value.trim() === "false")) return "boolean";
+  if (present.every((value) => !Number.isNaN(Date.parse(value.trim())) && /\d{4}-\d{2}-\d{2}/.test(value.trim()))) return "date";
+  return "text";
+}
+function datagridcolumnsof(rows) {
+  const fields = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  return fields.map((field) => ({ field, label: field, type: infercolumntype(rows.map((row) => row[field] ?? "")), inferred: true }));
+}
+function datagridof(input) {
+  if (input.title.trim() === "") throw new Error("The datagrid view needs its title.");
+  if (input.origin.trim() === "") throw new Error("The datagrid view needs its origin.");
+  if (input.rows.length === 0) throw new Error("The datagrid view needs at least one extracted row.");
+  const columns = datagridcolumnsof(input.rows);
+  const rows = input.rows.map((row, index) => ({ index, values: Object.fromEntries(columns.map((column) => [column.field, row[column.field] ?? ""])) }));
+  return { id: randomid(), title: input.title.trim(), origin: input.origin.trim(), runid: input.runid, columns, rows, at: input.at };
+}
+function exportmenudescriptors() {
+  return ["csv", "json", "clipboard"].flatMap((format) => ["selection", "step", "run"].map((scope) => ({ format, scope, destination: format === "clipboard" ? "clipboard" : "download" })));
+}
+
+// quickactions.ts
+function quickactioncatalog() {
+  return [
+    { id: "extractpage", label: "Extract page data", command: "starttask", surface: "sidepanel", session: true },
+    { id: "captureshot", label: "Capture a shot", command: "starttask", surface: "sidepanel", permission: "downloads", session: true },
+    { id: "runrecent", label: "Run the recent task", command: "starttask", surface: "popup", session: true },
+    { id: "opendashboardpage", label: "Open the dashboard", command: "opendashboardpage", surface: "dashboardpage" }
+  ];
+}
+function quickactionsfor(catalog, input) {
+  const capabilities = input.grantedcapabilities ?? ["activeTab", "storage", "scripting", "sidePanel"];
+  const grantedcapabilities2 = capabilities;
+  return catalog.filter((action) => quickactiongate({ action: { command: action.command, origin: input.origin, ...action.permission !== void 0 ? { permission: action.permission } : {}, ...action.session !== void 0 ? { session: action.session } : {} }, granted: input.granted, sessionactive: input.sessionactive, capabilities: grantedcapabilities2 }).allowed);
+}
+function shortcutdefaults() {
+  return [
+    { command: "starttask", key: "Enter", modifiers: [], editable: true, surface: "popup" },
+    { command: "pauserun", key: "p", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "resumerun", key: "r", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "cancelrun", key: "x", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "commandpalette", key: ".", modifiers: ["ctrl"], editable: true, surface: "popup" }
+  ];
+}
+function parseshortcut(text2) {
+  const parts = text2.trim().toLowerCase().split("+").map((part) => part.trim()).filter((part) => part !== "");
+  if (parts.length === 0) throw new Error("The shortcut binding needs its key.");
+  const modifiers = ["ctrl", "alt", "shift", "meta"];
+  const key = parts.filter((part) => !modifiers.includes(part))[0];
+  if (key === void 0 || key === "") throw new Error("The shortcut binding needs its key beside its modifiers.");
+  return { key, modifiers: parts.filter((part) => modifiers.includes(part)) };
+}
+function shortcuttext(binding) {
+  return [...binding.modifiers, binding.key].join("+");
+}
+function shortcutbindingafter(bindings, command, text2) {
+  const existing = bindings.find((binding) => binding.command === command);
+  if (existing === void 0) throw new Error(`The shortcutkeys know no ${command} command to edit.`);
+  const parsed = parseshortcut(text2);
+  return bindings.map((binding) => binding.command === command ? { ...binding, key: parsed.key, modifiers: parsed.modifiers } : binding);
+}
+function shortcutcommandof(bindings, input) {
+  const pressed = [...input.modifiers].map((modifier) => modifier.toLowerCase()).sort();
+  return bindings.find((binding) => binding.key.toLowerCase() === input.key.toLowerCase() && [...binding.modifiers].sort().join("+") === pressed.join("+") && (binding.command === "commandpalette" || binding.surface === input.surface))?.command;
+}
+function shortcutdispatchable(command, entries, input) {
+  const entry = entries.find((candidate) => candidate.action.command === command);
+  if (entry === void 0) return command === "commandpalette";
+  return paletteactiongate({ action: { command: entry.action.command, ...entry.action.permission !== void 0 ? { permission: entry.action.permission } : {}, ...entry.action.session !== void 0 ? { session: entry.action.session } : {} }, granted: input.granted, sessionactive: input.sessionactive }).allowed;
+}
+function parseomniboxtask(input) {
+  const text2 = input.text.trim();
+  if (text2 === "") throw new Error("The omnibox task needs its natural language goal after the keyword.");
+  if (input.origin.trim() === "") throw new Error("The omnibox task needs its active origin scope.");
+  return { id: randomid(), text: text2, origin: input.origin.trim(), surface: "omnibox", at: input.at };
+}
+function omniboxtasktotaskinput(submission) {
+  return { id: submission.id, text: submission.text, context: "", origin: submission.origin, surface: "omnibox", at: submission.at };
+}
+
+// statusviews.ts
+function statusbadgeof(input) {
+  if (input.planstate === void 0) return { state: "idle", waitingcount: 0 };
+  if (input.waitingcount > 0) return { state: "attention", waitingcount: input.waitingcount, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  if (input.planstate === "approved") return { state: "running", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  if (input.planstate === "pending") return { state: "waiting", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  return { state: "idle", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+}
+function badgetextof(state) {
+  if (state.state === "attention") return String(state.waitingcount);
+  if (state.state === "running") return "run";
+  if (state.state === "waiting") return "wait";
+  return "";
+}
+function badgecolorof(state) {
+  if (state.state === "attention") return "#b3261e";
+  if (state.state === "running") return "#1a73e8";
+  if (state.state === "waiting") return "#e37400";
+  return "#5f6368";
+}
+function notifydoneof(input) {
+  if (input.runid.trim() === "") throw new Error("The done notification needs its run id.");
+  return { id: randomid(), kind: "done", title: "The run completed", body: input.summary.trim() === "" ? `The run of ${input.origin} completed; the runsummary holds every step outcome.` : input.summary, deeplink: `#run-${input.runid}`, runid: input.runid, content: false, at: input.at };
+}
+function notifyattentionof(input) {
+  if (input.stepid.trim() === "") throw new Error("The attention notification needs its waiting step.");
+  const gate = notificationcontentgate({ content: input.content === true, consent: input.consent === true });
+  if (!gate.allowed) throw new Error(gate.reason ?? "The attention notification refuses its page content.");
+  return { id: randomid(), kind: "attention", title: input.cause === "gatewait" ? "The run waits for review" : input.cause === "phishguard" ? "The phishguard blocked a step" : "The run deferred a step", body: input.reason, deeplink: `#step-${input.stepid}`, runid: input.runid, stepid: input.stepid, content: input.content === true, at: input.at };
+}
+function notificationrespectsdnd(payload, dnd) {
+  if (dnd) return { show: false, reason: `The os stays in do not disturb, so the ${payload.kind} notification holds its deep link ${payload.deeplink} in the history instead of showing.` };
+  return { show: true, reason: `The ${payload.kind} notification shows with its deep link ${payload.deeplink}.` };
+}
+function recenttrayentryof(input) {
+  if (input.runid.trim() === "") throw new Error("The recenttray entry needs its run id.");
+  return { runid: input.runid, origin: input.origin, outcome: input.outcome, title: input.title, at: input.at, resumable: input.outcome === "halted", reopenable: input.outcome === "completed" || input.outcome === "failed" };
+}
+function recenttrayactions(entry) {
+  const actions = [];
+  if (entry.resumable) actions.push("resume");
+  if (entry.reopenable) actions.push("reopen");
+  return actions;
+}
+function stetoastof(input) {
+  if (input.stepid.trim() === "") throw new Error("The stetoast needs its step.");
+  return { id: randomid(), stepid: input.stepid, kind: input.kind, durationms: input.durationms, at: input.at };
+}
+function stetoaststackafter(toasts, toast, livecount) {
+  const history2 = [...toasts, toast];
+  if (livecount === void 0 || !Number.isInteger(livecount) || livecount <= 0) return { live: history2, history: history2 };
+  return { live: history2.slice(-livecount), history: history2 };
+}
+function stetoasthistory(toasts) {
+  return [...toasts].reverse();
+}
+
+// pickerviews.ts
+function stabilityscoreof(input) {
+  let score = 0;
+  if (input.hasid) score += 40;
+  if (input.hasstableattributes) score += 25;
+  if (input.hasrole) score += 15;
+  if (input.textunique) score += 10;
+  if (input.selector.trim() === "") score -= 20;
+  else if (input.selector.includes(":nth-child") || input.selector.includes(":nth-of-type")) score -= 15;
+  return Math.max(0, Math.min(100, score));
+}
+function pickercandidateof(input) {
+  const score = stabilityscoreof(input);
+  const reasons = [];
+  if (input.hasid) reasons.push("the id anchors the selector");
+  if (input.hasstableattributes) reasons.push("stable attributes back the selector");
+  if (input.hasrole) reasons.push("the aria role names the element");
+  if (input.textunique) reasons.push("the text stays unique on the page");
+  if (reasons.length === 0) reasons.push("only the positional shape anchors the selector");
+  return { selector: input.selector, ...input.text !== void 0 && input.text !== "" ? { text: input.text } : {}, ...input.role !== void 0 && input.role !== "" ? { role: input.role } : {}, stabilityscore: score, reason: `The stability score of ${score} stands because ${reasons.join(", ")}.` };
+}
+function pickersessionstart(input) {
+  const gate = pickeroverlaygate({ origin: input.origin, granted: input.granted });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { id: randomid(), origin: input.origin, candidates: rankcandidates(input.candidates), startedat: input.at };
+}
+function rankcandidates(candidates) {
+  return [...candidates].sort((left, right) => right.stabilityscore - left.stabilityscore);
+}
+function haloof(input) {
+  if (input.selector.trim() === "") throw new Error("The targethalo needs its target selector.");
+  return { stepid: input.stepid, selector: input.selector, rect: input.rect, state: input.state };
+}
+function halocolorof(state) {
+  if (state === "running") return "#1a73e8";
+  if (state === "waiting") return "#e37400";
+  if (state === "done") return "#188038";
+  if (state === "failed") return "#b3261e";
+  if (state === "halted") return "#3c4043";
+  return "#5f6368";
+}
+function guidedtips() {
+  return [
+    { id: "selectorstability", surface: "sidepanel", title: "Selector stability", body: "Devthink scores every candidate selector by its stability: an id anchor, stable attributes, an aria role and a unique text each lift the score while a positional shape lowers it, so the proposed step binds to the selector least likely to break.", pickerstep: "candidatepick" },
+    { id: "candidatelock", surface: "sidepanel", title: "Locking a candidate", body: "Lock one candidate to bind it to the proposed step; one picker session locks one candidate and the locked selector rides the step for its review.", pickerstep: "candidatelock" },
+    { id: "haloreadout", surface: "sidepanel", title: "The halo read out", body: "During a run the targethalo outlines the active target element and its color follows the step state: gray while pending, blue while running, amber at a gate, green when done, red on failure and dark when halted.", pickerstep: "halotracking" }
+  ];
+}
+function guidedtipdismiss(tips, dismissed, tipid) {
+  const tip = tips.find((candidate) => candidate.id === tipid);
+  if (tip === void 0) throw new Error(`The guidedtips know no ${tipid} tip.`);
+  return [.../* @__PURE__ */ new Set([...dismissed, tipid])];
+}
+function guidedtiprecall(dismissed) {
+  return [];
+}
+function pagechipof(input) {
+  if (input.stepid.trim() === "") throw new Error("The pagechip needs its step.");
+  if (input.selector.trim() === "") throw new Error("The pagechip needs its anchor selector.");
+  return { id: randomid(), stepid: input.stepid, selector: input.selector, origin: input.origin, at: input.at };
+}
+function pagechipresolve(chip, resolution, surface, at) {
+  if (surface === "background") throw new Error("The pagechip resolution needs its distinct human action from a surface; the background never resolves a review on its own.");
+  const resolved = { ...chip, resolution, resolvedat: at };
+  return {
+    chip: resolved,
+    logevent: { kind: "review", stepid: chip.stepid, summary: `The user ${resolution === "approve" ? "approved" : "rejected"} the step ${chip.stepid} of ${chip.origin} from the pagechip anchored to ${chip.selector} on the ${surface}; one distinct human action resolved the step alone.` }
+  };
+}
+
+// evidenceviews.ts
+function shotpanelof(input) {
+  const gate = shotpanelgate({ captureorigin: input.origin, granted: input.granted });
+  if (!gate.allowed) throw new Error(gate.reason);
+  if (input.stepid.trim() === "") throw new Error("The shotpanel view needs its step.");
+  return { id: randomid(), stepid: input.stepid, runid: input.runid, captureid: input.captureid, provenance: input.provenance, origin: input.origin, redactions: input.redactions ?? [], zoom: 1, pan: { x: 0, y: 0 }, at: input.at };
+}
+function comparepairof(input) {
+  if (input.stepid.trim() === "") throw new Error("The compareviewer pair needs its step.");
+  if (input.beforecaptureid === input.aftercaptureid) throw new Error("The compareviewer pair needs its distinct before and after captures.");
+  return { id: randomid(), stepid: input.stepid, beforecaptureid: input.beforecaptureid, aftercaptureid: input.aftercaptureid, slidervalue: 50 };
+}
+
+// siteprefs.ts
+function siteprofileof(input) {
+  const gate = siteprofilegate({ origin: input.origin });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { origin: input.origin, ...input.theme !== void 0 ? { theme: input.theme } : {}, ...input.shortcuts !== void 0 ? { shortcuts: input.shortcuts } : {}, ...input.defaultview !== void 0 ? { defaultview: input.defaultview } : {}, updatedat: input.at };
+}
+function siteprofileactive(profile, origin) {
+  return profile.origin === origin;
+}
+function siteprofilefor(profiles, origin) {
+  return profiles.find((profile) => siteprofileactive(profile, origin));
+}
+function darklighttokensof(mode) {
+  const tokens = mode === "dark" ? { surface: "#1f1f1f", elevated: "#2b2b2b", text: "#e3e3e3", muted: "#9aa0a6", accent: "#8ab4f8", border: "#3c4043", focus: "#aecbfa", error: "#f28b82", success: "#81c995", warning: "#fdd663" } : { surface: "#ffffff", elevated: "#f8f9fa", text: "#202124", muted: "#5f6368", accent: "#1a73e8", border: "#dadce0", focus: "#174ea6", error: "#b3261e", success: "#188038", warning: "#e37400" };
+  return { mode, tokens };
+}
+function resolveappearance(input) {
+  if (input.siteprofile?.theme !== void 0 && input.siteprofile.theme !== "system") return { ...darklighttokensof(input.siteprofile.theme), source: "site" };
+  if (input.useroverride !== void 0 && input.useroverride !== "system") return { ...darklighttokensof(input.useroverride), source: "user" };
+  return { ...darklighttokensof(input.ospreference), source: "os" };
+}
+function localebundles() {
+  return [
+    {
+      language: "en",
+      strings: {
+        "popup.title": "Devthink",
+        "popup.taskinput.placeholder": "Describe the goal for the active tab",
+        "popup.taskinput.submit": "Propose the plan",
+        "popup.palette.open": "Open the commandpalette",
+        "popup.recent.title": "Recent runs",
+        "popup.recent.resume": "Resume",
+        "popup.recent.reopen": "Reopen",
+        "sidepanel.tab.plan": "Plan",
+        "sidepanel.tab.run": "Run",
+        "sidepanel.tab.review": "Review",
+        "sidepanel.data.export": "Export",
+        "dashboard.title": "Dashboard",
+        "options.title": "Options",
+        "options.theme.label": "Theme",
+        "options.theme.dark": "Dark",
+        "options.theme.light": "Light",
+        "options.theme.system": "Follow the system",
+        "options.locale.label": "Language",
+        "options.shortcuts.label": "Shortcutkeys",
+        "options.notifications.label": "Notifications",
+        "options.importexport.label": "Import and export",
+        "options.tour.label": "Feature tour",
+        "stepapprove.approve": "Approve",
+        "stepapprove.reject": "Reject",
+        "stepapprove.edit": "Edit",
+        "pagechip.approve": "Approve",
+        "pagechip.reject": "Reject",
+        "grid.empty": "No extracted rows yet",
+        "toast.stepdone": "Step completed"
+      }
+    },
+    {
+      language: "pt",
+      strings: {
+        "popup.title": "Devthink",
+        "popup.taskinput.placeholder": "Descreva o objetivo para a aba ativa",
+        "popup.taskinput.submit": "Propor o plano",
+        "popup.palette.open": "Abrir a paleta de comandos",
+        "popup.recent.title": "Execu\xE7\xF5es recentes",
+        "popup.recent.resume": "Retomar",
+        "popup.recent.reopen": "Reabrir",
+        "sidepanel.tab.plan": "Plano",
+        "sidepanel.tab.run": "Execu\xE7\xE3o",
+        "sidepanel.tab.review": "Revis\xE3o",
+        "sidepanel.data.export": "Exportar",
+        "dashboard.title": "Painel",
+        "options.title": "Op\xE7\xF5es",
+        "options.theme.label": "Tema",
+        "options.theme.dark": "Escuro",
+        "options.theme.light": "Claro",
+        "options.theme.system": "Seguir o sistema",
+        "options.locale.label": "Idioma",
+        "options.shortcuts.label": "Atalhos",
+        "options.notifications.label": "Notifica\xE7\xF5es",
+        "options.importexport.label": "Importar e exportar",
+        "options.tour.label": "Tour de recursos",
+        "stepapprove.approve": "Aprovar",
+        "stepapprove.reject": "Rejeitar",
+        "stepapprove.edit": "Editar",
+        "pagechip.approve": "Aprovar",
+        "pagechip.reject": "Rejeitar",
+        "grid.empty": "Nenhuma linha extra\xEDda ainda",
+        "toast.stepdone": "Etapa conclu\xEDda"
+      }
+    }
+  ];
+}
+function localestring(bundles, language, key) {
+  const requested = bundles.find((bundle) => bundle.language === language);
+  const english = bundles.find((bundle) => bundle.language === "en");
+  return requested?.strings[key] ?? english?.strings[key] ?? key;
+}
+function supportedlanguages(bundles) {
+  return bundles.map((bundle) => bundle.language);
+}
+function localeformat(input) {
+  if (input.kind === "date") {
+    const date = new Date(input.value);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    return input.language === "pt" ? `${day}/${month}/${year} ${hours}:${minutes}` : `${year}-${month}-${day} ${hours}:${minutes}`;
+  }
+  if (input.kind === "duration") {
+    const seconds = Math.round(input.value / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return input.language === "pt" ? `${minutes} min ${rest} s` : `${minutes}m ${rest}s`;
+  }
+  const text2 = String(input.value);
+  const parts = text2.split(".");
+  const whole = parts[0] ?? "0";
+  const fraction = parts[1];
+  const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, input.language === "pt" ? "." : ",");
+  return fraction !== void 0 ? `${grouped}${input.language === "pt" ? "," : "."}${fraction}` : grouped;
+}
+
+// portability.ts
+function importexportpayloadof(input) {
+  if (input.profile.trim() === "") throw new Error("The importexport payload needs its profile name.");
+  const secrets = [...input.originprofiles, ...input.siteprofiles, ...input.notes, ...Object.values(input.preferences)].find((record2) => secretcarrying(record2)) !== void 0;
+  const gate = importexportgate({ containssecrets: secrets, unmaskedlogs: false });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { version: 1, kind: "settings", profile: input.profile.trim(), exportedat: input.at, contents: { originprofiles: input.originprofiles, siteprofiles: input.siteprofiles, notes: input.notes, preferences: input.preferences }, exclusions: ["secretvault values", "unmasked logs"] };
+}
+function secretcarrying(record2) {
+  if (record2 === null || typeof record2 !== "object") return false;
+  const entries = Object.entries(record2);
+  const secretkeys = ["secret", "token", "password", "apikey", "authorization"];
+  return entries.some(([key, value]) => secretkeys.some((shape) => key.toLowerCase().includes(shape)) && typeof value === "string" && value.trim() !== "");
+}
+function importexportvalidate(payload) {
+  const records = [...payload.contents.originprofiles, ...payload.contents.siteprofiles, ...payload.contents.notes, ...Object.values(payload.contents.preferences)];
+  const preferencessecrets = Object.entries(payload.contents.preferences).some(([key, value]) => secretcarrying({ [key]: value }));
+  const gate = importexportgate({ containssecrets: records.some((record2) => secretcarrying(record2)) || preferencessecrets, unmaskedlogs: payload.contents.unmaskedlogs !== void 0 });
+  if (!gate.allowed) return { ok: false, reason: gate.reason ?? "The importexport bundle refuses." };
+  if (payload.profile.trim() === "") return { ok: false, reason: "The importexport bundle needs its profile name." };
+  return { ok: true, reason: `The importexport bundle of the profile ${payload.profile} validates with ${payload.contents.originprofiles.length} origin profile${payload.contents.originprofiles.length === 1 ? "" : "s"}, ${payload.contents.siteprofiles.length} site profile${payload.contents.siteprofiles.length === 1 ? "" : "s"} and ${payload.contents.notes.length} note${payload.contents.notes.length === 1 ? "" : "s"}; ${payload.exclusions.join(" and ")} never enter any bundle.` };
+}
+function applyimport(payload, current) {
+  const validation = importexportvalidate(payload);
+  if (!validation.ok) throw new Error(validation.reason);
+  const applied = Object.keys(payload.contents.preferences);
+  return { preferences: { ...current, ...payload.contents.preferences }, applied };
+}
+function detectfilekind(filename, head) {
+  const extension = filename.toLowerCase().split(".").pop() ?? "";
+  if (extension === "csv") return "csv";
+  if (extension === "json") {
+    const trimmed = head.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) return trimmed.includes('"steps"') ? "workflow" : "json";
+    return "json";
+  }
+  if (extension === "yaml" || extension === "yml") return "workflow";
+  return void 0;
+}
+function dropimportof(input) {
+  if (input.filename.trim() === "") throw new Error("The dropimport session needs its filename.");
+  const kind = detectfilekind(input.filename, input.head);
+  if (kind === void 0) throw new Error(`The dropimport detects no csv, json or workflow kind in ${input.filename}; the import path refuses the file.`);
+  return { id: `${input.filename}:${input.at}`, filename: input.filename, kind, bytes: input.bytes, accepted: true, at: input.at };
+}
+
+// tourviews.ts
+function featuretourstops() {
+  return [
+    { id: "origingrants", surface: "popup", focus: "#allowlist", title: "Origin grants", body: "Devthink denies automation by default; grant one exact origin at a time and every run stays inside the granted origins.", order: 1 },
+    { id: "planreview", surface: "sidepanel", focus: "#plancards", title: "Plan review", body: "Every task becomes a plan of reviewed steps; read the plancards of each risk class and approve, reject or edit one step at a time.", order: 2 },
+    { id: "runcontrol", surface: "sidepanel", focus: "#timeline", title: "Run control", body: "Runs start, pause, resume and cancel under your hand while the stepstimeline follows every transition.", order: 3 },
+    { id: "logaudit", surface: "dashboardpage", focus: "#sessiongrid", title: "Log audit", body: "The immutable log chains every step transition with masked values; verify the chain and copy a verified range as an audit excerpt.", order: 4 },
+    { id: "datagrid", surface: "sidepanel", focus: "#datagrid", title: "The datagrid", body: "Extraction results render as a grid with inferred column types; sort and filter locally, select a row range and export csv, json or clipboard with masked values only.", order: 5 },
+    { id: "compareviewer", surface: "sidepanel", focus: "#compareviewer", title: "The compareviewer", body: "Every executed write step pairs its before and after captures; the slider overlays the two so you see exactly what the step changed.", order: 6 },
+    { id: "pickeroverlay", surface: "sidepanel", focus: "#picker", title: "The pickeroverlay", body: "Start a picker session to list the element candidates of the granted origin with stability scored selectors; lock one candidate for the proposed step.", order: 7 }
+  ];
+}
+function featuretourordered(stops) {
+  return [...stops].sort((left, right) => left.order - right.order);
+}
+function a11ylabelof(input) {
+  if (input.control.trim() === "") throw new Error("The a11ylabel needs its control.");
+  if (input.name.trim() === "") throw new Error("The a11ylabel needs its accessible name.");
+  return { control: input.control, role: input.role, name: input.name, ...input.state !== void 0 ? { state: input.state } : {}, ...input.value !== void 0 ? { value: input.value } : {} };
+}
+function a11ylabelsfor(surface) {
+  const labels = {
+    popup: [
+      a11ylabelof({ control: "taskinput", role: "textbox", name: "popup.taskinput.placeholder", state: "idle" }),
+      a11ylabelof({ control: "submit", role: "button", name: "popup.taskinput.submit" }),
+      a11ylabelof({ control: "palette", role: "button", name: "popup.palette.open" }),
+      a11ylabelof({ control: "recenttray", role: "list", name: "popup.recent.title", value: "0 runs" })
+    ],
+    sidepanel: [
+      a11ylabelof({ control: "plantab", role: "tab", name: "sidepanel.tab.plan", state: "selected" }),
+      a11ylabelof({ control: "runtab", role: "tab", name: "sidepanel.tab.run", state: "unselected" }),
+      a11ylabelof({ control: "reviewtab", role: "tab", name: "sidepanel.tab.review", state: "unselected" }),
+      a11ylabelof({ control: "datagrid", role: "table", name: "grid.empty" }),
+      a11ylabelof({ control: "compareviewer", role: "slider", name: "sidepanel.data.compare", value: "50" }),
+      a11ylabelof({ control: "picker", role: "button", name: "sidepanel.data.picker" })
+    ],
+    dashboardpage: [
+      a11ylabelof({ control: "sessiongrid", role: "table", name: "dashboard.title", value: "0 runs" }),
+      a11ylabelof({ control: "historysearch", role: "search", name: "dashboard.history" }),
+      a11ylabelof({ control: "dropzone", role: "region", name: "options.importexport.label" })
+    ],
+    optionspage: [
+      a11ylabelof({ control: "theme", role: "radiogroup", name: "options.theme.label", value: "system" }),
+      a11ylabelof({ control: "locale", role: "combobox", name: "options.locale.label", value: "en" }),
+      a11ylabelof({ control: "shortcuts", role: "group", name: "options.shortcuts.label" }),
+      a11ylabelof({ control: "notifications", role: "switch", name: "options.notifications.label", state: "off" }),
+      a11ylabelof({ control: "importexport", role: "region", name: "options.importexport.label" }),
+      a11ylabelof({ control: "tour", role: "button", name: "options.tour.label" })
+    ],
+    onboarding: [
+      a11ylabelof({ control: "onboarding", role: "dialog", name: "options.tour.label", state: "open" })
+    ],
+    omnibox: [
+      a11ylabelof({ control: "omnibox", role: "textbox", name: "popup.taskinput.placeholder" })
+    ],
+    page: [
+      a11ylabelof({ control: "pagechip", role: "group", name: "pagechip.approve", state: "pending" })
+    ]
+  };
+  return labels[surface];
+}
+function a11ylabellocalized(label, bundles, language) {
+  return { ...label, name: localestring(bundles, language, label.name) };
+}
+function a11ylabelslocalizedfor(surface, bundles, language) {
+  return a11ylabelsfor(surface).map((label) => a11ylabellocalized(label, bundles, language));
+}
+
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
 function buildrequest(input) {
@@ -14510,6 +15235,385 @@ function connectallowlist(entries) {
   return entries.map((entry) => ({ senderid: entry.senderid, displayname: entry.displayname, ...entry.origin !== void 0 ? { origin: entry.origin } : {}, addedat: entry.addedat }));
 }
 
+// flowlibrary.ts
+async function sha2563(payload) {
+  const bytes = new TextEncoder().encode(payload);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function manifestbody(manifest) {
+  return JSON.stringify({ id: manifest.id, title: manifest.title, description: manifest.description, version: manifest.version, publisher: manifest.publisher, ...manifest.registry !== void 0 ? { registry: manifest.registry } : {}, steps: manifest.steps, kinds: manifest.kinds, requiredgrants: manifest.requiredgrants, dataexpectations: manifest.dataexpectations, sensitive: manifest.sensitive });
+}
+async function manifestdigest(manifest) {
+  const { publish, ...body } = manifest;
+  void publish;
+  return sha2563(manifestbody(body));
+}
+async function validatemanifest(input) {
+  const errors = [];
+  const raw = input.manifest;
+  if (!Boolean(raw) || typeof raw !== "object" || Array.isArray(raw)) return { ok: false, errors: [{ path: "manifest", expected: "object", found: Array.isArray(raw) ? "array" : typeof raw, reason: "Every flowlibrary manifest travels as one plain object." }], reason: "The flowlibrary manifest is no plain object; schemastrict refuses the carrier before any import." };
+  const candidate = raw;
+  if (typeof candidate.id !== "string" || candidate.id.trim() === "") errors.push({ path: "id", expected: "string", found: typeof candidate.id, reason: "The flowlibrary manifest needs its id." });
+  if (typeof candidate.title !== "string" || candidate.title.trim() === "") errors.push({ path: "title", expected: "string", found: typeof candidate.title, reason: "The flowlibrary manifest needs its title." });
+  if (typeof candidate.description !== "string") errors.push({ path: "description", expected: "string", found: typeof candidate.description, reason: "The flowlibrary manifest needs its description." });
+  if (typeof candidate.version !== "string" || candidate.version.trim() === "") errors.push({ path: "version", expected: "string", found: typeof candidate.version, reason: "The flowlibrary manifest needs its version." });
+  if (typeof candidate.publisher !== "string" || candidate.publisher.trim() === "") errors.push({ path: "publisher", expected: "string", found: typeof candidate.publisher, reason: "The flowlibrary manifest names its publisher." });
+  if (!Array.isArray(candidate.steps) || candidate.steps.length === 0) errors.push({ path: "steps", expected: "array", found: Array.isArray(candidate.steps) ? "empty array" : typeof candidate.steps, reason: "The flowlibrary manifest declares its steps." });
+  if (Array.isArray(candidate.steps)) {
+    candidate.steps.forEach((step, index) => {
+      const shape = step;
+      if (!Boolean(shape) || typeof shape !== "object" || typeof shape.id !== "string" || shape.id.trim() === "" || typeof shape.kind !== "string" || shape.kind.trim() === "" || typeof shape.label !== "string") errors.push({ path: `steps.${index}`, expected: "flowlibrarystep", found: typeof step, reason: "Every flowlibrary step needs its id, kind and label." });
+    });
+  }
+  if (!Array.isArray(candidate.kinds) || candidate.kinds.length === 0) errors.push({ path: "kinds", expected: "array", found: typeof candidate.kinds, reason: "The flowlibrary manifest declares the action kinds its steps use." });
+  if (!Array.isArray(candidate.requiredgrants)) errors.push({ path: "requiredgrants", expected: "array", found: typeof candidate.requiredgrants, reason: "The flowlibrary manifest declares its required origin grants." });
+  if (!Array.isArray(candidate.dataexpectations)) errors.push({ path: "dataexpectations", expected: "array", found: typeof candidate.dataexpectations, reason: "The flowlibrary manifest declares its data expectations with minimization hints." });
+  if (typeof candidate.sensitive !== "boolean") errors.push({ path: "sensitive", expected: "boolean", found: typeof candidate.sensitive, reason: "The flowlibrary manifest marks whether it is sensitive." });
+  const unknownfields = Object.keys(candidate).filter((key) => !["id", "title", "description", "version", "publisher", "registry", "steps", "kinds", "requiredgrants", "dataexpectations", "sensitive", "publish"].includes(key));
+  for (const field of unknownfields) errors.push({ path: field, expected: "absent", found: "present", reason: `The flowlibrary manifest carries the unknown field ${field}; schemastrict refuses unknown fields.` });
+  const schemagate = librarymanifestgate({ errors });
+  if (!schemagate.allowed) return { ok: false, errors, reason: schemagate.reason ?? "The flowlibrary manifest fails schemastrict." };
+  const manifest = { id: candidate.id, title: candidate.title, description: candidate.description, version: candidate.version, publisher: candidate.publisher, ...typeof candidate.registry === "string" && candidate.registry.trim() !== "" ? { registry: candidate.registry } : {}, steps: candidate.steps.map((step) => ({ id: step.id, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, ...step.namespace !== void 0 ? { namespace: step.namespace } : {} })), kinds: candidate.kinds, requiredgrants: candidate.requiredgrants, dataexpectations: candidate.dataexpectations, sensitive: candidate.sensitive, ...isPublish(candidate.publish) ? { publish: candidate.publish } : {} };
+  const kinds = [...new Set(manifest.steps.map((step) => step.kind))];
+  const capabilitygate = librarycapabilitygate({ kinds, capabilities: input.capabilities });
+  if (!capabilitygate.allowed) return { ok: false, errors: [], reason: capabilitygate.reason ?? "", manifest };
+  return { ok: true, errors: [], reason: `The manifest ${manifest.id} of ${manifest.publisher} validates under schemastrict with ${manifest.steps.length} step${manifest.steps.length === 1 ? "" : "s"} and ${kinds.length} kind${kinds.length === 1 ? "" : "s"} inside the installed capability set.`, manifest };
+}
+function isPublish(value) {
+  if (!Boolean(value) || typeof value !== "object") return false;
+  const shape = value;
+  return typeof shape.publisher === "string" && shape.publisher.trim() !== "" && typeof shape.signature === "string" && shape.signature.trim() !== "" && typeof shape.digest === "string" && shape.digest.trim() !== "" && typeof shape.provenance === "string" && typeof shape.publishedat === "number";
+}
+async function verifypublishersignature(manifest) {
+  if (manifest.publish === void 0) return { verified: false, reason: `The manifest ${manifest.id} of ${manifest.publisher} carries no publisher signature; the entry quarantines until the user verifies its publisher.` };
+  const digest = await manifestdigest(manifest);
+  if (manifest.publish.digest !== digest) return { verified: false, reason: `The publisher signature of ${manifest.publish.publisher} covers the digest ${manifest.publish.digest} while the manifest body hashes to ${digest}; the verification refuses the signature in full.` };
+  if (manifest.publish.publisher !== manifest.publisher) return { verified: false, reason: `The publisher signature names ${manifest.publish.publisher} while the manifest carries the publisher ${manifest.publisher}; the verification refuses the signature in full.` };
+  const seal = await sha2563(`${manifest.publish.publisher}
+${manifest.publish.digest}
+${manifest.publish.provenance}`);
+  if (manifest.publish.signature !== seal) return { verified: false, reason: `The publisher signature of ${manifest.publish.publisher} seals neither the manifest digest nor its provenance; the verification refuses the signature in full.` };
+  return { verified: true, reason: `The publisher signature of ${manifest.publish.publisher} verifies over the manifest digest ${digest.slice(0, 12)}\u2026 with its provenance ${manifest.publish.provenance}.` };
+}
+async function libraryentryof(input) {
+  const digest = await manifestdigest(input.manifest);
+  const verification = await verifypublishersignature(input.manifest);
+  const quarantinegate = libraryquarantinegate({ verified: verification.verified, signaturepresent: input.manifest.publish !== void 0, signaturevalid: verification.verified });
+  const state = quarantinegate.allowed ? "available" : "quarantined";
+  return { id: `${input.manifest.id}@${input.manifest.version}`, manifest: input.manifest, digest, state, provenance: `${input.provenance}; ${verification.reason}`, addedat: input.now };
+}
+function grantdiffof(input) {
+  const required = [...new Set(input.manifest.requiredgrants)];
+  const added = required.filter((origin) => !input.heldgrants.includes(origin));
+  const kept = required.filter((origin) => input.heldgrants.includes(origin));
+  const originmappings = required.map((origin) => ({ origin, kinds: [...new Set(input.manifest.steps.map((step) => step.kind))] }));
+  return { added, kept, originmappings };
+}
+function sensitiveconsentfor(manifest, freshconsent) {
+  const gate = librarysensitivegate({ sensitive: manifest.sensitive, freshconsent });
+  return { required: manifest.sensitive, reason: gate.reason ?? "" };
+}
+function manifestrisk(manifest) {
+  let risk = "read";
+  for (const step of manifest.steps) {
+    const candidate = actionrisk(step.kind);
+    if (candidate === "sensitive") return "sensitive";
+    if (candidate === "interaction") risk = "interaction";
+  }
+  return risk;
+}
+function installlibrary(input) {
+  const manifest = input.entry.manifest;
+  const prefix = input.selectornamespace?.trim() ?? "";
+  const steps = manifest.steps.map((step) => ({
+    id: `${manifest.id}-${step.id}`,
+    kind: step.kind,
+    label: step.label,
+    ...step.target !== void 0 ? { target: prefix === "" ? step.target : `${prefix} ${step.target}`.trim() } : {},
+    ...step.value !== void 0 ? { value: step.value } : {}
+  }));
+  return { id: `library:${manifest.id}:${manifest.version}`, name: manifest.title, version: 1, origins: [...new Set(manifest.requiredgrants)], steps, blocks: [], risk: manifestrisk(manifest), reviewstate: "pending", createdat: input.now };
+}
+function updatelibrary(input) {
+  if (input.incoming.digest === input.existing.digest) return { changedsteps: [], addedgrants: [], versionfrom: input.existing.manifest.version, versionto: input.incoming.manifest.version, replace: false, reason: `The incoming ${input.incoming.manifest.id} carries the same manifest digest as the installed entry; the update replaces nothing.` };
+  const existingsteps = new Set(input.existing.manifest.steps.map((step) => step.id));
+  const incomingsteps = new Set(input.incoming.manifest.steps.map((step) => step.id));
+  const changedsteps = [.../* @__PURE__ */ new Set([...existingsteps, ...incomingsteps])].filter((id) => {
+    const before = input.existing.manifest.steps.find((step) => step.id === id);
+    const after = input.incoming.manifest.steps.find((step) => step.id === id);
+    return before === void 0 || after === void 0 || before.kind !== after.kind || before.target !== after.target || before.value !== after.value;
+  });
+  const addedgrants = [...new Set(input.incoming.manifest.requiredgrants)].filter((origin) => !input.existing.manifest.requiredgrants.includes(origin));
+  return { changedsteps, addedgrants, versionfrom: input.existing.manifest.version, versionto: input.incoming.manifest.version, replace: true, reason: `The update of ${input.incoming.manifest.id} from version ${input.existing.manifest.version} to ${input.incoming.manifest.version} changes ${changedsteps.length} step${changedsteps.length === 1 ? "" : "s"} and adds ${addedgrants.length} grant${addedgrants.length === 1 ? "" : "s"}; the version diff surfaces before the replace.` };
+}
+function removelibrary(input) {
+  return { removed: input.entry.id, keptforks: input.forks.map((fork) => fork.id), reason: `The library entry ${input.entry.manifest.title} leaves the store while its ${input.forks.length} local fork${input.forks.length === 1 ? "" : "s"} stay untouched; a fork is an independent local workflow.` };
+}
+function forklibrary(input) {
+  const manifest = input.entry.manifest;
+  const steps = manifest.steps.map((step) => ({ id: `fork-${step.id}`, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {} }));
+  return { id: `fork:${manifest.id}:${input.now}`, name: `${manifest.title} fork`, version: 1, origins: [...new Set(manifest.requiredgrants)], steps, blocks: [], risk: manifestrisk(manifest), reviewstate: "pending", createdat: input.now };
+}
+function librarysearch(input) {
+  const query = input.query?.trim().toLowerCase() ?? "";
+  return input.entries.filter((entry) => {
+    if (input.filter?.publisher !== void 0 && entry.manifest.publisher !== input.filter.publisher) return false;
+    if (input.filter?.sensitive !== void 0 && entry.manifest.sensitive !== input.filter.sensitive) return false;
+    if (input.filter?.state !== void 0 && entry.state !== input.filter.state) return false;
+    if (query === "") return true;
+    return [entry.manifest.title, entry.manifest.description, entry.manifest.publisher].some((text2) => text2.toLowerCase().includes(query));
+  });
+}
+function librarybrowserow(entry) {
+  return { id: entry.id, title: entry.manifest.title, publisher: entry.manifest.publisher, version: entry.manifest.version, grants: entry.manifest.requiredgrants, sensitive: entry.manifest.sensitive, state: entry.state, ...entry.manifest.registry !== void 0 ? { registry: entry.manifest.registry } : {} };
+}
+function librarystepsview(entry) {
+  return entry.manifest.steps.map((step) => {
+    const expectations = entry.manifest.dataexpectations.filter((expectation) => expectation.stepid === step.id);
+    return { id: step.id, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.namespace !== void 0 ? { namespace: step.namespace } : {}, families: expectations.map((expectation) => expectation.family), fields: [...new Set(expectations.flatMap((expectation) => expectation.fields))] };
+  });
+}
+function libraryeventof(input) {
+  if (input.entryid.trim() === "") throw new Error("The library event needs its entry id.");
+  return { id: `libraryevent:${input.kind}:${input.entryid}:${input.now}`, kind: input.kind, entryid: input.entryid, title: input.title, version: input.version, detail: input.detail, at: input.now };
+}
+
+// syncbridge.ts
+async function sha2564(payload) {
+  const bytes = new TextEncoder().encode(payload);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function syncdigestof(manifest) {
+  const { publish, ...body } = manifest;
+  void publish;
+  return sha2564(JSON.stringify(body));
+}
+function syncbridgehookof(input) {
+  if (input.endpoint.trim() === "") throw new Error(`The ${input.provider} hook needs its user configured endpoint; no provider address is ever hardcoded.`);
+  const gate = syncbridgeoptingate({ optin: false });
+  if (gate.allowed) throw new Error("The syncbridge hook never starts with its opt in on; no hook ever defaults on.");
+  return { id: `sync:${input.provider}:${input.now}`, provider: input.provider, direction: input.direction, optin: false, endpoint: input.endpoint.trim(), state: "idle", createdat: input.now };
+}
+function syncbridgeoptinflip(hook, optin) {
+  return { ...hook, optin, state: "idle" };
+}
+function syncbridgeproviders() {
+  return [
+    { provider: "file", label: "File provider", operations: ["pull", "push", "list"], note: "The file provider moves manifests through manual import and export files the user picks; the bridge carries no secret and no log entry under any flag." },
+    { provider: "web", label: "Web provider stub", operations: ["pull", "push", "list"], note: "The web provider stays a stub behind its opt in gate: the endpoint stays the user's configured registry value and no network call ships before the ecosystem part two backend exists." }
+  ];
+}
+async function syncbridgeexportpayload(manifests) {
+  const digests = [];
+  for (const manifest of manifests) digests.push(await syncdigestof(manifest));
+  return { version: 1, kind: "syncbridge", manifests, digests, exclusions: ["secretvault values", "logs"] };
+}
+function syncbridgevalidate(payload) {
+  const carriessecrets = payload.secrets !== void 0 || Array.isArray(payload.manifests) && payload.manifests.some((manifest) => secretcarrying2(manifest));
+  const gate = syncbridgescopegate({ carriessecrets, carrieslogs: payload.logs !== void 0 });
+  if (!gate.allowed) return { ok: false, reason: gate.reason ?? "The syncbridge payload refuses." };
+  if (payload.kind !== "syncbridge") return { ok: false, reason: "The syncbridge payload names its kind; a foreign payload never imports." };
+  if (!Array.isArray(payload.manifests)) return { ok: false, reason: "The syncbridge payload carries its manifest list." };
+  return { ok: true, reason: `The syncbridge payload carries ${payload.manifests.length} manifest${payload.manifests.length === 1 ? "" : "s"} and no secret and no log entry; the bridge moves manifests only.` };
+}
+function secretcarrying2(record2) {
+  if (record2 === null || typeof record2 !== "object") return false;
+  const entries = Object.entries(record2);
+  const secretkeys = ["secret", "token", "password", "apikey", "authorization"];
+  return entries.some(([key, value]) => secretkeys.some((shape) => key.toLowerCase().includes(shape)) && typeof value === "string" && value.trim() !== "");
+}
+async function syncbridgescan(input) {
+  const gate = syncbridgeoptingate({ optin: input.hook.optin });
+  if (!gate.allowed) return { conflicts: [], synced: [], reason: gate.reason ?? "" };
+  const conflicts = [];
+  const synced = [];
+  for (const remotemanifest of input.remote) {
+    const localmanifest = input.local.find((candidate) => candidate.manifestid === remotemanifest.manifestid);
+    if (localmanifest === void 0) {
+      synced.push(remotemanifest.manifestid);
+      continue;
+    }
+    if (localmanifest.digest === remotemanifest.digest) {
+      synced.push(remotemanifest.manifestid);
+      continue;
+    }
+    conflicts.push({ id: `conflict:${remotemanifest.manifestid}:${input.now}`, hookid: input.hook.id, manifestid: remotemanifest.manifestid, local: { digest: localmanifest.digest, version: localmanifest.version }, remote: { digest: remotemanifest.digest, version: remotemanifest.version }, detectedat: input.now });
+  }
+  return { conflicts, synced, reason: `The ${input.hook.provider} hook of ${input.hook.endpoint} scanned ${input.remote.length} remote manifest${input.remote.length === 1 ? "" : "s"} against ${input.local.length} local entr${input.local.length === 1 ? "y" : "ies"}: ${synced.length} moved while ${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"} surfaced both versions instead of a silent overwrite.` };
+}
+function webproviderstub(hook) {
+  const gate = syncbridgeoptingate({ optin: hook.optin });
+  return { hookid: hook.id, endpoint: hook.endpoint, optin: hook.optin, operations: ["pull", "push", "list"], stub: true, reason: gate.allowed ? `The web provider of ${hook.endpoint} stays a stub behind its explicit opt in; the ecosystem part two backend brings its network path.` : gate.reason ?? "" };
+}
+
+// attentionfeed.ts
+function attentionseverityof(cause) {
+  if (cause === "gatewait" || cause === "phishguard") return "critical";
+  if (cause === "deferral") return "warning";
+  return "info";
+}
+function attentiondeeplinkof(cause, runid, gateref) {
+  if (cause === "gatewait") return `devthink://gate/${encodeURIComponent(gateref ?? "unknown")}?run=${encodeURIComponent(runid)}`;
+  if (cause === "phishguard") return `devthink://phishguard?run=${encodeURIComponent(runid)}`;
+  if (cause === "deferral") return `devthink://deferred?run=${encodeURIComponent(runid)}`;
+  return `devthink://error?run=${encodeURIComponent(runid)}`;
+}
+function attentionentryof(input) {
+  if (input.runid.trim() === "") throw new Error("The attention entry needs its run ref.");
+  if (input.summary.trim() === "") throw new Error("The attention entry needs its summary in plain language.");
+  return { id: `attention:${input.cause}:${input.runid}:${input.gateref ?? "none"}`, cause: input.cause, severity: attentionseverityof(input.cause), runid: input.runid, ...input.gateref !== void 0 && input.gateref.trim() !== "" ? { gateref: input.gateref } : {}, origin: input.origin, summary: input.summary, deeplink: attentiondeeplinkof(input.cause, input.runid, input.gateref), at: input.at };
+}
+function dedupeattention(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const entry of [...entries].sort((a, b) => a.at - b.at)) {
+    const key = `${entry.cause}:${entry.runid}:${entry.gateref ?? "none"}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    kept.push(entry);
+  }
+  return kept;
+}
+function rankattention(entries) {
+  const order = { critical: 0, warning: 1, info: 2 };
+  return [...entries].sort((a, b) => order[a.severity] - order[b.severity] || b.at - a.at);
+}
+function attentioncountof(entries) {
+  return rankattention(dedupeattention(entries)).length;
+}
+function attentionnotifications(entries, now) {
+  return rankattention(dedupeattention(entries)).map((entry) => ({ id: `notify:${entry.id}`, kind: "attention", title: entry.cause === "gatewait" ? "A gate waits for you" : entry.cause === "phishguard" ? "The phishguard blocked a step" : entry.cause === "deferral" ? "A command deferred" : "A step failed", body: entry.summary, deeplink: entry.deeplink, runid: entry.runid, ...entry.gateref !== void 0 ? { stepid: entry.gateref } : {}, content: false, at: now }));
+}
+
+// backgroundruns.ts
+function backgroundqueueentryof(input) {
+  if (input.workflowid.trim() === "") throw new Error("The background queue entry needs its workflow id.");
+  return { id: `background:${input.workflowid}:${input.now}`, workflowid: input.workflowid, state: "queued", keepaliveheld: false, queuedat: input.now, summary: input.summary };
+}
+function enqueuebackgroundrun(input) {
+  return [...input.queue, backgroundqueueentryof({ workflowid: input.workflowid, summary: input.summary, now: input.now })];
+}
+function nextbackgroundrun(queue) {
+  return [...queue].filter((entry) => entry.state === "queued").sort((a, b) => a.queuedat - b.queuedat)[0];
+}
+function beginbackgroundrun(entry, now, reviewed) {
+  const gate = backgroundrungate({ reviewed, keepaliveheld: true });
+  return { entry: gate.allowed ? { ...entry, state: "running", keepaliveheld: true, startedat: now } : entry, gate: { allowed: gate.allowed, reason: gate.reason ?? "" } };
+}
+function finishbackgroundrun(entry, state, now) {
+  return { ...entry, state, keepaliveheld: false, endedat: now };
+}
+function resumebackgroundqueue(queue, now) {
+  const requeued = [];
+  const next = queue.map((entry) => {
+    if (entry.state !== "running") return entry;
+    requeued.push(entry.id);
+    const { startedat, ...rest } = entry;
+    void startedat;
+    return { ...rest, state: "queued", keepaliveheld: false };
+  });
+  void now;
+  return { queue: next, requeued };
+}
+function backgroundrunsview(queue) {
+  return queue.map((entry) => ({ id: entry.id, workflowid: entry.workflowid, state: entry.state, keepaliveheld: entry.keepaliveheld, queuedat: entry.queuedat, ...entry.startedat !== void 0 ? { startedat: entry.startedat } : {}, ...entry.endedat !== void 0 ? { endedat: entry.endedat } : {}, summary: entry.summary, progress: entry.state === "running" ? `Running with the keepalive signal held since ${entry.startedat ?? entry.queuedat}` : entry.state === "queued" ? "Queued for the next executor turn" : entry.state === "done" ? "Completed in the background" : "Failed; the attentionfeed carries the cause" }));
+}
+function backgroundtrayrows(queue, origin) {
+  return queue.filter((entry) => entry.state === "done" || entry.state === "failed").map((entry) => ({ runid: entry.id, origin, outcome: entry.state === "done" ? "completed" : "failed", title: `Background run of ${entry.workflowid}`, at: entry.endedat ?? entry.queuedat, resumable: false, reopenable: true }));
+}
+function cancelbackgroundentry(queue, id) {
+  const cancelled = [];
+  const next = queue.filter((entry) => {
+    if (entry.id === id && entry.state === "queued") {
+      cancelled.push(entry.id);
+      return false;
+    }
+    return true;
+  });
+  return { queue: next, cancelled };
+}
+
+// runreplay.ts
+function restoredrefsof(entry) {
+  const observation = /observation (\d+)/i.exec(entry.summary);
+  const capture = /capture ([a-z0-9-]+)/i.exec(entry.summary);
+  return { ...observation !== null ? { observationversion: Number(observation[1]) } : {}, ...capture !== null ? { captureid: capture[1] } : {} };
+}
+function replaystepof(entry, index, gates) {
+  const refs = restoredrefsof(entry);
+  return { stepid: entry.stepid ?? entry.id, index, summary: entry.summary, ...refs.observationversion !== void 0 ? { observationversion: refs.observationversion } : {}, ...refs.captureid !== void 0 ? { captureid: refs.captureid } : {}, gateresolutions: entry.stepid === void 0 ? [] : gates.filter((gate) => gate.gateid === entry.stepid) };
+}
+function runreplaysessionof(input) {
+  if (input.runid.trim() === "") throw new Error("The runreplay session needs its recorded run id.");
+  if (input.entries.length === 0) throw new Error("The runreplay session needs at least one verified log entry to walk.");
+  const steps = input.entries.map((entry, index) => replaystepof(entry, index, input.gates ?? []));
+  return { id: `replay:${input.runid}:${input.now}`, runid: input.runid, cursor: 0, playing: false, steps, openedat: input.now, actions: [] };
+}
+function replaymove(session, direction, now) {
+  const next = direction === "forward" ? Math.min(session.steps.length - 1, session.cursor + 1) : Math.max(0, session.cursor - 1);
+  const step = session.steps[next];
+  return { ...session, cursor: next, playing: false, actions: [...session.actions, { kind: "step", at: now, ...step !== void 0 ? { stepid: step.stepid } : {} }] };
+}
+function replayjump(session, stepid, now) {
+  const index = session.steps.findIndex((step) => step.stepid === stepid);
+  if (index === -1) throw new Error(`The runreplay knows no ${stepid} step in the recorded chain of ${session.runid}.`);
+  return { ...session, cursor: index, playing: false, actions: [...session.actions, { kind: "jump", stepid, at: now }] };
+}
+function replayplay(session, playing, now) {
+  return { ...session, playing, actions: [...session.actions, { kind: playing ? "play" : "pause", at: now }] };
+}
+function replayrestoredview(step) {
+  return { stepid: step.stepid, index: step.index, summary: step.summary, ...step.observationversion !== void 0 ? { observationversion: step.observationversion } : {}, ...step.captureid !== void 0 ? { captureid: step.captureid } : {}, gateresolutions: step.gateresolutions };
+}
+
+// outputcompare.ts
+function taskinputsignatureof(input) {
+  return `${input.objective.trim()}|${input.steps.length}|${input.steps.join(",")}`;
+}
+function comparemetricdefaults() {
+  return ["agreement", "divergence", "durationdelta"];
+}
+function joinruns(logsa, logsb) {
+  const sequence = [];
+  for (const entry of logsa) if (!sequence.includes(entry.stepid)) sequence.push(entry.stepid);
+  for (const entry of logsb) if (!sequence.includes(entry.stepid)) sequence.push(entry.stepid);
+  return sequence.map((stepid, index) => {
+    const a = logsa.find((entry) => entry.stepid === stepid);
+    const b = logsb.find((entry) => entry.stepid === stepid);
+    return { stepid, index, ...a !== void 0 ? { a } : {}, ...b !== void 0 ? { b } : {} };
+  });
+}
+function stepcomparisonof(pair) {
+  const a = pair.a;
+  const b = pair.b;
+  if (a === void 0 || b === void 0) return { stepid: pair.stepid, index: pair.index, agreement: "onlyone", summarya: a?.summary ?? "", summaryb: b?.summary ?? "", durationdelta: 0 };
+  const agree = a.state === b.state && a.summary === b.summary;
+  return { stepid: pair.stepid, index: pair.index, agreement: agree ? "agree" : "diverge", summarya: a.summary, summaryb: b.summary, durationdelta: a.duration - b.duration };
+}
+function firstdivergenceof(steps) {
+  const divergent = steps.find((step) => step.agreement !== "agree");
+  return divergent === void 0 ? void 0 : divergent.index;
+}
+function outputcomparesessionof(input) {
+  if (input.runids[0].trim() === "" || input.runids[1].trim() === "") throw new Error("The outputcompare session needs both run ids.");
+  if (input.runids[0] === input.runids[1]) throw new Error("The outputcompare session compares two distinct runs; one run never stands beside itself.");
+  const metrics = input.metrics ?? comparemetricdefaults();
+  const steps = joinruns(input.logsa, input.logsb).map((pair) => stepcomparisonof(pair));
+  const firstdivergence = firstdivergenceof(steps);
+  return { id: `compare:${input.runids[0]}:${input.runids[1]}:${input.now}`, runids: input.runids, metrics, steps, ...firstdivergence !== void 0 ? { firstdivergence } : {}, openedat: input.now };
+}
+function comparesessionmetrics(session) {
+  const agree = session.steps.filter((step) => step.agreement === "agree").length;
+  const diverge = session.steps.filter((step) => step.agreement === "diverge").length;
+  const onlyone = session.steps.filter((step) => step.agreement === "onlyone").length;
+  return { metrics: session.metrics, agree, diverge, onlyone, ...session.firstdivergence !== void 0 ? { firstdivergence: session.firstdivergence } : {}, reason: `The comparison of ${session.runids[0]} and ${session.runids[1]} graded ${agree} agreeing, ${diverge} divergent and ${onlyone} single run step${agree + diverge + onlyone === 1 ? "" : "s"} under the metric set ${session.metrics.join(", ")}${session.firstdivergence !== void 0 ? ` with the first divergence at step index ${session.firstdivergence}` : " with agreement across the whole sequence"}.` };
+}
+function outputcompareview(session) {
+  return session.steps.map((step) => ({ stepid: step.stepid, index: step.index, agreement: step.agreement, summarya: step.summarya, summaryb: step.summaryb, durationdelta: step.durationdelta, highlighted: session.firstdivergence !== void 0 && step.index === session.firstdivergence }));
+}
+
 // modelroute.ts
 function routevalid(route) {
   if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
@@ -15737,6 +16841,13 @@ function extensionpage(sender) {
 async function audit(kind, summary, extra = {}) {
   await memory.addaudi({ id: randomid(), kind, at: Date.now(), summary, ...extra });
   await recordsurfaceevent(kind, summary, extra);
+  if (kind === "session" || kind === "pause" || kind === "resume" || kind === "complete" || kind === "cancel" || kind === "gate" || kind === "notify" || kind === "attention" || kind === "backgroundrun") void updatestatusbadge().catch(() => {
+  });
+}
+async function recordattention(cause, runid, origin, summary, gateref) {
+  const entry = attentionentryof({ cause, runid, origin, summary, ...gateref !== void 0 && gateref.trim() !== "" ? { gateref } : {}, at: Date.now() });
+  await memory.addattentionentry(entry);
+  await audit("attention", `The attentionfeed collected ${entry.cause} of the run ${entry.runid}${entry.gateref !== void 0 ? ` at the gate ${entry.gateref}` : ""}: ${entry.summary} The deep link ${entry.deeplink} opens the exact waiting surface.`, { ...runid !== "" ? { planid: runid } : {} });
 }
 var surfacechannel = typeof BroadcastChannel === "function" ? new BroadcastChannel("devthinksurfaces") : void 0;
 var logstreamhistory = [];
@@ -16024,6 +17135,8 @@ async function confirmgatechain(step, session, plan, origin, classification, now
         await appendrunevent("gate", `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}: ${gateprompttext(gate)}`, session, origin, step.id).catch(() => {
         });
         await audit("gate", `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}; the executor pauses until one distinct human action resolves it and no timeout ever resolves a gate.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+        await recordattention("gatewait", plan.id, origin, `The ${gate.kind} gate of the ${step.kind} step ${step.id} waits for one human action; the executor pauses with no timeout.`, gate.gateid).catch(() => {
+        });
         return { allowed: false, reason: `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}: ${gateprompttext(gate)} The executor pauses until the human resolves it.` };
       }
     }
@@ -16049,6 +17162,8 @@ async function confirmgatechain(step, session, plan, origin, classification, now
         await appendrunevent("phish", `The phishguard blocked the credential step ${step.id} on ${origin}: ${verdict.reason}`, session, origin, step.id).catch(() => {
         });
         await audit("phish", `The phishguard blocked the ${step.kind} step ${step.id} on ${origin}: ${verdict.reason}`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+        await recordattention("phishguard", plan.id, origin, `The phishguard blocked the credential step ${step.id} on ${origin}: ${verdict.reason}`).catch(() => {
+        });
         return { allowed: false, reason: phishgate.reason ?? "" };
       }
     }
@@ -16063,6 +17178,8 @@ async function confirmgatechain(step, session, plan, origin, classification, now
       await appendrunevent("suspend", `The ratelimit bucket of ${origin} deferred the ${step.kind} step ${step.id} until the window resets at ${deferred.resetsat}: ${consumed.reason}`, session, origin, step.id).catch(() => {
       });
       await audit("defer", `The ratelimit bucket of ${origin} deferred the ${step.kind} step ${step.id} until the window resets at ${deferred.resetsat}; the bounds stay user configured choices with no hidden ceiling.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+      await recordattention("deferral", plan.id, origin, `The ratelimit bucket deferred the ${step.kind} step ${step.id} until the window resets at ${deferred.resetsat}.`).catch(() => {
+      });
       return { allowed: false, reason: consumed.reason };
     }
     await memory.saveratelimitbucket(consumed.bucket);
@@ -20908,10 +22025,16 @@ async function executeworkflowrun(step, session, plan, tabid2, origin, dry) {
       await audit("error", `The background run ${run.id} of the workflow ${record2.name} failed: ${reason}.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
       await refreshbadge().catch(() => {
       });
+    }).finally(() => {
+      void advancebackgroundqueue().catch(() => {
+      });
     });
     return { ok: true, summary: `The workflow run ${run.id} started in the background with ${record2.steps.length} reviewed steps and the panel may close; the checkpoints restore it on every worker wake.`, details: { runid: run.id, state: "running", background: true, executed: 0, total: record2.steps.length } };
   }
-  return await performworkflowrun({ record: record2, run, step, session, plan, tabid: tabid2, origin, options, dry });
+  const foregroundoutput = await performworkflowrun({ record: record2, run, step, session, plan, tabid: tabid2, origin, options, dry });
+  void advancebackgroundqueue().catch(() => {
+  });
+  return foregroundoutput;
 }
 function runcauseof(options) {
   const variables = options.variables;
@@ -21401,6 +22524,8 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
     const surface = errorsurfaceof({ stepid: step.id, runid: plan.id, message: summary, cause: classifyfailure({ message: summary, policyrefused: false, gatewait: false }), retryallowed: true, retryreason: "The failed step may dispatch again through the full consent gate chain.", context: { origin, kind: step.kind, environment: routing.environment }, now: Date.now() });
     await memory.adderrorsurface(surface).catch(() => {
     });
+    await recordattention("failure", plan.id, origin, `The ${step.kind} step ${step.id} failed: ${summary} The retry stays a reviewed dispatch.`).catch(() => {
+    });
     stepretry = { allowed: true, reason: `The ${surface.cause} failure of the step ${step.id} may retry through a new reviewed dispatch; the retry rides the full consent gate chain and never bypasses the review.` };
   }
   if (session) await appendrunevent("step", `The ${step.kind} step ${step.id} ${outcome.ok ? "completed" : "failed"} on ${origin}: ${summary}${securityverdict.classification.sensitive ? ` The step grades ${securityverdict.classification.reason}` : ""}`, session, origin, step.id).catch(() => {
@@ -21529,6 +22654,8 @@ var commandschemas = {
   environments: { action: "string", grants: "array", requestcapability: "boolean", pool: "object", offscreenclose: "boolean", sandbox: "object", settings: "object", render: "object", sandboxhost: "object" },
   transparency: {},
   surface: { palette: "object", task: "object", onboarding: "object", bus: "object", broadcast: "object", layout: "object", logstream: "object", approve: "object", diff: "object", review: "object", timeline: "object", dashboard: "object", settings: "object" },
+  views: { datagrid: "object", export: "object", quickaction: "object", shortcut: "object", omnibox: "object", badge: "object", notify: "object", recent: "object", picker: "object", halo: "object", tips: "object", shotpanel: "object", compare: "object", siteprofile: "object", theme: "object", locale: "object", importexport: "object", dropimport: "object", tour: "object", a11y: "object", chip: "object", toast: "object", settings: "object" },
+  ecosystem: { library: "object", sync: "object", attention: "object", replay: "object", compare: "object", background: "object", settings: "object" },
   execute: { stepid: "string" },
   configure: { endpoint: "string" }
 };
@@ -22028,6 +23155,709 @@ async function handlesurfacecommand(message) {
   }
   throw new Error("The surface command carries no palette, task, onboarding, bus, broadcast, layout, logstream, approve, diff, review, timeline, dashboard, snapshot or settings action.");
 }
+async function updatestatusbadge() {
+  try {
+    const plan = await memory.getplan();
+    const progress = await memory.getprogress();
+    const attentioncount = attentioncountof(await memory.getattentionentries());
+    const waitingcount = (plan !== void 0 && progress !== void 0 && progress.planid === plan.id ? Object.keys(progress.gatewaits ?? {}).length : 0) + attentioncount;
+    const state = statusbadgeof({ ...plan !== void 0 && (plan.state === "pending" || plan.state === "approved") ? { planstate: plan.state } : {}, waitingcount, ...plan !== void 0 ? { runid: plan.id } : {} });
+    await chrome.action.setBadgeText({ text: badgetextof(state) });
+    await chrome.action.setBadgeBackgroundColor({ color: badgecolorof(state) });
+  } catch {
+  }
+}
+function windowmatchmedia() {
+  const query = globalThis.matchMedia?.("(prefers-color-scheme: dark)");
+  return query?.matches === true ? "dark" : "light";
+}
+async function installedkindcapabilities() {
+  const granted = await grantedcapabilities();
+  return reviewedkinds().filter((kind) => {
+    const capability = requiredcapability(kind);
+    return capability === void 0 || granted.includes(capability);
+  });
+}
+async function ecosystemviewof() {
+  const entries = await memory.getflowlibrary();
+  const installed = entries.filter((entry) => entry.state === "installed");
+  const hooks = await memory.getsyncbridgehooks();
+  const conflicts = await memory.getsyncbridgeconflicts();
+  const attention = rankattention(await memory.getattentionentries()).slice(0, 50).map((entry) => ({ id: entry.id, cause: entry.cause, severity: entry.severity, runid: entry.runid, summary: entry.summary, deeplink: entry.deeplink, at: entry.at }));
+  const queue = await memory.getbackgroundqueue();
+  return ecosystemviews({
+    library: librarysearch({ entries }).map((entry) => librarybrowserow(entry)),
+    installed: installed.map((entry) => ({ id: entry.id, title: entry.manifest.title, version: entry.manifest.version, forkable: true })),
+    syncbridge: { hooks: hooks.map((hook) => ({ id: hook.id, provider: hook.provider, direction: hook.direction, optin: hook.optin, endpoint: hook.endpoint, state: hook.state })), conflicts: conflicts.filter((conflict) => conflict.resolution === void 0).map((conflict) => ({ id: conflict.id, manifestid: conflict.manifestid, localversion: conflict.local.version, remoteversion: conflict.remote.version, ...conflict.resolution !== void 0 ? { resolution: conflict.resolution } : {} })) },
+    attention,
+    backgroundruns: backgroundrunsview(queue)
+  });
+}
+async function handleecosystemcommand(message) {
+  const input = message;
+  const now = Date.now();
+  const session = await memory.getsession();
+  const settings = await memory.getsettings();
+  if (input.library !== void 0) {
+    const library = input.library;
+    if (library.browse !== void 0) {
+      const entries = librarysearch({ entries: await memory.getflowlibrary(), ...library.browse.query !== void 0 ? { query: library.browse.query } : {}, ...library.browse.publisher !== void 0 ? { filter: { publisher: library.browse.publisher } } : {}, ...library.browse.sensitive !== void 0 ? { filter: { sensitive: library.browse.sensitive } } : {}, ...library.browse.state !== void 0 ? { filter: { state: library.browse.state } } : {} });
+      await audit("library", `The dashboardpage browsed the flowlibrary with ${entries.length} matching entr${entries.length === 1 ? "y" : "ies"}; every row names its publisher, version, required grants and state.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...await ecosystemviewof(), rows: entries.map((entry) => librarybrowserow(entry)) };
+    }
+    if (library.entry !== void 0) {
+      const entry = (await memory.getflowlibrary()).find((candidate) => candidate.id === (library.entry?.entryid ?? ""));
+      if (!entry) throw new Error(`No flowlibrary entry matches ${library.entry.entryid ?? ""}.`);
+      return { entry, steps: librarystepsview(entry), expectations: entry.manifest.dataexpectations };
+    }
+    if (library.grants !== void 0) {
+      const entry = (await memory.getflowlibrary()).find((candidate) => candidate.id === (library.grants?.entryid ?? ""));
+      if (!entry) throw new Error(`No flowlibrary entry matches ${library.grants.entryid ?? ""}.`);
+      const grants = session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [];
+      const diff = grantdiffof({ manifest: entry.manifest, heldgrants: grants });
+      await audit("library", `The grant diff of ${entry.manifest.title} surfaces ${diff.added.length} added grant${diff.added.length === 1 ? "" : "s"} and ${diff.kept.length} held grant${diff.kept.length === 1 ? "" : "s"} before any import completes.`, { ...session ? { sessionid: session.id } : {} });
+      return { diff };
+    }
+    if (library.import !== void 0) {
+      const capabilities = await installedkindcapabilities();
+      const validation = await validatemanifest({ manifest: library.import.manifest, capabilities });
+      if (!validation.ok || validation.manifest === void 0) throw new Error(validation.reason);
+      const entry = await libraryentryof({ manifest: validation.manifest, provenance: `Imported from ${validation.manifest.registry ?? "a local file"} by the user`, now });
+      const stored = await memory.addlibraryentry(entry);
+      await audit("library", `The manifest ${entry.manifest.id} of ${entry.manifest.publisher} entered the flowlibrary as ${entry.state}${entry.state === "quarantined" ? "; the unverified publisher quarantines the entry until the user verifies it" : " with its verified publisher signature"}; the store deduplicates by the manifest digest and holds ${stored.length} entr${stored.length === 1 ? "y" : "ies"}.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...await ecosystemviewof(), entry };
+    }
+    if (library.install !== void 0) {
+      const entry = (await memory.getflowlibrary()).find((candidate) => candidate.id === (library.install?.entryid ?? ""));
+      if (!entry) throw new Error(`No flowlibrary entry matches ${library.install.entryid ?? ""}.`);
+      if (entry.state === "quarantined") {
+        const quarantinegate = libraryquarantinegate({ verified: false, signaturepresent: entry.manifest.publish !== void 0, signaturevalid: false });
+        throw new Error(quarantinegate.reason ?? "The quarantined entry never installs on its own.");
+      }
+      const capabilities = await installedkindcapabilities();
+      const capabilitygate = librarycapabilitygate({ kinds: [...new Set(entry.manifest.steps.map((step) => step.kind))], capabilities });
+      if (!capabilitygate.allowed) throw new Error(capabilitygate.reason);
+      const grants = session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [];
+      const grantgate = librarygrantgate({ requiredgrants: entry.manifest.requiredgrants, heldgrants: grants });
+      if (!grantgate.allowed) throw new Error(grantgate.reason);
+      const consent = sensitiveconsentfor(entry.manifest, library.install.consent === true);
+      if (consent.required && !library.install.consent) throw new Error(consent.reason);
+      const record2 = installlibrary({ entry, ...library.install.selectornamespace !== void 0 && library.install.selectornamespace.trim() !== "" ? { selectornamespace: library.install.selectornamespace } : {}, now });
+      await memory.addworkflowrecord(record2);
+      await memory.addworkflowimport({ id: randomid(), record: record2, importedat: now, libraryversion: entry.manifest.version });
+      const installedentry = { ...entry, state: "installed", installedat: now };
+      await memory.setflowlibrary((await memory.getflowlibrary()).map((candidate) => candidate.id === entry.id ? installedentry : candidate));
+      const event = libraryeventof({ kind: "install", entryid: entry.id, title: entry.manifest.title, version: entry.manifest.version, detail: `The manifest ${entry.manifest.id} of ${entry.manifest.publisher} resolved into the pending workflow ${record2.id} with ${record2.steps.length} steps and the selector namespace ${library.install.selectornamespace?.trim() || "unchanged"}.`, now });
+      await memory.addlibraryevent(event);
+      if (session) await appendrunevent("library", `The flowlibrary installed ${entry.manifest.title} version ${entry.manifest.version} of ${entry.manifest.publisher} as the pending workflow ${record2.id}; the import review approves its step list before anything runs.`, session, session.origin).catch(() => {
+      });
+      await audit("library", `The user installed ${entry.manifest.title} version ${entry.manifest.version} of ${entry.manifest.publisher}: the import landed as the pending workflow ${record2.id} with ${record2.steps.length} steps, the selector namespaces rewrote for the local profile and the import review gates every step before any run.`, { ...session ? { sessionid: session.id } : {}, planid: record2.id });
+      return { ...await ecosystemviewof(), record: record2, event };
+    }
+    if (library.update !== void 0) {
+      const entries = await memory.getflowlibrary();
+      const existing = entries.find((candidate) => candidate.id === (library.update?.entryid ?? ""));
+      if (!existing) throw new Error(`No installed flowlibrary entry matches ${library.update.entryid ?? ""}.`);
+      const incoming = await libraryentryof({ manifest: { ...existing.manifest, version: `${existing.manifest.version}+${now}` }, provenance: existing.provenance, now });
+      const diff = updatelibrary({ incoming, existing });
+      if (diff.replace) {
+        await memory.setflowlibrary((await memory.getflowlibrary()).map((candidate) => candidate.id === existing.id ? incoming : candidate));
+        const event = libraryeventof({ kind: "update", entryid: existing.id, title: existing.manifest.title, version: incoming.manifest.version, detail: diff.reason, now });
+        await memory.addlibraryevent(event);
+        if (session) await appendrunevent("library", `The flowlibrary updated ${existing.manifest.title} from version ${diff.versionfrom} to ${diff.versionto} with ${diff.changedsteps.length} changed steps and ${diff.addedgrants.length} added grants; the version diff surfaced before the replace.`, session, session.origin).catch(() => {
+        });
+        await audit("library", `The user updated ${existing.manifest.title} from version ${diff.versionfrom} to ${diff.versionto}: ${diff.changedsteps.length} step${diff.changedsteps.length === 1 ? "" : "s"} changed and ${diff.addedgrants.length} grant${diff.addedgrants.length === 1 ? "" : "s"} added; the version diff surfaced before the replace and the local forks stay untouched.`, { ...session ? { sessionid: session.id } : {} });
+      }
+      return { diff, ...await ecosystemviewof() };
+    }
+    if (library.remove !== void 0) {
+      const entry = (await memory.getflowlibrary()).find((candidate) => candidate.id === (library.remove?.entryid ?? ""));
+      if (!entry) throw new Error(`No flowlibrary entry matches ${library.remove.entryid ?? ""}.`);
+      const forks = (await memory.getworkflowrecordversions()).filter((record2) => record2.id.startsWith(`fork:${entry.manifest.id}:`));
+      const outcome = removelibrary({ entry, forks });
+      await memory.removelibraryentry(entry.id);
+      const event = libraryeventof({ kind: "remove", entryid: entry.id, title: entry.manifest.title, version: entry.manifest.version, detail: outcome.reason, now });
+      await memory.addlibraryevent(event);
+      if (session) await appendrunevent("library", `The flowlibrary removed ${entry.manifest.title} version ${entry.manifest.version} while its ${forks.length} local fork${forks.length === 1 ? "" : "s"} stayed untouched.`, session, session.origin).catch(() => {
+      });
+      await audit("library", `The user removed ${entry.manifest.title} version ${entry.manifest.version} from the flowlibrary; the ${forks.length} local fork${forks.length === 1 ? "" : "s"} stay untouched because a fork is an independent local workflow.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...outcome, ...await ecosystemviewof() };
+    }
+    if (library.fork !== void 0) {
+      const entry = (await memory.getflowlibrary()).find((candidate) => candidate.id === (library.fork?.entryid ?? ""));
+      if (!entry) throw new Error(`No flowlibrary entry matches ${library.fork.entryid ?? ""}.`);
+      const fork = forklibrary({ entry, now });
+      await memory.addworkflowrecord(fork);
+      await audit("library", `The user forked ${entry.manifest.title} version ${entry.manifest.version} into the independent local workflow ${fork.id} with ${fork.steps.length} steps; the fork owns its name from its creation on and reviews pending.`, { ...session ? { sessionid: session.id } : {} });
+      return { fork, ...await ecosystemviewof() };
+    }
+    if (library.export === true) {
+      const manifests = await memory.exportlibrarymanifests();
+      await audit("library", `The flowlibrary exported its manifest list for audit: ${manifests.length} entr${manifests.length === 1 ? "y" : "ies"} with digest, publisher, version, state and provenance and no step payload.`, { ...session ? { sessionid: session.id } : {} });
+      return { manifests };
+    }
+    throw new Error("The library command carries no browse, entry, grants, import, install, update, remove, fork or export action.");
+  }
+  if (input.sync !== void 0) {
+    const sync = input.sync;
+    if (sync.providers === true) return { providers: syncbridgeproviders() };
+    if (sync.hooks === true) return { hooks: await memory.getsyncbridgehooks() };
+    if (sync.hook?.add !== void 0) {
+      const provider = sync.hook.add.provider === "web" ? "web" : "file";
+      const direction = sync.hook.add.direction === "pull" ? "pull" : sync.hook.add.direction === "push" ? "push" : "both";
+      const hook = syncbridgehookof({ provider, direction, endpoint: sync.hook.add.endpoint ?? "", now });
+      await memory.setsyncbridgehooks([...await memory.getsyncbridgehooks(), hook]);
+      await audit("syncbridge", `The user added the ${provider} hook of ${hook.endpoint} with the direction ${direction}; the hook starts opted out because no hook ever defaults on.`, { ...session ? { sessionid: session.id } : {} });
+      return { hook, hooks: await memory.getsyncbridgehooks() };
+    }
+    if (sync.hook?.optin !== void 0) {
+      const hooks = await memory.getsyncbridgehooks();
+      const hook = hooks.find((candidate) => candidate.id === sync.hook?.optin?.hookid);
+      if (!hook) throw new Error(`No syncbridge hook matches ${sync.hook.optin.hookid ?? ""}.`);
+      const flipped = syncbridgeoptinflip(hook, sync.hook.optin.optin === true);
+      await memory.setsyncbridgehooks(hooks.map((candidate) => candidate.id === hook.id ? flipped : candidate));
+      await audit("syncbridge", `The user ${flipped.optin ? "opted the" : "opted the"} ${hook.provider} hook of ${hook.endpoint} ${flipped.optin ? "in" : "out"}; the explicit opt in stays the only switch and no hook ever defaults on.`, { ...session ? { sessionid: session.id } : {} });
+      return { hook: flipped, hooks: await memory.getsyncbridgehooks() };
+    }
+    if (sync.pull !== void 0) {
+      const hooks = await memory.getsyncbridgehooks();
+      const hook = hooks.find((candidate) => candidate.id === sync.pull?.hookid);
+      if (!hook) throw new Error(`No syncbridge hook matches ${sync.pull.hookid ?? ""}.`);
+      const optingate = syncbridgeoptingate({ optin: hook.optin });
+      if (!optingate.allowed) throw new Error(optingate.reason);
+      if (hook.provider === "web") return { stub: webproviderstub(hook) };
+      const validation = syncbridgevalidate(sync.pull.payload ?? {});
+      if (!validation.ok) throw new Error(validation.reason);
+      const payload = sync.pull.payload;
+      const entries = await memory.getflowlibrary();
+      const local = [];
+      for (const entry of entries) local.push({ manifestid: entry.manifest.id, version: entry.manifest.version, digest: entry.digest });
+      const remote = [];
+      for (const manifest of payload.manifests) remote.push({ manifestid: manifest.id, version: manifest.version, digest: await syncdigestof(manifest) });
+      const scan = await syncbridgescan({ hook, local, remote, now });
+      for (const manifest of payload.manifests) {
+        if (scan.synced.includes(manifest.id)) {
+          const entry = await libraryentryof({ manifest, provenance: `Pulled from the ${hook.provider} hook of ${hook.endpoint}`, now });
+          await memory.addlibraryentry(entry);
+        }
+      }
+      for (const conflict of scan.conflicts) await memory.addsyncbridgeconflict(conflict);
+      await memory.setsyncbridgehooks(hooks.map((candidate) => candidate.id === hook.id ? { ...candidate, state: "idle", lastsyncat: now } : candidate));
+      await audit("syncbridge", `The file hook of ${hook.endpoint} pulled ${payload.manifests.length} manifest${payload.manifests.length === 1 ? "" : "s"}: ${scan.synced.length} moved while ${scan.conflicts.length} conflict${scan.conflicts.length === 1 ? "" : "s"} surfaced both versions instead of a silent overwrite.`, { ...session ? { sessionid: session.id } : {} });
+      return { scan, ...await ecosystemviewof() };
+    }
+    if (sync.push !== void 0) {
+      const hooks = await memory.getsyncbridgehooks();
+      const hook = hooks.find((candidate) => candidate.id === sync.push?.hookid);
+      if (!hook) throw new Error(`No syncbridge hook matches ${sync.push.hookid ?? ""}.`);
+      const optingate = syncbridgeoptingate({ optin: hook.optin });
+      if (!optingate.allowed) throw new Error(optingate.reason);
+      if (hook.provider === "web") return { stub: webproviderstub(hook) };
+      const payload = await syncbridgeexportpayload((await memory.getflowlibrary()).map((entry) => entry.manifest));
+      await memory.setsyncbridgehooks(hooks.map((candidate) => candidate.id === hook.id ? { ...candidate, state: "idle", lastsyncat: now } : candidate));
+      await audit("syncbridge", `The file hook of ${hook.endpoint} pushed ${payload.manifests.length} manifest${payload.manifests.length === 1 ? "" : "s"} with its digest list; secrets and logs never ride the bridge under any flag.`, { ...session ? { sessionid: session.id } : {} });
+      return { payload, providers: syncbridgeproviders() };
+    }
+    if (sync.conflicts === true) return { conflicts: await memory.getsyncbridgeconflicts() };
+    if (sync.resolve !== void 0) {
+      const resolution = sync.resolve.resolution === "local" ? "local" : sync.resolve.resolution === "remote" ? "remote" : "merge";
+      const conflicts = await memory.resolvesyncbridgeconflict(sync.resolve.conflictid ?? "", resolution, now);
+      await audit("syncbridge", `The user resolved the syncbridge conflict ${sync.resolve.conflictid} with ${resolution}; one distinct action resolved the conflict and both versions stayed on record.`, { ...session ? { sessionid: session.id } : {} });
+      return { conflicts };
+    }
+    throw new Error("The sync command carries no providers, hooks, hook, pull, push, conflicts or resolve action.");
+  }
+  if (input.attention !== void 0) {
+    if (input.attention.dismiss !== void 0) {
+      const entries2 = await memory.dismissattentionentry(input.attention.dismiss.id ?? "");
+      await updatestatusbadge();
+      await audit("attention", `The user dismissed the attention entry ${input.attention.dismiss.id ?? ""}; the dismissal removes the feed row only while the waiting cause keeps its own resolution path.`, { ...session ? { sessionid: session.id } : {} });
+      return { attention: rankattention(entries2).map((entry) => ({ id: entry.id, cause: entry.cause, severity: entry.severity, runid: entry.runid, summary: entry.summary, deeplink: entry.deeplink, at: entry.at })) };
+    }
+    const entries = rankattention(await memory.getattentionentries());
+    const pruned = await memory.pruneattentionentries(now);
+    if (pruned.pruned.length > 0) await audit("attention", `The attentionfeed pruned ${pruned.pruned.length} entr${pruned.pruned.length === 1 ? "y" : "ies"} past the user configured retention window while the resolutions stay in the audit trail.`, {});
+    await updatestatusbadge();
+    return { attention: entries.map((entry) => ({ id: entry.id, cause: entry.cause, severity: entry.severity, runid: entry.runid, summary: entry.summary, deeplink: entry.deeplink, at: entry.at })), notifications: attentionnotifications(entries, now) };
+  }
+  if (input.replay !== void 0) {
+    if (input.replay.open !== void 0) {
+      const runid = input.replay.open.runid?.trim() ?? "";
+      if (runid === "") throw new Error("The runreplay needs its recorded run id.");
+      const log = await memory.getimmutablelog(runid);
+      if (!log) throw new Error(`No sealed run log matches ${runid}.`);
+      const report = await chainreportof(log);
+      const gate = runreplaygate({ sealed: log.seal !== void 0, chainvalid: report.valid });
+      if (!gate.allowed) throw new Error(gate.reason);
+      const read = await readverifiedlog(log);
+      const gates = (await memory.getgates()).map((record2) => ({ gateid: record2.gateid, kind: record2.kind, resolution: record2.state === "resolved" ? "approve" : record2.state === "refused" ? "refuse" : "waiting", at: record2.openedat }));
+      const cursors = await memory.getreplaycursors();
+      const stored = cursors[runid];
+      const sessionbuilt = runreplaysessionof({ runid, entries: read.entries, gates, now });
+      const replay = stored === void 0 ? sessionbuilt : { ...sessionbuilt, cursor: Math.min(stored.cursor, sessionbuilt.steps.length - 1), playing: stored.playing };
+      const current = replay.steps[replay.cursor] ?? replay.steps[0];
+      await audit("runreplay", `The runreplay opened the sealed run ${runid} whose chain verified across ${read.entries.length} entries; the replay walks it read only with the cursor at step ${replay.cursor} and every viewer action records here.`, { ...session ? { sessionid: session.id } : {} });
+      return { replay, ...current !== void 0 ? { restored: replayrestoredview(current) } : {} };
+    }
+    if (input.replay.move !== void 0 || input.replay.jump !== void 0 || input.replay.play !== void 0) {
+      const runid = (input.replay.move?.runid ?? input.replay.jump?.runid ?? input.replay.play?.runid ?? "").trim();
+      if (runid === "") throw new Error("The runreplay action needs its recorded run id.");
+      const log = await memory.getimmutablelog(runid);
+      if (!log) throw new Error(`No sealed run log matches ${runid}.`);
+      const report = await chainreportof(log);
+      const gate = runreplaygate({ sealed: log.seal !== void 0, chainvalid: report.valid });
+      if (!gate.allowed) throw new Error(gate.reason);
+      const read = await readverifiedlog(log);
+      const gates = (await memory.getgates()).map((record2) => ({ gateid: record2.gateid, kind: record2.kind, resolution: record2.state === "resolved" ? "approve" : record2.state === "refused" ? "refuse" : "waiting", at: record2.openedat }));
+      let replay = runreplaysessionof({ runid, entries: read.entries, gates, now });
+      const cursors = await memory.getreplaycursors();
+      const stored = cursors[runid];
+      if (stored !== void 0) replay = { ...replay, cursor: Math.min(stored.cursor, replay.steps.length - 1), playing: stored.playing };
+      if (input.replay.move !== void 0) replay = replaymove(replay, input.replay.move.direction === "backward" ? "backward" : "forward", now);
+      if (input.replay.jump !== void 0) replay = replayjump(replay, input.replay.jump.stepid ?? "", now);
+      if (input.replay.play !== void 0) replay = replayplay(replay, input.replay.play.playing === true, now);
+      await memory.setreplaycursor(runid, { cursor: replay.cursor, playing: replay.playing });
+      const current = replay.steps[replay.cursor] ?? replay.steps[0];
+      await audit("runreplay", `The runreplay viewer moved the cursor of ${runid} to step ${replay.cursor}${replay.playing ? " and plays" : ""}; the ${replay.actions[replay.actions.length - 1]?.kind ?? "step"} action records with its time and the replay touched no page state.`, { ...session ? { sessionid: session.id } : {} });
+      return { replay, ...current !== void 0 ? { restored: replayrestoredview(current) } : {} };
+    }
+    throw new Error("The replay command carries no open, move, jump or play action.");
+  }
+  if (input.compare !== void 0 && input.compare.open !== void 0) {
+    const runida = input.compare.open.runida?.trim() ?? "";
+    const runidb = input.compare.open.runidb?.trim() ?? "";
+    if (runida === "" || runidb === "") throw new Error("The outputcompare needs both run ids.");
+    const runa = (await memory.listworkflowruns()).find((run) => run.id === runida);
+    const runb = (await memory.listworkflowruns()).find((run) => run.id === runidb);
+    if (!runa || !runb) throw new Error("The outputcompare needs the stored runs of both run ids.");
+    const recorda = await memory.getworkflowrecord(runa.workflowid);
+    const recordb = await memory.getworkflowrecord(runb.workflowid);
+    if (!recorda || !recordb) throw new Error("The outputcompare needs the composed workflows of both runs.");
+    const logsa = await memory.getrunlog(runida);
+    const logsb = await memory.getrunlog(runidb);
+    const signaturea = taskinputsignatureof({ objective: recorda.name, steps: recorda.steps.map((step) => step.kind) });
+    const signatureb = taskinputsignatureof({ objective: recordb.name, steps: recordb.steps.map((step) => step.kind) });
+    const comparegate = outputcomparegate({ signaturea, signatureb });
+    if (!comparegate.allowed) throw new Error(comparegate.reason);
+    const readonlygate = outputcomparereadonlygate({ executessteps: false });
+    if (!readonlygate.allowed) throw new Error(readonlygate.reason);
+    const sessionbuilt = outputcomparesessionof({ runids: [runida, runidb], logsa, logsb, now });
+    await memory.addcomparesession(sessionbuilt);
+    const metrics = comparesessionmetrics(sessionbuilt);
+    await audit("outputcompare", `The outputcompare opened the runs ${runida} and ${runidb} that share their step sequence: ${metrics.reason} The comparison read the stored runlog outcomes only and executed no step.`, { ...session ? { sessionid: session.id } : {} });
+    return { session: sessionbuilt, metrics, view: outputcompareview(sessionbuilt) };
+  }
+  if (input.background !== void 0) {
+    if (input.background.queue !== void 0) {
+      const workflowid = input.background.queue.workflowid?.trim() ?? "";
+      if (workflowid === "") throw new Error("The background run queue needs its workflow id.");
+      const record2 = await memory.getworkflowrecord(workflowid);
+      if (!record2) throw new Error(`No composed workflow matches ${workflowid}.`);
+      const reviewgate = runreviewgranted(record2);
+      if (!reviewgate.allowed) throw new Error(reviewgate.reason ?? "The background run queue executes reviewed workflows only.");
+      const queue = enqueuebackgroundrun({ queue: await memory.getbackgroundqueue(), workflowid, summary: input.background.queue.summary ?? `Background run of ${record2.name}`, now });
+      await memory.setbackgroundqueue(queue);
+      await audit("backgroundrun", `The user queued the workflow ${record2.name} for a background run; the queue holds ${queue.filter((entry) => entry.state === "queued").length} waiting entr${queue.filter((entry) => entry.state === "queued").length === 1 ? "y" : "ies"} and the executor picks the oldest first.`, { ...session ? { sessionid: session.id } : {} });
+      void advancebackgroundqueue().catch(() => {
+      });
+      return { queue: backgroundrunsview(await memory.getbackgroundqueue()) };
+    }
+    if (input.background.cancel !== void 0) {
+      const cancelled = cancelbackgroundentry(await memory.getbackgroundqueue(), input.background.cancel.id ?? "");
+      await memory.setbackgroundqueue(cancelled.queue);
+      await audit("backgroundrun", `The user cancelled ${cancelled.cancelled.length} queued background run${cancelled.cancelled.length === 1 ? "" : "s"}; a running entry keeps its executor path.`, { ...session ? { sessionid: session.id } : {} });
+      return { queue: backgroundrunsview(cancelled.queue) };
+    }
+    await advancebackgroundqueue();
+    return { queue: backgroundrunsview(await memory.getbackgroundqueue()), tray: backgroundtrayrows(await memory.getbackgroundqueue(), session?.origin ?? "") };
+  }
+  if (input.settings !== void 0) {
+    const next = { ...settings ?? {}, ...input.settings.attentionretention !== void 0 ? { attentionretention: input.settings.attentionretention } : {} };
+    await memory.setsettings(next);
+    const pruned = await memory.pruneattentionentries(now);
+    await audit("attention", `The user set the attentionfeed retention window${input.settings.attentionretention !== void 0 ? ` to ${input.settings.attentionretention} milliseconds` : ""}; ${pruned.pruned.length} entr${pruned.pruned.length === 1 ? "y" : "ies"} left the feed while the resolutions stay in the audit trail.`, { ...session ? { sessionid: session.id } : {} });
+    return { settings: next };
+  }
+  return ecosystemviewof();
+}
+async function advancebackgroundqueue() {
+  const now = Date.now();
+  let queue = await memory.getbackgroundqueue();
+  if (queue.length === 0) return;
+  const session = await memory.getsession();
+  for (const entry of queue.filter((candidate) => candidate.state === "running")) {
+    if (await runofworkflowactive(entry.workflowid)) continue;
+    const runs = (await memory.listworkflowruns()).filter((run) => run.workflowid === entry.workflowid).sort((a, b) => b.startedat - a.startedat);
+    const last = runs[0];
+    const state = last?.state === "failed" ? "failed" : "done";
+    queue = queue.map((candidate) => candidate.id === entry.id ? finishbackgroundrun(candidate, state, now) : candidate);
+    if (session) await appendrunevent("background", `The background run of ${entry.workflowid} ${state === "done" ? "completed" : "failed"} and released its keepalive hold.`, session, session.origin).catch(() => {
+    });
+    await audit("backgroundrun", `The background run of ${entry.workflowid} ${state === "done" ? "completed" : "failed"} and released its keepalive hold${state === "failed" ? "; the attentionfeed carries the failure with its deep link" : ""}.`, { ...session ? { sessionid: session.id } : {} });
+    if (state === "failed") await recordattention("failure", entry.id, session?.origin ?? "", `The background run of ${entry.workflowid} failed: ${entry.summary}`).catch(() => {
+    });
+  }
+  await memory.setbackgroundqueue(queue);
+  if (queue.some((entry) => entry.state === "running")) return;
+  const next = nextbackgroundrun(queue);
+  if (next === void 0) return;
+  const record2 = await memory.getworkflowrecord(next.workflowid);
+  if (!record2) return;
+  const reviewgate = runreviewgranted(record2);
+  const begun = beginbackgroundrun(next, now, reviewgate.allowed);
+  if (!begun.gate.allowed) {
+    await audit("backgroundrun", `The background run of ${record2.name} stayed queued: ${begun.gate.reason}`, {});
+    return;
+  }
+  queue = queue.map((candidate) => candidate.id === next.id ? begun.entry : candidate);
+  await memory.setbackgroundqueue(queue);
+  if (!session || session.stoppedat || session.pausedat || session.expiresat <= now) return;
+  const plan = await memory.getplan();
+  if (!plan || plan.state !== "approved") return;
+  let granted = true;
+  for (const workfloworigin of record2.origins) {
+    if (!origingranted(session, workfloworigin)) granted = false;
+  }
+  if (!granted) return;
+  startkeepaliveport(next.workflowid);
+  await appendrunevent("background", `The background run queue started the workflow ${record2.name} version ${record2.version} with ${record2.steps.length} reviewed steps and holds the keepalive signal for its duration.`, session, session.origin).catch(() => {
+  });
+  await audit("backgroundrun", `The background run queue started the workflow ${record2.name} version ${record2.version} with ${record2.steps.length} reviewed steps; the keepalive signal holds for the whole run and every checkpoint restores it on each worker wake.`, { sessionid: session.id, planid: plan.id });
+  const runstep2 = { id: `background${next.id}`, kind: "runworkflow", summary: `The background queue run of ${record2.name}`, risk: "sensitive", options: JSON.stringify({ workflowid: next.workflowid, reviewed: true, background: true, variables: { backgroundqueue: next.id } }) };
+  const output = await executeworkflowstep(runstep2, session, plan, session.tabid, session.origin).catch((error) => ({ ok: false, summary: error instanceof Error ? error.message : String(error), details: {} }));
+  if (!output.ok) {
+    queue = queue.map((candidate) => candidate.id === next.id ? finishbackgroundrun(candidate, "failed", Date.now()) : candidate);
+    await memory.setbackgroundqueue(queue);
+    await recordattention("failure", next.id, session.origin, `The background run of ${record2.name} failed to start: ${output.summary}`).catch(() => {
+    });
+    await audit("backgroundrun", `The background run of ${record2.name} failed to start: ${output.summary}.`, { sessionid: session.id, planid: plan.id });
+  }
+  await refreshbadge().catch(() => {
+  });
+}
+async function recoverbackgroundqueue() {
+  const recovered = resumebackgroundqueue(await memory.getbackgroundqueue(), Date.now());
+  if (recovered.requeued.length > 0) {
+    await memory.setbackgroundqueue(recovered.queue);
+    await audit("backgroundrun", `The worker restart requeued ${recovered.requeued.length} interrupted background run${recovered.requeued.length === 1 ? "" : "s"}; the queue state persisted for exactly this recovery.`, {});
+  }
+  await advancebackgroundqueue().catch(() => {
+  });
+}
+async function handlesurfaceviewcommand(message) {
+  const input = message;
+  const now = Date.now();
+  const session = await memory.getsession();
+  const sessionactive = Boolean(session && !session.stoppedat && session.expiresat > now);
+  const settings = await memory.getsettings();
+  const plan = await memory.getplan();
+  const grantedorigins = session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [];
+  const surfaceof = (value, fallback) => ["popup", "sidepanel", "dashboardpage", "optionspage", "onboarding", "omnibox", "page"].includes(value ?? "") ? value : fallback;
+  if (input.datagrid !== void 0) {
+    if (input.datagrid.view !== void 0) {
+      const rows = input.datagrid.view.rows ?? [];
+      if (rows.length === 0) throw new Error("The datagrid view needs at least one extracted row.");
+      const view = datagridof({ title: input.datagrid.view.title ?? "Extraction result", origin: session?.origin ?? "", runid: plan?.id ?? "", rows, at: now });
+      await audit("datagrid", `The user opened the datagrid ${view.id} of ${view.rows.length} row${view.rows.length === 1 ? "" : "s"} and ${view.columns.length} inferred column${view.columns.length === 1 ? "" : "s"}; the grid previews the extraction result before any export.`, { ...session ? { sessionid: session.id } : {} });
+      return { view, menu: exportmenudescriptors() };
+    }
+    if (input.datagrid.sort !== void 0) return { hint: "The datagrid sort runs inside the surface module on the opened view; the sort needs its view id and its column field." };
+    if (input.datagrid.filter !== void 0) return { hint: "The datagrid filter runs locally inside the surface module; no row ever leaves the surface to filter." };
+    if (input.datagrid.select !== void 0) return { hint: "The row range selection marks the partial export scope inside the surface module." };
+  }
+  if (input.export !== void 0) {
+    if (input.export.menu === true) return { menu: exportmenudescriptors() };
+    if (input.export.run !== void 0) {
+      const format = input.export.run.format === "json" ? "json" : input.export.run.format === "clipboard" ? "clipboard" : "csv";
+      const scope = input.export.run.scope === "selection" ? "selection" : input.export.run.scope === "step" ? "step" : "run";
+      await audit("datagrid", `The user ran the ${format} export of the ${scope} scope; the masked values only rule honors the maskinputs verdicts of every sensitive field shape.`, { ...session ? { sessionid: session.id } : {} });
+      return { hint: "The export renders inside the surface module on the datagrid view the surface holds; the background never rebuilds the masked values twice.", format, scope };
+    }
+  }
+  if (input.quickaction !== void 0) {
+    const origin = input.quickaction.list?.origin?.trim() || session?.origin || "";
+    const capabilities = await grantedcapabilities();
+    const actions = quickactionsfor(quickactioncatalog(), { origin, granted: grantedorigins, sessionactive, grantedcapabilities: capabilities });
+    if (input.quickaction.surface === true) {
+      await audit("quickaction", `The ${origin || "originless"} tab lists ${actions.length} permitted quickaction${actions.length === 1 ? "" : "s"}; only the actions the origin allowlist and the capability set permit register.`, { ...session ? { sessionid: session.id } : {} });
+    }
+    return { actions, origin };
+  }
+  if (input.shortcut !== void 0) {
+    const stored = await memory.getshortcutbindings();
+    const bindings = stored.length > 0 ? stored : shortcutdefaults();
+    if (input.shortcut.edit !== void 0) {
+      const command = input.shortcut.edit.command?.trim() ?? "";
+      const text2 = input.shortcut.edit.text?.trim() ?? "";
+      const edited = shortcutbindingafter(bindings, command, text2);
+      await memory.setshortcutbindings(edited);
+      await audit("shortcut", `The user edited the ${command} shortcut to ${text2}; the binding stays user editable and the command keeps its palette gates.`, { ...session ? { sessionid: session.id } : {} });
+      return { bindings: edited };
+    }
+    if (input.shortcut.match !== void 0) {
+      const key = input.shortcut.match.key ?? "";
+      const modifiers = input.shortcut.match.modifiers ?? [];
+      const surface = surfaceof(input.shortcut.match.surface, "popup");
+      const command = shortcutcommandof(bindings, { key, modifiers, surface });
+      if (command !== void 0) {
+        const entries = palettecommandsof(surfacepalette(), { granted: await grantedcapabilities(), sessionactive });
+        const dispatchable = shortcutdispatchable(command, entries, { granted: await grantedcapabilities(), sessionactive });
+        await audit("shortcut", `The ${surface} pressed ${[...modifiers, key].join("+")} and the ${command} command matched${dispatchable ? "; the palette action gate allows the dispatch" : "; the palette action gate refuses the dispatch"}.`, { ...session ? { sessionid: session.id } : {} });
+        return { command, dispatchable };
+      }
+      return { command: void 0, dispatchable: false };
+    }
+    return { bindings: bindings.map((binding) => ({ ...binding, display: shortcuttext(binding) })) };
+  }
+  if (input.omnibox !== void 0 && input.omnibox.parse !== void 0) {
+    const text2 = input.omnibox.parse.text ?? "";
+    const origin = session?.origin ?? "";
+    const gate = omniboxtaskgate({ text: text2, origin, direct: false });
+    if (!gate.allowed) throw new Error(gate.reason);
+    const submission = parseomniboxtask({ text: text2, origin, at: now });
+    const taskinput = omniboxtasktotaskinput(submission);
+    await memory.addtaskinput(taskinput);
+    const proposed = await propose(taskinput.text, false);
+    await audit("omnibox", `The omnibox keyword parsed into the taskinput ${submission.id} for ${origin} and routed through the same proposal flow as the api; the plan ${proposed.id} awaits its plancard review.`, { ...session ? { sessionid: session.id } : {}, planid: proposed.id });
+    await broadcastsurfaceframe({ channel: "runstate", surface: "omnibox", summary: `An omnibox goal became the plan ${proposed.id} and awaits review.` });
+    return { submission, plan: proposed };
+  }
+  if (input.badge !== void 0) {
+    await updatestatusbadge();
+    const progress = await memory.getprogress();
+    const waitingcount = plan !== void 0 && progress !== void 0 && progress.planid === plan.id ? Object.keys(progress.gatewaits ?? {}).length : 0;
+    const state = statusbadgeof({ ...plan !== void 0 && (plan.state === "pending" || plan.state === "approved") ? { planstate: plan.state } : {}, waitingcount, ...plan !== void 0 ? { runid: plan.id } : {} });
+    return { badge: state, text: badgetextof(state), color: badgecolorof(state) };
+  }
+  if (input.notify !== void 0) {
+    const prefs = await memory.getnotificationprefs();
+    if (input.notify.consent !== void 0 || input.notify.enabled !== void 0) {
+      const next = { consent: input.notify.consent === true || prefs?.consent === true, enabled: input.notify.enabled === void 0 ? prefs?.enabled !== false : input.notify.enabled };
+      await memory.setnotificationprefs(next);
+      await audit("notify", `The user set the notification preference${input.notify.consent !== void 0 ? ` with the page content consent ${next.consent ? "granted" : "withheld"}` : ""}${input.notify.enabled !== void 0 ? ` and the notifications ${next.enabled ? "on" : "off"}` : ""}; a content bearing body never shows without its consent.`, { ...session ? { sessionid: session.id } : {} });
+      return { prefs: next };
+    }
+    if (input.notify.done !== void 0) {
+      const runid = input.notify.done.runid?.trim() || plan?.id || "";
+      if (runid === "") throw new Error("The done notification needs its run id.");
+      const payload = notifydoneof({ runid, origin: session?.origin ?? "", summary: input.notify.done.summary ?? "", at: now });
+      await memory.addnotificationhistory(payload);
+      await updatestatusbadge();
+      await broadcastsurfaceframe({ channel: "runstate", surface: "background", summary: `The run ${runid} completed; the deep link ${payload.deeplink} opens its runsummary.` });
+      await audit("notify", `The run ${runid} completed and its done notification carries the deep link ${payload.deeplink} to the runsummary; the body carries no page content so no consent is needed.`, { ...session ? { sessionid: session.id } : {} });
+      return { payload, dnd: notificationrespectsdnd(payload, input.notify.dnd === true) };
+    }
+    if (input.notify.attention !== void 0) {
+      const stepid = input.notify.attention.stepid?.trim() ?? "";
+      if (stepid === "") throw new Error("The attention notification needs its waiting step.");
+      const contentgate = notificationcontentgate({ content: input.notify.attention.content === true, consent: prefs?.consent === true || input.notify.attention.content !== true });
+      if (!contentgate.allowed) throw new Error(contentgate.reason);
+      const payload = notifyattentionof({ runid: input.notify.attention.runid?.trim() || plan?.id || "", stepid, cause: input.notify.attention.cause === "phishguard" ? "phishguard" : input.notify.attention.cause === "deferral" ? "deferral" : "gatewait", reason: input.notify.attention.reason ?? "The run waits for a human.", ...input.notify.attention.content === true ? { content: true } : {}, consent: prefs?.consent === true, at: now });
+      await memory.addnotificationhistory(payload);
+      await updatestatusbadge();
+      await broadcastsurfaceframe({ channel: "runstate", surface: "background", summary: `The step ${stepid} needs attention; the deep link ${payload.deeplink} opens the exact waiting step.` });
+      await audit("notify", `The step ${stepid} of the run ${payload.runid} needs attention (${payload.title.toLowerCase()}); the deep link ${payload.deeplink} opens the exact waiting step${input.notify.dnd === true ? " while the os do not disturb state holds the toast in the history" : ""}.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid });
+      return { payload, dnd: notificationrespectsdnd(payload, input.notify.dnd === true) };
+    }
+    if (input.notify.history === true) return { history: await memory.getnotificationhistory() };
+    return { prefs: prefs ?? { consent: false, enabled: true } };
+  }
+  if (input.recent !== void 0) {
+    if (input.recent.add !== void 0) {
+      const runid = input.recent.add.runid?.trim() ?? "";
+      if (runid === "") throw new Error("The recenttray entry needs its run id.");
+      const outcome = input.recent.add.outcome === "completed" ? "completed" : input.recent.add.outcome === "halted" ? "halted" : input.recent.add.outcome === "failed" ? "failed" : "running";
+      const entry = recenttrayentryof({ runid, origin: input.recent.add.origin?.trim() || session?.origin || "", outcome, title: input.recent.add.title ?? "", at: now });
+      await memory.addrecenttrayentry(entry);
+      await audit("recent", `The recenttray recorded the run ${runid} with its ${outcome} outcome${settings?.recenttraydepth !== void 0 ? ` inside the user depth of ${settings.recenttraydepth}` : ""}; a halted run offers resume and a completed run offers reopen.`, { ...session ? { sessionid: session.id } : {} });
+      return { tray: await memory.getrecenttray() };
+    }
+    if (input.recent.action !== void 0) {
+      const runid = input.recent.action.runid?.trim() ?? "";
+      const entry = (await memory.getrecenttray()).find((candidate) => candidate.runid === runid);
+      if (entry === void 0) throw new Error(`The recenttray knows no run ${runid}.`);
+      const actions = recenttrayactions(entry);
+      await audit("recent", `The user read the actions of the run ${runid} from the recenttray: ${actions.length === 0 ? "no action offers while the run stays live" : actions.join(" and ")}.`, { ...session ? { sessionid: session.id } : {} });
+      return { actions };
+    }
+    return { tray: await memory.getrecenttray() };
+  }
+  if (input.picker !== void 0) {
+    if (input.picker.start !== void 0) {
+      const candidates = (input.picker.start.candidates ?? []).map((candidate) => pickercandidateof({ selector: candidate.selector ?? "", ...candidate.text !== void 0 ? { text: candidate.text } : {}, ...candidate.role !== void 0 ? { role: candidate.role } : {}, hasid: candidate.hasid === true, hasstableattributes: candidate.hasstableattributes === true, hasrole: candidate.hasrole === true, textunique: candidate.textunique === true }));
+      const picker = pickersessionstart({ origin: session?.origin ?? "", granted: grantedorigins, candidates, at: now });
+      await audit("picker", `The sidepanel started the picker session ${picker.id} on the granted origin ${picker.origin} with ${picker.candidates.length} stability scored candidate${picker.candidates.length === 1 ? "" : "s"}.`, { ...session ? { sessionid: session.id } : {} });
+      return { picker, tips: guidedtips() };
+    }
+    if (input.picker.lock !== void 0) {
+      const stepid = input.picker.lock.stepid?.trim() ?? "";
+      const candidateindex = input.picker.lock.candidateindex ?? 0;
+      if (stepid === "") throw new Error("The candidate lock needs its step.");
+      return { hint: "The candidate lock binds one candidate of the open picker session inside the surface module; the locked selector rides the proposed step for its review.", stepid, candidateindex };
+    }
+  }
+  if (input.halo !== void 0) {
+    const halo = haloof({ stepid: input.halo.stepid?.trim() ?? "", selector: input.halo.selector ?? "", rect: { x: input.halo.rect?.x ?? 0, y: input.halo.rect?.y ?? 0, width: input.halo.rect?.width ?? 0, height: input.halo.rect?.height ?? 0 }, state: input.halo.state === "running" ? "running" : input.halo.state === "waiting" ? "waiting" : input.halo.state === "done" ? "done" : input.halo.state === "failed" ? "failed" : input.halo.state === "halted" ? "halted" : "pending" });
+    return { halo, color: halocolorof(halo.state) };
+  }
+  if (input.tips !== void 0) {
+    const tips = guidedtips();
+    if (input.tips.dismiss !== void 0) {
+      const dismissed = guidedtipdismiss(tips, (await memory.getsurfacelayout("optionspage"))?.preferences.dismissedtips?.split(",").filter((id) => id !== "") ?? [], input.tips.dismiss.tipid?.trim() ?? "");
+      await memory.setsurfacelayout({ surface: "optionspage", preferences: { dismissedtips: dismissed.join(",") }, updatedat: now });
+      await audit("picker", `The user dismissed the ${input.tips.dismiss.tipid} guidedtip; the optionspage recalls every dismissed tip on demand.`, { ...session ? { sessionid: session.id } : {} });
+      return { tips, dismissed };
+    }
+    if (input.tips.recall === true) {
+      const recalled = guidedtiprecall((await memory.getsurfacelayout("optionspage"))?.preferences.dismissedtips?.split(",").filter((id) => id !== "") ?? []);
+      await memory.setsurfacelayout({ surface: "optionspage", preferences: { dismissedtips: "" }, updatedat: now });
+      return { tips, dismissed: recalled };
+    }
+    return { tips, dismissed: (await memory.getsurfacelayout("optionspage"))?.preferences.dismissedtips?.split(",").filter((id) => id !== "") ?? [] };
+  }
+  if (input.shotpanel !== void 0) {
+    if (input.shotpanel.open !== void 0) {
+      const view = shotpanelof({ stepid: input.shotpanel.open.stepid?.trim() ?? "", runid: plan?.id ?? "", captureid: input.shotpanel.open.captureid?.trim() ?? "", provenance: input.shotpanel.open.provenance === "fullpage" ? "fullpage" : input.shotpanel.open.provenance === "element" ? "element" : input.shotpanel.open.provenance === "region" ? "region" : "viewport", origin: session?.origin ?? "", granted: grantedorigins, at: now });
+      await audit("shotpanel", `The user opened the shotpanel of the capture ${view.captureid} (${view.provenance}) of the step ${view.stepid}; the capture origin holds its allowlist entry and the redaction verdicts render beside the preview.`, { ...session ? { sessionid: session.id } : {} });
+      return { view };
+    }
+    return { hint: "The zoom and pan run inside the surface module on the opened shotpanel view." };
+  }
+  if (input.compare !== void 0) {
+    if (input.compare.pair !== void 0) {
+      const pair = comparepairof({ stepid: input.compare.pair.stepid?.trim() ?? "", beforecaptureid: input.compare.pair.beforecaptureid?.trim() ?? "", aftercaptureid: input.compare.pair.aftercaptureid?.trim() ?? "" });
+      return { pair };
+    }
+    return { hint: "The compareviewer pairs the before and after captures of every executed write step inside the surface module; the slider overlays the two captures." };
+  }
+  if (input.siteprofile !== void 0) {
+    if (input.siteprofile.save !== void 0) {
+      const origin = input.siteprofile.save.origin?.trim() || session?.origin || "";
+      const profile = siteprofileof({ origin, ...input.siteprofile.save.theme === "dark" || input.siteprofile.save.theme === "light" || input.siteprofile.save.theme === "system" ? { theme: input.siteprofile.save.theme } : {}, ...input.siteprofile.save.defaultview !== void 0 ? { defaultview: input.siteprofile.save.defaultview } : {}, at: now });
+      const profiles = [...(await memory.listsiteprofiles()).filter((candidate) => candidate.origin !== profile.origin), profile];
+      await memory.setsiteprofile(profile);
+      await memory.setsiteprofiles(profiles);
+      await audit("siteprofile", `The user saved the siteprofile of ${profile.origin}${profile.theme !== void 0 ? ` with the ${profile.theme} theme` : ""}${profile.defaultview !== void 0 ? ` and the ${profile.defaultview} default view` : ""}; the profile adjusts interface preferences only and never a policy gate.`, { ...session ? { sessionid: session.id } : {} });
+      return { profile, profiles };
+    }
+    if (input.siteprofile.get !== void 0) {
+      const origin = input.siteprofile.get.origin?.trim() || session?.origin || "";
+      const profiles = await memory.listsiteprofiles();
+      return { profile: siteprofilefor(profiles, origin), active: profiles.some((profile) => siteprofileactive(profile, origin)) };
+    }
+    return { profiles: await memory.listsiteprofiles() };
+  }
+  if (input.theme !== void 0) {
+    const ospreference = input.theme.ospreference === "dark" ? "dark" : input.theme.ospreference === "light" ? "light" : windowmatchmedia();
+    const preference = input.theme.preference === "dark" || input.theme.preference === "light" || input.theme.preference === "system" ? input.theme.preference : await memory.getthemepreference();
+    if (preference !== void 0 && input.theme.preference !== void 0) await memory.setthemepreference(preference);
+    const profile = session ? siteprofilefor(await memory.listsiteprofiles(), session.origin) : void 0;
+    const appearance = resolveappearance({ ospreference, ...preference !== void 0 ? { useroverride: preference } : {}, ...profile !== void 0 ? { siteprofile: profile } : {} });
+    if (input.theme.preference !== void 0) await audit("theme", `The user set the ${preference} theme preference; the resolved appearance stays ${appearance.mode} from ${appearance.source} and the tokens cover every surface including the dashboardpage.`, { ...session ? { sessionid: session.id } : {} });
+    return { appearance, ospreference, ...preference !== void 0 ? { preference } : {} };
+  }
+  if (input.locale !== void 0) {
+    const bundles = localebundles();
+    const language = settings?.uilanguage ?? "en";
+    if (input.locale.string !== void 0) return { value: localestring(bundles, language, input.locale.string.key ?? "") };
+    if (input.locale.format !== void 0) {
+      const kind = input.locale.format.kind === "date" ? "date" : input.locale.format.kind === "duration" ? "duration" : "number";
+      return { value: localeformat({ language, value: input.locale.format.value ?? 0, kind }) };
+    }
+    return { bundles, languages: supportedlanguages(bundles), language };
+  }
+  if (input.importexport !== void 0) {
+    if (input.importexport.export === true) {
+      const payload = importexportpayloadof({ profile: "profile", originprofiles: [], siteprofiles: (await memory.listsiteprofiles()).map((profile) => ({ origin: profile.origin, ...profile.theme !== void 0 ? { theme: profile.theme } : {}, ...profile.defaultview !== void 0 ? { defaultview: profile.defaultview } : {} })), notes: (await memory.getsitenotes()).map((note) => ({ origin: note.origin, title: note.title, sensitive: note.sensitive })), preferences: { ...settings ?? {} }, at: now });
+      await audit("importexport", `The user exported the settings bundle with ${payload.contents.originprofiles.length} origin profile${payload.contents.originprofiles.length === 1 ? "" : "s"}, ${payload.contents.siteprofiles.length} site profile${payload.contents.siteprofiles.length === 1 ? "" : "s"} and ${payload.contents.notes.length} note${payload.contents.notes.length === 1 ? "" : "s"}; ${payload.exclusions.join(" and ")} never enter any bundle.`, { ...session ? { sessionid: session.id } : {} });
+      return { payload };
+    }
+    if (input.importexport.validate !== void 0) {
+      const validation = importexportvalidate(input.importexport.validate);
+      await audit("importexport", `The import bundle validation ${validation.ok ? "passed" : "refused"}: ${validation.reason}`, { ...session ? { sessionid: session.id } : {} });
+      return validation;
+    }
+    if (input.importexport.apply !== void 0) {
+      const current = settings ?? {};
+      const applied = applyimport(input.importexport.apply, current);
+      await memory.setsettings(applied.preferences);
+      await audit("importexport", `The user imported ${applied.applied.length} preference key${applied.applied.length === 1 ? "" : "s"}; the secrets exclusion list stays untouched because no secret ever rides a bundle.`, { ...session ? { sessionid: session.id } : {} });
+      await broadcastsurfaceframe({ channel: "settings", surface: "optionspage", summary: "An importexport bundle applied its preferences." });
+      return applied;
+    }
+  }
+  if (input.dropimport !== void 0 && input.dropimport.file !== void 0) {
+    const sessionfile = dropimportof({ filename: input.dropimport.file.filename ?? "", bytes: input.dropimport.file.bytes ?? 0, head: input.dropimport.file.head ?? "", at: now });
+    await audit("dropimport", `The user dropped ${sessionfile.filename} (${sessionfile.bytes} byte${sessionfile.bytes === 1 ? "" : "s"}) and the detection named the ${sessionfile.kind} kind; the import path takes the file from here.`, { ...session ? { sessionid: session.id } : {} });
+    return { session: sessionfile };
+  }
+  if (input.tour !== void 0) {
+    const stops = featuretourordered(featuretourstops());
+    if (input.tour.replay === true) {
+      const replayed = await handlerequest({ kind: "surface", onboarding: { replay: true } }, {});
+      void replayed;
+      await audit("tour", `The user replayed the featuretour with ${stops.length} stop${stops.length === 1 ? "" : "s"} across the popup, the sidepanel and the dashboardpage, including the datagrid, the compareviewer and the pickeroverlay stops.`, { ...session ? { sessionid: session.id } : {} });
+      return { stops };
+    }
+    return { stops };
+  }
+  if (input.a11y !== void 0) {
+    if (input.a11y.localized !== void 0) {
+      const surface = surfaceof(input.a11y.localized.surface, "popup");
+      const language = input.a11y.localized.language ?? settings?.uilanguage ?? "en";
+      return { labels: a11ylabelslocalizedfor(surface, localebundles(), language), surface, language };
+    }
+    return { labels: a11ylabelsfor(surfaceof(input.a11y.labels?.surface, "popup")) };
+  }
+  if (input.chip !== void 0) {
+    if (input.chip.open !== void 0) {
+      const chip = pagechipof({ stepid: input.chip.open.stepid?.trim() ?? "", selector: input.chip.open.selector?.trim() ?? "", origin: session?.origin ?? "", at: now });
+      await audit("pagechip", `The pagechip ${chip.id} anchored to ${chip.selector} renders the inline confirmation of the gated step ${chip.stepid} on the page.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: chip.stepid });
+      return { chip };
+    }
+    if (input.chip.resolve !== void 0) {
+      const resolution = input.chip.resolve.resolution === "approve" ? "approve" : input.chip.resolve.resolution === "reject" ? "reject" : void 0;
+      if (resolution === void 0) throw new Error("The pagechip resolution needs its approve or reject decision.");
+      const surface = surfaceof(input.chip.resolve.surface, "page");
+      const chip = pagechipof({ stepid: input.chip.resolve.stepid?.trim() ?? "", selector: input.chip.resolve.selector?.trim() ?? "", origin: input.chip.resolve.origin?.trim() || session?.origin || "", at: now });
+      const resolved = pagechipresolve(chip, resolution, surface, now);
+      await appendrunevent("review", resolved.logevent.summary, session, chip.origin, chip.stepid);
+      await audit("pagechip", resolved.logevent.summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: chip.stepid });
+      await broadcastsurfaceframe({ channel: "runstate", surface, summary: `The step ${chip.stepid} resolved with a ${resolution} from the pagechip.` });
+      return { chip: resolved.chip, logevent: resolved.logevent };
+    }
+  }
+  if (input.toast !== void 0) {
+    if (input.toast.step !== void 0) {
+      const toast = stetoastof({ stepid: input.toast.step.stepid?.trim() ?? "", kind: input.toast.step.kind ?? "", durationms: input.toast.step.durationms ?? 0, at: now });
+      const livecount = settings?.toastlivecount;
+      const stacked = stetoaststackafter([], toast, livecount);
+      await broadcastsurfaceframe({ channel: "logstream", surface: "background", summary: `The step ${toast.stepid} (${toast.kind}) completed in ${toast.durationms} milliseconds.` });
+      await audit("toast", `The step ${toast.stepid} of the kind ${toast.kind} completed in ${toast.durationms} milliseconds; the steteoast confirms it${livecount !== void 0 ? ` inside the user live count of ${livecount}` : ""}.`, { ...session ? { sessionid: session.id } : {}, stepid: toast.stepid });
+      return { toast, live: stacked.live, history: stetoasthistory(stacked.history) };
+    }
+    return { hint: "The steteoast stack keeps its bounded live count inside the surface module while the full history stays queryable." };
+  }
+  if (input.settings !== void 0) {
+    const current = settings ?? {};
+    if (input.settings.recenttraydepth !== void 0 && (!Number.isInteger(input.settings.recenttraydepth) || input.settings.recenttraydepth <= 0)) throw new Error("The recenttray depth stays a positive whole number of runs the user chose; no engine cap exists.");
+    if (input.settings.toastlivecount !== void 0 && (!Number.isInteger(input.settings.toastlivecount) || input.settings.toastlivecount <= 0)) throw new Error("The steteoast live count stays a positive whole number the user chose; no engine cap exists.");
+    const next = {
+      ...current,
+      ...input.settings.recenttraydepth !== void 0 ? { recenttraydepth: input.settings.recenttraydepth } : {},
+      ...input.settings.notifyconsent !== void 0 ? { notifyconsent: input.settings.notifyconsent } : {},
+      ...input.settings.notifyenabled !== void 0 ? { notifyenabled: input.settings.notifyenabled } : {},
+      ...input.settings.themepreference === "dark" || input.settings.themepreference === "light" || input.settings.themepreference === "system" ? { themepreference: input.settings.themepreference } : {},
+      ...input.settings.uilanguage !== void 0 ? { uilanguage: input.settings.uilanguage } : {},
+      ...input.settings.toastlivecount !== void 0 ? { toastlivecount: input.settings.toastlivecount } : {}
+    };
+    await memory.setsettings(next);
+    await audit("configure", `The user set the interface finishing options${input.settings.recenttraydepth !== void 0 ? ` with the recenttray depth of ${input.settings.recenttraydepth}` : ""}${input.settings.themepreference !== void 0 ? ` and the ${input.settings.themepreference} theme preference` : ""}${input.settings.uilanguage !== void 0 ? ` and the ${input.settings.uilanguage} interface language` : ""}${input.settings.notifyconsent !== void 0 ? ` and the notification content consent ${input.settings.notifyconsent ? "granted" : "withheld"}` : ""}${input.settings.toastlivecount !== void 0 ? ` and the steteoast live count of ${input.settings.toastlivecount}` : ""}; every write takes effect without reloading the extension.`, { ...session ? { sessionid: session.id } : {} });
+    await broadcastsurfaceframe({ channel: "settings", surface: "optionspage", summary: "The interface finishing options changed and take effect without a reload." });
+    return { settings: next };
+  }
+  throw new Error("The views command carries no datagrid, export, quickaction, shortcut, omnibox, badge, notify, recent, picker, halo, tips, shotpanel, compare, siteprofile, theme, locale, importexport, dropimport, tour, a11y, chip, toast or settings action.");
+}
 async function handlerequest(message, sender) {
   const originverdict = origincheckof({ ...sender.id !== void 0 ? { senderid: sender.id } : {}, ...sender.origin !== void 0 ? { senderorigin: sender.origin } : {}, extensionid: chrome.runtime.id, connectallow: await memory.getconnectallow() });
   const inboundgate = origincheckgate({ verdict: originverdict });
@@ -22163,7 +23993,7 @@ async function handlerequest(message, sender) {
       const livetab = session ? await chrome.tabs.get(session.tabid).catch(() => void 0) : void 0;
       const waitprofile = session ? waitprofiles.find((record2) => record2.origin === session.origin) : void 0;
       const livestate = { phase: livetab?.status === "loading" ? "loading" : "complete", ...navrecords[0] ? { finalurl: navrecords[0].finalurl, redirects: navrecords[0].chain } : {} };
-      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof(), environments: await environmentviewof(), security: await securityviewof(), sessionview: await sessionviewof(), surfacepreferences: { ...runsettings?.paletterecents !== void 0 ? { paletterecents: runsettings.paletterecents } : {}, ...runsettings?.paletteshortcut !== void 0 ? { paletteshortcut: runsettings.paletteshortcut } : {}, ...runsettings?.logstreambuffer !== void 0 ? { logstreambuffer: runsettings.logstreambuffer } : {}, ...runsettings?.taskinputretention !== void 0 ? { taskinputretention: runsettings.taskinputretention } : {}, ...runsettings?.diffpreviewbytes !== void 0 ? { diffpreviewbytes: runsettings.diffpreviewbytes } : {} }, sessionpreferences: { ...runsettings?.recallwindow !== void 0 ? { recallwindow: runsettings.recallwindow } : {}, ...runsettings?.noteretention !== void 0 ? { noteretention: runsettings.noteretention } : {}, ...runsettings?.scratchpadretention !== void 0 ? { scratchpadretention: runsettings.scratchpadretention } : {}, ...runsettings?.summaryretention !== void 0 ? { summaryretention: runsettings.summaryretention } : {}, ...runsettings?.correctionretention !== void 0 ? { correctionretention: runsettings.correctionretention } : {}, ...runsettings?.summarywindow !== void 0 ? { summarywindow: runsettings.summarywindow } : {}, ...runsettings?.historyindex !== void 0 ? { historyindex: runsettings.historyindex } : {}, ...runsettings?.cancelrollback !== void 0 ? { cancelrollback: runsettings.cancelrollback } : {} } };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof(), environments: await environmentviewof(), security: await securityviewof(), sessionview: await sessionviewof(), surfacepreferences: { ...runsettings?.paletterecents !== void 0 ? { paletterecents: runsettings.paletterecents } : {}, ...runsettings?.paletteshortcut !== void 0 ? { paletteshortcut: runsettings.paletteshortcut } : {}, ...runsettings?.logstreambuffer !== void 0 ? { logstreambuffer: runsettings.logstreambuffer } : {}, ...runsettings?.taskinputretention !== void 0 ? { taskinputretention: runsettings.taskinputretention } : {}, ...runsettings?.diffpreviewbytes !== void 0 ? { diffpreviewbytes: runsettings.diffpreviewbytes } : {}, ...runsettings?.recenttraydepth !== void 0 ? { recenttraydepth: runsettings.recenttraydepth } : {}, ...runsettings?.notifyconsent !== void 0 ? { notifyconsent: runsettings.notifyconsent } : {}, ...runsettings?.notifyenabled !== void 0 ? { notifyenabled: runsettings.notifyenabled } : {}, ...runsettings?.themepreference !== void 0 ? { themepreference: runsettings.themepreference } : {}, ...runsettings?.uilanguage !== void 0 ? { uilanguage: runsettings.uilanguage } : {}, ...runsettings?.toastlivecount !== void 0 ? { toastlivecount: runsettings.toastlivecount } : {} }, sessionpreferences: { ...runsettings?.recallwindow !== void 0 ? { recallwindow: runsettings.recallwindow } : {}, ...runsettings?.noteretention !== void 0 ? { noteretention: runsettings.noteretention } : {}, ...runsettings?.scratchpadretention !== void 0 ? { scratchpadretention: runsettings.scratchpadretention } : {}, ...runsettings?.summaryretention !== void 0 ? { summaryretention: runsettings.summaryretention } : {}, ...runsettings?.correctionretention !== void 0 ? { correctionretention: runsettings.correctionretention } : {}, ...runsettings?.summarywindow !== void 0 ? { summarywindow: runsettings.summarywindow } : {}, ...runsettings?.historyindex !== void 0 ? { historyindex: runsettings.historyindex } : {}, ...runsettings?.cancelrollback !== void 0 ? { cancelrollback: runsettings.cancelrollback } : {} } };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -25237,6 +27067,10 @@ async function handlerequest(message, sender) {
       return handlesessionscommand(message);
     case "surface":
       return handlesurfacecommand(message);
+    case "views":
+      return handlesurfaceviewcommand(message);
+    case "ecosystem":
+      return handleecosystemcommand(message);
     case "security": {
       const input2 = message;
       const now = Date.now();
@@ -26285,6 +28119,8 @@ chrome.runtime.onStartup.addListener(() => {
   void detectcrash();
   void pauseinterruptedworkflowruns().then(() => restorebackgroundruns()).catch(() => {
   });
+  void recoverbackgroundqueue().catch(() => {
+  });
   void runwatchdog().catch(() => {
   });
 });