@vellumai/assistant 0.4.41 → 0.4.43

package/src/config/bundled-skills/guardian-verify-setup/SKILL.md

@@ -1,17 +1,14 @@
 ---
-name: "Guardian Verify Setup"
-description: "Set up guardian verification for voice, Telegram, or Slack channels via outbound verification flow"
-user-invocable: true
-metadata: { "vellum": { "emoji": "\ud83d\udd10" } }
+name: guardian-verify-setup
+description: Set up channel verification for phone, Telegram, or Slack channels via outbound verification flow
+compatibility: "Designed for Vellum personal assistants"
+metadata: {"emoji":"🔐","vellum":{"display-name":"Guardian Verify Setup","user-invocable":true}}
 ---
 
-You are helping your user set up guardian verification for a messaging channel (voice, Telegram, or Slack). This links their identity as the trusted guardian for the chosen channel. Use gateway control-plane APIs for outbound actions, and use `assistant integrations guardian status` for status reads.
+You are helping your user set up channel verification for a messaging channel (phone, Telegram, or Slack). This links their identity as the trusted guardian for the chosen channel. Use the `assistant channel-verification-sessions` CLI for all verification operations.
 
 ## Prerequisites
 
-- Use the injected `INTERNAL_GATEWAY_BASE_URL` for gateway API calls.
-- Never call the daemon runtime port directly; always call the gateway URL.
-- The bearer token is available as the `$GATEWAY_AUTH_TOKEN` environment variable for control-plane `curl` requests.
 - Run shell commands for this skill with `bash`.
 - Keep narration minimal: execute required calls first, then provide a concise status update. Do not narrate internal install/check/load chatter unless something fails.
 
@@ -19,7 +16,7 @@ You are helping your user set up guardian verification for a messaging channel (
 
 Ask the user which channel they want to verify:
 
-- **voice** -- verify a phone number for voice calls
+- **phone** -- verify a phone number for voice calls
 - **telegram** -- verify a Telegram account
 - **slack** -- verify a Slack account
 
@@ -29,7 +26,7 @@ If the user's intent already specifies a channel (e.g. "verify my phone number f
 
 Based on the chosen channel, ask for the required destination:
 
-- **Voice**: Ask for their phone number. Accept any common format (e.g. +15551234567, (555) 123-4567, 555-123-4567). The API normalizes it to E.164.
+- **Phone**: Ask for their phone number. Accept any common format (e.g. +15551234567, (555) 123-4567, 555-123-4567). The API normalizes it to E.164.
 - **Telegram**: Ask for their Telegram chat ID (numeric) or @handle. Explain:
   - If they know their numeric chat ID, provide it directly. The bot will send the code to that chat.
   - If they only know their @handle, the flow uses a bootstrap deep-link that they must click first.
@@ -40,24 +37,21 @@ Based on the chosen channel, ask for the required destination:
 Execute the outbound start request:
 
 ```bash
-curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/outbound/start" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" \
-  -d '{"channel": "<channel>", "destination": "<destination>"}'
+assistant channel-verification-sessions create --channel <channel> --destination "<destination>" --json
 ```
 
-Replace `<channel>` with `voice`, `telegram`, or `slack`, and `<destination>` with the phone number, Telegram destination, or Slack user ID.
+Replace `<channel>` with `phone`, `telegram`, or `slack`, and `<destination>` with the phone number, Telegram destination, or Slack user ID.
 
 ### On success (`success: true`)
 
 Report the exact next action based on the channel:
 
-- **Voice**: The response includes a `secret` field with the verification code. Tell the user the code BEFORE the call connects: "I'm calling [number] now. Your verification code is [secret]. When you answer the call, enter this code using your phone's keypad." The `/outbound/start` API call already initiates the voice call. Do NOT place a separate `call_start` call. **After delivering the code, immediately begin the voice auto-check polling loop** (see [Voice Auto-Check Polling](#voice-auto-check-polling) below).
+- **Phone**: The response includes a `secret` field with the verification code. Tell the user the code BEFORE the call connects: "I'm calling [number] now. Your verification code is [secret]. When you answer the call, enter this code using your phone's keypad." The `create` command already initiates the voice call. Do NOT place a separate `call_start` call. **After delivering the code, immediately begin the voice auto-check polling loop** (see [Voice Auto-Check Polling](#voice-auto-check-polling) below).
 - **Telegram with chat ID** (no `telegramBootstrapUrl` in response): The response includes a `secret` field. Show it in the current chat: "Your verification code is **[secret]**. I've also sent it to your Telegram. Open the Telegram bot chat and reply with that 6-digit code to complete verification." If the response does not contain a `secret` field, treat this as a control-plane error: tell the user something went wrong and ask them to retry from Step 3 or resend (Step 4).
 - **Telegram with handle** (`telegramBootstrapUrl` present in response): "Tap this deep-link first: [telegramBootstrapUrl]. After Telegram binds your identity, I'll send your verification code."
 - **Slack**: The response includes a `secret` field with the verification code. Show it in the current chat: "Your verification code is **[secret]**. I've also sent it to you as a Slack DM. Open the DM from the Vellum bot in Slack and reply with that 6-digit code to complete verification." The DM channel ID is captured automatically during this process for future message delivery. If the response does not contain a `secret` field, treat this as a control-plane error: tell the user something went wrong and ask them to retry from Step 3 or resend (Step 4). **After delivering the code, immediately begin the Slack auto-check polling loop** (see [Slack Auto-Check Polling](#slack-auto-check-polling) below).
 
-After reporting the bootstrap URL for Telegram handle flows, wait for the user to confirm they clicked the link. Then check guardian status (Step 6) to see if the bootstrap completed and a code was sent.
+After reporting the bootstrap URL for Telegram handle flows, wait for the user to confirm they clicked the link. Then check verification status (Step 6) to see if the bootstrap completed and a code was sent.
 
 ### On error (`success: false`)
 
@@ -67,9 +61,9 @@ Handle each error code:
 | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `missing_destination` | Ask the user to provide their phone number, Telegram destination, or Slack user ID.                                                                                                                                                                |
 | `invalid_destination` | Tell the user the format is invalid. For phone: suggest E.164 format (+15551234567). For Telegram: explain that group chat IDs (negative numbers) are not supported. For Slack: explain that the value must be a Slack member ID (e.g. U01ABCDEF). |
-| `already_bound`       | Tell the user a guardian is already bound for this channel. Ask if they want to replace it. If yes, re-run the start request with `"rebind": true` added to the JSON body.                                                                         |
+| `already_bound`       | Tell the user a guardian is already bound for this channel. Ask if they want to replace it. If yes, re-run the create command with `--rebind` added.                                                                         |
 | `rate_limited`        | Tell the user they have sent too many verification attempts to this destination. Ask them to wait and try again later.                                                                                                                             |
-| `unsupported_channel` | Tell the user the channel is not supported. Only voice, telegram, and slack are valid.                                                                                                                                                             |
+| `unsupported_channel` | Tell the user the channel is not supported. Only phone, telegram, and slack are valid.                                                                                                                                                             |
 | `no_bot_username`     | Telegram bot is not configured. Load and run the `telegram-setup` skill first.                                                                                                                                                                     |
 
 ## Step 4: Handle Resend
@@ -77,15 +71,12 @@ Handle each error code:
 If the user says they did not receive the code or asks to resend:
 
 ```bash
-curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/outbound/resend" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" \
-  -d '{"channel": "<channel>"}'
+assistant channel-verification-sessions resend --channel <channel> --json
 ```
 
 On success, report the next action based on the channel:
 
-- **Voice**: The resend response includes a fresh `secret` field with a new verification code. Tell the user the new code BEFORE the call connects — just like the initial start flow: "I'm calling [number] again. Your new verification code is [secret]. When you answer the call, enter this code using your phone's keypad." The `/outbound/resend` API call already initiates the voice call. Do NOT place a separate `call_start` call. **After delivering the code, immediately begin the voice auto-check polling loop** (see [Voice Auto-Check Polling](#voice-auto-check-polling) below).
+- **Phone**: The resend response includes a fresh `secret` field with a new verification code. Tell the user the new code BEFORE the call connects — just like the initial start flow: "I'm calling [number] again. Your new verification code is [secret]. When you answer the call, enter this code using your phone's keypad." The `resend` command already initiates the voice call. Do NOT place a separate `call_start` call. **After delivering the code, immediately begin the voice auto-check polling loop** (see [Voice Auto-Check Polling](#voice-auto-check-polling) below).
 - **Telegram**: The resend response includes a fresh `secret` field. Show the new code in the current chat: "Your new verification code is **[secret]**. I've also sent it to your Telegram. Open the Telegram bot chat and reply with that 6-digit code to complete verification." If the response does not contain a `secret` field, treat this as a control-plane error: tell the user something went wrong and ask them to retry from Step 3.
 - **Slack**: The resend response includes a fresh `secret` field. Show the new code in the current chat: "Your new verification code is **[secret]**. I've also sent it to you as a Slack DM. Reply to the DM with that 6-digit code to complete verification. (resent)" If the response does not contain a `secret` field, treat this as a control-plane error: tell the user something went wrong and ask them to retry from Step 3. **After delivering the code, immediately begin the Slack auto-check polling loop** (see [Slack Auto-Check Polling](#slack-auto-check-polling) below).
 
@@ -106,10 +97,7 @@ Handle each error code from the resend endpoint:
 If the user wants to cancel the verification:
 
 ```bash
-curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/outbound/cancel" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" \
-  -d '{"channel": "<channel>"}'
+assistant channel-verification-sessions cancel --channel <channel> --json
 ```
 
 Confirm cancellation to the user. On `no_active_session`, tell them there is nothing to cancel.
@@ -124,7 +112,7 @@ For **voice** verification only: after telling the user their code and instructi
 2. Check the binding status via Vellum CLI:
 
 ```bash
-assistant integrations guardian status --channel voice --json
+assistant channel-verification-sessions status --channel phone --json
 ```
 
 3. If the response shows `bound: true`: immediately send a proactive success message in the current chat — "Voice verification complete! Your phone number is now the trusted guardian." Stop polling.
@@ -133,7 +121,7 @@ assistant integrations guardian status --channel voice --json
 6. If the 2-minute timeout is reached without `bound: true`: proactively tell the user — "I've been checking for about 2 minutes but verification hasn't completed yet. The code may have expired or wasn't entered. Would you like me to resend a new code (Step 4) or start a new session (Step 3)?"
 
 **Rebind guard:**
-When in a **rebind flow** (i.e., the `start_outbound` request included `"rebind": true` because a binding already existed), do NOT treat `bound: true` alone as success. The pre-existing binding will show `bound: true` before the user has entered the new code, which would be a false positive. To guard against this:
+When in a **rebind flow** (i.e., the session creation request included `"rebind": true` because a binding already existed), do NOT treat `bound: true` alone as success. The pre-existing binding will show `bound: true` before the user has entered the new code, which would be a false positive. To guard against this:
 
 - Only report success when BOTH conditions are met: `bound: true` AND `verificationSessionId` is **absent** from the status response. The `verificationSessionId` field is present while a verification session is still active (pending). When the user enters the correct code, the session is consumed and `verificationSessionId` disappears from subsequent status responses. This proves the new outbound session was consumed and the binding is fresh.
 - If a poll shows `bound: true` but `verificationSessionId` is still present, the old binding is still active and the new code has not yet been consumed — continue polling.
@@ -155,7 +143,7 @@ For **Slack** verification: after telling the user their code and instructing th
 2. Check the binding status via Vellum CLI:
 
 ```bash
-assistant integrations guardian status --channel slack --json
+assistant channel-verification-sessions status --channel slack --json
 ```
 
 3. If the response shows `bound: true`: immediately send a proactive success message in the current chat — "Slack verification complete! Your Slack account is now the trusted guardian. The DM channel has been captured for future message delivery." Stop polling.
@@ -164,7 +152,7 @@ assistant integrations guardian status --channel slack --json
 6. If the 2-minute timeout is reached without `bound: true`: proactively tell the user — "I've been checking for about 2 minutes but verification hasn't completed yet. The code may have expired or wasn't entered. Would you like me to resend a new code (Step 4) or start a new session (Step 3)?"
 
 **Rebind guard:**
-When in a **rebind flow** (i.e., the `start_outbound` request included `"rebind": true` because a binding already existed), do NOT treat `bound: true` alone as success. The pre-existing binding will show `bound: true` before the user has entered the new code, which would be a false positive. To guard against this:
+When in a **rebind flow** (i.e., the session creation request included `"rebind": true` because a binding already existed), do NOT treat `bound: true` alone as success. The pre-existing binding will show `bound: true` before the user has entered the new code, which would be a false positive. To guard against this:
 
 - Only report success when BOTH conditions are met: `bound: true` AND `verificationSessionId` is **absent** from the status response. The `verificationSessionId` field is present while a verification session is still active (pending). When the user enters the correct code, the session is consumed and `verificationSessionId` disappears from subsequent status responses. This proves the new outbound session was consumed and the binding is fresh.
 - If a poll shows `bound: true` but `verificationSessionId` is still present, the old binding is still active and the new code has not yet been consumed — continue polling.
@@ -175,16 +163,16 @@ When in a **rebind flow** (i.e., the `start_outbound` request included `"rebind"
 - Do NOT require the user to ask "did it work?" — the whole point is proactive confirmation.
 - If the user sends a message while polling is in progress, handle their message normally.
 
-## Step 6: Check Guardian Status
+## Step 6: Check Verification Status
 
 After the user reports entering the code, verify the binding was created:
 
 ```bash
 CHANNEL="<channel>"
-assistant integrations guardian status --channel "$CHANNEL" --json
+assistant channel-verification-sessions status --channel "$CHANNEL" --json
 ```
 
-If the response shows the guardian is bound, confirm success: "Guardian verified! Your [channel] identity is now the trusted guardian."
+If the response shows the channel is bound, confirm success: "Verification complete! Your [channel] identity is now the trusted guardian."
 
 If not yet bound, offer to resend (Step 4) or generate a new session (Step 3).
 
@@ -193,13 +181,10 @@ If not yet bound, offer to resend (Step 4) or generate a new session (Step 3).
 If the user wants to remove themselves (or the current guardian) from a channel, use the revoke endpoint:
 
 ```bash
-curl -s -X POST "$INTERNAL_GATEWAY_BASE_URL/v1/integrations/guardian/revoke" \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer $GATEWAY_AUTH_TOKEN" \
-  -d '{"channel": "<channel>"}'
+assistant channel-verification-sessions revoke --channel <channel> --json
 ```
 
-Replace `<channel>` with the channel to unbind from (e.g. `voice`, `telegram`, `slack`).
+Replace `<channel>` with the channel to unbind from (e.g. `phone`, `telegram`, `slack`).
 
 ### On success (`success: true`)
 
@@ -213,6 +198,6 @@ The response includes `bound: false` after the operation completes. Check the pr
 - Verification codes expire after 10 minutes. If the session expires, start a new one.
 - The resend cooldown is 15 seconds between sends, with a maximum of 5 sends per session.
 - Per-destination rate limiting allows up to 10 sends within a 1-hour rolling window.
-- Guardian verification is identity-bound: the code can only be consumed by the identity matching the destination provided at start time.
+- Channel verification is identity-bound: the code can only be consumed by the identity matching the destination provided at start time.
 - **Missing `secret` guardrail**: For voice, Telegram chat-ID, and Slack flows, the API response MUST include a `secret` field. If `secret` is unexpectedly absent from a start or resend response that otherwise indicates success, treat this as a control-plane error. Do NOT fabricate a code or tell the user to proceed without one. Instead, tell the user something went wrong and ask them to retry the start (Step 3) or resend (Step 4).
 - **Revoking a guardian**: To remove the current guardian from a channel, use the revoke API (Step 7). This revokes the binding AND revokes the guardian's contact record, so they lose access to the channel. A new guardian can then be verified for that channel.

package/src/config/bundled-skills/image-studio/SKILL.md

@@ -1,9 +1,8 @@
 ---
-name: "Image Studio"
-description: "Generate and edit images using AI"
-user-invocable: true
-disable-model-invocation: false
-metadata: {"vellum": {"emoji": "🎨"}}
+name: image-studio
+description: Generate and edit images using AI
+compatibility: "Designed for Vellum personal assistants"
+metadata: {"emoji":"🎨","vellum":{"display-name":"Image Studio","user-invocable":true}}
 ---
 
 You are an image generation assistant. When the user asks you to create or edit images, use the `media_generate_image` tool.

package/src/config/bundled-skills/image-studio/tools/media-generate-image.ts

@@ -8,7 +8,7 @@ import {
   mapGeminiError,
 } from "../../../../media/gemini-image-service.js";
 import { getAttachmentsByIds } from "../../../../memory/attachments-store.js";
-import { getConversationThreadType } from "../../../../memory/conversation-store.js";
+import { getConversationThreadType } from "../../../../memory/conversation-crud.js";
 import type { ImageContent } from "../../../../providers/types.js";
 import { getAttachmentSourceConversations } from "../../../../tools/assets/search.js";
 import type {

package/src/config/bundled-skills/influencer/SKILL.md

@@ -1,17 +1,17 @@
 ---
-name: "Influencer Research"
-description: "Research influencers on Instagram, TikTok, and X/Twitter using the Chrome extension relay"
-user-invocable: true
-metadata: {"vellum": {"emoji": "🔍"}}
+name: influencer
+description: Research influencers on Instagram, TikTok, and X/Twitter using the Chrome extension relay
+compatibility: "Designed for Vellum personal assistants"
+metadata: {"emoji":"🔍","vellum":{"display-name":"Influencer Research","user-invocable":true}}
 ---
 
-You can research and discover influencers across Instagram, TikTok, and X/Twitter using the `assistant influencer` CLI.
+You can research and discover influencers across Instagram, TikTok, and X/Twitter using the bundled influencer scripts.
 
-## CLI Setup
+## Script Setup
 
-**IMPORTANT: Always use `host_bash` (not `bash`) for all `assistant influencer` commands.** The influencer CLI needs host access for the Chrome extension relay and the `vellum` binary, neither of which are available inside the sandbox.
+**IMPORTANT: Always use `host_bash` (not `bash`) for all influencer commands.** The scripts need host access for the `assistant` CLI binary (used for the Chrome extension relay), which is not available inside the sandbox.
 
-`assistant influencer` is a built-in subcommand of the Vellum assistant CLI. If `vellum` is not found, prepend `PATH="$HOME/.local/bin:$PATH"` to the command.
+The influencer scripts are bundled with this skill. Run them via `bun run {baseDir}/scripts/influencer.ts <subcommand> [options]`.
 
 ## Prerequisites
 
@@ -60,7 +60,7 @@ When the user asks to find or research influencers:
    - **Verified only?** — do they need the blue checkmark?
    - Don't over-ask. If the user says "find me fitness influencers on Instagram", that's enough to start.
 
-2. **Search** — run `assistant influencer search "<query>" --platforms <platforms> [options] --json`
+2. **Search** — run `bun run {baseDir}/scripts/influencer.ts search "<query>" --platforms <platforms> [options] --json`
 
 3. **Present results** — show a clean summary of each influencer found:
    - Username and display name
@@ -71,9 +71,9 @@ When the user asks to find or research influencers:
    - Content themes detected
    - Profile URL
 
-4. **Deep dive** (if needed) — run `assistant influencer profile <username> --platform <platform> --json` to get detailed data on a specific influencer.
+4. **Deep dive** (if needed) — run `bun run {baseDir}/scripts/influencer.ts profile <username> --platform <platform> --json` to get detailed data on a specific influencer.
 
-5. **Compare** (if needed) — run `assistant influencer compare instagram:user1 twitter:user2 tiktok:user3 --json` to compare influencers side by side.
+5. **Compare** (if needed) — run `bun run {baseDir}/scripts/influencer.ts compare instagram:user1 twitter:user2 tiktok:user3 --json` to compare influencers side by side.
 
 ## Follower Range Shortcuts
 
@@ -89,17 +89,17 @@ Human-friendly numbers are supported: `10k`, `100k`, `1m`, etc.
 ## Command Reference
 
 ```
-assistant influencer search "<query>" [options] --json
+bun run {baseDir}/scripts/influencer.ts search "<query>" [options] --json
   --platforms <list>       Comma-separated: instagram,tiktok,twitter (default: all three)
   --min-followers <n>      Minimum follower count (e.g. 10k, 100000)
   --max-followers <n>      Maximum follower count (e.g. 1m, 500k)
   --limit <n>              Max results per platform (default: 10)
   --verified               Only return verified accounts
 
-assistant influencer profile <username> --platform <platform> --json
+bun run {baseDir}/scripts/influencer.ts profile <username> --platform <platform> --json
   --platform <platform>    instagram, tiktok, or twitter (default: instagram)
 
-assistant influencer compare <platform:username ...> --json
+bun run {baseDir}/scripts/influencer.ts compare <platform:username ...> --json
   Arguments are space-separated platform:username pairs
   e.g. instagram:nike twitter:nike tiktok:nike
 ```
@@ -117,28 +117,28 @@ assistant influencer compare <platform:username ...> --json
   - Search with different criteria
   - Export the results
 - **Handle errors gracefully.** If a platform fails (e.g. not logged in), show results from the platforms that worked and mention which one failed.
-- **Do NOT use the browser skill.** All influencer research goes through the CLI, not browser automation.
+- **Do NOT use the browser skill.** All influencer research goes through the bundled scripts, not browser automation. Do NOT use `assistant influencer` directly — use the bundled scripts.
 
 ## Example Interactions
 
 **User**: "Find me fitness influencers on Instagram and TikTok"
 
-1. `assistant influencer search "fitness coach workout" --platforms instagram,tiktok --limit 10 --json`
+1. `bun run {baseDir}/scripts/influencer.ts search "fitness coach workout" --platforms instagram,tiktok --limit 10 --json`
 2. Present results grouped by platform with follower counts and bios
 3. "I found 8 fitness influencers on Instagram and 6 on TikTok. Want me to dig deeper into any of these profiles?"
 
 **User**: "I need micro-influencers in the beauty niche, verified only"
 
-1. `assistant influencer search "beauty makeup skincare" --platforms instagram,tiktok,twitter --min-followers 10k --max-followers 100k --verified --limit 10 --json`
+1. `bun run {baseDir}/scripts/influencer.ts search "beauty makeup skincare" --platforms instagram,tiktok,twitter --min-followers 10k --max-followers 100k --verified --limit 10 --json`
 2. Present filtered results
 3. Offer to compare top picks
 
 **User**: "Compare @username1 on Instagram with @username2 on TikTok"
 
-1. `assistant influencer compare instagram:username1 tiktok:username2 --json`
+1. `bun run {baseDir}/scripts/influencer.ts compare instagram:username1 tiktok:username2 --json`
 2. Present side-by-side comparison with followers, engagement, bio, themes
 
 **User**: "Tell me more about @specificuser on Instagram"
 
-1. `assistant influencer profile specificuser --platform instagram --json`
+1. `bun run {baseDir}/scripts/influencer.ts profile specificuser --platform instagram --json`
 2. Show full profile details including bio, follower/following counts, verified status, content themes

package/src/{influencer → config/bundled-skills/influencer/scripts}/client.ts

@@ -1,5 +1,9 @@
 /**
- * Influencer Research Client
+ * Influencer Research Client — Standalone Version
+ *
+ * This is a self-contained version of the influencer research client that
+ * communicates with the Chrome extension relay via the `assistant browser
+ * chrome relay` CLI subprocess instead of importing internal assistant modules.
  *
  * ARCHITECTURE
  * ============
@@ -45,22 +49,22 @@
  *   - The chrome.debugger API shows a yellow infobar on the tab being debugged
  */
 
-import type {
-  ExtensionCommand,
-  ExtensionResponse,
-} from "../browser-extension-relay/protocol.js";
-import { extensionRelayServer } from "../browser-extension-relay/server.js";
-import {
-  initAuthSigningKey,
-  isSigningKeyInitialized,
-  loadOrCreateSigningKey,
-} from "../runtime/auth/token-service.js";
-import { gatewayPost } from "../runtime/gateway-internal-client.js";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
+interface RelayResponse {
+  ok: boolean;
+  tabId?: number;
+  result?: unknown;
+  error?: string;
+}
+
 export interface InfluencerSearchCriteria {
   /** Keywords, niche, or topic to search for */
   query: string;
@@ -124,32 +128,19 @@ export interface InfluencerSearchResult {
 }
 
 // ---------------------------------------------------------------------------
-// Relay command routing (same pattern as Amazon client)
+// Relay command routing via `assistant browser chrome relay` subprocess
 // ---------------------------------------------------------------------------
 
 async function sendRelayCommand(
-  command: Record<string, unknown>,
-): Promise<ExtensionResponse> {
-  const status = extensionRelayServer.getStatus();
-  if (status.connected) {
-    return extensionRelayServer.sendCommand(
-      command as Omit<ExtensionCommand, "id">,
-    );
-  }
-
-  // Fall back to HTTP relay endpoint via the gateway.
-  // The gateway validates edge JWTs (aud=vellum-gateway) and mints an
-  // exchange token for the runtime. In CLI out-of-process contexts the
-  // signing key may not be initialized yet — load it from disk.
-  if (!isSigningKeyInitialized()) {
-    initAuthSigningKey(loadOrCreateSigningKey());
+  action: string,
+  args: Record<string, string | number>,
+): Promise<RelayResponse> {
+  const cmdArgs = ["browser", "chrome", "relay", action];
+  for (const [key, value] of Object.entries(args)) {
+    cmdArgs.push(`--${key}`, String(value));
   }
-
-  const { data } = await gatewayPost<ExtensionResponse>(
-    "/v1/browser-relay/command",
-    command,
-  );
-  return data;
+  const { stdout } = await execFileAsync("assistant", cmdArgs);
+  return JSON.parse(stdout);
 }
 
 // ---------------------------------------------------------------------------
@@ -160,45 +151,71 @@ async function findOrOpenTab(
   urlPattern: string,
   fallbackUrl: string,
 ): Promise<number> {
-  const resp = await sendRelayCommand({ action: "find_tab", url: urlPattern });
-  if (resp.success && resp.tabId !== undefined) {
-    return resp.tabId;
-  }
-
-  const newTab = await sendRelayCommand({
-    action: "new_tab",
-    url: fallbackUrl,
-  });
-  if (!newTab.success || newTab.tabId === undefined) {
+  const resp = await sendRelayCommand("find-tab", { url: urlPattern });
+  if (resp.ok && resp.tabId !== undefined) return resp.tabId;
+  const newTab = await sendRelayCommand("new-tab", { url: fallbackUrl });
+  if (!newTab.ok || newTab.tabId === undefined) {
     throw new Error(`Could not open tab for ${fallbackUrl}`);
   }
-
   await sleep(2500);
   return newTab.tabId;
 }
 
 async function navigateTab(tabId: number, url: string): Promise<void> {
-  const resp = await sendRelayCommand({ action: "navigate", tabId, url });
-  if (!resp.success) {
+  const resp = await sendRelayCommand("navigate", { "tab-id": tabId, url });
+  if (!resp.ok)
     throw new Error(`Failed to navigate: ${resp.error ?? "unknown error"}`);
-  }
   await sleep(3000);
 }
 
 /**
  * Evaluate a JS script in a tab. The script is wrapped in an IIFE by the relay
  * so use `return` to yield a value. For complex results, return a JSON string.
+ *
+ * Uses `spawn` to pipe code via stdin to avoid shell escaping issues with long
+ * JS snippets.
  */
 async function evalInTab(tabId: number, script: string): Promise<unknown> {
-  const resp = await sendRelayCommand({
-    action: "evaluate",
-    tabId,
-    code: script,
+  return new Promise((resolve, reject) => {
+    const proc = spawn("assistant", [
+      "browser",
+      "chrome",
+      "relay",
+      "evaluate",
+      "--tab-id",
+      String(tabId),
+    ]);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d: Buffer) => {
+      stdout += d;
+    });
+    proc.stderr.on("data", (d: Buffer) => {
+      stderr += d;
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        // The relay CLI writes structured errors to stdout, not stderr.
+        // Try to parse stdout for a JSON error message before falling back.
+        try {
+          const parsed: RelayResponse = JSON.parse(stdout);
+          if (parsed.error) return reject(new Error(parsed.error));
+        } catch {
+          // stdout wasn't valid JSON — fall through to stderr/exit code
+        }
+        return reject(new Error(stderr || `Exit code ${code}`));
+      }
+      try {
+        const result: RelayResponse = JSON.parse(stdout);
+        if (!result.ok) return reject(new Error(result.error ?? "Eval failed"));
+        resolve(result.result);
+      } catch {
+        reject(new Error(`Invalid JSON: ${stdout}`));
+      }
+    });
+    proc.stdin.write(script);
+    proc.stdin.end();
   });
-  if (!resp.success) {
-    throw new Error(`Browser eval failed: ${resp.error ?? "unknown error"}`);
-  }
-  return resp.result;
 }
 
 function sleep(ms: number): Promise<void> {