@wenathlan/extension 1.1.62 → 1.1.64

package/extension/dist/background.js

@@ -4900,6 +4900,265 @@ var sessionmemory = class {
       phishverdicts: await this.getphishverdicts()
     };
   }
+  /**
+   * Session interface persistence of the 1.1.63 family.
+   * The five session stores live here, scoped per profile workspace: the sitenotes per origin with sensitive bodies sealed at rest, the append only scratchpad entries per task with their step provenance, the distilled runsummaries per run and origin, the correctionmemory entries per origin and kind captured from plan review, and the consentmemory entries per origin with every grant, denial, expiry and revocation carrying its boundary; beside them the semanticrecall index with fingerprint deduplication answers ranked queries inside the run scope, the incremental historysearch corpus indexes session metadata, notes and summaries as they are written, the errorsurface payloads of failed steps keep their retry hints with the policy verdict, the per tab session references isolate parallel tabs, and the export bundles notes, summaries and corrections as one audit bundle.
+   * The recall seam stays documented: the local fingerprint index answers every query today while a future remote recall backend can take the same shapes behind the seam without touching the callers.
+   */
+  /** Replaces the stored site notes; a sensitive note carries its sealedbody only so the plain body never persists. */
+  async setsitenotes(notes) {
+    return this.adapter.set("sitenotes", notes);
+  }
+  /** Returns the stored site notes, oldest update first. */
+  async getsitenotes() {
+    return await this.adapter.get("sitenotes") ?? [];
+  }
+  /** Reads the site notes of one origin only; the read gate keeps the origin inside the session grants. */
+  async readsitenotes(origin) {
+    return (await this.getsitenotes()).filter((note) => note.origin === origin);
+  }
+  /** Writes one site note: a note of the same id keeps its latest edit while a new note joins the store. */
+  async writesitenote(note) {
+    const notes = await this.getsitenotes();
+    await this.setsitenotes(notes.some((candidate) => candidate.id === note.id) ? notes.map((candidate) => candidate.id === note.id ? note : candidate) : [...notes, note]);
+  }
+  /** Removes one site note by its id. */
+  async removesitenote(id) {
+    await this.setsitenotes((await this.getsitenotes()).filter((note) => note.id !== id));
+  }
+  /** Expires the site notes past the user configured window; an absent window keeps every note. */
+  async expiresitenotes(retention, now) {
+    if (retention === void 0) return await this.getsitenotes();
+    const kept = (await this.getsitenotes()).filter((note) => now - note.updatedat < retention);
+    await this.setsitenotes(kept);
+    return kept;
+  }
+  /** Replaces the stored scratchpad entries per task. */
+  async setscratchpad(entries) {
+    return this.adapter.set("scratchpad", entries);
+  }
+  /** Returns every stored scratchpad entry, newest first. */
+  async getscratchpadall() {
+    return await this.adapter.get("scratchpad") ?? [];
+  }
+  /** Appends one scratchpad entry: the pad stays append only so no later write rewrites an earlier entry. */
+  async appendscratchentry(entry) {
+    await this.setscratchpad([entry, ...await this.getscratchpadall()]);
+  }
+  /** Reads the scratchpad of one task session, newest first; entries of another task never cross the boundary. */
+  async readscratchpad(taskid, sessionid) {
+    return (await this.getscratchpadall()).filter((entry) => entry.taskid === taskid && entry.sessionid === sessionid);
+  }
+  /** Prunes the scratchpad entries past the user configured window; an absent window keeps every entry. */
+  async prunescratchentries(window2, now) {
+    if (window2 === void 0) return await this.getscratchpadall();
+    const kept = (await this.getscratchpadall()).filter((entry) => now - entry.at < window2);
+    await this.setscratchpad(kept);
+    return kept;
+  }
+  /** Stores one distilled run summary of a completed run. */
+  async setrunsummary(summary) {
+    return this.adapter.set(`runsummary:${summary.runid}`, summary);
+  }
+  /** Returns the stored run summary of one run; an absent summary returns undefined. */
+  async getrunsummary(runid) {
+    return this.adapter.get(`runsummary:${runid}`);
+  }
+  /** Lists the stored run summaries, oldest distillation first, optionally filtered by origin. */
+  async listrunsummaries(origin) {
+    const index = await this.adapter.get("runsummaryindex") ?? [];
+    const summaries = [];
+    for (const runid of index) {
+      const summary = await this.getrunsummary(runid);
+      if (summary) summaries.push(summary);
+    }
+    const filtered = origin === void 0 ? summaries : summaries.filter((summary) => summary.origins.includes(origin));
+    return filtered.sort((one, two) => one.distilledat - two.distilledat);
+  }
+  /** Tracks one run in the run summary index so the listing reads every stored summary. */
+  async trackrunsummary(runid) {
+    const index = await this.adapter.get("runsummaryindex") ?? [];
+    if (!index.includes(runid)) await this.adapter.set("runsummaryindex", [...index, runid]);
+  }
+  /** Expires the run summaries past the user configured window; an absent window keeps every summary. */
+  async expirerunsummaries(retention, now) {
+    const summaries = await this.listrunsummaries();
+    if (retention === void 0) return summaries;
+    const kept = [];
+    for (const summary of summaries) {
+      if (now - summary.distilledat > retention) await this.adapter.set(`runsummary:${summary.runid}`, { ...summary, steps: [], kinds: [], origins: summary.origins });
+      else kept.push(summary);
+    }
+    return kept;
+  }
+  /** Replaces the semantic recall index with its fingerprint deduplicated entries. */
+  async setrecallindex(index) {
+    return this.adapter.set("recallindex", index);
+  }
+  /** Returns the stored semantic recall index entries, newest first. */
+  async getrecallindex() {
+    return await this.adapter.get("recallindex") ?? [];
+  }
+  /** Adds one recall index entry with fingerprint deduplication: a repeated extraction keeps its first entry. */
+  async addrecallentry(entry) {
+    const index = await this.getrecallindex();
+    if (index.some((candidate) => candidate.fingerprint === entry.fingerprint && candidate.origin === entry.origin)) return;
+    await this.setrecallindex([entry, ...index]);
+  }
+  /** Answers one semantic recall query across the extraction stores: the local index ranks by text similarity inside the run scope and returns the provenance of every match. */
+  async semanticrecall(query, scope, rank) {
+    return rank(await this.getrecallindex(), query, scope);
+  }
+  /** Expires the recall index entries past the user configured window; the extraction records themselves stay for the audit trail. */
+  async expirerecallentries(window2, now) {
+    if (window2 === void 0) return await this.getrecallindex();
+    const kept = (await this.getrecallindex()).filter((entry) => now - entry.at < window2);
+    await this.setrecallindex(kept);
+    return kept;
+  }
+  /** Replaces the stored correction memory entries per origin and kind. */
+  async setcorrections(corrections) {
+    return this.adapter.set("corrections", corrections);
+  }
+  /** Returns the stored correction memory entries, newest first, optionally filtered by origin and kind. */
+  async getcorrections(filter) {
+    const entries = await this.adapter.get("corrections") ?? [];
+    return entries.filter((entry) => (filter?.origin === void 0 || entry.origin === filter.origin) && (filter?.kind === void 0 || entry.kind === filter.kind));
+  }
+  /** Records one correction memory entry captured from a plan review edit or rejection. */
+  async addcorrection(entry) {
+    await this.setcorrections([entry, ...await this.adapter.get("corrections") ?? []]);
+  }
+  /** Expires the correction memory entries past the user configured window; an absent window keeps every correction. */
+  async expirecorrectionentries(window2, now) {
+    if (window2 === void 0) return await this.getcorrections();
+    const kept = (await this.getcorrections()).filter((entry) => now - entry.at < window2);
+    await this.setcorrections(kept);
+    return kept;
+  }
+  /** Replaces the stored consent memory entries per origin. */
+  async setconsentmemory(entries) {
+    return this.adapter.set("consentmemory", entries);
+  }
+  /** Returns the stored consent memory entries, newest first, optionally filtered by origin. */
+  async getconsentmemory(origin) {
+    const entries = await this.adapter.get("consentmemory") ?? [];
+    return origin === void 0 ? entries : entries.filter((entry) => entry.origin === origin);
+  }
+  /** Records one consent memory entry per origin: every grant, denial, expiry and revocation lands with its boundary and kinds. */
+  async addconsentmemoryentry(entry) {
+    await this.setconsentmemory([entry, ...await this.adapter.get("consentmemory") ?? []]);
+  }
+  /** Replaces the stored error surface payloads of failed steps. */
+  async seterrorsurfaces(surfaces) {
+    return this.adapter.set("errorsurfaces", surfaces);
+  }
+  /** Returns the stored error surface payloads, newest first, optionally filtered by step. */
+  async geterrorsurfaces(stepid) {
+    const surfaces = await this.adapter.get("errorsurfaces") ?? [];
+    return stepid === void 0 ? surfaces : surfaces.filter((surface) => surface.stepid === stepid);
+  }
+  /** Records one error surface payload of a failed step with its retry hint and the policy verdict. */
+  async adderrorsurface(surface) {
+    await this.seterrorsurfaces([surface, ...await this.adapter.get("errorsurfaces") ?? []].slice(0, 500));
+  }
+  /** Replaces the incremental history search corpus of session metadata, notes and run summaries. */
+  async sethistoryindex(corpus) {
+    return this.adapter.set("historyindex", corpus);
+  }
+  /** Returns the incremental history search corpus, newest entry first. */
+  async gethistoryindex() {
+    return await this.adapter.get("historyindex") ?? [];
+  }
+  /** Adds one corpus entry to the incremental history index on each store write. */
+  async addhistoryentry(entry) {
+    const corpus = await this.gethistoryindex();
+    await this.sethistoryindex([entry, ...corpus.filter((candidate) => !(candidate.source === entry.source && candidate.id === entry.id))]);
+  }
+  /** Answers one history search query against the incremental corpus with the matched terms highlighted. */
+  async historysearch(query, search) {
+    return search(await this.gethistoryindex(), query);
+  }
+  /** Stores one per tab session reference so parallel tabs never collide inside the session stores. */
+  async settabsession(ref) {
+    return this.adapter.set(`tabsession:${ref.tabid}`, ref);
+  }
+  /** Returns the per tab session reference of one tab; an absent reference returns undefined. */
+  async gettabsession(tabid2) {
+    return this.adapter.get(`tabsession:${tabid2}`);
+  }
+  /** Lists every per tab session reference so the sessiongrid reads the per tab lock state of concurrent sessions. */
+  async listtabsessions() {
+    const tabs = await this.adapter.get("tabsessionindex") ?? [];
+    const refs = [];
+    for (const tabid2 of tabs) {
+      const ref = await this.gettabsession(tabid2);
+      if (ref) refs.push(ref);
+    }
+    return refs;
+  }
+  /** Tracks one tab in the per tab session index so the listing reads every isolated reference. */
+  async tracktabsession(tabid2) {
+    const tabs = await this.adapter.get("tabsessionindex") ?? [];
+    if (!tabs.includes(tabid2)) await this.adapter.set("tabsessionindex", [...tabs, tabid2]);
+  }
+  /** Exports the site notes, the run summaries and the correction memory as one audit bundle: sensitive note bodies stay sealed in the export. */
+  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()]);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -5181,6 +5440,11 @@ function isolatedinjection(step) {
   }
   return { world: "ISOLATED", code: step.value, args };
 }
+var runsummarytask = "runsummary";
+function summaryrequestof(input) {
+  if (input.payload.trim() === "") throw new Error("The runsummary request needs its payload reference.");
+  return { id: input.id, runid: input.runid, stepid: input.sessionid, task: runsummarytask, payload: input.payload, transferables: [], sentat: input.sentat };
+}
 
 // toolcatalog.ts
 var toolcatalogversion = 1;
@@ -10367,6 +10631,87 @@ function untrustedrendergate(input) {
   if (input.environment === "sandboxframe") return { allowed: true, reason: "The extracted markup renders inside the sandboxframe under its nonce with scripts and handlers stripped; the untrusted content never reenters the page context." };
   return { allowed: false, reason: `The extracted markup grades untrusted and refuses to render inside the ${input.environment}; every untrusted render routes through the sandboxframe.` };
 }
+function sitenotesreadgate(input) {
+  if (input.grants.includes(input.origin)) return { allowed: true, reason: `The session granted ${input.origin}, so the site notes of the origin read.` };
+  return { allowed: false, reason: `The session never granted ${input.origin}; the site notes of the origin refuse the read.` };
+}
+function sitenoteswritegate(input) {
+  if (!input.consent) return { allowed: false, reason: `The site note write for ${input.origin} needs the explicit consent of the user; no note lands without a reviewed write.` };
+  return { allowed: true, reason: `The user consented to the site note write for ${input.origin}; the note keeps its author provenance and its timestamps.` };
+}
+function scratchpadscopegate(input) {
+  if (input.taskid !== input.entrytaskid || input.sessionid !== input.entrysessionid) return { allowed: false, reason: `The scratchpad entry belongs to the task ${input.entrytaskid} of the session ${input.entrysessionid}; the task ${input.taskid} of the session ${input.sessionid} never crosses that boundary.` };
+  return { allowed: true, reason: `The scratchpad entry belongs to the task ${input.taskid} of the session ${input.sessionid} that asks for it.` };
+}
+function memoryreadscopegate(input) {
+  if (input.phase === "planning" || input.phase === "prompting") return { allowed: true, reason: `The ${input.phase} phase reads the correction and consent memory so the proposal and the prompt carry the prior decisions.` };
+  return { allowed: false, reason: `The ${input.phase} phase reads no correction or consent memory; the history serves the planning and the prompting alone.` };
+}
+function semanticrecallscopegate(input) {
+  if (input.origin === void 0) return { allowed: true, reason: `The recall query names no origin, so it ranks the ${input.scope.length} origin${input.scope.length === 1 ? "" : "s"} of the run scope only.` };
+  if (!input.scope.includes(input.origin)) return { allowed: false, reason: `The recall query asks for ${input.origin} while the run scope holds ${input.scope.length > 0 ? input.scope.join(", ") : "no origin"}; a recall across origins outside the run scope refuses.` };
+  return { allowed: true, reason: `The recall query asks for ${input.origin} inside the run scope; the ranking stays scoped.` };
+}
+function summarywindowvalid(window2) {
+  if (window2 === void 0) return { allowed: true, reason: "No runsummary window is configured, so the distillation keeps every step with no fixed cap." };
+  if (!Number.isInteger(window2) || window2 < 0) return { allowed: false, reason: "The runsummary window stays a whole number of steps the user chose; no engine cap exists." };
+  return { allowed: true, reason: `The runsummary window of ${window2} step${window2 === 1 ? "" : "s"} stays the user configured choice; no engine cap exists.` };
+}
+function sessionretentionvalid(window2) {
+  if (window2 === void 0) return { allowed: true, reason: "No retention window is configured, so the session store keeps every record forever." };
+  if (!Number.isFinite(window2) || window2 <= 0) return { allowed: false, reason: "The retention window stays a positive user value in milliseconds; no engine boundary expires a record." };
+  return { allowed: true, reason: `The retention window of ${window2} milliseconds stays the user configured choice.` };
+}
+function cancelrungate(input) {
+  if (input.rollbackscope === "none") return { allowed: true, reason: `The cancelrun stops the run with no rollback; the ${input.queuedstepids.length} queued step${input.queuedstepids.length === 1 ? "" : "s"} stay as the run left them and the ${input.executedstepids.length} executed step${input.executedstepids.length === 1 ? "" : "s"} stay in the sealed log.` };
+  return { allowed: true, reason: `The cancelrun rolls the ${input.queuedstepids.length} queued step${input.queuedstepids.length === 1 ? "" : "s"} back${input.queuedstepids.length > 0 ? ` (${input.queuedstepids.join(", ")})` : ""} while the ${input.executedstepids.length} executed step${input.executedstepids.length === 1 ? "" : "s"} stay untouched in the sealed log.` };
+}
+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.` };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -10617,7 +10962,7 @@ function maskexport(record2, shapes) {
 }
 
 // version.ts
-var packageversion = "1.1.62";
+var packageversion = "1.1.64";
 
 // types.ts
 var protocolversion = packageversion;
@@ -11594,6 +11939,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"];
@@ -12736,6 +13084,460 @@ function endcall(input) {
   return { contexts: input.contexts.map((candidate) => candidate.callid === input.callid ? context : candidate), context };
 }
 
+// sessioninterface.ts
+function textfingerprint(text2) {
+  let hash = 2166136261;
+  for (let index = 0; index < text2.length; index += 1) {
+    hash ^= text2.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function keystreambyte(id, position) {
+  let hash = 2166136261;
+  const source = `${id}:${position}`;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash & 255;
+}
+function sealnotebody(id, body) {
+  const sealed = Array.from(body, (character, index) => String.fromCharCode(character.charCodeAt(0) ^ keystreambyte(id, index))).join("");
+  return `sealed:${btoa(sealed)}`;
+}
+function opennotebody(id, sealedbody) {
+  if (!sealedbody.startsWith("sealed:")) return "";
+  try {
+    const sealed = atob(sealedbody.slice("sealed:".length));
+    return Array.from(sealed, (character, index) => String.fromCharCode(character.charCodeAt(0) ^ keystreambyte(id, index))).join("");
+  } catch {
+    return "";
+  }
+}
+function sitenoteof(input) {
+  if (input.origin.trim() === "") throw new Error("The site note needs its origin.");
+  if (input.title.trim() === "") throw new Error("The site note needs its title.");
+  if (input.body.trim() === "") throw new Error("The site note needs its body.");
+  const id = input.id ?? randomid();
+  if (input.sensitive === true) return { id, origin: input.origin, title: input.title.trim(), sealedbody: sealnotebody(id, input.body), author: input.author, sensitive: true, createdat: input.now, updatedat: input.now };
+  return { id, origin: input.origin, title: input.title.trim(), body: input.body, author: input.author, sensitive: false, createdat: input.now, updatedat: input.now };
+}
+function notebodyof(note) {
+  if (note.sensitive) return note.sealedbody !== void 0 ? opennotebody(note.id, note.sealedbody) : "";
+  return note.body ?? "";
+}
+function editnote(note, input) {
+  if (input.title.trim() === "") throw new Error("The site note keeps a non empty title.");
+  if (input.body.trim() === "") throw new Error("The site note keeps a non empty body.");
+  if (note.sensitive) return { ...note, title: input.title.trim(), sealedbody: sealnotebody(note.id, input.body), updatedat: input.now, author: input.author };
+  return { ...note, title: input.title.trim(), body: input.body, updatedat: input.now, author: input.author };
+}
+function scratchentryof(input) {
+  if (input.taskid.trim() === "") throw new Error("The scratchpad entry needs its task.");
+  if (input.text.trim() === "") throw new Error("The scratchpad entry needs its text.");
+  return { id: input.id ?? randomid(), taskid: input.taskid, sessionid: input.sessionid, text: input.text, ...input.stepid !== void 0 && input.stepid.trim() !== "" ? { stepid: input.stepid } : {}, author: input.author, at: input.now };
+}
+function distillrunsummary(input) {
+  const steps = input.outcomes.map((outcome) => {
+    const step = input.plan.steps.find((candidate) => candidate.id === outcome.stepid);
+    return { stepid: outcome.stepid, kind: step?.kind ?? "unknown", ok: outcome.ok, summary: outcome.summary };
+  });
+  const windowed = input.window !== void 0 && Number.isInteger(input.window) && input.window >= 0 ? steps.slice(Math.max(0, steps.length - input.window)) : steps;
+  const kinds = [...new Set(windowed.map((step) => step.kind))];
+  return { runid: input.plan.id, sessionid: input.sessionid, origins: [...new Set(input.origins)], kinds, steps: windowed, ...input.window !== void 0 && Number.isInteger(input.window) && input.window >= 0 ? { window: input.window } : {}, task: "runsummary", provenance: input.provenance, distilledat: input.now };
+}
+function summaryhistoryentry(summary) {
+  return { source: "summary", id: summary.runid, title: `Run summary of ${summary.runid}`, text: `${summary.origins.join(" ")} ${summary.kinds.join(" ")} ${summary.steps.map((step) => step.summary).join(" ")}`, outcome: summary.steps.every((step) => step.ok) ? "completed" : "failed", at: summary.distilledat };
+}
+function notehistoryentry(note) {
+  return { source: "note", id: note.id, ...note.origin !== "" ? { origin: note.origin } : {}, title: note.title, text: note.sensitive ? note.title : `${note.title} ${note.body ?? ""}`, at: note.updatedat };
+}
+function recallentryof(input) {
+  if (input.text.trim() === "") throw new Error("The recall index entry needs its text.");
+  if (input.stepid.trim() === "" || input.runid.trim() === "") throw new Error("The recall index entry needs its run and step provenance.");
+  const normalized = input.text.trim().replace(/\s+/g, " ");
+  return { fingerprint: textfingerprint(normalized), origin: input.origin, runid: input.runid, stepid: input.stepid, text: normalized, at: input.at };
+}
+function termsof(text2) {
+  return new Set(text2.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1));
+}
+function rankrecall(index, query, scope) {
+  if (query.text.trim() === "") return [];
+  const terms = termsof(query.text);
+  const scoped = query.origin !== void 0 && query.origin.trim() !== "" ? [query.origin] : scope.origins;
+  const matches = [];
+  for (const entry of index) {
+    if (!scoped.includes(entry.origin)) continue;
+    const entryterms = termsof(entry.text);
+    let shared = 0;
+    for (const term of terms) if (entryterms.has(term)) shared += 1;
+    const union = (/* @__PURE__ */ new Set([...terms, ...entryterms])).size;
+    const score = union === 0 ? 0 : shared / union;
+    if (score <= 0) continue;
+    matches.push({ entry, score, reason: `The extraction of ${entry.origin} shares ${shared} term${shared === 1 ? "" : "s"} with the query at the score ${score.toFixed(3)}; the match carries the run ${entry.runid} and the step ${entry.stepid}.` });
+  }
+  const ranked = matches.sort((one, two) => two.score - one.score);
+  return query.limit !== void 0 && Number.isInteger(query.limit) && query.limit >= 0 ? ranked.slice(0, query.limit) : ranked;
+}
+function editedcorrectionof(input) {
+  if (input.stepid.trim() === "" || input.kind.trim() === "") throw new Error("The correction needs its step and kind.");
+  if (input.original === input.corrected) throw new Error("The correction needs a changed step shape.");
+  return { id: input.id ?? randomid(), origin: input.origin, kind: input.kind, stepid: input.stepid, source: "edited", original: input.original, corrected: input.corrected, reason: input.reason, at: input.now };
+}
+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.");
+  return { id: input.id ?? randomid(), origin: input.origin, decision: input.decision, boundary: input.boundary, kinds: [...new Set(input.kinds)], at: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+}
+function consentadvisoryverdict(entries, origin, kind) {
+  const matching = entries.filter((entry) => entry.origin === origin && entry.kinds.includes(kind));
+  const latest = matching[matching.length - 1];
+  if (latest === void 0) return { advisory: false, reason: `No prior decision exists for the ${kind} kind on ${origin}; the prompt opens fresh.` };
+  if (latest.decision === "deny") return { advisory: true, reason: `The consent memory holds a prior denial of the ${kind} kind on ${origin} from ${new Date(latest.at).toISOString()}; the denial carries the same weight as a grant and the record stays advisory only.` };
+  return { advisory: true, reason: `The consent memory holds a prior ${latest.decision} of the ${kind} kind on ${origin} with the boundary ${latest.boundary}; the record advises the new prompt and never auto grants.` };
+}
+function rollbacksplit(plan, progress) {
+  const executed = progress && progress.planid === plan?.id ? progress.completedsteps : [];
+  const executedset = new Set(executed);
+  const queued = (plan?.steps ?? []).map((step) => step.id).filter((id) => !executedset.has(id));
+  return { executedstepids: executed, queuedstepids: queued };
+}
+function rollbackof(plan, progress, preference) {
+  const split = rollbacksplit(plan, progress);
+  if (preference === "none") return { scope: "none", label: `Stop the run ${plan?.id ?? ""} without a rollback; the ${split.queuedstepids.length} queued step${split.queuedstepids.length === 1 ? "" : "s"} stay as the run left them.`, queuedstepids: split.queuedstepids };
+  return { scope: "queued", label: `Cancel the run ${plan?.id ?? ""} and roll its ${split.queuedstepids.length} queued step${split.queuedstepids.length === 1 ? "" : "s"} back${split.queuedstepids.length > 0 ? ` (${split.queuedstepids.join(", ")})` : ""} while the ${split.executedstepids.length} executed step${split.executedstepids.length === 1 ? "" : "s"} stay untouched in the sealed log.`, queuedstepids: split.queuedstepids };
+}
+function cancelrunactionof(input) {
+  return { runid: input.runid, sessionid: input.sessionid, rollback: rollbackof(input.plan, input.progress, input.preference) };
+}
+function errorsurfaceof(input) {
+  if (input.message.trim() === "") throw new Error("The error surface needs its message in plain language.");
+  return { stepid: input.stepid, runid: input.runid, cause: input.cause, message: input.message, retry: { allowed: input.retryallowed, reason: input.retryreason }, context: input.context, at: input.now };
+}
+function classifyfailure(input) {
+  if (input.gatewait) return "gate";
+  if (input.policyrefused) return "policy";
+  if (/\b(network|offline|timeout|timed out|fetch failed|socket|dns|connection)\b/i.test(input.message)) return "network";
+  return "page";
+}
+function sessiongridrows(input) {
+  const rows = [];
+  if (input.session && input.plan && ["pending", "approved"].includes(input.plan.state)) {
+    const split = rollbacksplit(input.plan, input.progress);
+    const held = input.locks.some((lock) => lock.runid === input.plan?.id);
+    const origins = [.../* @__PURE__ */ new Set([input.session.origin, ...input.session.grants ?? []])];
+    const actions = ["cancelrun"];
+    if (input.session.pausedat !== void 0) actions.push("resume");
+    rows.push({ sessionid: input.session.id, runid: input.plan.id, origins, state: "live", outcome: `${split.executedstepids.length} of ${input.plan.steps.length} reviewed steps executed`, steps: input.plan.steps.length, completed: split.executedstepids.length, lock: held ? "held" : "free", tabid: input.session.tabid, updatedat: input.plan.createdat, actions });
+  }
+  for (const log of input.logs) {
+    const summary = input.summaries.find((candidate) => candidate.runid === log.runid);
+    const tabsession = input.tabsessions.find((candidate) => candidate.runid === log.runid);
+    const held = input.locks.some((lock) => lock.runid === log.runid);
+    rows.push({ sessionid: log.sessionid, runid: log.runid, origins: [...new Set(log.entries.map((entry) => entry.origin).filter((origin) => origin !== ""))], state: "saved", outcome: summary !== void 0 ? summary.steps.every((step) => step.ok) ? "completed" : "failed" : log.seal !== void 0 ? "sealed" : "open", steps: summary?.steps.length ?? log.entries.filter((entry) => entry.kind === "step").length, completed: summary?.steps.filter((step) => step.ok).length ?? log.entries.filter((entry) => entry.kind === "step").length, lock: held ? "held" : "free", ...log.seal !== void 0 ? { sealhash: log.seal.sealhash.current } : {}, ...tabsession !== void 0 ? { tabid: tabsession.tabid } : {}, updatedat: log.updatedat, actions: ["reopen"] });
+  }
+  return rows.sort((one, two) => two.updatedat - one.updatedat);
+}
+function historyqueryof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.text !== "string" || candidate.text.trim() === "") return void 0;
+  const origin = typeof candidate.origin === "string" && candidate.origin.trim() !== "" ? candidate.origin.trim() : void 0;
+  const from = typeof candidate.from === "number" && Number.isFinite(candidate.from) ? candidate.from : void 0;
+  const to = typeof candidate.to === "number" && Number.isFinite(candidate.to) ? candidate.to : void 0;
+  if (from !== void 0 && to !== void 0 && from > to) return void 0;
+  const outcome = typeof candidate.outcome === "string" && candidate.outcome.trim() !== "" ? candidate.outcome.trim() : void 0;
+  return { text: candidate.text.trim(), ...origin !== void 0 ? { origin } : {}, ...from !== void 0 ? { from } : {}, ...to !== void 0 ? { to } : {}, ...outcome !== void 0 ? { outcome } : {} };
+}
+function historysearch(corpus, query) {
+  const terms = query.text.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1);
+  const hits = [];
+  for (const entry of corpus) {
+    if (query.origin !== void 0 && entry.origin !== query.origin) continue;
+    if (query.from !== void 0 && entry.at < query.from) continue;
+    if (query.to !== void 0 && entry.at > query.to) continue;
+    if (query.outcome !== void 0 && entry.outcome !== query.outcome) continue;
+    const haystack = `${entry.title} ${entry.text}`.toLowerCase();
+    const matched = terms.filter((term) => haystack.includes(term));
+    if (matched.length === 0) continue;
+    const position = haystack.indexOf(matched[0] ?? "");
+    const start = Math.max(0, position - 40);
+    const excerpt = `${start > 0 ? "\u2026" : ""}${`${entry.title} ${entry.text}`.slice(start, start + 160)}${start + 160 < `${entry.title} ${entry.text}`.length ? "\u2026" : ""}`;
+    hits.push({ source: entry.source, id: entry.id, title: entry.title, excerpt, highlights: [...new Set(matched)], ...entry.origin !== void 0 ? { origin: entry.origin } : {}, ...entry.outcome !== void 0 ? { outcome: entry.outcome } : {}, at: entry.at });
+  }
+  return hits.sort((one, two) => two.at - one.at);
+}
+function tabsessionrefof(input) {
+  if (!Number.isInteger(input.tabid) || input.tabid < 0) throw new Error("The per tab session reference needs its tab.");
+  if (input.sessionid.trim() === "") throw new Error("The per tab session reference needs its session.");
+  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";
+}
+
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
 function buildrequest(input) {
@@ -14934,6 +15736,31 @@ 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);
+}
+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 {
@@ -15471,6 +16298,10 @@ async function startsession() {
   const { tab, origin } = await activecontext();
   const session = { id: randomid(), tabid: tab.id, origin, startedat: Date.now(), expiresat: Date.now() + sessionduration, grants: [origin] };
   await memory.setsession(session);
+  await memory.settabsession(tabsessionrefof({ tabid: session.tabid, sessionid: session.id, origin, now: session.startedat }));
+  await memory.tracktabsession(session.tabid);
+  await memory.addconsentmemoryentry(consentmemoryof({ origin, decision: "grant", boundary: `the session expiry at ${new Date(session.expiresat).toISOString()}`, kinds: ["observe"], now: session.startedat }));
+  if ((await memory.getsettings())?.historyindex !== false) await memory.addhistoryentry({ source: "session", id: session.id, origin, title: `Session of ${origin}`, text: `session ${origin} started ${new Date(session.startedat).toISOString()}`, at: session.startedat });
   await memory.addallowlistorigin({ origin, profileid: runstateprofile, grantedat: session.startedat });
   const scope = scopegrantof({ origin, kinds: ["observe"], boundary: `the session expiry at ${new Date(session.expiresat).toISOString()}`, now: session.startedat });
   let runlog = openrunlog({ runid: session.id, sessionid: session.id, now: session.startedat });
@@ -20420,6 +21251,8 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
     }
     await audit("deny", `The ${step.kind} step ${step.id} on ${origin} was denied without navigation: ${securityverdict.reason}`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
     if (securityverdict.suspended && session) {
+      await memory.addconsentmemoryentry(consentmemoryof({ origin, decision: "expire", boundary: "the consent window boundary that expired mid step", kinds: [step.kind], now: Date.now() })).catch(() => {
+      });
       await appendrunevent("expiry", `The consent window of ${origin} expired mid step and the run suspended at the step ${step.id}; a new explicit prompt renews it.`, session, origin, step.id).catch(() => {
       });
       await audit("expiry", `The consent window of ${origin} expired mid step and the run suspended at the step ${step.id}; the executor refuses to resume without a new explicit prompt.`, { sessionid: session.id, ...plan ? { planid: plan.id } : {}, stepid: step.id });
@@ -20559,6 +21392,17 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   const auditkind = stepauditkind(step, Boolean(output?.ok));
   await audit(auditkind, summary, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
   await memory.addoutcome(outcome);
+  if (session && plan) await memory.appendscratchentry(scratchentryof({ taskid: plan.id, sessionid: session.id, text: `${step.kind} ${step.id} ${outcome.ok ? "completed" : "failed"}: ${summary}`, stepid: step.id, author: "agent", now: Date.now() })).catch(() => {
+  });
+  if (plan) await memory.addrecallentry(recallentryof({ origin, runid: plan.id, stepid: step.id, text: summary, at: Date.now() })).catch(() => {
+  });
+  let stepretry;
+  if (!outcome.ok && plan) {
+    const surface = errorsurfaceof({ stepid: step.id, runid: plan.id, message: summary, cause: classifyfailure({ message: summary, policyrefused: false, gatewait: false }), retryallowed: true, retryreason: "The failed step may dispatch again through the full consent gate chain.", context: { origin, kind: step.kind, environment: routing.environment }, now: Date.now() });
+    await memory.adderrorsurface(surface).catch(() => {
+    });
+    stepretry = { allowed: true, reason: `The ${surface.cause} failure of the step ${step.id} may retry through a new reviewed dispatch; the retry rides the full consent gate chain and never bypasses the review.` };
+  }
   if (session) await appendrunevent("step", `The ${step.kind} step ${step.id} ${outcome.ok ? "completed" : "failed"} on ${origin}: ${summary}${securityverdict.classification.sensitive ? ` The step grades ${securityverdict.classification.reason}` : ""}`, session, origin, step.id).catch(() => {
   });
   if (output?.ok && plan && mode === "plan") {
@@ -20590,11 +21434,36 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
       const done = { ...plan, state: "completed", completedat: Date.now() };
       await memory.setplan(done);
       await closeplanrun(done.id, session?.id ?? "");
+      await distillcompletedrun(done, tracked, session, settings).catch(() => {
+      });
       await audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
     }
   }
+  if (stepretry !== void 0 && output !== void 0) return { ...output, retry: stepretry };
+  if (stepretry !== void 0) return { ok: false, summary, retry: stepretry };
   return output ?? { ok: false, summary };
 }
+async function distillcompletedrun(plan, progress, session, settings) {
+  const log = await memory.getimmutablelog(plan.id);
+  const origins = [.../* @__PURE__ */ new Set([session?.origin ?? "", ...(log?.entries ?? []).map((entry) => entry.origin).filter((entryorigin) => entryorigin !== "")])].filter((entryorigin) => entryorigin !== "");
+  let provenance = "inline";
+  const inline = distillrunsummary({ plan, outcomes: progress.outcomes ?? [], origins, sessionid: session?.id ?? "", ...settings?.summarywindow !== void 0 ? { window: settings.summarywindow } : {}, provenance: "inline", now: Date.now() });
+  const ready = await ensureoffscreendocument(plan.id).catch(() => false);
+  if (ready) {
+    const request = summaryrequestof({ id: randomid(), runid: plan.id, sessionid: session?.id ?? "", payload: JSON.stringify({ runid: plan.id, steps: inline.steps.length, window: settings?.summarywindow }), sentat: Date.now() });
+    try {
+      const answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "summary", request: { id: request.id, runid: request.runid, stepid: request.stepid, task: runsummarytask, payload: request.payload, transferables: [] } });
+      if (answer && answer.ok !== false) provenance = "offscreenworker";
+    } catch {
+    }
+  }
+  const summary = { ...inline, provenance };
+  await memory.setrunsummary(summary);
+  await memory.trackrunsummary(plan.id);
+  if (settings?.historyindex !== false) await memory.addhistoryentry(summaryhistoryentry(summary));
+  await audit("summary", `The run summary of ${plan.id} distilled ${summary.steps.length} step outcome${summary.steps.length === 1 ? "" : "s"} across ${summary.origins.length} origin${summary.origins.length === 1 ? "" : "s"} as one ${provenance === "offscreenworker" ? "offscreen worker task" : "inline distillation"}${summary.window !== void 0 ? ` inside the user configured window of ${summary.window} steps` : " with no window cap"}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id });
+  return summary;
+}
 async function previewstep(stepid) {
   const session = await memory.getsession();
   const plan = await memory.getplan();
@@ -20656,8 +21525,10 @@ async function provenancereportValue() {
 }
 var commandschemas = {
   security: { allowlist: "object", profile: "object", consent: "object", revoke: "object", mask: "object", read: "object", export: "object", settings: "object", gate: "object", vault: "object", connectallow: "object", ratelimit: "object", redact: "object" },
+  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" },
   execute: { stepid: "string" },
   configure: { endpoint: "string" }
 };
@@ -20669,6 +21540,494 @@ function schemavalidation(message) {
   if (schema === void 0) return [];
   return schemacheck({ command, schema }).errors;
 }
+async function sessionviewof() {
+  const session = await memory.getsession();
+  const plan = await memory.getplan();
+  const settings = await memory.getsettings();
+  const progress = await memory.getprogress();
+  const notes = await memory.getsitenotes();
+  const scratch = plan && session ? await memory.readscratchpad(plan.id, session.id) : [];
+  const summaries = await memory.listrunsummaries();
+  const corrections = await memory.getcorrections();
+  const consentmemory = await memory.getconsentmemory();
+  const index = await memory.getrecallindex();
+  const scope = session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [];
+  const recall = rankrecall(index, { text: plan?.objective ?? session?.origin ?? "" }, { origins: scope }).slice(0, 5);
+  const errors = (await memory.geterrorsurfaces()).slice(0, 20);
+  const rows = sessiongridrows({ ...session !== void 0 ? { session } : {}, ...plan !== void 0 ? { plan } : {}, ...progress !== void 0 ? { progress } : {}, logs: await memory.listimmutablelogs(), summaries, locks: await memory.getrunlocks(), tabsessions: await memory.listtabsessions() });
+  return {
+    grid: rows.map((row) => ({ sessionid: row.sessionid, runid: row.runid, origins: row.origins, state: row.state, outcome: row.outcome, steps: row.steps, completed: row.completed, lock: row.lock, ...row.tabid !== void 0 ? { tabid: row.tabid } : {}, ...row.sealhash !== void 0 ? { sealhash: row.sealhash } : {}, updatedat: row.updatedat, actions: row.actions })),
+    notes: notes.map((note) => ({ id: note.id, origin: note.origin, title: note.title, body: notebodyof(note), author: note.author, sensitive: note.sensitive, updatedat: note.updatedat })),
+    scratchpad: scratch.map((entry) => ({ id: entry.id, taskid: entry.taskid, text: entry.text, ...entry.stepid !== void 0 ? { stepid: entry.stepid } : {}, author: entry.author, at: entry.at })),
+    summaries: summaries.map((summary) => ({ runid: summary.runid, origins: summary.origins, kinds: summary.kinds, steps: summary.steps.length, provenance: summary.provenance, distilledat: summary.distilledat })),
+    corrections: corrections.slice(0, 20).map((entry) => ({ id: entry.id, origin: entry.origin, kind: entry.kind, stepid: entry.stepid, source: entry.source, reason: entry.reason, at: entry.at })),
+    consentmemory: consentmemory.slice(0, 20).map((entry) => ({ id: entry.id, origin: entry.origin, decision: entry.decision, boundary: entry.boundary, kinds: entry.kinds, at: entry.at, ...entry.expiresat !== void 0 ? { expiresat: entry.expiresat } : {} })),
+    recall: recall.map((match) => ({ origin: match.entry.origin, runid: match.entry.runid, stepid: match.entry.stepid, score: match.score, reason: match.reason })),
+    errors: errors.map((surface) => ({ stepid: surface.stepid, runid: surface.runid, cause: surface.cause, message: surface.message, retry: surface.retry, at: surface.at })),
+    emptystates: [
+      { surface: "sessiongrid", message: rows.length === 0 ? "No session exists yet; start the first run by describing an objective and reviewing the plan the agent proposes." : "" },
+      { surface: "historysearch", message: "No history matches yet; start with a first query such as an origin, a note title or a kind the runs executed." },
+      { surface: "sitenotes", message: notes.length === 0 ? `No site note exists${session ? ` for ${session.origin}` : ""} yet; write the first note with a title and a body and the note flow keeps it per origin with its author provenance.` : "" },
+      { surface: "scratchpad", message: scratch.length === 0 ? "The scratchpad holds no entry yet; the agent appends its per task notes here while the reviewed steps run, and every entry carries its step provenance." : "" }
+    ].filter((state) => state.message !== ""),
+    ...settings?.cancelrollback !== void 0 ? { cancelrollback: settings.cancelrollback } : {},
+    historyindex: settings?.historyindex !== false
+  };
+}
+async function handlesessionscommand(message) {
+  const input = message;
+  const now = Date.now();
+  const session = await memory.getsession();
+  const plan = await memory.getplan();
+  const settings = await memory.getsettings();
+  if (input.note !== void 0) {
+    if (input.note.add !== void 0) {
+      const origin = input.note.add.origin?.trim() || session?.origin || "";
+      if (origin === "") throw new Error("The site note needs its origin.");
+      const writegate = sitenoteswritegate({ consent: input.note.add.consent === true, origin });
+      if (!writegate.allowed) throw new Error(writegate.reason);
+      const note = sitenoteof({ origin, title: input.note.add.title ?? "", body: input.note.add.body ?? "", author: "user", ...input.note.add.sensitive === true ? { sensitive: true } : {}, now });
+      await memory.writesitenote(note);
+      if (settings?.historyindex !== false) await memory.addhistoryentry(notehistoryentry(note));
+      await audit("notes", `The user wrote the site note ${note.id} for ${origin}${note.sensitive ? " with its body sealed at rest" : ""}; the note keeps its author provenance and its timestamps.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...await sessionviewof(), note };
+    }
+    if (input.note.edit !== void 0) {
+      const id = input.note.edit.id?.trim() ?? "";
+      const note = (await memory.getsitenotes()).find((candidate) => candidate.id === id);
+      if (!note) throw new Error(`No site note ${id} exists to edit.`);
+      const writegate = sitenoteswritegate({ consent: true, origin: note.origin });
+      if (!writegate.allowed) throw new Error(writegate.reason);
+      const edited = editnote(note, { title: input.note.edit.title ?? note.title, body: input.note.edit.body ?? notebodyof(note), author: "user", now });
+      await memory.writesitenote(edited);
+      if (settings?.historyindex !== false) await memory.addhistoryentry(notehistoryentry(edited));
+      await audit("notes", `The user edited the site note ${edited.id} of ${edited.origin}; the edit keeps the created timestamp and names its author.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...await sessionviewof(), note: edited };
+    }
+    if (input.note.remove !== void 0) {
+      const id = input.note.remove.id?.trim() ?? "";
+      await memory.removesitenote(id);
+      await audit("notes", `The user removed the site note ${id}.`, { ...session ? { sessionid: session.id } : {} });
+      return { ...await sessionviewof(), removed: id };
+    }
+    if (input.note.list !== void 0) {
+      const origin = input.note.list.origin?.trim() || session?.origin || "";
+      if (origin === "") throw new Error("The site note read needs its origin.");
+      const readgate = sitenotesreadgate({ origin, grants: session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [] });
+      if (!readgate.allowed) throw new Error(readgate.reason);
+      return { notes: (await memory.readsitenotes(origin)).map((note) => ({ id: note.id, origin: note.origin, title: note.title, body: notebodyof(note), author: note.author, sensitive: note.sensitive, updatedat: note.updatedat })) };
+    }
+  }
+  if (input.scratch !== void 0) {
+    if (!session || !plan) throw new Error("The scratchpad serves the running task of an active session.");
+    const taskid = input.scratch.append?.taskid?.trim() || input.scratch.read?.taskid?.trim() || plan.id;
+    const scopegate2 = scratchpadscopegate({ taskid, sessionid: session.id, entrytaskid: taskid, entrysessionid: session.id });
+    if (!scopegate2.allowed) throw new Error(scopegate2.reason);
+    if (input.scratch.append !== void 0) {
+      const entry = scratchentryof({ taskid, sessionid: session.id, text: input.scratch.append.text ?? "", ...input.scratch.append.stepid !== void 0 && input.scratch.append.stepid.trim() !== "" ? { stepid: input.scratch.append.stepid } : {}, author: "user", now });
+      await memory.appendscratchentry(entry);
+      await audit("scratchpad", `The user appended one scratchpad entry to the task ${taskid}${entry.stepid !== void 0 ? ` beside the step ${entry.stepid}` : ""}; the pad stays append only.`, { sessionid: session.id, planid: taskid });
+      return { ...await sessionviewof(), entry };
+    }
+    if (input.scratch.read !== void 0) return { scratchpad: await memory.readscratchpad(taskid, session.id) };
+  }
+  if (input.summary !== void 0) {
+    if (input.summary.read !== void 0) {
+      const runid = input.summary.read.runid?.trim() || plan?.id || "";
+      const summary = await memory.getrunsummary(runid);
+      if (!summary) throw new Error(`No run summary exists for the run ${runid}.`);
+      return { summary };
+    }
+    if (input.summary.list !== void 0) return { summaries: await memory.listrunsummaries(input.summary.list.origin?.trim() || void 0) };
+  }
+  if (input.recall !== void 0 && input.recall.query !== void 0) {
+    const text2 = input.recall.query.text?.trim() ?? "";
+    if (text2 === "") throw new Error("The semantic recall query needs its text.");
+    const scope = session ? [.../* @__PURE__ */ new Set([session.origin, ...session.grants ?? []])] : [];
+    const scopegate2 = semanticrecallscopegate({ origin: input.recall.query.origin?.trim() || void 0, scope });
+    if (!scopegate2.allowed) throw new Error(scopegate2.reason);
+    const matches = await memory.semanticrecall({ text: text2, ...input.recall.query.origin !== void 0 && input.recall.query.origin.trim() !== "" ? { origin: input.recall.query.origin.trim() } : {}, ...input.recall.query.limit !== void 0 ? { limit: input.recall.query.limit } : {} }, { origins: scope }, rankrecall);
+    await audit("recall", `The semantic recall ranked ${matches.length} past extraction${matches.length === 1 ? "" : "s"} by text similarity inside the ${scope.length} origin scope${scope.length === 1 ? "" : "s"} of the run; every match carries its run and step provenance.`, { ...session ? { sessionid: session.id } : {} });
+    return { matches };
+  }
+  if (input.correction !== void 0 && input.correction.list !== void 0) {
+    const readgate = memoryreadscopegate({ phase: plan && plan.state === "pending" ? "planning" : "prompting" });
+    if (!readgate.allowed) throw new Error(readgate.reason);
+    return { corrections: await memory.getcorrections({ ...input.correction.list.origin !== void 0 ? { origin: input.correction.list.origin } : {}, ...input.correction.list.kind !== void 0 ? { kind: input.correction.list.kind } : {} }) };
+  }
+  if (input.consent !== void 0 && input.consent.list !== void 0) {
+    const readgate = memoryreadscopegate({ phase: "prompting" });
+    if (!readgate.allowed) throw new Error(readgate.reason);
+    const origin = input.consent.list.origin?.trim() || session?.origin || "";
+    const entries = await memory.getconsentmemory(origin === "" ? void 0 : origin);
+    const advisory = consentadvisoryverdict(entries, origin, "observe");
+    return { entries, advisory: advisory.reason };
+  }
+  if (input.grid !== void 0) {
+    if (input.grid.rows !== void 0) return { grid: (await sessionviewof()).grid };
+    if (input.grid.open !== void 0) {
+      const runid = input.grid.open.runid?.trim() ?? "";
+      const view = await sessionviewof();
+      const row = view.grid.find((candidate) => candidate.runid === runid);
+      if (!row) throw new Error(`No session grid row exists for the run ${runid}.`);
+      if (row.tabid !== void 0) await chrome.sidePanel.open({ tabId: row.tabid }).catch(() => {
+      });
+      await audit("session", `The user opened the session grid row of the run ${runid} from the interface deep link.`, { ...session ? { sessionid: session.id } : {}, planid: runid });
+      return { opened: runid };
+    }
+    if (input.grid.resume !== void 0) {
+      const runid = input.grid.resume.runid?.trim() ?? "";
+      if (!session) throw new Error("The resume needs its active session.");
+      if (session.pausedat === void 0) throw new Error("The session of the run stays active; nothing to resume.");
+      const { pausedat, ...resumedsession } = session;
+      void pausedat;
+      await memory.setsession(resumedsession);
+      await audit("resume", `The user resumed the paused session of the run ${runid} from the session grid.`, { sessionid: session.id, planid: runid });
+      return { ...await sessionviewof(), resumed: runid };
+    }
+    if (input.grid.reopen !== void 0) {
+      const runid = input.grid.reopen.runid?.trim() ?? "";
+      const log = await memory.getimmutablelog(runid);
+      if (!log) throw new Error(`No sealed run exists for the run ${runid}.`);
+      const read = await readverifiedlog(log);
+      if (!read.ok) throw new Error(read.reason);
+      await audit("session", `The user reopened the sealed run ${runid} from the session grid; the chain verification passed and the log link stays intact.`, { ...session ? { sessionid: session.id } : {}, planid: runid });
+      return { reopened: runid, entries: read.entries.length, ...log.seal !== void 0 ? { sealhash: log.seal.sealhash.current } : {} };
+    }
+  }
+  if (input.search !== void 0 && input.search.query !== void 0) {
+    if (settings?.historyindex === false) throw new Error("The historysearch index building stays off in the user preferences; the search box needs the index on.");
+    const query = historyqueryof(input.search.query);
+    if (!query) throw new Error("The history search needs its text with a coherent time range.");
+    const hits = await memory.historysearch(query, historysearch);
+    await audit("search", `The history search matched ${hits.length} entr${hits.length === 1 ? "y" : "ies"} of the corpus${query.origin !== void 0 ? ` for ${query.origin}` : ""}${query.outcome !== void 0 ? ` with the outcome ${query.outcome}` : ""}; every hit highlights its matched terms.`, { ...session ? { sessionid: session.id } : {} });
+    return { hits };
+  }
+  if (input.cancel !== void 0) {
+    const runid = input.cancel.runid?.trim() || plan?.id || "";
+    if (runid === "") throw new Error("The cancelrun needs its run.");
+    const progress = await memory.getprogress();
+    const preference = input.cancel.rollback === "none" ? "none" : input.cancel.rollback === "queued" ? "queued" : settings?.cancelrollback;
+    const action = cancelrunactionof({ runid, sessionid: session?.id ?? "", plan: plan && plan.id === runid ? plan : void 0, progress, preference });
+    const split = rollbacksplit(plan && plan.id === runid ? plan : void 0, progress);
+    const cancelgate = cancelrungate({ queuedstepids: action.rollback.queuedstepids, executedstepids: split.executedstepids, rollbackscope: action.rollback.scope });
+    if (!cancelgate.allowed) throw new Error(cancelgate.reason);
+    if (plan && plan.id === runid && ["pending", "approved"].includes(plan.state)) await memory.setplan({ ...plan, state: "cancelled" });
+    if (session) await appendrunevent("cancel", `The user cancelled the run ${runid}: ${action.rollback.label}`, session, session.origin).catch(() => {
+    });
+    await audit("cancel", `The user cancelled the run ${runid}: ${action.rollback.label}`, { ...session ? { sessionid: session.id } : {}, planid: runid });
+    return { ...await sessionviewof(), cancelled: action };
+  }
+  if (input.retry !== void 0) {
+    const stepid = input.retry.stepid?.trim() ?? "";
+    if (stepid === "") throw new Error("The retry needs its step.");
+    const retrygate = retrydispatchgate({ reviewed: true, stepid });
+    if (!retrygate.allowed) throw new Error(retrygate.reason);
+    const output = await executestep(stepid);
+    await audit("retry", `The user retried the step ${stepid} through a new reviewed dispatch: ${output.summary}`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid });
+    return output;
+  }
+  if (input.error !== void 0) return { errors: await memory.geterrorsurfaces(input.error.stepid?.trim() || void 0) };
+  if (input.settings !== void 0) {
+    const patch = { ...settings };
+    for (const field of ["noteretention", "scratchpadretention", "summaryretention", "correctionretention", "recallwindow"]) {
+      const value = input.settings[field];
+      if (value === void 0) continue;
+      const gate = sessionretentionvalid(value);
+      if (!gate.allowed) throw new Error(gate.reason);
+      patch[field] = value;
+    }
+    if (input.settings.summarywindow !== void 0) {
+      const windowgate = summarywindowvalid(input.settings.summarywindow);
+      if (!windowgate.allowed) throw new Error(windowgate.reason);
+      patch.summarywindow = input.settings.summarywindow;
+    }
+    if (input.settings.historyindex !== void 0) patch.historyindex = input.settings.historyindex === true;
+    if (input.settings.cancelrollback !== void 0) patch.cancelrollback = input.settings.cancelrollback === "none" ? "none" : "queued";
+    await memory.setsettings(patch);
+    await audit("configure", `The user updated the session interface preferences: notes retention ${patch.noteretention !== void 0 ? `${patch.noteretention} milliseconds` : "every note stays"}, scratchpad retention ${patch.scratchpadretention !== void 0 ? `${patch.scratchpadretention} milliseconds` : "every entry stays"}, summaries retention ${patch.summaryretention !== void 0 ? `${patch.summaryretention} milliseconds` : "every summary stays"}, corrections retention ${patch.correctionretention !== void 0 ? `${patch.correctionretention} milliseconds` : "every correction stays"}, recall window ${patch.recallwindow !== void 0 ? `${patch.recallwindow} milliseconds` : "the whole index"}, summary window ${patch.summarywindow !== void 0 ? `${patch.summarywindow} steps` : "no cap"}, historysearch index ${patch.historyindex !== false ? "on" : "off"} and cancelrun rollback ${patch.cancelrollback ?? "queued"}.`, {});
+    return { ...await sessionviewof(), configured: true };
+  }
+  if (input.bundle !== void 0 && input.bundle.export === true) {
+    const bundle = await memory.exportsessionbundle(now);
+    await audit("export", `The user exported the session audit bundle: ${bundle.notes.length} note${bundle.notes.length === 1 ? "" : "s"}, ${bundle.summaries.length} run summar${bundle.summaries.length === 1 ? "y" : "ies"} and ${bundle.corrections.length} correction${bundle.corrections.length === 1 ? "" : "s"}; sensitive note bodies stay sealed in the export.`, { ...session ? { sessionid: session.id } : {} });
+    return { bundle };
+  }
+  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 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 });
@@ -20804,7 +22163,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() };
+      return { config: await memory.getconfig(), session, plan, progress: plan && progress?.planid === plan.id ? progress : void 0, diagnostic: await memory.getdiagnostic(), audit: await memory.getaudit(), capabilities: await refreshcapabilities(), outcomes: await memory.getoutcomes(), holds: heldkeysreport({ tabid: session?.tabid ?? 0, holds }), dialogs: await memory.getdialogs(), retries: await memory.getretries(), ...signals ? { signals: signalsreport({ signals }) } : { signals: signalsreport({}) }, banners: await memory.getbanners(), mutationevents: await memory.getmutationevents(), focusevents: await memory.getfocusevents(), diffs: await memory.getdiffs(), selectors: await memory.getselectors(), ...a11y ? { a11y } : {}, ...reader ? { reader } : {}, ...map ? { map } : {}, trail: trailreport({ ...session ? { sessionid: session.id } : {}, trail }), navrecords, ratestates, safeties, curated, waitprofiles, auths, navcontrol, navqueues, artifacts, navstate: livestate, ...waitprofile ? { waitprofile } : {}, offline: !navigator.onLine, tabs, windows, layouts: layoutreport({ layouts }), tabgroups, tabmetas, badges, snapshots, closedtabs, tabwatchevents, clones, tasktabgauge: taskgauge, ...controltab ? { controltab } : {}, tabreport: report, profiles, tickets, wizards: wizardreport({ ...session ? { sessionid: session.id } : {}, wizards, picks }), picks, errorreports, captchas, detections, ...codeentry !== void 0 ? { codeentry: true } : {}, datasets, imports, extractsessions, streams, exports, provenances, taskrules, sheetendpoints: sheetgrants, downloads, netlogs, clipconsents, clips, quarantines, cleanuprules, cleanupruns, capturecounters, inventory, mimefilters, scanhooks, captures: capturemetadata, capturepairs, capturepolicy: runsettings?.capturepolicy ?? "manual", media: mediarecords, imagebatches, recordingconsents, recordingactive: [...activerecordings.values()].map((active) => ({ id: active.record.id, kind: active.record.kind, scope: active.record.scope, startedat: active.record.startedat, stopat: active.stopat })), recordingwindow: runsettings?.recordingwindow, calls, endpoints, fetchconsents, apikeys, callretention: runsettings?.callretention, fetchesactive: activefetches.size, exchanges, channels, subscriptions, apimap, messages: messagecount, webrequestgrant: runsettings?.webrequestgrant === true, bodyretention: runsettings?.bodyretention, timelineretention: runsettings?.timelineretention, timeline, consoleconsents: await memory.getconsoleconsents(), rotationtargets: await memory.getrotationtargets(), levelsummaries: await memory.getlevelsummaries(), cdpsessions: await memory.getcdpsessions(), cdpcommands: await memory.getcdpcommands(), cdpeventrules: await memory.getcdpeventrules(), breakpoints: await memory.getbreakpoints(), pauses: await memory.getpauses(), watchexpressions: await memory.getwatchexpressions(), scriptoverrides: await memory.getscriptoverrides(), debuggergrants: await memory.getdebuggergrants(), pauseretention: runsettings?.pauseretention, breakpointceiling: runsettings?.breakpointceiling, cdpattached: [...activecdpsessions.values()].filter((active) => active.session.detachedat === void 0).length, profileretention: runsettings?.profileretention, traceceiling: runsettings?.traceceiling, profile: profilereport({ flows: await memory.getflowmetrics(), heaps: await memory.getheaprecords(), samples: await memory.getgrowsamples(), trends: await memory.gettrends(), profiles: await memory.getcpuprofiles(), shifts: await memory.getshiftentries(), traces: await memory.gettracerecords(), sourcemaps: await memory.getsourcemaps(), consents: await memory.getsourcemapconsents() }), profileactive: activememorytrackers.size + activeprofiletargets.size, profiletargets: [...activeprofiletargets.values()].flatMap((entry) => entry.targets), socketsactive: activesockets.size, emulation: emulationreport({ ...plan && await loademulationstate(plan.id) !== void 0 ? { state: await loademulationstate(plan.id) } : {}, devices: await memory.getdevicepresets(), networks: await memory.getnetworkpresets(), locations: await memory.getlocationpresets(), agents: await memory.getagentpresets(), blackbox: await memory.getblackboxrules(), permissions: await memory.getpermissionoverrides(), consents: await memory.getlocationconsents() }), emulatedlayers: plan ? layernames(await loademulationstate(plan.id)) : [], emulationretention: runsettings?.emulationretention, traffic, tokens, authflows, activerules: [...activerules.values()].reduce((total, ruleset) => total + ruleset.blocks.filter((rule) => rule.revertedat === void 0).length + ruleset.mocks.filter((rule) => rule.revertedat === void 0).length + ruleset.rewrites.filter((rule) => rule.revertedat === void 0).length + (ruleset.proxy !== void 0 && ruleset.proxy.revertedat === void 0 ? 1 : 0), 0), sessionmemory: sessionreport({ records: sessionrecords, events: await memory.getsessionevents(), folders: await memory.getsessionfolders(), diffs: await memory.getsessiondiffs(), ...autosnapshot !== void 0 ? { auto: autosnapshot.interval } : {}, ...crashed ? { crashed: true } : {} }), autosnapshotstate: autosnapshot, sessionretention: runsettings?.sessionretention, trigger: triggerlist({ rules: await memory.gettriggerules(), workflows: await memory.listworkflows(), queue: await memory.gettriggerqueue() }), triggerretention: runsettings?.triggerretention, workflow: workflowreport({ workflows: await memory.listworkflows(), runs: await memory.listworkflowruns(), templates: await memory.getsteptemplates(), ...newestworkflowrun !== void 0 ? { log: await memory.getrunlog(newestworkflowrun.id), scopes: await memory.getrunscopes(newestworkflowrun.id), provenance: await memory.getworkflowprovenance(newestworkflowrun.id), control: await memory.listcontroldecisions(newestworkflowrun.id) } : {} }), runlogretention: runsettings?.runlogretention, runhistoryretention: runsettings?.runhistoryretention, editor: editorstate({ versions: await memory.listworkflowversions(), diffs: await memory.listversiondiffs(), history: await memory.gethistory(), overrides: await memory.listsiteoverrides(), imports: (await memory.listworkflowimports()).map((entry) => ({ id: entry.id, workflowid: entry.record.id, name: entry.record.name, version: entry.record.version, steps: entry.record.steps.length, risk: entry.record.risk, importedat: entry.importedat, ...entry.filename !== void 0 ? { filename: entry.filename } : {} })), backgroundruns: await memory.getbackgroundruns(), watchdog: { ...runsettings?.watchdog !== void 0 ? { config: runsettings.watchdog } : {}, events: await memory.listwatchdogevents() } }), ...taskstate !== void 0 ? { taskstate } : {}, ...stitchprogress.size > 0 ? { stitchprogress: [...stitchprogress.values()] } : {}, mcp: await mcpstateof(), llm: await llmstateof(), swarm: await swarmstateof(), environments: await environmentviewof(), security: await securityviewof(), sessionview: await sessionviewof(), surfacepreferences: { ...runsettings?.paletterecents !== void 0 ? { paletterecents: runsettings.paletterecents } : {}, ...runsettings?.paletteshortcut !== void 0 ? { paletteshortcut: runsettings.paletteshortcut } : {}, ...runsettings?.logstreambuffer !== void 0 ? { logstreambuffer: runsettings.logstreambuffer } : {}, ...runsettings?.taskinputretention !== void 0 ? { taskinputretention: runsettings.taskinputretention } : {}, ...runsettings?.diffpreviewbytes !== void 0 ? { diffpreviewbytes: runsettings.diffpreviewbytes } : {} }, sessionpreferences: { ...runsettings?.recallwindow !== void 0 ? { recallwindow: runsettings.recallwindow } : {}, ...runsettings?.noteretention !== void 0 ? { noteretention: runsettings.noteretention } : {}, ...runsettings?.scratchpadretention !== void 0 ? { scratchpadretention: runsettings.scratchpadretention } : {}, ...runsettings?.summaryretention !== void 0 ? { summaryretention: runsettings.summaryretention } : {}, ...runsettings?.correctionretention !== void 0 ? { correctionretention: runsettings.correctionretention } : {}, ...runsettings?.summarywindow !== void 0 ? { summarywindow: runsettings.summarywindow } : {}, ...runsettings?.historyindex !== void 0 ? { historyindex: runsettings.historyindex } : {}, ...runsettings?.cancelrollback !== void 0 ? { cancelrollback: runsettings.cancelrollback } : {} } };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -20833,7 +22192,12 @@ async function handlerequest(message, sender) {
       const rejected = { ...plan, state: "rejected" };
       await memory.setplan(rejected);
       const current = await memory.getsession();
+      for (const step of plan.steps) {
+        await memory.addcorrection(rejectedcorrectionof({ origin: current?.origin ?? "", kind: step.kind, stepid: step.id, original: JSON.stringify({ kind: step.kind, target: step.target, value: step.value, summary: step.summary }), reason: "The user rejected the reviewed plan during plan review.", now: Date.now() })).catch(() => {
+        });
+      }
       await audit("approval", "The user rejected the plan.", { ...current ? { sessionid: current.id } : {}, planid: rejected.id });
+      await audit("correction", `The rejection captured ${plan.steps.length} correction entr${plan.steps.length === 1 ? "y" : "ies"} in the correction memory, one per rejected step with its rejection reason.`, { ...current ? { sessionid: current.id } : {}, planid: rejected.id });
       return rejected;
     }
     case "preview":
@@ -23190,6 +24554,14 @@ async function handlerequest(message, sender) {
       await memory.setplan(plan);
       await memory.setprogress(resetforplan(await memory.getprogress(), plan, Date.now()));
       await memory.setreplans(replans.map((candidate) => candidate.id === replan.id ? { ...candidate, state: "approved" } : candidate));
+      const originaltail = draft.steps.filter((step) => !replan.completedstepids.includes(step.id));
+      for (let index = 0; index < originaltail.length && index < replan.tail.length; index += 1) {
+        const before = originaltail[index];
+        const after = replan.tail[index];
+        if (before === void 0 || after === void 0) continue;
+        await memory.addcorrection(editedcorrectionof({ origin: session?.origin ?? "", kind: after.kind, stepid: after.id, original: JSON.stringify({ kind: before.kind, target: before.target, value: before.value, summary: before.summary }), corrected: JSON.stringify({ kind: after.kind, target: after.target, value: after.value, summary: after.summary }), reason: `The plan review replaced the failed tail step ${before.id} with the revised step ${after.id} of the replan ${replan.id}.`, now: Date.now() })).catch(() => {
+        });
+      }
       await audit("model", `The user approved the fresh review of the replan ${replan.id}: ${completed.length} completed step${completed.length === 1 ? "" : "s"} stay and the ${replan.tail.length} revised step${replan.tail.length === 1 ? "" : "s"} became the changed tail of a pending plan that still passes the same plan review.`, { planid: plan.id, ...session ? { sessionid: session.id } : {} });
       return llmstateof();
     }
@@ -23861,6 +25233,10 @@ async function handlerequest(message, sender) {
       await audit("transparency", `The transparencypage read its transparency report in one memory read: ${report.grants.length} grant row${report.grants.length === 1 ? "" : "s"} with revoke actions, ${report.windows.length} consent window${report.windows.length === 1 ? "" : "s"}, ${report.connectallow.length} connectallow entr${report.connectallow.length === 1 ? "y" : "ies"}, ${report.permdiffs.length} permdiff record${report.permdiffs.length === 1 ? "" : "s"} and ${report.vault.length} vault label${report.vault.length === 1 ? "" : "s"}.`, {});
       return report;
     }
+    case "sessions":
+      return handlesessionscommand(message);
+    case "surface":
+      return handlesurfacecommand(message);
     case "security": {
       const input2 = message;
       const now = Date.now();
@@ -23891,6 +25267,8 @@ async function handlerequest(message, sender) {
         const existing = profiles.find((candidate) => candidate.origin === origin);
         const updated = profilekind({ profile: existing ?? originprofileof({ origin, now }), kind, decision, now });
         await memory.saveoriginprofile(updated);
+        if (decision === "deny") await memory.addconsentmemoryentry(consentmemoryof({ origin, decision: "deny", boundary: "the origin profile the user edits", kinds: [kind], now })).catch(() => {
+        });
         await audit("grant", `The origin profile of ${origin} now ${decision === "grant" ? "grants" : "denies"} the ${kind} kind the user reviewed; ${updated.grants.length} grant${updated.grants.length === 1 ? "" : "s"} and ${updated.denials.length} denial${updated.denials.length === 1 ? "" : "s"} on the origin.`, { ...session ? { sessionid: session.id } : {} });
         return { ...await securityviewof(), profile: updated };
       }
@@ -23905,6 +25283,8 @@ async function handlerequest(message, sender) {
           const kinds = (input2.consent.open.kinds ?? []).map((kind) => kind.trim()).filter((kind) => kind !== "");
           const window2 = openconsentwindow({ sessionid: session.id, origin, duration, kinds: kinds.length > 0 ? kinds : ["observe"], now });
           await memory.setconsentwindows([window2, ...(await memory.getconsentwindows()).map((candidate) => candidate.sessionid === session.id && candidate.origin === origin && candidate.state === "active" ? { ...candidate, state: "closed", closedat: now } : candidate)]);
+          await memory.addconsentmemoryentry(consentmemoryof({ origin, decision: "grant", boundary: window2.boundary, kinds: window2.kinds, expiresat: window2.expiresat, now })).catch(() => {
+          });
           await appendrunevent("grant", `The consent prompt opened the window ${window2.id} for ${origin} with the boundary ${window2.boundary}.`, session, origin).catch(() => {
           });
           await audit("grant", `The user answered the consent prompt for ${origin} with the window ${window2.id} and the boundary ${window2.boundary}; no grant ever outlives its named boundary.`, { sessionid: session.id });
@@ -23921,6 +25301,8 @@ async function handlerequest(message, sender) {
           if (!durationgate.allowed) throw new Error(durationgate.reason);
           const { renewed, closed } = renewconsentwindow({ window: current, duration, kinds: current.kinds, now });
           await memory.setconsentwindows([renewed, closed, ...(await memory.getconsentwindows()).filter((candidate) => candidate.id !== windowid)]);
+          await memory.addconsentmemoryentry(consentmemoryof({ origin: current.origin, decision: "grant", boundary: renewed.boundary, kinds: renewed.kinds, expiresat: renewed.expiresat, now })).catch(() => {
+          });
           await appendrunevent("grant", `The consent window of ${current.origin} renewed through a new explicit prompt with the boundary ${renewed.boundary}; the old window stays closed in the history.`, session, current.origin).catch(() => {
           });
           await audit("grant", `The user renewed the consent window of ${current.origin} through a new explicit prompt with the boundary ${renewed.boundary}.`, { sessionid: session.id });
@@ -23949,6 +25331,8 @@ async function handlerequest(message, sender) {
         const queued = (plan2?.steps ?? []).map((step) => step.id).filter((id) => !completed.has(id));
         const revocation = revokerun({ sessionid: session.id, runid, ...pendingstepid !== void 0 ? { pendingstepid } : {}, ...queued.length > 0 ? { queuedstepids: queued } : {}, actor: "user", ...input2.revoke.reason !== void 0 ? { reason: input2.revoke.reason } : {}, now });
         await memory.addrevocation(revocation);
+        await memory.addconsentmemoryentry(consentmemoryof({ origin: session.origin, decision: "revoke", boundary: "the mid run revocation of the user", kinds: ["observe"], now })).catch(() => {
+        });
         if (plan2 && plan2.id === runid && ["pending", "approved"].includes(plan2.state)) await memory.setplan({ ...plan2, state: "cancelled" });
         if (plan2 && plan2.id === runid && pendingstepid !== void 0) await memory.setprogress(recordrevocation(progress, runid, pendingstepid, { haltedstepids: revocation.haltedstepids, revokedstepid: pendingstepid, reason: revocation.reason }, now));
         await appendrunevent("revoke", `The user revoked the run ${runid}: the pending step ${pendingstepid ?? "none"} and every queued step halted without executing (${revocation.haltedstepids.join(", ")}).`, session, session.origin, pendingstepid).catch(() => {
@@ -24904,6 +26288,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;