@quanta-intellect/vessel-browser 0.1.31 → 0.1.33

package/README.md

@@ -11,7 +11,7 @@
 </div>
 
 
-Open source chromium-based browser for persistent web agents on Linux (Mac/Windows support to come).
+Open source chromium-based browser for persistent web agents. Linux is the most mature install target today, and macOS release packaging is available from source.
 
 Vessel gives external agent harnesses a real browser with durable state, MCP control, and a human-visible supervisory UI. It is built for long-running workflows where the agent drives and the human audits, intervenes, and redirects when needed.
 
@@ -200,12 +200,25 @@ npm run dist:dir
 
 # Package a Linux AppImage
 npm run dist
+
+# Package an unpacked macOS app bundle (run on macOS)
+npm run dist:mac:dir
+
+# Package macOS DMG + ZIP artifacts (run on macOS)
+npm run dist:mac
+
+# Package signed macOS DMG + ZIP artifacts (run on macOS with signing set up)
+npm run dist:mac:signed
 ```
 
 Notes:
 
 - `npm run dev` still launches the stock Electron binary, so Linux may continue showing the default Electron gear icon in development
 - packaged builds created with `npm run dist` / `npm run dist:dir` use the Vessel app icon
+- `npm run build:icon:mac` regenerates `resources/vessel-icon.icns` from `resources/vessel-icon.png` for macOS packaging
+- `npm run dist:mac` and `npm run dist:mac:dir` intentionally disable auto-signing so local packaging works on any Mac without keychain setup
+- `npm run dist:mac:signed` and `npm run dist:mac:dir:signed` use normal `electron-builder` signing discovery; if your login keychain has duplicate Apple certs, clean those up or use a dedicated keychain before running the signed path
+- signed builds are still not notarized by this repo out of the box, so Gatekeeper warnings remain until notarization is added for release publishing
 - the tracked smoke test runs typecheck, build, the MCP stdio proxy regression check, and the Electron navigation regression harness
 - for headless CI, run the smoke test under `xvfb-run -a npm run smoke:test`
 

package/out/main/index.js

@@ -11509,6 +11509,325 @@ async function submitForm$1(wc, args) {
 async function clickElementBySelector(wc, selector) {
   return clickResolvedSelector$1(wc, selector);
 }
+const HUGGING_FACE_HUB_HOSTS = /* @__PURE__ */ new Set(["huggingface.co", "www.huggingface.co"]);
+const HUGGING_FACE_MODEL_TASKS = [
+  {
+    value: "automatic-speech-recognition",
+    label: "automatic speech recognition",
+    phrases: ["automatic speech recognition", "speech recognition", "asr"]
+  },
+  {
+    value: "text-classification",
+    label: "text classification",
+    phrases: ["text classification", "classification"]
+  },
+  {
+    value: "token-classification",
+    label: "token classification",
+    phrases: ["token classification", "named entity recognition", "ner"]
+  },
+  {
+    value: "question-answering",
+    label: "question answering",
+    phrases: ["question answering", "qa"]
+  },
+  {
+    value: "sentence-similarity",
+    label: "sentence similarity",
+    phrases: ["sentence similarity", "semantic similarity"]
+  },
+  {
+    value: "feature-extraction",
+    label: "feature extraction",
+    phrases: ["feature extraction", "embeddings", "embedding"]
+  },
+  {
+    value: "image-classification",
+    label: "image classification",
+    phrases: ["image classification"]
+  },
+  {
+    value: "object-detection",
+    label: "object detection",
+    phrases: ["object detection"]
+  },
+  {
+    value: "image-to-text",
+    label: "image to text",
+    phrases: ["image to text", "image-to-text", "ocr"]
+  },
+  {
+    value: "text-to-image",
+    label: "text to image",
+    phrases: ["text to image", "text-to-image"]
+  },
+  {
+    value: "text-to-speech",
+    label: "text to speech",
+    phrases: ["text to speech", "text-to-speech", "tts"]
+  },
+  {
+    value: "text-generation",
+    label: "text generation",
+    phrases: [
+      "text generation",
+      "text-generation",
+      "llm",
+      "chat model",
+      "chat models",
+      "instruct model",
+      "instruct models"
+    ]
+  },
+  {
+    value: "text2text-generation",
+    label: "text2text generation",
+    phrases: [
+      "text2text generation",
+      "text-to-text generation",
+      "text to text generation"
+    ]
+  },
+  {
+    value: "summarization",
+    label: "summarization",
+    phrases: ["summarization", "summarize", "summarizer"]
+  },
+  {
+    value: "translation",
+    label: "translation",
+    phrases: ["translation", "translate", "translator"]
+  }
+];
+const HUGGING_FACE_MODEL_LIBRARIES = [
+  { value: "sentence-transformers", label: "sentence-transformers", phrases: ["sentence-transformers"] },
+  { value: "transformers.js", label: "transformers.js", phrases: ["transformers.js"] },
+  { value: "transformers", label: "transformers", phrases: ["transformers"] },
+  { value: "diffusers", label: "diffusers", phrases: ["diffusers"] },
+  { value: "safetensors", label: "safetensors", phrases: ["safetensors"] },
+  { value: "pytorch", label: "pytorch", phrases: ["pytorch"] },
+  { value: "tf", label: "tensorflow", phrases: ["tensorflow", "tf"] },
+  { value: "jax", label: "jax", phrases: ["jax"] },
+  { value: "onnx", label: "onnx", phrases: ["onnx"] },
+  { value: "gguf", label: "gguf", phrases: ["gguf"] },
+  { value: "mlx", label: "mlx", phrases: ["mlx"] }
+];
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripSearchPhrase(query, phrase) {
+  return query.replace(
+    new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "gi"),
+    " "
+  );
+}
+function collapseSearchTerms(query) {
+  return query.replace(/\b(on|in|for|with|without|from|by|to|of|the|a|an|and|or)\b/gi, " ").replace(/\b(find|show|search|browse|look(?:ing)?(?:\s+for)?|need|want)\b/gi, " ").replace(/\bhugging\s*face\b/gi, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeSearchQuery(query) {
+  return query.replace(/\s+/g, " ").trim();
+}
+function extractFirstMatchingFilter(query, filters) {
+  for (const filter of filters) {
+    for (const phrase of filter.phrases) {
+      const pattern = new RegExp(
+        `(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`,
+        "i"
+      );
+      if (!pattern.test(query)) continue;
+      return {
+        match: { value: filter.value, label: filter.label },
+        remainingQuery: stripSearchPhrase(query, phrase)
+      };
+    }
+  }
+  return { match: null, remainingQuery: query };
+}
+function mapHuggingFaceParameterBucket(query) {
+  const match = query.match(/\b(\d+(?:\.\d+)?)\s*(b|bn|billion|t|tn|trillion)\b/i);
+  if (!match) {
+    return { value: null, label: null, remainingQuery: query };
+  }
+  const amount = Number(match[1]);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { value: null, label: null, remainingQuery: query };
+  }
+  const unit = match[2].toLowerCase();
+  const billions = unit === "t" || unit === "tn" || unit === "trillion" ? amount * 1e3 : amount;
+  let value;
+  if (billions < 1) value = "n<1B";
+  else if (billions < 3) value = "1B<n<3B";
+  else if (billions < 6) value = "3B<n<6B";
+  else if (billions < 9) value = "6B<n<9B";
+  else if (billions < 12) value = "9B<n<12B";
+  else if (billions < 24) value = "12B<n<24B";
+  else if (billions < 32) value = "24B<n<32B";
+  else if (billions < 64) value = "32B<n<64B";
+  else if (billions < 128) value = "64B<n<128B";
+  else if (billions < 256) value = "128B<n<256B";
+  else if (billions < 500) value = "256B<n<500B";
+  else if (billions < 1e3) value = "500B<n<1T";
+  else value = "n>1T";
+  return {
+    value,
+    label: `${amount}${unit.startsWith("t") ? "T" : "B"} size bucket`,
+    remainingQuery: query.replace(match[0], " ")
+  };
+}
+function chooseHuggingFaceSection(url, query) {
+  const pathname = url.pathname.toLowerCase();
+  const normalized = query.toLowerCase();
+  const mentionsDatasets = /\b(dataset|datasets|corpus|benchmark|benchmarks)\b/.test(
+    normalized
+  );
+  const mentionsSpaces = /\b(space|spaces|app|apps|demo|demos|gradio|streamlit)\b/.test(
+    normalized
+  );
+  const mentionsModels = /\b(model|models|checkpoint|checkpoints|lora|loras|weights)\b/.test(
+    normalized
+  );
+  if (mentionsDatasets && !mentionsModels && !mentionsSpaces) return "datasets";
+  if (mentionsSpaces && !mentionsModels && !mentionsDatasets) return "spaces";
+  if (mentionsModels && !mentionsDatasets && !mentionsSpaces) return "models";
+  if (pathname.startsWith("/models")) return "models";
+  if (pathname.startsWith("/datasets")) return "datasets";
+  if (pathname.startsWith("/spaces")) return "spaces";
+  if (HUGGING_FACE_MODEL_TASKS.some(
+    (entry) => entry.phrases.some(
+      (phrase) => new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "i").test(
+        normalized
+      )
+    )
+  ) || HUGGING_FACE_MODEL_LIBRARIES.some(
+    (entry) => entry.phrases.some(
+      (phrase) => new RegExp(`(^|[^\\w])${escapeRegex(phrase)}(?=[^\\w]|$)`, "i").test(
+        normalized
+      )
+    )
+  ) || /\b\d+(?:\.\d+)?\s*(b|bn|billion|t|tn|trillion)\b/i.test(normalized)) {
+    return "models";
+  }
+  return null;
+}
+function buildHuggingFaceSearchShortcut(currentUrl, rawQuery) {
+  let url;
+  try {
+    url = new URL(currentUrl);
+  } catch {
+    return null;
+  }
+  const hostname = url.hostname.toLowerCase();
+  if (!HUGGING_FACE_HUB_HOSTS.has(hostname)) {
+    return null;
+  }
+  const query = rawQuery.trim();
+  if (!query) return null;
+  const section = chooseHuggingFaceSection(url, query);
+  if (!section) return null;
+  let remainingQuery = query;
+  const target = new URL(`https://huggingface.co/${section}`);
+  const appliedFilters = [];
+  if (section === "models") {
+    const taskResult = extractFirstMatchingFilter(
+      remainingQuery,
+      HUGGING_FACE_MODEL_TASKS
+    );
+    remainingQuery = taskResult.remainingQuery;
+    if (taskResult.match) {
+      target.searchParams.append("pipeline_tag", taskResult.match.value);
+      appliedFilters.push(`task: ${taskResult.match.label}`);
+    }
+    const libraryResult = extractFirstMatchingFilter(
+      remainingQuery,
+      HUGGING_FACE_MODEL_LIBRARIES
+    );
+    remainingQuery = libraryResult.remainingQuery;
+    if (libraryResult.match) {
+      target.searchParams.append("library", libraryResult.match.value);
+      appliedFilters.push(`library: ${libraryResult.match.label}`);
+    }
+    const parameterResult = mapHuggingFaceParameterBucket(remainingQuery);
+    remainingQuery = parameterResult.remainingQuery;
+    if (parameterResult.value && parameterResult.label) {
+      target.searchParams.append("num_parameters", parameterResult.value);
+      appliedFilters.push(parameterResult.label);
+    }
+  }
+  remainingQuery = collapseSearchTerms(
+    remainingQuery.replace(/\bmodels?\b/gi, " ").replace(/\bdatasets?\b/gi, " ").replace(/\bspaces?\b/gi, " ").replace(/\bapps?\b/gi, " ")
+  );
+  if (remainingQuery) {
+    target.searchParams.set("search", remainingQuery);
+  }
+  if (!remainingQuery && appliedFilters.length === 0) {
+    return null;
+  }
+  if (section === "spaces" && remainingQuery) {
+    target.searchParams.set("includeNonRunning", "true");
+  }
+  return {
+    url: target.toString(),
+    source: "Hugging Face",
+    section,
+    appliedFilters
+  };
+}
+const COMMON_SEARCH_QUERY_PARAMS = [
+  "search",
+  "q",
+  "query",
+  "keyword",
+  "keywords",
+  "term",
+  "text"
+];
+const COMMON_PAGINATION_PARAMS = [
+  "p",
+  "page",
+  "offset",
+  "start",
+  "cursor",
+  "skip"
+];
+function looksLikeSearchResultsPath(pathname) {
+  return /\/(search|results|browse|discover|find)(\/|$)/i.test(pathname);
+}
+function buildCommonSearchUrlShortcut(currentUrl, rawQuery) {
+  let url;
+  try {
+    url = new URL(currentUrl);
+  } catch {
+    return null;
+  }
+  if (!/^https?:$/i.test(url.protocol)) {
+    return null;
+  }
+  const query = normalizeSearchQuery(rawQuery);
+  if (!query) return null;
+  const existingParam = COMMON_SEARCH_QUERY_PARAMS.find(
+    (param) => url.searchParams.has(param)
+  );
+  if (!existingParam && !looksLikeSearchResultsPath(url.pathname)) {
+    return null;
+  }
+  const target = new URL(url.toString());
+  const searchParam = existingParam ?? "q";
+  target.searchParams.set(searchParam, query);
+  for (const param of COMMON_PAGINATION_PARAMS) {
+    target.searchParams.delete(param);
+  }
+  if (target.toString() === url.toString()) {
+    return null;
+  }
+  return {
+    url: target.toString(),
+    source: "page URL",
+    appliedFilters: existingParam ? [`updated ${existingParam} query`] : []
+  };
+}
+function buildSearchShortcut(currentUrl, rawQuery) {
+  return buildHuggingFaceSearchShortcut(currentUrl, rawQuery) ?? buildCommonSearchUrlShortcut(currentUrl, rawQuery);
+}
 async function locateSearchTarget(wc, explicitSelector) {
   if (explicitSelector) {
     return { selector: explicitSelector, submitSelector: null };
@@ -11775,6 +12094,19 @@ async function searchPage(wc, args) {
   if (buttonLikePatterns.some((p) => queryLower.includes(p))) {
     return `Error: "${query}" looks like a button label, not a search query. Use the click tool to interact with this element instead.`;
   }
+  if (typeof args.selector !== "string") {
+    const shortcut = buildSearchShortcut(wc.getURL(), query);
+    if (shortcut) {
+      const beforeUrl2 = wc.getURL();
+      assertSafeURL(shortcut.url);
+      wc.loadURL(shortcut.url);
+      await waitForPotentialNavigation$1(wc, beforeUrl2, 4e3);
+      const afterUrl2 = wc.getURL();
+      const applied = shortcut.appliedFilters.length > 0 ? ` (${shortcut.appliedFilters.join(", ")})` : "";
+      const destination = shortcut.section ? ` ${shortcut.section}` : "";
+      return `Searched "${query}" via ${shortcut.source}${destination} shortcut${applied} → ${afterUrl2}`;
+    }
+  }
   const searchInfo = await locateSearchTarget(
     wc,
     typeof args.selector === "string" ? args.selector : void 0
@@ -18755,11 +19087,21 @@ function stopMcpServer() {
     });
   });
 }
+const VALID_KIT_CATEGORIES = /* @__PURE__ */ new Set([
+  "research",
+  "shopping",
+  "productivity",
+  "forms"
+]);
 const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set([
   "research-collect",
   "price-scout",
   "form-filler"
 ]);
+const KIT_ID_UNSAFE_CHAR_PATTERN = /[\/\\\0]/;
+function isSafeAutomationKitId(id) {
+  return id.length > 0 && !KIT_ID_UNSAFE_CHAR_PATTERN.test(id);
+}
 function getUserKitsDir() {
   return path$1.join(electron.app.getPath("userData"), "kits");
 }
@@ -18769,10 +19111,16 @@ function ensureKitsDir() {
     fs$1.mkdirSync(dir, { recursive: true });
   }
 }
+function getKitFilePath(id) {
+  if (!isSafeAutomationKitId(id)) return null;
+  const kitsDir = path$1.resolve(getUserKitsDir());
+  const target = path$1.resolve(kitsDir, `${id}.kit.json`);
+  return target.startsWith(`${kitsDir}${path$1.sep}`) ? target : null;
+}
 function isValidKit(value) {
   if (!value || typeof value !== "object") return false;
   const k = value;
-  return typeof k.id === "string" && k.id.length > 0 && typeof k.name === "string" && k.name.length > 0 && typeof k.description === "string" && typeof k.icon === "string" && typeof k.promptTemplate === "string" && k.promptTemplate.length > 0 && Array.isArray(k.inputs);
+  return typeof k.id === "string" && isSafeAutomationKitId(k.id) && typeof k.name === "string" && k.name.length > 0 && typeof k.description === "string" && typeof k.category === "string" && VALID_KIT_CATEGORIES.has(k.category) && typeof k.icon === "string" && typeof k.promptTemplate === "string" && k.promptTemplate.length > 0 && Array.isArray(k.inputs);
 }
 function getInstalledKits() {
   ensureKitsDir();
@@ -18833,7 +19181,10 @@ async function installKitFromFile() {
     };
   }
   ensureKitsDir();
-  const dest = path$1.join(getUserKitsDir(), `${parsed.id}.kit.json`);
+  const dest = getKitFilePath(parsed.id);
+  if (!dest) {
+    return { ok: false, error: "Kit id contains unsupported characters." };
+  }
   try {
     fs$1.writeFileSync(dest, JSON.stringify(parsed, null, 2), "utf-8");
   } catch {
@@ -18841,12 +19192,21 @@ async function installKitFromFile() {
   }
   return { ok: true, kit: parsed };
 }
-function uninstallKit(id) {
+function uninstallKit(id, scheduledKitIds) {
   if (BUNDLED_KIT_IDS.has(id)) {
     return { ok: false, error: "Built-in kits cannot be removed." };
   }
+  if (scheduledKitIds?.has(id)) {
+    return {
+      ok: false,
+      error: "This kit has active scheduled jobs. Delete or reassign them first."
+    };
+  }
   ensureKitsDir();
-  const target = path$1.join(getUserKitsDir(), `${id}.kit.json`);
+  const target = getKitFilePath(id);
+  if (!target) {
+    return { ok: false, error: "Kit id contains unsupported characters." };
+  }
   if (!fs$1.existsSync(target)) {
     return { ok: false, error: "Kit not found." };
   }
@@ -18860,6 +19220,9 @@ function uninstallKit(id) {
 let jobs = [];
 let removeIdleListener = null;
 let broadcastFn = null;
+function getScheduledKitIds() {
+  return new Set(jobs.filter((j) => j.enabled).map((j) => j.kitId));
+}
 function getJobsPath() {
   return path$1.join(electron.app.getPath("userData"), "scheduled-jobs.json");
 }
@@ -19029,29 +19392,40 @@ async function fireJob(job, windowState, runtime2) {
 }
 function tick(windowState, runtime2) {
   if (isAIStreamActive()) return;
-  const now = /* @__PURE__ */ new Date();
-  let changed = false;
-  for (const job of jobs) {
-    if (!job.enabled) continue;
-    if (now < new Date(job.nextRunAt)) continue;
-    if (!tryBeginAIStream("scheduled")) break;
-    void fireJob(job, windowState, runtime2).finally(() => {
+  const dueIds = jobs.filter((job) => job.enabled && /* @__PURE__ */ new Date() >= new Date(job.nextRunAt)).map((job) => job.id);
+  if (dueIds.length === 0) return;
+  if (!tryBeginAIStream("scheduled")) return;
+  let idx = 0;
+  const fireNext = () => {
+    if (idx >= dueIds.length) {
       endAIStream("scheduled");
       queueMicrotask(() => tick(windowState, runtime2));
-    });
-    job.lastRunAt = now.toISOString();
+      return;
+    }
+    const jobId = dueIds[idx++];
+    const job = jobs.find((candidate) => candidate.id === jobId);
+    if (!job || !job.enabled) {
+      fireNext();
+      return;
+    }
+    const firedAt = /* @__PURE__ */ new Date();
+    if (firedAt < new Date(job.nextRunAt)) {
+      fireNext();
+      return;
+    }
+    job.lastRunAt = firedAt.toISOString();
     if (job.schedule.type === "once") {
       job.enabled = false;
     } else {
-      job.nextRunAt = computeNextRun(job.schedule, now).toISOString();
+      job.nextRunAt = computeNextRun(job.schedule, firedAt).toISOString();
     }
-    changed = true;
-    break;
-  }
-  if (changed) {
     saveJobs();
     broadcastFn?.(Channels.SCHEDULE_JOBS_UPDATE, jobs);
-  }
+    void fireJob(job, windowState, runtime2).catch((err) => {
+      console.warn("[scheduler] Unexpected error firing job:", err);
+    }).finally(fireNext);
+  };
+  fireNext();
 }
 function registerScheduleHandlers(windowState, runtime2, sendToAll) {
   broadcastFn = sendToAll;
@@ -19314,7 +19688,7 @@ function registerIpcHandlers(windowState, runtime2) {
         Channels.AI_STREAM_CHUNK,
         "Chat provider not configured. Open Settings (Ctrl+,) to choose a provider."
       );
-      sendToRendererViews(Channels.AI_STREAM_END);
+      sendToRendererViews(Channels.AI_STREAM_END, "failed");
       return { accepted: true };
     }
     if (!tryBeginAIStream("manual")) {
@@ -19331,7 +19705,7 @@ function registerIpcHandlers(windowState, runtime2) {
           activeChatProvider,
           activeTab?.view.webContents,
           (chunk) => sendToRendererViews(Channels.AI_STREAM_CHUNK, chunk),
-          () => sendToRendererViews(Channels.AI_STREAM_END),
+          () => sendToRendererViews(Channels.AI_STREAM_END, "completed"),
           tabManager,
           runtime2,
           history
@@ -19340,7 +19714,7 @@ function registerIpcHandlers(windowState, runtime2) {
         const msg = err instanceof Error ? err.message : "Unknown error";
         sendToRendererViews(Channels.AI_STREAM_CHUNK, `
 [Error: ${msg}]`);
-        sendToRendererViews(Channels.AI_STREAM_END);
+        sendToRendererViews(Channels.AI_STREAM_END, "failed");
       } finally {
         activeChatProvider = null;
         endAIStream("manual");
@@ -19762,7 +20136,7 @@ function registerIpcHandlers(windowState, runtime2) {
   });
   electron.ipcMain.handle(Channels.AUTOMATION_UNINSTALL, (_event, id) => {
     assertString(id, "id");
-    return uninstallKit(id);
+    return uninstallKit(id, getScheduledKitIds());
   });
   registerScheduleHandlers(windowState, runtime2, sendToRendererViews);
 }

package/out/preload/index.js

@@ -137,7 +137,7 @@ const api = {
       return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_CHUNK, handler);
     },
     onStreamEnd: (cb) => {
-      const handler = () => cb();
+      const handler = (_, status = "completed") => cb(status);
       electron.ipcRenderer.on(Channels.AI_STREAM_END, handler);
       return () => electron.ipcRenderer.removeListener(Channels.AI_STREAM_END, handler);
     },

package/out/renderer/assets/{index-DVD9XuhC.js → index-BFdOm6Op.js}

@@ -2324,11 +2324,14 @@ const [hasFirstChunk, setHasFirstChunk] = createSignal(false);
 const [streamStartedAt, setStreamStartedAt] = createSignal(null);
 const [recentQueries, setRecentQueries] = createSignal([]);
 const [pendingQueries, setPendingQueries] = createSignal([]);
+const [pendingQueryActivities, setPendingQueryActivities] = createSignal([]);
 const [queueNotice, setQueueNotice] = createSignal(null);
 const [automationActivities, setAutomationActivities] = createSignal([]);
 let initialized$1 = false;
 let pendingDrainScheduled = false;
 let listenerCleanups = [];
+let pendingAutomationActivity = null;
+let activeAutomationActivityId = null;
 function trimMessages(next) {
   return next.length > MAX_MESSAGE_HISTORY ? next.slice(-MAX_MESSAGE_HISTORY) : next;
 }
@@ -2348,17 +2351,23 @@ async function dispatchQuery(prompt) {
   const result = await window.vessel.ai.query(prompt, buildHistory());
   return result.accepted;
 }
-async function dispatchQueuedPrompt(prompt) {
+async function dispatchQueuedPrompt(prompt, activity) {
+  pendingAutomationActivity = activity;
   const accepted = await dispatchQuery(prompt);
   if (!accepted) {
+    pendingAutomationActivity = null;
     const queued = enqueuePendingPrompt(pendingQueries(), prompt, { atFront: true });
     setPendingQueries(queued.queue);
     setQueueNotice(queued.notice);
+    if (queued.status === "queued") {
+      setPendingQueryActivities((prev) => [activity, ...prev]);
+    }
   }
 }
 function schedulePendingDrain() {
   if (pendingDrainScheduled || isStreaming()) return;
   if (pendingQueries().length === 0) {
+    setPendingQueryActivities([]);
     setQueueNotice(null);
     return;
   }
@@ -2367,10 +2376,12 @@ function schedulePendingDrain() {
     pendingDrainScheduled = false;
     if (isStreaming()) return;
     const next = dequeuePendingPrompt(pendingQueries());
+    const [nextActivity = null, ...remainingActivities] = pendingQueryActivities();
     setPendingQueries(next.queue);
+    setPendingQueryActivities(remainingActivities);
     setQueueNotice(next.notice);
     if (next.nextPrompt) {
-      void dispatchQueuedPrompt(next.nextPrompt);
+      void dispatchQueuedPrompt(next.nextPrompt, nextActivity);
     }
   });
 }
@@ -2386,14 +2397,35 @@ function init$1() {
     setIsStreaming(true);
     setHasFirstChunk(false);
     setStreamStartedAt(Date.now());
+    if (pendingAutomationActivity) {
+      const activity = pendingAutomationActivity;
+      activeAutomationActivityId = activity.id;
+      setAutomationActivities(
+        (prev) => startAutomationActivity(prev, {
+          id: activity.id,
+          source: "scheduled",
+          title: activity.title,
+          icon: activity.icon,
+          status: "running",
+          startedAt: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      pendingAutomationActivity = null;
+    }
   }));
   listenerCleanups.push(window.vessel.ai.onStreamChunk((chunk) => {
     if (!hasFirstChunk()) {
       setHasFirstChunk(true);
     }
     setStreamingText((prev) => prev + chunk);
+    if (activeAutomationActivityId) {
+      const activityId = activeAutomationActivityId;
+      setAutomationActivities(
+        (prev) => appendAutomationActivityChunk(prev, activityId, chunk)
+      );
+    }
   }));
-  listenerCleanups.push(window.vessel.ai.onStreamEnd(() => {
+  listenerCleanups.push(window.vessel.ai.onStreamEnd((status) => {
     const finalText = streamingText();
     if (finalText) {
       setMessages((prev) => {
@@ -2401,6 +2433,19 @@ function init$1() {
         return trimMessages(next);
       });
     }
+    if (activeAutomationActivityId) {
+      const activityId = activeAutomationActivityId;
+      setAutomationActivities(
+        (prev) => finishAutomationActivity(
+          prev,
+          activityId,
+          status,
+          (/* @__PURE__ */ new Date()).toISOString()
+        )
+      );
+      activeAutomationActivityId = null;
+    }
+    pendingAutomationActivity = null;
     setStreamingText("");
     setIsStreaming(false);
     setHasFirstChunk(false);
@@ -2426,6 +2471,32 @@ function init$1() {
 }
 function useAI() {
   init$1();
+  const query = async (prompt, activity = null) => {
+    recordRecentQuery(prompt);
+    if (isStreaming()) {
+      const queued = enqueuePendingPrompt(pendingQueries(), prompt);
+      setPendingQueries(queued.queue);
+      setQueueNotice(queued.notice);
+      if (queued.status === "queued") {
+        setPendingQueryActivities((prev) => [...prev, activity]);
+      }
+      return queued.status;
+    }
+    setQueueNotice(null);
+    pendingAutomationActivity = activity;
+    const accepted = await dispatchQuery(prompt);
+    if (!accepted) {
+      pendingAutomationActivity = null;
+      const queued = enqueuePendingPrompt(pendingQueries(), prompt, { atFront: true });
+      setPendingQueries(queued.queue);
+      setQueueNotice(queued.notice);
+      if (queued.status === "queued") {
+        setPendingQueryActivities((prev) => [activity, ...prev]);
+      }
+      return queued.status;
+    }
+    return "started";
+  };
   return {
     messages,
     streamingText,
@@ -2438,39 +2509,28 @@ function useAI() {
     pendingQueryCount: () => pendingQueries().length,
     pendingQueryLimit: MAX_PENDING_QUERIES,
     queueNotice,
-    query: async (prompt) => {
-      recordRecentQuery(prompt);
-      if (isStreaming()) {
-        const queued = enqueuePendingPrompt(pendingQueries(), prompt);
-        setPendingQueries(queued.queue);
-        setQueueNotice(queued.notice);
-        return queued.status;
-      }
-      setQueueNotice(null);
-      const accepted = await dispatchQuery(prompt);
-      if (!accepted) {
-        const queued = enqueuePendingPrompt(pendingQueries(), prompt, { atFront: true });
-        setPendingQueries(queued.queue);
-        setQueueNotice(queued.notice);
-        return queued.status;
-      }
-      return "started";
-    },
+    query,
+    runAutomationPrompt: async (prompt, activity) => query(prompt, activity),
     cancel: () => window.vessel.ai.cancel(),
     removePendingQuery: (index) => {
       const next = removePendingPrompt(pendingQueries(), index);
       setPendingQueries(next.queue);
+      setPendingQueryActivities(
+        (prev) => prev.filter((_, itemIndex) => itemIndex !== index)
+      );
       setQueueNotice(next.notice);
     },
     clearPendingQueries: () => {
       const next = clearPendingPromptQueue();
       setPendingQueries(next.queue);
+      setPendingQueryActivities([]);
       setQueueNotice(next.notice);
     },
     clearHistory: () => {
       setMessages([]);
       const next = clearPendingPromptQueue();
       setPendingQueries(next.queue);
+      setPendingQueryActivities([]);
       setQueueNotice(next.notice);
     }
   };
@@ -4440,6 +4500,11 @@ var Zap = (props) => createComponent(Icon_default, mergeProps(props, {
   name: "zap"
 }));
 var zap_default = Zap;
+const BUNDLED_KIT_IDS = /* @__PURE__ */ new Set([
+  "research-collect",
+  "price-scout",
+  "form-filler"
+]);
 const BUNDLED_KITS = [
   {
     id: "research-collect",
@@ -4571,6 +4636,13 @@ Steps:
   }
 ];
 function renderKitPrompt(kit, values) {
+  for (const input of kit.inputs) {
+    if (input.required && !values[input.key]?.trim()) {
+      console.warn(
+        `[automation-kits] Required field "${input.key}" is empty for kit "${kit.id}".`
+      );
+    }
+  }
   return kit.promptTemplate.replace(
     /\{\{(\w+)\}\}/g,
     (_, key) => values[key] ?? ""
@@ -4599,7 +4671,6 @@ const KitIcon = (props) => {
     }
   });
 };
-const BUNDLED_KIT_IDS = new Set(BUNDLED_KITS.map((k) => k.id));
 const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
 function formatScheduleLabel(job) {
   const {
@@ -4650,7 +4721,7 @@ function toLocalDateTimeInput(iso) {
 }
 const AutomationTab = (props) => {
   const {
-    query,
+    runAutomationPrompt,
     isStreaming: isStreaming2,
     automationActivities: automationActivities2
   } = useAI();
@@ -4739,9 +4810,15 @@ const AutomationTab = (props) => {
     const kit = selectedKit();
     if (!kit || !canRun()) return;
     const prompt = renderKitPrompt(kit, fieldValues());
+    const activityId = `adhoc:${kit.id}:${Date.now()}`;
+    const result = await runAutomationPrompt(prompt, {
+      id: activityId,
+      title: kit.name,
+      icon: kit.icon
+    });
+    if (result === "rejected") return;
     setSelectedKit(null);
     props.onRun();
-    await query(prompt);
   };
   const handleSchedule = async () => {
     const kit = selectedKit();

package/out/renderer/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src 'self'; font-src 'self' data:;" />
     <title>Vessel</title>
-    <script type="module" crossorigin src="./assets/index-DVD9XuhC.js"></script>
+    <script type="module" crossorigin src="./assets/index-BFdOm6Op.js"></script>
     <link rel="stylesheet" crossorigin href="./assets/index-eS3ccAls.css">
   </head>
   <body>

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@quanta-intellect/vessel-browser",
   "mcpName": "io.github.unmodeled-tyler/vessel-browser",
-  "version": "0.1.31",
-  "description": "AI-native web browser for Linux — persistent browser runtime for autonomous agents with human supervision",
+  "version": "0.1.33",
+  "description": "AI-native web browser runtime for autonomous agents with human supervision",
   "main": "./out/main/index.js",
   "bin": {
     "vessel-browser": "./bin/vessel-browser.js"
@@ -18,8 +18,13 @@
   "scripts": {
     "dev": "ELECTRON_DISABLE_SANDBOX=1 electron-vite dev",
     "build": "electron-vite build",
+    "build:icon:mac": "scripts/build-macos-icon.sh",
     "dist": "npm run build && electron-builder --linux --publish never",
     "dist:dir": "npm run build && electron-builder --linux dir --publish never",
+    "dist:mac": "npm run build:icon:mac && npm run build && CSC_IDENTITY_AUTO_DISCOVERY=false electron-builder --mac dmg zip --publish never",
+    "dist:mac:dir": "npm run build:icon:mac && npm run build && CSC_IDENTITY_AUTO_DISCOVERY=false electron-builder --mac dir --publish never",
+    "dist:mac:signed": "npm run build:icon:mac && npm run build && electron-builder --mac dmg zip --publish never",
+    "dist:mac:dir:signed": "npm run build:icon:mac && npm run build && electron-builder --mac dir --publish never",
     "preview": "electron-vite preview",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",