@wenathlan/extension 1.1.61 → 1.1.63

package/extension/dist/background.js

@@ -4737,6 +4737,375 @@ var sessionmemory = class {
     }
     return kept;
   }
+  /**
+   * Security part two persistence of the 1.1.62 family.
+   * The protections for secrets, messages and money live here: the secretvault metadata with labels and scopes only and never values, scoped per profile workspace; the connectallow entries with their senders shipping empty by default; the ratelimit bucket state per origin and per session; the confirm gates with their resolution events and their human action provenance; the redactshot regions per origin and page template; the phishguard verdicts with their distance scores expiring past their freshness window; the permdiff records of each installed version; the safedefaults applications with their first seen origins; and the deferred command events waiting for their bucket reset.
+   * The vault values never touch this seam: only metadata persists while the values stay behind the vault seam the background wires.
+   */
+  /** Replaces the secretvault metadata of the profile workspaces: labels, scopes, provenance and digests only, never values. */
+  async setsecretvault(entries) {
+    return this.adapter.set("secretvault", entries);
+  }
+  /** Returns the stored secretvault metadata, oldest record first; the values live behind the vault seam and never persist. */
+  async getsecretvault() {
+    return await this.adapter.get("secretvault") ?? [];
+  }
+  /** Adds one secretvault metadata record scoped to a profile workspace; a duplicate vault id keeps its first record. */
+  async addsecret(entry) {
+    const entries = await this.getsecretvault();
+    if (entries.some((candidate) => candidate.vaultid === entry.vaultid)) return;
+    await this.setsecretvault([...entries, entry]);
+  }
+  /** Removes one secretvault metadata record by its vault id; the background drops the value behind the seam in the same action. */
+  async removesecret(vaultid) {
+    await this.setsecretvault((await this.getsecretvault()).filter((entry) => entry.vaultid !== vaultid));
+  }
+  /** Stamps the last use of one secretvault record: the metadata notes when the vault last released its value while the value itself stays unrecorded. */
+  async stampsecretuse(vaultid, at) {
+    await this.setsecretvault((await this.getsecretvault()).map((entry) => entry.vaultid === vaultid ? { ...entry, lastusedat: at } : entry));
+  }
+  /** Replaces the connectallow entries of external senders; the list ships empty by default with user managed entries only. */
+  async setconnectallow(entries) {
+    return this.adapter.set("connectallow", entries);
+  }
+  /** Returns the stored connectallow entries, oldest add first. */
+  async getconnectallow() {
+    return await this.adapter.get("connectallow") ?? [];
+  }
+  /** Adds one connectallow entry for an external sender; a duplicate sender id keeps its first entry. */
+  async addconnectallow(entry) {
+    const entries = await this.getconnectallow();
+    if (entries.some((candidate) => candidate.senderid === entry.senderid)) return;
+    await this.setconnectallow([...entries, entry]);
+  }
+  /** Removes one connectallow entry by its sender id; the origincheck drops the sender again after the removal. */
+  async removeconnectallow(senderid) {
+    await this.setconnectallow((await this.getconnectallow()).filter((entry) => entry.senderid !== senderid));
+  }
+  /** Replaces the ratelimit bucket state per origin and per session: the user configured bounds and windows with their used counts. */
+  async setratelimitbuckets(buckets) {
+    return this.adapter.set("ratelimitbuckets", buckets);
+  }
+  /** Returns the stored ratelimit buckets per origin and per session. */
+  async getratelimitbuckets() {
+    return await this.adapter.get("ratelimitbuckets") ?? [];
+  }
+  /** Upserts one ratelimit bucket: a bucket of the same origin and session replaces its state while a new pair joins the list. */
+  async saveratelimitbucket(bucket) {
+    const buckets = await this.getratelimitbuckets();
+    await this.setratelimitbuckets(buckets.some((candidate) => candidate.origin === bucket.origin && candidate.sessionid === bucket.sessionid) ? buckets.map((candidate) => candidate.origin === bucket.origin && candidate.sessionid === bucket.sessionid ? bucket : candidate) : [...buckets, bucket]);
+  }
+  /** Removes the ratelimit bucket of one origin and session; the origin runs without a bucket because the bounds stay user choices only. */
+  async removeratelimitbucket(origin, sessionid) {
+    await this.setratelimitbuckets((await this.getratelimitbuckets()).filter((bucket) => !(bucket.origin === origin && bucket.sessionid === sessionid)));
+  }
+  /** Replaces the confirm gates with their payloads and states; a resolved or refused gate stays terminal for the audit trail. */
+  async setgates(gates) {
+    return this.adapter.set("confirmgates", gates);
+  }
+  /** Returns the stored confirm gates, newest open first. */
+  async getgates() {
+    return await this.adapter.get("confirmgates") ?? [];
+  }
+  /** Upserts one confirm gate: a gate of the same step keeps its latest record because one gated step carries one live gate. */
+  async savegate(gate) {
+    const gates = await this.getgates();
+    await this.setgates(gates.some((candidate) => candidate.stepid === gate.stepid && candidate.kind === gate.kind) ? gates.map((candidate) => candidate.stepid === gate.stepid && candidate.kind === gate.kind ? gate : candidate) : [gate, ...gates]);
+  }
+  /** Records one gate resolution event with its human action provenance; the resolution history stays visible for the audit trail. */
+  async addgateresolution(resolution) {
+    await this.adapter.set("gateresolutions", [resolution, ...await this.adapter.get("gateresolutions") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded gate resolution events with their human action provenance, newest first. */
+  async getgateresolutions() {
+    return await this.adapter.get("gateresolutions") ?? [];
+  }
+  /** Replaces the redactshot regions per origin and page template. */
+  async setredactregions(regions) {
+    return this.adapter.set("redactregions", regions);
+  }
+  /** Returns the stored redactshot regions per origin and page template, oldest rule first. */
+  async getredactregions() {
+    return await this.adapter.get("redactregions") ?? [];
+  }
+  /** Adds one redactshot region, derived from a field shape or drawn by the user. */
+  async addredactregion(region) {
+    await this.setredactregions([...await this.getredactregions(), region]);
+  }
+  /** Removes one redactshot region by its id. */
+  async removeredactregion(id) {
+    await this.setredactregions((await this.getredactregions()).filter((region) => region.id !== id));
+  }
+  /** Records one phishguard verdict with its distance score; the records stay for the audit trail while the freshness window governs the live set. */
+  async addphishverdict(verdict) {
+    await this.adapter.set("phishverdicts", [verdict, ...(await this.adapter.get("phishverdicts") ?? []).filter((candidate) => candidate.origin !== verdict.origin)].slice(0, 500));
+  }
+  /** Returns the stored phishguard verdicts with their distance scores, newest first. */
+  async getphishverdicts() {
+    return await this.adapter.get("phishverdicts") ?? [];
+  }
+  /** Expires the phishguard verdicts past the user configured freshness window: the expired verdicts keep their records for the audit trail while the guard recomputes the next login step. */
+  async expirephishverdicts(freshness, now) {
+    const verdicts = await this.getphishverdicts();
+    if (freshness === void 0) return verdicts;
+    return verdicts.filter((verdict) => now - verdict.at < freshness);
+  }
+  /** Records one permdiff between two installed permission versions; the record of each installed update stays for the audit trail. */
+  async addpermdiff(diff) {
+    await this.adapter.set("permdiffs", [diff, ...await this.adapter.get("permdiffs") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded permdiffs of each installed update, newest first. */
+  async getpermdiffs() {
+    return await this.adapter.get("permdiffs") ?? [];
+  }
+  /** Stores the last installed permission set the permdiff of the next update compares against. */
+  async setlastpermissions(permissions, version) {
+    await this.adapter.set("lastpermissions", { permissions, version });
+  }
+  /** Returns the last installed permission set with its version; an absent record returns undefined. */
+  async getlastpermissions() {
+    return this.adapter.get("lastpermissions");
+  }
+  /** Records one safedefaults application with its first seen origin; the first visit of an unknown origin stays visible. */
+  async addsafedefaultapplication(application) {
+    const applications = await this.adapter.get("safedefaults") ?? [];
+    if (applications.some((candidate) => candidate.origin === application.origin)) return;
+    await this.adapter.set("safedefaults", [...applications, application]);
+  }
+  /** Returns the recorded safedefaults applications with their first seen origins, oldest first. */
+  async getsafedefaultapplications() {
+    return await this.adapter.get("safedefaults") ?? [];
+  }
+  /** Records one deferred command event with the reset time it waits for. */
+  async adddeferredevent(event) {
+    await this.adapter.set("deferredevents", [event, ...await this.adapter.get("deferredevents") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded deferred command events, newest first. */
+  async getdeferredevents() {
+    return await this.adapter.get("deferredevents") ?? [];
+  }
+  /** Serves the transparency data of the transparencypage in one read: every active grant with its origin, scope and boundary, every consent window ever granted with its expiry, the connectallow entries with their senders, the permdiff records of each installed update, the safedefaults applications and the secretvault metadata with labels and scopes only. */
+  async gettransparencyview() {
+    return {
+      allowlist: await this.getautomationallowlist(),
+      profiles: await this.getoriginprofiles(),
+      windows: await this.getconsentwindows(),
+      connectallow: await this.getconnectallow(),
+      permdiffs: await this.getpermdiffs(),
+      safedefaults: await this.getsafedefaultapplications(),
+      vault: await this.getsecretvault(),
+      gates: await this.getgates(),
+      resolutions: await this.getgateresolutions(),
+      deferred: await this.getdeferredevents(),
+      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 };
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -5018,6 +5387,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;
@@ -6673,6 +7047,226 @@ function consolediff(input) {
   return { base: input.baseid, target: input.targetid, lines, added: added.length, removed: removed.length, repeated: repeated.length, at: input.now };
 }
 
+// inboundguard.ts
+function shapeof(value) {
+  if (typeof value === "string") return "string";
+  if (typeof value === "number") return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (Array.isArray(value)) return "array";
+  return "object";
+}
+function schemacheck(input) {
+  const errors = [];
+  for (const [field, value] of Object.entries(input.command)) {
+    const expected = input.schema[field];
+    if (expected === void 0) {
+      errors.push({ path: field, expected: "absent", found: shapeof(value), reason: `The ${field} field sits absent from the declared grammar of the command; schemastrict refuses unknown fields before dispatch.` });
+      continue;
+    }
+    if (expected === "absent") {
+      errors.push({ path: field, expected: "absent", found: shapeof(value), reason: `The ${field} field carries no value under the declared grammar; schemastrict refuses it before dispatch.` });
+      continue;
+    }
+    if (shapeof(value) !== expected) errors.push({ path: field, expected, found: shapeof(value), reason: `The ${field} field expects a ${expected} while the command carries a ${shapeof(value)}; schemastrict refuses the shape mismatch before dispatch.` });
+  }
+  for (const field of input.required ?? []) {
+    if (input.command[field] === void 0) errors.push({ path: field, expected: input.schema[field] ?? "string", found: "absent", reason: `The ${field} field is required by the declared grammar and the command carries no value; schemastrict refuses the incomplete command before dispatch.` });
+  }
+  return { valid: errors.length === 0, errors };
+}
+function origincheckof(input) {
+  const sender = input.senderid ?? "an unknown sender";
+  const origin = input.senderorigin ?? "";
+  if (input.senderid === input.extensionid) return { accepted: true, sender, origin, reason: "The sender is this extension itself; the internal surface accepts." };
+  if (input.senderid !== void 0 && input.connectallow.some((entry) => entry.senderid === input.senderid && (entry.origin === void 0 || entry.origin === origin))) {
+    return { accepted: true, sender, origin, reason: `The sender ${sender} sits in the connectallow list the user manages${origin !== "" ? ` for ${origin}` : ""}; the message accepts.` };
+  }
+  if (input.senderid === void 0) return { accepted: false, sender, origin, reason: "The message carries no sender identity; the guard drops it before any handler runs." };
+  return { accepted: false, sender, origin, reason: `The sender ${sender} sits absent from the connectallow list; the guard drops the message without handler execution.` };
+}
+function portaccept(input) {
+  const verdict = origincheckof(input);
+  if (!verdict.accepted) return { ...verdict, reason: `The port ${input.portname} closes at its handshake: ${verdict.reason}` };
+  return { ...verdict, reason: `The port ${input.portname} accepted its handshake: ${verdict.reason}` };
+}
+function connectallowentryof(input) {
+  if (input.senderid.trim() === "") throw new Error("The connectallow entry needs its sender id.");
+  if (input.displayname.trim() === "") throw new Error("The connectallow entry needs its display name.");
+  return { senderid: input.senderid.trim(), displayname: input.displayname.trim(), ...input.origin !== void 0 && input.origin.trim() !== "" ? { origin: input.origin.trim() } : {}, addedat: input.now };
+}
+function bucketboundsvalid(limit, window2) {
+  if (!Number.isFinite(limit) || limit <= 0) return { valid: false, reason: "The ratelimit bucket limit stays a positive user value; no hidden ceiling exists." };
+  if (!Number.isFinite(window2) || window2 <= 0) return { valid: false, reason: "The ratelimit bucket window stays a positive user value in milliseconds; the window reset stays the user's choice." };
+  return { valid: true, reason: `The bucket bound of ${limit} commands per ${window2} milliseconds stays the user configured choice with no hidden ceiling.` };
+}
+function bucketof(input) {
+  const bounds = bucketboundsvalid(input.limit, input.window);
+  if (!bounds.valid) throw new Error(bounds.reason);
+  return { origin: input.origin, sessionid: input.sessionid, limit: input.limit, window: input.window, used: 0, windowstartedat: input.now, resetsat: input.now + input.window };
+}
+function bucketconsume(input) {
+  if (input.now >= input.bucket.resetsat) {
+    const fresh = { ...input.bucket, used: 0, windowstartedat: input.now, resetsat: input.now + input.bucket.window };
+    return { allowed: true, deferred: false, bucket: { ...fresh, used: 1 }, resetsat: fresh.resetsat, reason: `The bucket window of ${input.bucket.origin} reset and the command consumes the first slot of ${fresh.limit}.` };
+  }
+  if (input.bucket.used < input.bucket.limit) {
+    return { allowed: true, deferred: false, bucket: { ...input.bucket, used: input.bucket.used + 1 }, resetsat: input.bucket.resetsat, reason: `The command consumes slot ${input.bucket.used + 1} of ${input.bucket.limit} in the bucket of ${input.bucket.origin}.` };
+  }
+  return { allowed: false, deferred: true, bucket: input.bucket, resetsat: input.bucket.resetsat, reason: `The bucket of ${input.bucket.origin} holds its ${input.bucket.limit} command bound; the command defers until the window resets at ${input.bucket.resetsat}.` };
+}
+function deferredeventof(input) {
+  if (input.stepid.trim() === "" || input.kind.trim() === "") throw new Error("The deferred event needs its step and kind.");
+  return { id: input.id ?? randomid(), stepid: input.stepid, kind: input.kind, origin: input.origin, reason: input.reason, resetsat: input.resetsat, at: input.now };
+}
+
+// confirmgates.ts
+function stepoptions2(step) {
+  if (!step.options) return {};
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function gatekindfor(classes) {
+  if (classes.includes("payment")) return "confirmpay";
+  if (classes.includes("delete")) return "confirmdelete";
+  if (classes.includes("credential")) return "confirmcreds";
+  return void 0;
+}
+function paypayload(input) {
+  const payload = { payeeorigin: input.payeeorigin };
+  if (input.amount !== void 0 && input.amount.trim() !== "") payload.amount = input.amount.trim();
+  if (input.target !== void 0 && input.target.trim() !== "") payload.target = input.target.trim();
+  return payload;
+}
+function deletepayload(input) {
+  const payload = { scope: input.scope, irreversibility: input.irreversibility };
+  if (input.target !== void 0 && input.target.trim() !== "") payload.target = input.target.trim();
+  return payload;
+}
+function credspayload(label) {
+  if (label.trim() === "") throw new Error("The confirmcreds gate names its credential label; the value never appears.");
+  return { label: label.trim() };
+}
+function opengate(input) {
+  if (input.stepid.trim() === "" || input.runid.trim() === "" || input.origin.trim() === "") throw new Error("The confirm gate needs its step, run and origin.");
+  if (Object.keys(input.payload).length === 0) throw new Error("The confirm gate carries the payload the human reviews.");
+  return { gateid: input.gateid ?? randomid(), kind: input.kind, stepid: input.stepid, runid: input.runid, origin: input.origin, payload: { ...input.payload }, state: "open", openedat: input.now };
+}
+function gatestateof(gates, stepid) {
+  const gate = [...gates].reverse().find((candidate) => candidate.stepid === stepid);
+  if (gate === void 0) return { state: "none" };
+  return { state: gate.state, gate };
+}
+function resolvegate(input) {
+  if (input.actor.trim() === "") throw new Error("The gate resolution names its acting user; only a human resolves a gate.");
+  const gate = input.gates.find((candidate) => candidate.gateid === input.gateid);
+  if (gate === void 0) return { gates: input.gates };
+  if (gate.state !== "open") return { gates: input.gates };
+  const resolution = { gateid: gate.gateid, kind: gate.kind, stepid: gate.stepid, decision: input.decision, actor: input.actor, at: input.now };
+  return { gates: input.gates.map((candidate) => candidate.gateid === input.gateid ? { ...candidate, state: input.decision, resolvedat: input.now, actor: input.actor } : candidate), resolution };
+}
+function gateprompttext(gate) {
+  if (gate.kind === "confirmpay") {
+    const amount = gate.payload.amount !== void 0 ? `the amount ${gate.payload.amount}` : "an amount the step options name";
+    const target = gate.payload.target !== void 0 ? ` on ${gate.payload.target}` : "";
+    return `Approve the payment of ${amount} to ${gate.payload.payeeorigin}${target}? The step dispatches only after this distinct human action.`;
+  }
+  if (gate.kind === "confirmdelete") {
+    const target = gate.payload.target !== void 0 ? ` on ${gate.payload.target}` : "";
+    return `Approve the destructive delete${target} scoped to ${gate.payload.scope}? ${gate.payload.irreversibility} The step dispatches only after this distinct human action.`;
+  }
+  return `Approve the use of the credential ${gate.payload.label} on ${gate.origin}? The value stays behind the vault; the label is everything this prompt shows.`;
+}
+function gateforstep(input) {
+  const kind = gatekindfor(input.classes);
+  if (kind === void 0) return void 0;
+  const options = stepoptions2(input.step);
+  if (kind === "confirmpay") {
+    const amount = typeof options.amount === "string" ? options.amount : typeof options.value === "string" ? options.value : void 0;
+    return opengate({ kind, stepid: input.step.id, runid: input.runid, origin: input.origin, payload: paypayload({ ...amount !== void 0 && amount !== "" ? { amount } : {}, payeeorigin: String(options.payeeorigin ?? input.origin), ...input.step.target !== void 0 && input.step.target !== "" ? { target: input.step.target } : {} }), now: input.now });
+  }
+  if (kind === "confirmdelete") {
+    return opengate({ kind, stepid: input.step.id, runid: input.runid, origin: input.origin, payload: deletepayload({ ...input.step.target !== void 0 && input.step.target !== "" ? { target: input.step.target } : {}, scope: String(options.scope ?? input.origin), irreversibility: String(options.irreversibility ?? "A destructive delete destroys state the page cannot restore.") }), now: input.now });
+  }
+  if (input.credentiallabel === void 0 || input.credentiallabel.trim() === "") return void 0;
+  return opengate({ kind, stepid: input.step.id, runid: input.runid, origin: input.origin, payload: credspayload(input.credentiallabel), now: input.now });
+}
+
+// phishguard.ts
+function stepoptions3(step) {
+  if (!step.options) return {};
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function credentialstep(step) {
+  const credentialkinds2 = /* @__PURE__ */ new Set(["consentpassword", "saveapikey", "handleauth", "authflow", "fillcard", "fillcode"]);
+  if (credentialkinds2.has(step.kind)) return true;
+  const options = stepoptions3(step);
+  const fields = Array.isArray(options.fields) ? options.fields.filter((item) => Boolean(item) && typeof item === "object") : [];
+  const names = [...fields.map((field) => typeof field.name === "string" ? field.name : ""), typeof options.field === "string" ? options.field : "", step.target ?? ""].map((name) => name.toLowerCase());
+  return names.some((name) => name.includes("password") || name.includes("passwd") || name.includes("passphrase") || name.includes("token") || name.includes("secret") || name.includes("apikey"));
+}
+function originlabels(origin) {
+  const host = origin.trim().replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").split("/")[0] ?? "";
+  return host.split(".").filter((label) => label !== "").reverse();
+}
+function labeldistance(one, two) {
+  const rows = one.length + 1;
+  const columns = two.length + 1;
+  let previous = Array.from({ length: columns }, (_, index) => index);
+  for (let row = 1; row < rows; row += 1) {
+    const current = [row, ...Array.from({ length: columns - 1 }, () => 0)];
+    for (let column = 1; column < columns; column += 1) {
+      const substitution = (previous[column - 1] ?? 0) + (one[row - 1] === two[column - 1] ? 0 : 1);
+      current[column] = Math.min((previous[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, substitution);
+    }
+    previous = current;
+  }
+  return previous[columns - 1] ?? Math.max(one.length, two.length);
+}
+function lookalikedistance(one, two) {
+  if (one.trim() === "" || two.trim() === "") return 1;
+  if (one === two) return 0;
+  const first = originlabels(one);
+  const second = originlabels(two);
+  const edits = labeldistance(first, second);
+  const longest = Math.max(first.length, second.length);
+  if (longest === 0) return 1;
+  const distance = edits / longest;
+  return Math.min(1, Math.max(0, distance));
+}
+function phishthresholdvalid(threshold) {
+  if (!Number.isFinite(threshold) || threshold <= 0 || threshold >= 1) return { valid: false, reason: "The phishguard threshold stays a user choice between zero and one; the lookalike line never defaults." };
+  return { valid: true, reason: `The lookalike threshold ${threshold} stays the user configured line a login origin crosses at its own risk.` };
+}
+function phishverdictof(input) {
+  const threshold = phishthresholdvalid(input.threshold);
+  if (!threshold.valid) throw new Error(threshold.reason);
+  if (input.granted.includes(input.origin)) {
+    return { origin: input.origin, distance: 0, threshold: input.threshold, blocked: false, reason: `The login origin ${input.origin} sits among the granted origins; no lookalike watch applies.`, at: input.now };
+  }
+  let matchedorigin;
+  let distance = 1;
+  for (const granted of input.granted) {
+    const candidate = lookalikedistance(input.origin, granted);
+    if (candidate < distance) {
+      distance = candidate;
+      matchedorigin = granted;
+    }
+  }
+  if (matchedorigin !== void 0 && distance <= input.threshold) {
+    return { origin: input.origin, matchedorigin, distance, threshold: input.threshold, blocked: true, reason: `The login origin ${input.origin} sits ${distance} away from the granted origin ${matchedorigin} and crosses the user threshold ${input.threshold}; the credential step blocks and the deny event names ${matchedorigin}.`, at: input.now };
+  }
+  return { origin: input.origin, ...matchedorigin !== void 0 ? { matchedorigin } : {}, distance, threshold: input.threshold, blocked: false, reason: matchedorigin !== void 0 ? `The login origin ${input.origin} sits ${distance} away from its closest granted origin ${matchedorigin} and stays under the user threshold ${input.threshold}.` : `The login origin ${input.origin} carries no granted origin to resemble; the watch records the first visit.`, at: input.now };
+}
+
 // policy.ts
 var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts", "recordscreen", "captureaudio", "downloadimages", "callrest", "callgraphql", "sendmessage", "blockrequest", "mockresponse", "rewriteheaders", "setcookies", "clearcookies", "authflow", "saveapikey", "routeproxy", "postform", "postfiles", "attachcdp", "detachcdp", "cdpcmd", "overridescript", "heapshot", "profilecpu", "capturesourcemaps", "emulatedevice", "emulatenetwork", "emulatelocate", "setuseragent", "overridepermission", "restoresession", "exportsessions", "importsessions", "runworkflow", "visitrule", "urlrule", "menurule", "keyrule", "buttonrule", "cronrule", "intervalrule", "urllistrule", "webhookrule", "eventrule"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction", "capturebodies", "setbreakpoint", "stepcode", "watchexpr", "loop", "repeatuntil", "whileloop", "foreach", "parallel", "trycatch"]);
@@ -9923,6 +10517,106 @@ function logreadgate(input) {
   if (!input.valid) return { allowed: false, reason: input.brokenat !== void 0 ? `The log chain breaks at entry ${input.brokenat}; the audit accessor refuses the read of a forged record.` : "The log chain fails its verification; the audit accessor refuses the read of a forged record." };
   return { allowed: true, reason: "The log chain verifies from the genesis hash to the last entry; the audit accessor serves the entries." };
 }
+function schemaguardgate(input) {
+  if (input.errors.length === 0) return { allowed: true, reason: "The inbound command matches its declared schemastrict grammar field by field." };
+  const first = input.errors[0];
+  return { allowed: false, reason: `${input.errors.length} schema error${input.errors.length === 1 ? "" : "s"} refuse the command before dispatch: ${input.errors.map((error) => error.reason).join(" ")}${first !== void 0 ? ` The first error sits at ${first.path} expecting ${first.expected}.` : ""}` };
+}
+function origincheckgate(input) {
+  if (!input.verdict.accepted) return { allowed: false, reason: input.verdict.reason };
+  return { allowed: true, reason: input.verdict.reason };
+}
+function ratelimitboundsvalid(limit, window2) {
+  const bounds = bucketboundsvalid(limit, window2);
+  if (!bounds.valid) return { allowed: false, reason: bounds.reason };
+  return { allowed: true, reason: bounds.reason };
+}
+function confirmpaygate(input) {
+  const kind = gatekindfor(input.classes);
+  if (kind !== "confirmpay") return { allowed: true, reason: "The step carries no payment class and needs no confirmpay gate." };
+  if (input.state === "resolved") return { allowed: true, reason: "The human resolved the confirmpay gate of the payment step; the step dispatches with its reviewed amount, payee origin and target." };
+  if (input.state === "refused") return { allowed: false, reason: "The human refused the confirmpay gate of the payment step; the payment never dispatches." };
+  if (input.state === "open") return { allowed: false, reason: "The confirmpay gate of the payment step stays open with the amount, the payee origin and the target element; the executor pauses until the human resolves it and no timeout ever resolves a gate." };
+  return { allowed: false, reason: "The payment step opens its confirmpay gate with the amount, the payee origin and the target element; the executor pauses until one distinct human action resolves it." };
+}
+function confirmdeletegate(input) {
+  const kind = gatekindfor(input.classes);
+  if (kind !== "confirmdelete") return { allowed: true, reason: "The step carries no delete class and needs no confirmdelete gate." };
+  if (input.state === "resolved") return { allowed: true, reason: "The human resolved the confirmdelete gate of the destructive step; the step dispatches with its reviewed target, scope and irreversibility." };
+  if (input.state === "refused") return { allowed: false, reason: "The human refused the confirmdelete gate of the destructive step; the deletion never dispatches." };
+  if (input.state === "open") return { allowed: false, reason: "The confirmdelete gate of the destructive step stays open with the target, the scope and the irreversibility; the executor pauses until the human resolves it and no timeout ever resolves a gate." };
+  return { allowed: false, reason: "The destructive step opens its confirmdelete gate with the target, the scope and the irreversibility; the executor pauses until one distinct human action resolves it." };
+}
+function confirmcredsgate(input) {
+  const kind = gatekindfor(input.classes);
+  if (kind !== "confirmcreds") return { allowed: true, reason: "The step carries no credential class and needs no confirmcreds gate." };
+  if (input.state === "resolved") return { allowed: true, reason: "The human resolved the confirmcreds gate of the credential step; the step reads its value from the vault at the last possible moment and no log records it." };
+  if (input.state === "refused") return { allowed: false, reason: "The human refused the confirmcreds gate of the credential step; the credential never dispatches." };
+  if (input.state === "open") return { allowed: false, reason: "The confirmcreds gate of the credential step stays open with its credential label only; the executor pauses until the human resolves it and no timeout ever resolves a gate." };
+  return { allowed: false, reason: "The credential step opens its confirmcreds gate with its credential label only; the executor pauses until one distinct human action resolves it." };
+}
+function phishthresholdgate(threshold) {
+  const verdict = phishthresholdvalid(threshold);
+  if (!verdict.valid) return { allowed: false, reason: verdict.reason };
+  return { allowed: true, reason: verdict.reason };
+}
+function phishguardgate(input) {
+  if (input.verdict.blocked) return { allowed: false, reason: input.verdict.reason };
+  return { allowed: true, reason: input.verdict.reason };
+}
+function safedefaultsgate(input) {
+  if (input.profile !== void 0) return { allowed: true, reason: `The origin profile of ${input.profile.origin} exists; the safedefaults posture stays out of the decision.` };
+  if (!input.sensitive) return { allowed: true, reason: "The non-sensitive step rides the reads only baseline of the safedefaults posture; the first visit grants reads alone." };
+  return { allowed: false, reason: `No origin profile exists and the safedefaults posture denies the sensitive ${input.classes.length > 0 ? input.classes.join(" and ") : "by default"} step; open the originprofile editor to widen the profile the user controls.` };
+}
+function vaultsecretgate(input) {
+  if (input.leaks.length > 0) return { allowed: false, reason: `The plan carries ${input.leaks.length} plaintext secret value${input.leaks.length === 1 ? "" : "s"} that digest to vault records; secrets never ride step options, variables or plan texts, only the vault holds them.` };
+  if (input.carries) return { allowed: false, reason: "The step types a raw value into a masked field shape; credential steps read their value from the vault at the last possible moment and never carry it in the options." };
+  return { allowed: true, reason: "The step and the plan carry no secret outside the vault; the values stay behind the seam." };
+}
+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.` };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -9945,6 +10639,10 @@ function recordturnaround2(progress, planid, stepid, milliseconds, now) {
   const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
   return { ...base, turnarounds: { ...base.turnarounds ?? {}, [stepid]: milliseconds }, updatedat: now };
 }
+function recordgatewait(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, gatewaits: { ...base.gatewaits ?? {}, [stepid]: entry }, updatedat: now };
+}
 function iscomplete(progress, plan) {
   if (!progress || progress.planid !== plan.id) return false;
   const required = plan.steps.map((step) => step.id);
@@ -10169,7 +10867,7 @@ function maskexport(record2, shapes) {
 }
 
 // version.ts
-var packageversion = "1.1.61";
+var packageversion = "1.1.63";
 
 // types.ts
 var protocolversion = packageversion;
@@ -11143,6 +11841,9 @@ function environmentreport(input) {
     ...input.keepalive !== void 0 ? { keepalive: input.keepalive } : {}
   };
 }
+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 };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -11646,7 +12347,7 @@ async function readcapabilities() {
   ]);
   return { tabs, downloads, clipboardread, clipboardwrite, reportedat: Date.now() };
 }
-function stepoptions2(step) {
+function stepoptions4(step) {
   if (!step.options) return {};
   try {
     const parsed = JSON.parse(step.options);
@@ -11659,7 +12360,7 @@ function tabid(step) {
   return Number.parseInt(step.value ?? "", 10);
 }
 async function runbrowseraction(step, sessiontabid, windowid) {
-  const options = stepoptions2(step);
+  const options = stepoptions4(step);
   switch (step.kind) {
     case "tablist": {
       const tabs = await chrome.tabs.query({});
@@ -12285,6 +12986,200 @@ 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 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 };
+}
+
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
 function buildrequest(input) {
@@ -13119,6 +14014,144 @@ function acceptrenderresult(input) {
   return { accepted: true, result, reason: `The render result of the step ${render.stepid} answers the nonce of its render; the text stays inside the frame.` };
 }
 
+// secretvault.ts
+var vaultdigestprefix = "sha256:";
+async function vaultdigestof(value) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+  return vaultdigestprefix + [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function vaultentryof(input) {
+  if (input.label.trim() === "") throw new Error("The vault record needs its label; the surfaces show the label only.");
+  if (input.scope.trim() === "") throw new Error("The vault record needs its exact origin scope; a secret never rides every origin.");
+  if (!input.digest.startsWith(vaultdigestprefix)) throw new Error("The vault record carries its sha-256 digest, never its value.");
+  return { vaultid: input.vaultid ?? randomid(), label: input.label.trim(), scope: input.scope.trim(), profileid: input.profileid, provenance: input.provenance, algorithm: "sha-256", digest: input.digest, createdat: input.now };
+}
+function inmemoryvault() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    put: async (vaultid, value) => {
+      values.set(vaultid, value);
+    },
+    fetch: async (vaultid) => values.get(vaultid),
+    drop: async (vaultid) => {
+      values.delete(vaultid);
+    }
+  };
+}
+async function vaultstore(input) {
+  if (input.value === "") throw new Error("The vault stores a secret value the user supplied; an empty value stores nothing.");
+  const entry = vaultentryof({ label: input.label, scope: input.scope, profileid: input.profileid, provenance: input.provenance, digest: await vaultdigestof(input.value), now: input.now });
+  await input.seam.put(entry.vaultid, input.value);
+  return entry;
+}
+async function vaultvaluefor(input) {
+  const value = await input.seam.fetch(input.entry.vaultid);
+  if (value === void 0) return { ok: false, reason: `The vault holds no value behind the label ${input.entry.label}; add the secret again.` };
+  return { ok: true, value, reason: `The vault released the value behind the label ${input.entry.label} at the last possible moment; the value reaches the credential field only and no log records it.` };
+}
+async function vaultdelete(input) {
+  await input.seam.drop(input.entry.vaultid);
+  return { dropped: true, label: input.entry.label, reason: `The vault dropped the secret ${input.entry.label} of ${input.entry.scope}; no value and no copy remains behind the seam.` };
+}
+async function secretleakscan(input) {
+  const leaks = [];
+  for (const candidate of input.candidates) {
+    if (candidate.trim() === "") continue;
+    const digest = await vaultdigestof(candidate);
+    if (input.entries.some((entry) => entry.digest === digest)) leaks.push(candidate);
+  }
+  if (leaks.length > 0) return { leaks, reason: `The plan carries ${leaks.length} plaintext value${leaks.length === 1 ? "" : "s"} that digest to vault records; secrets never ride step options, variables or plan texts, only the vault holds them.` };
+  return { leaks: [], reason: "No candidate value digests to a vault record; the plan carries no leaked secret." };
+}
+function stepoptions5(step) {
+  if (!step.options) return {};
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function secretshapecarrying(step) {
+  const options = stepoptions5(step);
+  const fields = Array.isArray(options.fields) ? options.fields.filter((item) => Boolean(item) && typeof item === "object") : [];
+  const rawfield = fields.find((field) => typeof field.name === "string" && typeof field.value === "string" && field.value !== "" && maskingfield(field.name, []));
+  if (rawfield !== void 0) return { carries: true, reason: `The ${step.kind} step types a raw value into the ${String(rawfield.name)} field; credential steps read their value from the vault at the last possible moment and never carry it in the options.` };
+  if (typeof options.field === "string" && maskingfield(options.field, []) && step.value !== void 0 && step.value !== "") return { carries: true, reason: `The ${step.kind} step types a raw value into the ${options.field} field; credential steps read their value from the vault at the last possible moment and never carry it in the options.` };
+  return { carries: false, reason: "The step carries no raw value behind a masked field shape." };
+}
+function vaultview(entries) {
+  return entries.map((entry) => ({ vaultid: entry.vaultid, label: entry.label, scope: entry.scope, provenance: entry.provenance, createdat: entry.createdat, ...entry.lastusedat !== void 0 ? { lastusedat: entry.lastusedat } : {} }));
+}
+
+// redactshots.ts
+function regionof(input) {
+  if (input.origin.trim() === "" || input.template.trim() === "") throw new Error("The redact region needs its origin and its page template.");
+  for (const value of [input.x, input.y, input.width, input.height]) {
+    if (!Number.isFinite(value) || value < 0) throw new Error("The redact region needs finite, non-negative geometry in css pixels.");
+  }
+  if (input.width <= 0 || input.height <= 0) throw new Error("The redact region needs a positive width and height so the mask covers a real area.");
+  if (input.reason.trim() === "") throw new Error("The redact region names its reason in plain language.");
+  return { id: input.id ?? randomid(), origin: input.origin.trim(), template: input.template.trim(), x: input.x, y: input.y, width: input.width, height: input.height, reason: input.reason.trim(), source: input.source, createdat: input.now };
+}
+function regionsfor(regions, origin, template) {
+  return regions.filter((region) => region.origin === origin && region.template === template);
+}
+function templateof(step) {
+  if (step.options) {
+    try {
+      const parsed = JSON.parse(step.options);
+      if (Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const template = parsed.template;
+        if (typeof template === "string" && template.trim() !== "") return template.trim();
+      }
+    } catch {
+    }
+  }
+  return step.kind;
+}
+function redactedshot(record2, regions) {
+  if (regions.length === 0) return record2;
+  return { ...record2, redacted: true, redactedregions: regions.length };
+}
+function redactionsummary(regions) {
+  if (regions.length === 0) return "No redact region covered the capture; the stored bytes carry everything the surface saw.";
+  const sources = { fieldshape: 0, userdrawn: 0 };
+  for (const region of regions) sources[region.source] += 1;
+  return `${regions.length} redact region${regions.length === 1 ? "" : "s"} covered the capture before storage: ${sources.fieldshape} derived from sensitive field shapes and ${sources.userdrawn} drawn by the user (${regions.map((region) => region.reason).join("; ")}).`;
+}
+
+// transparency.ts
+function permissiondiff(input) {
+  if (input.fromversion.trim() === "" || input.toversion.trim() === "") throw new Error("The permdiff names the two versions it compares.");
+  const added = [...new Set(input.to.filter((permission) => !input.from.includes(permission)))];
+  const removed = [...new Set(input.from.filter((permission) => !input.to.includes(permission)))];
+  return { fromversion: input.fromversion, toversion: input.toversion, added, removed, computedat: input.now };
+}
+function permdiffchanged(diff) {
+  return diff.added.length > 0 || diff.removed.length > 0;
+}
+function permdiffsummary(diff) {
+  if (!permdiffchanged(diff)) return `The update from ${diff.fromversion} to ${diff.toversion} changed no permission.`;
+  const parts = [];
+  if (diff.added.length > 0) parts.push(`added ${diff.added.join(", ")}`);
+  if (diff.removed.length > 0) parts.push(`removed ${diff.removed.join(", ")}`);
+  return `The update from ${diff.fromversion} to ${diff.toversion} ${parts.join(" and ")}.`;
+}
+function transparencygrants(input) {
+  const grants = input.allowlist.map((entry) => ({ origin: entry.origin, scope: `automation allowlist of the profile workspace ${entry.profileid}`, boundary: "the user revokes the entry or the profile workspace", grantedat: entry.grantedat }));
+  for (const profile of input.profiles) {
+    grants.push({ origin: profile.origin, scope: `origin profile with ${profile.grants.length} granted and ${profile.denials.length} denied kinds`, boundary: "the user edits or revokes the profile", grantedat: profile.createdat });
+  }
+  return grants;
+}
+function windowhistory(windows) {
+  return windows.map((window2) => ({ id: window2.id, origin: window2.origin, state: window2.state, boundary: window2.boundary, startedat: window2.startedat, expiresat: window2.expiresat }));
+}
+function connectallowlist(entries) {
+  return entries.map((entry) => ({ senderid: entry.senderid, displayname: entry.displayname, ...entry.origin !== void 0 ? { origin: entry.origin } : {}, addedat: entry.addedat }));
+}
+
 // modelroute.ts
 function routevalid(route) {
   if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
@@ -14325,13 +15358,28 @@ var chromestorage = {
   }
 };
 var memory = new sessionmemory(chromestorage);
+var vaultseamstore = (() => {
+  const session = chrome.storage?.session;
+  if (session) {
+    return {
+      put: async (vaultid, value) => {
+        await session.set({ [`vault:${vaultid}`]: value });
+      },
+      fetch: async (vaultid) => (await session.get(`vault:${vaultid}`))[`vault:${vaultid}`],
+      drop: async (vaultid) => {
+        await session.remove(`vault:${vaultid}`);
+      }
+    };
+  }
+  return inmemoryvault();
+})();
 function extensionpage(sender) {
   return sender.id === chrome.runtime.id && Boolean(sender.url?.startsWith(chrome.runtime.getURL("")));
 }
 async function audit(kind, summary, extra = {}) {
   await memory.addaudi({ id: randomid(), kind, at: Date.now(), summary, ...extra });
 }
-function stepoptions3(step) {
+function stepoptions6(step) {
   try {
     return parseoptions(step);
   } catch {
@@ -14556,6 +15604,12 @@ async function securitystepgate(step, session, origin, settings) {
   const allowverdict = automationallowlistgate({ origin, allowlist: await memory.getautomationallowlist(), session });
   if (!allowverdict.allowed) return { allowed: false, suspended: false, reason: allowverdict.reason ?? "", classification };
   const profile = (await memory.getoriginprofiles()).find((candidate) => candidate.origin === origin);
+  if (profile === void 0) {
+    await memory.addsafedefaultapplication({ origin, firstseenat: now }).catch(() => {
+    });
+    const safedefaultverdict = safedefaultsgate({ profile, classes: classification.classes, sensitive: classification.sensitive });
+    if (!safedefaultverdict.allowed) return { allowed: false, suspended: false, reason: safedefaultverdict.reason ?? "", classification };
+  }
   const profileverdict = originprofilegate({ profile, kind: step.kind, sensitive: classification.sensitive });
   if (!profileverdict.allowed) return { allowed: false, suspended: false, reason: profileverdict.reason ?? "", classification };
   const windows = await memory.expireconsentwindows(now);
@@ -14568,8 +15622,115 @@ async function securitystepgate(step, session, origin, settings) {
   const revocation = plan === void 0 ? void 0 : (await memory.getrevocations()).find((candidate) => candidate.sessionid === session.id && candidate.runid === plan.id);
   const revokeverdict = revokerungate({ revocation, sessionid: session.id, runid: plan?.id ?? "" });
   if (!revokeverdict.allowed) return { allowed: false, suspended: false, reason: revokeverdict.reason ?? "", classification };
+  const confirmverdict = await confirmgatechain(step, session, plan, origin, classification, now);
+  if (confirmverdict !== void 0) return { allowed: confirmverdict.allowed, suspended: false, reason: confirmverdict.reason, classification };
   return { allowed: true, suspended: false, reason: `${classification.reason} ${allowverdict.reason ?? ""} ${windowverdict.reason ?? ""} ${consentverdict.reason ?? ""}`, classification };
 }
+async function confirmgatechain(step, session, plan, origin, classification, now) {
+  if (!session || !plan) return void 0;
+  const kind = gatekindfor(classification.classes);
+  if (kind !== void 0) {
+    const gates = await memory.getgates();
+    const state = gatestateof(gates, step.id);
+    if (state.state === "none") {
+      const vaultentries2 = await memory.getsecretvault();
+      const vaultlabel = vaultentries2.find((entry) => entry.scope === origin)?.label;
+      const gate = gateforstep({ step, classes: classification.classes, runid: plan.id, origin, credentiallabel: vaultlabel ?? `the credential the ${step.kind} step reviews`, now });
+      if (gate) {
+        await memory.savegate(gate);
+        await appendrunevent("gate", `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}: ${gateprompttext(gate)}`, session, origin, step.id).catch(() => {
+        });
+        await audit("gate", `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}; the executor pauses until one distinct human action resolves it and no timeout ever resolves a gate.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+        return { allowed: false, reason: `The ${gate.kind} gate opened for the ${step.kind} step ${step.id} on ${origin}: ${gateprompttext(gate)} The executor pauses until the human resolves it.` };
+      }
+    }
+    const gateverdict = kind === "confirmpay" ? confirmpaygate({ classes: classification.classes, state: state.state }) : kind === "confirmdelete" ? confirmdeletegate({ classes: classification.classes, state: state.state }) : confirmcredsgate({ classes: classification.classes, state: state.state });
+    if (!gateverdict.allowed) return { allowed: false, reason: gateverdict.reason ?? "" };
+    if (state.state === "resolved" && state.gate !== void 0 && state.gate.resolvedat !== void 0) {
+      await memory.setprogress(recordgatewait(await memory.getprogress(), plan.id, step.id, { gateid: state.gate.gateid, kind: state.gate.kind, openedat: state.gate.openedat, resolvedat: state.gate.resolvedat, waitedms: Math.max(0, state.gate.resolvedat - state.gate.openedat) }, now)).catch(() => {
+      });
+    }
+  }
+  if (credentialstep(step)) {
+    const settings = await memory.getsettings();
+    const threshold = settings?.phishdistance;
+    if (threshold !== void 0) {
+      const thresholdgate = phishthresholdgate(threshold);
+      if (!thresholdgate.allowed) return { allowed: false, reason: thresholdgate.reason ?? "" };
+      const live = await memory.expirephishverdicts(settings?.phishfreshness, now);
+      const stored = live.find((verdict2) => verdict2.origin === origin);
+      const verdict = stored ?? phishverdictof({ origin, granted: [.../* @__PURE__ */ new Set([...(await memory.getautomationallowlist()).map((entry) => entry.origin), session.origin])], threshold, now });
+      if (stored === void 0) await memory.addphishverdict(verdict);
+      const phishgate = phishguardgate({ verdict });
+      if (!phishgate.allowed) {
+        await appendrunevent("phish", `The phishguard blocked the credential step ${step.id} on ${origin}: ${verdict.reason}`, session, origin, step.id).catch(() => {
+        });
+        await audit("phish", `The phishguard blocked the ${step.kind} step ${step.id} on ${origin}: ${verdict.reason}`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+        return { allowed: false, reason: phishgate.reason ?? "" };
+      }
+    }
+  }
+  const buckets = await memory.getratelimitbuckets();
+  const bucket = buckets.find((candidate) => candidate.origin === origin && candidate.sessionid === session.id);
+  if (bucket !== void 0) {
+    const consumed = bucketconsume({ bucket, now });
+    if (!consumed.allowed) {
+      const deferred = deferredeventof({ stepid: step.id, kind: step.kind, origin, reason: consumed.reason, resetsat: consumed.resetsat, now });
+      await memory.adddeferredevent(deferred);
+      await appendrunevent("suspend", `The ratelimit bucket of ${origin} deferred the ${step.kind} step ${step.id} until the window resets at ${deferred.resetsat}: ${consumed.reason}`, session, origin, step.id).catch(() => {
+      });
+      await audit("defer", `The ratelimit bucket of ${origin} deferred the ${step.kind} step ${step.id} until the window resets at ${deferred.resetsat}; the bounds stay user configured choices with no hidden ceiling.`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+      return { allowed: false, reason: consumed.reason };
+    }
+    await memory.saveratelimitbucket(consumed.bucket);
+  }
+  const vaultentries = await memory.getsecretvault();
+  const options = stepoptions6(step);
+  const candidates = [step.value ?? "", ...Object.values(options).filter((value) => typeof value === "string")];
+  const leakscan = await secretleakscan({ candidates, entries: vaultentries });
+  const secretverdict = vaultsecretgate({ leaks: leakscan.leaks, carries: secretshapecarrying(step).carries });
+  if (!secretverdict.allowed) {
+    await audit("vault", `The vault secret scan refused the ${step.kind} step ${step.id} on ${origin}: ${secretverdict.reason}`, { sessionid: session.id, planid: plan.id, stepid: step.id });
+    return { allowed: false, reason: secretverdict.reason ?? "" };
+  }
+  return void 0;
+}
+async function resolvevaultvalues(step, session) {
+  void session;
+  const marker = /^vault:[A-Za-z0-9-]+$/;
+  if (step.options === void 0 || !step.options.includes("vault:")) return step;
+  const entries = await memory.getsecretvault();
+  let options = step.options;
+  try {
+    const parsed = JSON.parse(step.options);
+    if (Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const record2 = parsed;
+      const resolvevalue = async (value) => {
+        if (!marker.test(value)) return value;
+        const entry = entries.find((candidate) => candidate.vaultid === value.slice("vault:".length));
+        if (!entry) return value;
+        const fetched = await vaultvaluefor({ seam: vaultseamstore, entry });
+        if (fetched.ok && fetched.value !== void 0) {
+          await memory.stampsecretuse(entry.vaultid, Date.now());
+          return fetched.value;
+        }
+        return value;
+      };
+      for (const [key, value] of Object.entries(record2)) if (typeof value === "string") record2[key] = await resolvevalue(value);
+      if (Array.isArray(record2.fields)) {
+        for (const field of record2.fields) {
+          if (!Boolean(field) || typeof field !== "object" || Array.isArray(field)) continue;
+          const fieldrecord = field;
+          if (typeof fieldrecord.value === "string") fieldrecord.value = await resolvevalue(fieldrecord.value);
+        }
+      }
+      options = JSON.stringify(record2);
+    }
+  } catch {
+  }
+  if (options === step.options) return step;
+  return { ...step, options };
+}
 async function sealsessionrunlog(sessionid) {
   const log = await memory.getimmutablelog(sessionid);
   if (!log || log.seal !== void 0 || log.entries.length === 0) return;
@@ -14593,10 +15754,19 @@ async function securityviewof() {
     maskrules: await memory.getmaskrules(),
     chain,
     posture: "denydefault",
+    gates: await memory.getgates(),
+    resolutions: await memory.getgateresolutions(),
+    deferred: await memory.getdeferredevents(),
+    phishverdicts: await memory.getphishverdicts(),
+    vault: await memory.getsecretvault(),
+    connectallow: await memory.getconnectallow(),
+    safedefaults: await memory.getsafedefaultapplications(),
+    redactregions: await memory.getredactregions(),
     ...session ? { sessionorigin: session.origin } : {},
     ...settings?.consentduration !== void 0 ? { promptduration: settings.consentduration } : {},
     ...settings?.logretention !== void 0 ? { logretention: settings.logretention } : {},
-    ...settings?.maskshapes !== void 0 ? { maskshapes: settings.maskshapes } : {}
+    ...settings?.maskshapes !== void 0 ? { maskshapes: settings.maskshapes } : {},
+    ...settings?.phishdistance !== void 0 ? { phishdistance: settings.phishdistance } : {}
   };
 }
 async function executeisolatedevaluate(step, tabid2, origin) {
@@ -14618,9 +15788,11 @@ async function executeisolatedevaluate(step, tabid2, origin) {
   return result[0]?.result ?? { ok: false, summary: "The isolated world returned no result." };
 }
 async function executesandboxrender(step, session, plan, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const markup = typeof options.markup === "string" ? options.markup : "";
   const sourceorigin = typeof options.sourceorigin === "string" ? options.sourceorigin : origin;
+  const rendergate = untrustedrendergate({ environment: "sandboxframe" });
+  if (!rendergate.allowed) throw new Error(rendergate.reason);
   const settings = await memory.getsettings();
   const origingate = sandboxorigingate({ origin: sourceorigin, allowed: settings?.sandboxorigins ?? [] });
   if (!origingate.allowed) throw new Error(origingate.reason);
@@ -14652,7 +15824,7 @@ async function offloadparsetoworker(step, output, session, plan, origin) {
   const ready = await ensureoffscreendocument(runid);
   if (!ready) return { output, turnaround: void 0 };
   const payload = JSON.stringify({ summary: output?.summary ?? "", details: output?.details ?? {} });
-  const request = workerrequestof({ id: randomid(), runid, stepid: step.id, kind: step.kind, payload, options: stepoptions3(step), sentat: Date.now() });
+  const request = workerrequestof({ id: randomid(), runid, stepid: step.id, kind: step.kind, payload, options: stepoptions6(step), sentat: Date.now() });
   const started = Date.now();
   let answer;
   try {
@@ -14743,6 +15915,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 });
@@ -14855,7 +16031,7 @@ function stepauditkind(step, ok) {
   return ok ? "action" : "error";
 }
 function resolvedinnerstep(step, plan) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   if (typeof options.stepid === "string" && options.stepid.trim()) {
     return plan.steps.find((candidate) => candidate.id === options.stepid) ?? null;
   }
@@ -14864,7 +16040,7 @@ function resolvedinnerstep(step, plan) {
 async function executekeyhold(step, session, plan, tabid2, origin) {
   const output = await dispatchpagestep(step, tabid2, origin, plan);
   if (!output?.ok) return output ?? { ok: false, summary: "The key hold was not delivered." };
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const holdid = typeof options.holdid === "string" && options.holdid.trim() ? options.holdid : randomid();
   const modifiers = Array.isArray(options.modifiers) ? options.modifiers.filter((item) => typeof item === "string") : [];
   const hold = { holdid, key: step.value ?? "", ...modifiers.length > 0 ? { modifiers } : {}, tabid: tabid2, stepid: step.id, pressedat: Date.now() };
@@ -14897,7 +16073,7 @@ async function executedismissdialog(step, session, plan, tabid2, origin) {
   return { ok: true, summary: `Dialog handler armed${answer} for the next confirm, alert or prompt.` };
 }
 async function executeretryaction(step, session, plan, tabid2, origin) {
-  const rule = stepoptions3(step).retryrule;
+  const rule = stepoptions6(step).retryrule;
   const inner = resolvedinnerstep(step, plan);
   if (!inner) throw new Error("The reviewed wrapper step could not be resolved.");
   const innergate = validatestep(inner, origin);
@@ -14933,8 +16109,8 @@ async function executeenterframe(step, plan, tabid2, origin) {
   if (!inner) throw new Error("The reviewed frame wrapper step could not be resolved.");
   const innergate = validatestep(inner, origin);
   if (!innergate.allowed) throw new Error(`The wrapped step is not allowed: ${innergate.reason}`);
-  const options = stepoptions3(step);
-  const inneroptions = inner.options ? stepoptions3(inner) : void 0;
+  const options = stepoptions6(step);
+  const inneroptions = inner.options ? stepoptions6(inner) : void 0;
   const derived = { ...step, options: JSON.stringify({ ...options, kind: inner.kind, ...inner.target ? { target: inner.target } : {}, ...inner.value ? { value: inner.value } : {}, ...inneroptions ? { options: inneroptions } : {} }) };
   return dispatchpagestep(derived, tabid2, origin, plan);
 }
@@ -14946,7 +16122,7 @@ function detailarray(details, key) {
   return Array.isArray(value) ? value : [];
 }
 async function executediffsnapshots(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const versions = Array.isArray(options.versions) ? options.versions.filter((item) => typeof item === "number") : [];
   const baseversion = versions[0];
   const targetversion = versions[1];
@@ -14969,7 +16145,7 @@ async function executediffsnapshots(step, session, plan, tabid2, origin) {
   return { ok: Boolean(output.ok), summary: output.summary, details: { ...output.details ?? {}, versions: [baseversion, targetversion] } };
 }
 async function executewatchstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const watchid = typeof options.watchid === "string" && options.watchid.trim() ? options.watchid : randomid();
   const scopes = Array.isArray(options.scopes) ? options.scopes.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
   const events = Array.isArray(options.events) ? options.events.filter((item) => typeof item === "string" && item.trim().length > 0) : [];
@@ -15651,7 +16827,7 @@ function commandtabids(step, options) {
   return listed.length > 0 ? listed : single;
 }
 async function executetabscommand(step, session, plan, sessiontabid) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   const windowid = step.value && /^\d+$/.test(step.value) ? Number.parseInt(step.value, 10) : 0;
   const layoutgate = layoutmutationgranted(session, Date.now());
@@ -15927,7 +17103,7 @@ async function executetabscommand(step, session, plan, sessiontabid) {
   }
 }
 async function executesaveprofiles(step, session, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const record2 = parseformrecord(options.formrecord);
   const name = typeof options.name === "string" ? options.name : "";
   if (!name || !record2) throw new Error("A reviewed profile name and form record are required.");
@@ -15947,7 +17123,7 @@ async function executeasksubmit(step, session, plan, tabid2, origin) {
   return { ok: true, summary: `Asksubmit prompt opened for form ${ticket.form || "the reviewed form"}; the submission waits for your approval.`, details: { ticket, values } };
 }
 async function executesubmitform(step, session, plan, tabid2, origin) {
-  const consentref = typeof stepoptions3(step).consentref === "string" ? stepoptions3(step).consentref : "";
+  const consentref = typeof stepoptions6(step).consentref === "string" ? stepoptions6(step).consentref : "";
   const ticket = (await memory.gettickets()).find((item) => item.approved === true && (item.consentref === consentref || item.id === consentref));
   if (!ticket) throw new Error("No approved asksubmit ticket matches the reviewed consent ref; approve the submission in the review panel first.");
   const output = await dispatchpagestep(step, tabid2, origin, plan) ?? { ok: false, summary: "The form submission returned no result." };
@@ -15971,7 +17147,7 @@ async function executeretryform(step, session, plan, tabid2, origin) {
   return { ok: Boolean(output?.ok), summary: output?.summary ?? "The retried submission returned no result.", details: { attempts, windows, ok: Boolean(output?.ok) } };
 }
 async function executeconsentpassword(step, session, plan, tabid2, origin) {
-  const consentref = typeof stepoptions3(step).consentref === "string" ? stepoptions3(step).consentref : "";
+  const consentref = typeof stepoptions6(step).consentref === "string" ? stepoptions6(step).consentref : "";
   const gate = passwordconsentgranted(step);
   if (!gate.allowed) throw new Error(gate.reason ?? "A password fill requires a reviewed consent ref.");
   const output = await dispatchpagestep(step, tabid2, origin, plan);
@@ -15983,7 +17159,7 @@ async function executeattachfile(step, session, plan, tabid2, origin) {
   const artifacts = await memory.getartifacts();
   const artifact = artifacts.find((item) => item.name === name || item.id === name);
   if (!artifact) throw new Error(`No generated artifact named ${name} exists in the run store yet.`);
-  const derived = { ...step, options: JSON.stringify({ ...stepoptions3(step), artifact: artifact.id, artifactname: artifact.name }) };
+  const derived = { ...step, options: JSON.stringify({ ...stepoptions6(step), artifact: artifact.id, artifactname: artifact.name }) };
   const output = await dispatchpagestep(derived, tabid2, origin, plan);
   await audit("fill", `Artifact ${artifact.name} of kind ${artifact.kind} attached to the reviewed file input inside the form submission.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
   return { ...output ?? { ok: false, summary: "The artifact attachment returned no result." }, details: { ...output?.details ?? {}, artifact } };
@@ -16016,7 +17192,7 @@ async function executeformstep(step, session, plan, tabid2, origin) {
       return executecaptchahandoff(step, session, plan, tabid2, origin);
     case "fillcode": {
       const stored = await memory.getcodevalue();
-      const source = typeof stepoptions3(step).source === "string" ? stepoptions3(step).source : "";
+      const source = typeof stepoptions6(step).source === "string" ? stepoptions6(step).source : "";
       const derived = stored !== void 0 && source === "reviewed" ? { ...step, value: stored } : step;
       const output = await dispatchpagestep(derived, tabid2, origin, plan);
       await audit("fill", `One time code typed from the reviewed source ${source}${stored !== void 0 ? " through the consent gated code entry" : ""}.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
@@ -16087,7 +17263,7 @@ async function storeexport(stepid, datasetvalue, format, delimiter, session, pla
   return artifact;
 }
 async function executedatastep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   switch (step.kind) {
     case "scrapetable": {
@@ -16317,7 +17493,7 @@ async function verifyonerecord(record2, expected, extra) {
   return { ok: verification.ok, summary: verification.summary, details: { verification: { ...verification.matches, state: record2.state, path: record2.path, checksum: record2.checksum, bytes: record2.bytes } } };
 }
 async function executefilesstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   switch (step.kind) {
     case "batchdownload": {
@@ -16546,7 +17722,7 @@ reconcilmimefilter().catch(() => {
 });
 var stitchprogress = /* @__PURE__ */ new Map();
 function stepcaptureoptions(step) {
-  return captureoptionsof(stepoptions3(step).capture);
+  return captureoptionsof(stepoptions6(step).capture);
 }
 async function blobtodataurl(blob) {
   const buffer = new Uint8Array(await blob.arrayBuffer());
@@ -16670,7 +17846,7 @@ async function encodecanvas(width, height, draw, options) {
   return canvasdataurl(canvas, options.format, options.quality);
 }
 async function capturenamefor(step, plan, kind, format) {
-  const naming = stepoptions3(step).naming;
+  const naming = stepoptions6(step).naming;
   const rule = naming && typeof naming === "object" && !Array.isArray(naming) ? naming : { run: true, step: true, sequence: true, kind: true };
   const counters = (await memory.getcapturecounters()).find((item) => item.taskid === plan.id);
   const advanced = advancecounter(counters?.counters ?? {}, step.id);
@@ -16710,13 +17886,62 @@ async function grabstateshot(step, session, plan, tabid2, phase) {
   return record2;
 }
 async function storecapture(record2, session, plan, step, origin) {
+  const template = templateof(step);
+  const regions = regionsfor(await memory.getredactregions(), origin, template);
+  record2 = redactedshot(record2, regions);
   await memory.addcapture(record2);
+  if (regions.length > 0) await audit("capture", `The capture of ${origin} on the template ${template} stored with its sensitive regions masked: ${redactionsummary(regions)}`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
   const routed = await routecapture(record2, session, plan, step, origin);
   await memory.setprogress(recordcapture(await memory.getprogress(), plan.id, step.id, record2, Date.now()));
   await refreshbadge();
   return { record: record2, routed };
 }
+var activeredactregions = [];
+async function drawredactoverlays(tabid2) {
+  if (activeredactregions.length === 0) return;
+  const rects = activeredactregions.map((region) => ({ x: region.x, y: region.y, width: region.width, height: region.height }));
+  await chrome.scripting.executeScript({ target: { tabId: tabid2 }, func: (overlays) => {
+    let host = document.getElementById("devthinkredacthost");
+    if (!host) {
+      host = document.createElement("div");
+      host.id = "devthinkredacthost";
+      host.style.position = "fixed";
+      host.style.inset = "0";
+      host.style.zIndex = "2147483647";
+      host.style.pointerEvents = "none";
+      document.documentElement.appendChild(host);
+    }
+    for (const overlay of overlays) {
+      const rect = document.createElement("div");
+      rect.style.position = "fixed";
+      rect.style.left = `${overlay.x}px`;
+      rect.style.top = `${overlay.y}px`;
+      rect.style.width = `${overlay.width}px`;
+      rect.style.height = `${overlay.height}px`;
+      rect.style.background = "#000";
+      host.appendChild(rect);
+    }
+  }, args: [rects] }).catch(() => {
+  });
+}
+async function clearredactoverlays(tabid2) {
+  if (activeredactregions.length === 0) return;
+  await chrome.scripting.executeScript({ target: { tabId: tabid2 }, func: () => {
+    document.getElementById("devthinkredacthost")?.remove();
+  } }).catch(() => {
+  });
+}
 async function executecapturestep(step, session, plan, tabid2, origin) {
+  activeredactregions = regionsfor(await memory.getredactregions(), origin, templateof(step));
+  await drawredactoverlays(tabid2);
+  try {
+    return await executecapturestepinner(step, session, plan, tabid2, origin);
+  } finally {
+    await clearredactoverlays(tabid2);
+    activeredactregions = [];
+  }
+}
+async function executecapturestepinner(step, session, plan, tabid2, origin) {
   const options = stepcaptureoptions(step);
   const format = options.format ?? "png";
   const ratio = options.pixelratio ?? 1;
@@ -16739,7 +17964,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
     return { ok: true, summary: `Captured the visible viewport at ${record2.width} by ${record2.height} pixels.`, details: { capture: { id: record2.id, kind: record2.kind, format: record2.format, width: record2.width, height: record2.height, bytes: (record2.bytes ?? "").length, exporttarget: stored.routed.target } } };
   }
   if (step.kind === "shotfullpage") {
-    const rawoptions = stepoptions3(step);
+    const rawoptions = stepoptions6(step);
     const settle2 = typeof rawoptions.settle === "number" ? rawoptions.settle : 150;
     const overlap = typeof rawoptions.overlap === "number" ? rawoptions.overlap : 0;
     const wait = typeof rawoptions.wait === "number" ? rawoptions.wait : void 0;
@@ -16776,7 +18001,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
   }
   if (step.kind === "shotelement") {
     const selector = step.target ?? "";
-    const settle2 = typeof stepoptions3(step).settle === "number" ? stepoptions3(step).settle : 150;
+    const settle2 = typeof stepoptions6(step).settle === "number" ? stepoptions6(step).settle : 150;
     const measured = await bridgecall(tabid2, "measurepage");
     const targetinfo = await bridgecall(tabid2, "elementrect", selector);
     if (!targetinfo.ok || !targetinfo.rect) throw new Error(targetinfo.summary);
@@ -16817,7 +18042,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
     }
   }
   if (step.kind === "shotregion") {
-    const rawoptions = stepoptions3(step);
+    const rawoptions = stepoptions6(step);
     const rect = rawoptions.regionrect;
     if (!rect) throw new Error("A reviewed regionrect is required in options.");
     const container = typeof rawoptions.container === "string" ? rawoptions.container : void 0;
@@ -16858,7 +18083,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
     }
   }
   if (step.kind === "contactsheet") {
-    const rawoptions = stepoptions3(step);
+    const rawoptions = stepoptions6(step);
     const elements = (Array.isArray(rawoptions.elements) ? rawoptions.elements : []).filter((item) => typeof item === "string" && item.trim().length > 0);
     const layout = rawoptions.sheet && typeof rawoptions.sheet === "object" && !Array.isArray(rawoptions.sheet) ? rawoptions.sheet : { cellsize: 240, columns: 3, label: "both" };
     const measured = await bridgecall(tabid2, "measurepage");
@@ -16969,7 +18194,7 @@ async function thumbonecapture(source, directive, plan, step) {
   return { id: randomid(), runid: plan.id, stepid: step.id, kind: "makethumbs", format, width: geometry.width, height: geometry.height, capturedat: Date.now(), bytes: dataurl, name, target: source.id };
 }
 async function executemediastep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   const gate = mediagate(session, tabid2, origin, Date.now());
   if (!gate.allowed) throw new Error(gate.reason ?? "The media capture needs the active session tab grant.");
@@ -17228,7 +18453,7 @@ async function attachapikeys(names, origin) {
   return { headers, keys: attached };
 }
 async function executehttpstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   if (step.kind === "fetchurl") {
     const request = fetchrequestof(options.fetch);
@@ -17493,7 +18718,7 @@ async function closechannelsforrun(runid) {
   channelbuses.clear();
 }
 async function executesocketstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   if (step.kind === "opensocket") {
     const channel = channeloptionsof(options.socket);
@@ -17627,7 +18852,7 @@ async function executesocketstep(step, session, plan, tabid2, origin) {
   throw new Error("Unsupported socket observation kind.");
 }
 async function executenetwatchstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   if (step.kind === "watchrequests") {
     const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
@@ -17779,7 +19004,7 @@ function timelinedetail(entry, runid) {
   return { id: randomid(), runid, stepid: record2.stepid, time: record2.time, level: record2.level, source: record2.source, message: record2.message };
 }
 async function executetimelinestep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const watch = options.watch && typeof options.watch === "object" && !Array.isArray(options.watch) ? options.watch : {};
   const watchwindow = typeof watch.window === "number" && Number.isFinite(watch.window) && watch.window >= 0 ? watch.window : 0;
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
@@ -17934,7 +19159,7 @@ function pauseframes(entry) {
   });
 }
 async function executecdpstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   const debuggatecheck = debuggate(session, tabid2, origin, Date.now());
   if (!debuggatecheck.allowed) throw new Error(debuggatecheck.reason ?? "The devtools protocol step stays outside the debug gate.");
@@ -18168,7 +19393,7 @@ async function sampleheapforstep(tracker, stepid, tabid2, origin, plan) {
   if (trend.flaggedsteps.includes(stepid)) await memory.addtimelineentry({ id: randomid(), runid: tracker.runid, stepid, time: now, level: "warn", source: "longtask", message: `Heap growth of step ${stepid} exceeds the reviewed slope of ${tracker.slope} bytes per millisecond; the step is flagged in the memory trend.` });
 }
 async function executeprofilestep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   const targets = profiletargetsof(options);
   const grants = await memory.getdebuggergrants();
@@ -18497,7 +19722,7 @@ async function controlledfetch(runid, url, init, controller, window2, streamstat
   return response;
 }
 async function executenetcontrolstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   const ruleset = rulesetof(plan.id);
   if (step.kind === "blockrequest") {
@@ -18744,7 +19969,7 @@ async function enforcewindowreview(step, session, plan) {
   const progress = plan ? await memory.getprogress() : void 0;
   const tasktabids = plan ? trackedtasktabs(progress, plan.id) : [];
   const count = tasktabsinwindow(await livetabs(), windowid, tasktabids);
-  const gate = windowclosegate(count, stepoptions3(step).reviewed === true);
+  const gate = windowclosegate(count, stepoptions6(step).reviewed === true);
   if (!gate.allowed) throw new Error(gate.reason ?? "The window close needs explicit review.");
   if (session && count > 0) await audit("window", `Window ${windowid} closes while holding ${count} task tab${count === 1 ? "" : "s"} under the explicit reviewed flag.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
 }
@@ -18830,7 +20055,7 @@ async function revertemulationforrun(runid, reason, tabid2) {
   }
 }
 async function executeemulationstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   const revertplan = revertplanof(options.revertplan) ?? [];
   const family = familyofkind(step.kind) ?? "device";
@@ -18962,7 +20187,7 @@ async function performrestore(record2, restore, session) {
   return { restored, skippedorigins: grantscheck.skippedorigins };
 }
 async function executesessionstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   if (step.kind === "persiststate") {
     const progress = await memory.getprogress();
@@ -19107,7 +20332,7 @@ async function dispatchworkflowstep(step, context) {
   return { ok: Boolean(output.ok), summary: output.summary, ...output.details !== void 0 ? { details: output.details } : {} };
 }
 async function executedelaystep(step) {
-  const options = stepoptions3({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions6({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
   const delay = delayof(options.delay);
   const sampled = delayjitter(delay, hashseed(`${step.id}:${Date.now()}`));
   const transport = await sleepreviewed(sampled, step.id);
@@ -19154,7 +20379,7 @@ async function sleepreviewed(sampled, stepid) {
   return "timer";
 }
 async function executewaitelement(step, tabid2) {
-  const options = stepoptions3({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.target !== void 0 ? { target: step.target } : {}, ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions6({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.target !== void 0 ? { target: step.target } : {}, ...step.options !== void 0 ? { options: step.options } : {} });
   const wait = waitof(options.wait, step.target);
   const startedat = Date.now();
   const starttab = await chrome.tabs.get(tabid2).catch(() => void 0);
@@ -19182,7 +20407,7 @@ function waitof(value, target) {
   return { selector, timeout, poll };
 }
 async function executecomputestep(step, session) {
-  const options = stepoptions3({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions6({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
   const expression = options.expression;
   if (!expression || typeof expression !== "object") throw new Error("The compute step needs a reviewed expression.");
   const scopes = runscopes(options.variables);
@@ -19191,7 +20416,7 @@ async function executecomputestep(step, session) {
   return { ok: true, summary: `Computed ${expression.result} = ${typeof value === "string" ? `"${value}"` : String(value)} through the ${expression.operator} operator.`, details: { result: expression.result, kind: expression.resultkind, value } };
 }
 async function executeextractvarsstep(step, session) {
-  const options = stepoptions3({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.value !== void 0 ? { value: step.value } : {}, ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions6({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.value !== void 0 ? { value: step.value } : {}, ...step.options !== void 0 ? { options: step.options } : {} });
   const rule = options.rule;
   if (!rule || typeof rule !== "object" || typeof rule.pattern !== "string") throw new Error("The variable extraction needs a reviewed regex rule.");
   const text2 = typeof options.text === "string" ? options.text : step.value ?? "";
@@ -19204,7 +20429,7 @@ async function executeextractvarsstep(step, session) {
   return { ok: true, summary: `Captured ${extraction.variables.length} variable${extraction.variables.length === 1 ? "" : "s"} from the reviewed text.`, details: { matched: true, variables: extraction.variables } };
 }
 async function executeworkflowstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   if (step.kind === "composeworkflow") {
     const payload = options.workflow;
     if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("The workflow composition needs the reviewed workflow payload.");
@@ -19260,7 +20485,7 @@ function workflowstepofentry(value) {
   return blockinvocationof(value);
 }
 async function executeworkflowrun(step, session, plan, tabid2, origin, dry) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const workflowid = typeof options.workflowid === "string" ? options.workflowid : "";
   const storedrecord = await memory.getworkflowrecord(workflowid);
   if (!storedrecord) throw new Error(`No composed workflow matches ${workflowid || "the reviewed id"}.`);
@@ -19423,7 +20648,7 @@ async function storetimeoutabort(run, step, message, budget) {
   return { run: aborted, log: [entry] };
 }
 async function executetriggerstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const family = triggerfamilyof(step.kind);
   if (!family) throw new Error(`The ${step.kind} step is not a reviewed trigger kind.`);
   const workflowid = typeof options.workflowid === "string" ? options.workflowid : "";
@@ -19643,12 +20868,15 @@ 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 });
     }
     throw new Error(securityverdict.reason);
   }
+  step = await resolvevaultvalues(step, session);
   if (session && plan && plan.state === "approved" && mode === "plan") await openplanrun(session, plan);
   if (plan && plan.state === "approved") await markpendingstep(plan, step.id);
   if (routing.environment === "sandboxframe") return executesandboxrender(step, session, plan, origin);
@@ -19781,6 +21009,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") {
@@ -19812,11 +21051,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();
@@ -19825,7 +21089,7 @@ async function previewstep(stepid) {
   if (!step) throw new Error("Reviewed step was not found.");
   const gate = canpreview({ session, plan, step, tabid: tab.id, origin });
   if (!gate.allowed) throw new Error(gate.reason);
-  if (!step.target && !stepoptions3(step).targetref) throw new Error("Only a target-based step can be previewed.");
+  if (!step.target && !stepoptions6(step).targetref) throw new Error("Only a target-based step can be previewed.");
   const result = await chrome.scripting.executeScript({ target: { tabId: tab.id }, func: (action, expectedorigin) => {
     const bridge = globalThis.devthinkbridge;
     if (!bridge) throw new Error("Devthink page bridge is unavailable.");
@@ -19876,8 +21140,253 @@ async function extractionreportValue() {
 async function provenancereportValue() {
   return provenancereport({ records: await memory.getprovenances() });
 }
+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: {},
+  execute: { stepid: "string" },
+  configure: { endpoint: "string" }
+};
+function schemavalidation(message) {
+  if (!Boolean(message) || typeof message !== "object" || Array.isArray(message)) return [{ path: "message", expected: "object", found: Array.isArray(message) ? "array" : typeof message, reason: "Every inbound command travels as one plain object; schemastrict refuses the carrier before dispatch." }];
+  const command = message;
+  if (typeof command.kind !== "string" || command.kind.trim() === "") return [{ path: "kind", expected: "string", found: typeof command.kind, reason: "Every inbound command names its kind as a non-empty string; a kindless command never dispatches." }];
+  const schema = commandschemas[command.kind];
+  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 handlerequest(message, sender) {
-  if (!extensionpage(sender)) throw new Error("Requests are accepted only from Devthink extension pages.");
+  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 });
+  if (!inboundgate.allowed) {
+    await audit("inbound", `The origincheck dropped an inbound message from ${originverdict.sender}${originverdict.origin !== "" ? ` of ${originverdict.origin}` : ""} without handler execution: ${inboundgate.reason}`, {}).catch(() => {
+    });
+    throw new Error(inboundgate.reason);
+  }
+  if (sender.id === chrome.runtime.id && !extensionpage(sender)) throw new Error("Requests are accepted only from Devthink extension pages.");
+  const schemaerrors = schemavalidation(message);
+  const schemagate = schemaguardgate({ errors: schemaerrors });
+  if (!schemagate.allowed) {
+    await audit("schema", `The schemastrict validation refused an inbound command with ${schemaerrors.length} schema error${schemaerrors.length === 1 ? "" : "s"} at ${schemaerrors.map((error) => error.path).join(", ")}; the refusal echoes no payload.`, {}).catch(() => {
+    });
+    throw new Error(schemagate.reason);
+  }
   const input = message;
   switch (input.kind) {
     case "configure": {
@@ -19997,7 +21506,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(), 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();
@@ -20026,7 +21535,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":
@@ -22383,6 +23897,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();
     }
@@ -23048,6 +24570,14 @@ async function handlerequest(message, sender) {
       }
       throw new Error("The swarm merge request carries no merge, report, export, compare, lesson, costs, timeline, replay or snapshot action.");
     }
+    case "transparency": {
+      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) });
+      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 "security": {
       const input2 = message;
       const now = Date.now();
@@ -23078,6 +24608,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 };
       }
@@ -23092,6 +24624,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 });
@@ -23108,6 +24642,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 });
@@ -23136,6 +24672,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(() => {
@@ -23185,10 +24723,103 @@ async function handlerequest(message, sender) {
         }
         if (input2.settings.logretention !== void 0) patch.logretention = input2.settings.logretention;
         if (input2.settings.maskshapes !== void 0) patch.maskshapes = input2.settings.maskshapes.map((shape) => shape.trim().toLowerCase()).filter((shape) => shape !== "");
+        if (input2.settings.phishdistance !== void 0) {
+          const thresholdgate = phishthresholdgate(input2.settings.phishdistance);
+          if (!thresholdgate.allowed) throw new Error(thresholdgate.reason);
+          patch.phishdistance = input2.settings.phishdistance;
+        }
+        if (input2.settings.phishfreshness !== void 0) patch.phishfreshness = input2.settings.phishfreshness;
         await memory.setsettings(patch);
         await audit("configure", `The user updated the security settings: consent duration ${patch.consentduration !== void 0 ? `${patch.consentduration} milliseconds` : "the prompt asks every time"}, log retention ${patch.logretention !== void 0 ? `${patch.logretention} milliseconds` : "every sealed log stays"}, mask shapes ${patch.maskshapes?.length ?? 0} configured.`, {});
         return { ...await securityviewof(), configured: true };
       }
+      if (input2.gate !== void 0 && input2.gate.resolve !== void 0) {
+        const gateid = input2.gate.resolve.gateid?.trim() ?? "";
+        const decision = input2.gate.resolve.decision === "refused" ? "refused" : "resolved";
+        if (gateid === "") throw new Error("The gate resolution names its single gate.");
+        const resolved = resolvegate({ gates: await memory.getgates(), gateid, decision, actor: "user", now });
+        if (resolved.resolution === void 0 || resolved.gates === void 0) throw new Error(`No open gate ${gateid} exists to resolve; a gate resolution stays a distinct human action on one gate.`);
+        await memory.setgates(resolved.gates);
+        await memory.addgateresolution(resolved.resolution);
+        const gateplan = await memory.getplan();
+        const gate = resolved.gates.find((candidate) => candidate.gateid === gateid);
+        if (gateplan && gate?.resolvedat !== void 0) await memory.setprogress(recordgatewait(await memory.getprogress(), gateplan.id, gate.stepid, { gateid: gate.gateid, kind: gate.kind, openedat: gate.openedat, resolvedat: gate.resolvedat, waitedms: Math.max(0, gate.resolvedat - gate.openedat) }, now)).catch(() => {
+        });
+        if (session) await appendrunevent("gate", `The user ${decision === "resolved" ? "resolved" : "refused"} the ${resolved.resolution.kind} gate ${gateid} of the step ${resolved.resolution.stepid} through one distinct human action; no timeout resolved it and no batch approved it.`, session, gate?.origin ?? session.origin, resolved.resolution.stepid).catch(() => {
+        });
+        await audit("gate", `The user ${decision === "resolved" ? "resolved" : "refused"} the ${resolved.resolution.kind} gate ${gateid} of the step ${resolved.resolution.stepid} through one distinct human action; no timeout resolved it and no batch approved it.`, { ...session ? { sessionid: session.id } : {}, ...gateplan ? { planid: gateplan.id } : {}, stepid: resolved.resolution.stepid });
+        return { ...await securityviewof(), gate };
+      }
+      if (input2.vault !== void 0) {
+        if (input2.vault.add !== void 0) {
+          const label = input2.vault.add.label?.trim() ?? "";
+          const scope = input2.vault.add.scope?.trim() !== "" && input2.vault.add.scope !== void 0 ? input2.vault.add.scope.trim() : session?.origin ?? "";
+          const value = input2.vault.add.value ?? "";
+          if (label === "" || scope === "" || value === "") throw new Error("The vault entry needs its label, its exact origin scope and its value; the value stays behind the vault seam.");
+          const entry = await vaultstore({ seam: vaultseamstore, label, scope, profileid: runstateprofile, provenance: input2.vault.add.provenance === "session" ? "session" : "user", value, now });
+          await memory.addsecret(entry);
+          await audit("vault", `The user stored the secret ${entry.label} for ${entry.scope} behind the vault seam; the metadata keeps the label, the scope, the provenance and the digest while no plaintext value persists anywhere.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), secret: { vaultid: entry.vaultid, label: entry.label, scope: entry.scope } };
+        }
+        if (input2.vault.delete !== void 0) {
+          const vaultid = input2.vault.delete.vaultid?.trim() ?? "";
+          const entry = (await memory.getsecretvault()).find((candidate) => candidate.vaultid === vaultid);
+          if (!entry) throw new Error(`No vault entry ${vaultid} exists.`);
+          const dropped = await vaultdelete({ seam: vaultseamstore, entry });
+          await memory.removesecret(vaultid);
+          await audit("vault", `The user deleted the secret ${dropped.label} of ${entry.scope}: ${dropped.reason}`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removedsecret: vaultid };
+        }
+      }
+      if (input2.connectallow !== void 0) {
+        if (input2.connectallow.add !== void 0) {
+          const entry = connectallowentryof({ senderid: input2.connectallow.add.senderid?.trim() ?? "", displayname: input2.connectallow.add.displayname?.trim() ?? "", ...input2.connectallow.add.origin !== void 0 && input2.connectallow.add.origin.trim() !== "" ? { origin: input2.connectallow.add.origin.trim() } : {}, now });
+          await memory.addconnectallow(entry);
+          await audit("inbound", `The user allowed the external sender ${entry.displayname} (${entry.senderid})${entry.origin !== void 0 ? ` of ${entry.origin}` : ""}; the connectallow list ships empty by default and holds user managed entries only.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), allowedsender: entry };
+        }
+        if (input2.connectallow.remove !== void 0) {
+          const senderid = input2.connectallow.remove.senderid?.trim() ?? "";
+          await memory.removeconnectallow(senderid);
+          await audit("inbound", `The user removed the external sender ${senderid} from the connectallow list; the origincheck drops its messages and ports again.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removedsender: senderid };
+        }
+      }
+      if (input2.ratelimit !== void 0) {
+        if (input2.ratelimit.set !== void 0) {
+          const origin = input2.ratelimit.set.origin?.trim() ?? "";
+          const limit = input2.ratelimit.set.limit ?? 0;
+          const window2 = input2.ratelimit.set.window ?? 0;
+          if (origin === "") throw new Error("The ratelimit bucket needs its exact origin.");
+          const bounds = ratelimitboundsvalid(limit, window2);
+          if (!bounds.allowed) throw new Error(bounds.reason);
+          const bucket = bucketof({ origin, sessionid: session?.id ?? "global", limit, window: window2, now });
+          await memory.saveratelimitbucket(bucket);
+          await audit("rate", `The user configured the ratelimit bucket of ${origin} at ${limit} command${limit === 1 ? "" : "s"} per ${window2} milliseconds; the bounds stay user choices with no hidden ceiling.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), bucket };
+        }
+        if (input2.ratelimit.remove !== void 0) {
+          const origin = input2.ratelimit.remove.origin?.trim() ?? "";
+          const buckets = await memory.getratelimitbuckets();
+          for (const bucket of buckets.filter((candidate) => candidate.origin === origin)) await memory.removeratelimitbucket(bucket.origin, bucket.sessionid);
+          await audit("rate", `The user removed the ratelimit bucket of ${origin}; the origin runs without a bucket because the bounds stay user choices only.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removedbucket: origin };
+        }
+      }
+      if (input2.redact !== void 0) {
+        if (input2.redact.add !== void 0) {
+          const region = regionof({ origin: input2.redact.add.origin?.trim() !== "" && input2.redact.add.origin !== void 0 ? input2.redact.add.origin.trim() : session?.origin ?? "", template: input2.redact.add.template?.trim() !== "" && input2.redact.add.template !== void 0 ? input2.redact.add.template.trim() : "page", x: input2.redact.add.x ?? 0, y: input2.redact.add.y ?? 0, width: input2.redact.add.width ?? 0, height: input2.redact.add.height ?? 0, reason: input2.redact.add.reason?.trim() !== "" && input2.redact.add.reason !== void 0 ? input2.redact.add.reason.trim() : "The user drew the mask on the capture surface.", source: "userdrawn", now });
+          await memory.addredactregion(region);
+          await audit("capture", `The user drew the redact region ${region.id} at ${region.x},${region.y} of ${region.width}x${region.height} on ${region.origin}/${region.template}: ${region.reason}`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), region };
+        }
+        if (input2.redact.remove !== void 0) {
+          const id = input2.redact.remove.id?.trim() ?? "";
+          await memory.removeredactregion(id);
+          await audit("capture", `The user removed the redact region ${id}.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removedregion: id };
+        }
+      }
       const plan = await memory.getplan();
       const pending = [];
       if (session && plan && ["pending", "approved"].includes(plan.state)) {
@@ -23646,7 +25277,7 @@ async function raiseremoteapproval(clientid, toolname, params, step) {
   return { content: `The approval gate ${request.id} holds the ${toolname} call; it executes once the user approves it in the panel.`, payload: { approvalid: request.id, state: "pending", ...request.timeoutat !== void 0 ? { timeoutat: request.timeoutat } : {} }, iserror: false };
 }
 async function executelistruns(step, session) {
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const statefilter = typeof options.state === "string" && options.state.trim() !== "" ? options.state : void 0;
   const runs = await memory.listworkflowruns();
   const selected = statefilter !== void 0 ? runs.filter((run) => run.state === statefilter) : runs;
@@ -24021,7 +25652,7 @@ async function maybeautosnapshot() {
     await audit("session", `The reviewed auto snapshot interval stopped after ${state.interval.maxsnapshots} snapshot${state.interval.maxsnapshots === 1 ? "" : "s"}; the retention window of ${state.interval.expiry} millisecond${state.interval.expiry === 1 ? "" : "s"} expires them by user choice.`, { sessionid: session.id, planid: plan.id });
     return;
   }
-  const options = stepoptions3(step);
+  const options = stepoptions6(step);
   const snapshot2 = snapshotplanof(options.snapshot);
   if (!snapshot2) return;
   const record2 = await capturesessionrecord({ ...snapshot2, ...snapshot2.auto !== void 0 ? { auto: snapshot2.auto } : {} }, session, plan.id).catch(() => void 0);
@@ -24066,10 +25697,22 @@ async function restoreemulationstate() {
 restoreemulationstate().catch(() => {
 });
 chrome.runtime.onConnect.addListener((port) => {
-  if (port.name !== "devthinksidepanel" || port.sender?.id !== chrome.runtime.id || !port.sender.url?.startsWith(chrome.runtime.getURL(""))) return port.disconnect();
-  port.onMessage.addListener((message) => {
-    handlerequest(message, port.sender ?? {}).then((value) => port.postMessage({ ok: true, value })).catch((error) => port.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) }));
-  });
+  void (async () => {
+    const handshake = portaccept({ portname: port.name, ...port.sender?.id !== void 0 ? { senderid: port.sender.id } : {}, ...port.sender?.origin !== void 0 ? { senderorigin: port.sender.origin } : {}, extensionid: chrome.runtime.id, connectallow: await memory.getconnectallow() });
+    if (!handshake.accepted) {
+      await audit("inbound", `The port ${port.name} closed at its handshake: ${handshake.reason}`, {}).catch(() => {
+      });
+      port.disconnect();
+      return;
+    }
+    if (port.name !== "devthinksidepanel" || port.sender?.id !== chrome.runtime.id || !port.sender.url?.startsWith(chrome.runtime.getURL(""))) {
+      port.disconnect();
+      return;
+    }
+    port.onMessage.addListener((message) => {
+      handlerequest(message, port.sender ?? {}).then((value) => port.postMessage({ ok: true, value })).catch((error) => port.postMessage({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+    });
+  })();
 });
 {
   const webnavigation = chrome.webNavigation;
@@ -24155,4 +25798,16 @@ restoretriggers().catch(() => {
 });
 restorerunstates().catch(() => {
 });
+async function recordinstalledpermdiff() {
+  const manifest = chrome.runtime.getManifest();
+  const permissions = [...(manifest.permissions ?? []).map((permission) => `required:${permission}`), ...(manifest.optional_permissions ?? []).map((permission) => `optional:${permission}`), ...(manifest.optional_host_permissions ?? []).map((host) => `optionalhost:${host}`)];
+  const last = await memory.getlastpermissions();
+  if (last !== void 0 && last.version === manifest.version) return;
+  const diff = permissiondiff({ from: last?.permissions ?? [], to: permissions, fromversion: last?.version ?? "none", toversion: manifest.version, now: Date.now() });
+  await memory.addpermdiff(diff);
+  await memory.setlastpermissions(permissions, manifest.version);
+  await audit("transparency", `The installed update to ${manifest.version} recorded its permdiff: ${permdiffsummary(diff)}`, {});
+}
+recordinstalledpermdiff().catch(() => {
+});
 //# sourceMappingURL=background.js.map