@wenathlan/extension 1.1.63 → 1.1.65

package/extension/dist/background.js

@@ -5106,6 +5106,121 @@ var sessionmemory = class {
   async exportsessionbundle(exportedat) {
     return { kind: "sessionbundle", notes: await this.getsitenotes(), summaries: await this.listrunsummaries(), corrections: await this.getcorrections(), exportedat };
   }
+  /**
+   * Interface surface stores of the 1.1.64 family live here, scoped per profile workspace: the commandpalette usage counts the recent first ranking reads, the taskinput history of natural language goals, the onboarding completion state, the per surface layout preferences, the logstream filter preferences and the stepapprove resolution history per origin.
+   */
+  /** Returns every commandpalette usage record so the ranking lifts the recent commands first. */
+  async getpaletteusage() {
+    return await this.adapter.get("paletteusage") ?? [];
+  }
+  /** Replaces the commandpalette usage records after one use: the count grows and the last use time moves so the ranking reads both. */
+  async setpaletteusage(records) {
+    return this.adapter.set("paletteusage", records);
+  }
+  /** Returns the stored taskinput history, newest first. */
+  async gettaskinputs() {
+    return await this.adapter.get("taskinputs") ?? [];
+  }
+  /** Adds one taskinput submission to the per profile history; the retention window stays a user setting. */
+  async addtaskinput(entry) {
+    const retention = (await this.getsettings())?.taskinputretention;
+    const history2 = [entry, ...await this.gettaskinputs()];
+    await this.adapter.set("taskinputs", retention === void 0 ? history2 : history2.filter((candidate) => entry.at - candidate.at < retention));
+  }
+  /** Returns the onboarding completion state; an absent state means the walkthrough never ran. */
+  async getonboardingstate() {
+    return this.adapter.get("onboarding");
+  }
+  /** Stores the onboarding completion state; a done walkthrough never runs again on its own. */
+  async setonboardingstate(state) {
+    return this.adapter.set("onboarding", state);
+  }
+  /** Returns the layout preferences of one surface; an absent preference set returns undefined. */
+  async getsurfacelayout(surface) {
+    return this.adapter.get(`surfacelayout:${surface}`);
+  }
+  /** Stores the layout preferences of one surface, scoped per profile workspace. */
+  async setsurfacelayout(layout) {
+    return this.adapter.set(`surfacelayout:${layout.surface}`, layout);
+  }
+  /** Returns the stored logstream filter preferences of the live view. */
+  async getlogstreamfilters() {
+    return this.adapter.get("logstreamfilters");
+  }
+  /** Stores the logstream filter preferences of the live view. */
+  async setlogstreamfilters(filter) {
+    return this.adapter.set("logstreamfilters", filter);
+  }
+  /** Returns every stored stepapprove resolution, newest first, with its human provenance. */
+  async getstepapproveresolutions() {
+    return await this.adapter.get("stepapproveresolutions") ?? [];
+  }
+  /** Records one stepapprove resolution in the per origin history. */
+  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()]);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -10617,6 +10732,87 @@ function retrydispatchgate(input) {
   if (!input.reviewed) return { allowed: false, reason: `The retry of the step ${input.stepid} passes only through a new reviewed dispatch; an automatic retry never bypasses the review.` };
   return { allowed: true, reason: `The retry of the step ${input.stepid} dispatches again through the full consent gate chain: the session, the plan and the origin gates all recheck the step.` };
 }
+function paletteactiongate(input) {
+  if (input.action.permission !== void 0 && !input.granted.includes(input.action.permission)) return { allowed: false, reason: `The ${input.action.command} command needs the ${input.action.permission} capability granted before the palette lists it; the palette never offers an action the current capability set refuses.` };
+  if (input.action.session === true && !input.sessionactive) return { allowed: false, reason: `The ${input.action.command} command needs an active browser session before the palette lists it; the palette never offers a run action without its session.` };
+  return { allowed: true, reason: `The ${input.action.command} command rides its granted permissions and lists in the palette.` };
+}
+function taskinputproposalgate(input) {
+  if (input.direct) return { allowed: false, reason: "The taskinput never executes a goal directly; every natural language goal routes through the same proposal flow as the api and becomes a reviewed plan first." };
+  if (input.text.trim() === "") return { allowed: false, reason: "The taskinput submission needs its natural language goal; an empty goal never reaches the proposal flow." };
+  if (input.origin.trim() === "") return { allowed: false, reason: "The taskinput submission needs its active origin scope; a goal without an origin never reaches the proposal flow." };
+  return { allowed: true, reason: `The taskinput goal for ${input.origin} rides the same proposal flow as the api: the observation, the capabilities and the plan review all recheck it.` };
+}
+function planreviewgate(input) {
+  if (input.state === "approved") return { allowed: true, reason: "The plan already passed its review: the approval is the review of record and the execution proceeds." };
+  if (!input.reviewed) return { allowed: false, reason: "The pending plan has no plancard review yet; every step renders its card with the risk class, the environment and the options before any execution." };
+  return { allowed: true, reason: "The plancard review of the pending plan is open; the resolution of each step stays a distinct human action." };
+}
+function stepapprovegate(input) {
+  if (input.stepids.length === 0) return { allowed: false, reason: "A stepapprove resolution names its single step." };
+  if (input.stepids.length > 1) return { allowed: false, reason: `One human action resolves exactly one step; the batch of ${input.stepids.length} steps refuses in full because no batch approval exists.` };
+  if (input.surface === "background") return { allowed: false, reason: `The ${input.resolution} resolution of the step ${input.stepids[0]} needs its distinct human action from a surface; the background never resolves a review on its own.` };
+  if (input.resolution === "edit") return { allowed: true, reason: `The user edits the step ${input.stepids[0]} from the ${input.surface} before approving; the corrected shape rides the plan and the resolution keeps its human provenance.` };
+  return { allowed: true, reason: `The user ${input.resolution === "approve" ? "approved" : "rejected"} the step ${input.stepids[0]} from the ${input.surface}; one distinct human action resolved the step alone.` };
+}
+function diffpreviewgate(input) {
+  if (input.risk !== "sensitive") return { allowed: false, reason: `The ${input.risk} step changes no page or browser state; the diffpreview compares the observed before state with the predicted after state of write class steps only.` };
+  return { allowed: true, reason: "The write class step changes page or browser state, so the diffpreview compares its observed before state with its predicted after state." };
+}
+function onboardingconsentgate(input) {
+  if (input.consentevents.length === 0) return { allowed: true, reason: "The onboarding completion writes its single consent scoped event; no consent event exists yet." };
+  if (input.consentevents.length === 1) return { allowed: false, reason: `The onboarding already wrote its single consent scoped event ${input.consentevents[0]}; a walkthrough never writes a second one.` };
+  return { allowed: false, reason: `The onboarding found ${input.consentevents.length} consent scoped events; a walkthrough writes exactly one and the extra events refuse.` };
+}
+function logbufferboundvalid(bound) {
+  if (bound === void 0) return { allowed: true, reason: "No logstream buffer bound is configured, so the live window keeps every event while the full history stays in memory." };
+  if (!Number.isInteger(bound) || bound <= 0) return { allowed: false, reason: "The logstream buffer bound stays a positive whole number of events the user chose; no engine cap exists." };
+  return { allowed: true, reason: `The logstream buffer bound of ${bound} event${bound === 1 ? "" : "s"} stays the user configured choice; the full history stays in memory.` };
+}
+function logstreamegressgate(input) {
+  if (input.entries === 0) return { allowed: false, reason: "The audit excerpt names no event of the logstream; an empty range never copies." };
+  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." };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -10867,7 +11063,7 @@ function maskexport(record2, shapes) {
 }
 
 // version.ts
-var packageversion = "1.1.63";
+var packageversion = "1.1.65";
 
 // types.ts
 var protocolversion = packageversion;
@@ -11844,6 +12040,9 @@ function environmentreport(input) {
 function transparencyreport(input) {
   return { version: protocolversion, posture: "denydefault", grants: input.grants, windows: input.windows, connectallow: input.connectallow, permdiffs: input.permdiffs, safedefaults: input.safedefaults, vault: input.vault };
 }
+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 } : {} };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -13091,6 +13290,9 @@ function rejectedcorrectionof(input) {
   if (input.stepid.trim() === "" || input.reason.trim() === "") throw new Error("The rejected correction needs its step and its rejection reason.");
   return { id: input.id ?? randomid(), origin: input.origin, kind: input.kind, stepid: input.stepid, source: "rejected", original: input.original, reason: input.reason, at: input.now };
 }
+function matchingcorrections(corrections, proposal) {
+  return corrections.filter((entry) => entry.origin === proposal.origin && entry.kind === proposal.kind);
+}
 function consentmemoryof(input) {
   if (input.origin.trim() === "") throw new Error("The consent memory entry needs its origin.");
   if (input.boundary.trim() === "") throw new Error("The consent memory entry needs the boundary the prompt named.");
@@ -13180,6 +13382,726 @@ function tabsessionrefof(input) {
   return { tabid: input.tabid, sessionid: input.sessionid, ...input.runid !== void 0 && input.runid.trim() !== "" ? { runid: input.runid } : {}, origin: input.origin, updatedat: input.now };
 }
 
+// surfaces.ts
+function surfacepalette() {
+  return [
+    { id: "starttask", label: "Start task", keywords: ["task", "objective", "run", "goal", "plan"], action: { command: "starttask", surface: "popup" } },
+    { id: "pauserun", label: "Pause run", keywords: ["pause", "hold", "stop", "run"], action: { command: "pauserun", surface: "popup", session: true } },
+    { id: "resumerun", label: "Resume run", keywords: ["resume", "continue", "unpause", "run"], action: { command: "resumerun", surface: "popup", session: true } },
+    { id: "cancelrun", label: "Cancel run", keywords: ["cancel", "stop", "rollback", "queued"], action: { command: "cancelrun", surface: "popup", session: true } },
+    { id: "resumesession", label: "Resume session", keywords: ["session", "resume", "grid", "reopen"], action: { command: "resumesession", surface: "sidepanel" } },
+    { id: "stepapprove", label: "Review step", keywords: ["approve", "reject", "edit", "step", "review", "plancard"], action: { command: "stepapprove", surface: "sidepanel", session: true } },
+    { id: "diffpreview", label: "Preview step diff", keywords: ["diff", "preview", "before", "after", "write"], action: { command: "diffpreview", surface: "sidepanel", session: true } },
+    { id: "historysearch", label: "Search history", keywords: ["history", "search", "notes", "summaries", "corpus"], action: { command: "historysearch", surface: "dashboardpage" } },
+    { id: "revokeconsent", label: "Revoke consent", keywords: ["revoke", "consent", "allowlist", "origin", "grant"], action: { command: "revokeconsent", surface: "dashboardpage", session: true } },
+    { id: "opentransparencypage", label: "Open transparency page", keywords: ["transparency", "grants", "permissions", "diff"], action: { command: "opentransparencypage", surface: "optionspage" } },
+    { id: "opendashboardpage", label: "Open dashboard", keywords: ["dashboard", "sessions", "runs", "notes", "full"], action: { command: "opendashboardpage", surface: "dashboardpage" } },
+    { id: "openoptionspage", label: "Open options", keywords: ["options", "settings", "preferences", "configure"], action: { command: "openoptionspage", surface: "optionspage" } },
+    { id: "copyauditexcerpt", label: "Copy audit excerpt", keywords: ["audit", "excerpt", "copy", "verified", "range"], action: { command: "copyauditexcerpt", surface: "dashboardpage" } },
+    { id: "replayonboarding", label: "Replay onboarding", keywords: ["onboarding", "tour", "walkthrough", "replay", "first"], action: { command: "replayonboarding", surface: "onboarding" } }
+  ];
+}
+function palettecommandsof(entries, input) {
+  return entries.filter((entry) => paletteactiongate({ action: entry.action, granted: input.granted, sessionactive: input.sessionactive }).allowed);
+}
+function fuzzyentryscore(entry, query) {
+  const text2 = query.trim().toLowerCase();
+  if (text2 === "") return 1;
+  const id = entry.id.toLowerCase();
+  const label = entry.label.toLowerCase();
+  if (id === text2 || label === text2) return 100;
+  let score = 0;
+  if (id.includes(text2)) score += 40;
+  if (label.includes(text2)) score += 30;
+  for (const keyword of entry.keywords) {
+    const lower = keyword.toLowerCase();
+    if (lower === text2) score += 20;
+    else if (lower.includes(text2)) score += 10;
+  }
+  if (score === 0 && text2.length > 1) {
+    for (const haystack of [label, id]) {
+      let cursor = 0;
+      let matched = true;
+      for (const letter of text2) {
+        const found = haystack.indexOf(letter, cursor);
+        if (found === -1) {
+          matched = false;
+          break;
+        }
+        cursor = found + 1;
+      }
+      if (matched) {
+        score += 15;
+        break;
+      }
+    }
+  }
+  return score;
+}
+function palettequery(entries, input) {
+  const text2 = input.text.trim();
+  const matches = entries.map((entry) => ({ entry, score: fuzzyentryscore(entry, text2) })).filter((match) => match.score > 0);
+  const lastusedof = (command) => input.usage.find((record2) => record2.command === command)?.lastusedat ?? 0;
+  const countof = (command) => input.usage.find((record2) => record2.command === command)?.count ?? 0;
+  const recentwindow = input.recentwindow;
+  const ranked = matches.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    const leftrecent = recentwindow === void 0 ? 0 : countof(left.entry.action.command) > 0 && lastusedof(left.entry.action.command) >= lastusedof(right.entry.action.command) ? 1 : 0;
+    const rightrecent = recentwindow === void 0 ? 0 : countof(right.entry.action.command) > 0 && lastusedof(right.entry.action.command) >= lastusedof(left.entry.action.command) ? 1 : 0;
+    if (rightrecent !== leftrecent) return rightrecent - leftrecent;
+    return lastusedof(right.entry.action.command) - lastusedof(left.entry.action.command);
+  });
+  return ranked.map((match) => ({ entry: match.entry, score: match.score, reason: match.score >= 100 ? `The query matches the ${match.entry.id} command exactly.` : `The query matches the label or the keywords of the ${match.entry.id} command${countof(match.entry.action.command) > 0 ? ` and its ${countof(match.entry.action.command)} recorded use${countof(match.entry.action.command) === 1 ? "" : "s"} rank it first among equals` : ""}.` }));
+}
+function paletteuseafter(usage, command, now) {
+  const existing = usage.find((record2) => record2.command === command);
+  if (existing === void 0) return [{ command, count: 1, lastusedat: now }, ...usage];
+  return usage.map((record2) => record2.command === command ? { ...record2, count: record2.count + 1, lastusedat: now } : record2);
+}
+function taskinputof(input) {
+  if (input.text.trim() === "") throw new Error("The taskinput needs its natural language goal.");
+  if (input.origin.trim() === "") throw new Error("The taskinput needs its active origin scope.");
+  return { id: randomid(), text: input.text.trim(), context: input.context ?? "", origin: input.origin.trim(), surface: input.surface, at: input.at };
+}
+function onboardingsteps() {
+  return [
+    { 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" }
+  ];
+}
+function onboardingstart(previous, now) {
+  return { stepscompleted: [], done: false, startedat: now };
+}
+function onboardingcomplete(state, stepid, now) {
+  const steps = onboardingsteps();
+  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));
+  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 };
+}
+function broadcastframeof(input) {
+  if (input.summary.trim() === "") throw new Error("The broadcast frame needs its summary.");
+  return { channel: input.channel, surface: input.surface, summary: input.summary, at: input.at };
+}
+function broadcastchannelof(kind) {
+  if (["session", "proposal", "approval", "action", "stop", "pause", "resume", "complete", "cancel", "error", "capability"].includes(kind)) return "runstate";
+  if (["notes", "scratchpad", "summary", "recall", "correction", "consentmemory", "search", "vault", "gate", "grant", "revoke", "expiry", "deny"].includes(kind)) return "sessions";
+  if (["configure", "transparency"].includes(kind)) return "settings";
+  return "logstream";
+}
+function busrouteaction(action, input) {
+  const entry = surfacepalette().find((candidate) => candidate.action.command === action.command);
+  if (entry === void 0) return { dispatched: false, gate: "commandbus", reason: `The ${action.surface} asked for the unknown ${action.command} command; the bus routes only catalog commands.` };
+  const permission = paletteactiongate({ action: entry.action, granted: input.granted, sessionactive: input.sessionactive });
+  if (!permission.allowed) return { dispatched: false, gate: "paletteactiongate", reason: permission.reason ?? "The command misses its granted permission." };
+  if (action.command === "starttask") {
+    const proposal = taskinputproposalgate({ text: input.text ?? "", origin: input.origin ?? "", direct: false });
+    if (!proposal.allowed) return { dispatched: false, gate: "taskinputproposalgate", reason: proposal.reason ?? "The task submission refuses." };
+  }
+  if (action.command === "stepapprove" || action.command === "diffpreview") {
+    const review = planreviewgate({ reviewed: input.planreviewed, state: input.planstate });
+    if (!review.allowed) return { dispatched: false, gate: "planreviewgate", reason: review.reason ?? "The plan review stays open." };
+  }
+  return { dispatched: true, gate: "commandbus", reason: `The ${action.command} action of the ${action.surface} routed through its policy gates and dispatches.` };
+}
+
+// planreview.ts
+function plancardsof(input) {
+  return input.plan.steps.map((step) => ({
+    stepid: step.id,
+    kind: step.kind,
+    risk: step.risk,
+    environment: step.environment ?? defaultenvironment(step),
+    options: step.options ?? "",
+    summary: step.summary,
+    corrections: matchingcorrections(input.corrections, { origin: input.plan.origin, kind: step.kind }).map((entry) => ({ id: entry.id, source: entry.source, reason: entry.reason })),
+    editable: input.plan.state === "pending"
+  }));
+}
+function plancardgroups(cards) {
+  const order = ["sensitive", "interaction", "read"];
+  return order.map((risk) => ({ risk, cards: cards.filter((card) => card.risk === risk), expanded: risk === "sensitive" })).filter((group) => group.cards.length > 0);
+}
+function stepresolutionof(input) {
+  if (input.stepid.trim() === "") throw new Error("The stepapprove resolution needs its step.");
+  if (input.resolution === "edit" && (input.edited ?? "").trim() === "") throw new Error("The edited resolution needs its corrected step shape.");
+  return { stepid: input.stepid, planid: input.planid, origin: input.origin, resolution: input.resolution, surface: input.surface, ...input.edited !== void 0 && input.edited.trim() !== "" ? { edited: input.edited } : {}, at: input.at };
+}
+function resolutionlogeventof(resolution) {
+  return {
+    kind: "review",
+    stepid: resolution.stepid,
+    summary: resolution.resolution === "edit" ? `The user edited the step ${resolution.stepid} of the plan ${resolution.planid} from the ${resolution.surface} before approving; the corrected shape rides the plan.` : `The user ${resolution.resolution === "approve" ? "approved" : "rejected"} the step ${resolution.stepid} of the plan ${resolution.planid} from the ${resolution.surface}; one distinct human action resolved the step alone.`
+  };
+}
+function maskverdictsof(state, sensitivefields) {
+  const verdicts = {};
+  for (const [field, value] of Object.entries(state)) {
+    if (sensitivefields.includes(field)) verdicts[field] = `The ${field} value stays masked (${value.length} characters) and never renders in the clear.`;
+  }
+  return verdicts;
+}
+function diffpreviewof(input) {
+  const changes = [];
+  const fields = [.../* @__PURE__ */ new Set([...Object.keys(input.before), ...Object.keys(input.after)])];
+  for (const field of fields) {
+    const hasbefore = Object.prototype.hasOwnProperty.call(input.before, field);
+    const hasafter = Object.prototype.hasOwnProperty.call(input.after, field);
+    const beforevalue = input.before[field];
+    const aftervalue = input.after[field];
+    if (hasbefore && !hasafter && beforevalue !== void 0) changes.push({ field, kind: "removed", before: beforevalue });
+    else if (!hasbefore && hasafter && aftervalue !== void 0) changes.push({ field, kind: "added", after: aftervalue });
+    else if (hasbefore && hasafter && beforevalue !== void 0 && aftervalue !== void 0 && beforevalue !== aftervalue) changes.push({ field, kind: "changed", before: beforevalue, after: aftervalue });
+  }
+  return { stepid: input.stepid, before: input.before, after: input.after, changes, maskverdicts: input.maskverdicts ?? {}, provenance: input.provenance };
+}
+function stepstimelinenodes(input) {
+  const completed = input.progress?.completedsteps ?? [];
+  const outcomes = input.progress?.outcomes ?? [];
+  const environments = input.progress?.environments;
+  const turnarounds = input.progress?.turnarounds;
+  const gatewaits = input.progress?.gatewaits;
+  let activeset = false;
+  let blocked = false;
+  return input.plan.steps.map((step) => {
+    const outcome = [...outcomes].reverse().find((candidate) => candidate.stepid === step.id);
+    const gatewait = gatewaits?.[step.id];
+    let status;
+    if (outcome !== void 0) status = outcome.ok ? "done" : "failed";
+    else if (gatewait !== void 0) status = "waiting";
+    else if (completed.includes(step.id)) status = "done";
+    else if (input.plan.state === "cancelled" || input.plan.state === "expired") status = "halted";
+    else if (input.plan.state === "rejected") status = "halted";
+    else if (input.plan.state === "approved" && !activeset && !blocked) {
+      status = "running";
+      activeset = true;
+    } else status = "pending";
+    if (status === "waiting") blocked = true;
+    const active = status === "running";
+    return {
+      stepid: step.id,
+      kind: step.kind,
+      status,
+      ...turnarounds?.[step.id] !== void 0 ? { durationms: turnarounds[step.id] } : {},
+      ...environments?.[step.id] !== void 0 ? { environment: environments[step.id] } : step.environment !== void 0 ? { environment: step.environment } : {},
+      active,
+      anchor: `#step-${step.id}`,
+      ...outcome !== void 0 ? { resultsummary: outcome.summary } : {}
+    };
+  });
+}
+var logstreamgenesis = "0".repeat(64);
+async function logstreameventof(input) {
+  if (input.summary.trim() === "") throw new Error("The logstream event needs its summary.");
+  const id = randomid();
+  const hash = await entryhashof({ previous: input.previous, entry: { id, runid: "surfaces", kind: "step", summary: input.summary, origin: input.origin, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, at: input.at } });
+  return { id, level: input.level, source: input.source, origin: input.origin, summary: input.summary, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, masked: input.masked, maskverdict: input.maskverdict, hash, at: input.at };
+}
+function appendlogstreamevent(events, event) {
+  return [...events, event];
+}
+function filterlogstream(events, filter) {
+  return events.filter((event) => (filter.level === void 0 || event.level === filter.level) && (filter.origin === void 0 || filter.origin === "" || event.origin === filter.origin) && (filter.stepid === void 0 || filter.stepid === "" || event.stepid === filter.stepid));
+}
+function livebufferof(events, bound) {
+  if (bound === void 0) return events;
+  if (!Number.isInteger(bound) || bound <= 0) return events;
+  return events.slice(-bound);
+}
+async function verifylogstream(events) {
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
+    if (event === void 0) continue;
+    const predecessor = events[index - 1];
+    const expectedprevious = index === 0 || predecessor === void 0 ? logstreamgenesis : predecessor.hash.current;
+    if (event.hash.previous !== expectedprevious) return { valid: false, brokenat: index, reason: `The logstream chain breaks at the event ${event.id}: its previous hash does not link to its predecessor.` };
+    const recomputed = await entryhashof({ previous: event.hash.previous, entry: { id: event.id, runid: "surfaces", kind: "step", summary: event.summary, origin: event.origin, ...event.stepid !== void 0 ? { stepid: event.stepid } : {}, at: event.at } });
+    if (recomputed.current !== event.hash.current) return { valid: false, brokenat: index, reason: `The logstream chain breaks at the event ${event.id}: its own hash does not reproduce.` };
+  }
+  return { valid: true, reason: `The logstream chain of ${events.length} event${events.length === 1 ? "" : "s"} verifies link by link.` };
+}
+async function auditexcerptof(events, input) {
+  if (input.from < 0 || input.to <= input.from || input.to > events.length) return { ok: false, text: "", reason: `The excerpt range ${input.from} to ${input.to} names no contiguous slice of the ${events.length} event${events.length === 1 ? "" : "s"}.` };
+  const range = events.slice(input.from, input.to);
+  const verification = await verifylogstream(range);
+  if (!verification.valid) return { ok: false, text: "", reason: `The excerpt refuses the copy: ${verification.reason}` };
+  const text2 = range.map((event) => `[${event.at}] ${event.level} ${event.source}${event.stepid !== void 0 ? ` step ${event.stepid}` : ""} ${event.origin} \u2014 ${event.summary}${event.masked ? ` (${event.maskverdict})` : ""}`).join("\n");
+  return { ok: true, text: text2, reason: `The excerpt copied the verified range ${input.from} to ${input.to} of the logstream.` };
+}
+function loglevelof(kind) {
+  if (kind === "error") return "error";
+  if (["deny", "revoke", "stop", "quarantine", "phish", "defer", "schema", "expiry"].includes(kind)) return "warn";
+  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) {
@@ -15378,6 +16300,33 @@ 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") void updatestatusbadge().catch(() => {
+  });
+}
+var surfacechannel = typeof BroadcastChannel === "function" ? new BroadcastChannel("devthinksurfaces") : void 0;
+var logstreamhistory = [];
+var recentframes = [];
+async function recordsurfaceevent(kind, summary, extra = {}) {
+  try {
+    const session = await memory.getsession();
+    const origin = session?.origin ?? "";
+    if (origin === "") return;
+    const at = Date.now();
+    const lastevent = logstreamhistory[logstreamhistory.length - 1];
+    const previous = lastevent !== void 0 ? lastevent.hash.current : logstreamgenesis;
+    const event = await logstreameventof({ level: loglevelof(kind), source: "background", origin, summary, ...extra.stepid !== void 0 ? { stepid: extra.stepid } : {}, masked: extra.masked === true, maskverdict: extra.masked === true ? extra.maskverdict ?? "The source payload stayed masked before it streamed." : "The source payload carries no masked value.", previous, at });
+    logstreamhistory = appendlogstreamevent(logstreamhistory, event);
+    const frame = broadcastframeof({ channel: broadcastchannelof(kind), surface: "background", summary, at });
+    recentframes = [...recentframes, frame];
+    surfacechannel?.postMessage(frame);
+  } catch {
+  }
+}
+async function broadcastsurfaceframe(input) {
+  const frame = broadcastframeof({ ...input, at: Date.now() });
+  recentframes = [...recentframes, frame];
+  surfacechannel?.postMessage(frame);
 }
 function stepoptions6(step) {
   try {
@@ -21145,6 +22094,8 @@ var commandschemas = {
   sessions: { note: "object", scratch: "object", summary: "object", recall: "object", correction: "object", consent: "object", grid: "object", search: "object", cancel: "object", retry: "object", error: "object", settings: "object", bundle: "object" },
   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" },
   execute: { stepid: "string" },
   configure: { endpoint: "string" }
 };
@@ -21371,6 +22322,608 @@ async function handlesessionscommand(message) {
   }
   throw new Error("The sessions command carries no note, scratch, summary, recall, correction, consent, grid, search, cancel, retry, error, settings or bundle action.");
 }
+async function grantedcapabilities() {
+  const report = await memory.getcapabilities();
+  const granted = ["activeTab", "storage", "scripting", "sidePanel"];
+  if (report?.tabs) granted.push("tabs");
+  if (report?.downloads) granted.push("downloads");
+  if (report?.clipboardread) granted.push("clipboardRead");
+  if (report?.clipboardwrite) granted.push("clipboardWrite");
+  if (await offscreengranted()) granted.push("offscreen");
+  return granted;
+}
+async function surfacesnapshotof(surface) {
+  const settings = await memory.getsettings();
+  const session = await memory.getsession();
+  const sessionactive = Boolean(session && !session.stoppedat && session.expiresat > Date.now());
+  const granted = await grantedcapabilities();
+  const plan = await memory.getplan();
+  const progress = await memory.getprogress();
+  const onboarding = await memory.getonboardingstate();
+  const palette = palettequery(palettecommandsof(surfacepalette(), { granted, sessionactive }), { text: "", usage: await memory.getpaletteusage(), ...settings?.paletterecents !== void 0 ? { recentwindow: settings.paletterecents } : {} });
+  const verification = await verifylogstream(logstreamhistory);
+  return surfacesnapshot({
+    surface,
+    palette,
+    timeline: plan ? stepstimelinenodes({ plan, ...progress !== void 0 && progress.planid === plan.id ? { progress } : {}, now: Date.now() }) : [],
+    logstream: { events: livebufferof(logstreamhistory, settings?.logstreambuffer).map((event) => ({ id: event.id, level: event.level, source: event.source, origin: event.origin, summary: event.summary, ...event.stepid !== void 0 ? { stepid: event.stepid } : {}, masked: event.masked, maskverdict: event.maskverdict, at: event.at })), chainvalid: verification.valid, reason: verification.reason },
+    plancards: plan !== void 0 ? plancardgroups(plancardsof({ plan, corrections: await memory.getcorrections() })) : [],
+    ...onboarding !== void 0 ? { onboarding: { stepscompleted: onboarding.stepscompleted, done: onboarding.done } } : {}
+  });
+}
+async function handlesurfacecommand(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 surfaceof = (value, fallback) => ["popup", "sidepanel", "dashboardpage", "optionspage", "onboarding"].includes(value ?? "") ? value : fallback;
+  if (input.palette !== void 0) {
+    const granted = await grantedcapabilities();
+    const entries = surfacepalette();
+    if (input.palette.used !== void 0) {
+      const command = input.palette.used.command?.trim() ?? "";
+      if (command === "") throw new Error("The palette use record needs its command.");
+      const usage = paletteuseafter(await memory.getpaletteusage(), command, now);
+      const record2 = usage[0];
+      if (record2 === void 0) throw new Error("The palette use record never landed.");
+      await memory.setpaletteusage(usage);
+      await audit("palette", `The user ran the ${command} command from the commandpalette; its ${record2.count} recorded use${record2.count === 1 ? "" : "s"} rank it first among equal matches.`, { ...session ? { sessionid: session.id } : {} });
+      return { usage: record2 };
+    }
+    if (input.palette.query !== void 0) {
+      const matches = palettequery(palettecommandsof(entries, { granted, sessionactive }), { text: input.palette.query.text ?? "", usage: await memory.getpaletteusage(), ...settings?.paletterecents !== void 0 ? { recentwindow: settings.paletterecents } : {} });
+      return { matches };
+    }
+    return { entries: palettecommandsof(entries, { granted, sessionactive }) };
+  }
+  if (input.task !== void 0) {
+    if (input.task.submit !== void 0) {
+      if (!session || session.stoppedat || session.expiresat <= now) throw new Error("Start a current browser session before submitting a task goal.");
+      const { tab, origin } = await activecontext();
+      if (session.tabid !== tab.id || session.origin !== origin) throw new Error("The selected tab or origin no longer matches the approved session.");
+      const version = await memory.getobservationversion();
+      const storedobservation = version !== void 0 ? await memory.getobservation(version) : void 0;
+      const context = storedobservation ? `${storedobservation.observation.title}: ${storedobservation.observation.textpreview}` : tab.title ?? "";
+      const submission = taskinputof({ text: input.task.submit.text ?? "", context, origin, surface: surfaceof(input.task.submit.surface, "popup"), at: now });
+      await memory.addtaskinput(submission);
+      const proposed = await propose(submission.text, false);
+      await audit("surface", `The ${submission.surface} taskinput submitted a natural language goal for ${origin} with the active origin and the page outline attached; the goal routed through the same proposal flow as the api and the plan ${proposed.id} now awaits its plancard review.`, { sessionid: session.id, planid: proposed.id });
+      await broadcastsurfaceframe({ channel: "runstate", surface: "background", summary: `A taskinput goal became the plan ${proposed.id} and awaits review.` });
+      return { submission, plan: proposed, status: "ready" };
+    }
+    if (input.task.history === true) return { history: await memory.gettaskinputs() };
+    if (input.task.status === true) return { status: plan === void 0 ? "idle" : plan.state === "pending" ? "ready" : plan.state === "approved" ? "ready" : "failed" };
+  }
+  if (input.onboarding !== void 0) {
+    const state = await memory.getonboardingstate();
+    if (input.onboarding.complete !== void 0) {
+      const stepid = input.onboarding.complete.stepid?.trim() ?? "";
+      const current = state ?? onboardingstart(void 0, now);
+      const completion = onboardingcomplete(current, stepid, now);
+      if (completion.consentevent !== void 0) {
+        const consentgate = onboardingconsentgate({ consentevents: current.consentevent !== void 0 ? [current.consentevent] : [] });
+        if (!consentgate.allowed) throw new Error(consentgate.reason);
+        const origin = session?.origin ?? "onboarding";
+        await memory.addconsentmemoryentry(consentmemoryof({ origin, decision: "grant", boundary: "onboarding", kinds: [], now }));
+      }
+      await memory.setonboardingstate(completion.state);
+      await audit("onboarding", completion.consentevent !== void 0 ? `The user finished the onboarding walkthrough and its completion wrote the single consent scoped event ${completion.consentevent}; the walkthrough never writes a second one.` : `The user completed the ${stepid} step of the onboarding walkthrough; ${completion.state.stepscompleted.length} of ${onboardingsteps().length} steps stand done.`, { ...session ? { sessionid: session.id } : {} });
+      await broadcastsurfaceframe({ channel: "settings", surface: "background", summary: completion.consentevent !== void 0 ? "The onboarding walkthrough completed." : `The onboarding step ${stepid} completed.` });
+      return { steps: onboardingsteps(), state: completion.state, ...completion.consentevent !== void 0 ? { consentevent: completion.consentevent } : {} };
+    }
+    if (input.onboarding.replay === true) {
+      const replayed = onboardingstart(state, now);
+      await memory.setonboardingstate(replayed);
+      await audit("onboarding", "The user replayed the onboarding walkthrough on demand from the optionspage; the replay restarts the steps and writes no second consent event.", {});
+      return { steps: onboardingsteps(), state: replayed };
+    }
+    return { steps: onboardingsteps(), ...state ? { state } : {} };
+  }
+  if (input.bus !== void 0 && input.bus.action !== void 0) {
+    const surface = surfaceof(input.bus.action.surface, "popup");
+    const command = input.bus.action.command?.trim() ?? "";
+    const action = { surface, command, ...input.bus.action.stepid !== void 0 && input.bus.action.stepid.trim() !== "" ? { stepid: input.bus.action.stepid } : {}, ...input.bus.action.payload !== void 0 && input.bus.action.payload.trim() !== "" ? { payload: input.bus.action.payload } : {} };
+    const granted = await grantedcapabilities();
+    const route = busrouteaction(action, { sessionactive, granted, planreviewed: Boolean(plan && plan.state === "approved"), planstate: plan?.state === "pending" ? "pending" : "approved", text: input.bus.action.payload ?? "", origin: session?.origin ?? "" });
+    if (!route.dispatched) throw new Error(route.reason);
+    await audit("surface", `The ${surface} routed the ${command} action through the command bus: ${route.reason}`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {} });
+    if (command === "starttask") {
+      if (!sessionactive) await handlerequest({ kind: "startsession" }, {});
+      const goal = (input.bus.action.payload ?? "").trim();
+      if (goal !== "") await propose(goal, false);
+    } else if (command === "pauserun") await handlerequest({ kind: "pausesession" }, {});
+    else if (command === "resumerun") await handlerequest({ kind: "resumesession" }, {});
+    else if (command === "cancelrun") {
+      if (plan) await handlerequest({ kind: "sessions", cancel: { runid: plan.id } }, {}).catch(() => {
+      });
+    } else if (command === "revokeconsent") {
+      if (session) await handlerequest({ kind: "security", allowlist: { remove: { origin: session.origin } } }, {}).catch(() => {
+      });
+    }
+    await broadcastsurfaceframe({ channel: "runstate", surface, summary: `The ${command} action of the ${surface} dispatched through the command bus.` });
+    return { route, palette: palettecommandsof(surfacepalette(), { granted, sessionactive }) };
+  }
+  if (input.broadcast !== void 0 && input.broadcast.frames === true) {
+    const bound = settings?.logstreambuffer;
+    const boundgate = logbufferboundvalid(bound);
+    if (!boundgate.allowed) throw new Error(boundgate.reason);
+    return { frames: bound === void 0 ? recentframes : recentframes.slice(-bound), logstream: livebufferof(logstreamhistory, bound), total: logstreamhistory.length };
+  }
+  if (input.layout !== void 0) {
+    if (input.layout.set !== void 0) {
+      const surface = surfaceof(input.layout.set.surface, "popup");
+      const preferences = input.layout.set.preferences ?? {};
+      await memory.setsurfacelayout({ surface, preferences, updatedat: now });
+      await audit("surface", `The user saved the layout preferences of the ${surface} with ${Object.keys(preferences).length} key${Object.keys(preferences).length === 1 ? "" : "s"}; the preferences scope per profile workspace and take effect without a reload.`, { ...session ? { sessionid: session.id } : {} });
+      return { layout: { surface, preferences, updatedat: now } };
+    }
+    if (input.layout.get !== void 0) return { layout: await memory.getsurfacelayout(surfaceof(input.layout.get.surface, "popup")) };
+  }
+  if (input.logstream !== void 0) {
+    if (input.logstream.read !== void 0) {
+      const stored = await memory.getlogstreamfilters();
+      const requested = input.logstream.read.filters;
+      const level = requested?.level !== void 0 && requested.level !== "" ? requested.level : stored?.level;
+      const origin = requested?.origin !== void 0 && requested.origin !== "" ? requested.origin : stored?.origin;
+      const stepid = requested?.stepid !== void 0 && requested.stepid !== "" ? requested.stepid : stored?.stepid;
+      const filter = {};
+      if (level !== void 0 && level !== "") filter.level = level;
+      if (origin !== void 0 && origin !== "") filter.origin = origin;
+      if (stepid !== void 0 && stepid !== "") filter.stepid = stepid;
+      const verification = await verifylogstream(logstreamhistory);
+      return { events: filterlogstream(livebufferof(logstreamhistory, settings?.logstreambuffer), filter), chain: verification, total: logstreamhistory.length };
+    }
+    if (input.logstream.excerpt !== void 0) {
+      const from = input.logstream.excerpt.from ?? 0;
+      const to = input.logstream.excerpt.to ?? logstreamhistory.length;
+      const excerpt = await auditexcerptof(logstreamhistory, { from, to });
+      const gate = logstreamegressgate({ verified: excerpt.ok, entries: Math.max(0, Math.min(to, logstreamhistory.length) - Math.max(0, from)) });
+      if (!gate.allowed) throw new Error(gate.reason);
+      await audit("logstream", `The user copied the verified range ${from} to ${to} of the live logstream as an audit excerpt; the copy left the stream only after the chain verified.`, { ...session ? { sessionid: session.id } : {} });
+      return { excerpt: excerpt.text, reason: excerpt.reason };
+    }
+    if (input.logstream.filters?.set !== void 0) {
+      const requested = input.logstream.filters.set;
+      const filter = {};
+      if (requested?.level !== void 0 && requested.level !== "") filter.level = requested.level;
+      if (requested?.origin !== void 0 && requested.origin !== "") filter.origin = requested.origin;
+      if (requested?.stepid !== void 0 && requested.stepid !== "") filter.stepid = requested.stepid;
+      await memory.setlogstreamfilters(filter);
+      await audit("surface", `The user saved the logstream filter preferences${Object.keys(filter).length > 0 ? ` for ${Object.entries(filter).map(([key, value]) => `${key} ${value}`).join(" and ")}` : ""}; the live view reopens with them.`, {});
+      return { filters: filter };
+    }
+  }
+  if (input.approve !== void 0 && input.approve.resolve !== void 0) {
+    const stepid = input.approve.resolve.stepid?.trim() ?? "";
+    const resolution = input.approve.resolve.resolution === "approve" || input.approve.resolve.resolution === "edit" ? input.approve.resolve.resolution : input.approve.resolve.resolution === "reject" ? "reject" : void 0;
+    if (resolution === void 0) throw new Error("The stepapprove resolution needs its approve, reject or edit decision.");
+    const surface = surfaceof(input.approve.resolve.surface, "sidepanel");
+    if (!plan || !["pending", "approved"].includes(plan.state)) throw new Error("The stepapprove resolution serves the pending or approved plan under review.");
+    const step = plan.steps.find((candidate) => candidate.id === stepid);
+    if (!step) throw new Error(`No step ${stepid} of the plan ${plan.id} exists to resolve.`);
+    const gate = stepapprovegate({ stepids: [stepid], resolution, surface });
+    if (!gate.allowed) throw new Error(gate.reason);
+    const record2 = stepresolutionof({ stepid, planid: plan.id, origin: plan.origin, resolution, surface, ...resolution === "edit" && input.approve.resolve.edited !== void 0 ? { edited: input.approve.resolve.edited } : {}, at: now });
+    await memory.addstepapproveresolution(record2);
+    const event = resolutionlogeventof(record2);
+    if (resolution === "edit") {
+      const edited = input.approve.resolve.edited ?? "";
+      try {
+        const shape = JSON.parse(edited);
+        const editedkind = shape.kind;
+        const editedsummary = shape.summary;
+        if (typeof editedkind !== "string" || editedkind.trim() === "" || typeof editedsummary !== "string" || editedsummary.trim() === "") throw new Error("The edited step shape needs its kind and summary.");
+        await memory.setplan({ ...plan, steps: plan.steps.map((candidate) => candidate.id === stepid ? { ...candidate, kind: editedkind, summary: editedsummary, ...shape.target !== void 0 ? { target: shape.target } : {}, ...shape.value !== void 0 ? { value: shape.value } : {}, ...shape.options !== void 0 ? { options: shape.options } : {} } : candidate) });
+        await memory.addcorrection(editedcorrectionof({ origin: plan.origin, kind: step.kind, stepid, original: JSON.stringify({ kind: step.kind, summary: step.summary, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, ...step.options !== void 0 ? { options: step.options } : {} }), corrected: edited, reason: `The user edited the step ${stepid} from the ${surface} before approving.`, now }));
+      } catch (error) {
+        throw new Error(error instanceof Error ? error.message : "The edited step shape failed to parse.");
+      }
+    }
+    if (resolution === "reject") await memory.addcorrection(rejectedcorrectionof({ origin: plan.origin, kind: step.kind, stepid, original: JSON.stringify({ kind: step.kind, summary: step.summary }), reason: `The user rejected the step ${stepid} from the ${surface}.`, now }));
+    await appendrunevent("review", event.summary, session, plan.origin, stepid);
+    await audit("approval", event.summary, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid });
+    await broadcastsurfaceframe({ channel: "runstate", surface, summary: `The step ${stepid} resolved with a ${resolution} from the ${surface}.` });
+    return { resolution: record2, cards: plancardsof({ plan: await memory.getplan() ?? plan, corrections: await memory.getcorrections() }) };
+  }
+  if (input.diff !== void 0 && input.diff.preview !== void 0) {
+    const stepid = input.diff.preview.stepid?.trim() ?? "";
+    if (!plan) throw new Error("The diffpreview serves the plan under review.");
+    const step = plan.steps.find((candidate) => candidate.id === stepid);
+    if (!step) throw new Error(`No step ${stepid} of the plan ${plan.id} exists to preview.`);
+    const gate = diffpreviewgate({ risk: step.risk });
+    if (!gate.allowed) throw new Error(gate.reason);
+    if (!session) throw new Error("The diffpreview needs its session to observe the before state.");
+    const before = input.diff.preview.before ?? {};
+    const options = stepoptions6(step);
+    const predicted = { ...Object.fromEntries(Object.entries(options).filter(([, value]) => typeof value === "string" || typeof value === "number" || typeof value === "boolean").map(([key, value]) => [key, String(value)])), ...step.value !== void 0 ? { value: step.value } : {}, ...step.target !== void 0 ? { target: step.target } : {} };
+    const after = Object.keys(input.diff.preview.after ?? {}).length > 0 ? input.diff.preview.after : predicted;
+    const payload = JSON.stringify({ before, after });
+    let provenance = "inline";
+    if (settings?.diffpreviewbytes !== void 0 && payload.length >= settings.diffpreviewbytes && await offscreengranted()) {
+      try {
+        const answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "parse", request: { id: randomid(), runid: plan.id, stepid, task: "diffpreview", payload, transferables: [] } });
+        if (answer?.ok === true) provenance = "offscreenworker";
+      } catch {
+      }
+    }
+    const sensitivefields = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].filter((field) => defaultmaskshapes.some((shape) => field.toLowerCase().includes(shape)));
+    const preview = diffpreviewof({ stepid, before, after, maskverdicts: maskverdictsof({ ...before, ...after }, sensitivefields), provenance });
+    await audit("diff", `The user opened the diffpreview of the write class step ${stepid} of the plan ${plan.id}: ${preview.changes.filter((change) => change.kind === "added").length} added, ${preview.changes.filter((change) => change.kind === "changed").length} changed and ${preview.changes.filter((change) => change.kind === "removed").length} removed field${preview.changes.length === 1 ? "" : "s"}${preview.maskverdicts && Object.keys(preview.maskverdicts).length > 0 ? ` with ${Object.keys(preview.maskverdicts).length} masked value${Object.keys(preview.maskverdicts).length === 1 ? "" : "s"} carrying their mask verdicts` : ""}${provenance === "offscreenworker" ? "; the generation offloaded to the offscreen worker pool" : ""}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid });
+    return { preview };
+  }
+  if (input.review !== void 0) {
+    const corrections = await memory.getcorrections();
+    const cards = plan ? plancardsof({ plan, corrections }) : [];
+    if (input.review.groups !== void 0 || input.review.cards !== void 0) return { cards, groups: plancardgroups(cards) };
+    return { cards };
+  }
+  if (input.timeline !== void 0 && input.timeline.nodes === true) {
+    if (!plan) return { nodes: [] };
+    const progress = await memory.getprogress();
+    return { nodes: stepstimelinenodes({ plan, ...progress !== void 0 && progress.planid === plan.id ? { progress } : {}, now }) };
+  }
+  if (input.dashboard !== void 0 && input.dashboard.view === true) {
+    const view = await memory.gettransparencyview();
+    const report = transparencyreport({ grants: transparencygrants({ allowlist: view.allowlist, profiles: view.profiles }), windows: windowhistory(view.windows), connectallow: connectallowlist(view.connectallow), permdiffs: view.permdiffs, safedefaults: view.safedefaults, vault: vaultview(view.vault) });
+    const onboarding = await memory.getonboardingstate();
+    return { sessionview: await sessionviewof(), transparency: report, onboarding: onboarding ?? { stepscompleted: [], done: false }, environments: await environmentviewof(), security: await securityviewof() };
+  }
+  if (input.snapshot !== void 0) return await surfacesnapshotof(surfaceof(input.snapshot.surface, "popup"));
+  if (input.settings !== void 0) {
+    const current = settings ?? {};
+    if (input.settings.logstreambuffer !== void 0) {
+      const boundgate = logbufferboundvalid(input.settings.logstreambuffer);
+      if (!boundgate.allowed) throw new Error(boundgate.reason);
+    }
+    if (input.settings.paletterecents !== void 0 && (!Number.isInteger(input.settings.paletterecents) || input.settings.paletterecents < 0)) throw new Error("The palette recent window stays a whole number of commands the user chose.");
+    if (input.settings.taskinputretention !== void 0 && input.settings.taskinputretention <= 0) throw new Error("The taskinput history retention stays a positive user value in milliseconds.");
+    if (input.settings.diffpreviewbytes !== void 0 && input.settings.diffpreviewbytes <= 0) throw new Error("The diffpreview byte ceiling stays a positive user value.");
+    const next = {
+      ...current,
+      ...input.settings.paletterecents !== void 0 ? { paletterecents: input.settings.paletterecents } : {},
+      ...input.settings.logstreambuffer !== void 0 ? { logstreambuffer: input.settings.logstreambuffer } : {},
+      ...input.settings.taskinputretention !== void 0 ? { taskinputretention: input.settings.taskinputretention } : {},
+      ...input.settings.paletteshortcut !== void 0 ? { paletteshortcut: input.settings.paletteshortcut } : {},
+      ...input.settings.diffpreviewbytes !== void 0 ? { diffpreviewbytes: input.settings.diffpreviewbytes } : {}
+    };
+    await memory.setsettings(next);
+    await audit("configure", `The user set the interface surface options${input.settings.paletterecents !== void 0 ? ` with the palette recent window of ${input.settings.paletterecents}` : ""}${input.settings.logstreambuffer !== void 0 ? ` and the logstream live buffer bound of ${input.settings.logstreambuffer}` : ""}${input.settings.paletteshortcut !== void 0 ? ` and the palette shortcut ${input.settings.paletteshortcut}` : ""}${input.settings.diffpreviewbytes !== void 0 ? ` and the diffpreview byte ceiling of ${input.settings.diffpreviewbytes}` : ""}; every write takes effect without reloading the extension.`, { ...session ? { sessionid: session.id } : {} });
+    await broadcastsurfaceframe({ channel: "settings", surface: "optionspage", summary: "The interface surface options changed and take effect without a reload." });
+    return { settings: next };
+  }
+  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 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 } : {} });
+    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 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 });
@@ -21506,7 +23059,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(), 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();
@@ -24578,6 +26131,10 @@ async function handlerequest(message, sender) {
     }
     case "sessions":
       return handlesessionscommand(message);
+    case "surface":
+      return handlesurfacecommand(message);
+    case "views":
+      return handlesurfaceviewcommand(message);
     case "security": {
       const input2 = message;
       const now = Date.now();
@@ -25629,6 +27186,14 @@ chrome.runtime.onStartup.addListener(() => {
   void runwatchdog().catch(() => {
   });
 });
+chrome.runtime.onInstalled.addListener((details) => {
+  void (async () => {
+    if (details.reason !== "install") return;
+    await memory.setonboardingstate(onboardingstart(await memory.getonboardingstate(), Date.now()));
+    await audit("onboarding", "Devthink installed for the first time and the onboarding walkthrough started; it walks the origin grants, the plan review, the run control and the log audit once.", {});
+  })().catch(() => {
+  });
+});
 async function pauseinterruptedworkflowruns() {
   for (const run of await memory.listworkflowruns()) {
     if (run.state !== "running") continue;