@wenathlan/extension 1.1.59 → 1.1.61

package/extension/dist/background.js

@@ -1914,6 +1914,237 @@ function swarmoverview(input) {
   };
 }
 
+// runstate.ts
+function openrun(input) {
+  if (input.runid.trim() === "" || input.sessionid.trim() === "") throw new Error("The run state needs its run and session ids.");
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The keepalive heartbeat interval stays a positive user value in milliseconds.");
+  return {
+    runid: input.runid,
+    sessionid: input.sessionid,
+    planid: input.planid,
+    profileid: input.profileid,
+    state: "active",
+    urlhistory: [],
+    environments: {},
+    turnarounds: {},
+    keepalive: { runid: input.runid, sessionid: input.sessionid, state: "active", startedat: input.now, interval: input.interval, beats: 0, lastbeatat: input.now, portopen: true, events: [{ kind: "start", at: input.now, detail: `The keepalive port opens for the run ${input.runid} and beats every ${input.interval} milliseconds.` }] },
+    updatedat: input.now
+  };
+}
+function beatrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run emits no heartbeat.`);
+  return {
+    ...state,
+    keepalive: { ...state.keepalive, beats: state.keepalive.beats + 1, lastbeatat: now, events: [...state.keepalive.events, { kind: "heartbeat", at: now }].slice(-200) },
+    updatedat: now
+  };
+}
+function closerun(state, now) {
+  if (state.keepalive.state === "stopped") throw new Error(`The run ${state.runid} already stopped its keepalive port.`);
+  return {
+    ...state,
+    state: "completed",
+    keepalive: { ...state.keepalive, state: "stopped", stoppedat: now, portopen: false, events: [...state.keepalive.events, { kind: "stop", at: now, detail: "The run reached a terminal state and the keepalive port closed." }].slice(-200) },
+    updatedat: now
+  };
+}
+function reattachrun(state, now) {
+  if (state.keepalive.state !== "active") throw new Error(`The run ${state.runid} is ${state.keepalive.state}; a stopped run never reattaches.`);
+  return {
+    ...state,
+    state: "recovered",
+    keepalive: { ...state.keepalive, portopen: true, events: [...state.keepalive.events, { kind: "reattach", at: now, detail: "The service worker restarted and the keepalive port reattached from the persisted run state." }].slice(-200) },
+    updatedat: now
+  };
+}
+function recordurl(state, entry) {
+  if (entry.url.trim() === "") throw new Error("The url history entry needs its url.");
+  const record2 = { url: entry.url, stepid: entry.stepid, at: entry.now };
+  return { ...state, urlhistory: [...state.urlhistory.filter((item) => !(item.url === record2.url && item.stepid === record2.stepid)), record2], updatedat: entry.now };
+}
+function recordenvironment(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The environment record needs its step id.");
+  const provenance = { origin: input.origin, stepid: input.stepid, environment: input.environment };
+  return { ...state, environments: { ...state.environments, [input.stepid]: input.environment }, lastprovenance: provenance, updatedat: input.now };
+}
+function recordturnaround(state, input) {
+  if (input.stepid.trim() === "") throw new Error("The turnaround record needs its step id.");
+  if (!Number.isFinite(input.milliseconds) || input.milliseconds < 0) throw new Error("The worker turnaround stays a non-negative duration in milliseconds.");
+  return { ...state, turnarounds: { ...state.turnarounds, [input.stepid]: input.milliseconds }, updatedat: input.now };
+}
+function markpending(state, stepid, now) {
+  return { ...state, ...stepid !== void 0 && stepid.trim() !== "" ? { pendingstepid: stepid } : {}, updatedat: now };
+}
+function recoveryplan(state) {
+  if (state.state === "completed") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} completed before the restart; nothing resumes.` };
+  if (state.state === "reaped") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} was reaped as a zombie; the user starts a fresh reviewed run.` };
+  if (state.pendingstepid === void 0 || state.pendingstepid.trim() === "") return { runid: state.runid, recoverable: false, reason: `The run ${state.runid} carries no pending step; a fresh reviewed run starts over instead of guessing.` };
+  return { runid: state.runid, pendingstepid: state.pendingstepid, recoverable: true, reason: `The executor resumes the pending step ${state.pendingstepid} of the run ${state.runid} from the persisted run state.` };
+}
+function zombiesweep(input) {
+  if (!Number.isFinite(input.interval) || input.interval <= 0) throw new Error("The zombie sweep needs its heartbeat interval as a positive user value.");
+  if (!Number.isInteger(input.missedlimit) || input.missedlimit < 1) throw new Error("The zombie tolerance stays a positive whole number of silent intervals.");
+  const silentfor = input.interval * input.missedlimit;
+  const zombies = input.states.filter((state) => state.keepalive.state === "active" && input.now - state.keepalive.lastbeatat > silentfor);
+  if (zombies.length === 0) return { states: input.states, reaped: [] };
+  const ids = new Set(zombies.map((state) => state.runid));
+  return { states: input.states.map((state) => ids.has(state.runid) ? { ...state, state: "reaped", keepalive: { ...state.keepalive, state: "stopped", portopen: false, ...state.keepalive.stoppedat === void 0 ? { stoppedat: input.now } : {}, events: [...state.keepalive.events, { kind: "stop", at: input.now, detail: "The zombie reaper closed the silent run." }] } } : state), reaped: [...ids] };
+}
+function acquirerunlock(input) {
+  if (input.sessionid.trim() === "" || input.runid.trim() === "") throw new Error("The run lock needs its session and run ids.");
+  const live = input.locks.filter((lock2) => lock2.sessionid === input.sessionid && (lock2.expiresat === void 0 || lock2.expiresat > input.now));
+  const held = live.find((lock2) => lock2.runid !== input.runid);
+  if (held) return { locks: input.locks, acquired: false, reason: `The session ${input.sessionid} already holds the run ${held.runid}; a session never carries two concurrent runs.` };
+  const own = input.locks.find((lock2) => lock2.sessionid === input.sessionid && lock2.runid === input.runid);
+  if (own) return { locks: input.locks, acquired: true, reason: `The run ${input.runid} of the session ${input.sessionid} already holds its lock.` };
+  const lock = { sessionid: input.sessionid, runid: input.runid, holder: input.holder, acquiredat: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+  return { locks: [...input.locks.filter((entry) => entry.sessionid !== input.sessionid), lock], acquired: true, reason: `The run ${input.runid} locked the session ${input.sessionid} against concurrent runs.` };
+}
+function releaserunlock(input) {
+  const lock = input.locks.find((entry) => entry.sessionid === input.sessionid);
+  if (!lock || lock.runid !== input.runid) return { locks: input.locks, released: false, reason: `The run ${input.runid} holds no lock of the session ${input.sessionid}.` };
+  return { locks: input.locks.filter((entry) => entry.sessionid !== input.sessionid), released: true, reason: `The run ${input.runid} released the run lock of the session ${input.sessionid}.` };
+}
+function expirerunlocks(locks, now) {
+  const expired = locks.filter((lock) => lock.expiresat !== void 0 && now > lock.expiresat);
+  if (expired.length === 0) return { locks, expired: [] };
+  const ids = new Set(expired.map((lock) => lock.sessionid));
+  return { locks: locks.filter((lock) => !ids.has(lock.sessionid)), expired: [...ids] };
+}
+function serializesteps(input) {
+  const shared = /* @__PURE__ */ new Set();
+  const counts = /* @__PURE__ */ new Map();
+  for (const branch of input.branches) for (const step of branch.steps) counts.set(step.tabid, (counts.get(step.tabid) ?? 0) + 1);
+  for (const [tabid2, count] of counts) if (count > 1) shared.add(tabid2);
+  const order = [];
+  let cursor = 0;
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  for (const branch of input.branches) {
+    for (const step of branch.steps) {
+      if (!shared.has(step.tabid)) {
+        order.push({ branchid: branch.branchid, stepid: step.stepid, tabid: step.tabid, order: cursor });
+        cursor += 1;
+      }
+    }
+  }
+  return order;
+}
+async function sealrunstate(state) {
+  const payload = JSON.stringify(state);
+  const digest = await sha256(payload);
+  return { payload, algorithm: "sha-256", digest, sealedat: state.updatedat };
+}
+async function openseal(sealed) {
+  const digest = await sha256(sealed.payload);
+  if (digest !== sealed.digest) throw new Error("The sealed run state fails its integrity digest; a tampered run state never reaches the recovery.");
+  const parsed = JSON.parse(sealed.payload);
+  if (typeof parsed.runid !== "string" || typeof parsed.sessionid !== "string") throw new Error("The sealed run state carries no run record.");
+  return parsed;
+}
+async function sha256(value) {
+  const bytes = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function prunerunstates(input) {
+  if (!Number.isFinite(input.ceiling) || input.ceiling <= 0) return { states: input.states, pruned: [], reason: "No storage ceiling is configured, so the run states stay under the user choice alone." };
+  if (input.used <= input.ceiling) return { states: input.states, pruned: [], reason: `The run state storage sits at ${input.used} of the ${input.ceiling} bytes the user configured; no pressure exists.` };
+  const removable = input.states.filter((state) => state.state === "completed" || state.state === "reaped").sort((one, two) => one.updatedat - two.updatedat);
+  const states = [...input.states];
+  const pruned = [];
+  for (const candidate of removable) {
+    pruned.push(candidate.runid);
+    const index = states.findIndex((state) => state.runid === candidate.runid);
+    if (index >= 0) states.splice(index, 1);
+    if (pruned.length >= Math.max(1, Math.ceil(input.states.length / 2))) break;
+  }
+  return { states, pruned, reason: `The storage pressure at ${input.used} of ${input.ceiling} bytes pruned the ${pruned.length} oldest finished run state${pruned.length === 1 ? "" : "s"} while every active run keeps its state.` };
+}
+function exportrunstate(states, now) {
+  return {
+    runs: states.length,
+    urls: states.reduce((total, state) => total + state.urlhistory.length, 0),
+    environments: states.reduce((total, state) => total + Object.keys(state.environments).length, 0),
+    offloaded: states.reduce((total, state) => total + Object.values(state.turnarounds).length, 0),
+    beats: states.reduce((total, state) => total + state.keepalive.beats, 0),
+    exportedat: now
+  };
+}
+
+// immutablelog.ts
+async function sha2562(payload) {
+  const bytes = new TextEncoder().encode(payload);
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function entrybody(entry) {
+  return JSON.stringify({ id: entry.id, runid: entry.runid, kind: entry.kind, summary: entry.summary, origin: entry.origin, ...entry.stepid !== void 0 ? { stepid: entry.stepid } : {}, at: entry.at });
+}
+async function entryhashof(input) {
+  return { previous: input.previous, current: await sha2562(`${input.previous}
+${entrybody(input.entry)}`), algorithm: "sha-256" };
+}
+async function logentryof(input) {
+  if (input.summary.trim() === "") throw new Error("The log entry needs its summary in plain language.");
+  if (input.origin.trim() === "") throw new Error("The log entry needs its origin provenance.");
+  const entry = { id: input.id ?? randomid(), runid: input.runid, kind: input.kind, summary: input.summary, origin: input.origin, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, at: input.at };
+  return { ...entry, hash: await entryhashof({ previous: input.previous, entry }) };
+}
+function openrunlog(input) {
+  if (input.runid.trim() === "" || input.sessionid.trim() === "") throw new Error("The run log needs its run and session ids.");
+  return { runid: input.runid, sessionid: input.sessionid, entries: [], updatedat: input.now };
+}
+function lasthashof(log) {
+  const entry = log.entries[log.entries.length - 1];
+  return entry === void 0 ? "0".repeat(64) : entry.hash.current;
+}
+async function appendlogentry(input) {
+  if (input.log.seal !== void 0) throw new Error(`The run log of ${input.log.runid} sealed at ${input.log.seal.sealedat} and accepts no append; the seal is terminal.`);
+  const entry = await logentryof({ ...input.id !== void 0 ? { id: input.id } : {}, runid: input.log.runid, kind: input.kind, summary: input.summary, origin: input.origin, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, at: input.at, previous: lasthashof(input.log) });
+  return { ...input.log, entries: [...input.log.entries, entry], updatedat: input.at };
+}
+async function sealrunlog(log, now) {
+  if (log.seal !== void 0) throw new Error(`The run log of ${log.runid} already sealed at ${log.seal.sealedat}; the seal is terminal.`);
+  if (log.entries.length === 0) throw new Error("The run log seals at completion with at least one entry.");
+  const sealhash = await entryhashof({ previous: lasthashof(log), entry: { id: `seal:${log.runid}`, runid: log.runid, kind: "seal", summary: `The run ${log.runid} completed and the log sealed with ${log.entries.length} entries.`, origin: log.entries[log.entries.length - 1]?.origin ?? log.runid, at: now } });
+  const seal = { runid: log.runid, entries: log.entries.length, sealhash, sealedat: now };
+  return { log: { ...log, seal, updatedat: now }, seal };
+}
+async function verifylogchain(entries) {
+  let previous = "0".repeat(64);
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (entry === void 0) continue;
+    if (entry.hash.previous !== previous) return { valid: false, brokenat: index, reason: `The chain link of entry ${index} carries the previous hash ${entry.hash.previous} while its predecessor hashes to ${previous}; the chain reports tamper evidence.` };
+    const expected = await entryhashof({ previous, entry: { id: entry.id, runid: entry.runid, kind: entry.kind, summary: entry.summary, origin: entry.origin, ...entry.stepid !== void 0 ? { stepid: entry.stepid } : {}, at: entry.at } });
+    if (entry.hash.current !== expected.current) return { valid: false, brokenat: index, reason: `The entry hash of entry ${index} matches neither its body nor its predecessor hash; the chain reports tamper evidence.` };
+    previous = entry.hash.current;
+  }
+  return { valid: true, reason: `The hash chain of ${entries.length} entr${entries.length === 1 ? "y" : "ies"} verifies from the genesis hash to the last entry.` };
+}
+async function readverifiedlog(log) {
+  const verification = await verifylogchain(log.entries);
+  if (!verification.valid) return { ok: false, entries: [], reason: verification.reason };
+  return { ok: true, entries: [...log.entries], reason: verification.reason };
+}
+async function chainreportof(log) {
+  const verification = await verifylogchain(log.entries);
+  if (!verification.valid) return { runid: log.runid, valid: false, entries: log.entries.length, ...verification.brokenat !== void 0 ? { brokenat: verification.brokenat } : {}, reason: verification.reason };
+  return { runid: log.runid, valid: true, entries: log.entries.length, reason: verification.reason, ...log.seal !== void 0 ? { sealhash: log.seal.sealhash.current, sealedat: log.seal.sealedat } : {} };
+}
+async function exportlogchain(log) {
+  const read = await readverifiedlog(log);
+  if (!read.ok) return { runid: log.runid, entries: 0, chainvalid: false, reason: read.reason, log: [] };
+  return { runid: log.runid, entries: read.entries.length, chainvalid: true, reason: read.reason, ...log.seal !== void 0 ? { sealhash: log.seal.sealhash.current, sealedat: log.seal.sealedat } : {}, log: read.entries };
+}
+
 // memory.ts
 var sessionmemory = class {
   constructor(adapter) {
@@ -4258,6 +4489,254 @@ var sessionmemory = class {
   async getswarmcosts() {
     return await this.adapter.get("swarmcosts") ?? [];
   }
+  /**
+   * Execution environment persistence of the 1.1.60 family.
+   * The run state store seals every persisted run state with its sha-256 integrity digest through the storage api (the browser offers no at-rest encryption for its storage areas, so the honest derivation is the integrity seal that makes tampering detectable before any recovery uses the record), scopes every run state per profile so parallel profiles never share it, expires stale run state past the user configured window while the keepalive summaries survive, tracks the storage quota usage of the run state and prunes the oldest finished run states under pressure.
+   * The adapter seam keeps every accessor a one line storage delegation so a future worker state backend replaces the adapter only.
+   */
+  /** Returns the environment grant list of the active session; an absent list keeps the documented default posture. */
+  async getenvironmentgrants() {
+    return (await this.getsession())?.environmentgrants;
+  }
+  /** Replaces the environment grant list of the active session so the environment grants join the origin grants in the session record. */
+  async setenvironmentgrants(grants) {
+    const session = await this.getsession();
+    if (!session) throw new Error("The environment grants need an active session to join.");
+    await this.setsession({ ...session, environmentgrants: grants });
+  }
+  /** Seals and stores the run state of one profile: the payload travels beside its sha-256 digest so a tampered record at rest stays detectable before any recovery uses it. */
+  async setrunstate(profileid, state) {
+    const sealed = await sealrunstate(state);
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set(`runstate:${profileid}`, sealed);
+    if (!index.includes(profileid)) await this.adapter.set("runstateindex", [...index, profileid]);
+  }
+  /** Opens the sealed run state of one profile; a missing or tampered seal returns undefined so the recovery never trusts a broken record. */
+  async getrunstate(profileid) {
+    const sealed = await this.adapter.get(`runstate:${profileid}`);
+    if (!sealed) return void 0;
+    try {
+      return await openseal(sealed);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Removes the run state of one profile from the store and the index: the per profile key takes an empty seal that never opens, so the quota pruning drops the pruned records whole. */
+  async removerunstate(profileid) {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    await this.adapter.set("runstateindex", index.filter((entry) => entry !== profileid));
+    await this.adapter.set(`runstate:${profileid}`, { payload: "", algorithm: "sha-256", digest: "", sealedat: 0 });
+  }
+  /** Lists the stored run state records of every profile, oldest update first. */
+  async listrunstates() {
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const states = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (state) states.push(state);
+    }
+    return states.sort((one, two) => one.updatedat - two.updatedat);
+  }
+  /** Expires the stale run states past the user configured window: the expired records reduce to their keepalive summaries while an absent window keeps every run state whole. */
+  async expirerunstates(window2, now) {
+    if (window2 === void 0) return await this.listrunstates();
+    const index = await this.adapter.get("runstateindex") ?? [];
+    const kept = [];
+    for (const profileid of index) {
+      const state = await this.getrunstate(profileid);
+      if (!state) continue;
+      if (now - state.updatedat > window2 && state.keepalive.state === "stopped") {
+        const summary = { runid: state.runid, sessionid: state.sessionid, planid: state.planid, profileid: state.profileid, state: "expired", urlhistory: [], environments: {}, turnarounds: {}, keepalive: state.keepalive, updatedat: now };
+        const sealed = await sealrunstate(summary);
+        await this.adapter.set(`runstate:${profileid}`, sealed);
+      } else {
+        kept.push(state);
+      }
+    }
+    return kept;
+  }
+  /** Records one worker spawn or teardown event with its provenance beside the step outcomes. */
+  async addworkerevent(event) {
+    await this.adapter.set("workerevents", [event, ...await this.adapter.get("workerevents") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded worker spawn and teardown events, newest first. */
+  async getworkerevents() {
+    return await this.adapter.get("workerevents") ?? [];
+  }
+  /** Records one spawned offscreen document with its reasons and justification in the registry. */
+  async addoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", [entry, ...await this.adapter.get("offscreenregistry") ?? []]);
+  }
+  /** Replaces one registry entry after its offscreen document closes. */
+  async updateoffscreenentry(entry) {
+    await this.adapter.set("offscreenregistry", (await this.adapter.get("offscreenregistry") ?? []).map((candidate) => candidate.runid === entry.runid ? entry : candidate));
+  }
+  /** Returns the offscreen document registry with the reasons and justification of every spawn. */
+  async getoffscreenentries() {
+    return await this.adapter.get("offscreenregistry") ?? [];
+  }
+  /** Records one sandbox render with its provenance, source origin and nonce. */
+  async addsandboxrender(render) {
+    await this.adapter.set("sandboxrenders", [render, ...await this.adapter.get("sandboxrenders") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded sandbox renders with their provenance, newest first. */
+  async getsandboxrenders() {
+    return await this.adapter.get("sandboxrenders") ?? [];
+  }
+  /** Replaces the stored run locks after one acquisition, release or expiry sweep. */
+  async setrunlocks(locks) {
+    return this.adapter.set("runlocks", locks);
+  }
+  /** Returns the held run locks with their sessions, runs and expiries. */
+  async getrunlocks() {
+    return await this.adapter.get("runlocks") ?? [];
+  }
+  /** Tracks the storage quota usage of the run state: the last measured bytes stay beside the user configured ceiling so the pruning reads both. */
+  async trackrunstatequota(used) {
+    const settings = await this.getsettings();
+    await this.adapter.set("runstatequota", { used, ...settings?.runstatebytes !== void 0 ? { ceiling: settings.runstatebytes } : {}, trackedat: Date.now() });
+  }
+  /** Returns the last tracked storage quota usage of the run state with its ceiling when the user configured one. */
+  async getrunstatequota() {
+    return this.adapter.get("runstatequota");
+  }
+  /** Exports every stored run state as one single audit record through the runstate export envelope. */
+  async exportrunstates() {
+    return exportrunstate(await this.listrunstates(), Date.now());
+  }
+  /**
+   * Security part one persistence of the 1.1.61 family.
+   * The trust boundary records live here: the per origin automation allowlist scoped per profile workspace with one exact origin per entry, the per site originprofiles with their kind grants and denials, the active consentwindows with their expiry timestamps that expire closed past their boundary, the mid run revokerun events with the halted step ids that stay visible for later consent prompts, the fresh class consents per origin, the mask rules for field shapes per origin, and the sealed immutable run logs with their final hash.
+   * The run log store exposes no update or delete path: appends land whole, the seal closes a log with its final hash and the read path verifies the chain before returning a single entry so a broken link refuses the read.
+   * The adapter seam keeps every accessor a one line storage delegation so a future append only backend replaces the adapter only; the current storage areas offer no append only hardware, so the honest derivation is the hash chain that makes any rewrite detectable at read time.
+   */
+  /** Replaces the per origin automation allowlist of the profile workspaces; every entry carries one exact origin with no wildcard expansion. */
+  async setautomationallowlist(entries) {
+    return this.adapter.set("automationallowlist", entries);
+  }
+  /** Returns the per origin automation allowlist entries, oldest grant first. */
+  async getautomationallowlist() {
+    return await this.adapter.get("automationallowlist") ?? [];
+  }
+  /** Adds one exact origin to the automation allowlist of a profile workspace; a duplicate origin keeps its first grant. */
+  async addallowlistorigin(entry) {
+    const entries = await this.getautomationallowlist();
+    if (entries.some((candidate) => candidate.origin === entry.origin && candidate.profileid === entry.profileid)) return;
+    await this.setautomationallowlist([...entries, entry]);
+  }
+  /** Removes one origin from the automation allowlist; the denydefault posture refuses the origin again after the removal. */
+  async removeallowlistorigin(origin, profileid) {
+    await this.setautomationallowlist((await this.getautomationallowlist()).filter((entry) => !(entry.origin === origin && entry.profileid === profileid)));
+  }
+  /** Replaces the per site origin profiles with their kind grants and denials; one profile per origin. */
+  async setoriginprofiles(profiles) {
+    return this.adapter.set("originprofiles", profiles);
+  }
+  /** Returns the stored per site origin profiles, oldest update first. */
+  async getoriginprofiles() {
+    return await this.adapter.get("originprofiles") ?? [];
+  }
+  /** Upserts one origin profile: a profile of the same origin replaces its grants and denials while a new origin joins the list. */
+  async saveoriginprofile(profile) {
+    const profiles = await this.getoriginprofiles();
+    await this.setoriginprofiles(profiles.some((candidate) => candidate.origin === profile.origin) ? profiles.map((candidate) => candidate.origin === profile.origin ? profile : candidate) : [...profiles, profile]);
+  }
+  /** Replaces the consent windows; active windows keep their expiry timestamps and closed windows stay for the audit trail. */
+  async setconsentwindows(windows) {
+    return this.adapter.set("consentwindows", windows);
+  }
+  /** Returns the stored consent windows, newest start first. */
+  async getconsentwindows() {
+    return await this.adapter.get("consentwindows") ?? [];
+  }
+  /** Expires every consent window past its duration boundary: the closed windows keep their records while their grants bind no step anymore. */
+  async expireconsentwindows(now) {
+    const windows = await this.getconsentwindows();
+    const expired = windows.map((window2) => window2.state === "active" && now >= window2.expiresat ? { ...window2, state: "closed", closedat: now } : window2);
+    await this.setconsentwindows(expired);
+    return expired;
+  }
+  /** Records one mid run revocation with its halted step ids; the history stays visible for later consent prompts. */
+  async addrevocation(event) {
+    await this.adapter.set("revocations", [event, ...await this.adapter.get("revocations") ?? []].slice(0, 500));
+  }
+  /** Returns the recorded mid run revocations with their halted step ids, newest first. */
+  async getrevocations() {
+    return await this.adapter.get("revocations") ?? [];
+  }
+  /** Replaces the fresh class consents per origin. */
+  async setclassconsents(consents) {
+    return this.adapter.set("classconsents", consents);
+  }
+  /** Returns the fresh class consents per origin, newest grant first. */
+  async getclassconsents() {
+    return await this.adapter.get("classconsents") ?? [];
+  }
+  /** Records one fresh class consent per origin; the prompt of one class never widens another class. */
+  async addclassconsent(consent) {
+    const consents = (await this.getclassconsents()).filter((candidate) => !(candidate.origin === consent.origin && candidate.sensitiveclass === consent.sensitiveclass));
+    await this.setclassconsents([consent, ...consents]);
+  }
+  /** Replaces the mask rules for sensitive field shapes per origin. */
+  async setmaskrules(rules) {
+    return this.adapter.set("maskrules", rules);
+  }
+  /** Returns the stored mask rules for sensitive field shapes per origin, oldest rule first. */
+  async getmaskrules() {
+    return await this.adapter.get("maskrules") ?? [];
+  }
+  /** Adds one mask rule for field shapes, optionally scoped to one origin. */
+  async addmaskrule(rule) {
+    await this.setmaskrules([...await this.getmaskrules(), rule]);
+  }
+  /** Removes one mask rule by its id. */
+  async removemaskrule(id) {
+    await this.setmaskrules((await this.getmaskrules()).filter((rule) => rule.id !== id));
+  }
+  /** Stores the whole run log of one run: the append lands in one storage transaction so the entries and their chain links persist together. */
+  async setimmutablelog(log) {
+    return this.adapter.set(`immutablelog:${log.runid}`, log);
+  }
+  /** Returns the stored run log of one run; an absent log returns undefined. */
+  async getimmutablelog(runid) {
+    return this.adapter.get(`immutablelog:${runid}`);
+  }
+  /** Lists the stored run logs, oldest update first, with the sealed logs carrying their final hash. */
+  async listimmutablelogs() {
+    const index = await this.adapter.get("immutablelogindex") ?? [];
+    const logs = [];
+    for (const runid of index) {
+      const log = await this.getimmutablelog(runid);
+      if (log) logs.push(log);
+    }
+    return logs.sort((one, two) => one.updatedat - two.updatedat);
+  }
+  /** Stores the run log index entry of one run so the log listing reads every stored log. */
+  async trackimmutablelog(runid) {
+    const index = await this.adapter.get("immutablelogindex") ?? [];
+    if (!index.includes(runid)) await this.adapter.set("immutablelogindex", [...index, runid]);
+  }
+  /** Exports the verified log chain of one run for the audit file: the read path verifies the whole hash chain first and a broken link refuses the export with no entries served. */
+  async exportverifiedrunlog(runid) {
+    const log = await this.getimmutablelog(runid);
+    if (!log) throw new Error(`No run log exists for the run ${runid}.`);
+    return exportlogchain(log);
+  }
+  /** Expires the sealed run logs past the user configured retention: the entries reduce to their chain summaries while the seal hash always survives. */
+  async expireimmutablelogs(retention, now) {
+    const logs = await this.listimmutablelogs();
+    if (retention === void 0) return logs;
+    const kept = [];
+    for (const log of logs) {
+      if (log.seal !== void 0 && now - log.seal.sealedat > retention) {
+        const summary = { runid: log.runid, sessionid: log.sessionid, entries: [], seal: { ...log.seal, entries: log.seal.entries }, updatedat: now };
+        await this.setimmutablelog(summary);
+      } else {
+        kept.push(log);
+      }
+    }
+    return kept;
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -4301,6 +4780,245 @@ function randomid() {
   return crypto.randomUUID();
 }
 
+// originpolicy.ts
+function exactorigin(origin, entry) {
+  return origin.trim() !== "" && origin === entry;
+}
+function wildcardentry(entry) {
+  return entry.includes("*") || entry.includes("://*.") || entry.trim() === "" || entry.trim() === "https://" || entry.trim() === "http://";
+}
+function allowlistcheck(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The step needs the exact origin it targets." };
+  for (const entry of input.allowlist) {
+    if (wildcardentry(entry.origin)) return { allowed: false, reason: `The allowlist entry ${entry.origin} carries a wildcard; every grant binds to one exact origin with no wildcard expansion.` };
+  }
+  const scoped = input.profileid === void 0 ? input.allowlist : input.allowlist.filter((entry) => entry.profileid === input.profileid);
+  const granted = scoped.some((entry) => exactorigin(input.origin, entry.origin));
+  if (granted) return { allowed: true, reason: `The origin ${input.origin} sits inside the automation allowlist the user granted.` };
+  if (input.sessionorigin !== void 0 && exactorigin(input.origin, input.sessionorigin)) return { allowed: true, reason: `The active tab grant covers ${input.origin} as exactly one explicit single origin grant.` };
+  return { allowed: false, reason: `The denydefault posture refuses ${input.origin} because the origin sits absent from the automation allowlist; grant the origin first.` };
+}
+function originprofileof(input) {
+  if (input.origin.trim() === "") throw new Error("The origin profile needs its exact origin.");
+  return { profileid: input.profileid ?? randomid(), origin: input.origin, grants: [...input.grants ?? []], denials: [...input.denials ?? []], createdat: input.now, updatedat: input.now };
+}
+function profilekind(input) {
+  if (input.profile.grants.includes(input.kind) && input.decision === "grant") return input.profile;
+  if (input.profile.denials.includes(input.kind) && input.decision === "deny") return input.profile;
+  const grants = input.decision === "grant" ? [.../* @__PURE__ */ new Set([...input.profile.grants, input.kind])] : input.profile.grants.filter((kind) => kind !== input.kind);
+  const denials = input.decision === "deny" ? [.../* @__PURE__ */ new Set([...input.profile.denials, input.kind])] : input.profile.denials.filter((kind) => kind !== input.kind);
+  return { ...input.profile, grants, denials, updatedat: input.now };
+}
+function profilegrade(input) {
+  if (!input.sensitive) return { allowed: true, consult: false, reason: `The ${input.kind} kind grades non-sensitive and the origin profile needs no consult.` };
+  if (input.profile === void 0) return { allowed: true, consult: true, reason: `No origin profile exists for the ${input.kind} kind, so the fresh class consent gate alone routes the sensitive step.` };
+  if (input.profile.denials.includes(input.kind)) return { allowed: false, consult: true, reason: `The origin profile of ${input.profile.origin} denies the ${input.kind} kind; a denied kind never runs on that origin.` };
+  if (input.profile.grants.includes(input.kind)) return { allowed: true, consult: true, reason: `The origin profile of ${input.profile.origin} grants the ${input.kind} kind the user reviewed.` };
+  return { allowed: true, consult: true, reason: `The origin profile of ${input.profile.origin} carries no ${input.kind} decision, so the fresh class consent gate alone routes the sensitive step.` };
+}
+function stepoptions(step) {
+  if (!step.options) return {};
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed) && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+var paymentkinds = /* @__PURE__ */ new Set(["fillcard", "fillcode"]);
+var credentialkinds = /* @__PURE__ */ new Set(["consentpassword", "saveapikey", "handleauth", "authflow"]);
+var deletekinds = /* @__PURE__ */ new Set(["discardtab", "closepattern", "clearcookies", "removeattribute", "cleanupartifacts"]);
+var publishkinds = /* @__PURE__ */ new Set(["postform", "postfiles", "sendmessage", "submitform", "submitsearch", "writeclipboard"]);
+var defaultsensitivekinds = /* @__PURE__ */ new Set(["attachfile", "uploadfile", "uploadfiles", "downloadfile", "downloadimages", "batchdownload", "pausedownload", "resumedownload", "quarantinedownload", "evaluate"]);
+function sensitiveclassesof(step) {
+  const options = stepoptions(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 : "", typeof options.target === "string" ? options.target : ""].map((name) => name.toLowerCase());
+  const carries = (shape) => names.some((name) => name.includes(shape));
+  const classes = /* @__PURE__ */ new Set();
+  if (paymentkinds.has(step.kind) || carries("card") || carries("cvc") || carries("cvv")) classes.add("payment");
+  const credentialshape = carries("password") || carries("token") || carries("secret") || carries("apikey") || carries("passphrase");
+  const submits = step.kind === "submitform" || step.kind === "postform" || step.kind === "submitsearch" || step.kind === "fillform" || step.kind === "filllabel" || step.kind === "fillplaceholder";
+  if (credentialkinds.has(step.kind) || submits && credentialshape) classes.add("credential");
+  if (deletekinds.has(step.kind)) classes.add("delete");
+  if (publishkinds.has(step.kind) || step.kind === "callrest" || step.kind === "callgraphql") {
+    const verb = typeof options.method === "string" ? options.method.trim().toUpperCase() : typeof options.verb === "string" ? options.verb.trim().toUpperCase() : "";
+    if (step.kind === "callrest" || step.kind === "callgraphql") {
+      if (verb !== "" && !["GET", "HEAD", "OPTIONS"].includes(verb)) classes.add("publish");
+    } else classes.add("publish");
+  }
+  const bydefault = defaultsensitivekinds.has(step.kind);
+  const list = [...classes];
+  if (list.length === 0 && !bydefault) return { classes: [], bydefault: false, sensitive: false, reason: `The ${step.kind} kind carries no sensitive class and no default sensitive grade.` };
+  return { classes: list, bydefault, sensitive: true, reason: `The ${step.kind} kind grades sensitive${list.length > 0 ? ` through the ${list.join(", ")} class${list.length === 1 ? "" : "es"}` : ""}${bydefault ? " by default" : ""}.` };
+}
+function classconsentcovers(consents, origin, sensitiveclass, now) {
+  return consents.some((consent) => consent.origin === origin && consent.sensitiveclass === sensitiveclass && consent.grantedat <= now && (consent.expiresat === void 0 || now < consent.expiresat));
+}
+function missingclassconsents(input) {
+  const missing = input.classes.filter((kind) => !classconsentcovers(input.consents, input.origin, kind, input.now));
+  if (missing.length > 0) return { needed: true, missing, reason: `The sensitive classes ${missing.join(", ")} need one fresh consent prompt each on ${input.origin}.` };
+  if (input.bydefault && input.classes.length === 0) return { needed: true, missing: [], reason: `The ${input.origin} step grades sensitive by default and needs its fresh consent window prompt.` };
+  return { needed: false, missing: [], reason: `The fresh class consents of ${input.origin} cover every class the step names.` };
+}
+function openconsentwindow(input) {
+  if (input.sessionid.trim() === "" || input.origin.trim() === "") throw new Error("The consent window needs its session and its exact origin.");
+  if (!Number.isFinite(input.duration) || input.duration <= 0) throw new Error("The consent window needs its duration as a positive user value; no window defaults to unlimited.");
+  return { id: input.id ?? randomid(), sessionid: input.sessionid, origin: input.origin, startedat: input.now, duration: input.duration, expiresat: input.now + input.duration, boundary: input.boundary?.trim() !== "" && input.boundary !== void 0 ? input.boundary : `${input.duration} milliseconds the user chose`, kinds: [...new Set(input.kinds)], state: "active" };
+}
+function consentwindowstate(window2, now) {
+  if (window2.state === "closed" || now >= window2.expiresat) return { state: "expired", remaining: 0, reason: `The consent window of ${window2.origin} closed at its ${window2.boundary} boundary; the run suspends until a new explicit prompt renews it.` };
+  return { state: "active", remaining: window2.expiresat - now, reason: `The consent window of ${window2.origin} stays active with ${window2.expiresat - now} milliseconds left of its ${window2.boundary} boundary.` };
+}
+function windowgatesstep(input) {
+  if (input.window === void 0) return { allowed: false, suspended: false, reason: `No active consent window covers ${input.origin}; the consent prompt opens one before any step dispatches.` };
+  if (input.window.sessionid !== input.sessionid) return { allowed: false, suspended: false, reason: `The consent window scopes to the session ${input.window.sessionid} only and never widens to another session.` };
+  if (input.window.origin !== input.origin) return { allowed: false, suspended: false, reason: `The consent window scopes to the origin ${input.window.origin} only and never widens to another origin.` };
+  const state = consentwindowstate(input.window, input.now);
+  if (state.state === "expired") return { allowed: false, suspended: true, reason: state.reason };
+  return { allowed: true, suspended: false, reason: state.reason };
+}
+function renewconsentwindow(input) {
+  const closed = input.window.state === "active" ? { ...input.window, state: "closed", closedat: input.now } : input.window;
+  const renewed = openconsentwindow({ sessionid: input.window.sessionid, origin: input.window.origin, duration: input.duration, kinds: input.kinds.length > 0 ? input.kinds : input.window.kinds, now: input.now });
+  return { renewed, closed };
+}
+function revokerun(input) {
+  if (input.sessionid.trim() === "" || input.runid.trim() === "") throw new Error("The revocation needs its session and run ids.");
+  if (input.actor.trim() === "") throw new Error("The revocation names the acting user.");
+  const halted = [...input.pendingstepid !== void 0 ? [input.pendingstepid] : [], ...input.queuedstepids ?? []];
+  if (halted.length === 0) throw new Error("The revocation halts at least the pending step of the run.");
+  return { id: input.id ?? randomid(), sessionid: input.sessionid, runid: input.runid, haltedstepids: halted, actor: input.actor, reason: input.reason?.trim() !== "" && input.reason !== void 0 ? input.reason : "The user revoked the consent mid run.", at: input.now };
+}
+function scopegrantof(input) {
+  if (input.origin.trim() === "") throw new Error("The consent scope needs its exact origin.");
+  if (input.kinds.length === 0) throw new Error("The consent scope names the kinds it covers.");
+  if (input.boundary.trim() === "") throw new Error("The consent scope names its boundary; no grant defaults to unlimited.");
+  return { origin: input.origin, kinds: [...new Set(input.kinds)], boundary: input.boundary, grantedat: input.now };
+}
+function deniedevidenceof(input) {
+  return { origin: input.origin, kind: input.kind, reason: input.reason, at: input.now };
+}
+function consentprompttext(input) {
+  const label = input.classes.length > 0 ? `the ${input.classes.join(" and ")} class${input.classes.length === 1 ? "" : "es"}` : "a sensitive by default grade";
+  return `Allow the ${input.kind} step on ${input.origin} graded as ${label} for ${input.duration} milliseconds? The consent window closes at that boundary; no grant ever defaults to unlimited.`;
+}
+
+// environments.ts
+var offloadfamilies = [
+  { task: "htmlsnapshot", kinds: ["readhtml", "parsehtml", "readertree", "readoutline", "classifypage"] },
+  { task: "jsonpayload", kinds: ["readjson", "parsejson"] },
+  { task: "tablerows", kinds: ["readtable", "scrapetable", "detecttables", "deduperows", "transformvalues"] },
+  { task: "a11ytree", kinds: ["a11ytree"] },
+  { task: "complexselector", kinds: ["resolvexpath", "deriveselector", "detectvirtual"] },
+  { task: "stitchshots", kinds: ["contactsheet", "timelapse", "makethumbs"] }
+];
+function offfamilyof(kind) {
+  return offloadfamilies.find((family) => family.kinds.includes(kind))?.task;
+}
+function environmentsof(step) {
+  if (markuprenderstep(step)) return ["sandboxframe"];
+  if (step.kind === "evaluate") return ["isolatedworld"];
+  if (offfamilyof(step.kind) !== void 0) return ["pagecontext", "offscreenworker"];
+  return ["pagecontext"];
+}
+function defaultenvironment(step) {
+  if (markuprenderstep(step)) return "sandboxframe";
+  if (step.kind === "evaluate") return "isolatedworld";
+  return "pagecontext";
+}
+function offamilyeligible(kind) {
+  return offloadfamilies.some((family) => family.kinds.includes(kind));
+}
+function markuprenderstep(step) {
+  if (!step.options) return false;
+  try {
+    const parsed = JSON.parse(step.options);
+    return Boolean(parsed && typeof parsed === "object" && !Array.isArray(parsed) && typeof parsed.markup === "string" && parsed.markup.trim() !== "");
+  } catch {
+    return false;
+  }
+}
+function environmentrequirementsof(kinds) {
+  return kinds.map((kind) => {
+    const bare = { kind };
+    const environments = environmentsof(bare);
+    return { kind, environments, defaultenvironment: defaultenvironment(bare) };
+  });
+}
+function executorregistry() {
+  return [
+    { environment: "pagecontext", adapter: "pagebridge", description: "The page bridge executes dom actions inside the live page because page events only fire there." },
+    { environment: "isolatedworld", adapter: "scriptingapi", description: "The scripting api injects step logic inside the isolated world where page globals stay unreachable from step code." },
+    { environment: "offscreenworker", adapter: "offscreendocument", description: "The offscreen document hosts the worker pool that parses heavy payloads away from the page; the capability gate keeps it behind the optional offscreen grant with an inline fallback." },
+    { environment: "sandboxframe", adapter: "sandboxpage", description: "The sandboxed page renders untrusted markup with scripts and handlers stripped before render and posts its result back through a per render nonce." }
+  ];
+}
+function routeenvironment(step, input) {
+  const allowed = environmentsof(step);
+  const named = step.environment;
+  if (named !== void 0) {
+    if (!allowed.includes(named)) return { environment: defaultenvironment(step), fallback: false, reason: `The ${named} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits, so the executor routes to the ${defaultenvironment(step)} default.` };
+    return { environment: named, fallback: false, reason: `The reviewed step names its ${named} environment and the ${step.kind} kind permits it.` };
+  }
+  if (markuprenderstep(step)) return { environment: "sandboxframe", fallback: false, reason: `The ${step.kind} step carries untrusted markup, so it renders inside the sandboxframe only.` };
+  if (step.kind === "evaluate") return { environment: "isolatedworld", fallback: false, reason: "The evaluate kind runs inside the isolated world where page globals stay unreachable from step code." };
+  if (offamilyeligible(step.kind)) {
+    if (!input.offload) return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step stays inside the page because the user keeps the parse offload off.` };
+    if (!input.granted) return { environment: "pagecontext", fallback: true, reason: `The ${step.kind} step falls back to inline parsing inside the page because the offscreen capability grant stays absent.` };
+    return { environment: "offscreenworker", fallback: false, reason: `The ${step.kind} step offloads into the offscreen worker pool under the granted capability.` };
+  }
+  return { environment: "pagecontext", fallback: false, reason: `The ${step.kind} step keeps the pagecontext because page events only fire inside the live page.` };
+}
+function workerrequestof(input) {
+  const task = offfamilyof(input.kind);
+  if (task === void 0) throw new Error(`The ${input.kind} kind stays outside the offscreen worker pool families.`);
+  if (input.payload.trim() === "") throw new Error("The worker request needs its payload reference.");
+  return { id: input.id, runid: input.runid, stepid: input.stepid, task, payload: input.payload, transferables: transferablekeys(input.options ?? {}), sentat: input.sentat };
+}
+function transferablekeys(options) {
+  return Object.keys(options).filter((key) => options[key] instanceof ArrayBuffer);
+}
+function poolplan(input) {
+  if (input.size !== void 0) {
+    if (!Number.isFinite(input.size) || input.size < 1 || !Number.isInteger(input.size)) return { workers: input.current, added: 0, retired: 0, reason: "The configured pool size stays a positive whole number the user chose; the pool keeps its current workers." };
+    const target = input.size;
+    if (target > input.current) return { workers: target, added: target - input.current, retired: 0, reason: `The user configured pool size ${target} adds ${target - input.current} worker${target - input.current === 1 ? "" : "s"} to the pool.` };
+    if (target < input.current) return { workers: target, added: 0, retired: input.current - target, reason: `The user configured pool size ${target} retires ${input.current - target} worker${input.current - target === 1 ? "" : "s"} from the pool.` };
+    return { workers: target, added: 0, retired: 0, reason: `The pool holds the ${target} workers the user configured.` };
+  }
+  if (input.pending > input.current) return { workers: input.pending, added: input.pending - input.current, retired: 0, reason: `The ${input.pending} pending parses grow the pool by ${input.pending - input.current} worker${input.pending - input.current === 1 ? "" : "s"}; no engine cap exists.` };
+  if (input.current > input.pending) return { workers: input.pending, added: 0, retired: input.current - input.pending, reason: `The ${input.current - input.pending} idle worker${input.current - input.pending === 1 ? "" : "s"} retire down to the ${input.pending} pending parse${input.pending === 1 ? "" : "s"}.` };
+  return { workers: input.current, added: 0, retired: 0, reason: `The ${input.current} workers match the ${input.pending} pending parses; the pool stays unchanged.` };
+}
+function openoffscreen(input) {
+  if (input.document.trim() === "") throw new Error("The offscreen document needs its user configured path.");
+  if (input.reasons.length === 0) throw new Error("The offscreen document needs the reasons the user reviewed.");
+  if (input.justification.trim() === "") throw new Error("The offscreen document needs its justification in plain language.");
+  const open = input.registry.find((entry2) => entry2.runid === input.runid && entry2.closedat === void 0);
+  if (open) return { registry: input.registry, entry: open, reused: true };
+  const entry = { document: input.document, runid: input.runid, reasons: [...input.reasons], justification: input.justification, createdat: input.now };
+  return { registry: [entry, ...input.registry], entry, reused: false };
+}
+function closeoffscreen(registry, runid, now) {
+  const open = registry.find((entry) => entry.runid === runid && entry.closedat === void 0);
+  if (!open) return { registry, closed: false };
+  return { registry: registry.map((entry) => entry === open ? { ...entry, closedat: now } : entry), closed: true };
+}
+function isolatedinjection(step) {
+  if (step.kind !== "evaluate") throw new Error("The isolated world injection serves the evaluate kind only.");
+  if (!step.value || step.value.trim() === "") throw new Error("The evaluate step needs its reviewed expression.");
+  let args = [];
+  if (step.options) {
+    try {
+      const parsed = JSON.parse(step.options);
+      if (Array.isArray(parsed)) args = parsed.filter((item) => typeof item === "string");
+    } catch {
+    }
+  }
+  return { world: "ISOLATED", code: step.value, args };
+}
+
 // toolcatalog.ts
 var toolcatalogversion = 1;
 var toolnamespaces = ["browser", "workflow", "memory", "system"];
@@ -9127,6 +9845,84 @@ function mergeegressgrade(input) {
   if (input.carriespagecontent) return { allowed: true, reason: `The export of the report ${input.report.title} carries page content from the sources ${input.report.sources.join(", ")} and grades as a data egress event in the audit trail.` };
   return { allowed: true, reason: `The export of the report ${input.report.title} carries no page content and stays a plain report export.` };
 }
+function stepenvironmentvalid(step) {
+  if (step.environment !== void 0 && step.environment !== "pagecontext" && step.environment !== "isolatedworld" && step.environment !== "offscreenworker" && step.environment !== "sandboxframe") return { allowed: false, reason: "The step environment stays one of pagecontext, isolatedworld, offscreenworker and sandboxframe." };
+  const allowed = environmentsof(step);
+  if (step.environment !== void 0 && !allowed.includes(step.environment)) return { allowed: false, reason: `The ${step.environment} environment sits outside the ${allowed.join(", ")} the ${step.kind} kind permits; the review sees the environment of every step.` };
+  return { allowed: true, reason: step.environment === void 0 ? `The ${step.kind} step carries no environment field and routes to its ${defaultenvironment(step)} default.` : `The ${step.environment} environment of the ${step.kind} step sits inside the ${allowed.join(", ")} the kind permits.` };
+}
+function environmentgrantgate(step, grants) {
+  if (grants === void 0 || grants.length === 0) return { allowed: true, reason: `The session carries no environment grant list, so the ${defaultenvironment(step)} default of the ${step.kind} step stays the documented posture behind the same review.` };
+  const environment = step.environment ?? defaultenvironment(step);
+  if (!grants.includes(environment)) return { allowed: false, reason: `The ${environment} environment sits outside the ${grants.join(", ")} the session granted; no step ever widens the environment grants.` };
+  return { allowed: true, reason: `The ${environment} environment of the ${step.kind} step sits inside the ${grants.join(", ")} the session granted.` };
+}
+function offscreencapabilitygate(input) {
+  if (input.environment !== "offscreenworker") return { allowed: true, reason: `The ${input.environment} environment needs no offscreen capability grant.` };
+  if (!input.granted) return { allowed: false, reason: "The offscreen worker pool runs only under the user granted offscreen capability; the step falls back to inline parsing inside the page." };
+  return { allowed: true, reason: "The offscreen worker pool runs under the user granted offscreen capability." };
+}
+function keepalivegate(input) {
+  if (!input.session) return { allowed: false, reason: "The keepalive port opens only inside an active session." };
+  if (input.session.stoppedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed for a stopped session." };
+  if (input.session.pausedat !== void 0) return { allowed: false, reason: "The keepalive port stays closed while the session pauses; a resumed run reattaches it." };
+  if (input.now > input.session.expiresat) return { allowed: false, reason: "The keepalive port stays closed for an expired session." };
+  if (!input.plan || input.plan.state !== "approved") return { allowed: false, reason: "The keepalive port opens only behind an active reviewed plan; unreviewed work never holds the service worker alive." };
+  return { allowed: true, reason: `The approved plan ${input.plan.id} of the active session holds the keepalive port open for its whole run.` };
+}
+function keepaliveintervalvalid(interval) {
+  if (!Number.isFinite(interval) || interval <= 0) return { allowed: false, reason: "The keepalive heartbeat interval stays a positive user value in milliseconds." };
+  return { allowed: true, reason: `The keepalive heartbeat interval ${interval} milliseconds stays the user configured value; the roadmap documents thirty seconds while the choice stays the user's.` };
+}
+function workerpoolsizevalid(size) {
+  if (size === void 0) return { allowed: true, reason: "No worker pool size is configured, so the pool follows the pending parse queue alone with no engine cap." };
+  if (!Number.isInteger(size) || size < 1) return { allowed: false, reason: "The worker pool size stays a positive whole number the user configured; no engine cap exists." };
+  return { allowed: true, reason: `The worker pool size ${size} stays the user configured value; no engine cap exists.` };
+}
+function sandboxorigingate(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The sandbox render needs the source origin of its untrusted markup." };
+  if (input.allowed.length > 0 && !input.allowed.includes(input.origin)) return { allowed: false, reason: `The origin ${input.origin} sits outside the origins the user allows to render untrusted markup: ${input.allowed.join(", ")}.` };
+  return { allowed: true, reason: input.allowed.length === 0 ? `The origin ${input.origin} renders untrusted markup under the documented open origin list the user chose not to narrow.` : `The origin ${input.origin} sits inside the origins the user allows to render untrusted markup.` };
+}
+function environmentrequirements() {
+  return environmentrequirementsof([...allowedactions]);
+}
+function automationallowlistgate(input) {
+  const verdict = allowlistcheck({ origin: input.origin, allowlist: input.allowlist, ...input.session !== void 0 ? { sessionorigin: input.session.origin } : {} });
+  if (!verdict.allowed) return { allowed: false, reason: verdict.reason };
+  return { allowed: true, reason: verdict.reason };
+}
+function originprofilegate(input) {
+  const verdict = profilegrade(input);
+  if (!verdict.allowed) return { allowed: false, reason: verdict.reason };
+  return { allowed: true, reason: verdict.reason };
+}
+function consentwindowgate(input) {
+  if (!input.sensitive) return { allowed: true, reason: "The non-sensitive step rides the session origin grants and needs no consent window of its own." };
+  const verdict = windowgatesstep({ window: input.window, sessionid: input.sessionid, origin: input.origin, now: input.now });
+  if (!verdict.allowed) return { allowed: false, reason: verdict.reason };
+  return { allowed: true, reason: verdict.reason };
+}
+function revokerungate(input) {
+  if (input.revocation === void 0) return { allowed: true, reason: "No revocation halted the run; the steps keep their reviewed order." };
+  if (input.revocation.sessionid !== input.sessionid) return { allowed: true, reason: "The revocation belongs to another session and halts nothing here." };
+  if (input.revocation.runid !== input.runid) return { allowed: true, reason: "The revocation belongs to another run and halts nothing here." };
+  return { allowed: false, reason: `The revocation of ${input.revocation.actor} halted the pending step and ${Math.max(0, input.revocation.haltedstepids.length - 1)} queued step${Math.max(0, input.revocation.haltedstepids.length - 1) === 1 ? "" : "s"} without executing them: ${input.revocation.haltedstepids.join(", ")}.` };
+}
+function sensitiveclassgate(input) {
+  if (!input.sensitive) return { allowed: true, reason: "The step carries no sensitive class and needs no fresh consent prompt." };
+  const verdict = missingclassconsents({ origin: input.origin, classes: input.classes, bydefault: input.bydefault, consents: input.consents, now: input.now });
+  if (verdict.needed) return { allowed: false, reason: verdict.reason };
+  return { allowed: true, reason: verdict.reason };
+}
+function consentdurationvalid(duration) {
+  if (!Number.isFinite(duration) || duration <= 0) return { allowed: false, reason: "The consent window duration stays a positive user value in milliseconds; no grant ever defaults to unlimited." };
+  return { allowed: true, reason: `The consent window duration ${duration} milliseconds stays the user configured boundary the prompt names.` };
+}
+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." };
+}
 
 // progress.ts
 function emptyprogress(planid, now) {
@@ -9141,6 +9937,14 @@ function recordoutcome(progress, planid, outcome, now) {
   const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
   return { ...base, outcomes: [...base.outcomes ?? [], outcome], updatedat: now };
 }
+function recordenvironment2(progress, planid, stepid, environment, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  return { ...base, environments: { ...base.environments ?? {}, [stepid]: environment }, updatedat: now };
+}
+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 iscomplete(progress, plan) {
   if (!progress || progress.planid !== plan.id) return false;
   const required = plan.steps.map((step) => step.id);
@@ -9304,9 +10108,68 @@ function recordtoolcall(progress, planid, stepid, entry, now) {
   const outcome = { stepid, ok: entry.ok, summary: `The ${entry.tool} tool call of the client ${entry.clientid} ${entry.ok ? "ran behind the consent gates" : `was refused${entry.code !== void 0 ? ` with the ${entry.code} error` : ""}`}.`, details: { tool: entry }, at: now };
   return recordoutcome(base, planid, outcome, now);
 }
+function recorddenied(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: false, summary: `The ${entry.kind} step on ${entry.origin} was denied: ${entry.reason}`, details: { denied: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
+function recordrevocation(progress, planid, stepid, entry, now) {
+  const base = progress && progress.planid === planid ? progress : emptyprogress(planid, now);
+  const outcome = { stepid, ok: false, summary: `The run halted at the step ${stepid}${entry.haltedstepids.length > 1 ? ` with ${entry.haltedstepids.length - 1} queued step${entry.haltedstepids.length === 2 ? "" : "s"} rolled back` : ""}: ${entry.reason}`, details: { revoked: entry }, at: now };
+  return recordoutcome(base, planid, outcome, now);
+}
+
+// maskinputs.ts
+var defaultmaskshapes = ["password", "token", "card", "secret"];
+var maskmarker = "[redacted]";
+function fieldshapekind(name) {
+  const lowered = name.toLowerCase();
+  if (lowered.includes("password") || lowered.includes("passwd") || lowered.includes("pwd") || lowered.includes("passphrase")) return "password";
+  if (lowered.includes("token") || lowered.includes("apikey") || lowered.includes("api_key") || lowered.includes("auth") || lowered.includes("bearer")) return "token";
+  if (lowered.includes("card") || lowered.includes("cvc") || lowered.includes("cvv") || lowered.includes("expiry") || lowered.includes("pan")) return "card";
+  if (lowered.includes("secret")) return "secret";
+  return void 0;
+}
+function shapesof(input) {
+  const shapes = new Set(defaultmaskshapes);
+  for (const shape of input.settings?.maskshapes ?? []) if (shape.trim() !== "") shapes.add(shape.trim().toLowerCase());
+  for (const rule of input.rules) {
+    const scoped = rule.origin === void 0 || rule.origin === "" || input.origin !== void 0 && rule.origin === input.origin;
+    if (scoped) {
+      for (const shape of rule.shapes) if (shape.trim() !== "") shapes.add(shape.trim().toLowerCase());
+    }
+  }
+  return [...shapes];
+}
+function maskingfield(name, shapes) {
+  if (fieldshapekind(name) !== void 0) return true;
+  const lowered = name.toLowerCase();
+  return shapes.some((shape) => shape !== "" && lowered.includes(shape));
+}
+function maskvalue(value) {
+  return value === "" ? "" : maskmarker;
+}
+function maskfield(input) {
+  return maskingfield(input.name, input.shapes) ? maskvalue(input.value) : input.value;
+}
+function maskrecord(record2, shapes) {
+  const masked = {};
+  for (const [key, value] of Object.entries(record2)) {
+    if (typeof value === "string") {
+      const sibling = record2.name;
+      masked[key] = key === "value" && typeof sibling === "string" ? maskfield({ name: sibling, value, shapes }) : maskfield({ name: key, value, shapes });
+    } else if (Array.isArray(value)) masked[key] = value.map((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item) ? maskrecord(item, shapes) : item);
+    else if (Boolean(value) && typeof value === "object") masked[key] = maskrecord(value, shapes);
+    else masked[key] = value;
+  }
+  return masked;
+}
+function maskexport(record2, shapes) {
+  return maskrecord(record2, shapes);
+}
 
 // version.ts
-var packageversion = "1.1.59";
+var packageversion = "1.1.61";
 
 // types.ts
 var protocolversion = packageversion;
@@ -10270,6 +11133,16 @@ function runhistoryquery(value) {
 function runhistoryreport(input) {
   return { version: protocolversion, entries: input.entries, query: input.query ?? {} };
 }
+function environmentreport(input) {
+  return {
+    version: protocolversion,
+    environments: Object.entries(input.environments).map(([stepid, environment]) => ({ stepid, environment })),
+    turnarounds: Object.entries(input.turnarounds ?? {}).map(([stepid, milliseconds]) => ({ stepid, milliseconds })),
+    offscreen: input.offscreen ?? [],
+    workers: input.workers ?? 0,
+    ...input.keepalive !== void 0 ? { keepalive: input.keepalive } : {}
+  };
+}
 
 // capture.ts
 var capturekinds = ["shotview", "shotfullpage", "shotelement", "shotregion", "contactsheet"];
@@ -10773,7 +11646,7 @@ async function readcapabilities() {
   ]);
   return { tabs, downloads, clipboardread, clipboardwrite, reportedat: Date.now() };
 }
-function stepoptions(step) {
+function stepoptions2(step) {
   if (!step.options) return {};
   try {
     const parsed = JSON.parse(step.options);
@@ -10786,7 +11659,7 @@ function tabid(step) {
   return Number.parseInt(step.value ?? "", 10);
 }
 async function runbrowseraction(step, sessiontabid, windowid) {
-  const options = stepoptions(step);
+  const options = stepoptions2(step);
   switch (step.kind) {
     case "tablist": {
       const tabs = await chrome.tabs.query({});
@@ -12211,6 +13084,41 @@ function unreadcount(mailboxes, agentid) {
   return mailboxof(mailboxes, agentid).unread;
 }
 
+// sandboxframe.ts
+function stripscripts(markup) {
+  return markup.replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<script\b[^>]*\/>/gi, "").replace(/\son[a-z]+\s*=\s*"[^"]*"/gi, "").replace(/\son[a-z]+\s*=\s*'[^']*'/gi, "").replace(/\son[a-z]+\s*=\s*[^\s>]+/gi, "").replace(/javascript:/gi, "").trim();
+}
+function nonceof(seed) {
+  const alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let hash = 0;
+  for (let index = 0; index < seed.length; index += 1) hash = hash * 31 + seed.charCodeAt(index) >>> 0;
+  let nonce = "";
+  let state = hash === 0 ? 2654435769 : hash;
+  for (let index = 0; index < 16; index += 1) {
+    state = state * 1664525 + 1013904223 >>> 0;
+    nonce += alphabet[state % alphabet.length];
+  }
+  return nonce;
+}
+function sandboxrenderof(input) {
+  if (input.markup.trim() === "") throw new Error("The sandbox render needs its untrusted markup.");
+  if (input.sourceorigin.trim() === "") throw new Error("The sandbox render needs the source origin of its untrusted markup.");
+  if (input.stepid.trim() === "") throw new Error("The sandbox render names the reviewed step it renders for.");
+  return { id: input.id, nonce: nonceof(`${input.id}:${input.now}`), markup: stripscripts(input.markup), sourceorigin: input.sourceorigin, stepid: input.stepid, renderedat: input.now };
+}
+function rendermessage(render) {
+  return { channel: "devthinksandbox", type: "render", nonce: render.nonce, markup: render.markup };
+}
+function acceptrenderresult(input) {
+  if (input.message.channel !== "devthinksandbox") return { accepted: false, reason: "The sandbox message travels the devthinksandbox channel only." };
+  if (input.message.type !== "renderresult") return { accepted: false, reason: "The sandbox message answers with the renderresult type only." };
+  const render = input.renders.find((entry) => entry.nonce === input.message.nonce && entry.renderedat <= input.now);
+  if (!render) return { accepted: false, reason: "The sandbox message carries no nonce of a known render; a stale or replayed message never passes." };
+  const text2 = (input.message.text ?? "").replace(/<[^>]*>/g, "");
+  const result = { nonce: render.nonce, ok: input.message.ok !== false, text: text2, summary: input.message.summary?.trim() || `The sandbox frame rendered the markup of the step ${render.stepid} and returned its inert text.`, at: input.now };
+  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.` };
+}
+
 // modelroute.ts
 function routevalid(route) {
   if (route.kind.trim() === "") return { allowed: false, reason: "The model route needs its task kind." };
@@ -13423,7 +14331,7 @@ function extensionpage(sender) {
 async function audit(kind, summary, extra = {}) {
   await memory.addaudi({ id: randomid(), kind, at: Date.now(), summary, ...extra });
 }
-function stepoptions2(step) {
+function stepoptions3(step) {
   try {
     return parseoptions(step);
   } catch {
@@ -13516,11 +14424,333 @@ async function dispatchpagestep(step, tabid2, origin, plan) {
   await harvestdialogs(session, activeplan, step.id, tabid2);
   return result[0]?.result;
 }
+var roadmapheartbeat = 3e4;
+var roadmapzombieintervals = 3;
+var runstateprofile = "default";
+var keepaliveport;
+var workerpoolcounts = /* @__PURE__ */ new Map();
+async function offscreengranted() {
+  try {
+    return await chrome.permissions.contains({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function offscreendeclaration() {
+  try {
+    const response = await fetch(chrome.runtime.getURL("manifest.json"));
+    const manifest = await response.json();
+    if (!manifest.offscreen?.document || !manifest.offscreen.reasons?.length || !manifest.offscreen.justification?.trim()) return void 0;
+    return { document: manifest.offscreen.document, reasons: manifest.offscreen.reasons, justification: manifest.offscreen.justification };
+  } catch {
+    return void 0;
+  }
+}
+async function requestoffscreengrant() {
+  try {
+    return await chrome.permissions.request({ permissions: ["offscreen"] });
+  } catch {
+    return false;
+  }
+}
+async function ensureoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  if (!offscreen) return false;
+  const declaration = await offscreendeclaration();
+  if (!declaration) return false;
+  const opened = openoffscreen({ registry: await memory.getoffscreenentries(), document: declaration.document, runid, reasons: declaration.reasons, justification: declaration.justification, now: Date.now() });
+  if (!opened.reused) {
+    await memory.addoffscreenentry(opened.entry);
+    await audit("worker", `The offscreen document ${declaration.document} spawned for the run ${runid} under the reasons ${declaration.reasons.join(", ")} with the reviewed justification.`, {});
+  }
+  try {
+    if (!await offscreen.hasDocument()) await offscreen.createDocument({ url: chrome.runtime.getURL(declaration.document), reasons: declaration.reasons, justification: declaration.justification });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function closeoffscreendocument(runid) {
+  const offscreen = chrome.offscreen;
+  const outcome = closeoffscreen(await memory.getoffscreenentries(), runid, Date.now());
+  if (!outcome.closed) return;
+  const entry = outcome.registry.find((candidate) => candidate.runid === runid && candidate.closedat !== void 0);
+  if (entry) await memory.updateoffscreenentry(entry);
+  try {
+    if (offscreen && await offscreen.hasDocument()) await offscreen.closeDocument();
+  } catch {
+  }
+  await audit("worker", `The offscreen document of the run ${runid} closed with its worker pool; the registry keeps the reasons and justification of the spawn for the audit.`, {});
+}
+function startkeepaliveport(runid) {
+  if (keepaliveport) return;
+  try {
+    keepaliveport = chrome.runtime.connect({ name: `devthinkkeepalive:${runid}` });
+    keepaliveport.onDisconnect.addListener(() => {
+      keepaliveport = void 0;
+    });
+  } catch {
+  }
+}
+async function openplanrun(session, plan) {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const gate = keepalivegate({ session, plan, now: Date.now() });
+  if (!gate.allowed) return;
+  const existing = await memory.getrunstate(runstateprofile);
+  if (existing && existing.keepalive.state === "active") return;
+  const state = openrun({ runid: plan.id, sessionid: session.id, planid: plan.id, profileid: runstateprofile, interval, now: Date.now() });
+  await memory.setrunstate(runstateprofile, state);
+  const lock = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: plan.id, holder: "planrun", now: Date.now() });
+  if (lock.acquired) await memory.setrunlocks(lock.locks);
+  startkeepaliveport(plan.id);
+  await audit("environment", `The run state of the plan ${plan.id} opened with its keepalive port beating every ${interval} milliseconds${lock.acquired ? " and the session locked against concurrent runs" : ""}.`, { sessionid: session.id, planid: plan.id });
+}
+async function markpendingstep(plan, stepid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== plan.id || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, markpending(state, stepid, Date.now()));
+}
+async function recordstepenvironment(step, environment, session, plan, origin, turnaround) {
+  if (session && plan) {
+    await memory.setprogress(recordenvironment2(await memory.getprogress(), plan.id, step.id, environment, Date.now()));
+    const state = await memory.getrunstate(runstateprofile);
+    if (state && state.runid === plan.id) {
+      let next = recordenvironment(state, { stepid: step.id, environment, origin, now: Date.now() });
+      if (turnaround !== void 0) next = recordturnaround(next, { stepid: step.id, milliseconds: turnaround, now: Date.now() });
+      if (["navigate", "openlink", "followlink", "back", "forward"].includes(step.kind) && step.value) next = recordurl(next, { url: step.value, stepid: step.id, now: Date.now() });
+      await memory.setrunstate(runstateprofile, next);
+    }
+  }
+  if (plan && turnaround !== void 0) await memory.setprogress(recordturnaround2(await memory.getprogress(), plan.id, step.id, turnaround, Date.now()));
+}
+async function closeplanrun(planid, sessionid) {
+  const state = await memory.getrunstate(runstateprofile);
+  if (!state || state.runid !== planid || state.keepalive.state !== "active") return;
+  await memory.setrunstate(runstateprofile, closerun(state, Date.now()));
+  const release = releaserunlock({ locks: await memory.getrunlocks(), sessionid, runid: planid, now: Date.now() });
+  if (release.released) await memory.setrunlocks(release.locks);
+  try {
+    keepaliveport?.disconnect();
+  } catch {
+  }
+  keepaliveport = void 0;
+  await closeoffscreendocument(planid);
+  await audit("environment", `The run state of the plan ${planid} closed at its terminal state and the keepalive port released.`, { ...sessionid !== "" ? { sessionid } : {}, planid });
+}
+async function appendrunevent(kind, summary, session, origin, stepid) {
+  if (!session) return;
+  const now = Date.now();
+  let log = await memory.getimmutablelog(session.id);
+  if (!log) {
+    log = openrunlog({ runid: session.id, sessionid: session.id, now });
+    await memory.trackimmutablelog(session.id);
+  }
+  log = await appendlogentry({ log, kind, summary, origin, ...stepid !== void 0 ? { stepid } : {}, at: now });
+  await memory.setimmutablelog(log);
+}
+async function securitystepgate(step, session, origin, settings) {
+  const classification = sensitiveclassesof(step);
+  if (!session) return { allowed: true, suspended: false, reason: "The step runs behind the session review chain; a sessionless preview never dispatches.", classification };
+  const now = Date.now();
+  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);
+  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);
+  const window2 = windows.find((candidate) => candidate.state === "active" && candidate.sessionid === session.id && candidate.origin === origin);
+  const windowverdict = consentwindowgate({ window: window2, sessionid: session.id, origin, sensitive: classification.sensitive, now });
+  if (!windowverdict.allowed) return { allowed: false, suspended: windowverdict.reason?.includes("suspends") ?? false, reason: windowverdict.reason ?? "", classification };
+  const consentverdict = sensitiveclassgate({ origin, classes: classification.classes, bydefault: classification.bydefault, sensitive: classification.sensitive, consents: await memory.getclassconsents(), now });
+  if (!consentverdict.allowed) return { allowed: false, suspended: false, reason: `${classification.reason} ${consentverdict.reason ?? ""}`, classification };
+  const plan = await memory.getplan();
+  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 };
+  return { allowed: true, suspended: false, reason: `${classification.reason} ${allowverdict.reason ?? ""} ${windowverdict.reason ?? ""} ${consentverdict.reason ?? ""}`, classification };
+}
+async function sealsessionrunlog(sessionid) {
+  const log = await memory.getimmutablelog(sessionid);
+  if (!log || log.seal !== void 0 || log.entries.length === 0) return;
+  const sealed = await sealrunlog(log, Date.now());
+  await memory.setimmutablelog(sealed.log);
+  await audit("seal", `The immutable run log sealed at completion with ${sealed.log.entries.length} entries and the final hash ${sealed.seal.sealhash.current}.`, { sessionid });
+}
+async function securityviewof() {
+  const now = Date.now();
+  const settings = await memory.getsettings();
+  const session = await memory.getsession();
+  const logs = await memory.listimmutablelogs();
+  const chain = [];
+  for (const log of logs) chain.push(await chainreportof(log));
+  return {
+    allowlist: await memory.getautomationallowlist(),
+    profiles: await memory.getoriginprofiles(),
+    windows: await memory.expireconsentwindows(now),
+    consents: await memory.getclassconsents(),
+    revocations: await memory.getrevocations(),
+    maskrules: await memory.getmaskrules(),
+    chain,
+    posture: "denydefault",
+    ...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 } : {}
+  };
+}
+async function executeisolatedevaluate(step, tabid2, origin) {
+  const injection = isolatedinjection(step);
+  const result = await chrome.scripting.executeScript({ target: { tabId: tabid2 }, world: "ISOLATED", func: (code, args, expectedorigin) => {
+    if (location.origin !== expectedorigin) return { ok: false, summary: "Page origin changed before the evaluate step ran." };
+    try {
+      let outcome;
+      try {
+        outcome = new Function(`"use strict"; return (${code});`)(...args);
+      } catch {
+        outcome = new Function(`"use strict"; ${code}`)(...args);
+      }
+      return { ok: true, summary: `Reviewed expression returned ${outcome === void 0 ? "no value" : "a value"} inside the isolated world.`, details: { result: String(outcome) } };
+    } catch (error) {
+      return { ok: false, summary: `Reviewed expression failed inside the isolated world: ${error instanceof Error ? error.message : String(error)}` };
+    }
+  }, args: [injection.code, injection.args, 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 markup = typeof options.markup === "string" ? options.markup : "";
+  const sourceorigin = typeof options.sourceorigin === "string" ? options.sourceorigin : origin;
+  const settings = await memory.getsettings();
+  const origingate = sandboxorigingate({ origin: sourceorigin, allowed: settings?.sandboxorigins ?? [] });
+  if (!origingate.allowed) throw new Error(origingate.reason);
+  const render = sandboxrenderof({ id: randomid(), markup, sourceorigin, stepid: step.id, now: Date.now() });
+  await memory.addsandboxrender(render);
+  const hostready = await ensureoffscreendocument(plan?.id ?? step.id);
+  let answer;
+  if (hostready) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "sandboxrender", render: { id: render.id, nonce: render.nonce, markup: render.markup, sourceorigin: render.sourceorigin, stepid: render.stepid } });
+    } catch {
+    }
+  }
+  if (!answer) {
+    try {
+      answer = await chrome.runtime.sendMessage({ kind: "environments", action: "sandboxhost", render: rendermessage(render) });
+    } catch {
+    }
+  }
+  if (!answer) throw new Error("The sandbox frame needs an open host surface: grant the offscreen capability or keep the review panel open so the sandboxed page can render the untrusted markup.");
+  const accepted = acceptrenderresult({ renders: [render], message: { channel: "devthinksandbox", type: "renderresult", nonce: render.nonce, ok: answer.ok, ...answer.text !== void 0 ? { text: answer.text } : {}, summary: answer.summary }, now: Date.now() });
+  if (!accepted.accepted || !accepted.result) throw new Error(accepted.reason);
+  await audit("sandbox", `The step ${step.id} rendered untrusted markup from ${sourceorigin} inside the sandbox frame under the nonce ${render.nonce}; scripts and handlers were stripped before the render and the text never reentered the dom outside the frame.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  await recordstepenvironment(step, "sandboxframe", session, plan, sourceorigin, void 0);
+  return { ok: accepted.result.ok, summary: accepted.result.summary, details: { text: accepted.result.text, nonce: render.nonce, sourceorigin } };
+}
+async function offloadparsetoworker(step, output, session, plan, origin) {
+  const runid = plan?.id ?? step.id;
+  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 started = Date.now();
+  let answer;
+  try {
+    answer = await chrome.runtime.sendMessage({ kind: "offscreen", action: "parse", request: { id: request.id, runid: request.runid, stepid: request.stepid, task: request.task, payload: request.payload, transferables: request.transferables } });
+  } catch {
+  }
+  const turnaround = Date.now() - started;
+  if (!answer) return { output, turnaround: void 0 };
+  const provenance = { origin, stepid: step.id, environment: "offscreenworker" };
+  await memory.addworkerevent({ id: randomid(), runid, kind: "spawn", workers: workerpoolcounts.get(runid) ?? 1, reason: `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool with the transferable keys ${request.transferables.length > 0 ? request.transferables.join(", ") : "none"}.`, provenance, at: Date.now() });
+  await audit("worker", `The ${request.task} parse of the step ${step.id} ran inside the offscreen worker pool and answered in ${turnaround} milliseconds${answer.ok === false ? " with a refusal the inline parse covers" : ""}.`, { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {}, stepid: step.id });
+  const parsed = { ok: answer.ok !== false && (output?.ok ?? true), summary: answer.summary ?? output?.summary ?? "The offscreen worker answered the parse.", details: { ...output?.details ?? {}, workerparse: answer.result ?? "", task: request.task, turnaround } };
+  return { output: parsed, turnaround };
+}
+async function environmentviewof() {
+  const session = await memory.getsession();
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  const swept = zombiesweep({ states, now: Date.now(), interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+  const open = states.find((state) => state.keepalive.state === "active") ?? states[0];
+  const workers = (await chrome.runtime.sendMessage({ kind: "offscreen", action: "pool" }).catch(() => void 0))?.workers ?? 0;
+  return {
+    report: environmentreport({ environments: open?.environments ?? {}, turnarounds: open?.turnarounds ?? {}, offscreen: await memory.getoffscreenentries(), workers, ...open !== void 0 ? { keepalive: { runid: open.keepalive.runid, state: open.keepalive.state, beats: open.keepalive.beats, lastbeatat: open.keepalive.lastbeatat, portopen: open.keepalive.portopen } } : {} }),
+    ...session?.environmentgrants !== void 0 ? { grants: session.environmentgrants } : {},
+    requirements: environmentrequirements(),
+    registry: executorregistry(),
+    offscreengranted: await offscreengranted(),
+    parseoffload: settings?.parseoffload === true,
+    ...settings?.workerpoolsize !== void 0 ? { workerpoolsize: settings.workerpoolsize } : {},
+    ...settings?.sandboxorigins !== void 0 ? { sandboxorigins: settings.sandboxorigins } : {},
+    workerevents: (await memory.getworkerevents()).map((event) => ({ id: event.id, runid: event.runid, kind: event.kind, workers: event.workers, reason: event.reason, at: event.at })),
+    runstates: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, ...state.pendingstepid !== void 0 ? { pendingstepid: state.pendingstepid } : {}, urls: state.urlhistory.length })),
+    locks: await memory.getrunlocks(),
+    zombies: swept.reaped,
+    urls: (open?.urlhistory ?? []).slice(-50),
+    ...open !== void 0 ? { recovery: recoveryplan(open) } : {},
+    ...open !== void 0 && open.state === "recovered" ? { restartnotice: `The service worker restarted and the run ${open.runid} reattached from its persisted run state; the pending step ${open.pendingstepid ?? "none"} waits for the user.` } : {}
+  };
+}
+async function keepalivetick() {
+  const settings = await memory.getsettings();
+  const interval = settings?.keepaliveinterval ?? roadmapheartbeat;
+  const tolerance = settings?.zombieintervals ?? roadmapzombieintervals;
+  for (const state of await memory.listrunstates()) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, beatrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+  }
+  const swept = zombiesweep({ states: await memory.listrunstates(), now: Date.now(), interval, missedlimit: tolerance });
+  for (const runid of swept.reaped) {
+    await closeoffscreendocument(runid);
+    await audit("environment", `The zombie reaper closed the run ${runid} whose heartbeat fell silent past the ${tolerance} tolerated interval${tolerance === 1 ? "" : "s"}; the popup offers the reap action.`, {});
+  }
+  for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+  await memory.expirerunstates(settings?.runstateretention, Date.now());
+  const locks = expirerunlocks(await memory.getrunlocks(), Date.now());
+  if (locks.expired.length > 0) await memory.setrunlocks(locks.locks);
+  try {
+    const estimate = await navigator.storage.estimate();
+    if (estimate.usage !== void 0) await memory.trackrunstatequota(estimate.usage);
+    if (settings?.runstatebytes !== void 0) {
+      const quota = await memory.getrunstatequota();
+      if (quota && quota.used > settings.runstatebytes) {
+        const pruned = prunerunstates({ states: await memory.listrunstates(), used: quota.used, ceiling: settings.runstatebytes });
+        for (const runid of pruned.pruned) {
+          const state = await memory.listrunstates();
+          const target = state.find((entry) => entry.runid === runid);
+          if (target) await memory.removerunstate(target.profileid);
+        }
+        if (pruned.pruned.length > 0) await audit("environment", pruned.reason, {});
+      }
+    }
+  } catch {
+  }
+}
+async function restorerunstates() {
+  const settings = await memory.getsettings();
+  const states = await memory.listrunstates();
+  for (const state of states) {
+    if (state.keepalive.state !== "active") continue;
+    await memory.setrunstate(state.profileid, reattachrun(state, Date.now()));
+    startkeepaliveport(state.runid);
+    await audit("environment", `The service worker restarted and the run ${state.runid} reattached its keepalive port from the persisted run state; ${recoveryplan(state).reason}`, {});
+  }
+  void settings;
+}
 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.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 });
+  runlog = await appendlogentry({ log: runlog, kind: "grant", summary: `The session started for ${origin} with the consentscope grant: the origin ${scope.origin}, the ${scope.kinds.join(", ")} kinds of the observation baseline and the boundary ${scope.boundary}; the active tab counts as exactly one explicit single origin grant.`, origin, at: session.startedat });
+  await memory.trackimmutablelog(session.id);
+  await memory.setimmutablelog(runlog);
   await audit("session", `Session started for ${origin}.`, { sessionid: session.id });
+  await audit("grant", `The consentscope grant of ${origin} was written into the immutable log with the boundary ${scope.boundary}.`, { sessionid: session.id });
   const policy = await memory.getdialogpolicy();
   if (policy) {
     try {
@@ -13625,7 +14855,7 @@ function stepauditkind(step, ok) {
   return ok ? "action" : "error";
 }
 function resolvedinnerstep(step, plan) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   if (typeof options.stepid === "string" && options.stepid.trim()) {
     return plan.steps.find((candidate) => candidate.id === options.stepid) ?? null;
   }
@@ -13634,7 +14864,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 = stepoptions2(step);
+  const options = stepoptions3(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() };
@@ -13667,7 +14897,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 = stepoptions2(step).retryrule;
+  const rule = stepoptions3(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);
@@ -13703,8 +14933,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 = stepoptions2(step);
-  const inneroptions = inner.options ? stepoptions2(inner) : void 0;
+  const options = stepoptions3(step);
+  const inneroptions = inner.options ? stepoptions3(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);
 }
@@ -13716,7 +14946,7 @@ function detailarray(details, key) {
   return Array.isArray(value) ? value : [];
 }
 async function executediffsnapshots(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const versions = Array.isArray(options.versions) ? options.versions.filter((item) => typeof item === "number") : [];
   const baseversion = versions[0];
   const targetversion = versions[1];
@@ -13739,7 +14969,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 = stepoptions2(step);
+  const options = stepoptions3(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) : [];
@@ -14421,7 +15651,7 @@ function commandtabids(step, options) {
   return listed.length > 0 ? listed : single;
 }
 async function executetabscommand(step, session, plan, sessiontabid) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(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());
@@ -14697,7 +15927,7 @@ async function executetabscommand(step, session, plan, sessiontabid) {
   }
 }
 async function executesaveprofiles(step, session, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(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.");
@@ -14717,7 +15947,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 stepoptions2(step).consentref === "string" ? stepoptions2(step).consentref : "";
+  const consentref = typeof stepoptions3(step).consentref === "string" ? stepoptions3(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." };
@@ -14741,7 +15971,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 stepoptions2(step).consentref === "string" ? stepoptions2(step).consentref : "";
+  const consentref = typeof stepoptions3(step).consentref === "string" ? stepoptions3(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);
@@ -14753,7 +15983,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({ ...stepoptions2(step), artifact: artifact.id, artifactname: artifact.name }) };
+  const derived = { ...step, options: JSON.stringify({ ...stepoptions3(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 } };
@@ -14786,7 +16016,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 stepoptions2(step).source === "string" ? stepoptions2(step).source : "";
+      const source = typeof stepoptions3(step).source === "string" ? stepoptions3(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 });
@@ -14857,7 +16087,7 @@ async function storeexport(stepid, datasetvalue, format, delimiter, session, pla
   return artifact;
 }
 async function executedatastep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   switch (step.kind) {
     case "scrapetable": {
@@ -15087,7 +16317,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 = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   switch (step.kind) {
     case "batchdownload": {
@@ -15316,7 +16546,7 @@ reconcilmimefilter().catch(() => {
 });
 var stitchprogress = /* @__PURE__ */ new Map();
 function stepcaptureoptions(step) {
-  return captureoptionsof(stepoptions2(step).capture);
+  return captureoptionsof(stepoptions3(step).capture);
 }
 async function blobtodataurl(blob) {
   const buffer = new Uint8Array(await blob.arrayBuffer());
@@ -15440,7 +16670,7 @@ async function encodecanvas(width, height, draw, options) {
   return canvasdataurl(canvas, options.format, options.quality);
 }
 async function capturenamefor(step, plan, kind, format) {
-  const naming = stepoptions2(step).naming;
+  const naming = stepoptions3(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);
@@ -15509,7 +16739,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 = stepoptions2(step);
+    const rawoptions = stepoptions3(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;
@@ -15546,7 +16776,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
   }
   if (step.kind === "shotelement") {
     const selector = step.target ?? "";
-    const settle2 = typeof stepoptions2(step).settle === "number" ? stepoptions2(step).settle : 150;
+    const settle2 = typeof stepoptions3(step).settle === "number" ? stepoptions3(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);
@@ -15587,7 +16817,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
     }
   }
   if (step.kind === "shotregion") {
-    const rawoptions = stepoptions2(step);
+    const rawoptions = stepoptions3(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;
@@ -15628,7 +16858,7 @@ async function executecapturestep(step, session, plan, tabid2, origin) {
     }
   }
   if (step.kind === "contactsheet") {
-    const rawoptions = stepoptions2(step);
+    const rawoptions = stepoptions3(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");
@@ -15739,7 +16969,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 = stepoptions2(step);
+  const options = stepoptions3(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.");
@@ -15998,7 +17228,7 @@ async function attachapikeys(names, origin) {
   return { headers, keys: attached };
 }
 async function executehttpstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   if (step.kind === "fetchurl") {
     const request = fetchrequestof(options.fetch);
@@ -16263,7 +17493,7 @@ async function closechannelsforrun(runid) {
   channelbuses.clear();
 }
 async function executesocketstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   if (step.kind === "opensocket") {
     const channel = channeloptionsof(options.socket);
@@ -16397,7 +17627,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 = stepoptions2(step);
+  const options = stepoptions3(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 : {};
@@ -16549,7 +17779,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 = stepoptions2(step);
+  const options = stepoptions3(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 };
@@ -16704,7 +17934,7 @@ function pauseframes(entry) {
   });
 }
 async function executecdpstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(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.");
@@ -16938,7 +18168,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 = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   const targets = profiletargetsof(options);
   const grants = await memory.getdebuggergrants();
@@ -17267,7 +18497,7 @@ async function controlledfetch(runid, url, init, controller, window2, streamstat
   return response;
 }
 async function executenetcontrolstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id };
   const ruleset = rulesetof(plan.id);
   if (step.kind === "blockrequest") {
@@ -17514,7 +18744,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, stepoptions2(step).reviewed === true);
+  const gate = windowclosegate(count, stepoptions3(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 });
 }
@@ -17600,7 +18830,7 @@ async function revertemulationforrun(runid, reason, tabid2) {
   }
 }
 async function executeemulationstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   const revertplan = revertplanof(options.revertplan) ?? [];
   const family = familyofkind(step.kind) ?? "device";
@@ -17732,7 +18962,7 @@ async function performrestore(record2, restore, session) {
   return { restored, skippedorigins: grantscheck.skippedorigins };
 }
 async function executesessionstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(step);
   const extra = { sessionid: session.id, planid: plan.id, stepid: step.id };
   if (step.kind === "persiststate") {
     const progress = await memory.getprogress();
@@ -17877,7 +19107,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 = stepoptions2({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions3({ 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);
@@ -17924,7 +19154,7 @@ async function sleepreviewed(sampled, stepid) {
   return "timer";
 }
 async function executewaitelement(step, tabid2) {
-  const options = stepoptions2({ 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 = 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 wait = waitof(options.wait, step.target);
   const startedat = Date.now();
   const starttab = await chrome.tabs.get(tabid2).catch(() => void 0);
@@ -17952,7 +19182,7 @@ function waitof(value, target) {
   return { selector, timeout, poll };
 }
 async function executecomputestep(step, session) {
-  const options = stepoptions2({ id: step.id, kind: step.kind, summary: step.label, risk: "read", ...step.options !== void 0 ? { options: step.options } : {} });
+  const options = stepoptions3({ 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);
@@ -17961,7 +19191,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 = stepoptions2({ 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 = 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 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 ?? "";
@@ -17974,7 +19204,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 = stepoptions2(step);
+  const options = stepoptions3(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.");
@@ -18030,7 +19260,7 @@ function workflowstepofentry(value) {
   return blockinvocationof(value);
 }
 async function executeworkflowrun(step, session, plan, tabid2, origin, dry) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(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"}.`);
@@ -18193,7 +19423,7 @@ async function storetimeoutabort(run, step, message, budget) {
   return { run: aborted, log: [entry] };
 }
 async function executetriggerstep(step, session, plan, tabid2, origin) {
-  const options = stepoptions2(step);
+  const options = stepoptions3(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 : "";
@@ -18394,6 +19624,34 @@ async function executestep(stepid) {
 async function executeaction(step, session, plan, tabid2, origin, settings, verdicts, mode) {
   const gate = canexecute({ session, plan, step, tabid: tabid2, origin, ...verdicts !== void 0 && verdicts.length > 0 ? { verdicts } : {}, ...settings !== void 0 ? { settings } : {} });
   if (!gate.allowed) throw new Error(gate.reason);
+  const environmentverdict = stepenvironmentvalid(step);
+  if (!environmentverdict.allowed) throw new Error(environmentverdict.reason);
+  const environmentgrantverdict = environmentgrantgate(step, session?.environmentgrants);
+  if (!environmentgrantverdict.allowed) throw new Error(environmentgrantverdict.reason);
+  const offgranted = await offscreengranted();
+  const routing = routeenvironment(step, { offload: settings?.parseoffload === true, granted: offgranted });
+  const capabilityverdict = offscreencapabilitygate({ environment: routing.environment, granted: offgranted });
+  if (!capabilityverdict.allowed) throw new Error(capabilityverdict.reason);
+  if (routing.fallback && plan) await audit("environment", `The ${step.kind} step ${step.id} fell back to inline parsing inside the page because the offscreen capability grant stays absent.`, { ...session ? { sessionid: session.id } : {}, planid: plan.id, stepid: step.id });
+  const securityverdict = await securitystepgate(step, session, origin, settings);
+  if (!securityverdict.allowed) {
+    if (session && plan) {
+      await memory.setprogress(recorddenied(await memory.getprogress(), plan.id, step.id, deniedevidenceof({ origin, kind: step.kind, reason: securityverdict.reason, now: Date.now() }), Date.now())).catch(() => {
+      });
+      await appendrunevent("deny", `The ${step.kind} step ${step.id} on ${origin} was denied without navigation: ${securityverdict.reason}`, session, origin, step.id).catch(() => {
+      });
+    }
+    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 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);
+  }
+  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);
   const capability = requiredcapability(step.kind);
   if (capability) {
     const granted = await chrome.permissions.contains({ permissions: [capability] });
@@ -18481,8 +19739,12 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
     return output;
   };
   const runplan = plan;
+  const isolatedresult = routing.environment === "isolatedworld" ? await executeisolatedevaluate(step, tabid2, origin) : void 0;
+  let workerturnaround;
   const capturepolicystate = await runcapturepolicy();
-  if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
+  if (isolatedresult !== void 0) {
+    output = isolatedresult;
+  } else if (capturepolicystate === "beforeafter" && session && step.risk !== "read" && beforeafterwrapallowed(step.kind)) {
     const before = await grabstateshot(step, session, runplan, tabid2, "before");
     output = await dispatchreviewedstep();
     if (output?.ok) {
@@ -18498,8 +19760,14 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   } else {
     output = await dispatchreviewedstep();
   }
+  if (routing.environment === "offscreenworker" && workerturnaround === void 0) {
+    const offloaded = await offloadparsetoworker(step, output, session, plan, origin);
+    output = offloaded.output ?? output;
+    workerturnaround = offloaded.turnaround;
+  }
   if (["navigate", "back", "forward"].includes(step.kind)) await recordnavigation(step, session, tabid2);
   await recordevidence(step, output, session, plan, origin);
+  await recordstepenvironment(step, routing.environment, session, plan, origin, workerturnaround);
   if (output?.ok && plan && typeof output.details?.tabid === "number") {
     await memory.setprogress(assigntasktab(await memory.getprogress(), plan.id, output.details.tabid, Date.now()));
   }
@@ -18508,10 +19776,13 @@ async function executeaction(step, session, plan, tabid2, origin, settings, verd
   if (resolved) {
     await memory.addresolution({ stepid: step.id, mode: resolved.mode, selector: resolved.selector, label: resolved.label, at: Date.now() });
   }
-  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, ...output?.details ? { details: output.details } : {}, at: Date.now() };
+  const maskshapes = shapesof({ ...settings !== void 0 ? { settings } : {}, rules: await memory.getmaskrules(), origin });
+  const outcome = { stepid: step.id, ok: Boolean(output?.ok), summary, environment: routing.environment, ...output?.details ? { details: maskexport(output.details, maskshapes) } : {}, at: Date.now() };
   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) 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") {
     const base = await memory.getprogress();
     const completed = watchwindow ? recordwatchcompletion(base, plan.id, step.id, watchwindow.startedat, watchwindow.lifetime, Date.now()) : recordstep(base, plan.id, step.id, Date.now());
@@ -18540,6 +19811,7 @@ 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 audit("complete", "Every reviewed step of the approved plan has executed.", { ...session ? { sessionid: session.id } : {}, planid: done.id });
     }
   }
@@ -18553,7 +19825,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 && !stepoptions2(step).targetref) throw new Error("Only a target-based step can be previewed.");
+  if (!step.target && !stepoptions3(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.");
@@ -18725,7 +19997,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() };
+      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() };
     }
     case "capabilities":
       return refreshcapabilities();
@@ -19780,7 +21052,11 @@ async function handlerequest(message, sender) {
         });
         activerecordings.delete(id);
       }
-      if (session) await memory.setsession({ ...session, stoppedat: Date.now() });
+      if (session) {
+        await memory.setsession({ ...session, stoppedat: Date.now() });
+        await sealsessionrunlog(session.id).catch(() => {
+        });
+      }
       const plan = await memory.getplan();
       if (plan && ["pending", "approved"].includes(plan.state)) await memory.setplan({ ...plan, state: "cancelled" });
       await audit("stop", "The user stopped the browser session.", { ...session ? { sessionid: session.id } : {}, ...plan ? { planid: plan.id } : {} });
@@ -21772,6 +23048,303 @@ 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 "security": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const settings = await memory.getsettings();
+      if (input2.allowlist !== void 0) {
+        if (input2.allowlist.add !== void 0) {
+          const origin = input2.allowlist.add.origin?.trim() ?? "";
+          if (origin === "") throw new Error("The allowlist grant needs its exact origin.");
+          if (wildcardentry(origin)) throw new Error("The allowlist binds every grant to one exact origin; a wildcard entry never passes.");
+          await memory.addallowlistorigin({ origin, profileid: runstateprofile, grantedat: now });
+          await audit("grant", `The user added the exact origin ${origin} to the automation allowlist of the profile workspace; no wildcard expansion exists.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), granted: origin };
+        }
+        if (input2.allowlist.remove !== void 0) {
+          const origin = input2.allowlist.remove.origin?.trim() ?? "";
+          await memory.removeallowlistorigin(origin, runstateprofile);
+          await audit("revoke", `The user removed the origin ${origin} from the automation allowlist; the denydefault posture refuses the origin again.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removed: origin };
+        }
+      }
+      if (input2.profile !== void 0) {
+        const origin = input2.profile.origin?.trim() ?? session?.origin ?? "";
+        const kind = input2.profile.kind?.trim() ?? "";
+        const decision = input2.profile.decision === "deny" ? "deny" : "grant";
+        if (origin === "" || kind === "") throw new Error("The origin profile decision needs its exact origin and its action kind.");
+        const profiles = await memory.getoriginprofiles();
+        const existing = profiles.find((candidate) => candidate.origin === origin);
+        const updated = profilekind({ profile: existing ?? originprofileof({ origin, now }), kind, decision, now });
+        await memory.saveoriginprofile(updated);
+        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 };
+      }
+      if (input2.consent !== void 0) {
+        if (input2.consent.open !== void 0) {
+          if (!session) throw new Error("The consent window opens inside an active session.");
+          const duration = input2.consent.open.duration ?? settings?.consentduration;
+          if (duration === void 0) throw new Error("The consent prompt needs its duration in milliseconds; no grant ever defaults to unlimited.");
+          const durationgate = consentdurationvalid(duration);
+          if (!durationgate.allowed) throw new Error(durationgate.reason);
+          const origin = input2.consent.open.origin?.trim() !== "" && input2.consent.open.origin !== void 0 ? input2.consent.open.origin.trim() : session.origin;
+          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 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 });
+          return { ...await securityviewof(), window: window2 };
+        }
+        if (input2.consent.renew !== void 0) {
+          if (!session) throw new Error("The consent window renewal opens inside an active session.");
+          const windowid = input2.consent.renew.windowid?.trim() ?? "";
+          const current = (await memory.getconsentwindows()).find((candidate) => candidate.id === windowid && candidate.sessionid === session.id);
+          if (!current) throw new Error(`No consent window ${windowid} exists for the session.`);
+          const duration = input2.consent.renew.duration ?? settings?.consentduration;
+          if (duration === void 0) throw new Error("The renewal prompt needs its duration in milliseconds; a renewal only runs through a new explicit prompt.");
+          const durationgate = consentdurationvalid(duration);
+          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 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 });
+          return { ...await securityviewof(), window: renewed };
+        }
+        if (input2.consent.classes !== void 0) {
+          const origin = input2.consent.classes.origin?.trim() || session?.origin || "";
+          const classes = (input2.consent.classes.classes ?? []).map((kind) => kind.trim()).filter((kind) => kind !== "");
+          if (origin === "" || classes.length === 0) throw new Error("The fresh class consent needs its origin and its sensitive classes.");
+          for (const classname of classes) {
+            await memory.addclassconsent({ id: randomid(), origin, sensitiveclass: classname, grantedat: now });
+            await audit("grant", `The user gave one fresh consent prompt for the ${classname} class on ${origin}; the prompt of one class never widens another.`, { ...session ? { sessionid: session.id } : {} });
+          }
+          return { ...await securityviewof(), classes };
+        }
+      }
+      if (input2.revoke !== void 0) {
+        if (!session) throw new Error("The revocation needs its active session.");
+        const plan2 = await memory.getplan();
+        const runid = input2.revoke.runid?.trim() || plan2?.id || "";
+        if (runid === "") throw new Error("The revocation needs its run.");
+        const state = await memory.getrunstate(runstateprofile);
+        const pendingstepid = state?.pendingstepid;
+        const progress = await memory.getprogress();
+        const completed = new Set(progress?.planid === runid ? progress.completedsteps : []);
+        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);
+        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(() => {
+        });
+        await audit("revoke", `The user revoked the run ${runid} mid step: ${revocation.haltedstepids.length} step${revocation.haltedstepids.length === 1 ? "" : "s"} halted without executing, and the run log records the terminal event.`, { sessionid: session.id, planid: runid, ...pendingstepid !== void 0 ? { stepid: pendingstepid } : {} });
+        return { ...await securityviewof(), revocation };
+      }
+      if (input2.mask !== void 0) {
+        if (input2.mask.add !== void 0) {
+          const shapes = (input2.mask.add.shapes ?? []).map((shape) => shape.trim().toLowerCase()).filter((shape) => shape !== "");
+          if (shapes.length === 0) throw new Error("The mask rule needs its field shapes.");
+          const rule = { id: randomid(), ...input2.mask.add.origin !== void 0 && input2.mask.add.origin.trim() !== "" ? { origin: input2.mask.add.origin.trim() } : {}, shapes, createdat: now };
+          await memory.addmaskrule(rule);
+          await audit("mask", `The user added the mask rule ${rule.id} for the ${shapes.join(", ")} field shape${shapes.length === 1 ? "" : "s"}${rule.origin !== void 0 ? ` scoped to ${rule.origin}` : ""}; typed values behind the shapes never reach a record.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), rule };
+        }
+        if (input2.mask.remove !== void 0) {
+          const id = input2.mask.remove.id?.trim() ?? "";
+          await memory.removemaskrule(id);
+          await audit("mask", `The user removed the mask rule ${id}.`, { ...session ? { sessionid: session.id } : {} });
+          return { ...await securityviewof(), removed: id };
+        }
+      }
+      if (input2.read !== void 0) {
+        const runid = input2.read.runid?.trim() || session?.id || "";
+        const log = await memory.getimmutablelog(runid);
+        if (!log) throw new Error(`No run log exists for the run ${runid}.`);
+        const read = await readverifiedlog(log);
+        const readgate = logreadgate({ valid: read.ok });
+        if (!readgate.allowed) throw new Error(readgate.reason);
+        await audit("consent", `The run log of ${runid} was read through the audit accessor with ${read.entries.length} verified entries: ${read.reason}`, { ...session ? { sessionid: session.id } : {}, planid: runid });
+        return { ...await securityviewof(), log: read.entries, verification: read.reason };
+      }
+      if (input2.export !== void 0) {
+        const runid = input2.export.runid?.trim() || session?.id || "";
+        const exported = await memory.exportverifiedrunlog(runid);
+        if (!exported.chainvalid) throw new Error(exported.reason);
+        await audit("export", `The verified run log of ${runid} was exported as an audit file with ${exported.entries} entries${exported.sealhash !== void 0 ? ` and the seal hash ${exported.sealhash}` : ""}: ${exported.reason}`, { ...session ? { sessionid: session.id } : {}, planid: runid });
+        return { ...await securityviewof(), export: exported };
+      }
+      if (input2.settings !== void 0) {
+        const patch = { ...settings };
+        if (input2.settings.consentduration !== void 0) {
+          const durationgate = consentdurationvalid(input2.settings.consentduration);
+          if (!durationgate.allowed) throw new Error(durationgate.reason);
+          patch.consentduration = input2.settings.consentduration;
+        }
+        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 !== "");
+        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 };
+      }
+      const plan = await memory.getplan();
+      const pending = [];
+      if (session && plan && ["pending", "approved"].includes(plan.state)) {
+        for (const step of plan.steps) {
+          const classification = sensitiveclassesof(step);
+          if (!classification.sensitive) continue;
+          const missing = classification.classes.length > 0 ? classification.classes : [];
+          if (missing.length === 0 && !classification.bydefault) continue;
+          pending.push({ stepid: step.id, kind: step.kind, origin: plan.origin, prompt: consentprompttext({ origin: plan.origin, kind: step.kind, classes: classification.classes, bydefault: classification.bydefault, duration: settings?.consentduration ?? session.expiresat - now }) });
+        }
+      }
+      return { ...await securityviewof(), prompts: pending };
+    }
+    case "environments": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const settings = await memory.getsettings();
+      if (input2.requestcapability === true) {
+        const granted = await requestoffscreengrant();
+        await audit("environment", granted ? "The user granted the optional offscreen capability through the permissions api; the worker pool may spawn under the manifest declaration." : "The offscreen capability request stayed refused; the parse offload keeps its inline fallback inside the page.", { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), requested: granted };
+      }
+      if (input2.grants !== void 0) {
+        if (!session) throw new Error("The environment grants need an active session to join.");
+        const valid = /* @__PURE__ */ new Set(["pagecontext", "isolatedworld", "offscreenworker", "sandboxframe"]);
+        const requested = input2.grants.filter((environment) => valid.has(environment));
+        const unknown = input2.grants.filter((environment) => !valid.has(environment));
+        if (unknown.length > 0) throw new Error(`The environments ${unknown.join(", ")} sit outside the four execution environments.`);
+        await memory.setenvironmentgrants(requested);
+        await audit("environment", `The user set the environment grants of the session to ${requested.length > 0 ? requested.join(", ") : "the documented default posture"}; no step ever widens them.`, { sessionid: session.id });
+        return environmentviewof();
+      }
+      if (input2.pool !== void 0) {
+        const sizegate = workerpoolsizevalid(input2.pool.size ?? settings?.workerpoolsize);
+        if (!sizegate.allowed) throw new Error(sizegate.reason);
+        const runid = (await memory.getplan())?.id ?? "pool";
+        const current = workerpoolcounts.get(runid) ?? 0;
+        const plan = poolplan({ pending: input2.pool.pending ?? 0, current, ...input2.pool.size !== void 0 ? { size: input2.pool.size } : {} });
+        workerpoolcounts.set(runid, plan.workers);
+        const provenance = { origin: session?.origin ?? "", stepid: "", environment: "offscreenworker" };
+        await memory.addworkerevent({ id: randomid(), runid, kind: plan.added > 0 ? "spawn" : "teardown", workers: plan.workers, reason: plan.reason, provenance, at: now });
+        await audit("worker", `The worker pool of the run ${runid} holds ${plan.workers} worker${plan.workers === 1 ? "" : "s"}: ${plan.reason}`, { ...session ? { sessionid: session.id } : {} });
+        return { ...await environmentviewof(), pool: plan };
+      }
+      if (input2.offscreenclose === true) {
+        const runid = (await memory.getplan())?.id ?? "pool";
+        await closeoffscreendocument(runid);
+        return environmentviewof();
+      }
+      if (input2.settings !== void 0) {
+        const patch = { ...settings };
+        if (input2.settings.parseoffload !== void 0) patch.parseoffload = input2.settings.parseoffload === true;
+        if (input2.settings.workerpoolsize !== void 0) {
+          const sizegate = workerpoolsizevalid(input2.settings.workerpoolsize);
+          if (!sizegate.allowed) throw new Error(sizegate.reason);
+          patch.workerpoolsize = input2.settings.workerpoolsize;
+        }
+        if (input2.settings.sandboxorigins !== void 0) patch.sandboxorigins = input2.settings.sandboxorigins.map((origin) => origin.trim()).filter((origin) => origin !== "");
+        if (input2.settings.keepaliveinterval !== void 0) {
+          const intervalgate = keepaliveintervalvalid(input2.settings.keepaliveinterval);
+          if (!intervalgate.allowed) throw new Error(intervalgate.reason);
+          patch.keepaliveinterval = input2.settings.keepaliveinterval;
+        }
+        if (input2.settings.zombieintervals !== void 0) patch.zombieintervals = input2.settings.zombieintervals;
+        if (input2.settings.runstateretention !== void 0) patch.runstateretention = input2.settings.runstateretention;
+        if (input2.settings.runstatebytes !== void 0) patch.runstatebytes = input2.settings.runstatebytes;
+        await memory.setsettings(patch);
+        await audit("environment", `The user updated the environment settings: parse offload ${patch.parseoffload === true ? "on" : "off"}, worker pool size ${patch.workerpoolsize ?? "queue driven"}, sandbox origins ${patch.sandboxorigins?.length ?? 0} configured, keepalive interval ${patch.keepaliveinterval ?? "the roadmap thirty seconds"}, zombie tolerance ${patch.zombieintervals ?? "the roadmap three intervals"}.`, {});
+        return environmentviewof();
+      }
+      if (input2.render !== void 0) {
+        const result = await executesandboxrender({ id: input2.render.stepid ?? randomid(), kind: "setattribute", summary: "Render untrusted markup inside the sandbox frame.", risk: "sensitive", ...input2.render.markup !== void 0 ? { value: input2.render.markup } : {}, options: JSON.stringify({ markup: input2.render.markup ?? "", ...input2.render.origin !== void 0 ? { sourceorigin: input2.render.origin } : {} }) }, session, await memory.getplan(), input2.render.origin ?? session?.origin ?? "");
+        return { ...await environmentviewof(), render: result };
+      }
+      return environmentviewof();
+    }
+    case "runstate": {
+      const input2 = message;
+      const now = Date.now();
+      const session = await memory.getsession();
+      const plan = await memory.getplan();
+      const settings = await memory.getsettings();
+      const states = await memory.listrunstates();
+      if (input2.start === true) {
+        if (!session || !plan) throw new Error("The run state opens behind an active session with an approved plan.");
+        const gate = keepalivegate({ session, plan, now });
+        if (!gate.allowed) throw new Error(gate.reason);
+        await openplanrun(session, plan);
+        return { ...await environmentviewof(), opened: plan.id };
+      }
+      if (input2.stop === true) {
+        const open = states.find((state) => state.keepalive.state === "active");
+        if (open) await closeplanrun(open.runid, open.sessionid);
+        return environmentviewof();
+      }
+      if (input2.beat === true) {
+        await keepalivetick();
+        return environmentviewof();
+      }
+      if (input2.recover === true) {
+        const open = states.find((state) => state.keepalive.state === "active" || state.state === "recovered");
+        if (!open) throw new Error("No interrupted run waits for its recovery.");
+        const recovery = recoveryplan(open);
+        await memory.setrunstate(open.profileid, reattachrun(open, now));
+        await audit("environment", recovery.reason, { sessionid: open.sessionid });
+        if (recovery.recoverable && recovery.pendingstepid !== void 0 && plan && plan.id === open.planid && plan.state === "approved") {
+          const outcome = await executestep(recovery.pendingstepid);
+          return { ...await environmentviewof(), recovery, resumed: outcome.summary };
+        }
+        return { ...await environmentviewof(), recovery };
+      }
+      if (input2.reap === true) {
+        const swept = zombiesweep({ states, now, interval: settings?.keepaliveinterval ?? roadmapheartbeat, missedlimit: settings?.zombieintervals ?? roadmapzombieintervals });
+        for (const state of swept.states) await memory.setrunstate(state.profileid, state);
+        for (const runid of swept.reaped) await closeoffscreendocument(runid);
+        if (swept.reaped.length > 0) await audit("environment", `The user reaped the zombie run${swept.reaped.length === 1 ? "" : "s"} ${swept.reaped.join(", ")} from the popup warning.`, {});
+        return { ...await environmentviewof(), reaped: swept.reaped };
+      }
+      if (input2.lock !== void 0) {
+        if (input2.lock.acquire !== void 0) {
+          if (!session) throw new Error("The run lock needs its active session.");
+          const runid = input2.lock.acquire.runid?.trim() ?? plan?.id ?? "";
+          const outcome = acquirerunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid, holder: input2.lock.acquire.holder?.trim() ?? "user", ...input2.lock.acquire.expiresat !== void 0 ? { expiresat: input2.lock.acquire.expiresat } : {}, now });
+          if (!outcome.acquired) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+        if (input2.lock.release !== void 0) {
+          if (!session) throw new Error("The run lock release needs its active session.");
+          const outcome = releaserunlock({ locks: await memory.getrunlocks(), sessionid: session.id, runid: input2.lock.release.runid?.trim() ?? plan?.id ?? "", now });
+          if (!outcome.released) throw new Error(outcome.reason);
+          await memory.setrunlocks(outcome.locks);
+          await audit("environment", outcome.reason, { sessionid: session.id });
+          return { ...await environmentviewof(), lock: outcome.reason };
+        }
+      }
+      if (input2.serialize !== void 0) {
+        const branches = (input2.serialize.branches ?? []).map((branch) => ({ branchid: branch.branchid?.trim() ?? "", steps: (branch.steps ?? []).filter((step) => step.stepid !== void 0 && step.tabid !== void 0).map((step) => ({ stepid: step.stepid, tabid: step.tabid })) })).filter((branch) => branch.branchid !== "");
+        const order = serializesteps({ branches });
+        await audit("environment", `The executor serialized ${order.length} step${order.length === 1 ? "" : "s"} across parallel branches so steps sharing one tab never run inside the same beat; every other step keeps its branch order.`, {});
+        return { order };
+      }
+      if (input2.export === true) {
+        const exported = await memory.exportrunstates();
+        await audit("environment", `The run states were exported as one audit record: ${exported.runs} run${exported.runs === 1 ? "" : "s"}, ${exported.urls} url entr${exported.urls === 1 ? "y" : "ies"}, ${exported.environments} environment record${exported.environments === 1 ? "" : "s"} and ${exported.offloaded} worker turnaround${exported.offloaded === 1 ? "" : "s"}.`, {});
+        return { export: exported, states: states.map((state) => ({ runid: state.runid, sessionid: state.sessionid, state: state.state, beats: state.keepalive.beats, lastbeatat: state.keepalive.lastbeatat, pendingstepid: state.pendingstepid, urlhistory: state.urlhistory, environments: state.environments, turnarounds: state.turnarounds })) };
+      }
+      if (input2.profileid !== void 0) {
+        const state = await memory.getrunstate(input2.profileid);
+        if (!state) throw new Error(`No run state exists for the profile ${input2.profileid}.`);
+        return { state };
+      }
+      return environmentviewof();
+    }
     default:
       throw new Error("Unknown Devthink request.");
   }
@@ -22073,7 +23646,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 = stepoptions2(step);
+  const options = stepoptions3(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;
@@ -22448,7 +24021,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 = stepoptions2(step);
+  const options = stepoptions3(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);
@@ -22565,6 +24138,10 @@ setInterval(() => {
   void evaluatelistedtriggers().then(() => draintriggerqueue()).then(() => runwatchdog()).then(() => restorebackgroundruns()).catch(() => {
   });
 }, 3e4);
+setInterval(() => {
+  void keepalivetick().catch(() => {
+  });
+}, roadmapheartbeat);
 async function restoretriggers() {
   await registermenurules();
   await evaluatelistedtriggers();
@@ -22576,4 +24153,6 @@ async function restoretriggers() {
 }
 restoretriggers().catch(() => {
 });
+restorerunstates().catch(() => {
+});
 //# sourceMappingURL=background.js.map