unbrowse 9.0.4 → 9.2.0

package/runtime/cli.js

@@ -5,6 +5,7 @@ var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
@@ -31,6 +32,23 @@ var __toESM = (mod, isNodeMode, target) => {
     cache.set(mod, to);
   return to;
 };
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -6131,6 +6149,98 @@ async function payAndRetry(fullUrl, options) {
 var LOBSTER_PAY_TIMEOUT_MS = 30000, cachedCommand2 = undefined;
 var init_lobster_pay = () => {};
 
+// .tmp-runtime-src/proof/input-censor.ts
+var exports_input_censor = {};
+__export(exports_input_censor, {
+  isSensitiveFieldName: () => isSensitiveFieldName,
+  commitValue: () => commitValue,
+  censorSkillForPersistence: () => censorSkillForPersistence,
+  censorInputBody: () => censorInputBody
+});
+import { createHash as createHash5 } from "node:crypto";
+function looksLikePointer(v) {
+  return /^(op|keychain|bw|arg|vault):\/\//.test(v);
+}
+function commitValue(value) {
+  return `sha256:${createHash5("sha256").update(value).digest("hex")}`;
+}
+function isSensitiveFieldName(name) {
+  return SENSITIVE_FIELD.test(name);
+}
+function censorInputBody(body, prefix = "") {
+  const commitments = {};
+  let didCensor = false;
+  const walk = (val, keyName, path2) => {
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const out = {};
+      for (const [k, v] of Object.entries(val)) {
+        out[k] = walk(v, k, path2 ? `${path2}.${k}` : k);
+      }
+      return out;
+    }
+    if (Array.isArray(val)) {
+      return val.map((v, i) => walk(v, keyName, `${path2}[${i}]`));
+    }
+    const sensitive = isSensitiveFieldName(keyName) || typeof val === "string" && looksLikePointer(val);
+    if (sensitive && (typeof val === "string" || typeof val === "number" || typeof val === "boolean")) {
+      const commitment = commitValue(String(val));
+      commitments[path2 || keyName] = commitment;
+      didCensor = true;
+      return commitment;
+    }
+    return val;
+  };
+  const censored = walk(body, prefix, prefix);
+  return { censored, commitments, didCensor };
+}
+function censorSkillForPersistence(skill) {
+  if (!skill || !Array.isArray(skill.endpoints))
+    return { skill, didCensor: false };
+  let didCensor = false;
+  const endpoints = skill.endpoints.map((ep) => {
+    const method = String(ep.method ?? "GET").toUpperCase();
+    const body = ep.body;
+    if (method === "GET" || method === "HEAD" || body == null)
+      return ep;
+    const res = censorInputBody(body);
+    if (!res.didCensor)
+      return ep;
+    didCensor = true;
+    return {
+      ...ep,
+      body: res.censored,
+      input_commitments: res.commitments
+    };
+  });
+  if (!didCensor)
+    return { skill, didCensor: false };
+  return { skill: { ...skill, endpoints }, didCensor: true };
+}
+var SENSITIVE_FIELD;
+var init_input_censor = __esm(() => {
+  SENSITIVE_FIELD = new RegExp([
+    "pass(word|wd|phrase)?",
+    "secret",
+    "token",
+    "api[_-]?key",
+    "apikey",
+    "auth(orization|_token)?",
+    "access[_-]?key",
+    "client[_-]?secret",
+    "private[_-]?key",
+    "mnemonic",
+    "seed[_-]?phrase",
+    "ssn",
+    "credit[_-]?card",
+    "card[_-]?number",
+    "cvv",
+    "pin",
+    "otp",
+    "session[_-]?id",
+    "cookie"
+  ].join("|"), "i");
+});
+
 // .tmp-runtime-src/client/index.ts
 var exports_client = {};
 __export(exports_client, {
@@ -6171,6 +6281,7 @@ __export(exports_client, {
   looksLikeSkillId: () => looksLikeSkillId,
   loadConfig: () => loadConfig,
   listSkills: () => listSkills,
+  listLocalSkills: () => listLocalSkills,
   isX402Error: () => isX402Error,
   isValidAgentEmail: () => isValidAgentEmail,
   isLocalOnlyMode: () => isLocalOnlyMode,
@@ -6209,7 +6320,7 @@ __export(exports_client, {
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, existsSync as existsSync12, mkdirSync as mkdirSync5, readdirSync as readdirSync3, unlinkSync } from "fs";
 import { join as join15 } from "path";
 import { homedir as homedir13, hostname, release as osRelease } from "os";
-import { randomBytes as randomBytes5, createHash as createHash5 } from "crypto";
+import { randomBytes as randomBytes5, createHash as createHash6 } from "crypto";
 import { createInterface } from "readline";
 import { execSync as execSync2 } from "child_process";
 function getApiBaseUrl() {
@@ -6553,7 +6664,7 @@ function getApiKey() {
 function hashApiKey(key) {
   if (!key || key === "local-only")
     return "";
-  return createHash5("sha256").update(key).digest("hex");
+  return createHash6("sha256").update(key).digest("hex");
 }
 function getAgentId() {
   const config = loadConfig();
@@ -7127,7 +7238,9 @@ function writeSkillCache(skill, scopeId) {
         }
       }
     }
-    writeFileSync4(skillCachePath(skill.skill_id), JSON.stringify(skill), "utf-8");
+    const { censorSkillForPersistence: censorSkillForPersistence2 } = (init_input_censor(), __toCommonJS(exports_input_censor));
+    const { skill: persistable } = censorSkillForPersistence2(skill);
+    writeFileSync4(skillCachePath(skill.skill_id), JSON.stringify(persistable), "utf-8");
   } catch {}
 }
 function cachePublishedSkill(skill, scopeId) {
@@ -7169,6 +7282,29 @@ function getRecentLocalSkill(skillId, scopeId) {
   }
   return null;
 }
+function listLocalSkills() {
+  const bySkillId = new Map;
+  for (const s of recentLocalSkills.values()) {
+    if (s?.skill_id)
+      bySkillId.set(s.skill_id, s);
+  }
+  try {
+    const dir = getSkillCacheDir();
+    if (existsSync12(dir)) {
+      for (const f of readdirSync3(dir)) {
+        if (!f.endsWith(".json"))
+          continue;
+        const id = f.slice(0, -5);
+        if (bySkillId.has(id))
+          continue;
+        const s = readSkillCache(id);
+        if (s?.skill_id)
+          bySkillId.set(s.skill_id, s);
+      }
+    }
+  } catch {}
+  return [...bySkillId.values()];
+}
 function normalizeIntent(value) {
   return (value ?? "").trim().toLowerCase();
 }
@@ -8713,7 +8849,7 @@ function helpExit(subcommand, spec, opts = {}) {
 var EX_USAGE = 64, EX_SOFTWARE = 70, EX_GENERIC = 1;
 
 // .tmp-runtime-src/cli-v7/_stateless.ts
-import { randomBytes as randomBytes6, createHash as createHash6 } from "node:crypto";
+import { randomBytes as randomBytes6, createHash as createHash7 } from "node:crypto";
 function bytesToHex4(b) {
   let h = "";
   for (let i = 0;i < b.length; i++)
@@ -8738,7 +8874,7 @@ function freshNonce() {
   return bytesToBase642(new Uint8Array(randomBytes6(32)));
 }
 async function deriveCacheKeyFromSignature(signature) {
-  const hashHex = createHash6("sha256").update(signature).digest("hex");
+  const hashHex = createHash7("sha256").update(signature).digest("hex");
   return hashHex.slice(0, 32);
 }
 function sanitizeErrorHint(err) {
@@ -8887,15 +9023,15 @@ var init__stateless = __esm(() => {
 });
 
 // .tmp-runtime-src/cli-v7/_act-audit.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function sha256Hex(s) {
-  return createHash7("sha256").update(s, "utf8").digest("hex");
+  return createHash8("sha256").update(s, "utf8").digest("hex");
 }
 function deriveBreathActContextHash(sessionId, actType, selector, url, nowMs = Date.now()) {
   const bucket = Math.floor(nowMs / FIVE_MINUTES_MS).toString();
   const sel = selector ?? "";
   const payload = `${sessionId}:${actType}:${sel}:${url}:${bucket}`;
-  return createHash7("sha256").update(payload, "utf8").digest("hex");
+  return createHash8("sha256").update(payload, "utf8").digest("hex");
 }
 async function emitBreathActStateless(input) {
   const nowMs = input.nowMs ?? Date.now();
@@ -49720,12 +49856,12 @@ import {
 } from "node:fs/promises";
 import { homedir as homedir17 } from "node:os";
 import { join as join21 } from "node:path";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 function statelessTmpRoot() {
   return join21(homedir17(), ".unbrowse", "tmp");
 }
 function sessionTmpDir(sessionId) {
-  const hash = createHash8("sha256").update(sessionId).digest("hex").slice(0, 16);
+  const hash = createHash9("sha256").update(sessionId).digest("hex").slice(0, 16);
   return join21(statelessTmpRoot(), hash);
 }
 function sessionPath(sessionId) {
@@ -49920,7 +50056,7 @@ var init_go = __esm(() => {
 });
 
 // .tmp-runtime-src/values/adapters/arg.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function walkPath(scope, path11) {
   const segs = path11.split("/").filter((s) => s.length > 0);
   if (segs.length === 0) {
@@ -49983,7 +50119,7 @@ class ArgAdapter {
     }
     const raw = walkPath(ctx.argScope, pointer.path);
     const value = valueToBytes(raw);
-    const h = createHash9("sha256");
+    const h = createHash10("sha256");
     h.update(value);
     h.update(nonce);
     const commitment = new Uint8Array(h.digest());
@@ -50085,7 +50221,7 @@ var init_stderr_filter = __esm(() => {
 
 // .tmp-runtime-src/values/adapters/bw.ts
 import { spawn as spawn4 } from "node:child_process";
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function parseBwPath(path11) {
   const idx = path11.indexOf("/");
   if (idx < 0) {
@@ -50308,7 +50444,7 @@ class BwAdapter {
     if (value.length === 0) {
       throw new AdapterError("adapter_exit_nonzero", `bw returned empty value for ${pointer.raw}`);
     }
-    const h = createHash10("sha256");
+    const h = createHash11("sha256");
     h.update(value);
     h.update(nonce);
     const commitment = new Uint8Array(h.digest());
@@ -50341,7 +50477,7 @@ var init_bw = __esm(() => {
 
 // .tmp-runtime-src/values/adapters/keychain.ts
 import { spawn as spawn5 } from "node:child_process";
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 import { existsSync as existsSync18 } from "node:fs";
 import { homedir as homedir18, platform as platform3 } from "node:os";
 import { join as join22 } from "node:path";
@@ -50475,7 +50611,7 @@ class KeychainAdapter {
     if (value.length === 0) {
       throw new AdapterError("adapter_exit_nonzero", `security returned empty value for keychain://${service}/${account}`);
     }
-    const h = createHash11("sha256");
+    const h = createHash12("sha256");
     h.update(value);
     h.update(nonce);
     const commitment = new Uint8Array(h.digest());
@@ -50515,7 +50651,7 @@ var init_keychain = __esm(() => {
 
 // .tmp-runtime-src/values/adapters/op.ts
 import { spawn as spawn6 } from "node:child_process";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function whichOp() {
   return "op";
 }
@@ -50637,7 +50773,7 @@ class OpAdapter {
     if (value.length === 0) {
       throw new AdapterError("adapter_exit_nonzero", `op read returned empty value for ${pointer.raw}`);
     }
-    const h = createHash12("sha256");
+    const h = createHash13("sha256");
     h.update(value);
     h.update(nonce);
     const commitment = new Uint8Array(h.digest());
@@ -50690,7 +50826,7 @@ function parse2(uri) {
   }
   return { scheme, path: path11, raw: uri };
 }
-function looksLikePointer(value) {
+function looksLikePointer2(value) {
   if (typeof value !== "string")
     return false;
   const m = POINTER_RE.exec(value);
@@ -50803,7 +50939,7 @@ __export(exports_fill, {
   handler: () => handler5,
   deriveContextHash: () => deriveContextHash
 });
-import { randomBytes as randomBytes7, createHash as createHash13 } from "node:crypto";
+import { randomBytes as randomBytes7, createHash as createHash14 } from "node:crypto";
 function canonicalizeSignedFragment2(body) {
   return JSON.stringify({
     pointer: body.pointer,
@@ -50815,10 +50951,10 @@ function canonicalizeSignedFragment2(body) {
 function deriveContextHash(sessionId, selector, url, nowMs = Date.now()) {
   const bucket = Math.floor(nowMs / FIVE_MINUTES_MS2).toString();
   const payload = `${sessionId}:${selector}:${url}:${bucket}`;
-  return createHash13("sha256").update(payload, "utf8").digest("hex");
+  return createHash14("sha256").update(payload, "utf8").digest("hex");
 }
 function sha256Hex3(s) {
-  return createHash13("sha256").update(s, "utf8").digest("hex");
+  return createHash14("sha256").update(s, "utf8").digest("hex");
 }
 function bytesToHex5(b) {
   let h = "";
@@ -50883,7 +51019,7 @@ async function handler5(parsed, opts) {
   }
   let pointerUri;
   const inlineArgScope = parseArgScope(parsed);
-  if (looksLikePointer(pointerArg)) {
+  if (looksLikePointer2(pointerArg)) {
     pointerUri = pointerArg;
   } else {
     pointerUri = "arg://__inline__";
@@ -51030,7 +51166,7 @@ var exports_type = {};
 __export(exports_type, {
   handler: () => handler6
 });
-import { randomBytes as randomBytes8, createHash as createHash14 } from "node:crypto";
+import { randomBytes as randomBytes8, createHash as createHash15 } from "node:crypto";
 function canonicalizeSignedFragment3(body) {
   return JSON.stringify({
     pointer: body.pointer,
@@ -51042,10 +51178,10 @@ function canonicalizeSignedFragment3(body) {
 function deriveContextHash2(sessionId, url, nowMs = Date.now()) {
   const bucket = Math.floor(nowMs / FIVE_MINUTES_MS3).toString();
   const payload = `${sessionId}:__focus__:${url}:${bucket}`;
-  return createHash14("sha256").update(payload, "utf8").digest("hex");
+  return createHash15("sha256").update(payload, "utf8").digest("hex");
 }
 function sha256Hex4(s) {
-  return createHash14("sha256").update(s, "utf8").digest("hex");
+  return createHash15("sha256").update(s, "utf8").digest("hex");
 }
 function bytesToHex6(b) {
   let h = "";
@@ -51111,7 +51247,7 @@ async function handler6(parsed, opts) {
     process.exit(EX_GENERIC);
   }
   const sessionFlag = typeof parsed.flags.session === "string" ? parsed.flags.session : undefined;
-  const isPointerPath = looksLikePointer(textOrPointer);
+  const isPointerPath = looksLikePointer2(textOrPointer);
   let rec;
   try {
     rec = await resolveSession(sessionFlag);
@@ -51559,7 +51695,7 @@ var exports_select = {};
 __export(exports_select, {
   handler: () => handler9
 });
-import { randomBytes as randomBytes9, createHash as createHash15 } from "node:crypto";
+import { randomBytes as randomBytes9, createHash as createHash16 } from "node:crypto";
 function canonicalizeSignedFragment4(body) {
   return JSON.stringify({
     pointer: body.pointer,
@@ -51569,7 +51705,7 @@ function canonicalizeSignedFragment4(body) {
   });
 }
 function sha256Hex5(s) {
-  return createHash15("sha256").update(s, "utf8").digest("hex");
+  return createHash16("sha256").update(s, "utf8").digest("hex");
 }
 function bytesToHex7(b) {
   let h = "";
@@ -51678,7 +51814,7 @@ async function handler9(parsed, opts) {
   const byRaw = parsed.flags.by;
   const by = byRaw === "label" || byRaw === "index" ? byRaw : "value";
   const sessionFlag = typeof parsed.flags.session === "string" ? parsed.flags.session : undefined;
-  const isPointer = looksLikePointer(pointerArg);
+  const isPointer = looksLikePointer2(pointerArg);
   let rec;
   try {
     rec = await resolveSession(sessionFlag);
@@ -52174,9 +52310,9 @@ var exports_execute = {};
 __export(exports_execute, {
   handler: () => handler12
 });
-import { randomBytes as randomBytes10, createHash as createHash16 } from "node:crypto";
+import { randomBytes as randomBytes10, createHash as createHash17 } from "node:crypto";
 function sha256Hex6(s) {
-  return createHash16("sha256").update(s, "utf8").digest("hex");
+  return createHash17("sha256").update(s, "utf8").digest("hex");
 }
 function bytesToHex8(b) {
   let h = "";
@@ -52190,7 +52326,7 @@ function bytesToBase646(b) {
 function deriveExecContextHash(sessionId, locator, url, nowMs = Date.now()) {
   const bucket = Math.floor(nowMs / FIVE_MINUTES_MS4).toString();
   const payload = `${sessionId}:${locator}:${url}:${bucket}`;
-  return createHash16("sha256").update(payload, "utf8").digest("hex");
+  return createHash17("sha256").update(payload, "utf8").digest("hex");
 }
 function parseArgScope4(parsed) {
   const out = {};
@@ -52296,7 +52432,7 @@ function findPointerLeaves(params, prefix = "$") {
   for (const [k, v] of Object.entries(params)) {
     const path11 = `${prefix}.${k}`;
     if (typeof v === "string") {
-      if (looksLikePointer(v))
+      if (looksLikePointer2(v))
         out.push({ path: path11, pointer: v });
     } else if (v && typeof v === "object" && !Array.isArray(v)) {
       out.push(...findPointerLeaves(v, path11));
@@ -52434,7 +52570,7 @@ async function handler12(parsed, opts) {
   const outgoingHeaders = { ...descriptor.headers ?? {} };
   try {
     for (const [name, ptrOrValue] of rawHeaders) {
-      if (looksLikePointer(ptrOrValue)) {
+      if (looksLikePointer2(ptrOrValue)) {
         const slot = await resolveSlot({
           variant: "header-inject",
           locator: name,
@@ -52608,7 +52744,7 @@ __export(exports_auth_capture, {
 import { existsSync as existsSync19 } from "node:fs";
 import { homedir as homedir19, platform as platform4 } from "node:os";
 import { join as join23 } from "node:path";
-import { randomUUID as randomUUID2, createHash as createHash17 } from "node:crypto";
+import { randomUUID as randomUUID2, createHash as createHash18 } from "node:crypto";
 import { spawn as spawn7 } from "node:child_process";
 async function writeKeychainJson(account, valuesJson) {
   if (platform4() !== "darwin") {
@@ -52776,7 +52912,7 @@ async function handler13(parsed, opts) {
       cookies: sidecar
     };
     const canonicalInventory = JSON.stringify(inventoryDoc);
-    const cookiesInventoryRef = createHash17("sha256").update(canonicalInventory).digest("hex");
+    const cookiesInventoryRef = createHash18("sha256").update(canonicalInventory).digest("hex");
     rec = { ...rec, cookies_inventory_ref: cookiesInventoryRef };
     await writeSessionRecord(rec);
     for (const k of Object.keys(nameToValue))
@@ -53105,9 +53241,9 @@ __export(exports_snap, {
   handler: () => handler16,
   formatAxTree: () => formatAxTree
 });
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function urlHash32(s) {
-  return createHash18("sha256").update(s).digest("hex").slice(0, 32);
+  return createHash19("sha256").update(s).digest("hex").slice(0, 32);
 }
 async function getCurrentUrlSafe(conn, sessionId) {
   try {
@@ -53351,7 +53487,10 @@ function sanitizeForPublish(endpoints) {
       clean.body = redactSecrets(clean.body);
     }
     if (clean.query) {
-      clean.query = Object.fromEntries(Object.entries(clean.query).map(([key, value]) => [key, typeof value === "string" ? "example" : value]));
+      clean.query = Object.fromEntries(Object.entries(clean.query).map(([key, value]) => [
+        key,
+        typeof value === "string" ? "example" : synthesizePlaceholder(key, value)
+      ]));
     }
     if (clean.path_params) {
       clean.path_params = Object.fromEntries(Object.keys(clean.path_params).map((key) => [key, "example"]));
@@ -53384,18 +53523,17 @@ function sanitizeForPublish(endpoints) {
           delete semantic.sample_request_url;
         }
       }
-      if (semantic.requires) {
-        semantic.requires = semantic.requires.map((binding) => {
-          const { example_value: _exampleValue, ...rest } = binding;
-          return rest;
-        });
-      }
-      if (semantic.provides) {
-        semantic.provides = semantic.provides.map((binding) => {
-          const { example_value: _exampleValue, ...rest } = binding;
-          return rest;
-        });
-      }
+      const stripExample = (binding) => {
+        if (typeof binding.example_value === "string" && binding.example_value.startsWith("sha256:")) {
+          return binding;
+        }
+        const { example_value: _exampleValue, ...rest } = binding;
+        return rest;
+      };
+      if (semantic.requires)
+        semantic.requires = semantic.requires.map(stripExample);
+      if (semantic.provides)
+        semantic.provides = semantic.provides.map(stripExample);
       clean.semantic = semantic;
     }
     return clean;
@@ -53426,11 +53564,11 @@ var init_sanitize = __esm(() => {
 });
 
 // .tmp-runtime-src/capture/wallet-bind.ts
-import { createHash as createHash19 } from "node:crypto";
+import { createHash as createHash20 } from "node:crypto";
 function bindSecretToWallet(secret, walletPubkey) {
   if (!secret || !walletPubkey)
     throw new Error("bindSecretToWallet: secret and walletPubkey required");
-  return createHash19("sha256").update(walletPubkey).update(SEP).update(secret).digest("hex");
+  return createHash20("sha256").update(walletPubkey).update(SEP).update(secret).digest("hex");
 }
 function bindingTag(secret, walletPubkey) {
   return `bound:${bindSecretToWallet(secret, walletPubkey).slice(0, 16)}`;
@@ -53594,7 +53732,7 @@ var exports_resolve = {};
 __export(exports_resolve, {
   handler: () => handler17
 });
-import { createHash as createHash20, randomBytes as randomBytes11 } from "node:crypto";
+import { createHash as createHash21, randomBytes as randomBytes11 } from "node:crypto";
 function resolveApiBase2() {
   return process.env.UNBROWSE_API_URL ?? process.env.UNBROWSE_BACKEND_URL ?? DEFAULT_BACKEND_URL;
 }
@@ -53665,7 +53803,7 @@ async function handler17(parsed, opts) {
     const canonicalBytes = new TextEncoder().encode(fragment);
     const signed = await signBytes(canonicalBytes);
     const signatureHex = bytesToHex9(signed.signature);
-    const cacheKey = createHash20("sha256").update(signed.signature).digest("hex").slice(0, 32);
+    const cacheKey = createHash21("sha256").update(signed.signature).digest("hex").slice(0, 32);
     safeZero(signed.signature);
     const payload = {
       intent,
@@ -54272,7 +54410,7 @@ __export(exports_trace, {
 import { existsSync as existsSync21, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join27 } from "node:path";
 import { homedir as homedir23 } from "node:os";
-import { createHash as createHash21 } from "node:crypto";
+import { createHash as createHash22 } from "node:crypto";
 function redactValue(v) {
   if (typeof v === "string") {
     for (const prefix of POINTER_PREFIXES) {
@@ -54326,7 +54464,7 @@ function v7DomainFilePath(domain) {
 }
 function v7TmpPendingPath(domain) {
   const normalized = domain.toLowerCase().replace(/^www\./, "");
-  const sigHash = createHash21("sha256").update(normalized).digest("hex").slice(0, 16);
+  const sigHash = createHash22("sha256").update(normalized).digest("hex").slice(0, 16);
   return join27(homedir23(), ".unbrowse", "tmp", sigHash, "trace-pending.jsonl");
 }
 function rmLocalTraceFile(domain) {
@@ -71010,9 +71148,9 @@ __export(exports_markdown, {
   htmlToMarkdown: () => htmlToMarkdown,
   handler: () => handler22
 });
-import { createHash as createHash22 } from "node:crypto";
+import { createHash as createHash23 } from "node:crypto";
 function urlHash322(s) {
-  return createHash22("sha256").update(s).digest("hex").slice(0, 32);
+  return createHash23("sha256").update(s).digest("hex").slice(0, 32);
 }
 function stripPreamble(html) {
   return html.replace(/<!DOCTYPE[^>]*>/gi, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<script[^>]*?>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*?>[\s\S]*?<\/style>/gi, "").replace(/<noscript[^>]*?>[\s\S]*?<\/noscript>/gi, "");
@@ -71126,7 +71264,7 @@ var exports_screenshot = {};
 __export(exports_screenshot, {
   handler: () => handler23
 });
-import { createHash as createHash23 } from "node:crypto";
+import { createHash as createHash24 } from "node:crypto";
 import { mkdir as mkdir5, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir as homedir24 } from "node:os";
 import { join as join28 } from "node:path";
@@ -71134,10 +71272,10 @@ function tmpScreenshotDir(sigKey) {
   return join28(homedir24(), ".unbrowse", "tmp", sigKey);
 }
 function sha256HexBytes(bytes) {
-  return createHash23("sha256").update(bytes).digest("hex");
+  return createHash24("sha256").update(bytes).digest("hex");
 }
 function urlHash323(url) {
-  return createHash23("sha256").update(url).digest("hex").slice(0, 32);
+  return createHash24("sha256").update(url).digest("hex").slice(0, 32);
 }
 async function getCurrentUrlSafe2(conn, sessionId) {
   try {
@@ -71282,12 +71420,12 @@ var exports_text = {};
 __export(exports_text, {
   handler: () => handler24
 });
-import { createHash as createHash24 } from "node:crypto";
+import { createHash as createHash25 } from "node:crypto";
 function urlHash324(s) {
-  return createHash24("sha256").update(s).digest("hex").slice(0, 32);
+  return createHash25("sha256").update(s).digest("hex").slice(0, 32);
 }
 function selectorHashHex(selector) {
-  return createHash24("sha256").update(selector).digest("hex");
+  return createHash25("sha256").update(selector).digest("hex");
 }
 async function handler24(parsed, opts) {
   const meta = lookupKindMap("eval", "text");
@@ -71387,9 +71525,9 @@ __export(exports_cookies2, {
   redactCookies: () => redactCookies,
   handler: () => handler25
 });
-import { createHash as createHash25 } from "node:crypto";
+import { createHash as createHash26 } from "node:crypto";
 function urlHash325(s) {
-  return createHash25("sha256").update(s).digest("hex").slice(0, 32);
+  return createHash26("sha256").update(s).digest("hex").slice(0, 32);
 }
 function redactCookies(raw) {
   return raw.map((c) => {
@@ -71603,7 +71741,7 @@ var exports_skills = {};
 __export(exports_skills, {
   handler: () => handler27
 });
-import { createHash as createHash26, randomBytes as randomBytes12 } from "node:crypto";
+import { createHash as createHash27, randomBytes as randomBytes12 } from "node:crypto";
 function resolveApiBase4() {
   return process.env.UNBROWSE_API_URL ?? process.env.UNBROWSE_BACKEND_URL ?? DEFAULT_BACKEND_URL;
 }
@@ -71701,7 +71839,7 @@ async function handler27(parsed, opts) {
     }, ["op", "domain", "limit", "includeDeprecated", "nonce"]);
     const signed = await signBytes(new TextEncoder().encode(fragment));
     const signatureHex = bytesToHex12(signed.signature);
-    const cacheKey = createHash26("sha256").update(signed.signature).digest("hex").slice(0, 32);
+    const cacheKey = createHash27("sha256").update(signed.signature).digest("hex").slice(0, 32);
     safeZero(signed.signature);
     const signedHeaders = {
       "x-wallet-pubkey": walletPubkey,
@@ -71805,7 +71943,7 @@ var exports_skill2 = {};
 __export(exports_skill2, {
   handler: () => handler28
 });
-import { createHash as createHash27, randomBytes as randomBytes13 } from "node:crypto";
+import { createHash as createHash28, randomBytes as randomBytes13 } from "node:crypto";
 function resolveApiBase5() {
   return process.env.UNBROWSE_API_URL ?? process.env.UNBROWSE_BACKEND_URL ?? DEFAULT_BACKEND_URL;
 }
@@ -71873,7 +72011,7 @@ async function handler28(parsed, opts) {
     const fragment = canonicalizeSignedFragment({ op: "get_skill", skillId, nonce }, ["op", "skillId", "nonce"]);
     const signed = await signBytes(new TextEncoder().encode(fragment));
     const signatureHex = bytesToHex13(signed.signature);
-    const cacheKey = createHash27("sha256").update(signed.signature).digest("hex").slice(0, 32);
+    const cacheKey = createHash28("sha256").update(signed.signature).digest("hex").slice(0, 32);
     safeZero(signed.signature);
     const signedHeaders = {
       "x-wallet-pubkey": walletPubkey,
@@ -71984,7 +72122,7 @@ var exports_earnings = {};
 __export(exports_earnings, {
   handler: () => handler29
 });
-import { createHash as createHash28, randomBytes as randomBytes14 } from "node:crypto";
+import { createHash as createHash29, randomBytes as randomBytes14 } from "node:crypto";
 function resolveApiBase6() {
   return process.env.UNBROWSE_API_URL ?? process.env.UNBROWSE_BACKEND_URL ?? DEFAULT_BACKEND_URL;
 }
@@ -71998,7 +72136,7 @@ function bytesToBase6410(b) {
   return Buffer.from(b).toString("base64");
 }
 function deriveAgentId(walletPubkeyHex) {
-  return createHash28("sha256").update(walletPubkeyHex).digest("hex");
+  return createHash29("sha256").update(walletPubkeyHex).digest("hex");
 }
 function domainFromSkillId(skillId, fallback) {
   if (typeof fallback === "string" && fallback.length > 0)
@@ -72052,7 +72190,7 @@ async function handler29(parsed, opts) {
     }, ["op", "agentId", "since", "nonce"]);
     const signed = await signBytes(new TextEncoder().encode(fragment));
     const signatureHex = bytesToHex14(signed.signature);
-    const cacheKey = createHash28("sha256").update(signed.signature).digest("hex").slice(0, 32);
+    const cacheKey = createHash29("sha256").update(signed.signature).digest("hex").slice(0, 32);
     safeZero(signed.signature);
     headers["x-wallet-pubkey"] = walletPubkey;
     headers["x-stateless-nonce"] = nonce;
@@ -72176,7 +72314,7 @@ __export(exports_settings, {
   POINTER_PREFIX_REGEX: () => POINTER_PREFIX_REGEX
 });
 import { mkdir as mkdir6, readFile as readFile5, writeFile as writeFile4 } from "node:fs/promises";
-import { createHash as createHash29 } from "node:crypto";
+import { createHash as createHash30 } from "node:crypto";
 import { homedir as homedir25 } from "node:os";
 import { join as join29 } from "node:path";
 function resolveHome(override) {
@@ -72200,7 +72338,7 @@ function bytesToHex15(b) {
   return h;
 }
 function deriveSettingKeyHash(settingKey) {
-  return createHash29("sha256").update(settingKey, "utf8").digest("hex").slice(0, 32);
+  return createHash30("sha256").update(settingKey, "utf8").digest("hex").slice(0, 32);
 }
 async function readSettings(home) {
   try {
@@ -72230,7 +72368,7 @@ function rejectionReasonStateless(settingKey, rawValue) {
   return null;
 }
 async function writeStash(cacheKey, record, home) {
-  const sigHash = cacheKey || createHash29("sha256").update(`${record.settingKey}:${record.settingValuePointer}:${record.written_at}`).digest("hex").slice(0, 32);
+  const sigHash = cacheKey || createHash30("sha256").update(`${record.settingKey}:${record.settingValuePointer}:${record.written_at}`).digest("hex").slice(0, 32);
   const dir = join29(stashRoot(home), sigHash);
   await mkdir6(dir, { recursive: true });
   const path11 = join29(dir, "settings-stash.json");
@@ -74110,7 +74248,7 @@ __export(exports_spec, {
   emitEvalReadAuditSpec: () => emitEvalReadAuditSpec,
   domainHash32: () => domainHash32
 });
-import { createHash as createHash30 } from "node:crypto";
+import { createHash as createHash31 } from "node:crypto";
 import { existsSync as existsSync25, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir28 } from "node:os";
 import { join as join32 } from "node:path";
@@ -74248,7 +74386,7 @@ function firstHit(results) {
   return null;
 }
 function domainHash32(domain) {
-  return createHash30("sha256").update(domain.toLowerCase()).digest("hex").slice(0, 32);
+  return createHash31("sha256").update(domain.toLowerCase()).digest("hex").slice(0, 32);
 }
 function specCacheDir() {
   return join32(homedir28(), ".unbrowse", "tmp", "spec-cache");
@@ -114544,7 +114682,7 @@ var init_publish_admission = __esm(() => {
 });
 
 // .tmp-runtime-src/telemetry.ts
-import { createHash as createHash32 } from "node:crypto";
+import { createHash as createHash33 } from "node:crypto";
 import { existsSync as existsSync33, mkdirSync as mkdirSync15, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join37 } from "node:path";
 function getTraceDir() {
@@ -114554,7 +114692,7 @@ function isTracingEnabled() {
   return process.env.UNBROWSE_DISABLE_TRACES !== "1";
 }
 function hashValue(value) {
-  return createHash32("sha256").update(value).digest("hex").slice(0, 16);
+  return createHash33("sha256").update(value).digest("hex").slice(0, 16);
 }
 function isSensitiveName(name) {
   return SENSITIVE_PATTERNS.some((re) => re.test(name));
@@ -114572,7 +114710,7 @@ function anonymizeUrl(url) {
 }
 function hashResponseBody(result) {
   const str = typeof result === "string" ? result : JSON.stringify(result ?? "");
-  return createHash32("sha256").update(str).digest("hex").slice(0, 32);
+  return createHash33("sha256").update(str).digest("hex").slice(0, 32);
 }
 function classifyFailure2(error) {
   if (!error)
@@ -161831,6 +161969,78 @@ var init_probe = __esm(() => {
   HTML_LIKE = /text\/html|application\/xhtml\+xml/i;
 });
 
+// .tmp-runtime-src/proof/commitment.ts
+import { createHash as createHash34 } from "crypto";
+function hashResponseBody2(body) {
+  const hash = createHash34("sha256").update(body ?? "").digest("hex");
+  return `sha256:${hash}`;
+}
+var init_commitment = () => {};
+
+// .tmp-runtime-src/lib/write-receipt.ts
+var exports_write_receipt = {};
+__export(exports_write_receipt, {
+  yieldsFromResponse: () => yieldsFromResponse,
+  buildWriteReceipt: () => buildWriteReceipt,
+  bindingsFromBody: () => bindingsFromBody
+});
+function bindingsFromBody(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body))
+    return [];
+  const out = [];
+  for (const [k, v] of Object.entries(body)) {
+    const sensitive = isSensitiveFieldName(k);
+    out.push({
+      key: k,
+      required: true,
+      source: "body",
+      ...sensitive ? { semantic_type: "secret", example_value: commitValue(String(v)) } : typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? { example_value: String(v) } : {}
+    });
+  }
+  return out;
+}
+function yieldsFromResponse(responseBody) {
+  let obj = responseBody;
+  if (typeof responseBody === "string") {
+    try {
+      obj = JSON.parse(responseBody);
+    } catch {
+      return [];
+    }
+  }
+  if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+    const rec = obj;
+    const inner = rec.data ?? rec.json ?? rec.result;
+    if (inner && typeof inner === "object" && !Array.isArray(inner))
+      obj = inner;
+  }
+  if (!obj || typeof obj !== "object" || Array.isArray(obj))
+    return [];
+  const out = [];
+  for (const [k, v] of Object.entries(obj)) {
+    if (ID_KEY.test(k) && (typeof v === "string" || typeof v === "number")) {
+      out.push({ key: k, source: "response", semantic_type: "resource_id", example_value: String(v) });
+    }
+  }
+  return out;
+}
+function buildWriteReceipt(input2) {
+  const { commitments } = censorInputBody(input2.body ?? {});
+  return {
+    claim: input2.intent?.trim() || `${input2.method.toUpperCase()} ${input2.url}`,
+    input_commitments: commitments,
+    response_commitment: hashResponseBody2(typeof input2.responseBody === "string" ? input2.responseBody : input2.responseBody == null ? "" : JSON.stringify(input2.responseBody)),
+    requires: bindingsFromBody(input2.body),
+    provides: yieldsFromResponse(input2.responseBody)
+  };
+}
+var ID_KEY;
+var init_write_receipt = __esm(() => {
+  init_input_censor();
+  init_commitment();
+  ID_KEY = /^(id|uuid|_id|.+_id|.+Id|slug|key|name)$/;
+});
+
 // .tmp-runtime-src/execution/captcha-solve.ts
 function isCaptchaVendor(vendor) {
   if (!vendor)
@@ -169979,13 +170189,14 @@ __export(exports_execution, {
   buildStructuredReplayHeaders: () => buildStructuredReplayHeaders,
   buildPageFetchEndpoint: () => buildPageFetchEndpoint,
   buildPageArtifactCapture: () => buildPageArtifactCapture,
-  buildGraphqlRequestParams: () => buildGraphqlRequestParams
+  buildGraphqlRequestParams: () => buildGraphqlRequestParams,
+  buildAdhocWriteEndpoint: () => buildAdhocWriteEndpoint
 });
-import { createHash as createHash33 } from "node:crypto";
+import { createHash as createHash35 } from "node:crypto";
 function stableEndpointId(method, urlTemplate) {
   if (!method || !urlTemplate)
     return nanoid();
-  return createHash33("sha256").update(`${method}:${urlTemplate}`).digest("base64url").slice(0, 21);
+  return createHash35("sha256").update(`${method}:${urlTemplate}`).digest("base64url").slice(0, 21);
 }
 function stampTrace(trace) {
   trace.trace_version = TRACE_VERSION;
@@ -170556,6 +170767,27 @@ function buildPageFetchEndpoint(url, intent, authRequired = false) {
     }
   };
 }
+function buildAdhocWriteEndpoint(url, method, body) {
+  const m = method.toUpperCase();
+  return {
+    endpoint_id: stableEndpointId(m, url + "#adhoc_write"),
+    method: m,
+    url_template: url,
+    idempotency: "unsafe",
+    verification_status: "unverified",
+    reliability_score: 0.5,
+    description: `Ad-hoc ${m} to ${url}`,
+    ...body !== undefined && body !== null ? { body } : {},
+    trigger_url: url,
+    semantic: {
+      action_kind: "write",
+      resource_kind: "record",
+      description_in: `Sends a ${m} request to ${url}`,
+      description_out: `Returns the ${url} write response`,
+      ...body && typeof body === "object" && !Array.isArray(body) ? { requires: bindingsFromBody(body) } : {}
+    }
+  };
+}
 function derivePublicApiEndpointsFromUrl(url, intent, authRequired = false) {
   try {
     const u = new URL(url);
@@ -172721,6 +172953,12 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
     workflowChosenStrategy = workflowChosenStrategy ?? "server";
     recipeMatched = true;
   }
+  if (!recipeMatched && endpoint.method !== "GET" && endpoint.method !== "HEAD" && endpoint.method !== "OPTIONS") {
+    result = await serverFetch(workflowBindings?.extraHeaders, workflowBindings?.bodyOverride);
+    decisionTrace.push({ step: "server_fetch", status: result.status, write_method: endpoint.method });
+    workflowChosenStrategy = workflowChosenStrategy ?? "server";
+    recipeMatched = true;
+  }
   if (!recipeMatched) {
     const probeCookies = cookies.map((c) => ({ name: c.name, value: c.value }));
     const probe = await probeUrl(url, {
@@ -173506,7 +173744,8 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
       trace.result = data2;
     }
   }
-  if (trace.success && effectiveIntent && data2 != null) {
+  const isWriteEndpoint = ["POST", "PUT", "PATCH", "DELETE"].includes(String(endpoint.method ?? "").toUpperCase()) || endpoint.semantic?.action_kind === "write";
+  if (trace.success && effectiveIntent && data2 != null && !isWriteEndpoint) {
     const semanticAssessment = assessIntentResult(data2, effectiveIntent);
     const tinyCheck = semanticAssessment.verdict === "pass" ? { tiny: false } : looksLikeTinyContentReadResult(data2, effectiveIntent);
     if (tinyCheck.tiny) {
@@ -173529,6 +173768,16 @@ async function executeEndpoint(skill, endpoint, params = {}, projection, options
       trace.steps?.push({ step: "extraction_too_thin_gate", reason: tinyCheck.reason });
     }
   }
+  if (trace.success && isWriteEndpoint && data2 != null) {
+    try {
+      const provides = yieldsFromResponse(data2);
+      if (provides.length > 0) {
+        endpoint.semantic = { ...endpoint.semantic ?? { action_kind: "write", resource_kind: "record" }, provides };
+        trace.steps?.push({ step: "write_yields_registered", keys: provides.map((b) => b.key) });
+        cachePublishedSkill(skill, options?.client_scope);
+      }
+    } catch {}
+  }
   if (trace.success && !endpoint.response_schema && data2 != null && typeof data2 !== "string") {
     try {
       const inferred = inferSchema([data2]);
@@ -175229,6 +175478,7 @@ var init_execution = __esm(async () => {
   init_eviction_strikes();
   init_retry();
   init_probe();
+  init_write_receipt();
   init_captcha_solve();
   init_dag_feedback();
   init_nanoid();
@@ -176058,9 +176308,9 @@ var init_pre_resolve_gate = __esm(() => {
 });
 
 // .tmp-runtime-src/routing-telemetry.ts
-import { createHash as createHash34 } from "node:crypto";
+import { createHash as createHash36 } from "node:crypto";
 function stableHash(value) {
-  return createHash34("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 24);
+  return createHash36("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 24);
 }
 function sanitizeScalar(value) {
   if (value == null)
@@ -177481,7 +177731,7 @@ var init_mount = __esm(() => {
 // .tmp-runtime-src/orchestrator/index.ts
 import { existsSync as existsSync38, writeFileSync as writeFileSync18, readFileSync as readFileSync26, mkdirSync as mkdirSync21, readdirSync as readdirSync10 } from "node:fs";
 import { dirname as dirname9, join as join45 } from "node:path";
-import { createHash as createHash35 } from "node:crypto";
+import { createHash as createHash37 } from "node:crypto";
 function artifactResultWithShortlist(artifact, skillId, triggerUrl) {
   const ep = artifact.endpoint;
   const res = artifact.result;
@@ -177636,7 +177886,7 @@ function scopedResolveCacheKeys(scope, key2) {
   return scope === "global" ? [scopedCacheKey("global", key2)] : [scopedCacheKey(scope, key2), scopedCacheKey("global", key2)];
 }
 function snapshotPathForCacheKey(cacheKey2) {
-  const digest = createHash35("sha1").update(cacheKey2).digest("hex");
+  const digest = createHash37("sha1").update(cacheKey2).digest("hex");
   return join45(SKILL_SNAPSHOT_DIR, `${digest}.json`);
 }
 function writeSkillSnapshot(cacheKey2, skill) {
@@ -177663,11 +177913,11 @@ function compositeAddress(domain, target, steps, edges) {
     `steps:${steps.map((s) => s.endpoint_id).join(">")}`,
     `edges:${edges.map((e) => `${e.from}.${e.binding}->${e.to}`).sort().join("|")}`
   ].join("::");
-  return `composite:${createHash35("sha256").update(canonical2).digest("hex").slice(0, 32)}`;
+  return `composite:${createHash37("sha256").update(canonical2).digest("hex").slice(0, 32)}`;
 }
 function compositeLookupKey(domain, target) {
   const canonical2 = `domain:${domain}::target:${target}`;
-  return `lookup:${createHash35("sha256").update(canonical2).digest("hex").slice(0, 32)}`;
+  return `lookup:${createHash37("sha256").update(canonical2).digest("hex").slice(0, 32)}`;
 }
 function compositeFilePath(lookupKey2) {
   return join45(compositeSnapshotDir(), `${lookupKey2.replace(/[^a-z0-9]/gi, "_")}.json`);
@@ -180076,7 +180326,7 @@ async function resolveAndExecute(intent, params = {}, context, projection, optio
           const persisted = findCompositeInSkill(skill, candidate.endpoint.endpoint_id) ?? readComposite(replayDomain, candidate.endpoint.endpoint_id);
           const decision = planPrereqOrder(prereqOrder, persisted, (id) => {
             const ep = skill.endpoints.find((e) => e.endpoint_id === id);
-            return ep != null && canAutoExecuteEndpoint(ep);
+            return ep != null && ep.verification_status !== "disabled" && canAutoExecuteEndpoint(ep);
           });
           prereqOrder = decision.prereqOrder;
           replayedCompositeId = decision.replayedCompositeId;
@@ -184665,12 +184915,12 @@ var init_agent_augment = __esm(() => {
 });
 
 // .tmp-runtime-src/api/browse-index.ts
-import { createHash as createHash36 } from "node:crypto";
+import { createHash as createHash38 } from "node:crypto";
 import { readFileSync as readFileSync30 } from "node:fs";
 function stableEndpointId2(method, urlTemplate) {
   if (!method || !urlTemplate)
     return nanoid();
-  return createHash36("sha256").update(`${method}:${urlTemplate}`).digest("base64url").slice(0, 21);
+  return createHash38("sha256").update(`${method}:${urlTemplate}`).digest("base64url").slice(0, 21);
 }
 function normalizeBrowseUrl(url, baseUrl) {
   if (!url)
@@ -187074,6 +187324,275 @@ var init_skillmd = __esm(() => {
   ];
 });
 
+// .tmp-runtime-src/runtime/yield-store.ts
+var exports_yield_store = {};
+__export(exports_yield_store, {
+  recordYields: () => recordYields,
+  isYieldStale: () => isYieldStale,
+  getYieldCache: () => getYieldCache,
+  fillHolesFromYields: () => fillHolesFromYields,
+  clearSessionYields: () => clearSessionYields
+});
+import { existsSync as existsSync43, mkdirSync as mkdirSync25, readFileSync as readFileSync32, writeFileSync as writeFileSync22, unlinkSync as unlinkSync7 } from "node:fs";
+import os11 from "node:os";
+import path18 from "node:path";
+function configDir() {
+  return process.env.UNBROWSE_CONFIG_DIR || path18.join(process.env.HOME || os11.homedir(), ".unbrowse");
+}
+function yieldSessionDir() {
+  return path18.join(configDir(), "yield-sessions");
+}
+function isSafeSessionId(id) {
+  return typeof id === "string" && id.length > 0 && id.length <= 200 && /^[A-Za-z0-9._@:-]+$/.test(id);
+}
+function sessionFile(sessionId) {
+  const safe2 = Buffer.from(sessionId).toString("base64url").slice(0, 120);
+  return path18.join(yieldSessionDir(), `${safe2}.json`);
+}
+function persistSession(sessionId, cache) {
+  if (!isSafeSessionId(sessionId))
+    return;
+  try {
+    const dir = yieldSessionDir();
+    if (!existsSync43(dir))
+      mkdirSync25(dir, { recursive: true });
+    const entries = [];
+    for (const [k, y] of cache.entries()) {
+      if (y.sensitive) {
+        entries.push([k, { value: commitValue(String(y.value)), observed_at: y.observed_at, committed: true, ...y.ttl_ms ? { ttl_ms: y.ttl_ms } : {}, ...y.single_use ? { single_use: true } : {} }]);
+      } else {
+        entries.push([k, y]);
+      }
+    }
+    writeFileSync22(sessionFile(sessionId), JSON.stringify({ v: 1, entries }), "utf-8");
+  } catch {}
+}
+function loadSession(sessionId) {
+  if (!isSafeSessionId(sessionId))
+    return null;
+  try {
+    const raw = readFileSync32(sessionFile(sessionId), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.entries))
+      return null;
+    return new Map(parsed.entries);
+  } catch {
+    return null;
+  }
+}
+function cacheFor(sessionId, store) {
+  let cache = store.get(sessionId);
+  if (!cache) {
+    cache = (store === moduleStore ? loadSession(sessionId) : null) ?? new Map;
+    store.set(sessionId, cache);
+  }
+  return cache;
+}
+function scopedKey(key2, scope) {
+  return scope ? `${scope.length}:${scope}:${key2}` : key2;
+}
+function isYieldStale(y, nowMs) {
+  if (typeof y.ttl_ms !== "number")
+    return false;
+  const observed = Date.parse(y.observed_at);
+  if (!Number.isFinite(observed))
+    return false;
+  return nowMs - observed > y.ttl_ms;
+}
+function recordYields(sessionId, provides, opts) {
+  if (!sessionId || !Array.isArray(provides) || provides.length === 0)
+    return 0;
+  const store = opts?.store ?? moduleStore;
+  const nowIso = opts?.nowIso ?? new Date().toISOString();
+  const cache = cacheFor(sessionId, store);
+  let n = 0;
+  for (const b of provides) {
+    if (!b?.key || b.example_value === undefined)
+      continue;
+    cache.set(scopedKey(b.key, opts?.scope), {
+      value: b.example_value,
+      observed_at: b.observed_at ?? nowIso,
+      ...typeof b.ttl_ms === "number" ? { ttl_ms: b.ttl_ms } : {},
+      ...b.single_use ? { single_use: true } : {},
+      ...isSensitiveFieldName(b.key) ? { sensitive: true } : {}
+    });
+    n++;
+  }
+  if (store === moduleStore && n > 0)
+    persistSession(sessionId, cache);
+  return n;
+}
+function getYieldCache(sessionId, opts) {
+  const store = opts?.store ?? moduleStore;
+  const inMem = store.get(sessionId);
+  if (inMem)
+    return inMem;
+  if (store === moduleStore) {
+    const loaded = loadSession(sessionId);
+    if (loaded) {
+      store.set(sessionId, loaded);
+      return loaded;
+    }
+  }
+  return;
+}
+function fillHolesFromYields(sessionId, requires, params, opts) {
+  const filled = [];
+  if (!sessionId || !Array.isArray(requires) || requires.length === 0)
+    return { filled, params };
+  const store = opts?.store ?? moduleStore;
+  const cache = store.get(sessionId) ?? (store === moduleStore ? loadSession(sessionId) ?? undefined : undefined);
+  if (!cache)
+    return { filled, params };
+  if (store === moduleStore && !store.get(sessionId))
+    store.set(sessionId, cache);
+  const nowMs = opts?.nowMs ?? Date.now();
+  let consumed = false;
+  for (const b of requires) {
+    if (!b?.key)
+      continue;
+    if (params[b.key] !== undefined && params[b.key] !== null)
+      continue;
+    const ck = scopedKey(b.key, opts?.scope);
+    const y = cache.get(ck);
+    if (!y || isYieldStale(y, nowMs))
+      continue;
+    if (y.committed)
+      continue;
+    params[b.key] = y.value;
+    filled.push(b.key);
+    if (y.single_use) {
+      cache.delete(ck);
+      consumed = true;
+    }
+  }
+  if (consumed && store === moduleStore)
+    persistSession(sessionId, cache);
+  return { filled, params };
+}
+function clearSessionYields(sessionId, opts) {
+  const store = opts?.store ?? moduleStore;
+  store.delete(sessionId);
+  if (store === moduleStore && isSafeSessionId(sessionId)) {
+    try {
+      if (existsSync43(sessionFile(sessionId)))
+        unlinkSync7(sessionFile(sessionId));
+    } catch {}
+  }
+}
+var moduleStore;
+var init_yield_store = __esm(() => {
+  init_input_censor();
+  moduleStore = new Map;
+});
+
+// .tmp-runtime-src/lib/graph-core/cross-skill-index.ts
+var exports_cross_skill_index = {};
+__export(exports_cross_skill_index, {
+  suggestCrossSkillProducers: () => suggestCrossSkillProducers,
+  resolveProducersForHole: () => resolveProducersForHole,
+  buildGlobalProducerIndexFromCache: () => buildGlobalProducerIndexFromCache,
+  buildGlobalProducerIndex: () => buildGlobalProducerIndex,
+  bindingIdentityKey: () => bindingIdentityKey
+});
+function normEntity(e) {
+  const k = e.toLowerCase();
+  return ENTITY_ALIASES[k] ?? k;
+}
+function bindingIdentityKey(key2, resourceKind) {
+  const raw = String(key2 ?? "").trim();
+  if (!raw)
+    return "::";
+  const m = raw.match(/^([A-Za-z][A-Za-z0-9]*?)[_]?(id|ids|uuid|guid|slug|key)$/i);
+  if (m && m[1] && m[1].toLowerCase() !== m[2].toLowerCase()) {
+    const field = m[2].toLowerCase() === "ids" ? "id" : m[2].toLowerCase();
+    return `${normEntity(m[1])}::${field}`;
+  }
+  if (ID_FIELD.test(raw) && resourceKind) {
+    return `${normEntity(resourceKind)}::${raw.toLowerCase()}`;
+  }
+  return `${resourceKind ? normEntity(resourceKind) : ""}::${raw.toLowerCase()}`;
+}
+function endpointResourceKind(ep) {
+  return ep.semantic?.resource_kind;
+}
+function buildGlobalProducerIndex(skills) {
+  const byIdentity = new Map;
+  for (const skill of skills ?? []) {
+    if (!skill?.endpoints)
+      continue;
+    for (const ep of skill.endpoints) {
+      const rk = endpointResourceKind(ep);
+      const provides = ep.semantic?.provides ?? [];
+      for (const b of provides) {
+        if (!b?.key)
+          continue;
+        const identity = bindingIdentityKey(b.key, rk);
+        const producer = {
+          skill_id: skill.skill_id,
+          endpoint_id: ep.endpoint_id,
+          binding_key: b.key,
+          identity,
+          semantic_type: b.semantic_type,
+          resource_kind: rk
+        };
+        const list = byIdentity.get(identity) ?? [];
+        list.push(producer);
+        byIdentity.set(identity, list);
+      }
+    }
+  }
+  return { byIdentity };
+}
+function resolveProducersForHole(index2, hole, consumerResourceKind, opts) {
+  if (!hole?.key)
+    return [];
+  const identity = bindingIdentityKey(hole.key, consumerResourceKind);
+  const all = index2.byIdentity.get(identity) ?? [];
+  if (opts?.includeSameSkill)
+    return [...all];
+  const exclude = opts?.excludeSkillId;
+  return exclude ? all.filter((p) => p.skill_id !== exclude) : [...all];
+}
+async function buildGlobalProducerIndexFromCache() {
+  try {
+    const { listLocalSkills: listLocalSkills2 } = await Promise.resolve().then(() => (init_client(), exports_client));
+    return buildGlobalProducerIndex(listLocalSkills2());
+  } catch {
+    return { byIdentity: new Map };
+  }
+}
+function suggestCrossSkillProducers(endpointRequires, filledParams, consumerResourceKind, consumerSkillId, index2) {
+  const out = [];
+  for (const b of endpointRequires ?? []) {
+    if (!b?.key)
+      continue;
+    if (filledParams[b.key] !== undefined && filledParams[b.key] !== null)
+      continue;
+    const producers = resolveProducersForHole(index2, b, consumerResourceKind, { excludeSkillId: consumerSkillId });
+    if (producers.length)
+      out.push({ hole: b.key, producers });
+  }
+  return out;
+}
+var ENTITY_ALIASES, ID_FIELD;
+var init_cross_skill_index = __esm(() => {
+  ENTITY_ALIASES = {
+    repo: "repository",
+    repository: "repository",
+    org: "organization",
+    organisation: "organization",
+    organization: "organization",
+    user: "user",
+    account: "user",
+    post: "post",
+    posts: "post",
+    comment: "comment",
+    comments: "comment"
+  };
+  ID_FIELD = /^(id|uuid|guid|slug|key|number|no)$/i;
+});
+
 // .tmp-runtime-src/api/routes.ts
 var exports_routes = {};
 __export(exports_routes, {
@@ -187086,10 +187605,10 @@ __export(exports_routes, {
   buildAnalyticsSessionPayload: () => buildAnalyticsSessionPayload,
   __clearBrowseSessionsForTest: () => __clearBrowseSessionsForTest
 });
-import * as os11 from "os";
-import * as path18 from "path";
-import { readdirSync as readdirSync13, readFileSync as readFileSync32 } from "fs";
-import { writeFileSync as writeFileSync22, existsSync as existsSync43, mkdirSync as mkdirSync25 } from "fs";
+import * as os12 from "os";
+import * as path19 from "path";
+import { readdirSync as readdirSync13, readFileSync as readFileSync33 } from "fs";
+import { writeFileSync as writeFileSync23, existsSync as existsSync44, mkdirSync as mkdirSync26 } from "fs";
 import { join as join54 } from "path";
 function browseBrokerMax() {
   const n = Number(process.env.KURI_MULTI_BROKER_MAX ?? "1");
@@ -187554,12 +188073,12 @@ async function registerRoutes(app) {
         next_step: "Not paired yet. Run `unbrowse setup` to register an agent. Earnings start accruing once you publish a skill that other agents execute."
       });
     }
-    const fetchJson = async (path19) => {
+    const fetchJson = async (path20) => {
       try {
         const headers = {};
         if (apiKey)
           headers.Authorization = `Bearer ${apiKey}`;
-        const res = await fetch(`${BETA_API_URL}${path19}`, { headers });
+        const res = await fetch(`${BETA_API_URL}${path20}`, { headers });
         if (!res.ok)
           return null;
         return await res.json();
@@ -187814,20 +188333,20 @@ async function registerRoutes(app) {
   });
   app.get("/v1/trace/:trace_id", async (req, reply) => {
     const { trace_id } = req.params;
-    const traceDir = path18.join(process.env.UNBROWSE_TRACE_DIR ?? path18.join(os11.homedir(), ".unbrowse", "traces"));
+    const traceDir = path19.join(process.env.UNBROWSE_TRACE_DIR ?? path19.join(os12.homedir(), ".unbrowse", "traces"));
     if (trace_id === "latest") {
       try {
         const files = readdirSync13(traceDir).filter((f) => f.endsWith(".json")).sort().reverse();
         if (files.length === 0)
           return reply.send({ message: "No traces found", trace_id: "latest" });
-        const trace = JSON.parse(readFileSync32(join54(traceDir, files[0]), "utf-8"));
+        const trace = JSON.parse(readFileSync33(join54(traceDir, files[0]), "utf-8"));
         return reply.send({ trace_id: "latest", ...trace });
       } catch {
         return reply.send({ message: "No traces found (trace directory may not exist yet)", trace_id: "latest" });
       }
     }
     try {
-      const trace = JSON.parse(readFileSync32(join54(traceDir, `${trace_id}.json`), "utf-8"));
+      const trace = JSON.parse(readFileSync33(join54(traceDir, `${trace_id}.json`), "utf-8"));
       return reply.send({ trace_id, ...trace });
     } catch {
       return reply.code(404).send({ error: `Trace ${trace_id} not found` });
@@ -187938,13 +188457,13 @@ async function registerRoutes(app) {
       const ms = Date.now() - t0;
       if (learned && endpoints.length > 0) {
         const cacheKey2 = buildResolveCacheKey(learned.domain, intent, url);
-        const scopedKey = scopedCacheKey(clientScope, cacheKey2);
-        writeSkillSnapshot(scopedKey, learned);
+        const scopedKey2 = scopedCacheKey(clientScope, cacheKey2);
+        writeSkillSnapshot(scopedKey2, learned);
         const domainKey = getDomainReuseKey(url ?? learned.domain);
         if (domainKey) {
           domainSkillCache.set(domainKey, {
             skillId: learned.skill_id,
-            localSkillPath: snapshotPathForCacheKey(scopedKey),
+            localSkillPath: snapshotPathForCacheKey(scopedKey2),
             ts: Date.now()
           });
           persistDomainCache();
@@ -188019,9 +188538,9 @@ async function registerRoutes(app) {
   });
   app.get("/v1/skills", async (req, reply) => {
     const fs7 = __require("fs");
-    const path19 = __require("path");
-    const os12 = __require("os");
-    const cacheDir = process.env.UNBROWSE_SKILL_CACHE_DIR || path19.join(process.env.UNBROWSE_CONFIG_DIR || path19.join(os12.homedir(), ".unbrowse"), "skill-cache");
+    const path20 = __require("path");
+    const os13 = __require("os");
+    const cacheDir = process.env.UNBROWSE_SKILL_CACHE_DIR || path20.join(process.env.UNBROWSE_CONFIG_DIR || path20.join(os13.homedir(), ".unbrowse"), "skill-cache");
     const summaries = [];
     const seen = new Set;
     try {
@@ -188030,7 +188549,7 @@ async function registerRoutes(app) {
           if (!entry.endsWith(".json"))
             continue;
           try {
-            const raw = JSON.parse(fs7.readFileSync(path19.join(cacheDir, entry), "utf-8"));
+            const raw = JSON.parse(fs7.readFileSync(path20.join(cacheDir, entry), "utf-8"));
             if (!raw.skill_id || seen.has(raw.skill_id))
               continue;
             seen.add(raw.skill_id);
@@ -188402,21 +188921,21 @@ async function registerRoutes(app) {
     if (!skill_id)
       return reply.code(400).send({ error: "skill_id required" });
     const { join: join55 } = await import("node:path");
-    const { existsSync: existsSync44, readFileSync: readFileSync33, readdirSync: readdirSync14 } = await import("node:fs");
+    const { existsSync: existsSync45, readFileSync: readFileSync34, readdirSync: readdirSync14 } = await import("node:fs");
     const { homedir: homedir42 } = await import("node:os");
     let skill = null;
     try {
       const cacheDir = process.env.UNBROWSE_SKILL_CACHE_DIR || join55(process.env.UNBROWSE_CONFIG_DIR || join55(homedir42(), ".unbrowse"), "skill-cache");
-      if (existsSync44(cacheDir)) {
+      if (existsSync45(cacheDir)) {
         const direct = join55(cacheDir, `${skill_id}.json`);
-        if (existsSync44(direct))
-          skill = JSON.parse(readFileSync33(direct, "utf-8"));
+        if (existsSync45(direct))
+          skill = JSON.parse(readFileSync34(direct, "utf-8"));
         if (!skill) {
           for (const f of readdirSync14(cacheDir)) {
             if (!f.endsWith(".json"))
               continue;
             try {
-              const s = JSON.parse(readFileSync33(join55(cacheDir, f), "utf-8"));
+              const s = JSON.parse(readFileSync34(join55(cacheDir, f), "utf-8"));
               if (s.skill_id === skill_id) {
                 skill = s;
                 break;
@@ -188546,7 +189065,7 @@ async function registerRoutes(app) {
   app.post("/v1/skills/:skill_id/execute", { config: { rateLimit: ROUTE_LIMITS["/v1/skills/:skill_id/execute"] } }, async (req, reply) => {
     const clientScope = clientScopeFor(req);
     const { skill_id } = req.params;
-    const { params, projection, confirm_unsafe, confirm_third_party_terms, dry_run, intent, context_url } = req.body;
+    const { params, projection, confirm_unsafe, confirm_third_party_terms, dry_run, intent, context_url, session_id } = req.body;
     let skill = getRecentLocalSkill(skill_id, clientScope);
     if (!skill) {
       const { findExistingSkillForDomain: findLocal } = await Promise.resolve().then(() => (init_client(), exports_client));
@@ -188561,16 +189080,92 @@ async function registerRoutes(app) {
     }
     if (!skill)
       skill = await getSkill2(skill_id, clientScope);
+    let adhocWrite = false;
+    let adhocEndpointId;
+    {
+      const reqMethod = typeof req.body?.method === "string" ? String(req.body.method).toUpperCase() : undefined;
+      const adhocUrl = context_url ?? (typeof params?.url === "string" ? params.url : undefined);
+      if (reqMethod && adhocUrl && (reqMethod === "POST" || reqMethod === "PUT" || reqMethod === "PATCH" || reqMethod === "DELETE")) {
+        const { buildAdhocWriteEndpoint: buildAdhocWriteEndpoint2 } = await init_execution().then(() => exports_execution);
+        const reserved = new Set(["url", "endpoint_id", "method", "intent"]);
+        const pBody = params?.body;
+        const rawBody = pBody && typeof pBody === "object" && !Array.isArray(pBody) ? pBody : Object.fromEntries(Object.entries(params ?? {}).filter(([k]) => !reserved.has(k)));
+        const ep = buildAdhocWriteEndpoint2(adhocUrl, reqMethod, rawBody);
+        adhocEndpointId = ep.endpoint_id;
+        const nowIso = new Date().toISOString();
+        skill = {
+          skill_id,
+          version: "1.0.0",
+          schema_version: "1",
+          name: skill_id,
+          intent_signature: intent ?? `write ${adhocUrl}`,
+          domain: (() => {
+            try {
+              return new URL(adhocUrl).hostname;
+            } catch {
+              return skill_id;
+            }
+          })(),
+          description: `Ad-hoc agent write to ${adhocUrl}`,
+          owner_type: "agent",
+          execution_type: "http",
+          lifecycle: "active",
+          created_at: nowIso,
+          updated_at: nowIso,
+          endpoints: [ep]
+        };
+        adhocWrite = true;
+      }
+    }
     if (!skill)
       return reply.code(404).send({ error: "Skill not found" });
     const execParams = {
       ...params ?? {},
-      ...context_url && typeof params?.url !== "string" ? { url: context_url } : {}
+      ...context_url && typeof params?.url !== "string" ? { url: context_url } : {},
+      ...adhocEndpointId ? { endpoint_id: adhocEndpointId } : {}
     };
+    const effectiveConfirmUnsafe = confirm_unsafe || adhocWrite;
+    const yieldScope = (() => {
+      const u = context_url ?? (typeof params?.url === "string" ? params.url : undefined) ?? skill.domain;
+      try {
+        return new URL(String(u)).host;
+      } catch {
+        return skill.domain;
+      }
+    })();
+    if (session_id) {
+      try {
+        const { fillHolesFromYields: fillHolesFromYields2 } = await Promise.resolve().then(() => (init_yield_store(), exports_yield_store));
+        const byId = skill.endpoints.find((e) => e.endpoint_id === execParams.endpoint_id);
+        const targetEp = byId ?? (skill.endpoints.length === 1 ? skill.endpoints[0] : undefined);
+        const requires = targetEp?.semantic?.requires;
+        if (requires && requires.length) {
+          const { filled } = fillHolesFromYields2(session_id, requires, execParams, { scope: yieldScope });
+          if (filled.length)
+            console.log(`[pipe-walk] filled holes ${filled.join(",")} from session yields (scope=${yieldScope})`);
+        }
+      } catch (err) {
+        console.warn(`[pipe-walk] fill skipped: ${err?.message}`);
+      }
+    }
+    let crossSkillSuggestions = [];
+    try {
+      const byId = skill.endpoints.find((e) => e.endpoint_id === execParams.endpoint_id);
+      const targetEp = byId ?? (skill.endpoints.length === 1 ? skill.endpoints[0] : undefined);
+      const requires = targetEp?.semantic?.requires;
+      if (requires?.some((r) => r?.key && execParams[r.key] === undefined)) {
+        const { buildGlobalProducerIndexFromCache: buildGlobalProducerIndexFromCache2, suggestCrossSkillProducers: suggestCrossSkillProducers2 } = await Promise.resolve().then(() => (init_cross_skill_index(), exports_cross_skill_index));
+        const index2 = await buildGlobalProducerIndexFromCache2();
+        const rk = targetEp?.semantic?.resource_kind;
+        crossSkillSuggestions = suggestCrossSkillProducers2(requires, execParams, rk, skill.skill_id, index2);
+      }
+    } catch (err) {
+      console.warn(`[cross-skill] suggest skipped: ${err?.message}`);
+    }
     try {
       const executeDeadlineMs = Number(process.env.UNBROWSE_EXECUTE_TIMEOUT_MS) || 60000;
       const endpointIdForTrace = typeof execParams.endpoint_id === "string" ? execParams.endpoint_id : "";
-      let execResult = await withExecuteDeadline(executeSkill(skill, execParams, projection, { confirm_unsafe, confirm_third_party_terms, dry_run, intent, contextUrl: context_url, client_scope: clientScope }), executeDeadlineMs, () => {
+      let execResult = await withExecuteDeadline(executeSkill(skill, execParams, projection, { confirm_unsafe: effectiveConfirmUnsafe, confirm_third_party_terms, dry_run, intent, contextUrl: context_url, client_scope: clientScope }), executeDeadlineMs, () => {
         const now = new Date().toISOString();
         return {
           trace: {
@@ -188647,6 +189242,19 @@ async function registerRoutes(app) {
       }
       if (execResult.trace.success) {
         promoteExplicitExecution(clientScope, intent || skill.intent_signature, context_url || (typeof execParams.url === "string" ? execParams.url : undefined), skill, execResult.trace.endpoint_id, execResult.result);
+        if (session_id) {
+          try {
+            const { recordYields: recordYields2 } = await Promise.resolve().then(() => (init_yield_store(), exports_yield_store));
+            const { yieldsFromResponse: yieldsFromResponse2 } = await Promise.resolve().then(() => (init_write_receipt(), exports_write_receipt));
+            const execEp = skill.endpoints.find((e) => e.endpoint_id === execResult.trace.endpoint_id);
+            const provides = execEp?.semantic?.provides ?? yieldsFromResponse2(execResult.result?.data ?? execResult.result);
+            const n = recordYields2(session_id, provides, { scope: yieldScope });
+            if (n)
+              console.log(`[pipe-walk] recorded ${n} yield(s) for session (scope=${yieldScope})`);
+          } catch (err) {
+            console.warn(`[pipe-walk] capture skipped: ${err?.message}`);
+          }
+        }
       }
       if (execResult.trace.status_code === 404 && skill.domain && skill.intent_signature && skill.execution_type !== "browser-capture") {
         try {
@@ -188684,6 +189292,9 @@ async function registerRoutes(app) {
         skill,
         endpointId: execResult.trace.endpoint_id
       });
+      if (Array.isArray(crossSkillSuggestions) && crossSkillSuggestions.length) {
+        response.cross_skill_producers = crossSkillSuggestions;
+      }
       return reply.send(response);
     } catch (err) {
       return reply.code(500).send({ error: err.message });
@@ -188986,8 +189597,8 @@ async function registerRoutes(app) {
         publishAfterIndex: publishDecision.publishQueued
       }
     };
-    const path19 = await writeCaptureSpool(getCaptureSpoolDir(), envelope);
-    return { written: true, path: path19, request_count: requests.length };
+    const path20 = await writeCaptureSpool(getCaptureSpoolDir(), envelope);
+    return { written: true, path: path20, request_count: requests.length };
   }
   async function lightFlushBrowseCapture(session) {
     let harEntries = [];
@@ -189821,10 +190432,10 @@ ${result.markdown ?? ""}` : result.markdown;
   });
 }
 function saveTrace(trace) {
-  if (!existsSync43(TRACES_DIR))
-    mkdirSync25(TRACES_DIR, { recursive: true });
+  if (!existsSync44(TRACES_DIR))
+    mkdirSync26(TRACES_DIR, { recursive: true });
   const t = trace;
-  writeFileSync22(join54(TRACES_DIR, `${t.trace_id}.json`), JSON.stringify(trace, null, 2));
+  writeFileSync23(join54(TRACES_DIR, `${t.trace_id}.json`), JSON.stringify(trace, null, 2));
 }
 var BETA_API_URL, TRACES_DIR, browseSessions, inspectedHarEntries, perSessionBrokerCursor = 0, statsCache = null, STATS_CACHE_TTL;
 var init_routes = __esm(async () => {
@@ -189893,7 +190504,7 @@ __export(exports_indexer_core, {
   drainPendingIndexJobs: () => drainPendingIndexJobs,
   _processIndexJobForCli: () => processIndexJob2
 });
-import { existsSync as existsSync45, readdirSync as readdirSync14, readFileSync as readFileSync33 } from "node:fs";
+import { existsSync as existsSync46, readdirSync as readdirSync14, readFileSync as readFileSync34 } from "node:fs";
 import { join as join55 } from "node:path";
 function getQueueDir2() {
   return join55(process.env.HOME ?? "/tmp", ".unbrowse", "queue", "pending");
@@ -189908,7 +190519,7 @@ async function isWorkerActive2(queueDir) {
 }
 function getLocalAgentId2() {
   try {
-    const config = JSON.parse(readFileSync33(getUnbrowseConfigPath(), "utf-8"));
+    const config = JSON.parse(readFileSync34(getUnbrowseConfigPath(), "utf-8"));
     return config.agent_id ?? undefined;
   } catch {
     return;
@@ -189943,7 +190554,7 @@ function mergeAgentReview2(endpoints, reviews) {
   });
 }
 function findAndMergeDomainSnapshot2(snapshotDir, domain, incoming) {
-  if (!existsSync45(snapshotDir))
+  if (!existsSync46(snapshotDir))
     return null;
   const targetDomain = getRegistrableDomain(domain);
   let bestExisting = null;
@@ -189952,7 +190563,7 @@ function findAndMergeDomainSnapshot2(snapshotDir, domain, incoming) {
     if (!entry.endsWith(".json"))
       continue;
     try {
-      const candidate = JSON.parse(readFileSync33(join55(snapshotDir, entry), "utf-8"));
+      const candidate = JSON.parse(readFileSync34(join55(snapshotDir, entry), "utf-8"));
       if (getRegistrableDomain(candidate.domain) !== targetDomain)
         continue;
       if (candidate.execution_type !== "http")
@@ -190066,17 +190677,17 @@ function mergeBackgroundIndexJobs2(current, incoming) {
     publishAfterIndex: incoming.publishAfterIndex ?? current.publishAfterIndex
   };
 }
-function persistIndexedSkillState2(job, skill, scopedKey) {
+function persistIndexedSkillState2(job, skill, scopedKey2) {
   try {
     cachePublishedSkill(skill, job.clientScope);
   } catch {}
-  writeSkillSnapshot(scopedKey, skill);
+  writeSkillSnapshot(scopedKey2, skill);
   writeWorkflowPublishArtifact(buildWorkflowPublishArtifact(skill, readWorkflowArtifact(skill.skill_id), { publishStatus: "indexed" }));
   const domainKey = getDomainReuseKey(job.contextUrl ?? job.domain);
   if (domainKey) {
     domainSkillCache.set(domainKey, {
       skillId: skill.skill_id,
-      localSkillPath: snapshotPathForCacheKey(scopedKey),
+      localSkillPath: snapshotPathForCacheKey(scopedKey2),
       ts: Date.now()
     });
     persistDomainCache();
@@ -190085,7 +190696,7 @@ function persistIndexedSkillState2(job, skill, scopedKey) {
 async function indexSkillLocally2(job) {
   let { skill, domain, clientScope } = job;
   const scope = clientScope ?? "global";
-  const scopedKey = scopedCacheKey(scope, job.cacheKey);
+  const scopedKey2 = scopedCacheKey(scope, job.cacheKey);
   const merged = findAndMergeDomainSnapshot2(SKILL_SNAPSHOT_DIR3, domain, skill);
   if (merged) {
     console.error(`[capture-pipeline] merged ${skill.endpoints.length} new endpoint(s) into existing ${merged.endpoints.length - skill.endpoints.length} for ${domain}`);
@@ -190097,11 +190708,11 @@ async function indexSkillLocally2(job) {
       ep.description = generateLocalDescription(ep);
     }
   }
-  persistIndexedSkillState2(job, skill, scopedKey);
-  return { skill, domain, clientScope, scopedKey };
+  persistIndexedSkillState2(job, skill, scopedKey2);
+  return { skill, domain, clientScope, scopedKey: scopedKey2 };
 }
 async function publishIndexedSkill2(indexed) {
-  const { skill, domain, clientScope, scopedKey } = indexed;
+  const { skill, domain, clientScope, scopedKey: scopedKey2 } = indexed;
   const selection = selectMarketplacePublishClosure(skill);
   const markBlockedValidation = (errors2) => {
     writeWorkflowPublishArtifact(buildWorkflowPublishArtifact(skill, readWorkflowArtifact(skill.skill_id), {
@@ -190163,7 +190774,7 @@ async function publishIndexedSkill2(indexed) {
     ...skill.auth_profile_ref ? { auth_profile_ref: skill.auth_profile_ref } : {}
   };
   cachePublishedSkill(publishedSkill, clientScope);
-  writeSkillSnapshot(scopedKey, publishedSkill);
+  writeSkillSnapshot(scopedKey2, publishedSkill);
   const publishedAt = new Date().toISOString();
   writeWorkflowPublishArtifact(buildWorkflowPublishArtifact(skill, readWorkflowArtifact(skill.skill_id), {
     publishStatus: "published",
@@ -190193,7 +190804,7 @@ async function publishIndexedSkill2(indexed) {
   if (domainKey) {
     domainSkillCache.set(domainKey, {
       skillId: publishedSkill.skill_id,
-      localSkillPath: snapshotPathForCacheKey(scopedKey),
+      localSkillPath: snapshotPathForCacheKey(scopedKey2),
       ts: Date.now()
     });
     persistDomainCache();
@@ -190262,9 +190873,9 @@ function isIndexingInFlight(domain) {
   const queueDir = getQueueDir2();
   const cap = sanitizeDomain(domain);
   try {
-    if (existsSync45(join55(queueDir, `${cap}.lock`)))
+    if (existsSync46(join55(queueDir, `${cap}.lock`)))
       return true;
-    if (!existsSync45(queueDir))
+    if (!existsSync46(queueDir))
       return false;
     for (const name of readdirSync14(queueDir)) {
       if (!name.endsWith(".json"))
@@ -190304,7 +190915,7 @@ async function drainPendingIndexJobs() {
     const jobs = await listJobs(queueDir);
     let deadCount = 0;
     try {
-      if (existsSync45(deadDir)) {
+      if (existsSync46(deadDir)) {
         deadCount = readdirSync14(deadDir).filter((n) => n.endsWith(".json") && !n.endsWith(".tmp")).length;
       }
     } catch {
@@ -190372,6 +190983,368 @@ var init_indexer_core2 = __esm(async () => {
   backgroundIndexProcessor2 = processIndexJob2;
 });
 
+// .tmp-runtime-src/runtime/update-hints.ts
+var exports_update_hints = {};
+__export(exports_update_hints, {
+  shouldAutoUpdate: () => shouldAutoUpdate,
+  saveInstallSource: () => saveInstallSource2,
+  resolveInstallSource: () => resolveInstallSource2,
+  recordUpdateHint: () => recordUpdateHint,
+  maybeAutoUpdate: () => maybeAutoUpdate,
+  loadInstallSource: () => loadInstallSource2,
+  getInstalledVersion: () => getInstalledVersion,
+  configureUpdateHintHooks: () => configureUpdateHintHooks2,
+  checkForUpdates: () => checkForUpdates,
+  buildUpgradeCommand: () => buildUpgradeCommand,
+  autoUpdateDisabled: () => autoUpdateDisabled
+});
+import { spawn as spawn11 } from "node:child_process";
+import { existsSync as existsSync49, mkdirSync as mkdirSync30, readFileSync as readFileSync36, writeFileSync as writeFileSync26 } from "node:fs";
+import os15 from "node:os";
+import path23 from "node:path";
+function getHomeDir2() {
+  return process.env.HOME || os15.homedir();
+}
+function getConfigDir7() {
+  if (process.env.UNBROWSE_CONFIG_DIR)
+    return process.env.UNBROWSE_CONFIG_DIR;
+  return path23.join(getHomeDir2(), ".unbrowse");
+}
+function ensureDir5(dir) {
+  if (!existsSync49(dir))
+    mkdirSync30(dir, { recursive: true });
+  return dir;
+}
+function readJsonFile2(file) {
+  try {
+    return JSON.parse(readFileSync36(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile2(file, value) {
+  ensureDir5(path23.dirname(file));
+  writeFileSync26(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+function getInstallSourcePath2() {
+  return path23.join(getConfigDir7(), "install-source.json");
+}
+function getUpdateCheckStatePath() {
+  return path23.join(getConfigDir7(), "update-check.json");
+}
+function detectRepoRoot2(start4) {
+  let dir = path23.resolve(start4);
+  const root2 = path23.parse(dir).root;
+  while (dir !== root2) {
+    if (existsSync49(path23.join(dir, ".git")))
+      return dir;
+    dir = path23.dirname(dir);
+  }
+  return;
+}
+function detectInstallMethod2(packageRoot) {
+  if (process.env.UNBROWSE_SETUP_METHOD === "repo-clone")
+    return "repo-clone";
+  if (process.env.UNBROWSE_SETUP_METHOD === "npm-global")
+    return "npm-global";
+  if (packageRoot.includes(`${path23.sep}node_modules${path23.sep}`))
+    return "npm-global";
+  return detectRepoRoot2(packageRoot) ? "repo-clone" : "unknown";
+}
+function detectInstallHost2(repoRoot) {
+  const explicit = process.env.UNBROWSE_SETUP_HOST;
+  if (explicit)
+    return explicit;
+  if (!repoRoot)
+    return "unknown";
+  const codexHome = process.env.CODEX_HOME || path23.join(getHomeDir2(), ".codex");
+  if (repoRoot === path23.join(codexHome, "skills", "unbrowse"))
+    return "codex";
+  if (repoRoot === path23.join(getHomeDir2(), "(internal)", "skills", "unbrowse"))
+    return "claude";
+  if (repoRoot === path23.join(getHomeDir2(), "unbrowse"))
+    return "off";
+  return "unknown";
+}
+function getInstalledVersion(metaUrl) {
+  const packageRoot = getPackageRoot(metaUrl);
+  try {
+    const pkg = JSON.parse(readFileSync36(path23.join(packageRoot, "package.json"), "utf8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function resolveInstallSource2(metaUrl) {
+  const packageRoot = getPackageRoot(metaUrl);
+  const envRepoRoot = process.env.UNBROWSE_SETUP_ROOT || undefined;
+  const repoRoot = envRepoRoot || detectRepoRoot2(packageRoot);
+  return {
+    method: detectInstallMethod2(packageRoot),
+    host: detectInstallHost2(repoRoot),
+    package_root: packageRoot,
+    repo_root: repoRoot,
+    recorded_at: new Date().toISOString()
+  };
+}
+function saveInstallSource2(metaUrl) {
+  const state = resolveInstallSource2(metaUrl);
+  writeJsonFile2(getInstallSourcePath2(), state);
+  return state;
+}
+function loadInstallSource2(metaUrl) {
+  return readJsonFile2(getInstallSourcePath2()) ?? resolveInstallSource2(metaUrl);
+}
+function compareSemver(a, b) {
+  const parse10 = (value) => value.split("-", 1)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const left2 = parse10(a);
+  const right2 = parse10(b);
+  const max = Math.max(left2.length, right2.length);
+  for (let i = 0;i < max; i++) {
+    const diff = (left2[i] ?? 0) - (right2[i] ?? 0);
+    if (diff !== 0)
+      return diff;
+  }
+  return 0;
+}
+async function fetchLatestVersion() {
+  try {
+    const res = await fetch("https://registry.npmjs.org/unbrowse/latest", {
+      signal: AbortSignal.timeout(8000),
+      headers: { Accept: "application/json" }
+    });
+    if (!res.ok)
+      return null;
+    const body = await res.json();
+    return typeof body.version === "string" && body.version.trim() ? body.version.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function getUpdateIntervalMs() {
+  const value = Number.parseInt(process.env.UNBROWSE_UPDATE_CHECK_INTERVAL_MS ?? "", 10);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_INTERVAL_MS2;
+}
+function buildUpgradeCommand(install2) {
+  if (install2.method === "repo-clone" && install2.repo_root) {
+    const host = install2.host === "unknown" || install2.host === "auto" ? "off" : install2.host;
+    return `cd ${install2.repo_root} && git pull --ff-only && ./setup --host ${host}`;
+  }
+  return `curl -fsSL ${INSTALL_SCRIPT_URL} | bash`;
+}
+async function checkForUpdates(metaUrl, options) {
+  const installed = getInstalledVersion(metaUrl);
+  const install2 = loadInstallSource2(metaUrl);
+  const statePath = getUpdateCheckStatePath();
+  const state = readJsonFile2(statePath) ?? {};
+  const checkedAt = new Date().toISOString();
+  const intervalMs = getUpdateIntervalMs();
+  const lastChecked = state.latest_checked_at ? Date.parse(state.latest_checked_at) : Number.NaN;
+  const useCache = !options?.force && !!state.latest_version && Number.isFinite(lastChecked) && Date.now() - lastChecked < intervalMs;
+  const latest = useCache ? state.latest_version ?? null : await fetchLatestVersion();
+  if (!useCache) {
+    writeJsonFile2(statePath, {
+      ...state,
+      checked_at: checkedAt,
+      latest_version: latest ?? undefined,
+      latest_checked_at: checkedAt
+    });
+  }
+  return {
+    installed,
+    latest,
+    has_update: !!latest && compareSemver(latest, installed) > 0,
+    install: install2,
+    command: buildUpgradeCommand(install2),
+    checked_at: checkedAt,
+    cached: useCache
+  };
+}
+function recordUpdateHint(latestVersion) {
+  const statePath = getUpdateCheckStatePath();
+  const state = readJsonFile2(statePath) ?? {};
+  writeJsonFile2(statePath, {
+    ...state,
+    notified_version: latestVersion,
+    notified_at: new Date().toISOString()
+  });
+}
+function envOn(name) {
+  const v = (process.env[name] ?? "").toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
+function shouldAutoUpdate(input2) {
+  if (input2.disabled)
+    return { update: false, reason: "disabled" };
+  if (!input2.hasUpdate)
+    return { update: false, reason: "up-to-date" };
+  if (input2.method !== "npm-global")
+    return { update: false, reason: `method:${input2.method}` };
+  if (input2.lastAttemptAt) {
+    const last2 = Date.parse(input2.lastAttemptAt);
+    if (Number.isFinite(last2) && input2.nowMs - last2 < input2.intervalMs) {
+      return { update: false, reason: "throttled" };
+    }
+  }
+  return { update: true, reason: "applying" };
+}
+function autoUpdateDisabled() {
+  return envOn("UNBROWSE_NO_AUTO_UPDATE") || envOn("UNBROWSE_DISABLE_UPDATE_HINTS") || envOn("CI") || !!process.env.GITHUB_ACTIONS;
+}
+async function maybeAutoUpdate(metaUrl) {
+  try {
+    const result = await checkForUpdates(metaUrl);
+    const statePath = getUpdateCheckStatePath();
+    const state = readJsonFile2(statePath) ?? {};
+    const decision = shouldAutoUpdate({
+      hasUpdate: result.has_update,
+      method: result.install.method,
+      disabled: autoUpdateDisabled(),
+      lastAttemptAt: state.auto_update_attempted_at,
+      nowMs: Date.now(),
+      intervalMs: getUpdateIntervalMs()
+    });
+    if (!decision.update)
+      return { applied: false, reason: decision.reason };
+    if (!result.latest)
+      return { applied: false, reason: "no-latest" };
+    writeJsonFile2(statePath, {
+      ...state,
+      auto_update_attempted_at: new Date().toISOString(),
+      auto_update_target: result.latest
+    });
+    const logFile = path23.join(ensureDir5(getConfigDir7()), "auto-update.log");
+    const child = spawn11(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "-g", `unbrowse@${result.latest}`], { detached: true, stdio: ["ignore", "ignore", "ignore"], windowsHide: true });
+    try {
+      writeFileSync26(logFile, `${new Date().toISOString()} auto-update ${result.installed} -> ${result.latest} (pid ${child.pid ?? "?"})
+`, { flag: "a" });
+    } catch {}
+    child.unref();
+    return { applied: true, reason: "spawned", from: result.installed, to: result.latest };
+  } catch (err) {
+    return { applied: false, reason: `error:${err?.message ?? "unknown"}` };
+  }
+}
+function commandIncludesHook2(command2, marker) {
+  return typeof command2 === "string" && command2.includes(marker);
+}
+function getCodexConfigPath2() {
+  const codexHome = process.env.CODEX_HOME || path23.join(getHomeDir2(), ".codex");
+  return path23.join(codexHome, "config.toml");
+}
+function getClaudeSettingsPath2() {
+  return path23.join(getHomeDir2(), "(internal)", "settings.json");
+}
+function getHookScriptPath2(metaUrl) {
+  return path23.join(getPackageRoot(metaUrl), "bin", "unbrowse-update-hint.mjs");
+}
+function ensureCodexHooksFeature2(content) {
+  if (/\bcodex_hooks\s*=\s*true\b/.test(content))
+    return content;
+  if (/\[features\]/.test(content)) {
+    return content.replace(/\[features\]\r?\n/, (match) => `${match}codex_hooks = true
+`);
+  }
+  const prefix = content && !content.endsWith(`
+`) ? `
+` : "";
+  return `${content}${prefix}[features]
+codex_hooks = true
+`;
+}
+function repairManagedCodexHookTable2(content) {
+  const marker = CODEX_MARKER2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return content.replace(new RegExp(`(${marker}\\r?\\n)\\[\\[?hooks\\]?\\]?(?=\\r?\\n)`, "g"), "$1[hooks]");
+}
+function writeCodexHook2(metaUrl) {
+  const configPath3 = getCodexConfigPath2();
+  if (!existsSync49(path23.dirname(configPath3))) {
+    return { host: "codex", action: "not-detected", config_file: configPath3 };
+  }
+  try {
+    const hookScript = getHookScriptPath2(metaUrl).replace(/\\/g, "/");
+    const fileExistsBefore = existsSync49(configPath3);
+    let content = fileExistsBefore ? readFileSync36(configPath3, "utf8") : "";
+    const previous = content;
+    content = ensureCodexHooksFeature2(content);
+    content = repairManagedCodexHookTable2(content);
+    if (!content.includes("unbrowse-update-hint.mjs")) {
+      const command2 = `node "${hookScript}"`;
+      const prefix = content && !content.endsWith(`
+`) ? `
+` : "";
+      content += `${prefix}${CODEX_MARKER2}
+[hooks]
+event = "SessionStart"
+command = ${JSON.stringify(command2)}
+`;
+    }
+    if (content !== previous) {
+      writeFileSync26(configPath3, content, "utf8");
+      return {
+        host: "codex",
+        action: fileExistsBefore ? "updated" : "installed",
+        config_file: configPath3
+      };
+    }
+    return { host: "codex", action: "already-installed", config_file: configPath3 };
+  } catch (error) {
+    return {
+      host: "codex",
+      action: "failed",
+      config_file: configPath3,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function writeClaudeHook2(metaUrl) {
+  const settingsPath = getClaudeSettingsPath2();
+  if (!existsSync49(path23.dirname(settingsPath))) {
+    return { host: "claude", action: "not-detected", config_file: settingsPath };
+  }
+  try {
+    const hookScript = getHookScriptPath2(metaUrl).replace(/\\/g, "/");
+    const command2 = `node "${hookScript}"`;
+    const fileExistsBefore = existsSync49(settingsPath);
+    const settings = readJsonFile2(settingsPath) ?? {};
+    settings.hooks ??= {};
+    settings.hooks.SessionStart ??= [];
+    const existing = settings.hooks.SessionStart.some((entry) => Array.isArray(entry.hooks) && entry.hooks.some((hook) => commandIncludesHook2(hook.command, "unbrowse-update-hint.mjs")));
+    if (!existing) {
+      settings.hooks.SessionStart.push({
+        hooks: [{ type: "command", command: command2 }]
+      });
+      writeJsonFile2(settingsPath, settings);
+      return {
+        host: "claude",
+        action: fileExistsBefore ? "updated" : "installed",
+        config_file: settingsPath
+      };
+    }
+    return { host: "claude", action: "already-installed", config_file: settingsPath };
+  } catch (error) {
+    return {
+      host: "claude",
+      action: "failed",
+      config_file: settingsPath,
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function configureUpdateHintHooks2(metaUrl, install2) {
+  if (process.env.UNBROWSE_DISABLE_UPDATE_HINTS === "1")
+    return [];
+  const source = install2 ?? loadInstallSource2(metaUrl);
+  const configuredHosts = source.host === "codex" || source.host === "claude" ? [source.host] : ["codex", "claude"];
+  return configuredHosts.map((host) => host === "codex" ? writeCodexHook2(metaUrl) : writeClaudeHook2(metaUrl));
+}
+var INSTALL_SCRIPT_URL = "https://unbrowse.ai/install.sh", DEFAULT_INTERVAL_MS2, CODEX_MARKER2 = "# Unbrowse update hints — managed by unbrowse setup";
+var init_update_hints = __esm(() => {
+  init_paths();
+  DEFAULT_INTERVAL_MS2 = 12 * 60 * 60 * 1000;
+});
+
 // .tmp-runtime-src/lib/indexer-core/queue-store.ts
 var exports_queue_store = {};
 __export(exports_queue_store, {
@@ -190411,10 +191384,10 @@ async function writeJob2(queueDir, envelope) {
   await rename3(tmpPath, finalPath);
   return finalPath;
 }
-async function rewriteJobAtPath2(path24, envelope) {
-  const tmpPath = `${path24}.tmp`;
+async function rewriteJobAtPath2(path25, envelope) {
+  const tmpPath = `${path25}.tmp`;
   await writeFile7(tmpPath, JSON.stringify(envelope));
-  await rename3(tmpPath, path24);
+  await rename3(tmpPath, path25);
 }
 function isJobEnvelope2(value) {
   if (value === null || typeof value !== "object")
@@ -190450,24 +191423,24 @@ async function listJobs2(queueDir) {
       continue;
     if (entry.name.endsWith(".tmp"))
       continue;
-    const path24 = join57(absDir, entry.name);
+    const path25 = join57(absDir, entry.name);
     let parsed;
     try {
-      const raw = await readFile9(path24, "utf8");
+      const raw = await readFile9(path25, "utf8");
       parsed = JSON.parse(raw);
     } catch {
       continue;
     }
     if (!isJobEnvelope2(parsed))
       continue;
-    results.push({ path: path24, envelope: parsed });
+    results.push({ path: path25, envelope: parsed });
   }
   results.sort((a, b) => a.envelope.queuedAt - b.envelope.queuedAt);
   return results;
 }
-async function deleteJob2(path24) {
+async function deleteJob2(path25) {
   try {
-    await unlink5(path24);
+    await unlink5(path25);
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -190489,11 +191462,11 @@ async function sweepStaleTmp2(queueDir, maxAgeMs = 60000) {
   for (const name of entries) {
     if (!name.endsWith(".tmp"))
       continue;
-    const path24 = join57(absDir, name);
+    const path25 = join57(absDir, name);
     try {
-      const st = await stat6(path24);
+      const st = await stat6(path25);
       if (now - st.mtimeMs > maxAgeMs) {
-        await unlink5(path24);
+        await unlink5(path25);
         unlinked += 1;
       }
     } catch {
@@ -190581,13 +191554,13 @@ async function tryAcquireWorkerSlot2(queueDir) {
 async function touchHeartbeat2(queueDir) {
   const absDir = resolve13(queueDir);
   await mkdir9(absDir, { recursive: true });
-  const path24 = join57(absDir, ".heartbeat");
-  await writeFile7(path24, String(Date.now()));
+  const path25 = join57(absDir, ".heartbeat");
+  await writeFile7(path25, String(Date.now()));
 }
 async function heartbeatAgeMs2(queueDir) {
-  const path24 = join57(resolve13(queueDir), ".heartbeat");
+  const path25 = join57(resolve13(queueDir), ".heartbeat");
   try {
-    const st = await stat6(path24);
+    const st = await stat6(path25);
     return Date.now() - st.mtimeMs;
   } catch (err) {
     if (err.code === "ENOENT")
@@ -190614,25 +191587,25 @@ async function listJobsWithRejects2(queueDir) {
       continue;
     if (entry.name.endsWith(".tmp"))
       continue;
-    const path24 = join57(absDir, entry.name);
+    const path25 = join57(absDir, entry.name);
     let parsed;
     try {
-      const raw = await readFile9(path24, "utf8");
+      const raw = await readFile9(path25, "utf8");
       parsed = JSON.parse(raw);
     } catch {
-      rejected.push({ path: path24, reason: "corrupt_json" });
+      rejected.push({ path: path25, reason: "corrupt_json" });
       continue;
     }
     const v = parsed;
     if (v === null || typeof v !== "object" || v.version !== 1) {
-      rejected.push({ path: path24, reason: "wrong_version" });
+      rejected.push({ path: path25, reason: "wrong_version" });
       continue;
     }
     if (!isJobEnvelope2(parsed)) {
-      rejected.push({ path: path24, reason: "missing_fields" });
+      rejected.push({ path: path25, reason: "missing_fields" });
       continue;
     }
-    accepted.push({ path: path24, envelope: parsed });
+    accepted.push({ path: path25, envelope: parsed });
   }
   accepted.sort((a, b) => a.envelope.queuedAt - b.envelope.queuedAt);
   rejected.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
@@ -190646,7 +191619,7 @@ __export(exports_wallet, {
   getWalletContext: () => getWalletContext2,
   checkWalletConfigured: () => checkWalletConfigured2
 });
-import { existsSync as existsSync50, readFileSync as readFileSync37 } from "node:fs";
+import { existsSync as existsSync51, readFileSync as readFileSync38 } from "node:fs";
 import { homedir as homedir43 } from "node:os";
 import { join as join58 } from "node:path";
 function asNonEmptyString2(value) {
@@ -190654,10 +191627,10 @@ function asNonEmptyString2(value) {
 }
 function getLobsterWalletFromLocalConfig2() {
   const agentsPath = join58(process.env.HOME || homedir43(), ".lobster", "agents.json");
-  if (!existsSync50(agentsPath))
+  if (!existsSync51(agentsPath))
     return;
   try {
-    const raw = JSON.parse(readFileSync37(agentsPath, "utf8"));
+    const raw = JSON.parse(readFileSync38(agentsPath, "utf8"));
     const activeAgentId = asNonEmptyString2(raw.activeAgentId);
     const activeAgent = Array.isArray(raw.agents) ? raw.agents.find((agent) => asNonEmptyString2(agent.id) === activeAgentId) : activeAgentId ? raw.agents?.[activeAgentId] : undefined;
     return asNonEmptyString2(activeAgent?.authorizedWallets?.solana) ?? asNonEmptyString2(activeAgent?.walletAddress) ?? asNonEmptyString2(activeAgent?.wallet_address);
@@ -190704,35 +191677,35 @@ var init_wallet2 = __esm(() => {
 });
 
 // .tmp-runtime-src/telemetry/config.ts
-import { existsSync as existsSync51, mkdirSync as mkdirSync31, readFileSync as readFileSync38, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync32, readFileSync as readFileSync39, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir44 } from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 function getUnbrowseHome2() {
   const home = process.env.HOME || homedir44();
-  return path24.join(home, ".unbrowse");
+  return path25.join(home, ".unbrowse");
 }
 function getConfigPath3() {
-  return path24.join(getUnbrowseHome2(), "config.json");
+  return path25.join(getUnbrowseHome2(), "config.json");
 }
 function getSessionsDir() {
-  return path24.join(getUnbrowseHome2(), "sessions");
+  return path25.join(getUnbrowseHome2(), "sessions");
 }
 function readConfigFile2() {
   const p = getConfigPath3();
-  if (!existsSync51(p))
+  if (!existsSync52(p))
     return {};
   try {
-    return JSON.parse(readFileSync38(p, "utf8"));
+    return JSON.parse(readFileSync39(p, "utf8"));
   } catch {
     return {};
   }
 }
 function writeConfigFile2(updated) {
   const dir = getUnbrowseHome2();
-  if (!existsSync51(dir))
-    mkdirSync31(dir, { recursive: true });
-  writeFileSync27(getConfigPath3(), JSON.stringify(updated, null, 2), "utf8");
+  if (!existsSync52(dir))
+    mkdirSync32(dir, { recursive: true });
+  writeFileSync28(getConfigPath3(), JSON.stringify(updated, null, 2), "utf8");
 }
 function getTelemetryConfig() {
   const env2 = process.env.UNBROWSE_TELEMETRY;
@@ -190769,18 +191742,18 @@ function writeTelemetryConfig(patch) {
 }
 function ensureSessionsDir() {
   const dir = getSessionsDir();
-  if (!existsSync51(dir))
-    mkdirSync31(dir, { recursive: true });
+  if (!existsSync52(dir))
+    mkdirSync32(dir, { recursive: true });
   return dir;
 }
 var DEFAULT_UPLOAD_ENDPOINT = "https://beta-api.unbrowse.ai/v1/telemetry/session";
 var init_config = () => {};
 
 // .tmp-runtime-src/telemetry/sanitize.ts
-import { createHash as createHash37 } from "node:crypto";
+import { createHash as createHash39 } from "node:crypto";
 function shaHex(input2, hexLen) {
   const bytes = Math.ceil(hexLen / SHA_HEX_PER_BYTE);
-  return createHash37("sha256").update(input2).digest("hex").slice(0, hexLen);
+  return createHash39("sha256").update(input2).digest("hex").slice(0, hexLen);
 }
 function isEntityShapedSegment(segment) {
   if (!segment)
@@ -190972,21 +191945,21 @@ __export(exports_upload, {
   uploadSessionInBackground: () => uploadSessionInBackground,
   uploadSession: () => uploadSession
 });
-import { readFileSync as readFileSync39, existsSync as existsSync52 } from "node:fs";
-import { createHash as createHash38 } from "node:crypto";
+import { readFileSync as readFileSync40, existsSync as existsSync53 } from "node:fs";
+import { createHash as createHash40 } from "node:crypto";
 function deriveAgentFingerprint(meta) {
   const seed = `${meta.mcp_version ?? "?"}|${meta.node_version ?? "?"}|${meta.platform ?? "?"}`;
-  return createHash38("sha256").update(seed).digest("hex").slice(0, 16);
+  return createHash40("sha256").update(seed).digest("hex").slice(0, 16);
 }
 async function uploadSession(input2) {
   const cfg = getResolvedTelemetryConfig();
   if (!cfg.enabled)
     return { ok: false, reason: "telemetry_disabled" };
-  if (!existsSync52(input2.session_file))
+  if (!existsSync53(input2.session_file))
     return { ok: false, reason: "no_session_file" };
   let raw;
   try {
-    raw = readFileSync39(input2.session_file, "utf8");
+    raw = readFileSync40(input2.session_file, "utf8");
   } catch (err) {
     return { ok: false, reason: `read_error: ${err instanceof Error ? err.message : String(err)}` };
   }
@@ -191040,9 +192013,9 @@ var init_upload = __esm(() => {
 });
 
 // .tmp-runtime-src/telemetry/session-log.ts
-import { existsSync as existsSync53, openSync as openSync2, writeSync, closeSync } from "node:fs";
-import path25 from "node:path";
-import { randomUUID as randomUUID6, createHash as createHash39 } from "node:crypto";
+import { existsSync as existsSync54, openSync as openSync2, writeSync, closeSync } from "node:fs";
+import path26 from "node:path";
+import { randomUUID as randomUUID6, createHash as createHash41 } from "node:crypto";
 
 class RealSessionLogger {
   cfg;
@@ -191065,7 +192038,7 @@ class RealSessionLogger {
     if (this.fd !== undefined)
       return;
     const dir = ensureSessionsDir();
-    this.filePath = path25.join(dir, `${this.session_id}.jsonl`);
+    this.filePath = path26.join(dir, `${this.session_id}.jsonl`);
     this.fd = openSync2(this.filePath, "a");
     this.startedAtMs = Date.now();
     const event = {
@@ -191205,10 +192178,10 @@ function createSessionLogger(cfg, meta) {
   return new RealSessionLogger(cfg, meta);
 }
 function hashNotes(notes) {
-  return createHash39("sha256").update(notes).digest("hex").slice(0, 16);
+  return createHash41("sha256").update(notes).digest("hex").slice(0, 16);
 }
 function sessionFileExists(filePath) {
-  return existsSync53(filePath);
+  return existsSync54(filePath);
 }
 var init_session_log = __esm(() => {
   init_config();
@@ -191285,7 +192258,7 @@ __export(exports_skillmd2, {
   credentialHoles: () => credentialHoles2,
   credentialHoleToRuntimeHole: () => credentialHoleToRuntimeHole2
 });
-import { mkdirSync as mkdirSync32, writeFileSync as writeFileSync28 } from "node:fs";
+import { mkdirSync as mkdirSync33, writeFileSync as writeFileSync29 } from "node:fs";
 import { homedir as homedir45 } from "node:os";
 import { join as join59, resolve as resolve14 } from "node:path";
 function escapeYaml2(s) {
@@ -191631,11 +192604,11 @@ function exportSkillMdLocal2(skill) {
     if (!dir.startsWith(base + "/") && dir !== base) {
       throw new Error("skill_export_path_escape");
     }
-    mkdirSync32(dir, { recursive: true });
-    const path26 = join59(dir, "SKILL.md");
+    mkdirSync33(dir, { recursive: true });
+    const path27 = join59(dir, "SKILL.md");
     const content = renderSkillMd2(skill);
-    writeFileSync28(path26, content);
-    return path26;
+    writeFileSync29(path27, content);
+    return path27;
   } catch (e) {
     console.warn(`[skillmd] export failed: ${e.message}`);
     return null;
@@ -191669,13 +192642,13 @@ __export(exports_domain_notes, {
   MAX_NOTES_BYTES: () => MAX_NOTES_BYTES2
 });
 import {
-  readFileSync as readFileSync40,
-  writeFileSync as writeFileSync29,
-  existsSync as existsSync54,
-  mkdirSync as mkdirSync33,
+  readFileSync as readFileSync41,
+  writeFileSync as writeFileSync30,
+  existsSync as existsSync55,
+  mkdirSync as mkdirSync34,
   statSync as statSync10,
   renameSync as renameSync4,
-  unlinkSync as unlinkSync7
+  unlinkSync as unlinkSync8
 } from "node:fs";
 import { join as join60 } from "node:path";
 import { homedir as homedir46 } from "node:os";
@@ -191723,7 +192696,7 @@ function readDomainNote2(domain) {
   } catch {
     return null;
   }
-  if (!existsSync54(p))
+  if (!existsSync55(p))
     return null;
   let size3 = 0;
   try {
@@ -191735,7 +192708,7 @@ function readDomainNote2(domain) {
     return null;
   let body;
   try {
-    body = readFileSync40(p, "utf-8");
+    body = readFileSync41(p, "utf-8");
   } catch {
     return null;
   }
@@ -191765,19 +192738,19 @@ function writeDomainNote2(domain, body) {
   const trimmed = body.length > MAX_NOTES_BYTES2 ? body.slice(0, MAX_NOTES_BYTES2) : body;
   const dir = p.slice(0, p.lastIndexOf("/"));
   try {
-    if (!existsSync54(dir))
-      mkdirSync33(dir, { recursive: true });
+    if (!existsSync55(dir))
+      mkdirSync34(dir, { recursive: true });
   } catch {
     return;
   }
   const tmp = `${p}.tmp.${process.pid}.${Date.now()}`;
   try {
-    writeFileSync29(tmp, trimmed, "utf-8");
+    writeFileSync30(tmp, trimmed, "utf-8");
     renameSync4(tmp, p);
   } catch {
     try {
-      if (existsSync54(tmp))
-        unlinkSync7(tmp);
+      if (existsSync55(tmp))
+        unlinkSync8(tmp);
     } catch {}
   }
 }
@@ -191892,7 +192865,7 @@ __export(exports_claude_mcp_register, {
   applyAllowList: () => applyAllowList,
   UNBROWSE_MCP_TOOL_NAMES: () => UNBROWSE_MCP_TOOL_NAMES
 });
-import { readFileSync as readFileSync41, writeFileSync as writeFileSync30, existsSync as existsSync55, mkdirSync as mkdirSync34 } from "node:fs";
+import { readFileSync as readFileSync42, writeFileSync as writeFileSync31, existsSync as existsSync56, mkdirSync as mkdirSync35 } from "node:fs";
 import { join as join61, dirname as dirname11 } from "node:path";
 import { homedir as homedir47 } from "node:os";
 import { spawnSync as spawnSync4 } from "node:child_process";
@@ -191928,10 +192901,10 @@ function realClaudeCliAdapter() {
     },
     serverAlreadyRegistered(homeDir, entryName = "unbrowse") {
       const claudeJson = join61(homeDir, "(internal)");
-      if (!existsSync55(claudeJson))
+      if (!existsSync56(claudeJson))
         return false;
       try {
-        const data2 = JSON.parse(readFileSync41(claudeJson, "utf-8"));
+        const data2 = JSON.parse(readFileSync42(claudeJson, "utf-8"));
         return !!data2?.mcpServers?.[entryName];
       } catch {
         return false;
@@ -192034,9 +193007,9 @@ async function registerWithClaudeCode(opts = { serverCommand: "", serverArgs: []
     };
   }
   const serverAlreadyRegistered = adapter2.serverAlreadyRegistered(home);
-  if (serverAlreadyRegistered && existsSync55(settingsPath)) {
+  if (serverAlreadyRegistered && existsSync56(settingsPath)) {
     try {
-      const existing = JSON.parse(readFileSync41(settingsPath, "utf-8"));
+      const existing = JSON.parse(readFileSync42(settingsPath, "utf-8"));
       const existingAllow = existing?.permissions?.allow;
       const { added: added2 } = mergeAllowList(existingAllow, allowEntries);
       if (added2 === 0) {
@@ -192058,19 +193031,19 @@ async function registerWithClaudeCode(opts = { serverCommand: "", serverArgs: []
     serverRegistered = adapter2.registerServer(opts.serverCommand, opts.serverArgs, env2);
   }
   const settingsDir = dirname11(settingsPath);
-  if (!existsSync55(settingsDir))
-    mkdirSync34(settingsDir, { recursive: true });
+  if (!existsSync56(settingsDir))
+    mkdirSync35(settingsDir, { recursive: true });
   let current = {};
-  if (existsSync55(settingsPath)) {
+  if (existsSync56(settingsPath)) {
     try {
-      current = JSON.parse(readFileSync41(settingsPath, "utf-8"));
+      current = JSON.parse(readFileSync42(settingsPath, "utf-8"));
     } catch {
-      writeFileSync30(`${settingsPath}.backup-${Date.now()}`, readFileSync41(settingsPath, "utf-8"));
+      writeFileSync31(`${settingsPath}.backup-${Date.now()}`, readFileSync42(settingsPath, "utf-8"));
       current = {};
     }
   }
   const { settings, added, already } = applyAllowList(current, allowEntries);
-  writeFileSync30(settingsPath, `${JSON.stringify(settings, null, 2)}
+  writeFileSync31(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   return {
     claude_cli_present: true,
@@ -192138,10 +193111,10 @@ __export(exports_mcp_hosts_register, {
   __testing__: () => __testing__
 });
 import {
-  readFileSync as readFileSync42,
-  writeFileSync as writeFileSync31,
-  existsSync as existsSync56,
-  mkdirSync as mkdirSync35,
+  readFileSync as readFileSync43,
+  writeFileSync as writeFileSync32,
+  existsSync as existsSync57,
+  mkdirSync as mkdirSync36,
   copyFileSync as copyFileSync4
 } from "node:fs";
 import { join as join62, dirname as dirname12 } from "node:path";
@@ -192172,32 +193145,32 @@ function configPathFor(host, home) {
       return join62(home, ".codeium", "windsurf", "mcp_config.json");
   }
 }
-function safeReadJson(path26) {
-  if (!existsSync56(path26))
+function safeReadJson(path27) {
+  if (!existsSync57(path27))
     return {};
   try {
-    const data2 = JSON.parse(readFileSync42(path26, "utf-8"));
+    const data2 = JSON.parse(readFileSync43(path27, "utf-8"));
     return { data: data2 };
   } catch {
     return { parseError: true };
   }
 }
-function backupAndReset(path26) {
+function backupAndReset(path27) {
   try {
-    copyFileSync4(path26, `${path26}.backup-${Date.now()}`);
+    copyFileSync4(path27, `${path27}.backup-${Date.now()}`);
   } catch {}
 }
-function writeJsonIfChanged(path26, next2, before2) {
+function writeJsonIfChanged(path27, next2, before2) {
   const nextSerialized = `${JSON.stringify(next2, null, 2)}
 `;
   if (before2 && JSON.stringify(before2) === JSON.stringify(next2))
     return false;
-  mkdirSync35(dirname12(path26), { recursive: true });
-  writeFileSync31(path26, nextSerialized);
+  mkdirSync36(dirname12(path27), { recursive: true });
+  writeFileSync32(path27, nextSerialized);
   return true;
 }
 function registerSimpleMcpServer(host, configPath4, serverCommand, serverArgs, env2, entryName = "unbrowse") {
-  if (!existsSync56(configPath4)) {
+  if (!existsSync57(configPath4)) {
     return { host, config_path: configPath4, action: "not_detected" };
   }
   const { data: data2, parseError } = safeReadJson(configPath4);
@@ -192234,7 +193207,7 @@ function registerSimpleMcpServer(host, configPath4, serverCommand, serverArgs, e
   };
 }
 function registerContinueMcpServer(configPath4, serverCommand, serverArgs, env2, entryName = "unbrowse") {
-  if (!existsSync56(configPath4)) {
+  if (!existsSync57(configPath4)) {
     return { host: "continue", config_path: configPath4, action: "not_detected" };
   }
   const { data: data2, parseError } = safeReadJson(configPath4);
@@ -192277,12 +193250,12 @@ function registerContinueMcpServer(configPath4, serverCommand, serverArgs, env2,
   };
 }
 function registerCodexMcpServer(configPath4, serverCommand, serverArgs, env2, entryName = "unbrowse") {
-  if (!existsSync56(configPath4)) {
+  if (!existsSync57(configPath4)) {
     return { host: "codex", config_path: configPath4, action: "not_detected" };
   }
   let body;
   try {
-    body = readFileSync42(configPath4, "utf-8");
+    body = readFileSync43(configPath4, "utf-8");
   } catch {
     return { host: "codex", config_path: configPath4, action: "parse_error", detail: "could not read file" };
   }
@@ -192311,8 +193284,8 @@ function registerCodexMcpServer(configPath4, serverCommand, serverArgs, env2, en
   const next2 = body.endsWith(`
 `) ? `${body}${proposedStanza}` : `${body}
 ${proposedStanza}`;
-  mkdirSync35(dirname12(configPath4), { recursive: true });
-  writeFileSync31(configPath4, next2);
+  mkdirSync36(dirname12(configPath4), { recursive: true });
+  writeFileSync32(configPath4, next2);
   return { host: "codex", config_path: configPath4, action: "merged" };
 }
 function registerMcpHosts(opts) {
@@ -192461,10 +193434,10 @@ __export(exports_payment_provider2, {
   _clearPaymentProviderCacheForTests: () => _clearPaymentProviderCacheForTests2
 });
 import fs8 from "node:fs";
-import path26 from "node:path";
-import os16 from "node:os";
+import path27 from "node:path";
+import os17 from "node:os";
 function configPath4() {
-  return process.env.UNBROWSE_CONFIG_PATH || path26.join(os16.homedir(), ".unbrowse", "config.json");
+  return process.env.UNBROWSE_CONFIG_PATH || path27.join(os17.homedir(), ".unbrowse", "config.json");
 }
 function readConfigFile3() {
   const p = configPath4();
@@ -192478,7 +193451,7 @@ function readConfigFile3() {
 }
 function writeConfigFile3(merged) {
   const p = configPath4();
-  fs8.mkdirSync(path26.dirname(p), { recursive: true });
+  fs8.mkdirSync(path27.dirname(p), { recursive: true });
   fs8.writeFileSync(p, JSON.stringify(merged, null, 2));
 }
 function getPaymentProviderConfig2() {
@@ -192761,7 +193734,7 @@ __export(exports_browser_cookies2, {
 });
 import { execFileSync as execFileSync8 } from "node:child_process";
 import { createDecipheriv as createDecipheriv4, pbkdf2Sync as pbkdf2Sync2 } from "node:crypto";
-import { copyFileSync as copyFileSync5, existsSync as existsSync57, mkdtempSync as mkdtempSync5, readdirSync as readdirSync15, rmSync as rmSync4 } from "node:fs";
+import { copyFileSync as copyFileSync5, existsSync as existsSync58, mkdtempSync as mkdtempSync5, readdirSync as readdirSync15, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir5, homedir as homedir49, platform as platform6 } from "node:os";
 import { join as join63 } from "node:path";
 function getChromeUserDataDir2() {
@@ -192787,7 +193760,7 @@ function resolveChromiumCookiesPath2(opts) {
     join63(userDataDir, "Network", "Cookies"),
     join63(userDataDir, "Cookies")
   ];
-  return candidates.find((candidate) => existsSync57(candidate)) ?? candidates[0] ?? null;
+  return candidates.find((candidate) => existsSync58(candidate)) ?? candidates[0] ?? null;
 }
 function getFirefoxProfilesRoot2() {
   const home = homedir49();
@@ -192808,7 +193781,7 @@ function getFirefoxProfilesRoot2() {
 function pickFirefoxProfile2(profilesRoot, profile) {
   if (profile) {
     const candidate2 = join63(profilesRoot, profile, "cookies.sqlite");
-    return existsSync57(candidate2) ? candidate2 : null;
+    return existsSync58(candidate2) ? candidate2 : null;
   }
   const entries = readdirSync15(profilesRoot, { withFileTypes: true });
   const defaultRelease = entries.find((e) => e.isDirectory() && e.name.includes("default-release"));
@@ -192816,11 +193789,11 @@ function pickFirefoxProfile2(profilesRoot, profile) {
   if (!targetDir)
     return null;
   const candidate = join63(profilesRoot, targetDir, "cookies.sqlite");
-  return existsSync57(candidate) ? candidate : null;
+  return existsSync58(candidate) ? candidate : null;
 }
 function getFirefoxCookiesPath2(profile) {
   const profilesRoot = getFirefoxProfilesRoot2();
-  if (!profilesRoot || !existsSync57(profilesRoot))
+  if (!profilesRoot || !existsSync58(profilesRoot))
     return null;
   return pickFirefoxProfile2(profilesRoot, profile);
 }
@@ -192895,7 +193868,7 @@ function withTempCopy2(dbPath, fn) {
     copyFileSync5(dbPath, tempDb);
     for (const ext of ["-wal", "-shm"]) {
       const src = dbPath + ext;
-      if (existsSync57(src))
+      if (existsSync58(src))
         copyFileSync5(src, tempDb + ext);
     }
     return fn(tempDb);
@@ -192940,7 +193913,7 @@ function extractFromChromium2(domain, opts) {
   const warnings = [];
   const dbPath = resolveChromiumCookiesPath2(opts);
   const sourceLabel = opts?.browserName || "Chromium";
-  if (!dbPath || !existsSync57(dbPath)) {
+  if (!dbPath || !existsSync58(dbPath)) {
     warnings.push(`${sourceLabel} cookies DB not found${dbPath ? ` at ${dbPath}` : ""}`);
     return { cookies: [], source: null, warnings };
   }
@@ -193036,7 +194009,7 @@ function extractBrowserCookies2(domain, opts) {
   const __result = _extractBrowserCookiesInner2(domain, opts);
   try {
     const traceDir = join63(homedir49(), ".unbrowse", "traces");
-    if (!existsSync57(traceDir))
+    if (!existsSync58(traceDir))
       mkdirSync(traceDir, { recursive: true });
     const entry = JSON.stringify({
       d: domain,
@@ -193090,7 +194063,7 @@ function scanAllBrowserSessions2(domain) {
   const home = homedir49();
   for (const browser of CHROMIUM_BROWSERS2) {
     const userDataDir = platform6() === "darwin" ? join63(home, "Library", "Application Support", browser.macPath) : platform6() === "win32" ? join63(process.env.LOCALAPPDATA ?? join63(home, "AppData", "Local"), browser.macPath, "User Data") : join63(home, ".config", browser.macPath.toLowerCase());
-    if (!existsSync57(userDataDir))
+    if (!existsSync58(userDataDir))
       continue;
     try {
       const result = extractFromChromium2(domain, {
@@ -193133,7 +194106,7 @@ function chromiumCookiesPathForUserDataDir2(userDataDir) {
     join63(userDataDir, "Default", "Network", "Cookies")
   ];
   for (const p of candidates)
-    if (existsSync57(p))
+    if (existsSync58(p))
       return p;
   return null;
 }
@@ -193167,13 +194140,13 @@ function scanChromiumDomainSummary2(userDataDir, browserName) {
 }
 function scanFirefoxDomainSummary2() {
   const profilesRoot = getFirefoxProfilesRoot2();
-  if (!profilesRoot || !existsSync57(profilesRoot))
+  if (!profilesRoot || !existsSync58(profilesRoot))
     return null;
   const profile = pickFirefoxProfile2(profilesRoot);
   if (!profile)
     return null;
   const cookiesPath = getFirefoxCookiesPath2(profile);
-  if (!cookiesPath || !existsSync57(cookiesPath))
+  if (!cookiesPath || !existsSync58(cookiesPath))
     return null;
   try {
     return withTempCopy2(cookiesPath, (temp) => {
@@ -193206,7 +194179,7 @@ function listCookieDomains2() {
   const home = homedir49();
   for (const browser of CHROMIUM_BROWSERS2) {
     const userDataDir = platform6() === "darwin" ? join63(home, "Library", "Application Support", browser.macPath) : platform6() === "win32" ? join63(process.env.LOCALAPPDATA ?? join63(home, "AppData", "Local"), browser.macPath, "User Data") : join63(home, ".config", browser.macPath.toLowerCase());
-    if (!existsSync57(userDataDir)) {
+    if (!existsSync58(userDataDir)) {
       browsersSkipped.push(`${browser.name} (not installed)`);
       continue;
     }
@@ -194377,7 +195350,7 @@ function extractSPAData2(html3) {
   const MAX_BRANCHES = 12;
   const MIN_BRANCH_LEN = 3;
   const MAX_PATH_DEPTH = 6;
-  const visit = (node2, path27, depth) => {
+  const visit = (node2, path28, depth) => {
     if (branchEmissions.length >= MAX_BRANCHES || depth > MAX_PATH_DEPTH)
       return;
     if (Array.isArray(node2)) {
@@ -194392,19 +195365,19 @@ function extractSPAData2(html3) {
               type: "spa-initial-state",
               data: node2,
               element_count: node2.length,
-              selector: path27 || "(root)"
+              selector: path28 || "(root)"
             });
           }
         }
       }
       for (let i = 0;i < Math.min(node2.length, 20); i++) {
-        visit(node2[i], `${path27}[${i}]`, depth + 1);
+        visit(node2[i], `${path28}[${i}]`, depth + 1);
       }
       return;
     }
     if (node2 && typeof node2 === "object") {
       for (const [key2, value] of Object.entries(node2)) {
-        visit(value, path27 ? `${path27}.${key2}` : key2, depth + 1);
+        visit(value, path28 ? `${path28}.${key2}` : key2, depth + 1);
       }
     }
   };
@@ -197288,7 +198261,7 @@ __export(exports_x402_fetch, {
   x402Fetch: () => x402Fetch2,
   resolveWalletConfig: () => resolveWalletConfig2
 });
-import { existsSync as existsSync58, readFileSync as readFileSync43 } from "node:fs";
+import { existsSync as existsSync59, readFileSync as readFileSync44 } from "node:fs";
 import { homedir as homedir50 } from "node:os";
 import { join as join64 } from "node:path";
 function resolveWalletConfig2(env2 = process.env) {
@@ -197306,10 +198279,10 @@ function resolveWalletConfig2(env2 = process.env) {
     return { adapter: "none", max_cost_usd };
   }
   const home = env2.HOME || homedir50();
-  if (existsSync58(join64(home, ".lobster", "agents.json"))) {
+  if (existsSync59(join64(home, ".lobster", "agents.json"))) {
     return { adapter: "lobster", max_cost_usd };
   }
-  if (existsSync58(join64(home, ".privy", "session.json"))) {
+  if (existsSync59(join64(home, ".privy", "session.json"))) {
     return { adapter: "privy", max_cost_usd };
   }
   if (env2.UNBROWSE_WALLET_KEY?.trim()) {
@@ -197376,11 +198349,11 @@ async function signViaLobster2(envelope) {
 async function signViaPrivy2(envelope) {
   const home = process.env.HOME || homedir50();
   const sessionPath2 = join64(home, ".privy", "session.json");
-  if (!existsSync58(sessionPath2))
+  if (!existsSync59(sessionPath2))
     return { error: "privy session missing" };
   let sessionToken = "";
   try {
-    const raw = JSON.parse(readFileSync43(sessionPath2, "utf8"));
+    const raw = JSON.parse(readFileSync44(sessionPath2, "utf8"));
     sessionToken = raw.token ?? raw.access_token ?? "";
   } catch {
     return { error: "privy session unreadable" };
@@ -197439,9 +198412,9 @@ async function signViaGeneric2(envelope, keyRef) {
   if (signer.startsWith("exec:")) {
     const cmd = signer.slice("exec:".length);
     try {
-      const { spawn: spawn11 } = await import("node:child_process");
+      const { spawn: spawn12 } = await import("node:child_process");
       return await new Promise((resolve15) => {
-        const proc = spawn11(cmd, [keyRef], { stdio: ["pipe", "pipe", "pipe"], shell: true });
+        const proc = spawn12(cmd, [keyRef], { stdio: ["pipe", "pipe", "pipe"], shell: true });
         let out = "";
         let err = "";
         proc.stdout.on("data", (d) => {
@@ -197782,8 +198755,8 @@ __export(exports_version2, {
   DEFAULT_BACKEND_URL: () => DEFAULT_BACKEND_URL2,
   CODE_HASH: () => CODE_HASH2
 });
-import { createHash as createHash40 } from "crypto";
-import { existsSync as existsSync59, readFileSync as readFileSync44, readdirSync as readdirSync16 } from "fs";
+import { createHash as createHash42 } from "crypto";
+import { existsSync as existsSync60, readFileSync as readFileSync45, readdirSync as readdirSync16 } from "fs";
 import { dirname as dirname13, join as join65, parse as parse10 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
 import { execSync as execSync7 } from "child_process";
@@ -197807,10 +198780,10 @@ function collectTsFiles2(dir) {
   return results;
 }
 function hashFiles2(srcDir, files) {
-  const hash = createHash40("sha256");
+  const hash = createHash42("sha256");
   for (const file of files) {
     hash.update(file.slice(srcDir.length));
-    hash.update(readFileSync44(file, "utf-8"));
+    hash.update(readFileSync45(file, "utf-8"));
   }
   return hash.digest("hex").slice(0, 12);
 }
@@ -197824,7 +198797,7 @@ function resolveCodeHashSourceDir2(moduleDir) {
   ];
   for (const candidate of candidates) {
     try {
-      if (!existsSync59(candidate))
+      if (!existsSync60(candidate))
         continue;
       const files = collectTsFiles2(candidate);
       if (files.length > 0)
@@ -197847,7 +198820,7 @@ function computeCodeHash2() {
   } catch {}
   const pkgVersion = getPackageVersion2();
   if (pkgVersion !== "unknown") {
-    return createHash40("sha256").update(`package:${pkgVersion}`).digest("hex").slice(0, 12);
+    return createHash42("sha256").update(`package:${pkgVersion}`).digest("hex").slice(0, 12);
   }
   return "compiled";
 }
@@ -197874,7 +198847,7 @@ function getPackageVersionForModuleDir2(moduleDir) {
   const root2 = parse10(dir).root;
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync44(join65(dir, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync45(join65(dir, "package.json"), "utf-8"));
       return typeof pkg.version === "string" ? pkg.version : "unknown";
     } catch {}
     if (dir === root2)
@@ -198072,16 +199045,16 @@ var init_build = __esm(() => {
 
 // .tmp-runtime-src/cli-v7/act/fill-form.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { randomBytes as randomBytes22, createHash as createHash41 } from "node:crypto";
+import { randomBytes as randomBytes22, createHash as createHash43 } from "node:crypto";
 import { homedir as homedir51 } from "node:os";
 import { join as join66 } from "node:path";
 function sha256Hex8(s) {
-  return createHash41("sha256").update(s, "utf8").digest("hex");
+  return createHash43("sha256").update(s, "utf8").digest("hex");
 }
 function deriveFormContextHash(sessionId, formSelector, url, nowMs = Date.now()) {
   const bucket = Math.floor(nowMs / FIVE_MINUTES_MS5).toString();
   const payload = `${sessionId}:form:${formSelector}:${url}:${bucket}`;
-  return createHash41("sha256").update(payload, "utf8").digest("hex");
+  return createHash43("sha256").update(payload, "utf8").digest("hex");
 }
 function formSlotEnumExpression(formSelector) {
   const fs9 = JSON.stringify(formSelector);
@@ -198437,7 +199410,7 @@ var init_fill_form = __esm(() => {
 });
 
 // .tmp-runtime-src/cli-v7/act/session-park.ts
-import { createHash as createHash42 } from "node:crypto";
+import { createHash as createHash44 } from "node:crypto";
 function canonicalizeSignedFragment5(body) {
   const pointersCanonical = body.boundPointers.map((bp) => ({
     l1_pointer: bp.l1_pointer,
@@ -198552,7 +199525,7 @@ async function handler36(parsed, opts) {
   }
   const recForDelete = rec;
   const parkedAt = Date.now();
-  const capturedEndpointsHash = createHash42("sha256").update(`${rec.sessionId}:${targetUrl}:v7.2.0-preview.0:empty`).digest("hex");
+  const capturedEndpointsHash = createHash44("sha256").update(`${rec.sessionId}:${targetUrl}:v7.2.0-preview.0:empty`).digest("hex");
   const { signature: sigBytes, walletPubkey: pubBytes } = await signBytes(new TextEncoder().encode(""));
   const walletPubkeyHex = bytesToHex18(pubBytes);
   const bodyWithoutSig = {
@@ -199090,7 +200063,7 @@ async function drainOnce(queueDir, processor, maxAttempts = 3) {
 `);
     }
   }
-  for (const { path: path27, envelope } of accepted) {
+  for (const { path: path28, envelope } of accepted) {
     const lockPath = join67(queueDir, sanitizeDomain(envelope.domain) + ".lock");
     const release = await acquireLock(lockPath);
     if (release === null)
@@ -199098,7 +200071,7 @@ async function drainOnce(queueDir, processor, maxAttempts = 3) {
     try {
       try {
         await processor(envelope.job);
-        await deleteJob(path27);
+        await deleteJob(path28);
         processed++;
       } catch {
         const newAttempts = envelope.attempts + 1;
@@ -199112,10 +200085,10 @@ async function drainOnce(queueDir, processor, maxAttempts = 3) {
             attempts: newAttempts,
             job: envelope.job
           });
-          await deleteJob(path27);
+          await deleteJob(path28);
           deadLettered++;
         } else {
-          await rewriteJobAtPath(path27, {
+          await rewriteJobAtPath(path28, {
             version: 1,
             domain: envelope.domain,
             queuedAt: Date.now(),
@@ -199211,10 +200184,10 @@ async function writeCaptureSpool2(spoolDir, envelope) {
   await rename5(tmpPath, finalPath);
   return finalPath;
 }
-async function rewriteCaptureSpoolAtPath(path27, envelope) {
-  const tmpPath = `${path27}.tmp`;
+async function rewriteCaptureSpoolAtPath(path28, envelope) {
+  const tmpPath = `${path28}.tmp`;
   await writeFile8(tmpPath, JSON.stringify(envelope));
-  await rename5(tmpPath, path27);
+  await rename5(tmpPath, path28);
 }
 async function listCaptureSpool(spoolDir) {
   const absDir = resolve15(spoolDir);
@@ -199234,23 +200207,23 @@ async function listCaptureSpool(spoolDir) {
       continue;
     if (entry.name.endsWith(".tmp"))
       continue;
-    const path27 = join68(absDir, entry.name);
+    const path28 = join68(absDir, entry.name);
     let parsed;
     try {
-      parsed = JSON.parse(await readFile10(path27, "utf8"));
+      parsed = JSON.parse(await readFile10(path28, "utf8"));
     } catch {
       continue;
     }
     if (!isCaptureSpoolEnvelope(parsed))
       continue;
-    results.push({ path: path27, envelope: parsed });
+    results.push({ path: path28, envelope: parsed });
   }
   results.sort((a, b) => a.envelope.capturedAt - b.envelope.capturedAt);
   return results;
 }
-async function deleteCaptureSpool(path27) {
+async function deleteCaptureSpool(path28) {
   try {
-    await unlink6(path27);
+    await unlink6(path28);
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -199264,7 +200237,7 @@ async function drainCaptureSpoolOnce(spoolDir, processor, maxAttempts = 3) {
   let failed = 0;
   let deadLettered = 0;
   const accepted = await listCaptureSpool(spoolDir);
-  for (const { path: path27, envelope } of accepted) {
+  for (const { path: path28, envelope } of accepted) {
     const lockPath = join68(resolve15(spoolDir), sanitizeDomain(envelope.domain) + ".lock");
     const release = await acquireLock(lockPath);
     if (release === null)
@@ -199272,19 +200245,19 @@ async function drainCaptureSpoolOnce(spoolDir, processor, maxAttempts = 3) {
     try {
       try {
         await processor(envelope.capture);
-        await deleteCaptureSpool(path27);
+        await deleteCaptureSpool(path28);
         processed++;
       } catch {
         const newAttempts = envelope.attempts + 1;
         if (newAttempts >= maxAttempts) {
           const deadDir = join68(resolve15(spoolDir), "dead");
           await mkdir11(deadDir, { recursive: true });
-          await rename5(path27, join68(deadDir, basename4(path27))).catch(async () => {
-            await deleteCaptureSpool(path27);
+          await rename5(path28, join68(deadDir, basename4(path28))).catch(async () => {
+            await deleteCaptureSpool(path28);
           });
           deadLettered++;
         } else {
-          await rewriteCaptureSpoolAtPath(path27, {
+          await rewriteCaptureSpoolAtPath(path28, {
             ...envelope,
             capturedAt: Date.now(),
             attempts: newAttempts
@@ -199353,18 +200326,18 @@ function hasInlineAuth2(proxyUrl) {
 }
 function spawnAuthForwarder2(upstreamUrl) {
   try {
-    const { spawnSync: spawnSync6, spawn: spawn11 } = __require("node:child_process");
-    const path27 = __require("node:path");
+    const { spawnSync: spawnSync6, spawn: spawn12 } = __require("node:child_process");
+    const path28 = __require("node:path");
     const fs9 = __require("node:fs");
     let here = __dirname;
     let scriptPath = null;
     for (let i = 0;i < 6; i++) {
-      const candidate = path27.join(here, "scripts", "local-proxy-auth-forwarder.py");
+      const candidate = path28.join(here, "scripts", "local-proxy-auth-forwarder.py");
       if (fs9.existsSync(candidate)) {
         scriptPath = candidate;
         break;
       }
-      const parent2 = path27.dirname(here);
+      const parent2 = path28.dirname(here);
       if (parent2 === here)
         break;
       here = parent2;
@@ -199374,12 +200347,12 @@ function spawnAuthForwarder2(upstreamUrl) {
 `);
       return null;
     }
-    const os17 = __require("node:os");
-    const readyFile = path27.join(os17.tmpdir(), `kuri-proxy-forwarder-${process.pid}-${Date.now()}.ready`);
+    const os18 = __require("node:os");
+    const readyFile = path28.join(os18.tmpdir(), `kuri-proxy-forwarder-${process.pid}-${Date.now()}.ready`);
     try {
       fs9.unlinkSync(readyFile);
     } catch {}
-    const child = spawn11("python3", [scriptPath, "--upstream", upstreamUrl, "--quiet", "--ready-file", readyFile], {
+    const child = spawn12("python3", [scriptPath, "--upstream", upstreamUrl, "--quiet", "--ready-file", readyFile], {
       stdio: "ignore",
       detached: true
     });
@@ -199807,14 +200780,14 @@ __export(exports_server, {
   getInflightMcpBridgedCount: () => getInflightMcpBridgedCount
 });
 import { execSync as execSync8 } from "node:child_process";
-import { mkdirSync as mkdirSync36, unlinkSync as unlinkSync8, writeFileSync as writeFileSync32 } from "node:fs";
-import path27 from "node:path";
+import { mkdirSync as mkdirSync37, unlinkSync as unlinkSync9, writeFileSync as writeFileSync33 } from "node:fs";
+import path28 from "node:path";
 function updatePidFile(pidFile, host = "127.0.0.1", port = 6969) {
   if (!pidFile)
     return;
   try {
-    mkdirSync36(path27.dirname(pidFile), { recursive: true });
-    writeFileSync32(pidFile, JSON.stringify({
+    mkdirSync37(path28.dirname(pidFile), { recursive: true });
+    writeFileSync33(pidFile, JSON.stringify({
       pid: process.pid,
       base_url: `http://${host}:${port}`,
       started_at: new Date().toISOString(),
@@ -199827,7 +200800,7 @@ function clearPidFile(pidFile) {
   if (!pidFile)
     return;
   try {
-    unlinkSync8(pidFile);
+    unlinkSync9(pidFile);
   } catch {}
 }
 function getInflightMcpBridgedCount() {
@@ -199964,7 +200937,35 @@ var init_server = __esm(async () => {
 
 // .tmp-runtime-src/cli.ts
 var import_dotenv = __toESM(require_main(), 1);
-import { spawn as spawn11 } from "child_process";
+import { spawn as spawn12 } from "child_process";
+import { createHash as createHash45 } from "crypto";
+
+// .tmp-runtime-src/lib/infer-write-method.ts
+var WRITE_METHODS = new Set(["POST", "PUT", "PATCH", "DELETE"]);
+var READ_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+var INTENT_RULES = [
+  ["DELETE", /\b(delete|remove|destroy|cancel|unsubscribe|revoke|deregister)\b/i],
+  ["PUT", /\b(replace|overwrite|put|set\s+the\s+entire)\b/i],
+  ["PATCH", /\b(update|edit|modify|change|rename|patch|adjust|toggle)\b/i],
+  ["POST", /\b(create|post|add|submit|new|register|sign\s*up|send|upload|publish|insert|book|order|comment|reply|like|upvote|vote)\b/i]
+];
+function inferWriteMethod(explicit, intent, hasBody) {
+  if (explicit) {
+    const m = explicit.toUpperCase();
+    if (WRITE_METHODS.has(m))
+      return m;
+    if (READ_METHODS.has(m))
+      return;
+  }
+  const text = intent || "";
+  for (const [verb, re] of INTENT_RULES) {
+    if (re.test(text))
+      return verb;
+  }
+  if (hasBody)
+    return "POST";
+  return;
+}
 
 // .tmp-runtime-src/env/kuri-proxy-bridge.ts
 init_proxy_fetch();
@@ -201123,7 +202124,7 @@ init_telemetry_attribution();
 import { readFileSync as readFileSync15, writeFileSync as writeFileSync8, existsSync as existsSync26, mkdirSync as mkdirSync10, readdirSync as readdirSync6, unlinkSync as unlinkSync3 } from "fs";
 import { join as join33 } from "path";
 import { homedir as homedir29, hostname as hostname2, release as osRelease2 } from "os";
-import { randomBytes as randomBytes15, createHash as createHash31 } from "crypto";
+import { randomBytes as randomBytes15, createHash as createHash32 } from "crypto";
 import { createInterface as createInterface3 } from "readline";
 import { execSync as execSync5 } from "child_process";
 var PROFILE_NAME2 = sanitizeProfileName2(process.env.UNBROWSE_PROFILE ?? DEFAULT_PROFILE ?? "");
@@ -202730,19 +203731,19 @@ function getLastVendorBlock(windowMs = 60000) {
 }
 
 // .tmp-runtime-src/runtime/paths.ts
-import { existsSync as existsSync44, mkdirSync as mkdirSync26, realpathSync as realpathSync2 } from "node:fs";
-import path19 from "node:path";
+import { existsSync as existsSync45, mkdirSync as mkdirSync27, realpathSync as realpathSync2 } from "node:fs";
+import path20 from "node:path";
 import { createRequire as createRequire4 } from "node:module";
 import { fileURLToPath as fileURLToPath6, pathToFileURL as pathToFileURL2 } from "node:url";
 function resolveSiblingEntrypoint2(metaUrl, basename3) {
   const file = fileURLToPath6(metaUrl);
-  return path19.join(path19.dirname(file), `${basename3}${path19.extname(file) || ".js"}`);
+  return path20.join(path20.dirname(file), `${basename3}${path20.extname(file) || ".js"}`);
 }
 function isBundledVirtualEntrypoint(entrypoint) {
   return entrypoint.startsWith("/$bunfs/");
 }
 function runtimeArgsForEntrypoint2(metaUrl, entrypoint) {
-  if (path19.extname(entrypoint) !== ".ts") {
+  if (path20.extname(entrypoint) !== ".ts") {
     return process.platform === "win32" ? [pathToFileURL2(entrypoint).href] : [entrypoint];
   }
   if (process.versions.bun)
@@ -202750,8 +203751,8 @@ function runtimeArgsForEntrypoint2(metaUrl, entrypoint) {
   try {
     const req = createRequire4(metaUrl);
     const tsxPkg = req.resolve("tsx/package.json");
-    const tsxLoader = path19.join(path19.dirname(tsxPkg), "dist", "loader.mjs");
-    if (existsSync44(tsxLoader))
+    const tsxLoader = path20.join(path20.dirname(tsxPkg), "dist", "loader.mjs");
+    if (existsSync45(tsxLoader))
       return ["--import", pathToFileURL2(tsxLoader).href, entrypoint];
   } catch {}
   return ["--import", "tsx", entrypoint];
@@ -202769,7 +203770,7 @@ function isMainModule(metaUrl) {
   try {
     return realpathSync2(entry) === realpathSync2(modulePath);
   } catch {
-    return path19.resolve(entry) === path19.resolve(modulePath);
+    return path20.resolve(entry) === path20.resolve(modulePath);
   }
 }
 
@@ -202815,52 +203816,52 @@ init_client2();
 init_logger();
 init_wallet();
 import { execFileSync as execFileSync7 } from "node:child_process";
-import { existsSync as existsSync47, mkdirSync as mkdirSync28, writeFileSync as writeFileSync24 } from "node:fs";
-import os13 from "node:os";
-import path21 from "node:path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync29, writeFileSync as writeFileSync25 } from "node:fs";
+import os14 from "node:os";
+import path22 from "node:path";
 
 // .tmp-runtime-src/runtime/update-hints.ts
 init_paths();
-import { existsSync as existsSync46, mkdirSync as mkdirSync27, readFileSync as readFileSync34, writeFileSync as writeFileSync23 } from "node:fs";
-import os12 from "node:os";
-import path20 from "node:path";
+import { existsSync as existsSync47, mkdirSync as mkdirSync28, readFileSync as readFileSync35, writeFileSync as writeFileSync24 } from "node:fs";
+import os13 from "node:os";
+import path21 from "node:path";
 var DEFAULT_INTERVAL_MS = 12 * 60 * 60 * 1000;
 var CODEX_MARKER = "# Unbrowse update hints — managed by unbrowse setup";
 function getHomeDir() {
-  return process.env.HOME || os12.homedir();
+  return process.env.HOME || os13.homedir();
 }
 function getConfigDir6() {
   if (process.env.UNBROWSE_CONFIG_DIR)
     return process.env.UNBROWSE_CONFIG_DIR;
-  return path20.join(getHomeDir(), ".unbrowse");
+  return path21.join(getHomeDir(), ".unbrowse");
 }
 function ensureDir4(dir) {
-  if (!existsSync46(dir))
-    mkdirSync27(dir, { recursive: true });
+  if (!existsSync47(dir))
+    mkdirSync28(dir, { recursive: true });
   return dir;
 }
 function readJsonFile(file) {
   try {
-    return JSON.parse(readFileSync34(file, "utf8"));
+    return JSON.parse(readFileSync35(file, "utf8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(file, value) {
-  ensureDir4(path20.dirname(file));
-  writeFileSync23(file, `${JSON.stringify(value, null, 2)}
+  ensureDir4(path21.dirname(file));
+  writeFileSync24(file, `${JSON.stringify(value, null, 2)}
 `);
 }
 function getInstallSourcePath() {
-  return path20.join(getConfigDir6(), "install-source.json");
+  return path21.join(getConfigDir6(), "install-source.json");
 }
 function detectRepoRoot(start4) {
-  let dir = path20.resolve(start4);
-  const root2 = path20.parse(dir).root;
+  let dir = path21.resolve(start4);
+  const root2 = path21.parse(dir).root;
   while (dir !== root2) {
-    if (existsSync46(path20.join(dir, ".git")))
+    if (existsSync47(path21.join(dir, ".git")))
       return dir;
-    dir = path20.dirname(dir);
+    dir = path21.dirname(dir);
   }
   return;
 }
@@ -202869,7 +203870,7 @@ function detectInstallMethod(packageRoot) {
     return "repo-clone";
   if (process.env.UNBROWSE_SETUP_METHOD === "npm-global")
     return "npm-global";
-  if (packageRoot.includes(`${path20.sep}node_modules${path20.sep}`))
+  if (packageRoot.includes(`${path21.sep}node_modules${path21.sep}`))
     return "npm-global";
   return detectRepoRoot(packageRoot) ? "repo-clone" : "unknown";
 }
@@ -202879,12 +203880,12 @@ function detectInstallHost(repoRoot) {
     return explicit;
   if (!repoRoot)
     return "unknown";
-  const codexHome = process.env.CODEX_HOME || path20.join(getHomeDir(), ".codex");
-  if (repoRoot === path20.join(codexHome, "skills", "unbrowse"))
+  const codexHome = process.env.CODEX_HOME || path21.join(getHomeDir(), ".codex");
+  if (repoRoot === path21.join(codexHome, "skills", "unbrowse"))
     return "codex";
-  if (repoRoot === path20.join(getHomeDir(), "(internal)", "skills", "unbrowse"))
+  if (repoRoot === path21.join(getHomeDir(), "(internal)", "skills", "unbrowse"))
     return "claude";
-  if (repoRoot === path20.join(getHomeDir(), "unbrowse"))
+  if (repoRoot === path21.join(getHomeDir(), "unbrowse"))
     return "off";
   return "unknown";
 }
@@ -202912,14 +203913,14 @@ function commandIncludesHook(command2, marker) {
   return typeof command2 === "string" && command2.includes(marker);
 }
 function getCodexConfigPath() {
-  const codexHome = process.env.CODEX_HOME || path20.join(getHomeDir(), ".codex");
-  return path20.join(codexHome, "config.toml");
+  const codexHome = process.env.CODEX_HOME || path21.join(getHomeDir(), ".codex");
+  return path21.join(codexHome, "config.toml");
 }
 function getClaudeSettingsPath() {
-  return path20.join(getHomeDir(), "(internal)", "settings.json");
+  return path21.join(getHomeDir(), "(internal)", "settings.json");
 }
 function getHookScriptPath(metaUrl) {
-  return path20.join(getPackageRoot(metaUrl), "bin", "unbrowse-update-hint.mjs");
+  return path21.join(getPackageRoot(metaUrl), "bin", "unbrowse-update-hint.mjs");
 }
 function ensureCodexHooksFeature(content) {
   if (/\bcodex_hooks\s*=\s*true\b/.test(content))
@@ -202941,13 +203942,13 @@ function repairManagedCodexHookTable(content) {
 }
 function writeCodexHook(metaUrl) {
   const configPath3 = getCodexConfigPath();
-  if (!existsSync46(path20.dirname(configPath3))) {
+  if (!existsSync47(path21.dirname(configPath3))) {
     return { host: "codex", action: "not-detected", config_file: configPath3 };
   }
   try {
     const hookScript = getHookScriptPath(metaUrl).replace(/\\/g, "/");
-    const fileExistsBefore = existsSync46(configPath3);
-    let content = fileExistsBefore ? readFileSync34(configPath3, "utf8") : "";
+    const fileExistsBefore = existsSync47(configPath3);
+    let content = fileExistsBefore ? readFileSync35(configPath3, "utf8") : "";
     const previous = content;
     content = ensureCodexHooksFeature(content);
     content = repairManagedCodexHookTable(content);
@@ -202963,7 +203964,7 @@ command = ${JSON.stringify(command2)}
 `;
     }
     if (content !== previous) {
-      writeFileSync23(configPath3, content, "utf8");
+      writeFileSync24(configPath3, content, "utf8");
       return {
         host: "codex",
         action: fileExistsBefore ? "updated" : "installed",
@@ -202982,13 +203983,13 @@ command = ${JSON.stringify(command2)}
 }
 function writeClaudeHook(metaUrl) {
   const settingsPath = getClaudeSettingsPath();
-  if (!existsSync46(path20.dirname(settingsPath))) {
+  if (!existsSync47(path21.dirname(settingsPath))) {
     return { host: "claude", action: "not-detected", config_file: settingsPath };
   }
   try {
     const hookScript = getHookScriptPath(metaUrl).replace(/\\/g, "/");
     const command2 = `node "${hookScript}"`;
-    const fileExistsBefore = existsSync46(settingsPath);
+    const fileExistsBefore = existsSync47(settingsPath);
     const settings = readJsonFile(settingsPath) ?? {};
     settings.hooks ??= {};
     settings.hooks.SessionStart ??= [];
@@ -203042,18 +204043,18 @@ function detectPackageManagers() {
 }
 function resolveConfigHome() {
   if (process.platform === "win32") {
-    return process.env.APPDATA || path21.join(os13.homedir(), "AppData", "Roaming");
+    return process.env.APPDATA || path22.join(os14.homedir(), "AppData", "Roaming");
   }
-  return process.env.XDG_CONFIG_HOME || path21.join(os13.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path22.join(os14.homedir(), ".config");
 }
 function getOpenCodeGlobalCommandsDir() {
-  return path21.join(resolveConfigHome(), "opencode", "commands");
+  return path22.join(resolveConfigHome(), "opencode", "commands");
 }
 function getOpenCodeProjectCommandsDir(cwd) {
-  return path21.join(cwd, ".opencode", "commands");
+  return path22.join(cwd, ".opencode", "commands");
 }
 function detectOpenCode(cwd) {
-  return hasBinary("opencode") || existsSync47(path21.join(resolveConfigHome(), "opencode")) || existsSync47(path21.join(cwd, ".opencode"));
+  return hasBinary("opencode") || existsSync48(path22.join(resolveConfigHome(), "opencode")) || existsSync48(path22.join(cwd, ".opencode"));
 }
 function renderOpenCodeCommand() {
   return `---
@@ -203081,13 +204082,13 @@ function writeOpenCodeCommand(scope, cwd) {
   if (scope === "auto" && !detected) {
     return { detected: false, action: "not-detected", scope: "off" };
   }
-  const resolvedScope = scope === "project" ? "project" : scope === "global" ? "global" : existsSync47(path21.join(cwd, ".opencode")) ? "project" : "global";
+  const resolvedScope = scope === "project" ? "project" : scope === "global" ? "global" : existsSync48(path22.join(cwd, ".opencode")) ? "project" : "global";
   const commandsDir = resolvedScope === "project" ? getOpenCodeProjectCommandsDir(cwd) : getOpenCodeGlobalCommandsDir();
-  const commandFile = path21.join(ensureDir2(commandsDir), "unbrowse.md");
+  const commandFile = path22.join(ensureDir2(commandsDir), "unbrowse.md");
   const content = renderOpenCodeCommand();
-  const action2 = existsSync47(commandFile) ? "updated" : "installed";
-  mkdirSync28(path21.dirname(commandFile), { recursive: true });
-  writeFileSync24(commandFile, content);
+  const action2 = existsSync48(commandFile) ? "updated" : "installed";
+  mkdirSync29(path22.dirname(commandFile), { recursive: true });
+  writeFileSync25(commandFile, content);
   return {
     detected: detected || scope !== "auto",
     action: action2,
@@ -203097,10 +204098,10 @@ function writeOpenCodeCommand(scope, cwd) {
 }
 async function ensureBrowserEngineInstalled() {
   const binary = findKuriBinary();
-  if (existsSync47(binary)) {
+  if (existsSync48(binary)) {
     return { installed: true, action: "already-installed" };
   }
-  const sourceDir = getKuriSourceCandidates().find((candidate) => existsSync47(path21.join(candidate, "build.zig")));
+  const sourceDir = getKuriSourceCandidates().find((candidate) => existsSync48(path22.join(candidate, "build.zig")));
   if (!sourceDir) {
     return {
       installed: false,
@@ -203122,7 +204123,7 @@ async function ensureBrowserEngineInstalled() {
       timeout: 300000
     });
     const builtBinary = findKuriBinary();
-    if (existsSync47(builtBinary)) {
+    if (existsSync48(builtBinary)) {
       return {
         installed: true,
         action: "installed",
@@ -203156,7 +204157,7 @@ async function runSetup2(options) {
   }
   const walletCheck = checkWalletConfigured();
   const skipWalletSetup = process.env.UNBROWSE_SKIP_WALLET_SETUP === "1";
-  let lobsterInstalled = hasBinary("lobstercash") || existsSync47(path21.join(os13.homedir(), ".agents", "skills", "lobstercash", "SKILL.md"));
+  let lobsterInstalled = hasBinary("lobstercash") || existsSync48(path22.join(os14.homedir(), ".agents", "skills", "lobstercash", "SKILL.md"));
   if (!skipWalletSetup && !walletCheck.configured) {
     const isInteractive = !!process.stdin.isTTY && !!process.stdout.isTTY && process.env.UNBROWSE_NON_INTERACTIVE !== "1";
     let userOptedToSkip = false;
@@ -203246,7 +204247,7 @@ async function runSetup2(options) {
   return {
     os: {
       platform: process.platform,
-      release: os13.release(),
+      release: os14.release(),
       arch: process.arch
     },
     host_environment: hostEnv,
@@ -203285,176 +204286,8 @@ async function promptRegisterSessionKey(ctx) {
   return { skipped: true, reason: "deferred_to_sdk_or_web" };
 }
 
-// .tmp-runtime-src/runtime/update-hints.ts
-init_paths();
-import { existsSync as existsSync48, mkdirSync as mkdirSync29, readFileSync as readFileSync35, writeFileSync as writeFileSync25 } from "node:fs";
-import os14 from "node:os";
-import path22 from "node:path";
-var INSTALL_SCRIPT_URL = "https://unbrowse.ai/install.sh";
-var DEFAULT_INTERVAL_MS2 = 12 * 60 * 60 * 1000;
-function getHomeDir2() {
-  return process.env.HOME || os14.homedir();
-}
-function getConfigDir7() {
-  if (process.env.UNBROWSE_CONFIG_DIR)
-    return process.env.UNBROWSE_CONFIG_DIR;
-  return path22.join(getHomeDir2(), ".unbrowse");
-}
-function ensureDir5(dir) {
-  if (!existsSync48(dir))
-    mkdirSync29(dir, { recursive: true });
-  return dir;
-}
-function readJsonFile2(file) {
-  try {
-    return JSON.parse(readFileSync35(file, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function writeJsonFile2(file, value) {
-  ensureDir5(path22.dirname(file));
-  writeFileSync25(file, `${JSON.stringify(value, null, 2)}
-`);
-}
-function getInstallSourcePath2() {
-  return path22.join(getConfigDir7(), "install-source.json");
-}
-function getUpdateCheckStatePath() {
-  return path22.join(getConfigDir7(), "update-check.json");
-}
-function detectRepoRoot2(start4) {
-  let dir = path22.resolve(start4);
-  const root2 = path22.parse(dir).root;
-  while (dir !== root2) {
-    if (existsSync48(path22.join(dir, ".git")))
-      return dir;
-    dir = path22.dirname(dir);
-  }
-  return;
-}
-function detectInstallMethod2(packageRoot) {
-  if (process.env.UNBROWSE_SETUP_METHOD === "repo-clone")
-    return "repo-clone";
-  if (process.env.UNBROWSE_SETUP_METHOD === "npm-global")
-    return "npm-global";
-  if (packageRoot.includes(`${path22.sep}node_modules${path22.sep}`))
-    return "npm-global";
-  return detectRepoRoot2(packageRoot) ? "repo-clone" : "unknown";
-}
-function detectInstallHost2(repoRoot) {
-  const explicit = process.env.UNBROWSE_SETUP_HOST;
-  if (explicit)
-    return explicit;
-  if (!repoRoot)
-    return "unknown";
-  const codexHome = process.env.CODEX_HOME || path22.join(getHomeDir2(), ".codex");
-  if (repoRoot === path22.join(codexHome, "skills", "unbrowse"))
-    return "codex";
-  if (repoRoot === path22.join(getHomeDir2(), "(internal)", "skills", "unbrowse"))
-    return "claude";
-  if (repoRoot === path22.join(getHomeDir2(), "unbrowse"))
-    return "off";
-  return "unknown";
-}
-function getInstalledVersion(metaUrl) {
-  const packageRoot = getPackageRoot(metaUrl);
-  try {
-    const pkg = JSON.parse(readFileSync35(path22.join(packageRoot, "package.json"), "utf8"));
-    return pkg.version ?? "unknown";
-  } catch {
-    return "unknown";
-  }
-}
-function resolveInstallSource2(metaUrl) {
-  const packageRoot = getPackageRoot(metaUrl);
-  const envRepoRoot = process.env.UNBROWSE_SETUP_ROOT || undefined;
-  const repoRoot = envRepoRoot || detectRepoRoot2(packageRoot);
-  return {
-    method: detectInstallMethod2(packageRoot),
-    host: detectInstallHost2(repoRoot),
-    package_root: packageRoot,
-    repo_root: repoRoot,
-    recorded_at: new Date().toISOString()
-  };
-}
-function loadInstallSource2(metaUrl) {
-  return readJsonFile2(getInstallSourcePath2()) ?? resolveInstallSource2(metaUrl);
-}
-function compareSemver(a, b) {
-  const parse10 = (value) => value.split("-", 1)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const left2 = parse10(a);
-  const right2 = parse10(b);
-  const max = Math.max(left2.length, right2.length);
-  for (let i = 0;i < max; i++) {
-    const diff = (left2[i] ?? 0) - (right2[i] ?? 0);
-    if (diff !== 0)
-      return diff;
-  }
-  return 0;
-}
-async function fetchLatestVersion() {
-  try {
-    const res = await fetch("https://registry.npmjs.org/unbrowse/latest", {
-      signal: AbortSignal.timeout(8000),
-      headers: { Accept: "application/json" }
-    });
-    if (!res.ok)
-      return null;
-    const body = await res.json();
-    return typeof body.version === "string" && body.version.trim() ? body.version.trim() : null;
-  } catch {
-    return null;
-  }
-}
-function getUpdateIntervalMs() {
-  const value = Number.parseInt(process.env.UNBROWSE_UPDATE_CHECK_INTERVAL_MS ?? "", 10);
-  return Number.isFinite(value) && value > 0 ? value : DEFAULT_INTERVAL_MS2;
-}
-function buildUpgradeCommand(install2) {
-  if (install2.method === "repo-clone" && install2.repo_root) {
-    const host = install2.host === "unknown" || install2.host === "auto" ? "off" : install2.host;
-    return `cd ${install2.repo_root} && git pull --ff-only && ./setup --host ${host}`;
-  }
-  return `curl -fsSL ${INSTALL_SCRIPT_URL} | bash`;
-}
-async function checkForUpdates(metaUrl, options) {
-  const installed = getInstalledVersion(metaUrl);
-  const install2 = loadInstallSource2(metaUrl);
-  const statePath = getUpdateCheckStatePath();
-  const state = readJsonFile2(statePath) ?? {};
-  const checkedAt = new Date().toISOString();
-  const intervalMs = getUpdateIntervalMs();
-  const lastChecked = state.latest_checked_at ? Date.parse(state.latest_checked_at) : Number.NaN;
-  const useCache = !options?.force && !!state.latest_version && Number.isFinite(lastChecked) && Date.now() - lastChecked < intervalMs;
-  const latest = useCache ? state.latest_version ?? null : await fetchLatestVersion();
-  if (!useCache) {
-    writeJsonFile2(statePath, {
-      ...state,
-      checked_at: checkedAt,
-      latest_version: latest ?? undefined,
-      latest_checked_at: checkedAt
-    });
-  }
-  return {
-    installed,
-    latest,
-    has_update: !!latest && compareSemver(latest, installed) > 0,
-    install: install2,
-    command: buildUpgradeCommand(install2),
-    checked_at: checkedAt,
-    cached: useCache
-  };
-}
-function recordUpdateHint(latestVersion) {
-  const statePath = getUpdateCheckStatePath();
-  const state = readJsonFile2(statePath) ?? {};
-  writeJsonFile2(statePath, {
-    ...state,
-    notified_version: latestVersion,
-    notified_at: new Date().toISOString()
-  });
-}
+// .tmp-runtime-src/cli.ts
+init_update_hints();
 
 // .tmp-runtime-src/cli-setup.ts
 init_contribution();
@@ -203541,10 +204374,10 @@ function maybeShowContributionNotice() {
 
 // .tmp-runtime-src/config/contribution.ts
 import fs7 from "node:fs";
-import path23 from "node:path";
-import os15 from "node:os";
+import path24 from "node:path";
+import os16 from "node:os";
 function configPath3() {
-  return process.env.UNBROWSE_CONFIG_PATH || path23.join(os15.homedir(), ".unbrowse", "config.json");
+  return process.env.UNBROWSE_CONFIG_PATH || path24.join(os16.homedir(), ".unbrowse", "config.json");
 }
 var DEFAULT3 = {
   contribution: { share_pointers: true, auto_review: true, passive_index: true, set_via: "default" },
@@ -203596,7 +204429,7 @@ function getContributionConfig2() {
   if (isExistingUserMigration) {
     try {
       const merged = { ...raw, ...cached4 };
-      fs7.mkdirSync(path23.dirname(p), { recursive: true });
+      fs7.mkdirSync(path24.dirname(p), { recursive: true });
       fs7.writeFileSync(p, JSON.stringify(merged, null, 2));
     } catch {}
   }
@@ -203624,14 +204457,14 @@ function setContributionConfig2(updates) {
       existing = JSON.parse(content);
   } catch {}
   const merged = { ...existing, ...next2 };
-  fs7.mkdirSync(path23.dirname(p), { recursive: true });
+  fs7.mkdirSync(path24.dirname(p), { recursive: true });
   fs7.writeFileSync(p, JSON.stringify(merged, null, 2));
   cached4 = next2;
 }
 
 // .tmp-runtime-src/settings.ts
 init_domain();
-import { existsSync as existsSync49, mkdirSync as mkdirSync30, readFileSync as readFileSync36, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync50, mkdirSync as mkdirSync31, readFileSync as readFileSync37, writeFileSync as writeFileSync27 } from "node:fs";
 import { join as join56 } from "node:path";
 import { homedir as homedir42 } from "node:os";
 function sanitizeProfileName6(value) {
@@ -203649,8 +204482,8 @@ function getUnbrowseConfigPath2() {
 function loadRawConfig2() {
   try {
     const configPath4 = getUnbrowseConfigPath2();
-    if (existsSync49(configPath4)) {
-      const parsed = JSON.parse(readFileSync36(configPath4, "utf-8"));
+    if (existsSync50(configPath4)) {
+      const parsed = JSON.parse(readFileSync37(configPath4, "utf-8"));
       if (parsed && typeof parsed === "object")
         return parsed;
     }
@@ -203658,10 +204491,10 @@ function loadRawConfig2() {
   return {};
 }
 function saveRawConfig2(config) {
-  const configDir = getConfigDir8();
-  if (!existsSync49(configDir))
-    mkdirSync30(configDir, { recursive: true });
-  writeFileSync26(getUnbrowseConfigPath2(), JSON.stringify(config, null, 2), { mode: 384 });
+  const configDir2 = getConfigDir8();
+  if (!existsSync50(configDir2))
+    mkdirSync31(configDir2, { recursive: true });
+  writeFileSync27(getUnbrowseConfigPath2(), JSON.stringify(config, null, 2), { mode: 384 });
 }
 function normalizeDomainRule2(value) {
   let normalized = value.trim().toLowerCase();
@@ -204050,7 +204883,7 @@ async function _spawnDrainWorker() {
   if (slot === null)
     return;
   try {
-    const child = spawn11(process.execPath, [entry, "__drain-queue"], {
+    const child = spawn12(process.execPath, [entry, "__drain-queue"], {
       detached: true,
       stdio: "ignore"
     });
@@ -204176,8 +205009,8 @@ function parseArgs(argv) {
   }
   return { command: command2, args: positional, flags, params };
 }
-async function api4(method, path28, body, opts) {
-  let url = path28;
+async function api4(method, path29, body, opts) {
+  let url = path29;
   let payload = body;
   if (method === "GET" && body && typeof body === "object") {
     const params = new URLSearchParams;
@@ -204289,8 +205122,8 @@ async function ensureKuriReachable(kuriBase) {
   };
   if (await probeOnce())
     return;
-  const { spawn: spawn12 } = await import("child_process");
-  const { existsSync: existsSync60, openSync: openSync3 } = await import("fs");
+  const { spawn: spawn13 } = await import("child_process");
+  const { existsSync: existsSync61, openSync: openSync3 } = await import("fs");
   const { join: join69, dirname: dirname14 } = await import("path");
   const { fileURLToPath: fileURLToPath8 } = await import("url");
   const moduleDir = dirname14(fileURLToPath8(import.meta.url));
@@ -204316,7 +205149,7 @@ async function ensureKuriReachable(kuriBase) {
     kuriTarget ? join69(moduleDir, "../packages/skill/vendor/kuri", kuriTarget, kuriBinName) : undefined,
     "/opt/homebrew/bin/kuri",
     "/usr/local/bin/kuri"
-  ].filter((p) => !!p && existsSync60(p));
+  ].filter((p) => !!p && existsSync61(p));
   if (candidates.length === 0) {
     die(`Kuri unreachable at ${kuriBase} and no kuri binary found in standard paths. Set UNBROWSE_KURI_BIN, or run: submodules/kuri/zig-out/bin/kuri`);
   }
@@ -204331,7 +205164,7 @@ async function ensureKuriReachable(kuriBase) {
   })();
   info(`auto-spawning kuri from ${kuriBin} (port ${expectedPort}, logs: /tmp/kuri.log)`);
   const logFd = openSync3("/tmp/kuri.log", "a");
-  const child = spawn12(kuriBin, [], {
+  const child = spawn13(kuriBin, [], {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: { ...process.env, PORT: expectedPort, HOST: "127.0.0.1" }
@@ -204377,7 +205210,7 @@ function openUrl(url) {
     return;
   try {
     const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-    spawn11(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+    spawn12(cmd, [url], { detached: true, stdio: "ignore" }).unref();
   } catch {}
 }
 function resolveResultError(result) {
@@ -204639,6 +205472,9 @@ function slimTrace(obj) {
     out.source = obj.source;
   if (obj.skill)
     out.skill = obj.skill;
+  if (Array.isArray(obj.cross_skill_producers) && obj.cross_skill_producers.length) {
+    out.cross_skill_producers = obj.cross_skill_producers;
+  }
   return out;
 }
 function formatSavedDuration(ms) {
@@ -205438,8 +206274,8 @@ async function cmdRun(args, flags) {
     throw error;
   }
 }
-function drillPath(data2, path28) {
-  const segments = path28.split(/\./).flatMap((s) => {
+function drillPath(data2, path29) {
+  const segments = path29.split(/\./).flatMap((s) => {
     const m = s.match(/^(.+)\[\]$/);
     return m ? [m[1], "[]"] : [s];
   });
@@ -205466,9 +206302,9 @@ function drillPath(data2, path28) {
   }
   return values;
 }
-function resolveDotPath(obj, path28) {
+function resolveDotPath(obj, path29) {
   let cur = obj;
-  for (const key2 of path28.split(".")) {
+  for (const key2 of path29.split(".")) {
     if (cur == null || typeof cur !== "object")
       return;
     cur = cur[key2];
@@ -205485,8 +206321,8 @@ function applyExtract(items, extractSpec) {
   return items.map((item) => {
     const row = {};
     let hasValue = false;
-    for (const { alias, path: path28 } of fields) {
-      const val2 = resolveDotPath(item, path28);
+    for (const { alias, path: path29 } of fields) {
+      const val2 = resolveDotPath(item, path29);
       row[alias] = val2 ?? null;
       if (val2 != null)
         hasValue = true;
@@ -205515,7 +206351,18 @@ function schemaOf(value, depth = 4) {
 }
 var SYNTHETIC_SKILL_IDS = new Set(["exa-web-search"]);
 async function cmdExecute(flags) {
-  const skillId = flags.skill ?? flags["skill-id"];
+  const explicitMethod = typeof flags.method === "string" ? flags.method.toUpperCase() : undefined;
+  const intentText = typeof (flags.intent ?? flags.task) === "string" ? String(flags.intent ?? flags.task) : "";
+  const hasBody = !!flags.body || typeof flags.params === "string" && /["']body["']\s*:/.test(flags.params);
+  const effectiveMethod = inferWriteMethod(explicitMethod, intentText, hasBody);
+  const writeMethod = ["POST", "PUT", "PATCH", "DELETE"].includes(effectiveMethod ?? "");
+  if (writeMethod)
+    flags.method = effectiveMethod;
+  let skillId = flags.skill ?? flags["skill-id"];
+  if (!skillId && typeof flags.url === "string" && writeMethod) {
+    const idHash = createHash45("sha256").update(`${effectiveMethod} ${String(flags.url)}`).digest("hex").slice(0, 40);
+    skillId = `adhoc-write-${idHash}`;
+  }
   if (!skillId)
     die("--skill is required. List skills: unbrowse skills. Or run unbrowse resolve --intent '...' first to get a skill_id.");
   if (SYNTHETIC_SKILL_IDS.has(skillId)) {
@@ -205554,6 +206401,13 @@ async function cmdExecute(flags) {
     if (flags.params) {
       body.params = { ...body.params, ...JSON.parse(flags.params) };
     }
+    if (flags.body) {
+      try {
+        body.params.body = JSON.parse(flags.body);
+      } catch {
+        body.params.body = flags.body;
+      }
+    }
     const cliKv = flags._params;
     if (cliKv && Object.keys(cliKv).length > 0) {
       body.params = { ...body.params, ...cliKv };
@@ -205562,6 +206416,10 @@ async function cmdExecute(flags) {
       body.context_url = flags.url;
       body.params.url = flags.url;
     }
+    if (typeof flags.method === "string")
+      body.method = flags.method.toUpperCase();
+    if (typeof flags.session === "string")
+      body.session_id = flags.session;
     if (flags.intent ?? flags.task)
       body.intent = flags.intent ?? flags.task;
     if (flags["dry-run"])
@@ -205898,9 +206756,9 @@ async function cmdSkillPackage(args, flags) {
   const { renderSkillMd: renderSkillMd3, validateSkillPackage: validateSkillPackage3, forbiddenPublicTerms: forbiddenPublicTerms3 } = await Promise.resolve().then(() => (init_skillmd2(), exports_skillmd2));
   const { sanitizeDomain: sanitizeDomain5 } = await Promise.resolve().then(() => (init_domain_notes2(), exports_domain_notes));
   const fs9 = __require("fs");
-  const path28 = __require("path");
+  const path29 = __require("path");
   const domain = sanitizeDomain5(String(skill.domain ?? id));
-  const outDir = flags.out || path28.join(process.cwd(), `unbrowse-ai-${domain}`);
+  const outDir = flags.out || path29.join(process.cwd(), `unbrowse-ai-${domain}`);
   if (flags.expose)
     skill.exposed = true;
   const md = renderSkillMd3(skill);
@@ -205921,8 +206779,8 @@ Credentials are never embedded \u2014 they are placeholders filled at call time
   if (readmeLeaks.length)
     die(`invalid README for ${domain}: forbidden public term(s) ${readmeLeaks.map((t) => `/${t}/`).join(", ")}`);
   fs9.mkdirSync(outDir, { recursive: true });
-  fs9.writeFileSync(path28.join(outDir, "SKILL.md"), md);
-  fs9.writeFileSync(path28.join(outDir, "README.md"), readme);
+  fs9.writeFileSync(path29.join(outDir, "SKILL.md"), md);
+  fs9.writeFileSync(path29.join(outDir, "README.md"), readme);
   output2({ ok: true, domain, out: outDir, files: ["SKILL.md", "README.md"], install: `npx skills add unbrowse-ai/${domain}` }, !!flags.pretty);
 }
 async function cmdCleanupStale(flags) {
@@ -206067,10 +206925,10 @@ async function cmdSetup(flags) {
   }
   const hasGcloud = (() => {
     try {
-      const { existsSync: existsSync60 } = __require("fs");
+      const { existsSync: existsSync61 } = __require("fs");
       const { homedir: homedir52 } = __require("os");
       const { join: join69 } = __require("path");
-      return existsSync60(join69(homedir52(), ".config", "gcloud", "application_default_credentials.json"));
+      return existsSync61(join69(homedir52(), ".config", "gcloud", "application_default_credentials.json"));
     } catch {
       return false;
     }
@@ -206402,10 +207260,10 @@ async function cmdNote(flags, args) {
   if (sub === "list") {
     const { homedir: homedir52 } = await import("os");
     const { join: join69 } = await import("path");
-    const { readdirSync: readdirSync17, existsSync: existsSync60 } = await import("fs");
+    const { readdirSync: readdirSync17, existsSync: existsSync61 } = await import("fs");
     const profile = process.env.UNBROWSE_PROFILE ?? "";
     const dir = process.env.UNBROWSE_DOMAIN_NOTES_DIR ?? (profile ? join69(homedir52(), ".unbrowse", "profiles", profile, "domain-notes") : join69(homedir52(), ".unbrowse", "domain-notes"));
-    if (!existsSync60(dir)) {
+    if (!existsSync61(dir)) {
       output2({ notes: [], dir }, !!flags.pretty);
       return;
     }
@@ -207246,7 +208104,13 @@ async function cmdUpgrade(flags) {
       return;
     }
     info(`Update available: ${result.installed} -> ${result.latest}`);
-    info(`Run: ${result.command}`);
+    const { maybeAutoUpdate: maybeAutoUpdate2 } = await Promise.resolve().then(() => (init_update_hints(), exports_update_hints));
+    const applied = await maybeAutoUpdate2(import.meta.url);
+    if (applied.applied) {
+      info(`Auto-updating in the background: ${applied.from} -> ${applied.to} (takes effect next run).`);
+    } else {
+      info(`Run: ${result.command}`);
+    }
     if (!hintOnly) {
       info("Tip: `unbrowse setup` now installs session-start update hints for Codex and Claude when those hosts are present.");
     }
@@ -207259,7 +208123,7 @@ async function cmdUpgrade(flags) {
 async function cmdMcp(flags) {
   const entrypoint = resolveSiblingEntrypoint2(import.meta.url, "mcp");
   const childArgs = isBundledVirtualEntrypoint(entrypoint) ? ["mcp-serve", ...flags["no-auto-start"] ? ["--no-auto-start"] : []] : [...runtimeArgsForEntrypoint2(import.meta.url, entrypoint), ...flags["no-auto-start"] ? ["--no-auto-start"] : []];
-  const child = spawn11(process.execPath, childArgs, {
+  const child = spawn12(process.execPath, childArgs, {
     cwd: process.cwd(),
     stdio: "inherit",
     env: {
@@ -207283,7 +208147,7 @@ async function cmdMcp(flags) {
 async function cmdContractBridge(_flags) {
   const entrypoint = resolveSiblingEntrypoint2(import.meta.url, "contract-bridge");
   const childArgs = isBundledVirtualEntrypoint(entrypoint) ? ["contract-bridge-serve"] : [...runtimeArgsForEntrypoint2(import.meta.url, entrypoint)];
-  const child = spawn11(process.execPath, childArgs, {
+  const child = spawn12(process.execPath, childArgs, {
     cwd: process.cwd(),
     stdio: "inherit",
     env: { ...process.env, CONTRACT_BRIDGE_MODE: "1" }
@@ -207611,7 +208475,7 @@ async function cmdRegister(flags) {
         info(`Opening browser: ${url}`);
         try {
           const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
-          spawn11(cmd, [url], { detached: true, stdio: "ignore" }).unref();
+          spawn12(cmd, [url], { detached: true, stdio: "ignore" }).unref();
         } catch {}
       }
     });
@@ -207657,7 +208521,7 @@ async function cmdRegister(flags) {
 async function cmdSessionsScan(flags) {
   const domain = flags.domain;
   const { scanAllBrowserSessions: scanAllBrowserSessions3, findBestBrowserSession: findBestBrowserSession3 } = await Promise.resolve().then(() => (init_browser_cookies2(), exports_browser_cookies2));
-  const { execFileSync: execFileSync9, existsSync: existsSync60 } = await import("./cli-imports.js").catch(() => ({ execFileSync: __require("child_process").execFileSync, existsSync: __require("fs").existsSync }));
+  const { execFileSync: execFileSync9, existsSync: existsSync61 } = await import("./cli-imports.js").catch(() => ({ execFileSync: __require("child_process").execFileSync, existsSync: __require("fs").existsSync }));
   if (domain) {
     const sessions = scanAllBrowserSessions3(domain);
     if (sessions.length === 0) {
@@ -207760,7 +208624,7 @@ async function cmdCorpusTest(flags) {
       break;
     if (attempt < retries - 1) {
       try {
-        spawn11("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
+        spawn12("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
       } catch {}
       await new Promise((r) => setTimeout(r, 2000));
     }
@@ -207806,7 +208670,7 @@ async function cmdCorpusRun(flags) {
     const caseId = c.id || new URL(c.url).hostname;
     info(`corpus-run [${caseId}] starting`);
     try {
-      spawn11("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
+      spawn12("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
     } catch {}
     await new Promise((r) => setTimeout(r, 1500));
     let best = { capture: "error", endpoints: 0, requests: 0 };
@@ -207820,7 +208684,7 @@ async function cmdCorpusRun(flags) {
         break;
       if (attempt < retries - 1) {
         try {
-          spawn11("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
+          spawn12("pkill", ["-9", "-f", "kuri|chrome-profile"], { stdio: "ignore" });
         } catch {}
         await new Promise((r) => setTimeout(r, 2000));
       }
@@ -207923,8 +208787,8 @@ async function cmdConnectChrome() {
 async function cmdContract(args, flags) {
   const sub = args[0];
   const baseUrl = ((typeof flags["url"] === "string" ? flags["url"] : undefined) ?? process.env.UNBROWSE_API_URL ?? "https://beta-api.unbrowse.ai").replace(/\/+$/, "");
-  async function call2(path28, opts = {}) {
-    const url = new URL(`${baseUrl}${path28}`);
+  async function call2(path29, opts = {}) {
+    const url = new URL(`${baseUrl}${path29}`);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query))
         url.searchParams.set(k, v);
@@ -208041,8 +208905,8 @@ async function cmdContribute(args, flags) {
   const [method, ...rest] = endpoint.split(" ");
   const target = rest.join(" ");
   const [host, ...pathParts] = target.split("/");
-  const path28 = "/" + pathParts.join("/");
-  const shape = shapePointer({ method, host, path: path28, paramKeys });
+  const path29 = "/" + pathParts.join("/");
+  const shape = shapePointer({ method, host, path: path29, paramKeys });
   const delta = await signDelta({ op: "add", endpoint, shape, freshness: Date.now() });
   const validity = proveDeltaValidity(delta, count, bound);
   const attestation = await attestExecution({ origin, method, shapeHash: shape });
@@ -208539,6 +209403,7 @@ if (isMainModule(import.meta.url)) {
   });
 }
 export {
+  slimTrace,
   parseCmdRunArgs,
   parseArgs,
   fetchOutcome,