@wenathlan/extension 1.1.63 → 1.1.64

package/dist/index.js

@@ -5206,6 +5206,59 @@ var sessionmemory = class {
   async exportsessionbundle(exportedat) {
     return { kind: "sessionbundle", notes: await this.getsitenotes(), summaries: await this.listrunsummaries(), corrections: await this.getcorrections(), exportedat };
   }
+  /**
+   * Interface surface stores of the 1.1.64 family live here, scoped per profile workspace: the commandpalette usage counts the recent first ranking reads, the taskinput history of natural language goals, the onboarding completion state, the per surface layout preferences, the logstream filter preferences and the stepapprove resolution history per origin.
+   */
+  /** Returns every commandpalette usage record so the ranking lifts the recent commands first. */
+  async getpaletteusage() {
+    return await this.adapter.get("paletteusage") ?? [];
+  }
+  /** Replaces the commandpalette usage records after one use: the count grows and the last use time moves so the ranking reads both. */
+  async setpaletteusage(records) {
+    return this.adapter.set("paletteusage", records);
+  }
+  /** Returns the stored taskinput history, newest first. */
+  async gettaskinputs() {
+    return await this.adapter.get("taskinputs") ?? [];
+  }
+  /** Adds one taskinput submission to the per profile history; the retention window stays a user setting. */
+  async addtaskinput(entry) {
+    const retention = (await this.getsettings())?.taskinputretention;
+    const history = [entry, ...await this.gettaskinputs()];
+    await this.adapter.set("taskinputs", retention === void 0 ? history : history.filter((candidate) => entry.at - candidate.at < retention));
+  }
+  /** Returns the onboarding completion state; an absent state means the walkthrough never ran. */
+  async getonboardingstate() {
+    return this.adapter.get("onboarding");
+  }
+  /** Stores the onboarding completion state; a done walkthrough never runs again on its own. */
+  async setonboardingstate(state) {
+    return this.adapter.set("onboarding", state);
+  }
+  /** Returns the layout preferences of one surface; an absent preference set returns undefined. */
+  async getsurfacelayout(surface) {
+    return this.adapter.get(`surfacelayout:${surface}`);
+  }
+  /** Stores the layout preferences of one surface, scoped per profile workspace. */
+  async setsurfacelayout(layout) {
+    return this.adapter.set(`surfacelayout:${layout.surface}`, layout);
+  }
+  /** Returns the stored logstream filter preferences of the live view. */
+  async getlogstreamfilters() {
+    return this.adapter.get("logstreamfilters");
+  }
+  /** Stores the logstream filter preferences of the live view. */
+  async setlogstreamfilters(filter) {
+    return this.adapter.set("logstreamfilters", filter);
+  }
+  /** Returns every stored stepapprove resolution, newest first, with its human provenance. */
+  async getstepapproveresolutions() {
+    return await this.adapter.get("stepapproveresolutions") ?? [];
+  }
+  /** Records one stepapprove resolution in the per origin history. */
+  async addstepapproveresolution(resolution) {
+    await this.adapter.set("stepapproveresolutions", [resolution, ...await this.getstepapproveresolutions()]);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -11350,6 +11403,48 @@ function retrydispatchgate(input) {
   if (!input.reviewed) return { allowed: false, reason: `The retry of the step ${input.stepid} passes only through a new reviewed dispatch; an automatic retry never bypasses the review.` };
   return { allowed: true, reason: `The retry of the step ${input.stepid} dispatches again through the full consent gate chain: the session, the plan and the origin gates all recheck the step.` };
 }
+function paletteactiongate(input) {
+  if (input.action.permission !== void 0 && !input.granted.includes(input.action.permission)) return { allowed: false, reason: `The ${input.action.command} command needs the ${input.action.permission} capability granted before the palette lists it; the palette never offers an action the current capability set refuses.` };
+  if (input.action.session === true && !input.sessionactive) return { allowed: false, reason: `The ${input.action.command} command needs an active browser session before the palette lists it; the palette never offers a run action without its session.` };
+  return { allowed: true, reason: `The ${input.action.command} command rides its granted permissions and lists in the palette.` };
+}
+function taskinputproposalgate(input) {
+  if (input.direct) return { allowed: false, reason: "The taskinput never executes a goal directly; every natural language goal routes through the same proposal flow as the api and becomes a reviewed plan first." };
+  if (input.text.trim() === "") return { allowed: false, reason: "The taskinput submission needs its natural language goal; an empty goal never reaches the proposal flow." };
+  if (input.origin.trim() === "") return { allowed: false, reason: "The taskinput submission needs its active origin scope; a goal without an origin never reaches the proposal flow." };
+  return { allowed: true, reason: `The taskinput goal for ${input.origin} rides the same proposal flow as the api: the observation, the capabilities and the plan review all recheck it.` };
+}
+function planreviewgate(input) {
+  if (input.state === "approved") return { allowed: true, reason: "The plan already passed its review: the approval is the review of record and the execution proceeds." };
+  if (!input.reviewed) return { allowed: false, reason: "The pending plan has no plancard review yet; every step renders its card with the risk class, the environment and the options before any execution." };
+  return { allowed: true, reason: "The plancard review of the pending plan is open; the resolution of each step stays a distinct human action." };
+}
+function stepapprovegate(input) {
+  if (input.stepids.length === 0) return { allowed: false, reason: "A stepapprove resolution names its single step." };
+  if (input.stepids.length > 1) return { allowed: false, reason: `One human action resolves exactly one step; the batch of ${input.stepids.length} steps refuses in full because no batch approval exists.` };
+  if (input.surface === "background") return { allowed: false, reason: `The ${input.resolution} resolution of the step ${input.stepids[0]} needs its distinct human action from a surface; the background never resolves a review on its own.` };
+  if (input.resolution === "edit") return { allowed: true, reason: `The user edits the step ${input.stepids[0]} from the ${input.surface} before approving; the corrected shape rides the plan and the resolution keeps its human provenance.` };
+  return { allowed: true, reason: `The user ${input.resolution === "approve" ? "approved" : "rejected"} the step ${input.stepids[0]} from the ${input.surface}; one distinct human action resolved the step alone.` };
+}
+function diffpreviewgate(input) {
+  if (input.risk !== "sensitive") return { allowed: false, reason: `The ${input.risk} step changes no page or browser state; the diffpreview compares the observed before state with the predicted after state of write class steps only.` };
+  return { allowed: true, reason: "The write class step changes page or browser state, so the diffpreview compares its observed before state with its predicted after state." };
+}
+function onboardingconsentgate(input) {
+  if (input.consentevents.length === 0) return { allowed: true, reason: "The onboarding completion writes its single consent scoped event; no consent event exists yet." };
+  if (input.consentevents.length === 1) return { allowed: false, reason: `The onboarding already wrote its single consent scoped event ${input.consentevents[0]}; a walkthrough never writes a second one.` };
+  return { allowed: false, reason: `The onboarding found ${input.consentevents.length} consent scoped events; a walkthrough writes exactly one and the extra events refuse.` };
+}
+function logbufferboundvalid(bound) {
+  if (bound === void 0) return { allowed: true, reason: "No logstream buffer bound is configured, so the live window keeps every event while the full history stays in memory." };
+  if (!Number.isInteger(bound) || bound <= 0) return { allowed: false, reason: "The logstream buffer bound stays a positive whole number of events the user chose; no engine cap exists." };
+  return { allowed: true, reason: `The logstream buffer bound of ${bound} event${bound === 1 ? "" : "s"} stays the user configured choice; the full history stays in memory.` };
+}
+function logstreamegressgate(input) {
+  if (input.entries === 0) return { allowed: false, reason: "The audit excerpt names no event of the logstream; an empty range never copies." };
+  if (!input.verified) return { allowed: false, reason: "The logstream chain failed its live verification; the audit excerpt refuses the copy because only a verified range leaves the stream." };
+  return { allowed: true, reason: `The logstream chain verifies across the ${input.entries} event${input.entries === 1 ? "" : "s"} of the range; the audit excerpt copies as one verified record.` };
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -11710,7 +11805,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.63";
+var packageversion = "1.1.64";
 
 // types.ts
 var protocolversion = packageversion;
@@ -13056,6 +13151,273 @@ function sessionbundleof(input) {
   return { kind: "sessionbundle", notes: input.notes, summaries: input.summaries, corrections: input.corrections, exportedat: input.exportedat };
 }
 
+// planreview.ts
+function plancardsof(input) {
+  return input.plan.steps.map((step) => ({
+    stepid: step.id,
+    kind: step.kind,
+    risk: step.risk,
+    environment: step.environment ?? defaultenvironment(step),
+    options: step.options ?? "",
+    summary: step.summary,
+    corrections: matchingcorrections(input.corrections, { origin: input.plan.origin, kind: step.kind }).map((entry) => ({ id: entry.id, source: entry.source, reason: entry.reason })),
+    editable: input.plan.state === "pending"
+  }));
+}
+function plancardgroups(cards) {
+  const order = ["sensitive", "interaction", "read"];
+  return order.map((risk) => ({ risk, cards: cards.filter((card) => card.risk === risk), expanded: risk === "sensitive" })).filter((group) => group.cards.length > 0);
+}
+function stepresolutionof(input) {
+  if (input.stepid.trim() === "") throw new Error("The stepapprove resolution needs its step.");
+  if (input.resolution === "edit" && (input.edited ?? "").trim() === "") throw new Error("The edited resolution needs its corrected step shape.");
+  return { stepid: input.stepid, planid: input.planid, origin: input.origin, resolution: input.resolution, surface: input.surface, ...input.edited !== void 0 && input.edited.trim() !== "" ? { edited: input.edited } : {}, at: input.at };
+}
+function resolutionlogeventof(resolution) {
+  return {
+    kind: "review",
+    stepid: resolution.stepid,
+    summary: resolution.resolution === "edit" ? `The user edited the step ${resolution.stepid} of the plan ${resolution.planid} from the ${resolution.surface} before approving; the corrected shape rides the plan.` : `The user ${resolution.resolution === "approve" ? "approved" : "rejected"} the step ${resolution.stepid} of the plan ${resolution.planid} from the ${resolution.surface}; one distinct human action resolved the step alone.`
+  };
+}
+function resolutionhistoryafter(history, resolution) {
+  return [resolution, ...history];
+}
+function maskverdictsof(state, sensitivefields) {
+  const verdicts = {};
+  for (const [field, value] of Object.entries(state)) {
+    if (sensitivefields.includes(field)) verdicts[field] = `The ${field} value stays masked (${value.length} characters) and never renders in the clear.`;
+  }
+  return verdicts;
+}
+function diffpreviewof(input) {
+  const changes = [];
+  const fields = [.../* @__PURE__ */ new Set([...Object.keys(input.before), ...Object.keys(input.after)])];
+  for (const field of fields) {
+    const hasbefore = Object.prototype.hasOwnProperty.call(input.before, field);
+    const hasafter = Object.prototype.hasOwnProperty.call(input.after, field);
+    const beforevalue = input.before[field];
+    const aftervalue = input.after[field];
+    if (hasbefore && !hasafter && beforevalue !== void 0) changes.push({ field, kind: "removed", before: beforevalue });
+    else if (!hasbefore && hasafter && aftervalue !== void 0) changes.push({ field, kind: "added", after: aftervalue });
+    else if (hasbefore && hasafter && beforevalue !== void 0 && aftervalue !== void 0 && beforevalue !== aftervalue) changes.push({ field, kind: "changed", before: beforevalue, after: aftervalue });
+  }
+  return { stepid: input.stepid, before: input.before, after: input.after, changes, maskverdicts: input.maskverdicts ?? {}, provenance: input.provenance };
+}
+function stepstimelinenodes(input) {
+  const completed = input.progress?.completedsteps ?? [];
+  const outcomes = input.progress?.outcomes ?? [];
+  const environments = input.progress?.environments;
+  const turnarounds = input.progress?.turnarounds;
+  const gatewaits = input.progress?.gatewaits;
+  let activeset = false;
+  let blocked = false;
+  return input.plan.steps.map((step) => {
+    const outcome = [...outcomes].reverse().find((candidate) => candidate.stepid === step.id);
+    const gatewait = gatewaits?.[step.id];
+    let status;
+    if (outcome !== void 0) status = outcome.ok ? "done" : "failed";
+    else if (gatewait !== void 0) status = "waiting";
+    else if (completed.includes(step.id)) status = "done";
+    else if (input.plan.state === "cancelled" || input.plan.state === "expired") status = "halted";
+    else if (input.plan.state === "rejected") status = "halted";
+    else if (input.plan.state === "approved" && !activeset && !blocked) {
+      status = "running";
+      activeset = true;
+    } else status = "pending";
+    if (status === "waiting") blocked = true;
+    const active = status === "running";
+    return {
+      stepid: step.id,
+      kind: step.kind,
+      status,
+      ...turnarounds?.[step.id] !== void 0 ? { durationms: turnarounds[step.id] } : {},
+      ...environments?.[step.id] !== void 0 ? { environment: environments[step.id] } : step.environment !== void 0 ? { environment: step.environment } : {},
+      active,
+      anchor: `#step-${step.id}`,
+      ...outcome !== void 0 ? { resultsummary: outcome.summary } : {}
+    };
+  });
+}
+function activetimelineanchor(nodes) {
+  return nodes.find((node) => node.active)?.anchor;
+}
+var logstreamgenesis = "0".repeat(64);
+async function logstreameventof(input) {
+  if (input.summary.trim() === "") throw new Error("The logstream event needs its summary.");
+  const id = randomid();
+  const hash = await entryhashof({ previous: input.previous, entry: { id, runid: "surfaces", kind: "step", summary: input.summary, origin: input.origin, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, at: input.at } });
+  return { id, level: input.level, source: input.source, origin: input.origin, summary: input.summary, ...input.stepid !== void 0 ? { stepid: input.stepid } : {}, masked: input.masked, maskverdict: input.maskverdict, hash, at: input.at };
+}
+function appendlogstreamevent(events, event) {
+  return [...events, event];
+}
+function filterlogstream(events, filter) {
+  return events.filter((event) => (filter.level === void 0 || event.level === filter.level) && (filter.origin === void 0 || filter.origin === "" || event.origin === filter.origin) && (filter.stepid === void 0 || filter.stepid === "" || event.stepid === filter.stepid));
+}
+function livebufferof(events, bound) {
+  if (bound === void 0) return events;
+  if (!Number.isInteger(bound) || bound <= 0) return events;
+  return events.slice(-bound);
+}
+async function verifylogstream(events) {
+  for (let index = 0; index < events.length; index += 1) {
+    const event = events[index];
+    if (event === void 0) continue;
+    const predecessor = events[index - 1];
+    const expectedprevious = index === 0 || predecessor === void 0 ? logstreamgenesis : predecessor.hash.current;
+    if (event.hash.previous !== expectedprevious) return { valid: false, brokenat: index, reason: `The logstream chain breaks at the event ${event.id}: its previous hash does not link to its predecessor.` };
+    const recomputed = await entryhashof({ previous: event.hash.previous, entry: { id: event.id, runid: "surfaces", kind: "step", summary: event.summary, origin: event.origin, ...event.stepid !== void 0 ? { stepid: event.stepid } : {}, at: event.at } });
+    if (recomputed.current !== event.hash.current) return { valid: false, brokenat: index, reason: `The logstream chain breaks at the event ${event.id}: its own hash does not reproduce.` };
+  }
+  return { valid: true, reason: `The logstream chain of ${events.length} event${events.length === 1 ? "" : "s"} verifies link by link.` };
+}
+async function auditexcerptof(events, input) {
+  if (input.from < 0 || input.to <= input.from || input.to > events.length) return { ok: false, text: "", reason: `The excerpt range ${input.from} to ${input.to} names no contiguous slice of the ${events.length} event${events.length === 1 ? "" : "s"}.` };
+  const range = events.slice(input.from, input.to);
+  const verification = await verifylogstream(range);
+  if (!verification.valid) return { ok: false, text: "", reason: `The excerpt refuses the copy: ${verification.reason}` };
+  const text2 = range.map((event) => `[${event.at}] ${event.level} ${event.source}${event.stepid !== void 0 ? ` step ${event.stepid}` : ""} ${event.origin} \u2014 ${event.summary}${event.masked ? ` (${event.maskverdict})` : ""}`).join("\n");
+  return { ok: true, text: text2, reason: `The excerpt copied the verified range ${input.from} to ${input.to} of the logstream.` };
+}
+function loglevelof(kind) {
+  if (kind === "error") return "error";
+  if (["deny", "revoke", "stop", "quarantine", "phish", "defer", "schema", "expiry"].includes(kind)) return "warn";
+  return "info";
+}
+
+// surfaces.ts
+function surfacepalette() {
+  return [
+    { id: "starttask", label: "Start task", keywords: ["task", "objective", "run", "goal", "plan"], action: { command: "starttask", surface: "popup" } },
+    { id: "pauserun", label: "Pause run", keywords: ["pause", "hold", "stop", "run"], action: { command: "pauserun", surface: "popup", session: true } },
+    { id: "resumerun", label: "Resume run", keywords: ["resume", "continue", "unpause", "run"], action: { command: "resumerun", surface: "popup", session: true } },
+    { id: "cancelrun", label: "Cancel run", keywords: ["cancel", "stop", "rollback", "queued"], action: { command: "cancelrun", surface: "popup", session: true } },
+    { id: "resumesession", label: "Resume session", keywords: ["session", "resume", "grid", "reopen"], action: { command: "resumesession", surface: "sidepanel" } },
+    { id: "stepapprove", label: "Review step", keywords: ["approve", "reject", "edit", "step", "review", "plancard"], action: { command: "stepapprove", surface: "sidepanel", session: true } },
+    { id: "diffpreview", label: "Preview step diff", keywords: ["diff", "preview", "before", "after", "write"], action: { command: "diffpreview", surface: "sidepanel", session: true } },
+    { id: "historysearch", label: "Search history", keywords: ["history", "search", "notes", "summaries", "corpus"], action: { command: "historysearch", surface: "dashboardpage" } },
+    { id: "revokeconsent", label: "Revoke consent", keywords: ["revoke", "consent", "allowlist", "origin", "grant"], action: { command: "revokeconsent", surface: "dashboardpage", session: true } },
+    { id: "opentransparencypage", label: "Open transparency page", keywords: ["transparency", "grants", "permissions", "diff"], action: { command: "opentransparencypage", surface: "optionspage" } },
+    { id: "opendashboardpage", label: "Open dashboard", keywords: ["dashboard", "sessions", "runs", "notes", "full"], action: { command: "opendashboardpage", surface: "dashboardpage" } },
+    { id: "openoptionspage", label: "Open options", keywords: ["options", "settings", "preferences", "configure"], action: { command: "openoptionspage", surface: "optionspage" } },
+    { id: "copyauditexcerpt", label: "Copy audit excerpt", keywords: ["audit", "excerpt", "copy", "verified", "range"], action: { command: "copyauditexcerpt", surface: "dashboardpage" } },
+    { id: "replayonboarding", label: "Replay onboarding", keywords: ["onboarding", "tour", "walkthrough", "replay", "first"], action: { command: "replayonboarding", surface: "onboarding" } }
+  ];
+}
+function palettecommandsof(entries, input) {
+  return entries.filter((entry) => paletteactiongate({ action: entry.action, granted: input.granted, sessionactive: input.sessionactive }).allowed);
+}
+function fuzzyentryscore(entry, query) {
+  const text2 = query.trim().toLowerCase();
+  if (text2 === "") return 1;
+  const id = entry.id.toLowerCase();
+  const label = entry.label.toLowerCase();
+  if (id === text2 || label === text2) return 100;
+  let score = 0;
+  if (id.includes(text2)) score += 40;
+  if (label.includes(text2)) score += 30;
+  for (const keyword of entry.keywords) {
+    const lower = keyword.toLowerCase();
+    if (lower === text2) score += 20;
+    else if (lower.includes(text2)) score += 10;
+  }
+  if (score === 0 && text2.length > 1) {
+    for (const haystack of [label, id]) {
+      let cursor = 0;
+      let matched = true;
+      for (const letter of text2) {
+        const found = haystack.indexOf(letter, cursor);
+        if (found === -1) {
+          matched = false;
+          break;
+        }
+        cursor = found + 1;
+      }
+      if (matched) {
+        score += 15;
+        break;
+      }
+    }
+  }
+  return score;
+}
+function palettequery(entries, input) {
+  const text2 = input.text.trim();
+  const matches = entries.map((entry) => ({ entry, score: fuzzyentryscore(entry, text2) })).filter((match) => match.score > 0);
+  const lastusedof = (command) => input.usage.find((record2) => record2.command === command)?.lastusedat ?? 0;
+  const countof = (command) => input.usage.find((record2) => record2.command === command)?.count ?? 0;
+  const recentwindow = input.recentwindow;
+  const ranked = matches.sort((left, right) => {
+    if (right.score !== left.score) return right.score - left.score;
+    const leftrecent = recentwindow === void 0 ? 0 : countof(left.entry.action.command) > 0 && lastusedof(left.entry.action.command) >= lastusedof(right.entry.action.command) ? 1 : 0;
+    const rightrecent = recentwindow === void 0 ? 0 : countof(right.entry.action.command) > 0 && lastusedof(right.entry.action.command) >= lastusedof(left.entry.action.command) ? 1 : 0;
+    if (rightrecent !== leftrecent) return rightrecent - leftrecent;
+    return lastusedof(right.entry.action.command) - lastusedof(left.entry.action.command);
+  });
+  return ranked.map((match) => ({ entry: match.entry, score: match.score, reason: match.score >= 100 ? `The query matches the ${match.entry.id} command exactly.` : `The query matches the label or the keywords of the ${match.entry.id} command${countof(match.entry.action.command) > 0 ? ` and its ${countof(match.entry.action.command)} recorded use${countof(match.entry.action.command) === 1 ? "" : "s"} rank it first among equals` : ""}.` }));
+}
+function paletteuseafter(usage, command, now) {
+  const existing = usage.find((record2) => record2.command === command);
+  if (existing === void 0) return [{ command, count: 1, lastusedat: now }, ...usage];
+  return usage.map((record2) => record2.command === command ? { ...record2, count: record2.count + 1, lastusedat: now } : record2);
+}
+function taskinputof(input) {
+  if (input.text.trim() === "") throw new Error("The taskinput needs its natural language goal.");
+  if (input.origin.trim() === "") throw new Error("The taskinput needs its active origin scope.");
+  return { id: randomid(), text: input.text.trim(), context: input.context ?? "", origin: input.origin.trim(), surface: input.surface, at: input.at };
+}
+function taskhistoryafter(history, entry, retention, now) {
+  if (retention === void 0) return [entry, ...history];
+  return [entry, ...history].filter((candidate) => now - candidate.at < retention);
+}
+function onboardingsteps() {
+  return [
+    { id: "origingrants", surface: "popup", title: "Origin grants", body: "Devthink denies automation by default; grant one exact origin at a time from the popup and every run stays inside the granted origins.", completion: "origingrantscompleted" },
+    { id: "planreview", surface: "sidepanel", title: "Plan review", body: "Every task becomes a plan of reviewed steps; read the plancards of each risk class and approve, reject or edit one step at a time.", completion: "planreviewcompleted" },
+    { id: "runcontrol", surface: "sidepanel", title: "Run control", body: "Runs start, pause, resume and cancel under your hand; a cancelled run rolls only its queued steps back while the executed steps stay sealed.", completion: "runcontrolcompleted" },
+    { id: "logaudit", surface: "dashboardpage", title: "Log audit", body: "The immutable log chains every step transition with masked values; open the dashboard, verify the chain and copy a verified range as an audit excerpt.", completion: "logauditcompleted" }
+  ];
+}
+function onboardingstart(previous, now) {
+  return { stepscompleted: [], done: false, startedat: now };
+}
+function onboardingcomplete(state, stepid, now) {
+  const steps = onboardingsteps();
+  const step = steps.find((candidate) => candidate.id === stepid);
+  if (step === void 0) throw new Error(`The onboarding knows no ${stepid} step.`);
+  const completed = state.stepscompleted.includes(stepid) ? state.stepscompleted : [...state.stepscompleted, stepid];
+  const done = steps.every((candidate) => completed.includes(candidate.id));
+  if (!done) return { state: { ...state, stepscompleted: completed, done: false } };
+  const consentevent = "onboardingconsentgranted";
+  return { state: { stepscompleted: completed, done: true, ...state.startedat !== void 0 ? { startedat: state.startedat } : {}, consentevent, completedat: now }, consentevent };
+}
+function broadcastframeof(input) {
+  if (input.summary.trim() === "") throw new Error("The broadcast frame needs its summary.");
+  return { channel: input.channel, surface: input.surface, summary: input.summary, at: input.at };
+}
+function broadcastchannelof(kind) {
+  if (["session", "proposal", "approval", "action", "stop", "pause", "resume", "complete", "cancel", "error", "capability"].includes(kind)) return "runstate";
+  if (["notes", "scratchpad", "summary", "recall", "correction", "consentmemory", "search", "vault", "gate", "grant", "revoke", "expiry", "deny"].includes(kind)) return "sessions";
+  if (["configure", "transparency"].includes(kind)) return "settings";
+  return "logstream";
+}
+function busrouteaction(action, input) {
+  const entry = surfacepalette().find((candidate) => candidate.action.command === action.command);
+  if (entry === void 0) return { dispatched: false, gate: "commandbus", reason: `The ${action.surface} asked for the unknown ${action.command} command; the bus routes only catalog commands.` };
+  const permission = paletteactiongate({ action: entry.action, granted: input.granted, sessionactive: input.sessionactive });
+  if (!permission.allowed) return { dispatched: false, gate: "paletteactiongate", reason: permission.reason ?? "The command misses its granted permission." };
+  if (action.command === "starttask") {
+    const proposal = taskinputproposalgate({ text: input.text ?? "", origin: input.origin ?? "", direct: false });
+    if (!proposal.allowed) return { dispatched: false, gate: "taskinputproposalgate", reason: proposal.reason ?? "The task submission refuses." };
+  }
+  if (action.command === "stepapprove" || action.command === "diffpreview") {
+    const review = planreviewgate({ reviewed: input.planreviewed, state: input.planstate });
+    if (!review.allowed) return { dispatched: false, gate: "planreviewgate", reason: review.reason ?? "The plan review stays open." };
+  }
+  return { dispatched: true, gate: "commandbus", reason: `The ${action.command} action of the ${action.surface} routed through its policy gates and dispatches.` };
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -14009,6 +14371,9 @@ function logchainreport(input) {
 function transparencyreport(input) {
   return { version: protocolversion, posture: "denydefault", grants: input.grants, windows: input.windows, connectallow: input.connectallow, permdiffs: input.permdiffs, safedefaults: input.safedefaults, vault: input.vault };
 }
+function surfacesnapshot(input) {
+  return { version: protocolversion, surface: input.surface, palette: input.palette, timeline: input.timeline, logstream: input.logstream, plancards: input.plancards, ...input.onboarding !== void 0 ? { onboarding: input.onboarding } : {} };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -14720,6 +15085,7 @@ export {
   acquirelock,
   acquirerunlock,
   activelayers,
+  activetimelineanchor,
   addedge,
   addhistoryentry,
   addnode,
@@ -14745,6 +15111,7 @@ export {
   apikeyconsentgranted,
   apireplayspecof,
   appendlogentry,
+  appendlogstreamevent,
   applycooldown,
   applyheaderules,
   applylayer,
@@ -14764,6 +15131,7 @@ export {
   attachcdpsession,
   attachtargetof,
   attachtimeline,
+  auditexcerptof,
   authconsentgranted,
   authorizeurl,
   authrefusedmessage,
@@ -14795,6 +15163,8 @@ export {
   breakpointbudgetallowed,
   breakpointceilingof,
   breakpointinputof,
+  broadcastchannelof,
+  broadcastframeof,
   broadcastrecipient,
   browserpermissions,
   bucketboundsvalid,
@@ -14809,6 +15179,7 @@ export {
   buildstitchplan,
   buildtoolcatalog,
   bumprevision,
+  busrouteaction,
   callgraphql,
   calllocal,
   calllogreport,
@@ -14940,6 +15311,8 @@ export {
   actionrisk as deriveactionrisk,
   detachcdpsession,
   devicepresetof,
+  diffpreviewgate,
+  diffpreviewof,
   diffresponse,
   diffreviewgrade,
   diffsessionrecords,
@@ -15030,6 +15403,7 @@ export {
   filteredsessions,
   filterentries,
   filterexchanges,
+  filterlogstream,
   finishrecording,
   fixedheadermatch,
   flowmetricnames,
@@ -15123,6 +15497,7 @@ export {
   listdue,
   listremotestatus,
   listtools,
+  livebufferof,
   loadworkflow,
   localhostbind,
   localsensitivegrade,
@@ -15131,10 +15506,15 @@ export {
   locationpresetof,
   locationrangevalid,
   lockkey,
+  logbufferboundvalid,
   logchainreport,
   logentryof,
+  loglevelof,
   loglevels,
   logreadgate,
+  logstreamegressgate,
+  logstreameventof,
+  logstreamgenesis,
   longtaskcapture,
   lookalikedistance,
   loopof,
@@ -15157,6 +15537,7 @@ export {
   maskstoredvalues,
   masktypedvalues,
   maskvalue,
+  maskverdictsof,
   matchingcorrections,
   matchmessage,
   matchurl,
@@ -15211,6 +15592,10 @@ export {
   offfamilyof,
   offloadkinds,
   offscreencapabilitygate,
+  onboardingcomplete,
+  onboardingconsentgate,
+  onboardingstart,
+  onboardingsteps,
   openchannel,
   openconsensus,
   openconsentwindow,
@@ -15234,8 +15619,12 @@ export {
   pairexchange,
   pairingframes,
   pairstates,
+  paletteactiongate,
   palettecategories,
+  palettecommandsof,
   palettenodes,
+  palettequery,
+  paletteuseafter,
   parallelof,
   parsecommand,
   parsecompletion,
@@ -15277,9 +15666,12 @@ export {
   phishverdictof,
   ping,
   planallowlist,
+  plancardgroups,
+  plancardsof,
   plandraftreviewgate,
   planlint,
   plannersplit,
+  planreviewgate,
   pollcursorof,
   polldecision,
   pollurl,
@@ -15380,6 +15772,8 @@ export {
   requestreview,
   requeue,
   requireapproval,
+  resolutionhistoryafter,
+  resolutionlogeventof,
   resolutionverdict,
   resolveapproval,
   resolvedrisk,
@@ -15538,8 +15932,11 @@ export {
   starttls,
   statusclassof,
   steal,
+  stepapprovegate,
   stepenvironmentvalid,
   stepmodeof,
+  stepresolutionof,
+  stepstimelinenodes,
   steptemplateof,
   stepwindows,
   stopone,
@@ -15557,6 +15954,8 @@ export {
   summaryhistoryentry,
   summaryrequestof,
   summarywindowvalid,
+  surfacepalette,
+  surfacesnapshot,
   swarmcosts,
   swarmoverview,
   swarmreport,
@@ -15568,6 +15967,9 @@ export {
   tabsessionrefof,
   targetgate,
   taskcounts,
+  taskhistoryafter,
+  taskinputof,
+  taskinputproposalgate,
   taskstatechecksum,
   taskstateof,
   taskstatevalid,
@@ -15658,6 +16060,7 @@ export {
   verdictfresh,
   verifyauth,
   verifylogchain,
+  verifylogstream,
   verifytoken,
   verifywebhook,
   visitmatch,