@carrierllc/mcp 0.9.3 → 0.10.0

package/dist/index.js

@@ -47,7 +47,7 @@ import {
   usageOverPeriodParams,
   verifyStorefront,
   withOcsListSummary
-} from "./chunk-KHNJNJX3.js";
+} from "./chunk-DUAENMJE.js";
 import "./chunk-SHKKVIIA.js";
 
 // src/index.ts
@@ -360,6 +360,469 @@ async function invokeModelRaw(creds, payload, opts = {}, signal) {
     signal?.removeEventListener("abort", onAbort);
   }
 }
+var PENDING_ASK_PREFIX = "manus_pending_ask:";
+var PENDING_ASK_TTL_SECONDS = 24 * 3600;
+var OCS_DASHBOARD_DEFAULT = "https://ocs.esimvault.cloud";
+function buildLoginPreamble(dashboardUrl) {
+  return `STEP 1 \u2014 LOGIN:
+Navigate to ${dashboardUrl}/login (or the main page if no /login path).
+Enter the OCS portal username and password provided below.
+Wait for the dashboard to fully load after login.
+If already logged in (session cookie persists), skip to STEP 2.
+
+`;
+}
+function assembleUiAgentPrompt(operationPrompt, credentials, dashboardUrl) {
+  return `You are a Carrier MCP UI automation agent. Your task is to perform an OCS dashboard operation that is not available via the OCS REST API.
+
+OCS PORTAL CREDENTIALS (use these to log in \u2014 NEVER include them in your output):
+  Username: ${credentials.username}
+  Password: ${credentials.password}
+
+` + buildLoginPreamble(dashboardUrl) + `STEP 2 \u2014 OPERATION:
+` + operationPrompt + `
+
+STEP 3 \u2014 VERIFICATION:
+After completing the operation, verify the result by checking the dashboard shows the expected state.
+Take a screenshot of the final state for audit purposes.
+Report success or failure with a clear summary.`;
+}
+function redactCredentials(prompt, credentials) {
+  return prompt.replaceAll(credentials.password, "***REDACTED***").replaceAll(credentials.username, "***REDACTED***");
+}
+function buildCreateSteeringListPrompt(params, dashboardUrl) {
+  return `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
+Create a new steering list with the following details:
+  Name: ${params.name}
+` + (params.description ? `  Description: ${params.description}
+` : "") + `Click the "Create" or "Add" button to create the steering list.
+After creation, note the new steering list ID from the dashboard.
+`;
+}
+function buildBuildSteeringListPrompt(params, dashboardUrl) {
+  const add = params.add_operators ?? [];
+  const remove = params.remove_operators ?? [];
+  return `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
+Open steering list ID ${params.steering_list_id} for editing.
+Operator type: ${params.operator_type ?? "priority"}
+` + (add.length > 0 ? `Add the following operators: ${add.join(", ")}
+` : "") + (remove.length > 0 ? `Remove the following operators: ${remove.join(", ")}
+` : "") + `Save the changes and verify the updated operator list.
+`;
+}
+function buildSetAccountSteeringListPrompt(params, dashboardUrl) {
+  return `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
+Open account ID ${params.account_id}.
+` + (params.steering_list_id === 0 ? `Remove/unset the steering list assignment from this account.
+` : `Assign steering list ID ${params.steering_list_id} to this account.
+`) + `Save the changes and verify the steering list assignment is updated.
+`;
+}
+function buildCreateAccountPrompt(params, dashboardUrl) {
+  return `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
+Create a new account with the following details:
+  Name: ${params.name}
+` + (params.description ? `  Description: ${params.description}
+` : "") + (params.initial_balance ? `  Initial balance: ${params.initial_balance}
+` : "") + `Click the "Create" or "Add" button.
+After creation, note the new account ID from the dashboard.
+`;
+}
+function buildCreateDestinationListPrompt(params, dashboardUrl) {
+  const prefixes = params.prefixes ?? [];
+  return `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
+Create a new destination list with the following details:
+  Name: ${params.name}
+` + (params.description ? `  Description: ${params.description}
+` : "") + (prefixes.length > 0 ? `  Prefixes to add: ${prefixes.join(", ")}
+` : "") + `Save the new destination list and note the ID.
+`;
+}
+function buildEditDestinationListPrompt(params, dashboardUrl) {
+  const add = params.add_prefixes ?? [];
+  const remove = params.remove_prefixes ?? [];
+  return `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
+Open destination list ID ${params.destination_list_id} for editing.
+` + (params.new_name ? `Rename to: ${params.new_name}
+` : "") + (add.length > 0 ? `Add prefixes: ${add.join(", ")}
+` : "") + (remove.length > 0 ? `Remove prefixes: ${remove.join(", ")}
+` : "") + `Save the changes and verify the updated prefix list.
+`;
+}
+function buildDeleteDestinationListPrompt(params, dashboardUrl) {
+  return `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
+Find destination list ID ${params.destination_list_id}.
+Delete this destination list. Confirm the deletion when prompted.
+Verify the list no longer appears in the dashboard.
+`;
+}
+function buildDeletePackageTemplatePrompt(params, dashboardUrl) {
+  return `Navigate to the Package Templates section of the OCS dashboard at ${dashboardUrl}.
+Find package template ID ${params.template_id}.
+Delete this package template. Confirm the deletion when prompted.
+Verify the template no longer appears in the template list.
+`;
+}
+function buildEditLocationZonePrompt(params, dashboardUrl) {
+  const add = params.add_countries ?? [];
+  const remove = params.remove_countries ?? [];
+  return `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
+Open location zone ID ${params.zone_id} for editing.
+` + (params.new_name ? `Rename to: ${params.new_name}
+` : "") + (add.length > 0 ? `Add countries: ${add.join(", ")}
+` : "") + (remove.length > 0 ? `Remove countries: ${remove.join(", ")}
+` : "") + `Save the changes and verify the updated country list.
+`;
+}
+function buildDeleteLocationZonePrompt(params, dashboardUrl) {
+  return `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
+Find location zone ID ${params.zone_id}.
+Delete this location zone. Confirm the deletion when prompted.
+If the dashboard shows an error (e.g. zone in use by active templates), report the error.
+Verify the zone no longer appears in the zone list.
+`;
+}
+var BROWSER_USE_API = "https://api.browser-use.com/api/v4";
+var RUN_TIMEOUT_MS = 10 * 6e4;
+var POLL_INTERVAL_MS = 3e3;
+function browserUseConfigured(env) {
+  return Boolean(env.apiKey);
+}
+function apiKey(env) {
+  const key = env.apiKey;
+  if (!key) {
+    throw new Error(
+      "BROWSER_USE_API_KEY is not set \u2014 the browser-use provider cannot run."
+    );
+  }
+  return key;
+}
+async function v4(env, path, init) {
+  const res = await fetch(`${BROWSER_USE_API}${path}`, {
+    method: init?.method ?? "GET",
+    headers: {
+      "X-Browser-Use-API-Key": apiKey(env),
+      "Content-Type": "application/json"
+    },
+    ...init?.body ? { body: JSON.stringify(init.body) } : {}
+  });
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+  }
+  return { ok: res.ok, status: res.status, data };
+}
+function mapStatus(raw) {
+  switch ((raw ?? "").toLowerCase()) {
+    case "finished":
+    case "completed":
+    case "success":
+    case "stopped":
+      return "stopped";
+    case "failed":
+    case "error":
+      return "error";
+    case "paused":
+    case "waiting":
+    case "needs_input":
+      return "waiting";
+    default:
+      return "running";
+  }
+}
+function defaultRedact(text) {
+  return text.replace(/(\bpassword\b\s*[:=]\s*)\S+/gi, "$1***REDACTED***").replace(/(\busername\b\s*[:=]\s*)\S+/gi, "$1***REDACTED***");
+}
+function toTaskResult(run, redact) {
+  const status = mapStatus(run.status);
+  const scrub = (text) => defaultRedact(redact ? redact(text) : text);
+  const payload = run.result ?? run.output;
+  if (payload && typeof payload === "object") {
+    const p = payload;
+    return {
+      success: status === "stopped" && !run.error,
+      summary: scrub(
+        typeof p.summary === "string" ? p.summary : JSON.stringify(payload)
+      ).slice(0, 2e3),
+      ...typeof p.entity_id === "string" ? { entity_id: p.entity_id } : {},
+      ...run.error ? { error_message: scrub(run.error) } : {},
+      // The hosted agent does not report a screenshot count. Zero is honest;
+      // inventing one would put a fabricated number in an audit row.
+      screenshots_taken: 0
+    };
+  }
+  return {
+    success: status === "stopped" && !run.error,
+    summary: typeof payload === "string" ? scrub(payload).slice(0, 2e3) : "",
+    ...run.error ? { error_message: scrub(run.error) } : {},
+    screenshots_taken: 0
+  };
+}
+function viewerUrl(run) {
+  return run.sessionId ? `https://cloud.browser-use.com/sessions/${run.sessionId}` : void 0;
+}
+function runSpend(run) {
+  if (!run || typeof run.totalCostUsd !== "number") return null;
+  return {
+    costUsd: run.totalCostUsd,
+    inputTokens: run.totalInputTokens ?? 0,
+    outputTokens: run.totalOutputTokens ?? 0
+  };
+}
+async function createRun(env, task, opts) {
+  const body2 = { task };
+  if (opts?.model) body2.model = opts.model;
+  if (opts?.outputSchema) body2.schema = opts.outputSchema;
+  const res = await v4(env, "/runs", { method: "POST", body: body2 });
+  if (!res.ok) {
+    throw new Error(
+      `Browser Use run create failed: HTTP ${res.status} ${JSON.stringify(res.data).slice(0, 300)}`
+    );
+  }
+  const run = res.data;
+  if (!run?.id) throw new Error("Browser Use run create returned no id");
+  const url = viewerUrl(run);
+  return { runId: run.id, ...url ? { sessionViewerUrl: url } : {} };
+}
+async function getRun(env, runId) {
+  const res = await v4(env, `/runs/${encodeURIComponent(runId)}`);
+  if (!res.ok) return null;
+  return res.data;
+}
+async function waitForRun(env, runId, timeoutMs = RUN_TIMEOUT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  while (Date.now() < deadline) {
+    last = await getRun(env, runId);
+    if (last && mapStatus(last.status) !== "running") return last;
+    await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+  }
+  return last;
+}
+function toSteelTask(taskId, run, opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const status = mapStatus(run?.status);
+  const url = run ? viewerUrl(run) : void 0;
+  return {
+    task_id: taskId,
+    status,
+    ...opts?.ownerSub ? { owner_sub: opts.ownerSub } : {},
+    // The console's task detail view renders steel_session_id. It is the
+    // provider's session id, whoever the provider is.
+    ...run?.sessionId ? { steel_session_id: run.sessionId } : {},
+    ...run?.id ? { run_id: run.id } : {},
+    ...url ? { session_viewer_url: url } : {},
+    ...opts?.title ? { title: opts.title } : {},
+    created_at: opts?.createdAt ?? now,
+    updated_at: now,
+    ...run && status !== "running" ? { result: toTaskResult(run, opts?.redact) } : {},
+    // Scrubbed on the same grounds as the result: the question is agent-authored
+    // text, and an agent that pauses to ask for help is exactly the one likely
+    // to quote its own instructions — password line included — while explaining
+    // what it is stuck on. This string is stored in KV and handed to operators
+    // by ui_agent_list_pending.
+    ...status === "waiting" ? { pending_question: pendingQuestion(run, opts?.redact) } : {}
+  };
+}
+function pendingQuestion(run, redact) {
+  const payload = run?.result;
+  const q = payload && typeof payload === "object" ? payload.question : void 0;
+  if (typeof q !== "string" || q.length === 0) {
+    return "The browser agent is paused and needs input to continue.";
+  }
+  return defaultRedact(redact ? redact(q) : q);
+}
+function taskKey(taskId) {
+  return `steel_task:${taskId}`;
+}
+var TASK_TTL_SECONDS = 7 * 24 * 3600;
+async function beginUiAgentRun(prompt, title, env, opts) {
+  if (!browserUseConfigured(env)) {
+    throw new Error("BROWSER_USE_API_KEY is not configured");
+  }
+  const taskId = opts?.taskId ?? `bu_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const base = {
+    task_id: taskId,
+    status: "running",
+    title,
+    created_at: createdAt,
+    updated_at: createdAt,
+    ...opts?.ownerSub ? { owner_sub: opts.ownerSub } : {}
+  };
+  await putTask(env, base);
+  let created;
+  try {
+    created = await createRun(env, prompt, {
+      ...opts?.model ? { model: opts.model } : {},
+      ...opts?.outputSchema ? { outputSchema: opts.outputSchema } : {}
+    });
+  } catch (err7) {
+    const message = err7 instanceof Error ? err7.message : String(err7);
+    await putTask(env, {
+      ...base,
+      status: "error",
+      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+      result: {
+        success: false,
+        summary: `Failed to start a Browser Use run: ${message}`,
+        error_message: message,
+        screenshots_taken: 0
+      }
+    });
+    throw err7;
+  }
+  const dispatched = {
+    ...base,
+    run_id: created.runId,
+    ...created.sessionViewerUrl ? { session_viewer_url: created.sessionViewerUrl } : {},
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await putTask(env, dispatched);
+  const complete = async () => {
+    let run;
+    try {
+      run = await waitForRun(env, created.runId);
+    } catch (err7) {
+      const message = err7 instanceof Error ? err7.message : String(err7);
+      const failed = {
+        success: false,
+        summary: `Browser Use run failed: ${message}`,
+        error_message: message,
+        screenshots_taken: 0
+      };
+      await putTask(env, {
+        ...dispatched,
+        status: "error",
+        result: failed,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      writeAgentAudit(env, {
+        event_type: "task_stopped",
+        stop_reason: "error",
+        task_id: taskId
+      });
+      return {
+        task_id: taskId,
+        status: "error",
+        ...created.sessionViewerUrl ? { session_viewer_url: created.sessionViewerUrl } : {},
+        result: failed
+      };
+    }
+    const final = toSteelTask(taskId, run, {
+      title,
+      ...opts?.ownerSub ? { ownerSub: opts.ownerSub } : {},
+      ...opts?.redact ? { redact: opts.redact } : {},
+      createdAt
+    });
+    if (!final.session_viewer_url && created.sessionViewerUrl) {
+      final.session_viewer_url = created.sessionViewerUrl;
+    }
+    final.run_id = created.runId;
+    await putTask(env, final);
+    if (final.status === "waiting") {
+      await writePendingAsk(env, final);
+    }
+    const spend = runSpend(run);
+    writeAgentAudit(env, {
+      event_type: "task_stopped",
+      stop_reason: final.status === "waiting" ? "ask" : final.status === "stopped" ? "finish" : final.status === "running" ? "timeout" : "error",
+      task_id: taskId,
+      ...spend ? { spend } : {}
+    });
+    return {
+      task_id: taskId,
+      status: final.status,
+      ...final.session_viewer_url ? { session_viewer_url: final.session_viewer_url } : {},
+      ...final.result ? { result: final.result } : {},
+      ...spend ? { spend } : {}
+    };
+  };
+  return {
+    task_id: taskId,
+    ...created.sessionViewerUrl ? { session_viewer_url: created.sessionViewerUrl } : {},
+    complete
+  };
+}
+async function runUiAgent(prompt, title, env, opts) {
+  const handle = await beginUiAgentRun(prompt, title, env, opts);
+  return await handle.complete();
+}
+async function getUiAgentTask(taskId, env) {
+  const raw = await env.store.get(taskKey(taskId));
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function resumeUiAgentTask(taskId, reply, env) {
+  const pendingRaw = await env.store.get(`${PENDING_ASK_PREFIX}${taskId}`);
+  if (!pendingRaw) {
+    return { ok: false, error: "No pending-ask entry found for this task_id." };
+  }
+  const task = await getUiAgentTask(taskId, env);
+  if (!task) {
+    return { ok: false, error: "Task record not found." };
+  }
+  await env.store.delete(`${PENDING_ASK_PREFIX}${taskId}`);
+  const { pending_question: _dropped, ...rest } = task;
+  await putTask(env, {
+    ...rest,
+    status: "running",
+    updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  writeAgentAudit(env, {
+    event_type: "task_stopped",
+    stop_reason: "resumed",
+    task_id: taskId,
+    replyLen: reply.length
+  });
+  return { ok: true };
+}
+async function putTask(env, task) {
+  await env.store.put(taskKey(task.task_id), JSON.stringify(task), {
+    expirationTtl: TASK_TTL_SECONDS
+  });
+}
+async function writePendingAsk(env, task) {
+  const entry = {
+    task_id: task.task_id,
+    question: task.pending_question ?? "The browser agent is paused and needs input to continue.",
+    task_url: task.session_viewer_url ?? "",
+    asked_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await env.store.put(
+    `${PENDING_ASK_PREFIX}${task.task_id}`,
+    JSON.stringify(entry),
+    { expirationTtl: PENDING_ASK_TTL_SECONDS }
+  );
+}
+function writeAgentAudit(env, entry) {
+  try {
+    env.audit({
+      blobs: [
+        "steel_agent",
+        entry.event_type,
+        entry.stop_reason,
+        entry.task_id,
+        "0",
+        "browser_use"
+      ],
+      doubles: [
+        entry.replyLen ?? 0,
+        entry.spend?.costUsd ?? 0,
+        entry.spend?.inputTokens ?? 0,
+        entry.spend?.outputTokens ?? 0
+      ],
+      indexes: [entry.task_id]
+    });
+  } catch (err7) {
+    console.error(`[browser-use-agent] audit write failed: ${err7.message}`);
+  }
+}
 
 // src/billing.ts
 var TIER_CALL_LIMITS = {
@@ -4888,246 +5351,358 @@ import { z as z11 } from "zod";
 // src/tools-ui-agent.ts
 import { z as z4 } from "zod";
 
-// src/clerk.ts
-import { createClerkClient } from "@clerk/backend";
-async function getOcsPortalCredentials(env, orgId, userId) {
-  const baseUrl2 = "https://api.clerk.com/v1";
-  const headers = {
-    Authorization: `Bearer ${env.CLERK_SECRET_KEY}`,
-    "Content-Type": "application/json"
-  };
-  if (orgId) {
-    try {
-      const res = await fetch(`${baseUrl2}/organizations/${orgId}`, { headers });
-      if (res.ok) {
-        const org = await res.json();
-        if (org.private_metadata?.ocs_portal?.username && org.private_metadata.ocs_portal.password) {
-          return org.private_metadata.ocs_portal;
-        }
-      }
-    } catch {
-    }
-  }
-  if (userId) {
-    try {
-      const res = await fetch(`${baseUrl2}/users/${userId}`, { headers });
-      if (res.ok) {
-        const user = await res.json();
-        if (user.private_metadata?.ocs_portal?.username && user.private_metadata.ocs_portal.password) {
-          return user.private_metadata.ocs_portal;
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-
-// src/manus-common.ts
-var MANUS_API_BASE = "https://api.manus.ai/v2";
-
-// src/tools-ui-agent.ts
-async function createManusTask(apiKey, prompt, title, outputSchema) {
-  const body2 = {
-    message: { content: prompt },
-    agent_profile: "manus-1.6-lite",
-    hide_in_task_list: true,
-    interactive_mode: false,
-    title
-  };
-  if (outputSchema) {
-    body2.structured_output_schema = outputSchema;
-  }
-  const res = await fetch(`${MANUS_API_BASE}/task.create`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body2)
-  });
-  return await res.json();
-}
-var OCS_DASHBOARD_DEFAULT = "https://ocs.esimvault.cloud";
-function noCredentialsError() {
+// src/ui-agent-stub.ts
+var REMOTE_MCP_URL = "https://mcp.carrier.llc/mcp";
+var REASON_TEXT = {
+  ocs_portal_credentials: "drives the OCS web dashboard, which needs OCS portal login credentials. Those are stored in Clerk private metadata and read through the Clerk Backend API, which the local CLI has no secret for.",
+  recurring_runtime: "needs a recurring runtime. Browser Use Cloud has no native scheduler, so the hosted Worker implements schedules with KV plus a Cloudflare Cron Trigger and leader election. A CLI process exits when the client disconnects, so a schedule created here would never fire."
+};
+function uiAgentStubError(toolName, reason) {
   return {
     isError: true,
     content: [
       {
         type: "text",
         text: JSON.stringify({
-          error: "ocs_portal_not_linked",
-          message: "OCS portal credentials are not configured. An organisation admin must link their OCS portal login via the Carrier Console settings page (Organisation Profile \u2192 OCS Portal) before UI-agent operations can be dispatched.",
-          action: "Navigate to https://console.carrier.llc/settings and link your OCS portal credentials."
+          error: "requires_worker_runtime",
+          tool: toolName,
+          reason,
+          message: `${toolName} ${REASON_TEXT[reason]} Connect to the remote Carrier MCP Worker to use this tool. Generic web browsing (ui_agent_ask / ui_agent_status) does work locally \u2014 set BROWSER_USE_API_KEY.`,
+          remote_url: REMOTE_MCP_URL
         })
       }
     ]
   };
 }
-function noManusKeyError() {
+
+// src/portal-credentials.ts
+var PORTAL_OPT_IN_ENV = "CARRIER_ALLOW_PORTAL_PASSWORD";
+var PORTAL_USERNAME_ENV = "CARRIER_OCS_PORTAL_USERNAME";
+var PORTAL_PASSWORD_ENV = "CARRIER_OCS_PORTAL_PASSWORD";
+var PORTAL_DASHBOARD_ENV = "CARRIER_OCS_DASHBOARD_URL";
+var PORTAL_PASSWORD_WARNING = [
+  `${PORTAL_OPT_IN_ENV} is set: the ten OCS-dashboard tools will use the portal login in`,
+  `${PORTAL_USERNAME_ENV} / ${PORTAL_PASSWORD_ENV}.`,
+  "",
+  "That password is full dashboard access, not a scoped API token. Held in an environment",
+  "variable it is readable from shell history, from `ps` output by any process on this",
+  "machine, and from CI logs if this runs in CI. Carrier never logs it, returns it in tool",
+  "output, or writes it to an audit row, but it is sent to Browser Use Cloud, which types it",
+  "into the OCS login form.",
+  "",
+  "Each dashboard run also costs roughly $0.20-1.00 against your own BROWSER_USE_API_KEY.",
+  "",
+  `Unset ${PORTAL_OPT_IN_ENV} to turn this off; the tools then refuse as they did before.`
+].join("\n");
+var PORTAL_PASSWORD_RUN_NOTE = `This run used the OCS portal password from ${PORTAL_PASSWORD_ENV}, enabled by ${PORTAL_OPT_IN_ENV}. That credential is full dashboard access and was sent to Browser Use Cloud to type into the OCS login form. It is not logged, audited or returned anywhere in this response.`;
+function flagSet(raw) {
+  if (raw === void 0) return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true";
+}
+function nonEmpty(raw) {
+  if (raw === void 0) return void 0;
+  return raw.length > 0 ? raw : void 0;
+}
+function readPortalOptIn(env = process.env) {
+  const flag = flagSet(env[PORTAL_OPT_IN_ENV]);
+  const username = nonEmpty(env[PORTAL_USERNAME_ENV]);
+  const password = nonEmpty(env[PORTAL_PASSWORD_ENV]);
+  const hasCredentials = username !== void 0 && password !== void 0;
+  if (flag && hasCredentials) {
+    return {
+      enabled: true,
+      credentials: { username, password },
+      ...nonEmpty(env[PORTAL_DASHBOARD_ENV]) ? { dashboardUrl: env[PORTAL_DASHBOARD_ENV] } : {}
+    };
+  }
+  if (flag) return { enabled: false, gap: "flag_without_credentials" };
+  if (hasCredentials)
+    return { enabled: false, gap: "credentials_without_flag" };
+  return { enabled: false, gap: "not_requested" };
+}
+function warnPortalOptIn(optIn, write = (line) => console.error(line)) {
+  if (optIn.enabled) {
+    write(PORTAL_PASSWORD_WARNING);
+    return;
+  }
+  if (optIn.gap === "flag_without_credentials") {
+    write(PORTAL_PASSWORD_WARNING);
+    write(
+      `${PORTAL_USERNAME_ENV} and ${PORTAL_PASSWORD_ENV} are not both set, so the OCS-dashboard tools stay disabled.`
+    );
+    return;
+  }
+  if (optIn.gap === "credentials_without_flag") {
+    write(
+      `${PORTAL_PASSWORD_ENV} is set but ${PORTAL_OPT_IN_ENV} is not, so the OCS-dashboard tools stay disabled and this portal password is unused. Unset it unless you mean to opt in.`
+    );
+  }
+}
+
+// src/ui-agent-runtime.ts
+function createMemoryStore() {
+  const map = /* @__PURE__ */ new Map();
   return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          error: "manus_api_not_configured",
-          message: "MANUS_API_KEY is not configured on this Carrier MCP deployment. UI-agent tools require a Manus API key to spawn browser automation agents. Contact your Carrier MCP administrator."
-        })
-      }
-    ]
+    async get(key) {
+      const hit = map.get(key);
+      if (!hit) return null;
+      if (hit.expiresAt !== null && Date.now() >= hit.expiresAt) {
+        map.delete(key);
+        return null;
+      }
+      return hit.value;
+    },
+    async put(key, value, options) {
+      const ttl = options?.expirationTtl;
+      map.set(key, {
+        value,
+        expiresAt: ttl === void 0 ? null : Date.now() + ttl * 1e3
+      });
+    },
+    async delete(key) {
+      map.delete(key);
+    }
   };
 }
-function buildLoginPreamble(dashboardUrl) {
-  return `STEP 1 \u2014 LOGIN:
-Navigate to ${dashboardUrl}/login (or the main page if no /login path).
-Enter the OCS portal username and password provided below.
-Wait for the dashboard to fully load after login.
-If already logged in (session cookie persists), skip to STEP 2.
-
-`;
+var DEFAULT_MAX_RUNS_PER_PROCESS = 10;
+var MAX_RUNS_ENV = "CARRIER_BROWSER_USE_MAX_RUNS";
+var SpendLimitError = class extends Error {
+  constructor(limit) {
+    super(
+      `Browser-agent run limit reached: ${limit} run(s) in this CLI session. Each run costs roughly $0.20-1.00 against your own BROWSER_USE_API_KEY. Raise it with ${MAX_RUNS_ENV}=<n>, or 0 to disable the browser agent entirely. Restarting the CLI resets the count.`
+    );
+    this.limit = limit;
+    this.name = "SpendLimitError";
+  }
+  limit;
+};
+function maxRunsPerProcess(env = process.env) {
+  const raw = env[MAX_RUNS_ENV];
+  if (raw === void 0 || raw.trim() === "") {
+    return DEFAULT_MAX_RUNS_PER_PROCESS;
+  }
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    return DEFAULT_MAX_RUNS_PER_PROCESS;
+  }
+  return parsed;
 }
-var UI_AGENT_RESULT_SCHEMA = {
-  type: "object",
-  properties: {
-    success: { type: "boolean", description: "Whether the operation completed successfully" },
-    summary: { type: "string", description: "Human-readable summary of what was done" },
-    entity_id: { type: "string", description: "ID of the created/modified entity (if applicable)" },
-    error_message: { type: "string", description: "Error description if the operation failed" },
-    screenshots_taken: { type: "number", description: "Number of screenshots captured during the operation" }
-  },
-  required: ["success", "summary"]
+var RunBudget = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  used = 0;
+  /** Consume one run, or throw. Call immediately before dispatching. */
+  reserve() {
+    if (this.used >= this.limit) throw new SpendLimitError(this.limit);
+    this.used += 1;
+  }
+  get remaining() {
+    return Math.max(0, this.limit - this.used);
+  }
+  get spent() {
+    return this.used;
+  }
 };
-function wrapUiAgentHandler(toolName, gapId, requiredScope, ctx, buildPrompt) {
-  return async (args) => {
-    const start = Date.now();
-    const isDryRun = args.dry_run === true;
-    if (!ctx.props.scope.includes(requiredScope)) {
-      ctx.audit({
-        tool_name: toolName,
-        ocs_method: `[ui-agent:${gapId}]`,
-        status: "scope_denied",
-        dry_run: false,
-        duration_ms: 0
-      });
-      return {
-        isError: true,
-        content: [
-          {
-            type: "text",
-            text: `Scope denied: tool '${toolName}' requires '${requiredScope}' scope. Your token has: [${ctx.props.scope.join(", ")}].`
-          }
-        ]
-      };
+function createUiAgentRuntime(processEnv = process.env) {
+  const apiKey2 = processEnv.BROWSER_USE_API_KEY;
+  const spend = { runs: 0, costUsd: 0 };
+  const audit2 = (row) => {
+    const cost = row.doubles?.[1];
+    if (typeof cost === "number" && cost > 0) {
+      spend.runs += 1;
+      spend.costUsd = Math.round((spend.costUsd + cost) * 1e6) / 1e6;
     }
-    if (!ctx.env.MANUS_API_KEY) {
-      return noManusKeyError();
-    }
-    const clerkUserId = ctx.props.sub.startsWith("clerk_") ? ctx.props.sub.slice(6) : void 0;
-    const creds = await getOcsPortalCredentials(ctx.env, ctx.props.org_id, clerkUserId);
-    if (!creds) {
-      return noCredentialsError();
-    }
-    const dashboardUrl = ctx.env.OCS_DASHBOARD_URL ?? OCS_DASHBOARD_DEFAULT;
-    const prompt = buildPrompt(args, dashboardUrl);
-    const fullPrompt = `You are a Carrier MCP UI automation agent. Your task is to perform an OCS dashboard operation that is not available via the OCS REST API.
-
-OCS PORTAL CREDENTIALS (use these to log in \u2014 NEVER include them in your output):
-  Username: ${creds.username}
-  Password: ${creds.password}
-
-` + buildLoginPreamble(dashboardUrl) + `STEP 2 \u2014 OPERATION:
-` + prompt + `
+  };
+  return {
+    env: {
+      ...apiKey2 ? { apiKey: apiKey2 } : {},
+      store: createMemoryStore(),
+      audit: audit2
+    },
+    budget: new RunBudget(maxRunsPerProcess(processEnv)),
+    spend,
+    configured: Boolean(apiKey2),
+    dispatchedTaskIds: /* @__PURE__ */ new Set()
+  };
+}
 
-STEP 3 \u2014 VERIFICATION:
-After completing the operation, verify the result by checking the dashboard shows the expected state.
-Take a screenshot of the final state for audit purposes.
-Report success or failure with a clear summary.`;
-    if (isDryRun) {
-      const redactedPrompt = fullPrompt.replaceAll(creds.password, "***REDACTED***").replaceAll(creds.username, "***REDACTED***");
+// src/tools-ui-agent.ts
+var UI_AGENT_TOOL_SCOPES = {
+  ui_create_steering_list: "write",
+  ui_build_steering_list: "write",
+  ui_set_account_steering_list: "write",
+  ui_request_reseller_relay_change: "write",
+  ui_create_account: "admin",
+  ui_create_destination_list: "write",
+  ui_edit_destination_list: "write",
+  ui_delete_destination_list: "admin",
+  ui_delete_package_template: "admin",
+  ui_edit_location_zone: "write",
+  ui_delete_location_zone: "admin"
+};
+var STDIO_NOTE_DISABLED = " Requires the remote Carrier MCP Worker deployment \u2014 the local CLI holds no OCS portal credentials.";
+var STDIO_NOTE_ENABLED = " Runs locally: CARRIER_ALLOW_PORTAL_PASSWORD is set and OCS portal credentials are supplied, so this drives the dashboard from this machine. Each run costs roughly $0.20-1.00 against your own BROWSER_USE_API_KEY and counts against CARRIER_BROWSER_USE_MAX_RUNS.";
+function stdioNote(optIn) {
+  return optIn.enabled ? STDIO_NOTE_ENABLED : STDIO_NOTE_DISABLED;
+}
+function portalStub(toolName) {
+  return uiAgentStubError(toolName, "ocs_portal_credentials");
+}
+function jsonResult(body2, isError = false) {
+  return {
+    ...isError ? { isError: true } : {},
+    content: [{ type: "text", text: JSON.stringify(body2, null, 2) }]
+  };
+}
+function wrapPortalHandler(toolName, gapId, requiredScope, ctx, runtime, optIn, buildPrompt) {
+  return async (args) => {
+    const start = Date.now();
+    const ocsMethod = `[ui-agent:${gapId}]`;
+    if (!ctx.props.scope.includes(requiredScope)) {
       ctx.audit({
         tool_name: toolName,
-        ocs_method: `[ui-agent:${gapId}]`,
-        status: "dry_run",
-        dry_run: true,
-        duration_ms: 0,
-        event_type: "ui_agent_dispatch"
+        ocs_method: ocsMethod,
+        status: "scope_denied",
+        dry_run: false,
+        duration_ms: 0
       });
       return {
+        isError: true,
         content: [
           {
             type: "text",
-            text: JSON.stringify({
-              dry_run: true,
-              tool: toolName,
-              gap_id: gapId,
-              agent_prompt_preview: redactedPrompt,
-              note: "No Manus agent was dispatched. Set dry_run=false to execute."
-            }, null, 2)
+            text: `Scope denied: tool '${toolName}' requires '${requiredScope}' scope. Your token has: [${ctx.props.scope.join(", ")}].`
           }
         ]
       };
     }
+    if (!optIn.enabled) return portalStub(toolName);
+    if (!browserUseConfigured(runtime.env)) {
+      return jsonResult(
+        {
+          error: "browser_use_not_configured",
+          tool: toolName,
+          message: "BROWSER_USE_API_KEY is not set, so the dashboard agent cannot run. Set it in the environment of the process running this MCP server. Runs are billed to that key at roughly $0.20-1.00 each."
+        },
+        true
+      );
+    }
+    const { credentials } = optIn;
+    const dashboardUrl = optIn.dashboardUrl ?? OCS_DASHBOARD_DEFAULT;
+    const redact = (text) => redactCredentials(text, credentials);
+    const fullPrompt = assembleUiAgentPrompt(
+      buildPrompt(args, dashboardUrl),
+      credentials,
+      dashboardUrl
+    );
+    if (args.dry_run === true) {
+      ctx.audit({
+        tool_name: toolName,
+        ocs_method: ocsMethod,
+        status: "dry_run",
+        dry_run: true,
+        duration_ms: 0,
+        event_type: "ui_agent_dispatch"
+      });
+      return jsonResult({
+        dry_run: true,
+        tool: toolName,
+        gap_id: gapId,
+        agent_prompt_preview: redact(fullPrompt),
+        runs_remaining_this_session: runtime.budget.remaining,
+        note: "No browser agent was dispatched. Set dry_run=false to execute.",
+        portal_password_note: PORTAL_PASSWORD_RUN_NOTE
+      });
+    }
+    try {
+      runtime.budget.reserve();
+    } catch (err7) {
+      if (err7 instanceof SpendLimitError) {
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: ocsMethod,
+          // The existing quota status, not a new one: AuditRow's status is a
+          // closed union shared with the Worker.
+          status: "quota_exceeded",
+          dry_run: false,
+          duration_ms: 0,
+          event_type: "ui_agent_dispatch"
+        });
+        return jsonResult(
+          { error: "run_limit_reached", message: err7.message },
+          true
+        );
+      }
+      throw err7;
+    }
     try {
-      const result2 = await createManusTask(
-        ctx.env.MANUS_API_KEY,
+      const result2 = await runUiAgent(
         fullPrompt,
-        `Carrier MCP UI Agent: ${toolName} (${gapId})`,
-        UI_AGENT_RESULT_SCHEMA
+        `Carrier CLI UI Agent: ${toolName} (${gapId})`,
+        runtime.env,
+        { ownerSub: ctx.props.sub, redact }
       );
-      if (!result2.ok || !result2.task_id) {
+      if (!result2.task_id) {
         ctx.audit({
           tool_name: toolName,
-          ocs_method: `[ui-agent:${gapId}]`,
+          ocs_method: ocsMethod,
           status: "error",
           dry_run: false,
           duration_ms: Date.now() - start,
           event_type: "ui_agent_dispatch"
         });
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: "manus_dispatch_failed",
-                message: result2.error?.message ?? "Failed to create Manus task",
-                code: result2.error?.code
-              })
-            }
-          ]
-        };
+        return jsonResult(
+          {
+            error: "steel_dispatch_failed",
+            message: "Failed to create a browser agent task"
+          },
+          true
+        );
       }
+      runtime.dispatchedTaskIds.add(result2.task_id);
       ctx.audit({
         tool_name: toolName,
-        ocs_method: `[ui-agent:${gapId}]`,
-        status: "ui_agent_dispatched",
+        ocs_method: ocsMethod,
+        status: result2.status === "error" ? "error" : "ui_agent_dispatched",
         dry_run: false,
         duration_ms: Date.now() - start,
         event_type: "ui_agent_dispatch",
         manus_task_id: result2.task_id
+        // AE blob position is the contract; the name is history
+      });
+      return jsonResult({
+        status: result2.status === "stopped" ? "ui_agent_completed" : result2.status === "waiting" ? "ui_agent_awaiting_input" : result2.status,
+        tool: toolName,
+        gap_id: gapId,
+        // Held still across the vendor swap and across transports: MCP clients
+        // and the console read these names.
+        steel_task_id: result2.task_id,
+        steel_session_viewer_url: result2.session_viewer_url,
+        // Redacted defensively. `runUiAgent` already applies the same redactor
+        // before the record is stored, so this is the second of two passes over
+        // the fields an agent can echo its instructions into. Field-by-field
+        // rather than over the serialised JSON: a password containing a quote
+        // or a backslash is escaped by JSON.stringify and would no longer match
+        // a plain substring replace.
+        result: result2.result ? {
+          ...result2.result,
+          summary: redact(result2.result.summary),
+          ...result2.result.entity_id !== void 0 ? { entity_id: redact(result2.result.entity_id) } : {},
+          ...result2.result.error_message !== void 0 ? { error_message: redact(result2.result.error_message) } : {}
+        } : void 0,
+        cost_usd: result2.spend?.costUsd,
+        session_spend_usd: runtime.spend.costUsd,
+        runs_remaining_this_session: runtime.budget.remaining,
+        note: "The run completed in-process \u2014 a local CLI has no background runtime, so this call blocked for its duration.",
+        portal_password_note: PORTAL_PASSWORD_RUN_NOTE
       });
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              status: "ui_agent_dispatched",
-              tool: toolName,
-              gap_id: gapId,
-              manus_task_id: result2.task_id,
-              manus_task_url: result2.task_url,
-              note: "A Manus browser automation agent has been dispatched to perform this operation on the OCS web dashboard. The agent will log in, execute the operation, and verify the result. You can track progress at the task URL above. Real-time completion updates arrive via webhook and are recorded in the audit log. The poll_endpoint below is provided for backward compatibility.",
-              webhook_status: "active",
-              poll_endpoint: `GET ${MANUS_API_BASE}/task.listMessages?task_id=${result2.task_id}&order=desc&limit=5`
-            }, null, 2)
-          }
-        ]
-      };
     } catch (err7) {
       ctx.audit({
         tool_name: toolName,
-        ocs_method: `[ui-agent:${gapId}]`,
+        ocs_method: ocsMethod,
         status: "error",
         dry_run: false,
         duration_ms: Date.now() - start,
@@ -5138,57 +5713,44 @@ Report success or failure with a clear summary.`;
         content: [
           {
             type: "text",
-            text: `Error dispatching UI agent: ${err7 instanceof Error ? err7.message : String(err7)}`
+            text: redact(
+              `Error dispatching the UI agent: ${err7 instanceof Error ? err7.message : String(err7)}`
+            )
           }
         ]
       };
     }
   };
 }
-var UI_AGENT_TOOL_SCOPES = {
-  ui_create_steering_list: "write",
-  ui_build_steering_list: "write",
-  ui_set_account_steering_list: "write",
-  ui_request_reseller_relay_change: "write",
-  ui_create_account: "admin",
-  ui_create_destination_list: "write",
-  ui_edit_destination_list: "write",
-  ui_delete_destination_list: "admin",
-  ui_delete_package_template: "admin",
-  ui_edit_location_zone: "write",
-  ui_delete_location_zone: "admin"
-};
-function registerAllUiAgentTools(server2, ctx) {
+function registerAllUiAgentTools(server2, ctx, runtime, optIn = readPortalOptIn()) {
+  const NOTE = stdioNote(optIn);
+  const gated = (toolName, gapId, scope, buildPrompt) => wrapPortalHandler(toolName, gapId, scope, ctx, runtime, optIn, buildPrompt);
   server2.registerTool(
     "ui_create_steering_list",
     {
       title: "Create Steering List (UI Agent)",
-      description: "Creates a new network steering list (OPLMN preference configuration) via the OCS web dashboard. This operation is not available via the OCS REST API. A Manus browser agent will be dispatched to perform the operation. Params: `name` (steering list name), `description` (optional). Returns: dispatch confirmation with Manus task ID for tracking.",
+      description: "Creates a new network steering list (OPLMN preference configuration) via the OCS web dashboard. This operation is not available via the OCS REST API. A browser agent is dispatched to perform the operation. Params: `name` (steering list name), `description` (optional)." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new steering list"),
         description: z4.string().optional().describe("Optional description for the steering list"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_steering_list",
       "G-01",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
-Create a new steering list with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + `Click the "Create" or "Add" button to create the steering list.
-After creation, note the new steering list ID from the dashboard.
-`
+      (args, dashboardUrl) => buildCreateSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_build_steering_list",
     {
       title: "Build Steering List (UI Agent)",
-      description: "Adds or removes operators (MCC-MNC) from an existing steering list via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `steering_list_id`, `add_operators` (array of MCC-MNC to add), `remove_operators` (array to remove), `operator_type` ('priority' or 'excluded').",
+      description: "Adds or removes operators (MCC-MNC) from an existing steering list via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `steering_list_id`, `add_operators` (array of MCC-MNC to add), `remove_operators` (array to remove), `operator_type` ('priority' or 'excluded')." + NOTE,
       inputSchema: {
         steering_list_id: z4.number().describe("ID of the steering list to modify"),
         add_operators: z4.array(z4.string()).optional().describe("MCC-MNC codes to add (e.g. ['20801', '26201'])"),
@@ -5197,42 +5759,35 @@ After creation, note the new steering list ID from the dashboard.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_build_steering_list",
       "G-02",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
-Open steering list ID ${args.steering_list_id} for editing.
-Operator type: ${args.operator_type ?? "priority"}
-` + (args.add_operators && args.add_operators.length > 0 ? `Add the following operators: ${args.add_operators.join(", ")}
-` : "") + (args.remove_operators && args.remove_operators.length > 0 ? `Remove the following operators: ${args.remove_operators.join(", ")}
-` : "") + `Save the changes and verify the updated operator list.
-`
+      (args, dashboardUrl) => buildBuildSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_set_account_steering_list",
     {
       title: "Set Account Steering List (UI Agent)",
-      description: "Assigns or removes a steering list at the account level via the OCS web dashboard. The subscriber-level counterpart `modify_subscriber_steering_list` is available via API; this account-level operation is UI-only. Params: `account_id`, `steering_list_id` (0 to remove).",
+      description: "Assigns or removes a steering list at the account level via the OCS web dashboard. The subscriber-level counterpart `modify_subscriber_steering_list` is available via API; this account-level operation is UI-only. Params: `account_id`, `steering_list_id` (0 to remove)." + NOTE,
       inputSchema: {
         account_id: z4.number().describe("Account ID to assign the steering list to"),
         steering_list_id: z4.number().describe("Steering list ID to assign (0 to remove/unset)"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_set_account_steering_list",
       "G-03",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
-Open account ID ${args.account_id}.
-` + (args.steering_list_id === 0 ? `Remove/unset the steering list assignment from this account.
-` : `Assign steering list ID ${args.steering_list_id} to this account.
-`) + `Save the changes and verify the steering list assignment is updated.
-`
+      (args, dashboardUrl) => buildSetAccountSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
@@ -5252,7 +5807,12 @@ Open account ID ${args.account_id}.
       if (!ctx.props.scope.includes("write")) {
         return {
           isError: true,
-          content: [{ type: "text", text: "Scope denied: tool 'ui_request_reseller_relay_change' requires 'write' scope." }]
+          content: [
+            {
+              type: "text",
+              text: "Scope denied: tool 'ui_request_reseller_relay_change' requires 'write' scope."
+            }
+          ]
         };
       }
       const resellerId = args.reseller_id ?? ctx.props.reseller_id;
@@ -5264,7 +5824,15 @@ Open account ID ${args.account_id}.
       if (requested.length === 0) {
         return {
           isError: true,
-          content: [{ type: "text", text: JSON.stringify({ error: "relay_state_required", message: "Choose at least one relay flag and desired state." }) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "relay_state_required",
+                message: "Choose at least one relay flag and desired state."
+              })
+            }
+          ]
         };
       }
       const draft = [
@@ -5284,14 +5852,23 @@ Open account ID ${args.account_id}.
         event_type: "ui_agent_dispatch"
       });
       return {
-        content: [{ type: "text", text: JSON.stringify({
-          status: "parent_request_drafted",
-          capability: "parent_controlled",
-          reseller_id: resellerId,
-          parent_reseller: resellerId === 1170 ? "Bridge4IP" : "parent reseller/support",
-          draft,
-          sent: false
-        }, null, 2) }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "parent_request_drafted",
+                capability: "parent_controlled",
+                reseller_id: resellerId,
+                parent_reseller: resellerId === 1170 ? "Bridge4IP" : "parent reseller/support",
+                draft,
+                sent: false
+              },
+              null,
+              2
+            )
+          }
+        ]
       };
     }
   );
@@ -5299,7 +5876,7 @@ Open account ID ${args.account_id}.
     "ui_create_account",
     {
       title: "Create Account (UI Agent)",
-      description: "Creates a new sub-account under the reseller via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `name` (account name), `description` (optional), `initial_balance` (optional, default 0).",
+      description: "Creates a new sub-account under the reseller via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `name` (account name), `description` (optional), `initial_balance` (optional, default 0)." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new account"),
         description: z4.string().optional().describe("Optional description"),
@@ -5307,26 +5884,21 @@ Open account ID ${args.account_id}.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_account",
       "G-05",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
-Create a new account with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + (args.initial_balance ? `  Initial balance: ${args.initial_balance}
-` : "") + `Click the "Create" or "Add" button.
-After creation, note the new account ID from the dashboard.
-`
+      (args, dashboardUrl) => buildCreateAccountPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_create_destination_list",
     {
       title: "Create Destination List (UI Agent)",
-      description: "Creates a new destination list (named set of phone number prefixes for MOC call permissions) via the OCS web dashboard. Params: `name`, `prefixes` (array of prefix strings), `description`.",
+      description: "Creates a new destination list (named set of phone number prefixes for MOC call permissions) via the OCS web dashboard. Params: `name`, `prefixes` (array of prefix strings), `description`." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new destination list"),
         prefixes: z4.array(z4.string()).optional().describe("Phone number prefixes to include (e.g. ['+31', '+49'])"),
@@ -5334,25 +5906,21 @@ After creation, note the new account ID from the dashboard.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_destination_list",
       "G-12",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Create a new destination list with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + (args.prefixes && args.prefixes.length > 0 ? `  Prefixes to add: ${args.prefixes.join(", ")}
-` : "") + `Save the new destination list and note the ID.
-`
+      (args, dashboardUrl) => buildCreateDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_edit_destination_list",
     {
       title: "Edit Destination List (UI Agent)",
-      description: "Edits an existing destination list via the OCS web dashboard. Params: `destination_list_id`, `add_prefixes`, `remove_prefixes`, `new_name`.",
+      description: "Edits an existing destination list via the OCS web dashboard. Params: `destination_list_id`, `add_prefixes`, `remove_prefixes`, `new_name`." + NOTE,
       inputSchema: {
         destination_list_id: z4.number().describe("ID of the destination list to edit"),
         add_prefixes: z4.array(z4.string()).optional().describe("Prefixes to add"),
@@ -5361,69 +5929,61 @@ Create a new destination list with the following details:
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_edit_destination_list",
       "G-12",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Open destination list ID ${args.destination_list_id} for editing.
-` + (args.new_name ? `Rename to: ${args.new_name}
-` : "") + (args.add_prefixes && args.add_prefixes.length > 0 ? `Add prefixes: ${args.add_prefixes.join(", ")}
-` : "") + (args.remove_prefixes && args.remove_prefixes.length > 0 ? `Remove prefixes: ${args.remove_prefixes.join(", ")}
-` : "") + `Save the changes and verify the updated prefix list.
-`
+      (args, dashboardUrl) => buildEditDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_destination_list",
     {
       title: "Delete Destination List (UI Agent)",
-      description: "Deletes a destination list via the OCS web dashboard. Params: `destination_list_id`. WARNING: This is destructive and cannot be undone.",
+      description: "Deletes a destination list via the OCS web dashboard. Params: `destination_list_id`. WARNING: This is destructive and cannot be undone." + NOTE,
       inputSchema: {
         destination_list_id: z4.number().describe("ID of the destination list to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_destination_list",
       "G-12",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Find destination list ID ${args.destination_list_id}.
-Delete this destination list. Confirm the deletion when prompted.
-Verify the list no longer appears in the dashboard.
-`
+      (args, dashboardUrl) => buildDeleteDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_package_template",
     {
       title: "Delete Package Template (UI Agent)",
-      description: "Deletes a package template from the product catalog via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `template_id`. WARNING: This is destructive.",
+      description: "Deletes a package template from the product catalog via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `template_id`. WARNING: This is destructive." + NOTE,
       inputSchema: {
         template_id: z4.number().describe("ID of the package template to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_package_template",
       "G-18",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Package Templates section of the OCS dashboard at ${dashboardUrl}.
-Find package template ID ${args.template_id}.
-Delete this package template. Confirm the deletion when prompted.
-Verify the template no longer appears in the template list.
-`
+      (args, dashboardUrl) => buildDeletePackageTemplatePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_edit_location_zone",
     {
       title: "Edit Location Zone (UI Agent)",
-      description: "Edits an existing location zone via the OCS web dashboard. `create_location_zone` is available via API; edit is UI-only. Params: `zone_id`, `new_name`, `add_countries`, `remove_countries`.",
+      description: "Edits an existing location zone via the OCS web dashboard. `create_location_zone` is available via API; edit is UI-only. Params: `zone_id`, `new_name`, `add_countries`, `remove_countries`." + NOTE,
       inputSchema: {
         zone_id: z4.number().describe("ID of the location zone to edit"),
         new_name: z4.string().optional().describe("Rename the location zone"),
@@ -5432,137 +5992,40 @@ Verify the template no longer appears in the template list.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_edit_location_zone",
       "G-19",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
-Open location zone ID ${args.zone_id} for editing.
-` + (args.new_name ? `Rename to: ${args.new_name}
-` : "") + (args.add_countries && args.add_countries.length > 0 ? `Add countries: ${args.add_countries.join(", ")}
-` : "") + (args.remove_countries && args.remove_countries.length > 0 ? `Remove countries: ${args.remove_countries.join(", ")}
-` : "") + `Save the changes and verify the updated country list.
-`
+      (args, dashboardUrl) => buildEditLocationZonePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_location_zone",
     {
       title: "Delete Location Zone (UI Agent)",
-      description: "Deletes a location zone via the OCS web dashboard. `create_location_zone` is available via API; delete is UI-only. Params: `zone_id`. WARNING: Zones in use by active templates may not be deletable.",
+      description: "Deletes a location zone via the OCS web dashboard. `create_location_zone` is available via API; delete is UI-only. Params: `zone_id`. WARNING: Zones in use by active templates may not be deletable." + NOTE,
       inputSchema: {
         zone_id: z4.number().describe("ID of the location zone to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_location_zone",
       "G-19",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
-Find location zone ID ${args.zone_id}.
-Delete this location zone. Confirm the deletion when prompted.
-If the dashboard shows an error (e.g. zone in use by active templates), report the error.
-Verify the zone no longer appears in the zone list.
-`
+      (args, dashboardUrl) => buildDeleteLocationZonePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
 }
 
 // src/tools-ui-agent-ask.ts
 import { z as z5 } from "zod";
-
-// src/manus-webhook.ts
-var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
-var DEDUP_TTL_SECONDS = 7 * 24 * 3600;
-var PENDING_ASK_TTL_SECONDS = 24 * 3600;
-var PENDING_ASK_PREFIX = "manus_pending_ask:";
-
-// src/manus-client.ts
-var MANUS_API_BASE2 = "https://api.manus.ai/v2";
-function getManusKeys(env) {
-  if (!env.MANUS_API_KEY) return null;
-  return {
-    primary: env.MANUS_API_KEY,
-    fallback: env.MANUS_API_KEY_FALLBACK
-  };
-}
-var FALLBACK_TRIGGER_CODES = /* @__PURE__ */ new Set([401, 403, 429]);
-var ManusApiError = class extends Error {
-  constructor(message, httpStatus, manusError, keyUsed, bothFailed) {
-    super(message);
-    this.httpStatus = httpStatus;
-    this.manusError = manusError;
-    this.keyUsed = keyUsed;
-    this.bothFailed = bothFailed;
-    this.name = "ManusApiError";
-  }
-  httpStatus;
-  manusError;
-  keyUsed;
-  bothFailed;
-};
-async function withFallback(fn, keys) {
-  const primaryResult = await fn(keys.primary);
-  if (!FALLBACK_TRIGGER_CODES.has(primaryResult._httpStatus)) {
-    return { ...primaryResult, key_used: "primary" };
-  }
-  if (!keys.fallback) {
-    throw new ManusApiError(
-      `Manus API request failed: HTTP ${primaryResult._httpStatus}`,
-      primaryResult._httpStatus,
-      void 0,
-      "primary",
-      false
-    );
-  }
-  const fallbackResult = await fn(keys.fallback);
-  if (!FALLBACK_TRIGGER_CODES.has(fallbackResult._httpStatus)) {
-    return { ...fallbackResult, key_used: "fallback" };
-  }
-  throw new ManusApiError(
-    `Manus API request failed with both keys: HTTP ${fallbackResult._httpStatus}`,
-    fallbackResult._httpStatus,
-    void 0,
-    "fallback",
-    true
-  );
-}
-async function manusPost(path, apiKey, body2) {
-  const res = await fetch(`${MANUS_API_BASE2}/${path}`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body2)
-  });
-  const data = await res.json();
-  return { _httpStatus: res.status, data, key_used: "primary" };
-}
-async function sendMessage(keys, taskId, content, opts) {
-  const message = { content };
-  if (opts?.connectors?.length) message.connectors = opts.connectors;
-  if (opts?.enableSkills?.length) message.enable_skills = opts.enableSkills;
-  if (opts?.forceSkills?.length) message.force_skills = opts.forceSkills;
-  const body2 = {
-    task_id: taskId,
-    message
-  };
-  if (opts?.agentProfile) body2.agent_profile = opts.agentProfile;
-  if (opts?.outputSchema) body2.structured_output_schema = opts.outputSchema;
-  return withFallback(
-    (apiKey) => manusPost("task.sendMessage", apiKey, body2),
-    keys
-  );
-}
-async function askReply(keys, taskId, reply) {
-  return sendMessage(keys, taskId, reply);
-}
-
-// src/tools-ui-agent-ask.ts
 var UI_AGENT_ASK_TOOL_SCOPES = {
   ui_agent_reply: "write",
   ui_agent_list_pending: "read"
@@ -5572,12 +6035,23 @@ function computeExpiresAt(askedAt) {
   if (isNaN(asked)) return "";
   return new Date(asked + PENDING_ASK_TTL_SECONDS * 1e3).toISOString();
 }
-async function callerOwnsTask(ctx, taskId) {
-  let raw;
+var emptyStore = {
+  get: async () => null,
+  put: async () => void 0,
+  delete: async () => void 0
+};
+async function callerOwnsTask(ctx, taskId, fallback) {
+  const key = `steel_task:${taskId}`;
+  let raw = null;
   try {
-    raw = await ctx.env.CARRIER_USERS.get(`steel_task:${taskId}`);
+    raw = await ctx.env.CARRIER_USERS.get(key);
   } catch {
-    return false;
+    if (!fallback) return false;
+    try {
+      raw = await fallback.get(key);
+    } catch {
+      return false;
+    }
   }
   if (!raw) return false;
   try {
@@ -5587,15 +6061,26 @@ async function callerOwnsTask(ctx, taskId) {
     return false;
   }
 }
-function registerUiAgentAskTools(server2, ctx) {
+function listableBinding(ctx) {
+  const kv = ctx.env.CARRIER_USERS;
+  return kv && typeof kv.list === "function" ? kv : null;
+}
+function registerUiAgentAskTools(server2, ctx, runtime) {
+  const sharedEnv = () => ({
+    ...runtime?.env.apiKey ? { apiKey: runtime.env.apiKey } : {},
+    store: ctx.env.CARRIER_USERS ?? runtime?.env.store ?? emptyStore,
+    audit: runtime?.env.audit ?? (() => void 0)
+  });
   server2.registerTool(
     "ui_agent_reply",
     {
       title: "Reply to Paused UI Agent Task",
-      description: "Resumes a Manus browser automation task that paused with stop_reason 'ask'. Use ui_agent_list_pending to find tasks waiting for input. Provide the task_id and your reply (e.g. a 2FA code, a field value, or a yes/no answer). The reply content is never recorded in audit logs \u2014 only its length is logged.",
+      description: "Resumes a browser automation task that paused to ask a question. Use ui_agent_list_pending to find tasks waiting for input. Provide the task_id and your reply (e.g. a 2FA code, a field value, or a yes/no answer). The reply content is never recorded in audit logs \u2014 only its length is logged.",
       inputSchema: {
-        task_id: z5.string().describe("Manus task ID to resume (from ui_agent_list_pending)"),
-        reply: z5.string().describe("Your answer to the agent's question (e.g. a 2FA code or confirmation)")
+        task_id: z5.string().describe("Task ID to resume (from ui_agent_list_pending)"),
+        reply: z5.string().describe(
+          "Your answer to the agent's question (e.g. a 2FA code or confirmation)"
+        )
       }
     },
     async (args) => {
@@ -5619,24 +6104,14 @@ function registerUiAgentAskTools(server2, ctx) {
           ]
         };
       }
-      const keys = getManusKeys(ctx.env);
-      if (!keys) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                error: "manus_api_not_configured",
-                message: "MANUS_API_KEY is not configured on this deployment."
-              })
-            }
-          ]
-        };
+      const env = sharedEnv();
+      let pendingRaw = null;
+      try {
+        pendingRaw = await env.store.get(`${PENDING_ASK_PREFIX}${task_id}`);
+      } catch {
+        pendingRaw = null;
       }
-      const pendingKey = `${PENDING_ASK_PREFIX}${task_id}`;
-      const pendingRaw = await ctx.env.CARRIER_USERS.get(pendingKey);
-      if (pendingRaw === null || !await callerOwnsTask(ctx, task_id)) {
+      if (pendingRaw === null || !await callerOwnsTask(ctx, task_id, runtime?.env.store)) {
         return {
           isError: true,
           content: [
@@ -5650,75 +6125,42 @@ function registerUiAgentAskTools(server2, ctx) {
           ]
         };
       }
-      let result2;
-      try {
-        const replyOutcome = await askReply(keys, task_id, reply);
-        result2 = replyOutcome.data;
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_reply",
-          ocs_method: "[ui-agent:ask-reply]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_resume",
-          manus_task_id: task_id
-        });
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: `Error calling Manus task.reply: ${err7 instanceof Error ? err7.message : String(err7)}`
-            }
-          ]
-        };
-      }
-      if (!result2.ok) {
-        ctx.audit({
-          tool_name: "ui_agent_reply",
-          ocs_method: "[ui-agent:ask-reply]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_resume",
-          manus_task_id: task_id
-        });
+      const outcome = await resumeUiAgentTask(task_id, reply, env);
+      ctx.audit({
+        tool_name: "ui_agent_reply",
+        ocs_method: "[ui-agent:ask-reply]",
+        status: outcome.ok ? "ui_agent_resumed" : "error",
+        dry_run: false,
+        duration_ms: Date.now() - start,
+        event_type: "ui_agent_resume"
+      });
+      if (!outcome.ok) {
         return {
           isError: true,
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                error: "manus_reply_failed",
-                message: result2.error?.message ?? "Manus task.reply returned ok=false",
-                code: result2.error?.code,
-                task_id
+                error: "resume_failed",
+                message: outcome.error ?? "The task could not be resumed."
               })
             }
           ]
         };
       }
-      ctx.audit({
-        tool_name: "ui_agent_reply",
-        ocs_method: "[ui-agent:ask-reply]",
-        status: "ui_agent_resumed",
-        dry_run: false,
-        duration_ms: Date.now() - start,
-        event_type: "ui_agent_resume",
-        manus_task_id: task_id
-      });
-      await ctx.env.CARRIER_USERS.delete(pendingKey);
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify({
-              status: "resumed",
-              task_id,
-              reply_length: reply.length,
-              message: "The Manus agent has received your reply and is continuing the task. The task will emit a task_stopped webhook when complete."
-            }, null, 2)
+            text: JSON.stringify(
+              {
+                status: "ui_agent_resumed",
+                task_id,
+                reply_length: reply.length
+              },
+              null,
+              2
+            )
           }
         ]
       };
@@ -5728,7 +6170,7 @@ function registerUiAgentAskTools(server2, ctx) {
     "ui_agent_list_pending",
     {
       title: "List Pending UI Agent Tasks (Waiting for Input)",
-      description: "Returns all Manus browser automation tasks that are currently paused waiting for human input (stop_reason 'ask'). Shows the agent's question, task URL, and when it was asked. Entries expire after 24 hours. Use ui_agent_reply to resume a task.",
+      description: "Returns browser automation tasks currently paused waiting for human input. Shows the agent's question, task URL, and when it was asked. Entries expire after 24 hours. Use ui_agent_reply to resume a task.",
       inputSchema: {}
     },
     async () => {
@@ -5743,61 +6185,61 @@ function registerUiAgentAskTools(server2, ctx) {
           ]
         };
       }
-      let keys;
-      try {
-        const listing = await ctx.env.CARRIER_USERS.list({ prefix: PENDING_ASK_PREFIX });
-        keys = listing.keys;
-      } catch (err7) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: `Error listing pending tasks: ${err7 instanceof Error ? err7.message : String(err7)}`
-            }
-          ]
-        };
-      }
-      if (keys.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                pending_tasks: [],
-                count: 0,
-                message: "No Manus tasks are currently waiting for input."
-              }, null, 2)
-            }
-          ]
-        };
+      const kv = listableBinding(ctx);
+      let taskIds;
+      if (kv) {
+        try {
+          const listing = await kv.list({ prefix: PENDING_ASK_PREFIX });
+          taskIds = listing.keys.map(
+            (k) => k.name.slice(PENDING_ASK_PREFIX.length)
+          );
+        } catch (err7) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Error listing pending tasks: ${err7 instanceof Error ? err7.message : String(err7)}`
+              }
+            ]
+          };
+        }
+      } else {
+        taskIds = [...runtime?.dispatchedTaskIds ?? []];
       }
+      const store = sharedEnv().store;
       const entries = await Promise.all(
-        keys.map(async ({ name }) => {
-          const raw = await ctx.env.CARRIER_USERS.get(name);
+        taskIds.map(async (taskId) => {
+          let raw;
+          try {
+            raw = await store.get(`${PENDING_ASK_PREFIX}${taskId}`);
+          } catch {
+            return null;
+          }
           if (!raw) return null;
+          if (!await callerOwnsTask(ctx, taskId, runtime?.env.store)) {
+            return null;
+          }
           try {
             const parsed = JSON.parse(raw);
-            const taskId = parsed.task_id ?? name.slice(PENDING_ASK_PREFIX.length);
-            if (!await callerOwnsTask(ctx, taskId)) return null;
-            return {
-              ...parsed,
-              expires_at: computeExpiresAt(parsed.asked_at)
-            };
+            return { ...parsed, expires_at: computeExpiresAt(parsed.asked_at) };
           } catch {
             return null;
           }
         })
       );
-      const validEntries = entries.filter((e) => e !== null);
+      const validEntries = entries.filter(
+        (e) => e !== null
+      );
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify({
-              pending_tasks: validEntries,
-              count: validEntries.length
-            }, null, 2)
+            text: JSON.stringify(
+              { pending_tasks: validEntries, count: validEntries.length },
+              null,
+              2
+            )
           }
         ]
       };
@@ -5807,277 +6249,6 @@ function registerUiAgentAskTools(server2, ctx) {
 
 // src/tools-ui-agent-schedule.ts
 import { z as z6 } from "zod";
-
-// src/manus-schedule.ts
-var ManusScheduleError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "ManusScheduleError";
-  }
-  statusCode;
-};
-function expandCronMinuteField(minuteField) {
-  if (minuteField === "*" || minuteField.includes(" ")) {
-    return null;
-  }
-  const tokens = minuteField.split(",").map((t) => t.trim()).filter(Boolean);
-  const set = /* @__PURE__ */ new Set();
-  for (const token2 of tokens) {
-    const stepWildcard = /^[*]\/(\d+)$/.exec(token2);
-    if (stepWildcard) {
-      const step = parseInt(stepWildcard[1] ?? "0", 10);
-      if (step < 1) return null;
-      for (let m = 0; m < 60; m += step) set.add(m);
-      continue;
-    }
-    const rangeWithStep = /^(\d+)-(\d+)\/(\d+)$/.exec(token2);
-    if (rangeWithStep) {
-      const start = parseInt(rangeWithStep[1] ?? "0", 10);
-      const end = parseInt(rangeWithStep[2] ?? "0", 10);
-      const step = parseInt(rangeWithStep[3] ?? "0", 10);
-      if (step < 1 || start > end) return null;
-      for (let m = start; m <= end; m += step) set.add(m);
-      continue;
-    }
-    const rangeOnly = /^(\d+)-(\d+)$/.exec(token2);
-    if (rangeOnly) {
-      const start = parseInt(rangeOnly[1] ?? "0", 10);
-      const end = parseInt(rangeOnly[2] ?? "0", 10);
-      if (start > end) return null;
-      for (let m = start; m <= end; m++) set.add(m);
-      continue;
-    }
-    const single = /^(\d+)$/.exec(token2);
-    if (single) {
-      set.add(parseInt(single[1] ?? "0", 10));
-      continue;
-    }
-    return null;
-  }
-  const arr = Array.from(set).sort((a, b) => a - b);
-  for (const v of arr) {
-    if (v < 0 || v > 59) return null;
-  }
-  return arr;
-}
-function minuteFieldViolatesFiveMinuteRule(minuteField, fullCron) {
-  const minutes = expandCronMinuteField(minuteField);
-  if (minutes === null) {
-    return `Cron expression rejected: unrecognized or unsupported minute field '${minuteField}'. Minimum interval is 5 minutes; use lists, ranges with step \u2265 5, or */5 or higher.`;
-  }
-  if (minutes.length === 0) {
-    return `Cron expression rejected: minute field '${minuteField}' expands to no valid minutes.`;
-  }
-  if (minutes.length === 1) {
-    return null;
-  }
-  for (let i = 1; i < minutes.length; i++) {
-    const gap = (minutes[i] ?? 0) - (minutes[i - 1] ?? 0);
-    if (gap < 5) {
-      return `Cron expression rejected: '${fullCron}' implies a ${gap}-minute gap in the minute field. Minimum allowed interval is 5 minutes.`;
-    }
-  }
-  const wrapGap = 60 - (minutes[minutes.length - 1] ?? 0) + (minutes[0] ?? 0);
-  if (wrapGap < 5) {
-    return `Cron expression rejected: '${fullCron}' implies a ${wrapGap}-minute wraparound gap in the minute field. Minimum allowed interval is 5 minutes.`;
-  }
-  return null;
-}
-function validateCron(cron) {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    return `Invalid cron expression: expected 5 fields (minute hour day month weekday), got ${parts.length}.`;
-  }
-  const [minuteField] = parts;
-  if (minuteField === "*") {
-    return "Cron expression rejected: '* * * * *' runs every minute. Minimum allowed interval is 5 minutes.";
-  }
-  return minuteFieldViolatesFiveMinuteRule(minuteField ?? "", cron);
-}
-async function createSchedule(apiKey, params) {
-  const body2 = {
-    name: params.name,
-    cron: params.cron,
-    prompt_template: params.prompt_template,
-    agent_profile: params.agent_profile ?? "manus-1.6-lite",
-    interactive_mode: false,
-    hide_in_task_list: false
-  };
-  const res = await fetch(`${MANUS_API_BASE}/schedule.create`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body2)
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.create failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function listSchedules(apiKey) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.list`, {
-    headers: { "x-manus-api-key": apiKey }
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.list failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  const data = await res.json();
-  if (Array.isArray(data)) {
-    return { ok: true, schedules: data };
-  }
-  return data;
-}
-async function deleteSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.delete`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.delete failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function pauseSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.pause`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.pause failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function resumeSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.resume`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.resume failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-
-// src/manus-usage.ts
-var ManusUsageError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "ManusUsageError";
-  }
-  statusCode;
-};
-var CACHE_KEY = "manus_usage_cache";
-var CACHE_TTL_SECONDS = 60;
-var USAGE_THRESHOLD_WARNING = 1e3;
-var USAGE_THRESHOLD_CRITICAL = 100;
-async function fetchUsageFromApi(apiKey) {
-  const now = /* @__PURE__ */ new Date();
-  const month = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
-  const [usageRes, creditsRes] = await Promise.all([
-    fetch(`${MANUS_API_BASE}/usage.get`, {
-      headers: { "x-manus-api-key": apiKey }
-    }),
-    fetch(`${MANUS_API_BASE}/credits.get`, {
-      headers: { "x-manus-api-key": apiKey }
-    })
-  ]);
-  if (!usageRes.ok && !creditsRes.ok) {
-    throw new ManusUsageError(
-      `Manus usage APIs failed: usage.get HTTP ${usageRes.status}, credits.get HTTP ${creditsRes.status}`,
-      Math.max(usageRes.status, creditsRes.status)
-    );
-  }
-  let spentCredits = 0;
-  let remainingCredits = 0;
-  let taskCount = 0;
-  if (usageRes.ok) {
-    const usageData = await usageRes.json();
-    spentCredits = usageData.spent_credits ?? usageData.credits_used ?? 0;
-    taskCount = usageData.task_count ?? usageData.tasks_run ?? 0;
-    if (usageData.remaining_credits !== void 0 || usageData.credits_remaining !== void 0) {
-      remainingCredits = usageData.remaining_credits ?? usageData.credits_remaining ?? 0;
-    }
-  }
-  if (creditsRes.ok) {
-    const creditsData = await creditsRes.json();
-    const fromCreditsApi = creditsData.remaining_credits ?? creditsData.credits_remaining ?? creditsData.balance;
-    if (fromCreditsApi !== void 0) {
-      remainingCredits = fromCreditsApi;
-    }
-  }
-  return { month, spent_credits: spentCredits, remaining_credits: remainingCredits, task_count: taskCount };
-}
-async function getUsage(apiKey, env) {
-  const cached = await env.CARRIER_USERS.get(CACHE_KEY, "json");
-  const nowMs = Date.now();
-  if (cached && nowMs - cached.fetched_at < CACHE_TTL_SECONDS * 1e3) {
-    return { data: cached.data, from_cache: true };
-  }
-  const data = await fetchUsageFromApi(apiKey);
-  await env.CARRIER_USERS.put(
-    CACHE_KEY,
-    JSON.stringify({ data, fetched_at: nowMs }),
-    { expirationTtl: CACHE_TTL_SECONDS }
-  );
-  return { data, from_cache: false };
-}
-function emitUsageThresholdIfNeeded(env, data) {
-  const { remaining_credits, month, task_count } = data;
-  if (remaining_credits < USAGE_THRESHOLD_CRITICAL) {
-    writeUsageThresholdAudit(env, "critical", remaining_credits, month, task_count);
-  } else if (remaining_credits < USAGE_THRESHOLD_WARNING) {
-    writeUsageThresholdAudit(env, "warning", remaining_credits, month, task_count);
-  }
-}
-function writeUsageThresholdAudit(env, severity, remainingCredits, month, taskCount) {
-  try {
-    env.AUDIT_LOG.writeDataPoint({
-      blobs: [
-        "manus_usage_threshold",
-        severity,
-        month,
-        String(taskCount)
-      ],
-      doubles: [remainingCredits],
-      indexes: ["manus_usage"]
-    });
-  } catch (err7) {
-    console.error(`[manus-usage] threshold audit write failed: ${err7.message}`);
-  }
-}
-
-// src/tools-ui-agent-schedule.ts
 var UI_AGENT_SCHEDULE_TOOL_SCOPES = {
   ui_agent_schedule_create: "admin",
   ui_agent_schedule_list: "read",
@@ -6086,20 +6257,7 @@ var UI_AGENT_SCHEDULE_TOOL_SCOPES = {
   ui_agent_schedule_resume: "admin",
   ui_agent_usage: "read"
 };
-function noManusKeyError2() {
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          error: "manus_api_not_configured",
-          message: "MANUS_API_KEY is not configured on this Carrier MCP deployment. Schedule and usage tools require a Manus API key. Contact your Carrier MCP administrator."
-        })
-      }
-    ]
-  };
-}
+var STDIO_NOTE = " Requires the remote Carrier MCP Worker deployment \u2014 a local CLI has no recurring runtime, so schedules cannot fire here.";
 function scopeError(toolName, required, actual) {
   return {
     isError: true,
@@ -6111,427 +6269,126 @@ function scopeError(toolName, required, actual) {
     ]
   };
 }
-function registerScheduleAndUsageTools(server2, ctx) {
+function scopeDenied(ctx, toolName, required) {
+  ctx.audit({
+    tool_name: toolName,
+    ocs_method: `[ui-agent:${toolName}]`,
+    status: "scope_denied",
+    dry_run: false,
+    duration_ms: 0
+  });
+  return scopeError(toolName, required, ctx.props.scope);
+}
+function registerScheduleAndUsageTools(server2, ctx, runtime) {
   server2.registerTool(
     "ui_agent_schedule_create",
     {
-      title: "Create Manus Schedule (UI Agent)",
-      description: "Creates a recurring Manus agent run on a cron schedule. Use this to automate periodic OCS audits, fleet health checks, or any recurring browser-automation task. Minimum interval: 5 minutes (*/1, */2, */3, */4 and '* * * * *' are rejected). Requires admin scope. Returns schedule_id.",
+      title: "Create UI Agent Schedule",
+      description: "Creates a recurring browser-agent run on a cron schedule, to automate periodic OCS audits, fleet health checks, or any recurring browser-automation task. Minimum interval: 5 minutes. Requires admin scope." + STDIO_NOTE,
       inputSchema: {
         name: z6.string().describe("Human-readable name for this schedule"),
         cron: z6.string().describe(
           "Standard 5-field cron expression (minute hour day month weekday). Minimum interval: 5 minutes. Example: '0 */6 * * *' = every 6 hours."
         ),
-        prompt_template: z6.string().describe("Agent prompt/task template the Manus agent will execute on each run"),
-        profile: z6.string().optional().describe("Manus agent profile to use. Defaults to 'manus-1.6-lite'.")
+        prompt_template: z6.string().describe(
+          "Agent prompt/task template the browser agent will execute on each run"
+        ),
+        profile: z6.string().optional().describe(
+          "Browser-agent profile to use. Defaults to the deployment's configured profile."
+        )
       }
     },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_create",
-          ocs_method: "[manus:schedule.create]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_create", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      const cronError = validateCron(args.cron);
-      if (cronError) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: JSON.stringify({ error: "invalid_cron", message: cronError }) }]
-        };
-      }
-      try {
-        const result2 = await createSchedule(ctx.env.MANUS_API_KEY, {
-          name: args.name,
-          cron: args.cron,
-          prompt_template: args.prompt_template,
-          agent_profile: args.profile
-        });
-        ctx.audit({
-          tool_name: "ui_agent_schedule_create",
-          ocs_method: "[manus:schedule.create]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok || !result2.schedule_id) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_create_failed",
-                  message: result2.error?.message ?? "Manus schedule.create returned ok=false",
-                  code: result2.error?.code
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                status: "created",
-                schedule_id: result2.schedule_id,
-                name: args.name,
-                cron: args.cron
-              }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_create",
-          ocs_method: "[manus:schedule.create]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
-      }
-    }
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_create", "admin") : uiAgentStubError("ui_agent_schedule_create", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_schedule_list",
     {
-      title: "List Manus Schedules",
-      description: "Lists all Manus recurring schedules configured for this API key. Returns schedule IDs, names, cron expressions, status (active/paused), and next/last run timestamps.",
-      inputSchema: {}
-    },
-    async () => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("read")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_list",
-          ocs_method: "[manus:schedule.list]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_list", "read", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await listSchedules(ctx.env.MANUS_API_KEY);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_list",
-          ocs_method: "[manus:schedule.list]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_list_failed",
-                  message: result2.error?.message ?? "Manus schedule.list returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ schedules: result2.schedules ?? [] }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_list",
-          ocs_method: "[manus:schedule.list]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
-      }
-    }
-  );
-  server2.registerTool(
-    "ui_agent_schedule_delete",
-    {
-      title: "Delete Manus Schedule",
-      description: "Permanently deletes a Manus recurring schedule. This cannot be undone. Use ui_agent_schedule_pause to temporarily suspend instead. Requires admin scope.",
-      inputSchema: {
-        schedule_id: z6.string().describe("ID of the schedule to delete")
-      }
-    },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_delete",
-          ocs_method: "[manus:schedule.delete]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_delete", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await deleteSchedule(ctx.env.MANUS_API_KEY, args.schedule_id);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_delete",
-          ocs_method: "[manus:schedule.delete]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_delete_failed",
-                  message: result2.error?.message ?? "Manus schedule.delete returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ status: "deleted", schedule_id: args.schedule_id }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_delete",
-          ocs_method: "[manus:schedule.delete]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
+      title: "List UI Agent Schedules",
+      description: "Lists all recurring browser-agent schedules configured for this deployment. Returns schedule IDs, names, cron expressions, status (active/paused), and next/last run timestamps." + STDIO_NOTE,
+      inputSchema: {}
+    },
+    async () => !ctx.props.scope.includes("read") ? scopeDenied(ctx, "ui_agent_schedule_list", "read") : uiAgentStubError("ui_agent_schedule_list", "recurring_runtime")
+  );
+  server2.registerTool(
+    "ui_agent_schedule_delete",
+    {
+      title: "Delete UI Agent Schedule",
+      description: "Permanently deletes a recurring browser-agent schedule. This cannot be undone. Use ui_agent_schedule_pause to temporarily suspend instead. Requires admin scope." + STDIO_NOTE,
+      inputSchema: {
+        schedule_id: z6.string().describe("ID of the schedule to delete")
       }
-    }
+    },
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_delete", "admin") : uiAgentStubError("ui_agent_schedule_delete", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_schedule_pause",
     {
-      title: "Pause Manus Schedule",
-      description: "Pauses an active Manus recurring schedule. The schedule is preserved and can be resumed later with ui_agent_schedule_resume. Requires admin scope.",
+      title: "Pause UI Agent Schedule",
+      description: "Pauses an active recurring browser-agent schedule. The schedule is preserved and can be resumed later with ui_agent_schedule_resume. Requires admin scope." + STDIO_NOTE,
       inputSchema: {
         schedule_id: z6.string().describe("ID of the schedule to pause")
       }
     },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_pause", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await pauseSchedule(ctx.env.MANUS_API_KEY, args.schedule_id);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_pause_failed",
-                  message: result2.error?.message ?? "Manus schedule.pause returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ status: "paused", schedule_id: args.schedule_id }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
-      }
-    }
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_pause", "admin") : uiAgentStubError("ui_agent_schedule_pause", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_schedule_resume",
     {
-      title: "Resume Manus Schedule",
-      description: "Resumes a paused Manus recurring schedule. Requires admin scope.",
+      title: "Resume UI Agent Schedule",
+      description: "Resumes a paused recurring browser-agent schedule. Requires admin scope." + STDIO_NOTE,
       inputSchema: {
         schedule_id: z6.string().describe("ID of the schedule to resume")
       }
     },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_resume", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await resumeSchedule(ctx.env.MANUS_API_KEY, args.schedule_id);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_resume_failed",
-                  message: result2.error?.message ?? "Manus schedule.resume returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ status: "active", schedule_id: args.schedule_id }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
-      }
-    }
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_resume", "admin") : uiAgentStubError("ui_agent_schedule_resume", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_usage",
     {
-      title: "Manus Usage & Credits",
-      description: "Returns current month Manus credit spend, remaining balance, and task count. Result is cached for 60 seconds in KV to avoid rate-limiting the Manus API. Emits an Analytics Engine event when remaining_credits drops below 1000 (warning) or 100 (critical). Use this to track Carrier's Manus credit burn.",
+      title: "UI Agent Usage & Spend",
+      description: "Reports browser-agent spend for the current CLI session: runs dispatched, real vendor-billed cost in USD, and how many runs remain under the session limit. This is a per-process figure, not an account total \u2014 it resets when the CLI restarts, and it cannot see runs billed to the same API key by other processes or by the hosted Worker. Check your Browser Use account for the authoritative balance. Requires read scope.",
       inputSchema: {}
     },
     async () => {
-      const start = Date.now();
       if (!ctx.props.scope.includes("read")) {
         ctx.audit({
           tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
+          ocs_method: "[ui-agent:usage]",
           status: "scope_denied",
           dry_run: false,
           duration_ms: 0
         });
-        return scopeError("ui_agent_usage", "read", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const { data, from_cache } = await getUsage(ctx.env.MANUS_API_KEY, ctx.env);
-        emitUsageThresholdIfNeeded(ctx.env, data);
-        ctx.audit({
-          tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
-          status: "ok",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
         return {
+          isError: true,
           content: [
             {
               type: "text",
-              text: JSON.stringify({ ...data, from_cache }, null, 2)
+              text: `Scope denied: tool 'ui_agent_usage' requires 'read' scope. Your token has: [${ctx.props.scope.join(", ")}].`
             }
           ]
         };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
-        const msg = err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
       }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                scope: "cli_session",
+                configured: runtime.configured,
+                runs_billed_this_session: runtime.spend.runs,
+                cost_usd_this_session: runtime.spend.costUsd,
+                runs_dispatched_this_session: runtime.budget.spent,
+                runs_remaining_this_session: runtime.budget.remaining,
+                run_limit_env: MAX_RUNS_ENV,
+                note: "Session-scoped. Resets when this CLI process exits and does not include runs billed to the same key elsewhere. The authoritative balance is in your Browser Use account."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
     }
   );
 }
@@ -12233,43 +12090,228 @@ function registerGreenzoneTools(server2, ctx) {
 
 // src/tools-ui-agent-generic.ts
 import { z as z22 } from "zod";
-var STDIO_ERROR = {
-  isError: true,
-  content: [
-    {
-      type: "text",
-      text: JSON.stringify({
-        error: "requires_worker_runtime",
-        message: "ui_agent_ask and ui_agent_status require the remote Carrier MCP Worker deployment (mcp.carrier.llc/mcp) \u2014 they cannot run in stdio/local mode because Steel browser sessions and KV task state require Cloudflare Workers runtime bindings. Connect to the remote MCP endpoint to use these tools.",
-        remote_url: "https://mcp.carrier.llc/mcp"
-      })
-    }
-  ]
-};
-function registerUiAgentGenericTools(server2, _ctx) {
+var COST_PER_STEP_USD = 0.014;
+var SESSION_OVERHEAD_USD = 5e-3;
+function estimateCostUsd2(steps) {
+  return Math.round((COST_PER_STEP_USD * steps + SESSION_OVERHEAD_USD) * 100) / 100;
+}
+function notConfiguredError(toolName) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "browser_use_not_configured",
+          tool: toolName,
+          message: "BROWSER_USE_API_KEY is not set, so the browsing agent cannot run. Set it in the environment of the process running this MCP server. Runs are billed to that key at roughly $0.20-1.00 each."
+        })
+      }
+    ]
+  };
+}
+function scopeError2(toolName, required, actual) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "scope_denied",
+          message: `Scope denied: tool '${toolName}' requires '${required}' scope. Your token has: [${actual.join(", ")}].`
+        })
+      }
+    ]
+  };
+}
+function registerUiAgentGenericTools(server2, ctx, runtime) {
   server2.registerTool(
     "ui_agent_ask",
     {
-      title: "Dispatch Generic Steel Browsing Agent",
-      description: "Dispatch a Steel browsing agent task with a natural-language prompt. The agent will navigate the web, use Tavily web search if needed, and return the result. Use for ad-hoc research, page extraction, form filling outside the OCS portal. Pro/Enterprise scope required. Cost ~$0.20-1.00 per task depending on complexity. Returns task_id immediately \u2014 poll with ui_agent_status for completion. Set dry_run=true to preview cost estimate without executing. NOTE: requires remote Worker deployment (mcp.carrier.llc/mcp) \u2014 not available in stdio mode.",
+      title: "Dispatch Generic Browsing Agent",
+      description: "Send a plain-language task to a hosted browsing agent, which drives a real browser on the open web \u2014 navigating pages, searching, extracting content, filling forms outside the OCS portal. Each run costs roughly $0.20-1.00 in model spend against your own BROWSER_USE_API_KEY, so treat it as the expensive last resort, not a lookup. Limited to CARRIER_BROWSER_USE_MAX_RUNS runs per CLI session (default 10). Params: `prompt` (1-4000 chars \u2014 name the target URL and the exact data or action), `max_steps` (1-30, default 15; prices the dry-run estimate only), `dry_run` (true returns only `estimated_cost_usd` and creates no session). Returns the finished result: unlike the hosted Worker, a local CLI has no background runtime, so this call blocks for the length of the run. Requires `write` scope. Do NOT use this to work out which Carrier tool answers a request \u2014 that is `carrier_ask`, which costs nothing. Do NOT use this for anything the OCS API already covers; every other tool here is faster, free, and audited.",
       inputSchema: {
-        prompt: z22.string().min(1).max(4e3).describe("Natural-language task description for the Steel browsing agent."),
-        max_steps: z22.number().int().min(1).max(30).optional().describe("Maximum agent steps (1\u201330, default 15)."),
-        dry_run: z22.boolean().optional().describe("Preview cost estimate without dispatching.")
+        prompt: z22.string().min(1).max(4e3).describe(
+          "Natural-language task description for the browsing agent. Be specific: include target URLs, data to extract, or actions to perform."
+        ),
+        max_steps: z22.number().int().min(1).max(30).optional().describe(
+          "Advisory step budget (1\u201330, default 15). Prices the dry-run estimate; the hosted agent sets its own depth."
+        ),
+        dry_run: z22.boolean().optional().describe(
+          "Preview cost estimate without dispatching. Returns estimated_cost_usd only \u2014 no browser session is created."
+        )
       }
     },
-    async (_args) => STDIO_ERROR
+    async (args) => {
+      const start = Date.now();
+      const toolName = "ui_agent_ask";
+      const { prompt, max_steps = 15, dry_run = false } = args;
+      if (!ctx.props.scope.includes("write") && !ctx.props.scope.includes("admin")) {
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: "scope_denied",
+          dry_run: false,
+          duration_ms: 0
+        });
+        return scopeError2(toolName, "write", ctx.props.scope);
+      }
+      if (dry_run) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: "dry_run",
+                  estimated_cost_usd: estimateCostUsd2(max_steps),
+                  runs_remaining_this_session: runtime.budget.remaining,
+                  note: "No browser session was created and nothing was billed."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (!browserUseConfigured(runtime.env)) {
+        return notConfiguredError(toolName);
+      }
+      try {
+        runtime.budget.reserve();
+      } catch (err7) {
+        if (err7 instanceof SpendLimitError) {
+          ctx.audit({
+            tool_name: toolName,
+            ocs_method: "[ui-agent:generic-ask]",
+            // The existing quota status, not a new one: AuditRow's status is a
+            // closed union shared with the Worker, and a stdio-only value would
+            // be a row shape the hosted surface never emits.
+            status: "quota_exceeded",
+            dry_run: false,
+            duration_ms: 0,
+            event_type: "ui_agent_dispatch"
+          });
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "run_limit_reached",
+                  message: err7.message
+                })
+              }
+            ]
+          };
+        }
+        throw err7;
+      }
+      try {
+        const result2 = await runUiAgent(
+          prompt,
+          "Carrier CLI browsing agent",
+          runtime.env
+        );
+        runtime.dispatchedTaskIds.add(result2.task_id);
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: result2.status === "error" ? "error" : "ok",
+          dry_run: false,
+          duration_ms: Date.now() - start,
+          event_type: "ui_agent_dispatch"
+        });
+        return {
+          ...result2.status === "error" ? { isError: true } : {},
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: result2.status,
+                  task_id: result2.task_id,
+                  ...result2.session_viewer_url ? { session_viewer_url: result2.session_viewer_url } : {},
+                  result: result2.result,
+                  session_spend_usd: runtime.spend.costUsd,
+                  runs_remaining_this_session: runtime.budget.remaining,
+                  note: "The run completed in-process. Task records live only for this CLI session \u2014 ui_agent_status can read this task_id until the process exits."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err7) {
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: "error",
+          dry_run: false,
+          duration_ms: Date.now() - start,
+          event_type: "ui_agent_dispatch"
+        });
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "ui_agent_failed",
+                message: err7 instanceof Error ? err7.message : String(err7)
+              })
+            }
+          ]
+        };
+      }
+    }
   );
   server2.registerTool(
     "ui_agent_status",
     {
-      title: "Get Steel Agent Task Status",
-      description: "Poll the status of a Steel browser agent task dispatched by ui_agent_ask or any ui_* tool. Returns current status (pending | running | completed | failed) and result when available. NOTE: requires remote Worker deployment (mcp.carrier.llc/mcp) \u2014 not available in stdio mode.",
+      title: "Poll Browsing Agent Task Status",
+      description: "Returns the current state of a browsing-agent task by `task_id`, including its result once finished. In the local CLI, ui_agent_ask already returns the finished result, so this is mainly for re-reading a task within the same session. Task records do not survive the CLI process exiting. Requires `read` scope.",
       inputSchema: {
-        task_id: z22.string().describe("Steel task ID returned by ui_agent_ask or any ui_* tool dispatch")
+        task_id: z22.string().describe("Task ID returned by ui_agent_ask")
       }
     },
-    async (_args) => STDIO_ERROR
+    async (args) => {
+      const toolName = "ui_agent_status";
+      if (ctx.props.scope.length === 0) {
+        return scopeError2(toolName, "read", ctx.props.scope);
+      }
+      if (!browserUseConfigured(runtime.env)) {
+        return notConfiguredError(toolName);
+      }
+      const task = await getUiAgentTask(
+        args.task_id,
+        runtime.env
+      );
+      if (!task) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "task_not_found",
+                message: `No task record for task_id=${args.task_id}. In the local CLI these live in memory for the lifetime of the process, so a task from an earlier session is gone rather than expired.`
+              })
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(task, null, 2)
+          }
+        ]
+      };
+    }
   );
 }
 
@@ -12295,8 +12337,15 @@ var stdioEnv = {
   ASSETS: null,
   CARRIER_USERS: null,
   DOWNLOADS: null,
-  MANUS_API_KEY: "",
   STRIPE_SECRET_KEY: process.env.STRIPE_SECRET_KEY ?? "",
+  // Browser Use Cloud. Read from the environment with a real fallback, the way
+  // STRIPE_SECRET_KEY above and the wallet values below are — unlike the
+  // MANUS_API_KEY this replaces, which was hardcoded to "" with no fallback at
+  // all, so every ui_agent_* tool returned a configuration error to every
+  // caller from the day it shipped. Absent is still a valid state: the tools
+  // stay registered and say so. Runs are billed to this key at ~$0.20-1.00
+  // each, so dispatch is capped per process — see ui-agent-runtime.ts.
+  BROWSER_USE_API_KEY: process.env.BROWSER_USE_API_KEY,
   // Prepaid-wallet configuration. Read from the environment so a local operator
   // who holds these values gets working wallet tools; when absent the tools stay
   // registered (catalog parity with the Worker) and return an explicit
@@ -12340,13 +12389,16 @@ registerCountryHistoryTool(server, toolCtx);
 registerDepletionEventsTool(server, toolCtx);
 registerAllApps(server, toolCtx);
 registerAllPricingTools(server, toolCtx);
-registerScheduleAndUsageTools(server, toolCtx);
-registerAllUiAgentTools(server, toolCtx);
-registerUiAgentAskTools(server, toolCtx);
+var uiAgentRuntime = createUiAgentRuntime();
+var portalOptIn = readPortalOptIn();
+warnPortalOptIn(portalOptIn);
+registerScheduleAndUsageTools(server, toolCtx, uiAgentRuntime);
+registerAllUiAgentTools(server, toolCtx, uiAgentRuntime, portalOptIn);
+registerUiAgentAskTools(server, toolCtx, uiAgentRuntime);
 registerStripeConnectTools(server, { env: stdioEnv, props });
 registerWalletTools(server, { env: stdioEnv, props });
 registerGreenzoneTools(server, toolCtx);
-registerUiAgentGenericTools(server, toolCtx);
+registerUiAgentGenericTools(server, toolCtx, uiAgentRuntime);
 registerStorefrontLogoTools(
   server,
   stdioEnv,