@wenathlan/extension 1.1.65 → 1.1.66

package/dist/index.js

@@ -5321,6 +5321,111 @@ var sessionmemory = class {
   async addnotificationhistory(payload) {
     await this.adapter.set("notificationhistory", [payload, ...await this.getnotificationhistory()]);
   }
+  /**
+   * Ecosystem stores of the 1.1.66 family live here, scoped per profile workspace: the flowlibrary entries with their manifest digests and provenance, the library install and removal events, the syncbridge hooks with their conflict records, the attentionfeed entries with their configurable retention, the runreplay cursors per viewed run, the outputcompare sessions with their metric results and the background run queue state for restart recovery.
+   * The flowlibrary store deduplicates entries by manifest digest, every entry carries its publisher provenance, and the manifest list exports for audit; the memory adapter seam stays the documented marketplace backend boundary because a future remote registry replaces the adapter only.
+   */
+  /** Returns every flowlibrary entry of the profile workspace, newest first. */
+  async getflowlibrary() {
+    return await this.adapter.get("flowlibrary") ?? [];
+  }
+  /** Replaces the flowlibrary entries of the profile workspace. */
+  async setflowlibrary(entries) {
+    return this.adapter.set("flowlibrary", entries);
+  }
+  /** Adds one flowlibrary entry deduplicated by manifest digest: an entry whose digest already exists replaces its predecessor while its provenance keeps both records. */
+  async addlibraryentry(entry) {
+    const entries = await this.getflowlibrary();
+    const deduped = entries.filter((candidate) => candidate.digest !== entry.digest);
+    await this.setflowlibrary([entry, ...deduped]);
+    return [entry, ...deduped];
+  }
+  /** Removes one flowlibrary entry by its id while the library events keep their record for the audit trail. */
+  async removelibraryentry(entryid) {
+    await this.setflowlibrary((await this.getflowlibrary()).filter((candidate) => candidate.id !== entryid));
+  }
+  /** Returns every library install, update and removal event, newest first. */
+  async getlibraryevents() {
+    return await this.adapter.get("libraryevents") ?? [];
+  }
+  /** Records one library lifecycle event beside the flowlibrary store. */
+  async addlibraryevent(event) {
+    await this.adapter.set("libraryevents", [event, ...await this.getlibraryevents()]);
+  }
+  /** Exports the manifest list of the flowlibrary for audit: one row per entry with its digest, publisher, version, state and provenance and no step payload. */
+  async exportlibrarymanifests() {
+    return (await this.getflowlibrary()).map((entry) => ({ id: entry.id, title: entry.manifest.title, publisher: entry.manifest.publisher, version: entry.manifest.version, digest: entry.digest, state: entry.state, provenance: entry.provenance, addedat: entry.addedat }));
+  }
+  /** Returns every syncbridge hook of the profile workspace; every hook keeps its explicit opt in with no default on. */
+  async getsyncbridgehooks() {
+    return await this.adapter.get("syncbridgehooks") ?? [];
+  }
+  /** Replaces the syncbridge hooks of the profile workspace. */
+  async setsyncbridgehooks(hooks) {
+    return this.adapter.set("syncbridgehooks", hooks);
+  }
+  /** Returns every syncbridge conflict record, newest first, with both versions instead of a silent overwrite. */
+  async getsyncbridgeconflicts() {
+    return await this.adapter.get("syncbridgeconflicts") ?? [];
+  }
+  /** Records one syncbridge conflict with both manifest versions. */
+  async addsyncbridgeconflict(conflict) {
+    await this.adapter.set("syncbridgeconflicts", [conflict, ...await this.getsyncbridgeconflicts()]);
+  }
+  /** Resolves one syncbridge conflict by its id with the resolution the user picked; one conflict resolves exactly once. */
+  async resolvesyncbridgeconflict(id, resolution, now) {
+    const conflicts = await this.getsyncbridgeconflicts();
+    await this.adapter.set("syncbridgeconflicts", conflicts.map((conflict) => conflict.id === id && conflict.resolution === void 0 ? { ...conflict, resolution, resolvedat: now } : conflict));
+    return this.getsyncbridgeconflicts();
+  }
+  /** Returns every attentionfeed entry, newest first, with its cause, refs and deep link. */
+  async getattentionentries() {
+    return await this.adapter.get("attentionfeed") ?? [];
+  }
+  /** Records one attentionfeed entry deduplicated by its cause, run and gate refs while the retention window stays a user setting. */
+  async addattentionentry(entry) {
+    const existing = (await this.getattentionentries()).filter((candidate) => candidate.id !== entry.id);
+    await this.adapter.set("attentionfeed", [entry, ...existing]);
+  }
+  /** Dismisses one attentionfeed entry by its id: the dismissal removes the feed row only while the waiting cause keeps its own resolution path. */
+  async dismissattentionentry(id) {
+    const entries = (await this.getattentionentries()).filter((candidate) => candidate.id !== id);
+    await this.adapter.set("attentionfeed", entries);
+    return entries;
+  }
+  /** Prunes the attentionfeed entries past their retention window; an absent window keeps every entry while the pruned ids return for the audit note. */
+  async pruneattentionentries(now) {
+    const retention = (await this.getsettings())?.attentionretention;
+    const entries = await this.getattentionentries();
+    if (retention === void 0) return { kept: entries, pruned: [] };
+    const kept = entries.filter((entry) => now - entry.at < retention);
+    await this.adapter.set("attentionfeed", kept);
+    return { kept, pruned: entries.filter((entry) => now - entry.at >= retention).map((entry) => entry.id) };
+  }
+  /** Returns the runreplay cursors per viewed run so a reopened replay stands where the viewer left it. */
+  async getreplaycursors() {
+    return await this.adapter.get("replaycursors") ?? {};
+  }
+  /** Stores one runreplay cursor for its viewed run. */
+  async setreplaycursor(runid, cursor) {
+    await this.adapter.set("replaycursors", { ...await this.getreplaycursors(), [runid]: cursor });
+  }
+  /** Returns every outputcompare session with its metric results, newest first. */
+  async getcomparesessions() {
+    return await this.adapter.get("comparesessions") ?? [];
+  }
+  /** Records one outputcompare session with the metric set it used. */
+  async addcomparesession(session) {
+    await this.adapter.set("comparesessions", [session, ...await this.getcomparesessions()]);
+  }
+  /** Returns the background run queue state for restart recovery: every entry with its state and its keepalive hold. */
+  async getbackgroundqueue() {
+    return await this.adapter.get("backgroundqueue") ?? [];
+  }
+  /** Replaces the background run queue state after every transition so the restart recovery reads it in one call. */
+  async setbackgroundqueue(queue) {
+    return this.adapter.set("backgroundqueue", queue);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -11552,6 +11657,63 @@ function importexportgate(input) {
   if (input.unmaskedlogs) return { allowed: false, reason: "The importexport bundle carries unmasked log entries; only masked summaries ever move between profiles, so the bundle refuses in full." };
   return { allowed: true, reason: "The importexport bundle carries no secretvault value and no unmasked log; the originprofiles, the siteprofiles, the notes and the preferences move with their honest exclusion list." };
 }
+function librarymanifestgate(input) {
+  if (input.errors.length > 0) return { allowed: false, reason: `The flowlibrary manifest fails schemastrict with ${input.errors.length} error${input.errors.length === 1 ? "" : "s"}: ${input.errors.slice(0, 3).map((error) => `${error.path} expected ${error.expected}`).join("; ")}; the import refuses before anything else.` };
+  return { allowed: true, reason: "The flowlibrary manifest passes schemastrict with no shape error; the validation names every field it checked." };
+}
+function librarycapabilitygate(input) {
+  const missing = [...new Set(input.kinds)].filter((kind) => !input.capabilities.includes(kind));
+  if (missing.length > 0) return { allowed: false, reason: `The flowlibrary manifest uses the kind${missing.length === 1 ? "" : "s"} ${missing.join(", ")} the installed capability set lacks; the import refuses in full.` };
+  return { allowed: true, reason: `Every kind of the flowlibrary manifest sits inside the installed capability set of ${input.capabilities.length} kind${input.capabilities.length === 1 ? "" : "s"}.` };
+}
+function librarygrantgate(input) {
+  const missing = [...new Set(input.requiredgrants)].filter((origin) => !input.heldgrants.includes(origin));
+  if (missing.length > 0) return { allowed: false, reason: `The flowlibrary manifest requires the grant${missing.length === 1 ? "" : "s"} ${missing.join(", ")} the profile does not hold; the grant diff shows them and the user grants them before the import completes.` };
+  return { allowed: true, reason: `The profile holds every grant the flowlibrary manifest requires${input.requiredgrants.length === 0 ? " and the manifest requires none" : ""}.` };
+}
+function librarysensitivegate(input) {
+  if (!input.sensitive) return { allowed: true, reason: "The flowlibrary manifest carries no sensitive mark, so no fresh consent prompt stands before its import." };
+  if (!input.freshconsent) return { allowed: false, reason: "The flowlibrary manifest is marked sensitive; its import needs a fresh consent prompt the user answers before anything lands." };
+  return { allowed: true, reason: "The user answered the fresh consent prompt of the sensitive flowlibrary manifest; the import proceeds behind the same review." };
+}
+function libraryquarantinegate(input) {
+  if (!input.signaturepresent && !input.verified) return { allowed: false, reason: "The flowlibrary entry carries no publisher signature; the entry quarantines until the user verifies its publisher, and a quarantined entry never installs on its own." };
+  if (input.signaturepresent && !input.signaturevalid) return { allowed: false, reason: "The publisher signature of the flowlibrary entry failed its verification; the entry quarantines and never installs under any flag." };
+  return { allowed: true, reason: "The publisher signature of the flowlibrary entry verified over its manifest digest; the entry stays available for the grant diff and the import." };
+}
+function libraryimportgate(input) {
+  if (!input.proposal) return { allowed: false, reason: "A library import lands as a proposal only; no template ever executes directly and the plan review gates every step as always." };
+  if (!input.planreviewed) return { allowed: false, reason: "The library import proposal has no plan review yet; the plancards render and the user approves one step at a time before any execution." };
+  return { allowed: true, reason: "The library import landed as a proposal and its plan passed the same review as every native task; the consent gates never moved." };
+}
+function syncbridgeoptingate(input) {
+  if (!input.optin) return { allowed: false, reason: "The syncbridge hook stays off because no explicit opt in exists; no hook ever defaults on and no manifest moves without the user turning the hook on." };
+  return { allowed: true, reason: "The user explicitly opted the syncbridge hook in; the hook moves manifests only and never secrets or logs." };
+}
+function syncbridgescopegate(input) {
+  if (input.carriessecrets) return { allowed: false, reason: "The syncbridge payload carries a secretvault value shape; the bridge moves manifests only, so the payload refuses in full." };
+  if (input.carrieslogs) return { allowed: false, reason: "The syncbridge payload carries log entries; the bridge moves manifests only, so the payload refuses in full." };
+  return { allowed: true, reason: "The syncbridge payload carries manifests only; secrets and logs never ride the bridge under any flag." };
+}
+function runreplaygate(input) {
+  if (!input.sealed) return { allowed: false, reason: "The runreplay walks sealed runs only; an open run keeps moving and its replay would show a chain that still grows." };
+  if (!input.chainvalid) return { allowed: false, reason: "The sealed chain of the run failed its verification; the replay refuses the walk because only a verified chain stands as audit evidence." };
+  return { allowed: true, reason: "The run sealed and its chain verified from the genesis hash to the seal; the replay walks it read only, restoring the observation and capture of each step." };
+}
+function outputcomparegate(input) {
+  if (input.signaturea.trim() === "" || input.signatureb.trim() === "") return { allowed: false, reason: "The outputcompare needs the task input signature of both runs; a signatureless run never compares." };
+  if (input.signaturea !== input.signatureb) return { allowed: false, reason: "The two runs carry different task input signatures; only runs that started from the same input compare their outcomes." };
+  return { allowed: true, reason: "The two runs share their task input signature, so their step outcomes compare under the recorded metric set." };
+}
+function outputcomparereadonlygate(input) {
+  if (input.executessteps) return { allowed: false, reason: "The outputcompare never executes a step; it reads the stored outcomes of both runs only, so any executing path refuses in full." };
+  return { allowed: true, reason: "The outputcompare joins the stored outcomes of both runs without touching the page; no step executes inside a comparison." };
+}
+function backgroundrungate(input) {
+  if (!input.reviewed) return { allowed: false, reason: "The background run queue executes reviewed workflows only; an unreviewed workflow never starts, with or without an open surface." };
+  if (!input.keepaliveheld) return { allowed: false, reason: "A background run holds the keepalive signal for its whole duration; a run that releases the signal early stops being a background run." };
+  return { allowed: true, reason: "The reviewed workflow runs in the background with the keepalive signal held and every checkpoint restoring it on each worker wake." };
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -11912,7 +12074,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.65";
+var packageversion = "1.1.66";
 
 // types.ts
 var protocolversion = packageversion;
@@ -13483,7 +13645,8 @@ function onboardingsteps() {
     { 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" }
+    { 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" },
+    { id: "library", surface: "dashboardpage", title: "Flow library", body: "The flowlibrary shares reviewed workflow templates: browse an entry, read its step list and grant diff, and every install still lands as a proposal behind the same review.", completion: "librarycompleted", optional: true }
   ];
 }
 function onboardingstart(previous, now) {
@@ -13494,7 +13657,7 @@ function onboardingcomplete(state, stepid, now) {
   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));
+  const done = steps.filter((candidate) => candidate.optional !== true).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 };
@@ -14085,6 +14248,445 @@ function a11ylabelslocalizedfor(surface, bundles, language) {
   return a11ylabelsfor(surface).map((label) => a11ylabellocalized(label, bundles, language));
 }
 
+// flowlibrary.ts
+async function sha2563(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 manifestbody(manifest) {
+  return JSON.stringify({ id: manifest.id, title: manifest.title, description: manifest.description, version: manifest.version, publisher: manifest.publisher, ...manifest.registry !== void 0 ? { registry: manifest.registry } : {}, steps: manifest.steps, kinds: manifest.kinds, requiredgrants: manifest.requiredgrants, dataexpectations: manifest.dataexpectations, sensitive: manifest.sensitive });
+}
+async function manifestdigest(manifest) {
+  const { publish, ...body } = manifest;
+  void publish;
+  return sha2563(manifestbody(body));
+}
+async function validatemanifest(input) {
+  const errors = [];
+  const raw = input.manifest;
+  if (!Boolean(raw) || typeof raw !== "object" || Array.isArray(raw)) return { ok: false, errors: [{ path: "manifest", expected: "object", found: Array.isArray(raw) ? "array" : typeof raw, reason: "Every flowlibrary manifest travels as one plain object." }], reason: "The flowlibrary manifest is no plain object; schemastrict refuses the carrier before any import." };
+  const candidate = raw;
+  if (typeof candidate.id !== "string" || candidate.id.trim() === "") errors.push({ path: "id", expected: "string", found: typeof candidate.id, reason: "The flowlibrary manifest needs its id." });
+  if (typeof candidate.title !== "string" || candidate.title.trim() === "") errors.push({ path: "title", expected: "string", found: typeof candidate.title, reason: "The flowlibrary manifest needs its title." });
+  if (typeof candidate.description !== "string") errors.push({ path: "description", expected: "string", found: typeof candidate.description, reason: "The flowlibrary manifest needs its description." });
+  if (typeof candidate.version !== "string" || candidate.version.trim() === "") errors.push({ path: "version", expected: "string", found: typeof candidate.version, reason: "The flowlibrary manifest needs its version." });
+  if (typeof candidate.publisher !== "string" || candidate.publisher.trim() === "") errors.push({ path: "publisher", expected: "string", found: typeof candidate.publisher, reason: "The flowlibrary manifest names its publisher." });
+  if (!Array.isArray(candidate.steps) || candidate.steps.length === 0) errors.push({ path: "steps", expected: "array", found: Array.isArray(candidate.steps) ? "empty array" : typeof candidate.steps, reason: "The flowlibrary manifest declares its steps." });
+  if (Array.isArray(candidate.steps)) {
+    candidate.steps.forEach((step, index) => {
+      const shape = step;
+      if (!Boolean(shape) || typeof shape !== "object" || typeof shape.id !== "string" || shape.id.trim() === "" || typeof shape.kind !== "string" || shape.kind.trim() === "" || typeof shape.label !== "string") errors.push({ path: `steps.${index}`, expected: "flowlibrarystep", found: typeof step, reason: "Every flowlibrary step needs its id, kind and label." });
+    });
+  }
+  if (!Array.isArray(candidate.kinds) || candidate.kinds.length === 0) errors.push({ path: "kinds", expected: "array", found: typeof candidate.kinds, reason: "The flowlibrary manifest declares the action kinds its steps use." });
+  if (!Array.isArray(candidate.requiredgrants)) errors.push({ path: "requiredgrants", expected: "array", found: typeof candidate.requiredgrants, reason: "The flowlibrary manifest declares its required origin grants." });
+  if (!Array.isArray(candidate.dataexpectations)) errors.push({ path: "dataexpectations", expected: "array", found: typeof candidate.dataexpectations, reason: "The flowlibrary manifest declares its data expectations with minimization hints." });
+  if (typeof candidate.sensitive !== "boolean") errors.push({ path: "sensitive", expected: "boolean", found: typeof candidate.sensitive, reason: "The flowlibrary manifest marks whether it is sensitive." });
+  const unknownfields = Object.keys(candidate).filter((key) => !["id", "title", "description", "version", "publisher", "registry", "steps", "kinds", "requiredgrants", "dataexpectations", "sensitive", "publish"].includes(key));
+  for (const field of unknownfields) errors.push({ path: field, expected: "absent", found: "present", reason: `The flowlibrary manifest carries the unknown field ${field}; schemastrict refuses unknown fields.` });
+  const schemagate = librarymanifestgate({ errors });
+  if (!schemagate.allowed) return { ok: false, errors, reason: schemagate.reason ?? "The flowlibrary manifest fails schemastrict." };
+  const manifest = { id: candidate.id, title: candidate.title, description: candidate.description, version: candidate.version, publisher: candidate.publisher, ...typeof candidate.registry === "string" && candidate.registry.trim() !== "" ? { registry: candidate.registry } : {}, steps: candidate.steps.map((step) => ({ id: step.id, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {}, ...step.namespace !== void 0 ? { namespace: step.namespace } : {} })), kinds: candidate.kinds, requiredgrants: candidate.requiredgrants, dataexpectations: candidate.dataexpectations, sensitive: candidate.sensitive, ...isPublish(candidate.publish) ? { publish: candidate.publish } : {} };
+  const kinds = [...new Set(manifest.steps.map((step) => step.kind))];
+  const capabilitygate = librarycapabilitygate({ kinds, capabilities: input.capabilities });
+  if (!capabilitygate.allowed) return { ok: false, errors: [], reason: capabilitygate.reason ?? "", manifest };
+  return { ok: true, errors: [], reason: `The manifest ${manifest.id} of ${manifest.publisher} validates under schemastrict with ${manifest.steps.length} step${manifest.steps.length === 1 ? "" : "s"} and ${kinds.length} kind${kinds.length === 1 ? "" : "s"} inside the installed capability set.`, manifest };
+}
+function isPublish(value) {
+  if (!Boolean(value) || typeof value !== "object") return false;
+  const shape = value;
+  return typeof shape.publisher === "string" && shape.publisher.trim() !== "" && typeof shape.signature === "string" && shape.signature.trim() !== "" && typeof shape.digest === "string" && shape.digest.trim() !== "" && typeof shape.provenance === "string" && typeof shape.publishedat === "number";
+}
+async function verifypublishersignature(manifest) {
+  if (manifest.publish === void 0) return { verified: false, reason: `The manifest ${manifest.id} of ${manifest.publisher} carries no publisher signature; the entry quarantines until the user verifies its publisher.` };
+  const digest = await manifestdigest(manifest);
+  if (manifest.publish.digest !== digest) return { verified: false, reason: `The publisher signature of ${manifest.publish.publisher} covers the digest ${manifest.publish.digest} while the manifest body hashes to ${digest}; the verification refuses the signature in full.` };
+  if (manifest.publish.publisher !== manifest.publisher) return { verified: false, reason: `The publisher signature names ${manifest.publish.publisher} while the manifest carries the publisher ${manifest.publisher}; the verification refuses the signature in full.` };
+  const seal = await sha2563(`${manifest.publish.publisher}
+${manifest.publish.digest}
+${manifest.publish.provenance}`);
+  if (manifest.publish.signature !== seal) return { verified: false, reason: `The publisher signature of ${manifest.publish.publisher} seals neither the manifest digest nor its provenance; the verification refuses the signature in full.` };
+  return { verified: true, reason: `The publisher signature of ${manifest.publish.publisher} verifies over the manifest digest ${digest.slice(0, 12)}\u2026 with its provenance ${manifest.publish.provenance}.` };
+}
+async function signmanifest(manifest, provenance, publishedat) {
+  const digest = await manifestdigest(manifest);
+  return { publisher: manifest.publisher, signature: await sha2563(`${manifest.publisher}
+${digest}
+${provenance}`), digest, provenance, publishedat };
+}
+async function libraryentryof(input) {
+  const digest = await manifestdigest(input.manifest);
+  const verification = await verifypublishersignature(input.manifest);
+  const quarantinegate = libraryquarantinegate({ verified: verification.verified, signaturepresent: input.manifest.publish !== void 0, signaturevalid: verification.verified });
+  const state = quarantinegate.allowed ? "available" : "quarantined";
+  return { id: `${input.manifest.id}@${input.manifest.version}`, manifest: input.manifest, digest, state, provenance: `${input.provenance}; ${verification.reason}`, addedat: input.now };
+}
+function grantdiffof(input) {
+  const required = [...new Set(input.manifest.requiredgrants)];
+  const added = required.filter((origin) => !input.heldgrants.includes(origin));
+  const kept = required.filter((origin) => input.heldgrants.includes(origin));
+  const originmappings = required.map((origin) => ({ origin, kinds: [...new Set(input.manifest.steps.map((step) => step.kind))] }));
+  return { added, kept, originmappings };
+}
+function sensitiveconsentfor(manifest, freshconsent) {
+  const gate = librarysensitivegate({ sensitive: manifest.sensitive, freshconsent });
+  return { required: manifest.sensitive, reason: gate.reason ?? "" };
+}
+function libraryproposalof(entry) {
+  const gate = libraryimportgate({ proposal: true, planreviewed: true });
+  return { objective: `Install the flowlibrary template ${entry.manifest.title} version ${entry.manifest.version} of ${entry.manifest.publisher} with ${entry.manifest.steps.length} steps and ${entry.manifest.requiredgrants.length} required grant${entry.manifest.requiredgrants.length === 1 ? "" : "s"}.`, reviewed: true, reason: gate.reason ?? "" };
+}
+function manifestrisk(manifest) {
+  let risk = "read";
+  for (const step of manifest.steps) {
+    const candidate = actionrisk(step.kind);
+    if (candidate === "sensitive") return "sensitive";
+    if (candidate === "interaction") risk = "interaction";
+  }
+  return risk;
+}
+function installlibrary(input) {
+  const manifest = input.entry.manifest;
+  const prefix = input.selectornamespace?.trim() ?? "";
+  const steps = manifest.steps.map((step) => ({
+    id: `${manifest.id}-${step.id}`,
+    kind: step.kind,
+    label: step.label,
+    ...step.target !== void 0 ? { target: prefix === "" ? step.target : `${prefix} ${step.target}`.trim() } : {},
+    ...step.value !== void 0 ? { value: step.value } : {}
+  }));
+  return { id: `library:${manifest.id}:${manifest.version}`, name: manifest.title, version: 1, origins: [...new Set(manifest.requiredgrants)], steps, blocks: [], risk: manifestrisk(manifest), reviewstate: "pending", createdat: input.now };
+}
+function updatelibrary(input) {
+  if (input.incoming.digest === input.existing.digest) return { changedsteps: [], addedgrants: [], versionfrom: input.existing.manifest.version, versionto: input.incoming.manifest.version, replace: false, reason: `The incoming ${input.incoming.manifest.id} carries the same manifest digest as the installed entry; the update replaces nothing.` };
+  const existingsteps = new Set(input.existing.manifest.steps.map((step) => step.id));
+  const incomingsteps = new Set(input.incoming.manifest.steps.map((step) => step.id));
+  const changedsteps = [.../* @__PURE__ */ new Set([...existingsteps, ...incomingsteps])].filter((id) => {
+    const before = input.existing.manifest.steps.find((step) => step.id === id);
+    const after = input.incoming.manifest.steps.find((step) => step.id === id);
+    return before === void 0 || after === void 0 || before.kind !== after.kind || before.target !== after.target || before.value !== after.value;
+  });
+  const addedgrants = [...new Set(input.incoming.manifest.requiredgrants)].filter((origin) => !input.existing.manifest.requiredgrants.includes(origin));
+  return { changedsteps, addedgrants, versionfrom: input.existing.manifest.version, versionto: input.incoming.manifest.version, replace: true, reason: `The update of ${input.incoming.manifest.id} from version ${input.existing.manifest.version} to ${input.incoming.manifest.version} changes ${changedsteps.length} step${changedsteps.length === 1 ? "" : "s"} and adds ${addedgrants.length} grant${addedgrants.length === 1 ? "" : "s"}; the version diff surfaces before the replace.` };
+}
+function removelibrary(input) {
+  return { removed: input.entry.id, keptforks: input.forks.map((fork) => fork.id), reason: `The library entry ${input.entry.manifest.title} leaves the store while its ${input.forks.length} local fork${input.forks.length === 1 ? "" : "s"} stay untouched; a fork is an independent local workflow.` };
+}
+function forklibrary(input) {
+  const manifest = input.entry.manifest;
+  const steps = manifest.steps.map((step) => ({ id: `fork-${step.id}`, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.value !== void 0 ? { value: step.value } : {} }));
+  return { id: `fork:${manifest.id}:${input.now}`, name: `${manifest.title} fork`, version: 1, origins: [...new Set(manifest.requiredgrants)], steps, blocks: [], risk: manifestrisk(manifest), reviewstate: "pending", createdat: input.now };
+}
+function librarysearch(input) {
+  const query = input.query?.trim().toLowerCase() ?? "";
+  return input.entries.filter((entry) => {
+    if (input.filter?.publisher !== void 0 && entry.manifest.publisher !== input.filter.publisher) return false;
+    if (input.filter?.sensitive !== void 0 && entry.manifest.sensitive !== input.filter.sensitive) return false;
+    if (input.filter?.state !== void 0 && entry.state !== input.filter.state) return false;
+    if (query === "") return true;
+    return [entry.manifest.title, entry.manifest.description, entry.manifest.publisher].some((text2) => text2.toLowerCase().includes(query));
+  });
+}
+function librarybrowserow(entry) {
+  return { id: entry.id, title: entry.manifest.title, publisher: entry.manifest.publisher, version: entry.manifest.version, grants: entry.manifest.requiredgrants, sensitive: entry.manifest.sensitive, state: entry.state, ...entry.manifest.registry !== void 0 ? { registry: entry.manifest.registry } : {} };
+}
+function librarystepsview(entry) {
+  return entry.manifest.steps.map((step) => {
+    const expectations = entry.manifest.dataexpectations.filter((expectation) => expectation.stepid === step.id);
+    return { id: step.id, kind: step.kind, label: step.label, ...step.target !== void 0 ? { target: step.target } : {}, ...step.namespace !== void 0 ? { namespace: step.namespace } : {}, families: expectations.map((expectation) => expectation.family), fields: [...new Set(expectations.flatMap((expectation) => expectation.fields))] };
+  });
+}
+function dataexpectationssummary(manifest) {
+  const families = /* @__PURE__ */ new Map();
+  for (const expectation of manifest.dataexpectations) {
+    const entry = families.get(expectation.family) ?? { fields: /* @__PURE__ */ new Set(), steps: /* @__PURE__ */ new Set() };
+    for (const field of expectation.fields) entry.fields.add(field);
+    entry.steps.add(expectation.stepid);
+    families.set(expectation.family, entry);
+  }
+  return [...families.entries()].map(([family, entry]) => ({ family, fields: [...entry.fields], steps: [...entry.steps] }));
+}
+function libraryeventof(input) {
+  if (input.entryid.trim() === "") throw new Error("The library event needs its entry id.");
+  return { id: `libraryevent:${input.kind}:${input.entryid}:${input.now}`, kind: input.kind, entryid: input.entryid, title: input.title, version: input.version, detail: input.detail, at: input.now };
+}
+function exportlibrarymanifests(entries) {
+  return entries.map((entry) => ({ id: entry.id, title: entry.manifest.title, publisher: entry.manifest.publisher, version: entry.manifest.version, digest: entry.digest, state: entry.state, provenance: entry.provenance, addedat: entry.addedat }));
+}
+
+// syncbridge.ts
+async function sha2564(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("");
+}
+async function syncdigestof(manifest) {
+  const { publish, ...body } = manifest;
+  void publish;
+  return sha2564(JSON.stringify(body));
+}
+function syncbridgehookof(input) {
+  if (input.endpoint.trim() === "") throw new Error(`The ${input.provider} hook needs its user configured endpoint; no provider address is ever hardcoded.`);
+  const gate = syncbridgeoptingate({ optin: false });
+  if (gate.allowed) throw new Error("The syncbridge hook never starts with its opt in on; no hook ever defaults on.");
+  return { id: `sync:${input.provider}:${input.now}`, provider: input.provider, direction: input.direction, optin: false, endpoint: input.endpoint.trim(), state: "idle", createdat: input.now };
+}
+function syncbridgeoptinflip(hook, optin) {
+  return { ...hook, optin, state: "idle" };
+}
+function syncbridgeproviders() {
+  return [
+    { provider: "file", label: "File provider", operations: ["pull", "push", "list"], note: "The file provider moves manifests through manual import and export files the user picks; the bridge carries no secret and no log entry under any flag." },
+    { provider: "web", label: "Web provider stub", operations: ["pull", "push", "list"], note: "The web provider stays a stub behind its opt in gate: the endpoint stays the user's configured registry value and no network call ships before the ecosystem part two backend exists." }
+  ];
+}
+async function syncbridgeexportpayload(manifests) {
+  const digests = [];
+  for (const manifest of manifests) digests.push(await syncdigestof(manifest));
+  return { version: 1, kind: "syncbridge", manifests, digests, exclusions: ["secretvault values", "logs"] };
+}
+function syncbridgevalidate(payload) {
+  const carriessecrets = payload.secrets !== void 0 || Array.isArray(payload.manifests) && payload.manifests.some((manifest) => secretcarrying2(manifest));
+  const gate = syncbridgescopegate({ carriessecrets, carrieslogs: payload.logs !== void 0 });
+  if (!gate.allowed) return { ok: false, reason: gate.reason ?? "The syncbridge payload refuses." };
+  if (payload.kind !== "syncbridge") return { ok: false, reason: "The syncbridge payload names its kind; a foreign payload never imports." };
+  if (!Array.isArray(payload.manifests)) return { ok: false, reason: "The syncbridge payload carries its manifest list." };
+  return { ok: true, reason: `The syncbridge payload carries ${payload.manifests.length} manifest${payload.manifests.length === 1 ? "" : "s"} and no secret and no log entry; the bridge moves manifests only.` };
+}
+function secretcarrying2(record2) {
+  if (record2 === null || typeof record2 !== "object") return false;
+  const entries = Object.entries(record2);
+  const secretkeys = ["secret", "token", "password", "apikey", "authorization"];
+  return entries.some(([key, value]) => secretkeys.some((shape) => key.toLowerCase().includes(shape)) && typeof value === "string" && value.trim() !== "");
+}
+async function syncbridgescan(input) {
+  const gate = syncbridgeoptingate({ optin: input.hook.optin });
+  if (!gate.allowed) return { conflicts: [], synced: [], reason: gate.reason ?? "" };
+  const conflicts = [];
+  const synced = [];
+  for (const remotemanifest of input.remote) {
+    const localmanifest = input.local.find((candidate) => candidate.manifestid === remotemanifest.manifestid);
+    if (localmanifest === void 0) {
+      synced.push(remotemanifest.manifestid);
+      continue;
+    }
+    if (localmanifest.digest === remotemanifest.digest) {
+      synced.push(remotemanifest.manifestid);
+      continue;
+    }
+    conflicts.push({ id: `conflict:${remotemanifest.manifestid}:${input.now}`, hookid: input.hook.id, manifestid: remotemanifest.manifestid, local: { digest: localmanifest.digest, version: localmanifest.version }, remote: { digest: remotemanifest.digest, version: remotemanifest.version }, detectedat: input.now });
+  }
+  return { conflicts, synced, reason: `The ${input.hook.provider} hook of ${input.hook.endpoint} scanned ${input.remote.length} remote manifest${input.remote.length === 1 ? "" : "s"} against ${input.local.length} local entr${input.local.length === 1 ? "y" : "ies"}: ${synced.length} moved while ${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"} surfaced both versions instead of a silent overwrite.` };
+}
+function resolveconflict(conflict, resolution, now) {
+  if (conflict.resolution !== void 0) throw new Error(`The conflict ${conflict.id} already resolved at ${conflict.resolvedat}; one conflict resolves exactly once.`);
+  return { ...conflict, resolution, resolvedat: now };
+}
+function conflictsfor(conflicts, hookid) {
+  return hookid === void 0 ? conflicts : conflicts.filter((conflict) => conflict.hookid === hookid);
+}
+function webproviderstub(hook) {
+  const gate = syncbridgeoptingate({ optin: hook.optin });
+  return { hookid: hook.id, endpoint: hook.endpoint, optin: hook.optin, operations: ["pull", "push", "list"], stub: true, reason: gate.allowed ? `The web provider of ${hook.endpoint} stays a stub behind its explicit opt in; the ecosystem part two backend brings its network path.` : gate.reason ?? "" };
+}
+function fileproviderof(hook) {
+  return { hookid: hook.id, operations: [{ kind: "pull", label: "Pull the manifests of one dropped syncbridge file" }, { kind: "push", label: "Push the local manifests into one export file" }, { kind: "list", label: "List the manifests the hook carries" }] };
+}
+
+// attentionfeed.ts
+function attentionseverityof(cause) {
+  if (cause === "gatewait" || cause === "phishguard") return "critical";
+  if (cause === "deferral") return "warning";
+  return "info";
+}
+function attentiondeeplinkof(cause, runid, gateref) {
+  if (cause === "gatewait") return `devthink://gate/${encodeURIComponent(gateref ?? "unknown")}?run=${encodeURIComponent(runid)}`;
+  if (cause === "phishguard") return `devthink://phishguard?run=${encodeURIComponent(runid)}`;
+  if (cause === "deferral") return `devthink://deferred?run=${encodeURIComponent(runid)}`;
+  return `devthink://error?run=${encodeURIComponent(runid)}`;
+}
+function attentionentryof(input) {
+  if (input.runid.trim() === "") throw new Error("The attention entry needs its run ref.");
+  if (input.summary.trim() === "") throw new Error("The attention entry needs its summary in plain language.");
+  return { id: `attention:${input.cause}:${input.runid}:${input.gateref ?? "none"}`, cause: input.cause, severity: attentionseverityof(input.cause), runid: input.runid, ...input.gateref !== void 0 && input.gateref.trim() !== "" ? { gateref: input.gateref } : {}, origin: input.origin, summary: input.summary, deeplink: attentiondeeplinkof(input.cause, input.runid, input.gateref), at: input.at };
+}
+function collectattention(input) {
+  const entries = [];
+  for (const wait of input.gatewaits ?? []) entries.push(attentionentryof({ cause: "gatewait", runid: wait.runid, origin: wait.origin, summary: `The ${wait.kind} gate of the step ${wait.stepid} waits ${wait.waitedms} milliseconds for one human action.`, gateref: wait.gateid, at: input.now }));
+  for (const block of input.phishblocks ?? []) entries.push(attentionentryof({ cause: "phishguard", runid: block.runid, origin: block.origin, summary: `The phishguard blocked a credential step on ${block.origin} that resembles the granted ${block.matchedorigin}: ${block.reason}`, at: input.now }));
+  for (const deferral of input.deferrals ?? []) entries.push(attentionentryof({ cause: "deferral", runid: deferral.runid, origin: deferral.origin, summary: `A command deferred past its rate window on ${deferral.origin}: ${deferral.reason}`, at: input.now }));
+  for (const failure of input.failures ?? []) entries.push(attentionentryof({ cause: "failure", runid: failure.runid, origin: failure.origin, summary: `The step ${failure.stepid} failed: ${failure.message}`, at: input.now }));
+  return entries;
+}
+function dedupeattention(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const entry of [...entries].sort((a, b) => a.at - b.at)) {
+    const key = `${entry.cause}:${entry.runid}:${entry.gateref ?? "none"}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    kept.push(entry);
+  }
+  return kept;
+}
+function rankattention(entries) {
+  const order = { critical: 0, warning: 1, info: 2 };
+  return [...entries].sort((a, b) => order[a.severity] - order[b.severity] || b.at - a.at);
+}
+function attentioncountof(entries) {
+  return rankattention(dedupeattention(entries)).length;
+}
+function dismissattention(entries, id) {
+  return entries.filter((entry) => entry.id !== id);
+}
+function pruneattention(entries, retention, now) {
+  if (retention === void 0) return { kept: entries, pruned: [] };
+  const kept = entries.filter((entry) => now - entry.at < retention);
+  return { kept, pruned: entries.filter((entry) => now - entry.at >= retention).map((entry) => entry.id) };
+}
+function attentionnotifications(entries, now) {
+  return rankattention(dedupeattention(entries)).map((entry) => ({ id: `notify:${entry.id}`, kind: "attention", title: entry.cause === "gatewait" ? "A gate waits for you" : entry.cause === "phishguard" ? "The phishguard blocked a step" : entry.cause === "deferral" ? "A command deferred" : "A step failed", body: entry.summary, deeplink: entry.deeplink, runid: entry.runid, ...entry.gateref !== void 0 ? { stepid: entry.gateref } : {}, content: false, at: now }));
+}
+
+// backgroundruns.ts
+function backgroundqueueentryof(input) {
+  if (input.workflowid.trim() === "") throw new Error("The background queue entry needs its workflow id.");
+  return { id: `background:${input.workflowid}:${input.now}`, workflowid: input.workflowid, state: "queued", keepaliveheld: false, queuedat: input.now, summary: input.summary };
+}
+function enqueuebackgroundrun(input) {
+  return [...input.queue, backgroundqueueentryof({ workflowid: input.workflowid, summary: input.summary, now: input.now })];
+}
+function nextbackgroundrun(queue) {
+  return [...queue].filter((entry) => entry.state === "queued").sort((a, b) => a.queuedat - b.queuedat)[0];
+}
+function beginbackgroundrun(entry, now, reviewed) {
+  const gate = backgroundrungate({ reviewed, keepaliveheld: true });
+  return { entry: gate.allowed ? { ...entry, state: "running", keepaliveheld: true, startedat: now } : entry, gate: { allowed: gate.allowed, reason: gate.reason ?? "" } };
+}
+function finishbackgroundrun(entry, state, now) {
+  return { ...entry, state, keepaliveheld: false, endedat: now };
+}
+function resumebackgroundqueue(queue, now) {
+  const requeued = [];
+  const next = queue.map((entry) => {
+    if (entry.state !== "running") return entry;
+    requeued.push(entry.id);
+    const { startedat, ...rest } = entry;
+    void startedat;
+    return { ...rest, state: "queued", keepaliveheld: false };
+  });
+  void now;
+  return { queue: next, requeued };
+}
+function backgroundrunattention(entry, origin) {
+  if (entry.state === "failed") return { cause: "failure", runid: entry.id, origin, summary: `The background run of ${entry.workflowid} failed: ${entry.summary}` };
+  if (entry.state === "queued") return { cause: "deferral", runid: entry.id, origin, summary: `The background run of ${entry.workflowid} waits for its executor turn.` };
+  return void 0;
+}
+function backgroundrunsview(queue) {
+  return queue.map((entry) => ({ id: entry.id, workflowid: entry.workflowid, state: entry.state, keepaliveheld: entry.keepaliveheld, queuedat: entry.queuedat, ...entry.startedat !== void 0 ? { startedat: entry.startedat } : {}, ...entry.endedat !== void 0 ? { endedat: entry.endedat } : {}, summary: entry.summary, progress: entry.state === "running" ? `Running with the keepalive signal held since ${entry.startedat ?? entry.queuedat}` : entry.state === "queued" ? "Queued for the next executor turn" : entry.state === "done" ? "Completed in the background" : "Failed; the attentionfeed carries the cause" }));
+}
+function backgroundtrayrows(queue, origin) {
+  return queue.filter((entry) => entry.state === "done" || entry.state === "failed").map((entry) => ({ runid: entry.id, origin, outcome: entry.state === "done" ? "completed" : "failed", title: `Background run of ${entry.workflowid}`, at: entry.endedat ?? entry.queuedat, resumable: false, reopenable: true }));
+}
+function cancelbackgroundentry(queue, id) {
+  const cancelled = [];
+  const next = queue.filter((entry) => {
+    if (entry.id === id && entry.state === "queued") {
+      cancelled.push(entry.id);
+      return false;
+    }
+    return true;
+  });
+  return { queue: next, cancelled };
+}
+
+// runreplay.ts
+function restoredrefsof(entry) {
+  const observation = /observation (\d+)/i.exec(entry.summary);
+  const capture = /capture ([a-z0-9-]+)/i.exec(entry.summary);
+  return { ...observation !== null ? { observationversion: Number(observation[1]) } : {}, ...capture !== null ? { captureid: capture[1] } : {} };
+}
+function replaystepof(entry, index, gates) {
+  const refs = restoredrefsof(entry);
+  return { stepid: entry.stepid ?? entry.id, index, summary: entry.summary, ...refs.observationversion !== void 0 ? { observationversion: refs.observationversion } : {}, ...refs.captureid !== void 0 ? { captureid: refs.captureid } : {}, gateresolutions: entry.stepid === void 0 ? [] : gates.filter((gate) => gate.gateid === entry.stepid) };
+}
+function runreplaysessionof(input) {
+  if (input.runid.trim() === "") throw new Error("The runreplay session needs its recorded run id.");
+  if (input.entries.length === 0) throw new Error("The runreplay session needs at least one verified log entry to walk.");
+  const steps = input.entries.map((entry, index) => replaystepof(entry, index, input.gates ?? []));
+  return { id: `replay:${input.runid}:${input.now}`, runid: input.runid, cursor: 0, playing: false, steps, openedat: input.now, actions: [] };
+}
+function replaymove(session, direction, now) {
+  const next = direction === "forward" ? Math.min(session.steps.length - 1, session.cursor + 1) : Math.max(0, session.cursor - 1);
+  const step = session.steps[next];
+  return { ...session, cursor: next, playing: false, actions: [...session.actions, { kind: "step", at: now, ...step !== void 0 ? { stepid: step.stepid } : {} }] };
+}
+function replayjump(session, stepid, now) {
+  const index = session.steps.findIndex((step) => step.stepid === stepid);
+  if (index === -1) throw new Error(`The runreplay knows no ${stepid} step in the recorded chain of ${session.runid}.`);
+  return { ...session, cursor: index, playing: false, actions: [...session.actions, { kind: "jump", stepid, at: now }] };
+}
+function replayplay(session, playing, now) {
+  return { ...session, playing, actions: [...session.actions, { kind: playing ? "play" : "pause", at: now }] };
+}
+function replayviewaction(session, action) {
+  return { ...session, actions: [...session.actions, { kind: action.kind, ...action.stepid !== void 0 ? { stepid: action.stepid } : {}, at: action.at }] };
+}
+function replayrestoredview(step) {
+  return { stepid: step.stepid, index: step.index, summary: step.summary, ...step.observationversion !== void 0 ? { observationversion: step.observationversion } : {}, ...step.captureid !== void 0 ? { captureid: step.captureid } : {}, gateresolutions: step.gateresolutions };
+}
+function replaycursorof(session) {
+  return { runid: session.runid, cursor: session.cursor, playing: session.playing };
+}
+
+// outputcompare.ts
+function taskinputsignatureof(input) {
+  return `${input.objective.trim()}|${input.steps.length}|${input.steps.join(",")}`;
+}
+function comparemetricdefaults() {
+  return ["agreement", "divergence", "durationdelta"];
+}
+function joinruns(logsa, logsb) {
+  const sequence = [];
+  for (const entry of logsa) if (!sequence.includes(entry.stepid)) sequence.push(entry.stepid);
+  for (const entry of logsb) if (!sequence.includes(entry.stepid)) sequence.push(entry.stepid);
+  return sequence.map((stepid, index) => {
+    const a = logsa.find((entry) => entry.stepid === stepid);
+    const b = logsb.find((entry) => entry.stepid === stepid);
+    return { stepid, index, ...a !== void 0 ? { a } : {}, ...b !== void 0 ? { b } : {} };
+  });
+}
+function stepcomparisonof(pair) {
+  const a = pair.a;
+  const b = pair.b;
+  if (a === void 0 || b === void 0) return { stepid: pair.stepid, index: pair.index, agreement: "onlyone", summarya: a?.summary ?? "", summaryb: b?.summary ?? "", durationdelta: 0 };
+  const agree = a.state === b.state && a.summary === b.summary;
+  return { stepid: pair.stepid, index: pair.index, agreement: agree ? "agree" : "diverge", summarya: a.summary, summaryb: b.summary, durationdelta: a.duration - b.duration };
+}
+function firstdivergenceof(steps) {
+  const divergent = steps.find((step) => step.agreement !== "agree");
+  return divergent === void 0 ? void 0 : divergent.index;
+}
+function outputcomparesessionof(input) {
+  if (input.runids[0].trim() === "" || input.runids[1].trim() === "") throw new Error("The outputcompare session needs both run ids.");
+  if (input.runids[0] === input.runids[1]) throw new Error("The outputcompare session compares two distinct runs; one run never stands beside itself.");
+  const metrics = input.metrics ?? comparemetricdefaults();
+  const steps = joinruns(input.logsa, input.logsb).map((pair) => stepcomparisonof(pair));
+  const firstdivergence = firstdivergenceof(steps);
+  return { id: `compare:${input.runids[0]}:${input.runids[1]}:${input.now}`, runids: input.runids, metrics, steps, ...firstdivergence !== void 0 ? { firstdivergence } : {}, openedat: input.now };
+}
+function comparesessionmetrics(session) {
+  const agree = session.steps.filter((step) => step.agreement === "agree").length;
+  const diverge = session.steps.filter((step) => step.agreement === "diverge").length;
+  const onlyone = session.steps.filter((step) => step.agreement === "onlyone").length;
+  return { metrics: session.metrics, agree, diverge, onlyone, ...session.firstdivergence !== void 0 ? { firstdivergence: session.firstdivergence } : {}, reason: `The comparison of ${session.runids[0]} and ${session.runids[1]} graded ${agree} agreeing, ${diverge} divergent and ${onlyone} single run step${agree + diverge + onlyone === 1 ? "" : "s"} under the metric set ${session.metrics.join(", ")}${session.firstdivergence !== void 0 ? ` with the first divergence at step index ${session.firstdivergence}` : " with agreement across the whole sequence"}.` };
+}
+function outputcompareview(session) {
+  return session.steps.map((step) => ({ stepid: step.stepid, index: step.index, agreement: step.agreement, summarya: step.summarya, summaryb: step.summaryb, durationdelta: step.durationdelta, highlighted: session.firstdivergence !== void 0 && step.index === session.firstdivergence }));
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -15044,6 +15646,9 @@ function surfacesnapshot(input) {
 function interfaceviews(input) {
   return { version: protocolversion, ...input.datagrid !== void 0 ? { datagrid: input.datagrid } : {}, exportmenu: input.exportmenu, badge: input.badge, recenttray: input.recenttray, toasts: input.toasts, appearance: input.appearance };
 }
+function ecosystemviews(input) {
+  return { version: protocolversion, library: input.library, installed: input.installed, syncbridge: input.syncbridge, attention: input.attention, backgroundruns: input.backgroundruns, ...input.replay !== void 0 ? { replay: input.replay } : {}, ...input.compare !== void 0 ? { compare: input.compare } : {} };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -15807,6 +16412,11 @@ export {
   attachcdpsession,
   attachtargetof,
   attachtimeline,
+  attentioncountof,
+  attentiondeeplinkof,
+  attentionentryof,
+  attentionnotifications,
+  attentionseverityof,
   auditexcerptof,
   authconsentgranted,
   authorizeurl,
@@ -15814,11 +16424,17 @@ export {
   authreport,
   autointervalof,
   automationallowlistgate,
+  backgroundqueueentryof,
+  backgroundrunattention,
+  backgroundrungate,
+  backgroundrunsview,
+  backgroundtrayrows,
   backoffdelay,
   badgecolorof,
   badgetextof,
   batchreport,
   beatrun,
+  beginbackgroundrun,
   bindlocalhost,
   bindparam,
   bindvariables,
@@ -15864,6 +16480,7 @@ export {
   callmodel,
   callrest,
   callsreport,
+  cancelbackgroundentry,
   cancelframes,
   cancellederror,
   cancelrun,
@@ -15909,12 +16526,15 @@ export {
   closeidlechannels,
   closeoffscreen,
   closerun,
+  collectattention,
   collectmessages,
   collectresults,
   commandguard,
+  comparemetricdefaults,
   compareoutputs,
   comparepairof,
   comparepairsforsteps,
+  comparesessionmetrics,
   complete,
   composeworkflow,
   conditionof,
@@ -15922,6 +16542,7 @@ export {
   confirmdeletegate,
   confirmmanualrun,
   confirmpaygate,
+  conflictsfor,
   connectallowentryof,
   connectallowgate,
   connectallowlist,
@@ -15963,12 +16584,14 @@ export {
   crossesviewport,
   cursorfrom,
   darklighttokensof,
+  dataexpectationssummary,
   datagridcolumnsof,
   datagridof,
   datasetresponse,
   debuggate,
   debuggerconsentcovers,
   debugwaitbudgetallowed,
+  dedupeattention,
   dedupeimages,
   defaultapprovalwindowms,
   defaultchallengelifetimems,
@@ -16003,6 +16626,7 @@ export {
   diffversions,
   disarmkillswitch,
   disconnectclient,
+  dismissattention,
   dispatchtool,
   distillrunsummary,
   domainkinds,
@@ -16013,6 +16637,7 @@ export {
   dryrunprojection,
   dryrunreport,
   dryrunworkflow,
+  ecosystemviews,
   editedcorrectionof,
   editnote,
   editorsavegate,
@@ -16032,6 +16657,7 @@ export {
   emulationstateof,
   enforcemaxclients,
   enqueue,
+  enqueuebackgroundrun,
   enqueuerequest,
   entryfresh,
   entryhashof,
@@ -16069,6 +16695,7 @@ export {
   expirnotes,
   exportcontentreview,
   exportdatagrid,
+  exportlibrarymanifests,
   exportlogchain,
   exportmenudescriptors,
   exportpresetlibrary,
@@ -16091,16 +16718,20 @@ export {
   fetchrequestof,
   fieldshapekind,
   fieldshaperegions,
+  fileproviderof,
   filterdatagridrows,
   filteredsessions,
   filterentries,
   filterexchanges,
   filterlogstream,
+  finishbackgroundrun,
   finishrecording,
+  firstdivergenceof,
   fixedheadermatch,
   flowmetricnames,
   flowspecof,
   foreachof,
+  forklibrary,
   formpayloadof,
   formreportresponse,
   framedlog,
@@ -16112,6 +16743,7 @@ export {
   gatestateof,
   generatedvalueallowed,
   grantallowlistentry,
+  grantdiffof,
   graphqlopenvelope,
   graphqlrequestof,
   groupselect,
@@ -16159,6 +16791,7 @@ export {
   inheritconsent,
   initialize,
   inmemoryvault,
+  installlibrary,
   interfaceviews,
   interleavetimeline,
   iscdpkind,
@@ -16181,6 +16814,7 @@ export {
   iswatchkind,
   isworkflowkind,
   joinbranches,
+  joinruns,
   jsonpathrulesof,
   keepalivegate,
   keepaliveintervalvalid,
@@ -16195,6 +16829,18 @@ export {
   layernames,
   layoutreport,
   levelrank,
+  librarybrowserow,
+  librarycapabilitygate,
+  libraryentryof,
+  libraryeventof,
+  librarygrantgate,
+  libraryimportgate,
+  librarymanifestgate,
+  libraryproposalof,
+  libraryquarantinegate,
+  librarysearch,
+  librarysensitivegate,
+  librarystepsview,
   listapprovals,
   listdue,
   listremotestatus,
@@ -16225,6 +16871,7 @@ export {
   lookalikedistance,
   loopof,
   mailboxof,
+  manifestdigest,
   manualpreview,
   manualrunpreview,
   mapresponse,
@@ -16286,6 +16933,7 @@ export {
   newsessiondiff,
   newsessionrecord,
   newworkflowrun,
+  nextbackgroundrun,
   nextrequest,
   nobatchresolution,
   nonceof,
@@ -16326,6 +16974,10 @@ export {
   originprofilegate,
   originprofileof,
   outcomeresponse,
+  outputcomparegate,
+  outputcomparereadonlygate,
+  outputcomparesessionof,
+  outputcompareview,
   overlayslider,
   overrideinputof,
   overridematches,
@@ -16418,6 +17070,7 @@ export {
   providervalid,
   proxygate,
   proxyrouteof,
+  pruneattention,
   prunerunstates,
   prunescratchpad,
   publishmessage,
@@ -16431,6 +17084,7 @@ export {
   quickactionsfor,
   randomid,
   rankapis,
+  rankattention,
   rankcandidates,
   rankrecall,
   ratelimitboundsvalid,
@@ -16480,6 +17134,7 @@ export {
   releaselock,
   releaserunlock,
   removeedge,
+  removelibrary,
   removenode,
   removetemplate,
   rendermessage,
@@ -16493,8 +17148,15 @@ export {
   replannonfail,
   replanreviewgate,
   replayagentrun,
+  replaycursorof,
+  replayjump,
+  replaymove,
+  replayplay,
+  replayrestoredview,
+  replaystepof,
   replaytrace,
   replayurl,
+  replayviewaction,
   reportstep,
   requestbody,
   requestreview,
@@ -16505,6 +17167,7 @@ export {
   resolutionverdict,
   resolveappearance,
   resolveapproval,
+  resolveconflict,
   resolvedrisk,
   resolveescalation,
   resolvegate,
@@ -16520,6 +17183,7 @@ export {
   restoreplanof,
   restorereviewgranted,
   resumeall,
+  resumebackgroundqueue,
   resumehandoff,
   resumeone,
   retireentries,
@@ -16561,6 +17225,8 @@ export {
   runloop,
   runparallel,
   runrepeatuntil,
+  runreplaygate,
+  runreplaysessionof,
   runreviewgranted,
   runstep,
   runsummarytask,
@@ -16613,6 +17279,7 @@ export {
   sendmessage,
   sensitiveclassesof,
   sensitiveclassgate,
+  sensitiveconsentfor,
   sensitivepipelingate,
   sequenceintegrity,
   serializearg,
@@ -16651,6 +17318,7 @@ export {
   shotpanelpan,
   shotpanelzoom,
   signalsreport,
+  signmanifest,
   sitenoteof,
   sitenotesreadgate,
   sitenoteswritegate,
@@ -16680,6 +17348,7 @@ export {
   statusclassof,
   steal,
   stepapprovegate,
+  stepcomparisonof,
   stepenvironmentvalid,
   stepmodeof,
   stepresolutionof,
@@ -16713,6 +17382,15 @@ export {
   swarmstateof,
   swarmstatereport,
   sweepreviews,
+  syncbridgeexportpayload,
+  syncbridgehookof,
+  syncbridgeoptinflip,
+  syncbridgeoptingate,
+  syncbridgeproviders,
+  syncbridgescan,
+  syncbridgescopegate,
+  syncbridgevalidate,
+  syncdigestof,
   tabreportresponse,
   tabsessionkey,
   tabsessionrefof,
@@ -16721,6 +17399,7 @@ export {
   taskhistoryafter,
   taskinputof,
   taskinputproposalgate,
+  taskinputsignatureof,
   taskstatechecksum,
   taskstateof,
   taskstatevalid,
@@ -16783,6 +17462,7 @@ export {
   unreadcount,
   untrustedrendergate,
   unwrapgraphql,
+  updatelibrary,
   updaterule,
   urlencodeform,
   usagetotals,
@@ -16791,6 +17471,7 @@ export {
   validatefieldmatch,
   validateformrecord,
   validateframe,
+  validatemanifest,
   validateregexrule,
   validatesiteoverride,
   validatestep,
@@ -16812,6 +17493,7 @@ export {
   verifyauth,
   verifylogchain,
   verifylogstream,
+  verifypublishersignature,
   verifytoken,
   verifywebhook,
   visitmatch,
@@ -16823,6 +17505,7 @@ export {
   watchexpressionof,
   watchgate,
   webhooksecretok,
+  webproviderstub,
   whileof,
   wildcardentry,
   windowgatesstep,