@wenathlan/extension 1.1.62 → 1.1.63

package/dist/index.js

@@ -5000,6 +5000,212 @@ var sessionmemory = class {
       phishverdicts: await this.getphishverdicts()
     };
   }
+  /**
+   * Session interface persistence of the 1.1.63 family.
+   * The five session stores live here, scoped per profile workspace: the sitenotes per origin with sensitive bodies sealed at rest, the append only scratchpad entries per task with their step provenance, the distilled runsummaries per run and origin, the correctionmemory entries per origin and kind captured from plan review, and the consentmemory entries per origin with every grant, denial, expiry and revocation carrying its boundary; beside them the semanticrecall index with fingerprint deduplication answers ranked queries inside the run scope, the incremental historysearch corpus indexes session metadata, notes and summaries as they are written, the errorsurface payloads of failed steps keep their retry hints with the policy verdict, the per tab session references isolate parallel tabs, and the export bundles notes, summaries and corrections as one audit bundle.
+   * The recall seam stays documented: the local fingerprint index answers every query today while a future remote recall backend can take the same shapes behind the seam without touching the callers.
+   */
+  /** Replaces the stored site notes; a sensitive note carries its sealedbody only so the plain body never persists. */
+  async setsitenotes(notes) {
+    return this.adapter.set("sitenotes", notes);
+  }
+  /** Returns the stored site notes, oldest update first. */
+  async getsitenotes() {
+    return await this.adapter.get("sitenotes") ?? [];
+  }
+  /** Reads the site notes of one origin only; the read gate keeps the origin inside the session grants. */
+  async readsitenotes(origin) {
+    return (await this.getsitenotes()).filter((note) => note.origin === origin);
+  }
+  /** Writes one site note: a note of the same id keeps its latest edit while a new note joins the store. */
+  async writesitenote(note) {
+    const notes = await this.getsitenotes();
+    await this.setsitenotes(notes.some((candidate) => candidate.id === note.id) ? notes.map((candidate) => candidate.id === note.id ? note : candidate) : [...notes, note]);
+  }
+  /** Removes one site note by its id. */
+  async removesitenote(id) {
+    await this.setsitenotes((await this.getsitenotes()).filter((note) => note.id !== id));
+  }
+  /** Expires the site notes past the user configured window; an absent window keeps every note. */
+  async expiresitenotes(retention, now) {
+    if (retention === void 0) return await this.getsitenotes();
+    const kept = (await this.getsitenotes()).filter((note) => now - note.updatedat < retention);
+    await this.setsitenotes(kept);
+    return kept;
+  }
+  /** Replaces the stored scratchpad entries per task. */
+  async setscratchpad(entries) {
+    return this.adapter.set("scratchpad", entries);
+  }
+  /** Returns every stored scratchpad entry, newest first. */
+  async getscratchpadall() {
+    return await this.adapter.get("scratchpad") ?? [];
+  }
+  /** Appends one scratchpad entry: the pad stays append only so no later write rewrites an earlier entry. */
+  async appendscratchentry(entry) {
+    await this.setscratchpad([entry, ...await this.getscratchpadall()]);
+  }
+  /** Reads the scratchpad of one task session, newest first; entries of another task never cross the boundary. */
+  async readscratchpad(taskid, sessionid) {
+    return (await this.getscratchpadall()).filter((entry) => entry.taskid === taskid && entry.sessionid === sessionid);
+  }
+  /** Prunes the scratchpad entries past the user configured window; an absent window keeps every entry. */
+  async prunescratchentries(window, now) {
+    if (window === void 0) return await this.getscratchpadall();
+    const kept = (await this.getscratchpadall()).filter((entry) => now - entry.at < window);
+    await this.setscratchpad(kept);
+    return kept;
+  }
+  /** Stores one distilled run summary of a completed run. */
+  async setrunsummary(summary) {
+    return this.adapter.set(`runsummary:${summary.runid}`, summary);
+  }
+  /** Returns the stored run summary of one run; an absent summary returns undefined. */
+  async getrunsummary(runid) {
+    return this.adapter.get(`runsummary:${runid}`);
+  }
+  /** Lists the stored run summaries, oldest distillation first, optionally filtered by origin. */
+  async listrunsummaries(origin) {
+    const index = await this.adapter.get("runsummaryindex") ?? [];
+    const summaries = [];
+    for (const runid of index) {
+      const summary = await this.getrunsummary(runid);
+      if (summary) summaries.push(summary);
+    }
+    const filtered = origin === void 0 ? summaries : summaries.filter((summary) => summary.origins.includes(origin));
+    return filtered.sort((one, two) => one.distilledat - two.distilledat);
+  }
+  /** Tracks one run in the run summary index so the listing reads every stored summary. */
+  async trackrunsummary(runid) {
+    const index = await this.adapter.get("runsummaryindex") ?? [];
+    if (!index.includes(runid)) await this.adapter.set("runsummaryindex", [...index, runid]);
+  }
+  /** Expires the run summaries past the user configured window; an absent window keeps every summary. */
+  async expirerunsummaries(retention, now) {
+    const summaries = await this.listrunsummaries();
+    if (retention === void 0) return summaries;
+    const kept = [];
+    for (const summary of summaries) {
+      if (now - summary.distilledat > retention) await this.adapter.set(`runsummary:${summary.runid}`, { ...summary, steps: [], kinds: [], origins: summary.origins });
+      else kept.push(summary);
+    }
+    return kept;
+  }
+  /** Replaces the semantic recall index with its fingerprint deduplicated entries. */
+  async setrecallindex(index) {
+    return this.adapter.set("recallindex", index);
+  }
+  /** Returns the stored semantic recall index entries, newest first. */
+  async getrecallindex() {
+    return await this.adapter.get("recallindex") ?? [];
+  }
+  /** Adds one recall index entry with fingerprint deduplication: a repeated extraction keeps its first entry. */
+  async addrecallentry(entry) {
+    const index = await this.getrecallindex();
+    if (index.some((candidate) => candidate.fingerprint === entry.fingerprint && candidate.origin === entry.origin)) return;
+    await this.setrecallindex([entry, ...index]);
+  }
+  /** Answers one semantic recall query across the extraction stores: the local index ranks by text similarity inside the run scope and returns the provenance of every match. */
+  async semanticrecall(query, scope, rank) {
+    return rank(await this.getrecallindex(), query, scope);
+  }
+  /** Expires the recall index entries past the user configured window; the extraction records themselves stay for the audit trail. */
+  async expirerecallentries(window, now) {
+    if (window === void 0) return await this.getrecallindex();
+    const kept = (await this.getrecallindex()).filter((entry) => now - entry.at < window);
+    await this.setrecallindex(kept);
+    return kept;
+  }
+  /** Replaces the stored correction memory entries per origin and kind. */
+  async setcorrections(corrections) {
+    return this.adapter.set("corrections", corrections);
+  }
+  /** Returns the stored correction memory entries, newest first, optionally filtered by origin and kind. */
+  async getcorrections(filter) {
+    const entries = await this.adapter.get("corrections") ?? [];
+    return entries.filter((entry) => (filter?.origin === void 0 || entry.origin === filter.origin) && (filter?.kind === void 0 || entry.kind === filter.kind));
+  }
+  /** Records one correction memory entry captured from a plan review edit or rejection. */
+  async addcorrection(entry) {
+    await this.setcorrections([entry, ...await this.adapter.get("corrections") ?? []]);
+  }
+  /** Expires the correction memory entries past the user configured window; an absent window keeps every correction. */
+  async expirecorrectionentries(window, now) {
+    if (window === void 0) return await this.getcorrections();
+    const kept = (await this.getcorrections()).filter((entry) => now - entry.at < window);
+    await this.setcorrections(kept);
+    return kept;
+  }
+  /** Replaces the stored consent memory entries per origin. */
+  async setconsentmemory(entries) {
+    return this.adapter.set("consentmemory", entries);
+  }
+  /** Returns the stored consent memory entries, newest first, optionally filtered by origin. */
+  async getconsentmemory(origin) {
+    const entries = await this.adapter.get("consentmemory") ?? [];
+    return origin === void 0 ? entries : entries.filter((entry) => entry.origin === origin);
+  }
+  /** Records one consent memory entry per origin: every grant, denial, expiry and revocation lands with its boundary and kinds. */
+  async addconsentmemoryentry(entry) {
+    await this.setconsentmemory([entry, ...await this.adapter.get("consentmemory") ?? []]);
+  }
+  /** Replaces the stored error surface payloads of failed steps. */
+  async seterrorsurfaces(surfaces) {
+    return this.adapter.set("errorsurfaces", surfaces);
+  }
+  /** Returns the stored error surface payloads, newest first, optionally filtered by step. */
+  async geterrorsurfaces(stepid) {
+    const surfaces = await this.adapter.get("errorsurfaces") ?? [];
+    return stepid === void 0 ? surfaces : surfaces.filter((surface) => surface.stepid === stepid);
+  }
+  /** Records one error surface payload of a failed step with its retry hint and the policy verdict. */
+  async adderrorsurface(surface) {
+    await this.seterrorsurfaces([surface, ...await this.adapter.get("errorsurfaces") ?? []].slice(0, 500));
+  }
+  /** Replaces the incremental history search corpus of session metadata, notes and run summaries. */
+  async sethistoryindex(corpus) {
+    return this.adapter.set("historyindex", corpus);
+  }
+  /** Returns the incremental history search corpus, newest entry first. */
+  async gethistoryindex() {
+    return await this.adapter.get("historyindex") ?? [];
+  }
+  /** Adds one corpus entry to the incremental history index on each store write. */
+  async addhistoryentry(entry) {
+    const corpus = await this.gethistoryindex();
+    await this.sethistoryindex([entry, ...corpus.filter((candidate) => !(candidate.source === entry.source && candidate.id === entry.id))]);
+  }
+  /** Answers one history search query against the incremental corpus with the matched terms highlighted. */
+  async historysearch(query, search) {
+    return search(await this.gethistoryindex(), query);
+  }
+  /** Stores one per tab session reference so parallel tabs never collide inside the session stores. */
+  async settabsession(ref) {
+    return this.adapter.set(`tabsession:${ref.tabid}`, ref);
+  }
+  /** Returns the per tab session reference of one tab; an absent reference returns undefined. */
+  async gettabsession(tabid) {
+    return this.adapter.get(`tabsession:${tabid}`);
+  }
+  /** Lists every per tab session reference so the sessiongrid reads the per tab lock state of concurrent sessions. */
+  async listtabsessions() {
+    const tabs = await this.adapter.get("tabsessionindex") ?? [];
+    const refs = [];
+    for (const tabid of tabs) {
+      const ref = await this.gettabsession(tabid);
+      if (ref) refs.push(ref);
+    }
+    return refs;
+  }
+  /** Tracks one tab in the per tab session index so the listing reads every isolated reference. */
+  async tracktabsession(tabid) {
+    const tabs = await this.adapter.get("tabsessionindex") ?? [];
+    if (!tabs.includes(tabid)) await this.adapter.set("tabsessionindex", [...tabs, tabid]);
+  }
+  /** Exports the site notes, the run summaries and the correction memory as one audit bundle: sensitive note bodies stay sealed in the export. */
+  async exportsessionbundle(exportedat) {
+    return { kind: "sessionbundle", notes: await this.getsitenotes(), summaries: await this.listrunsummaries(), corrections: await this.getcorrections(), exportedat };
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -5996,6 +6202,11 @@ function isolatedinjection(step) {
   }
   return { world: "ISOLATED", code: step.value, args };
 }
+var runsummarytask = "runsummary";
+function summaryrequestof(input) {
+  if (input.payload.trim() === "") throw new Error("The runsummary request needs its payload reference.");
+  return { id: input.id, runid: input.runid, stepid: input.sessionid, task: runsummarytask, payload: input.payload, transferables: [], sentat: input.sentat };
+}
 
 // httpclient.ts
 var httpkinds = ["fetchurl", "parsejson", "parsehtml", "callrest", "callgraphql"];
@@ -11095,6 +11306,50 @@ function untrustedrendergate(input) {
   if (input.environment === "sandboxframe") return { allowed: true, reason: "The extracted markup renders inside the sandboxframe under its nonce with scripts and handlers stripped; the untrusted content never reenters the page context." };
   return { allowed: false, reason: `The extracted markup grades untrusted and refuses to render inside the ${input.environment}; every untrusted render routes through the sandboxframe.` };
 }
+function sitenotesreadgate(input) {
+  if (input.grants.includes(input.origin)) return { allowed: true, reason: `The session granted ${input.origin}, so the site notes of the origin read.` };
+  return { allowed: false, reason: `The session never granted ${input.origin}; the site notes of the origin refuse the read.` };
+}
+function sitenoteswritegate(input) {
+  if (!input.consent) return { allowed: false, reason: `The site note write for ${input.origin} needs the explicit consent of the user; no note lands without a reviewed write.` };
+  return { allowed: true, reason: `The user consented to the site note write for ${input.origin}; the note keeps its author provenance and its timestamps.` };
+}
+function scratchpadscopegate(input) {
+  if (input.taskid !== input.entrytaskid || input.sessionid !== input.entrysessionid) return { allowed: false, reason: `The scratchpad entry belongs to the task ${input.entrytaskid} of the session ${input.entrysessionid}; the task ${input.taskid} of the session ${input.sessionid} never crosses that boundary.` };
+  return { allowed: true, reason: `The scratchpad entry belongs to the task ${input.taskid} of the session ${input.sessionid} that asks for it.` };
+}
+function memoryreadscopegate(input) {
+  if (input.phase === "planning" || input.phase === "prompting") return { allowed: true, reason: `The ${input.phase} phase reads the correction and consent memory so the proposal and the prompt carry the prior decisions.` };
+  return { allowed: false, reason: `The ${input.phase} phase reads no correction or consent memory; the history serves the planning and the prompting alone.` };
+}
+function semanticrecallscopegate(input) {
+  if (input.origin === void 0) return { allowed: true, reason: `The recall query names no origin, so it ranks the ${input.scope.length} origin${input.scope.length === 1 ? "" : "s"} of the run scope only.` };
+  if (!input.scope.includes(input.origin)) return { allowed: false, reason: `The recall query asks for ${input.origin} while the run scope holds ${input.scope.length > 0 ? input.scope.join(", ") : "no origin"}; a recall across origins outside the run scope refuses.` };
+  return { allowed: true, reason: `The recall query asks for ${input.origin} inside the run scope; the ranking stays scoped.` };
+}
+function summarywindowvalid(window) {
+  if (window === void 0) return { allowed: true, reason: "No runsummary window is configured, so the distillation keeps every step with no fixed cap." };
+  if (!Number.isInteger(window) || window < 0) return { allowed: false, reason: "The runsummary window stays a whole number of steps the user chose; no engine cap exists." };
+  return { allowed: true, reason: `The runsummary window of ${window} step${window === 1 ? "" : "s"} stays the user configured choice; no engine cap exists.` };
+}
+function sessionretentionvalid(window) {
+  if (window === void 0) return { allowed: true, reason: "No retention window is configured, so the session store keeps every record forever." };
+  if (!Number.isFinite(window) || window <= 0) return { allowed: false, reason: "The retention window stays a positive user value in milliseconds; no engine boundary expires a record." };
+  return { allowed: true, reason: `The retention window of ${window} milliseconds stays the user configured choice.` };
+}
+function consentmemoryadvisorygate(input) {
+  if (input.auto) return { allowed: false, reason: `The consent memory never auto grants: the prior decisions of ${input.latest?.origin ?? "the origin"} stay advisory and every grant needs its own prompt.` };
+  if (input.latest !== void 0 && input.latest.decision === "deny") return { allowed: true, reason: `The consent memory holds a prior denial for ${input.latest.origin} with the same weight as a grant; the prompt shows the refusal and the user decides again.` };
+  return { allowed: true, reason: "The consent memory stays advisory; the prompt opens with the prior decisions and the user decides." };
+}
+function cancelrungate(input) {
+  if (input.rollbackscope === "none") return { allowed: true, reason: `The cancelrun stops the run with no rollback; the ${input.queuedstepids.length} queued step${input.queuedstepids.length === 1 ? "" : "s"} stay as the run left them and the ${input.executedstepids.length} executed step${input.executedstepids.length === 1 ? "" : "s"} stay in the sealed log.` };
+  return { allowed: true, reason: `The cancelrun rolls the ${input.queuedstepids.length} queued step${input.queuedstepids.length === 1 ? "" : "s"} back${input.queuedstepids.length > 0 ? ` (${input.queuedstepids.join(", ")})` : ""} while the ${input.executedstepids.length} executed step${input.executedstepids.length === 1 ? "" : "s"} stay untouched in the sealed log.` };
+}
+function retrydispatchgate(input) {
+  if (!input.reviewed) return { allowed: false, reason: `The retry of the step ${input.stepid} passes only through a new reviewed dispatch; an automatic retry never bypasses the review.` };
+  return { allowed: true, reason: `The retry of the step ${input.stepid} dispatches again through the full consent gate chain: the session, the plan and the origin gates all recheck the step.` };
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -11455,7 +11710,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.62";
+var packageversion = "1.1.63";
 
 // types.ts
 var protocolversion = packageversion;
@@ -12554,6 +12809,253 @@ function vaultprompttext(entry, origin) {
   return `Use the credential ${entry.label} of ${entry.scope} on ${origin}? The value stays behind the vault and no surface ever displays it.`;
 }
 
+// sessioninterface.ts
+function textfingerprint(text2) {
+  let hash = 2166136261;
+  for (let index = 0; index < text2.length; index += 1) {
+    hash ^= text2.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function keystreambyte(id, position) {
+  let hash = 2166136261;
+  const source = `${id}:${position}`;
+  for (let index = 0; index < source.length; index += 1) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash & 255;
+}
+function sealnotebody(id, body) {
+  const sealed = Array.from(body, (character, index) => String.fromCharCode(character.charCodeAt(0) ^ keystreambyte(id, index))).join("");
+  return `sealed:${btoa(sealed)}`;
+}
+function opennotebody(id, sealedbody) {
+  if (!sealedbody.startsWith("sealed:")) return "";
+  try {
+    const sealed = atob(sealedbody.slice("sealed:".length));
+    return Array.from(sealed, (character, index) => String.fromCharCode(character.charCodeAt(0) ^ keystreambyte(id, index))).join("");
+  } catch {
+    return "";
+  }
+}
+function sitenoteof(input) {
+  if (input.origin.trim() === "") throw new Error("The site note needs its origin.");
+  if (input.title.trim() === "") throw new Error("The site note needs its title.");
+  if (input.body.trim() === "") throw new Error("The site note needs its body.");
+  const id = input.id ?? randomid();
+  if (input.sensitive === true) return { id, origin: input.origin, title: input.title.trim(), sealedbody: sealnotebody(id, input.body), author: input.author, sensitive: true, createdat: input.now, updatedat: input.now };
+  return { id, origin: input.origin, title: input.title.trim(), body: input.body, author: input.author, sensitive: false, createdat: input.now, updatedat: input.now };
+}
+function notebodyof(note) {
+  if (note.sensitive) return note.sealedbody !== void 0 ? opennotebody(note.id, note.sealedbody) : "";
+  return note.body ?? "";
+}
+function editnote(note, input) {
+  if (input.title.trim() === "") throw new Error("The site note keeps a non empty title.");
+  if (input.body.trim() === "") throw new Error("The site note keeps a non empty body.");
+  if (note.sensitive) return { ...note, title: input.title.trim(), sealedbody: sealnotebody(note.id, input.body), updatedat: input.now, author: input.author };
+  return { ...note, title: input.title.trim(), body: input.body, updatedat: input.now, author: input.author };
+}
+function expirnotes(notes, retention, now) {
+  if (retention === void 0) return notes;
+  return notes.filter((note) => now - note.updatedat < retention);
+}
+function scratchentryof(input) {
+  if (input.taskid.trim() === "") throw new Error("The scratchpad entry needs its task.");
+  if (input.text.trim() === "") throw new Error("The scratchpad entry needs its text.");
+  return { id: input.id ?? randomid(), taskid: input.taskid, sessionid: input.sessionid, text: input.text, ...input.stepid !== void 0 && input.stepid.trim() !== "" ? { stepid: input.stepid } : {}, author: input.author, at: input.now };
+}
+function scratchpadof(entries, taskid, sessionid) {
+  return entries.filter((entry) => entry.taskid === taskid && entry.sessionid === sessionid);
+}
+function prunescratchpad(entries, window, now) {
+  if (window === void 0) return entries;
+  return entries.filter((entry) => now - entry.at < window);
+}
+function distillrunsummary(input) {
+  const steps = input.outcomes.map((outcome) => {
+    const step = input.plan.steps.find((candidate) => candidate.id === outcome.stepid);
+    return { stepid: outcome.stepid, kind: step?.kind ?? "unknown", ok: outcome.ok, summary: outcome.summary };
+  });
+  const windowed = input.window !== void 0 && Number.isInteger(input.window) && input.window >= 0 ? steps.slice(Math.max(0, steps.length - input.window)) : steps;
+  const kinds = [...new Set(windowed.map((step) => step.kind))];
+  return { runid: input.plan.id, sessionid: input.sessionid, origins: [...new Set(input.origins)], kinds, steps: windowed, ...input.window !== void 0 && Number.isInteger(input.window) && input.window >= 0 ? { window: input.window } : {}, task: "runsummary", provenance: input.provenance, distilledat: input.now };
+}
+function summaryhistoryentry(summary) {
+  return { source: "summary", id: summary.runid, title: `Run summary of ${summary.runid}`, text: `${summary.origins.join(" ")} ${summary.kinds.join(" ")} ${summary.steps.map((step) => step.summary).join(" ")}`, outcome: summary.steps.every((step) => step.ok) ? "completed" : "failed", at: summary.distilledat };
+}
+function notehistoryentry(note) {
+  return { source: "note", id: note.id, ...note.origin !== "" ? { origin: note.origin } : {}, title: note.title, text: note.sensitive ? note.title : `${note.title} ${note.body ?? ""}`, at: note.updatedat };
+}
+function recallentryof(input) {
+  if (input.text.trim() === "") throw new Error("The recall index entry needs its text.");
+  if (input.stepid.trim() === "" || input.runid.trim() === "") throw new Error("The recall index entry needs its run and step provenance.");
+  const normalized = input.text.trim().replace(/\s+/g, " ");
+  return { fingerprint: textfingerprint(normalized), origin: input.origin, runid: input.runid, stepid: input.stepid, text: normalized, at: input.at };
+}
+function addrecallentry(index, entry) {
+  if (index.some((candidate) => candidate.fingerprint === entry.fingerprint && candidate.origin === entry.origin)) return index;
+  return [...index, entry];
+}
+function termsof(text2) {
+  return new Set(text2.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1));
+}
+function rankrecall(index, query, scope) {
+  if (query.text.trim() === "") return [];
+  const terms = termsof(query.text);
+  const scoped = query.origin !== void 0 && query.origin.trim() !== "" ? [query.origin] : scope.origins;
+  const matches = [];
+  for (const entry of index) {
+    if (!scoped.includes(entry.origin)) continue;
+    const entryterms = termsof(entry.text);
+    let shared = 0;
+    for (const term of terms) if (entryterms.has(term)) shared += 1;
+    const union = (/* @__PURE__ */ new Set([...terms, ...entryterms])).size;
+    const score = union === 0 ? 0 : shared / union;
+    if (score <= 0) continue;
+    matches.push({ entry, score, reason: `The extraction of ${entry.origin} shares ${shared} term${shared === 1 ? "" : "s"} with the query at the score ${score.toFixed(3)}; the match carries the run ${entry.runid} and the step ${entry.stepid}.` });
+  }
+  const ranked = matches.sort((one, two) => two.score - one.score);
+  return query.limit !== void 0 && Number.isInteger(query.limit) && query.limit >= 0 ? ranked.slice(0, query.limit) : ranked;
+}
+function expirerecallindex(index, window, now) {
+  if (window === void 0) return index;
+  return index.filter((entry) => now - entry.at < window);
+}
+function editedcorrectionof(input) {
+  if (input.stepid.trim() === "" || input.kind.trim() === "") throw new Error("The correction needs its step and kind.");
+  if (input.original === input.corrected) throw new Error("The correction needs a changed step shape.");
+  return { id: input.id ?? randomid(), origin: input.origin, kind: input.kind, stepid: input.stepid, source: "edited", original: input.original, corrected: input.corrected, reason: input.reason, at: input.now };
+}
+function rejectedcorrectionof(input) {
+  if (input.stepid.trim() === "" || input.reason.trim() === "") throw new Error("The rejected correction needs its step and its rejection reason.");
+  return { id: input.id ?? randomid(), origin: input.origin, kind: input.kind, stepid: input.stepid, source: "rejected", original: input.original, reason: input.reason, at: input.now };
+}
+function matchingcorrections(corrections, proposal) {
+  return corrections.filter((entry) => entry.origin === proposal.origin && entry.kind === proposal.kind);
+}
+function expirecorrections(corrections, window, now) {
+  if (window === void 0) return corrections;
+  return corrections.filter((entry) => now - entry.at < window);
+}
+function consentmemoryof(input) {
+  if (input.origin.trim() === "") throw new Error("The consent memory entry needs its origin.");
+  if (input.boundary.trim() === "") throw new Error("The consent memory entry needs the boundary the prompt named.");
+  return { id: input.id ?? randomid(), origin: input.origin, decision: input.decision, boundary: input.boundary, kinds: [...new Set(input.kinds)], at: input.now, ...input.expiresat !== void 0 ? { expiresat: input.expiresat } : {} };
+}
+function consentadvisory(entries, origin, now) {
+  return entries.filter((entry) => entry.origin === origin && (entry.expiresat === void 0 || entry.expiresat > now));
+}
+function consentadvisoryverdict(entries, origin, kind) {
+  const matching = entries.filter((entry) => entry.origin === origin && entry.kinds.includes(kind));
+  const latest = matching[matching.length - 1];
+  if (latest === void 0) return { advisory: false, reason: `No prior decision exists for the ${kind} kind on ${origin}; the prompt opens fresh.` };
+  if (latest.decision === "deny") return { advisory: true, reason: `The consent memory holds a prior denial of the ${kind} kind on ${origin} from ${new Date(latest.at).toISOString()}; the denial carries the same weight as a grant and the record stays advisory only.` };
+  return { advisory: true, reason: `The consent memory holds a prior ${latest.decision} of the ${kind} kind on ${origin} with the boundary ${latest.boundary}; the record advises the new prompt and never auto grants.` };
+}
+function rollbacksplit(plan, progress) {
+  const executed = progress && progress.planid === plan?.id ? progress.completedsteps : [];
+  const executedset = new Set(executed);
+  const queued = (plan?.steps ?? []).map((step) => step.id).filter((id) => !executedset.has(id));
+  return { executedstepids: executed, queuedstepids: queued };
+}
+function rollbackof(plan, progress, preference) {
+  const split = rollbacksplit(plan, progress);
+  if (preference === "none") return { scope: "none", label: `Stop the run ${plan?.id ?? ""} without a rollback; the ${split.queuedstepids.length} queued step${split.queuedstepids.length === 1 ? "" : "s"} stay as the run left them.`, queuedstepids: split.queuedstepids };
+  return { scope: "queued", label: `Cancel the run ${plan?.id ?? ""} and roll its ${split.queuedstepids.length} queued step${split.queuedstepids.length === 1 ? "" : "s"} back${split.queuedstepids.length > 0 ? ` (${split.queuedstepids.join(", ")})` : ""} while the ${split.executedstepids.length} executed step${split.executedstepids.length === 1 ? "" : "s"} stay untouched in the sealed log.`, queuedstepids: split.queuedstepids };
+}
+function cancelrunactionof(input) {
+  return { runid: input.runid, sessionid: input.sessionid, rollback: rollbackof(input.plan, input.progress, input.preference) };
+}
+function errorsurfaceof(input) {
+  if (input.message.trim() === "") throw new Error("The error surface needs its message in plain language.");
+  return { stepid: input.stepid, runid: input.runid, cause: input.cause, message: input.message, retry: { allowed: input.retryallowed, reason: input.retryreason }, context: input.context, at: input.now };
+}
+function classifyfailure(input) {
+  if (input.gatewait) return "gate";
+  if (input.policyrefused) return "policy";
+  if (/\b(network|offline|timeout|timed out|fetch failed|socket|dns|connection)\b/i.test(input.message)) return "network";
+  return "page";
+}
+function retryhintof(surface) {
+  if (!surface.retry.allowed) return { allowed: false, reason: `The ${surface.cause} failure of the step ${surface.stepid} refuses the retry: ${surface.retry.reason}` };
+  return { allowed: true, reason: `The ${surface.cause} failure of the step ${surface.stepid} may retry through a new reviewed dispatch; the retry rides the full consent gate chain and never bypasses the review.` };
+}
+function sessiongridrows(input) {
+  const rows = [];
+  if (input.session && input.plan && ["pending", "approved"].includes(input.plan.state)) {
+    const split = rollbacksplit(input.plan, input.progress);
+    const held = input.locks.some((lock) => lock.runid === input.plan?.id);
+    const origins = [.../* @__PURE__ */ new Set([input.session.origin, ...input.session.grants ?? []])];
+    const actions = ["cancelrun"];
+    if (input.session.pausedat !== void 0) actions.push("resume");
+    rows.push({ sessionid: input.session.id, runid: input.plan.id, origins, state: "live", outcome: `${split.executedstepids.length} of ${input.plan.steps.length} reviewed steps executed`, steps: input.plan.steps.length, completed: split.executedstepids.length, lock: held ? "held" : "free", tabid: input.session.tabid, updatedat: input.plan.createdat, actions });
+  }
+  for (const log of input.logs) {
+    const summary = input.summaries.find((candidate) => candidate.runid === log.runid);
+    const tabsession = input.tabsessions.find((candidate) => candidate.runid === log.runid);
+    const held = input.locks.some((lock) => lock.runid === log.runid);
+    rows.push({ sessionid: log.sessionid, runid: log.runid, origins: [...new Set(log.entries.map((entry) => entry.origin).filter((origin) => origin !== ""))], state: "saved", outcome: summary !== void 0 ? summary.steps.every((step) => step.ok) ? "completed" : "failed" : log.seal !== void 0 ? "sealed" : "open", steps: summary?.steps.length ?? log.entries.filter((entry) => entry.kind === "step").length, completed: summary?.steps.filter((step) => step.ok).length ?? log.entries.filter((entry) => entry.kind === "step").length, lock: held ? "held" : "free", ...log.seal !== void 0 ? { sealhash: log.seal.sealhash.current } : {}, ...tabsession !== void 0 ? { tabid: tabsession.tabid } : {}, updatedat: log.updatedat, actions: ["reopen"] });
+  }
+  return rows.sort((one, two) => two.updatedat - one.updatedat);
+}
+function historyqueryof(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const candidate = value;
+  if (typeof candidate.text !== "string" || candidate.text.trim() === "") return void 0;
+  const origin = typeof candidate.origin === "string" && candidate.origin.trim() !== "" ? candidate.origin.trim() : void 0;
+  const from = typeof candidate.from === "number" && Number.isFinite(candidate.from) ? candidate.from : void 0;
+  const to = typeof candidate.to === "number" && Number.isFinite(candidate.to) ? candidate.to : void 0;
+  if (from !== void 0 && to !== void 0 && from > to) return void 0;
+  const outcome = typeof candidate.outcome === "string" && candidate.outcome.trim() !== "" ? candidate.outcome.trim() : void 0;
+  return { text: candidate.text.trim(), ...origin !== void 0 ? { origin } : {}, ...from !== void 0 ? { from } : {}, ...to !== void 0 ? { to } : {}, ...outcome !== void 0 ? { outcome } : {} };
+}
+function addhistoryentry(corpus, entry) {
+  return [entry, ...corpus.filter((candidate) => !(candidate.source === entry.source && candidate.id === entry.id))];
+}
+function highlightterms(text2, query) {
+  const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1);
+  const lower = text2.toLowerCase();
+  return [...new Set(terms.filter((term) => lower.includes(term)))];
+}
+function historysearch(corpus, query) {
+  const terms = query.text.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1);
+  const hits = [];
+  for (const entry of corpus) {
+    if (query.origin !== void 0 && entry.origin !== query.origin) continue;
+    if (query.from !== void 0 && entry.at < query.from) continue;
+    if (query.to !== void 0 && entry.at > query.to) continue;
+    if (query.outcome !== void 0 && entry.outcome !== query.outcome) continue;
+    const haystack = `${entry.title} ${entry.text}`.toLowerCase();
+    const matched = terms.filter((term) => haystack.includes(term));
+    if (matched.length === 0) continue;
+    const position = haystack.indexOf(matched[0] ?? "");
+    const start = Math.max(0, position - 40);
+    const excerpt = `${start > 0 ? "\u2026" : ""}${`${entry.title} ${entry.text}`.slice(start, start + 160)}${start + 160 < `${entry.title} ${entry.text}`.length ? "\u2026" : ""}`;
+    hits.push({ source: entry.source, id: entry.id, title: entry.title, excerpt, highlights: [...new Set(matched)], ...entry.origin !== void 0 ? { origin: entry.origin } : {}, ...entry.outcome !== void 0 ? { outcome: entry.outcome } : {}, at: entry.at });
+  }
+  return hits.sort((one, two) => two.at - one.at);
+}
+function emptystatemessage(surface, origin) {
+  if (surface === "historysearch") return "No history matches yet; start with a first query such as an origin, a note title or a kind the runs executed.";
+  if (surface === "sitenotes") return `No site note exists${origin !== void 0 ? ` for ${origin}` : ""} yet; write the first note with a title and a body and the note flow keeps it per origin with its author provenance.`;
+  if (surface === "scratchpad") return "The scratchpad holds no entry yet; the agent appends its per task notes here while the reviewed steps run, and every entry carries its step provenance.";
+  return "No session exists yet; start the first run by describing an objective and reviewing the plan the agent proposes.";
+}
+function tabsessionkey(tabid) {
+  return `tabsession:${tabid}`;
+}
+function tabsessionrefof(input) {
+  if (!Number.isInteger(input.tabid) || input.tabid < 0) throw new Error("The per tab session reference needs its tab.");
+  if (input.sessionid.trim() === "") throw new Error("The per tab session reference needs its session.");
+  return { tabid: input.tabid, sessionid: input.sessionid, ...input.runid !== void 0 && input.runid.trim() !== "" ? { runid: input.runid } : {}, origin: input.origin, updatedat: input.now };
+}
+function sessionbundleof(input) {
+  return { kind: "sessionbundle", notes: input.notes, summaries: input.summaries, corrections: input.corrections, exportedat: input.exportedat };
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -14219,7 +14721,9 @@ export {
   acquirerunlock,
   activelayers,
   addedge,
+  addhistoryentry,
   addnode,
+  addrecallentry,
   addusage,
   agentbudgetcheck,
   agentbudgetvalid,
@@ -14314,6 +14818,8 @@ export {
   cancelframes,
   cancellederror,
   cancelrun,
+  cancelrunactionof,
+  cancelrungate,
   canceltask,
   canexecute,
   capturebody,
@@ -14348,6 +14854,7 @@ export {
   claim,
   claimheartbeat,
   classconsentcovers,
+  classifyfailure,
   classifyintent,
   closechannel,
   closeidlechannels,
@@ -14369,7 +14876,11 @@ export {
   connectallowlist,
   connectclient,
   consensusstate,
+  consentadvisory,
+  consentadvisoryverdict,
   consentdurationvalid,
+  consentmemoryadvisorygate,
+  consentmemoryof,
   consentmodel,
   consentprompttext,
   consentwindowgate,
@@ -14436,6 +14947,7 @@ export {
   disarmkillswitch,
   disconnectclient,
   dispatchtool,
+  distillrunsummary,
   domainkinds,
   downloadreport,
   draftplan,
@@ -14443,6 +14955,8 @@ export {
   dryrunprojection,
   dryrunreport,
   dryrunworkflow,
+  editedcorrectionof,
+  editnote,
   editorsavegate,
   editorstate,
   editstep,
@@ -14451,6 +14965,7 @@ export {
   emptyboard,
   emptyconnectallow,
   emptyqueue,
+  emptystatemessage,
   emugate,
   emulationkinds,
   emulationreport,
@@ -14471,6 +14986,7 @@ export {
   environmentsof,
   errorcapture,
   errorreportresponse,
+  errorsurfaceof,
   escalate,
   evaluatecondition,
   evaluatetrigger,
@@ -14484,12 +15000,15 @@ export {
   expandtemplate,
   expireapprovals,
   expireconsentwindows,
+  expirecorrections,
   expirelayers,
   expirelocks,
   expireprofilerecords,
+  expirerecallindex,
   expirerunlocks,
   expiresessions,
   expiretokens,
+  expirnotes,
   exportcontentreview,
   exportlogchain,
   exportpresetlibrary,
@@ -14545,6 +15064,9 @@ export {
   heartbeatreport,
   heldkeysreport,
   hideblackboxedframes,
+  highlightterms,
+  historyqueryof,
+  historysearch,
   hostpattern,
   htmlqueriesof,
   httpframepipeline,
@@ -14635,6 +15157,7 @@ export {
   maskstoredvalues,
   masktypedvalues,
   maskvalue,
+  matchingcorrections,
   matchmessage,
   matchurl,
   matchurlpattern,
@@ -14642,6 +15165,7 @@ export {
   mediaentries,
   mediakinds,
   mediareport,
+  memoryreadscopegate,
   mergeregions,
   mergeresults,
   messageegressgrade,
@@ -14678,6 +15202,8 @@ export {
   nobatchresolution,
   nonceof,
   normalizeendpoint,
+  notebodyof,
+  notehistoryentry,
   oauthflowof,
   observationmodeof,
   observationresponse,
@@ -14689,6 +15215,7 @@ export {
   openconsensus,
   openconsentwindow,
   opengate,
+  opennotebody,
   openoffscreen,
   openrun,
   openrunlog,
@@ -14779,6 +15306,7 @@ export {
   proxygate,
   proxyrouteof,
   prunerunstates,
+  prunescratchpad,
   publishmessage,
   pushscope,
   quarantinereport,
@@ -14787,6 +15315,7 @@ export {
   queuelanesvalid,
   randomid,
   rankapis,
+  rankrecall,
   ratelimitboundsvalid,
   ratelimitbudgetallowed,
   ratelimitgate,
@@ -14798,6 +15327,7 @@ export {
   readstream,
   readverifiedlog,
   reattachrun,
+  recallentryof,
   receivemessage,
   receivemessages,
   reconnectwaits,
@@ -14824,6 +15354,7 @@ export {
   regionsteps,
   regionvalid,
   registeragent,
+  rejectedcorrectionof,
   rejectioncapture,
   relayframe,
   releaselock,
@@ -14871,6 +15402,8 @@ export {
   retireentries,
   retireentry,
   retryafterof,
+  retrydispatchgate,
+  retryhintof,
   revertalllayers,
   revertlayer,
   revertplanof,
@@ -14885,6 +15418,8 @@ export {
   rewritesourcelocation,
   roleaddress,
   roledefaults,
+  rollbackof,
+  rollbacksplit,
   rotatelogs,
   rotationruleof,
   routeenvironment,
@@ -14905,6 +15440,7 @@ export {
   runrepeatuntil,
   runreviewgranted,
   runstep,
+  runsummarytask,
   runtobreakpoint,
   runtry,
   runurllist,
@@ -14930,6 +15466,10 @@ export {
   scopecheck,
   scopegate,
   scopegrantof,
+  scratchentryof,
+  scratchpadof,
+  scratchpadscopegate,
+  sealnotebody,
   sealrunlog,
   sealrunstate,
   seamweights,
@@ -14943,6 +15483,7 @@ export {
   securityreport,
   seededrandom,
   selectorresponse,
+  semanticrecallscopegate,
   sendcdpcommand,
   sendfetch,
   sendmessage,
@@ -14958,14 +15499,17 @@ export {
   servercapabilities,
   serverenablementgate,
   servermethods,
+  sessionbundleof,
   sessionfileversion,
   sessionfolderof,
   sessionfolderunique,
+  sessiongridrows,
   sessionkinds,
   sessionmemory,
   sessionnameunique,
   sessionreport,
   sessionrestoregate,
+  sessionretentionvalid,
   sessiontabof,
   setvariable,
   shapesof,
@@ -14973,6 +15517,9 @@ export {
   shareworkflow,
   shiftentryof,
   signalsreport,
+  sitenoteof,
+  sitenotesreadgate,
+  sitenoteswritegate,
   snapnode,
   snapshotplanof,
   snapshotretentionwindow,
@@ -15007,6 +15554,9 @@ export {
   submitreviewgranted,
   subscriptionframes,
   subscriptionoptionsof,
+  summaryhistoryentry,
+  summaryrequestof,
+  summarywindowvalid,
   swarmcosts,
   swarmoverview,
   swarmreport,
@@ -15014,6 +15564,8 @@ export {
   swarmstatereport,
   sweepreviews,
   tabreportresponse,
+  tabsessionkey,
+  tabsessionrefof,
   targetgate,
   taskcounts,
   taskstatechecksum,