@carrierllc/mcp 0.9.2 → 0.10.0

package/dist/index.js

@@ -1,25 +1,32 @@
 #!/usr/bin/env node
 import {
   CARRIER_VERSION,
+  OCS_MAX_USAGE_WINDOW_DAYS,
   ROUTER_RULES,
   TARGET_IDS,
   acquireEndpointSlot,
+  applyParamRenames,
   applySubscriberFilters,
   buildListSubscriberParams,
   buildRouterCatalog,
   buildSite,
   clerkCliDeps,
   configureClerkInstance,
+  daysUntil,
   deploySite,
   esimStatusPerAccountParams,
+  extractDailyUsage,
   extractEsimStatusCounts,
+  filterActiveSubscribers,
   fleetScreen,
+  formatBytes,
   formatProbes,
   generateStorefrontLogo,
   getLimitForEndpoint,
   getRateLimitWindowCounts,
   imsiFromSubscriberRecord,
   isTargetId,
+  lastNDaysPeriod,
   loadStorefrontBrand,
   locationParams,
   mergeEnvLocal,
@@ -33,11 +40,14 @@ import {
   recurringPackageParams,
   renderHtml,
   repairPlanFor,
+  runWithBudget,
   storefrontClerkUrls,
   subscriberIdParams,
+  subscriberRows,
   usageOverPeriodParams,
-  verifyStorefront
-} from "./chunk-4XHSOF62.js";
+  verifyStorefront,
+  withOcsListSummary
+} from "./chunk-DUAENMJE.js";
 import "./chunk-SHKKVIIA.js";
 
 // src/index.ts
@@ -69,32 +79,35 @@ var OcsClient = class {
   async call(method, params = {}) {
     await acquireEndpointSlot(this.token, method, "interactive");
     const url = `${this.baseUrl}/v1?token=${this.token}`;
-    const body2 = JSON.stringify({ [method]: params });
-    const res = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: body2
-    });
-    if (!res.ok) {
-      throw new OcsApiError(res.status, `HTTP ${res.status} ${res.statusText}`, method);
-    }
-    const json = await res.json();
-    if (json.status?.code !== 0) {
-      throw new OcsApiError(json.status?.code ?? -1, json.status?.msg ?? "Unknown error", method);
-    }
-    if (method === "getCustomerTariff" && json["listTariffRule"] !== void 0) {
-      return json["listTariffRule"];
-    }
-    if (method === "getSubscriberLocationByCellId") {
-      const byMethod = json[method];
-      if (byMethod !== void 0) {
-        return byMethod;
+    const body2 = JSON.stringify({ [method]: applyParamRenames(method, params) });
+    return runWithBudget(method, async (signal) => {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: body2,
+        signal
+      });
+      if (!res.ok) {
+        throw new OcsApiError(res.status, `HTTP ${res.status} ${res.statusText}`, method);
       }
-      if (json["subscriberLocation"] !== void 0) {
-        return json["subscriberLocation"];
+      const json = await res.json();
+      if (json.status?.code !== 0) {
+        throw new OcsApiError(json.status?.code ?? -1, json.status?.msg ?? "Unknown error", method);
       }
-    }
-    return json[method] ?? json;
+      if (method === "getCustomerTariff" && json["listTariffRule"] !== void 0) {
+        return json["listTariffRule"];
+      }
+      if (method === "getSubscriberLocationByCellId") {
+        const byMethod = json[method];
+        if (byMethod !== void 0) {
+          return byMethod;
+        }
+        if (json["subscriberLocation"] !== void 0) {
+          return json["subscriberLocation"];
+        }
+      }
+      return json[method] ?? json;
+    });
   }
 };
 
@@ -189,6 +202,9 @@ function estimateCostUsd(u, rates = HAIKU_RATES) {
 var DEFAULT_BEDROCK_REGION = "us-east-1";
 var DEFAULT_MODEL_ID = "us.anthropic.claude-haiku-4-5-20251001-v1:0";
 var BEDROCK_TIMEOUT_MS = 3e4;
+var MAX_ATTEMPTS = 4;
+var INITIAL_RETRY_MS = 100;
+var MIN_ATTEMPT_BUDGET_MS = 250;
 var BedrockRateLimitError = class extends Error {
   isRateLimit = true;
   /**
@@ -218,7 +234,11 @@ function client(creds) {
       secretAccessKey: creds.secretAccessKey,
       ...creds.sessionToken ? { sessionToken: creds.sessionToken } : {},
       region,
-      service: "bedrock"
+      service: "bedrock",
+      // See MAX_ATTEMPTS. aws4fetch's retry loop cannot be cancelled, so this
+      // layer owns the policy instead. Changing this back to the default 10
+      // silently restores the ~50s stall that timeoutMs is supposed to prevent.
+      retries: 0
     }),
     region,
     modelId: creds.modelId ?? DEFAULT_MODEL_ID
@@ -260,6 +280,47 @@ async function fail(resp) {
   }
   throw new BedrockError(text || `Bedrock returned HTTP ${resp.status}`, resp.status);
 }
+function timedOut() {
+  const err7 = new Error("Bedrock call timed out before a usable response");
+  err7.name = "TimeoutError";
+  return err7;
+}
+function sleep(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+function retryable(status) {
+  return status === 429 || status >= 500;
+}
+async function sendWithRetry(aws, url, init, signal, deadlineAt) {
+  let throttled = null;
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    if (signal.aborted) break;
+    let resp;
+    try {
+      resp = await aws.fetch(url, init);
+    } catch (err7) {
+      if (signal.aborted && throttled) return throttled;
+      throw err7;
+    }
+    if (!retryable(resp.status)) return resp;
+    throttled = resp;
+    if (attempt === MAX_ATTEMPTS - 1) break;
+    const backoff = Math.random() * INITIAL_RETRY_MS * 2 ** attempt;
+    if (Date.now() + backoff + MIN_ATTEMPT_BUDGET_MS > deadlineAt) break;
+    await sleep(backoff, signal);
+  }
+  if (throttled) return throttled;
+  throw timedOut();
+}
 async function invokeTool(creds, req, signal) {
   const json = await invokeModelRaw(
     creds,
@@ -273,19 +334,24 @@ async function invokeTool(creds, req, signal) {
 }
 async function invokeModelRaw(creds, payload, opts = {}, signal) {
   const { aws, region, modelId } = client(creds);
+  const timeoutMs = opts.timeoutMs ?? BEDROCK_TIMEOUT_MS;
+  const deadlineAt = Date.now() + timeoutMs;
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? BEDROCK_TIMEOUT_MS);
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
   const onAbort = () => controller.abort();
   signal?.addEventListener("abort", onAbort, { once: true });
   try {
-    const resp = await aws.fetch(
+    const resp = await sendWithRetry(
+      aws,
       `https://bedrock-runtime.${region}.amazonaws.com/model/${encodeURIComponent(modelId)}/invoke`,
       {
         method: "POST",
         headers: headersFor(opts.attribution, "application/json"),
         body: JSON.stringify(payload),
         signal: controller.signal
-      }
+      },
+      controller.signal,
+      deadlineAt
     );
     if (!resp.ok) await fail(resp);
     return await resp.json();
@@ -294,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 = {
@@ -769,11 +1298,12 @@ function wrapHandler(toolName, ocsMethod, requiredScope, ctx, handler) {
     return result2;
   };
 }
-async function ocsCall(env, token2, method, params = {}) {
+async function ocsCall(env, token2, method, params = {}, listKind) {
   const client2 = new OcsClient(env.CARRIER_OCS_BASE_URL, token2);
   const result2 = await client2.call(method, params);
+  const payload = listKind ? withOcsListSummary(result2, listKind) : result2;
   return {
-    content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
   };
 }
 async function resolveSubscriberByIccid(env, token2, iccid, cache) {
@@ -803,7 +1333,7 @@ function registerAllTools(server2, ctx) {
     "list_reseller_accounts",
     {
       title: "List Reseller Accounts",
-      description: "Use this to enumerate the accounts (sub-resellers or customer accounts) BELOW a reseller. Params: `resellerId` (integer, optional \u2014 omit to list accounts under the token owner's reseller). Returns: `{ reseller: [ { id, name, account: [ { id, name, balance, packageOnly } ] } ] }` \u2014 the accounts are NESTED under each reseller, not a flat top-level array. Do NOT use this to fetch a single subscriber's details \u2014 use `get_subscriber` instead. Do NOT use this to check eSIM activation counts \u2014 use `esim_status_per_account` for that. Do NOT use this to find a reseller's PARENT, balance or charging plans \u2014 those are above or on the reseller itself, not in this list; use `get_reseller_info`.",
+      description: "Use this to enumerate the accounts (sub-resellers or customer accounts) BELOW a reseller. Params: `resellerId` (integer, optional \u2014 omit to list accounts under the token owner's reseller). Returns: `{ summary, reseller: [ { id, name, account: [ { id, name, balance, packageOnly } ] } ] }` \u2014 the accounts are NESTED under each reseller, not a flat top-level array. `summary.total` therefore counts RESELLERS; the account count is `summary.nested.accounts`. For any question about accounts use that, never `total`. Do NOT use this to fetch a single subscriber's details \u2014 use `get_subscriber` instead. Do NOT use this to check eSIM activation counts \u2014 use `esim_status_per_account` for that. Do NOT use this to find a reseller's PARENT, balance or charging plans \u2014 those are above or on the reseller itself, not in this list; use `get_reseller_info`.",
       inputSchema: {
         resellerId: z.number().optional().describe("Filter to a specific reseller by ID (omit for token owner's reseller)")
       },
@@ -817,7 +1347,7 @@ function registerAllTools(server2, ctx) {
       async ({ resellerId }, token2) => {
         const params = {};
         if (resellerId !== void 0) params.resellerId = resellerId;
-        return ocsCall(ctx.env, token2, "listResellerAccount", params);
+        return ocsCall(ctx.env, token2, "listResellerAccount", params, "resellers");
       }
     )
   );
@@ -965,7 +1495,7 @@ function registerAllTools(server2, ctx) {
     "list_subscribers",
     {
       title: "List Subscribers",
-      description: "Use this to list subscribers with optional filters and pagination. Good for fleet enumeration, bulk status checks, and finding subscribers by account or status. OCS REQUIRES at least one search key \u2014 provide exactly one of: `imsi`, `iccid`, `activationCode`, `accountId`, or `msisdn`. Calling with no key will be rejected before reaching OCS. Params: `imsi` (string), `iccid` (string), `activationCode` (string), `accountId` (integer), `msisdn` (string), `status` (string, e.g. 'ACTIVE'/'SUSPENDED'), `offset` (integer, pagination \u2014 default 0), `limit` (integer, max results \u2014 always set to avoid unbounded fetches; recommended max 100 per call). Returns: array of subscriber summary records with ICCID, status, and account. Do NOT use this to fetch full details for a specific subscriber \u2014 use `get_subscriber` for that.",
+      description: "Use this to list subscribers with optional filters and pagination. Good for fleet enumeration, bulk status checks, and finding subscribers by account or status. OCS REQUIRES at least one search key \u2014 provide exactly one of: `imsi`, `iccid`, `activationCode`, `accountId`, or `msisdn`. Calling with no key will be rejected before reaching OCS. Params: `imsi` (string), `iccid` (string), `activationCode` (string), `accountId` (integer), `msisdn` (string), `status` (string, e.g. 'ACTIVE'/'SUSPENDED'), `offset` (integer, pagination \u2014 default 0), `limit` (integer, max results \u2014 always set to avoid unbounded fetches; recommended max 100 per call). Returns: `{ summary, subscriberList: [...] }` \u2014 subscriber summary records with ICCID, status and account, behind a server-counted `summary.total` (rows returned) and `summary.breakdown.status`. Answer 'how many' from `summary`, not by counting rows \u2014 but when `summary.moreAvailable` is set this is one page, so report `summary.upstreamTotal` for the fleet-wide figure, never `total`. Do NOT use this to fetch full details for a specific subscriber \u2014 use `get_subscriber` for that.",
       inputSchema: z.object({
         imsi: z.string().optional().describe("Filter by IMSI"),
         iccid: z.string().optional().describe("Filter by ICCID"),
@@ -994,7 +1524,12 @@ function registerAllTools(server2, ctx) {
         const raw = await client2.call("listSubscriber", params);
         const payload = applySubscriberFilters(raw, args);
         return {
-          content: [{ type: "text", text: JSON.stringify(payload, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(withOcsListSummary(payload, "subscribers"), null, 2)
+            }
+          ]
         };
       }
     )
@@ -1321,7 +1856,7 @@ function registerAllTools(server2, ctx) {
     "list_subscriber_packages",
     {
       title: "List Subscriber Packages",
-      description: "Use this to retrieve all prepaid packages currently assigned to a subscriber. Returns each package's allowance (data/voice/SMS), consumed usage, expiry date, status, and packageId. Always call this before any package modification tool (`modify_package_limits`, `modify_package_expiry`, `modify_package_status`, `delete_subscriber_package`) to confirm the correct packageId and current state. Params: `iccid` (subscriber identifier). Returns: array of package records with `packageId`, `name`, `status`, `dataLimit`, `dataUsed`, `expirationDate`, `recurring` flag. Do NOT use this to browse the product catalog \u2014 use `list_package_templates` for that.",
+      description: "Use this to retrieve all prepaid packages currently assigned to a subscriber. Returns each package's allowance (data/voice/SMS), consumed usage, expiry date, status, and packageId. Always call this before any package modification tool (`modify_package_limits`, `modify_package_expiry`, `modify_package_status`, `delete_subscriber_package`) to confirm the correct packageId and current state. Params: `iccid` (subscriber identifier). Returns: `{ summary, prepaidPackage: [...] }` \u2014 package records with `packageId`, `name`, `status`, `dataLimit`, `dataUsed`, `expirationDate` and a `recurring` flag, behind a server-counted `summary.total` and a `summary.breakdown` over status and recurring. Answer 'how many' from `summary`, not by counting rows. Do NOT use this to browse the product catalog \u2014 use `list_package_templates` for that.",
       inputSchema: { iccid: z.string().describe("The subscriber ICCID") },
       annotations: { readOnlyHint: true }
     },
@@ -1330,7 +1865,7 @@ function registerAllTools(server2, ctx) {
       "listSubscriberPrepaidPackages",
       TOOL_SCOPES["list_subscriber_packages"],
       ctx,
-      async ({ iccid }, token2) => ocsCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid })
+      async ({ iccid }, token2) => ocsCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid }, "packages")
     )
   );
   server2.registerTool(
@@ -1563,10 +2098,11 @@ function registerAllTools(server2, ctx) {
     "list_package_templates",
     {
       title: "List Package Templates",
-      description: "Use this to browse the product catalog of prepaid package templates available for assignment. Returns each template's name, data/voice/SMS limits, pricing, validity period, location zone, and recurring configuration. Call this before `assign_package` or `assign_recurring_package` to obtain valid `packageTemplateId` values. Params: `accountId` (integer, optional \u2014 filter templates visible to a specific account). Returns: array of template records with `templateId`, `name`, `dataLimit`, `price`, `validityDays`, `locationZoneId`, `recurring`. Do NOT use this to list packages assigned to a specific subscriber \u2014 use `list_subscriber_packages`.",
-      inputSchema: {
-        accountId: z.number().optional().describe("Filter templates by account ID")
-      },
+      description: "Use this to browse the product catalog of prepaid package templates available for assignment. Returns each template's name, data/voice/SMS limits, pricing, validity period, location zone, and recurring configuration. Call this before `assign_package` or `assign_recurring_package` to obtain valid `packageTemplateId` values. Params: none \u2014 returns the whole catalog for the token owner's reseller. Returns: `{ summary, template: [...] }`. `summary.total` is the number of templates, counted by the server over the complete catalog, and `summary.breakdown` counts the templates per `recurring` value and per location zone. Answer any 'how many' question from `summary` \u2014 it is authoritative, and counting the rows yourself gets it wrong. Each row carries `prepaidpackagetemplateid`, `prepaidpackagetemplatename`, `databyte` (bytes), `cost`, `perioddays`, `locationzoneid`, `rdbLocationZones.locationzonename` and `recurring`. Do NOT use this to list packages assigned to a specific subscriber \u2014 use `list_subscriber_packages`.",
+      // No `accountId` — see the matching note in apps/mcp-server/src/tools.ts.
+      // OCS rejected every call that carried it, and it is not a rename of any
+      // of the five properties OCS does accept.
+      inputSchema: {},
       annotations: { readOnlyHint: true }
     },
     wrapHandler(
@@ -1574,11 +2110,7 @@ function registerAllTools(server2, ctx) {
       "listPrepaidPackageTemplate",
       TOOL_SCOPES["list_package_templates"],
       ctx,
-      async ({ accountId }, token2) => {
-        const params = {};
-        if (accountId !== void 0) params.accountId = accountId;
-        return ocsCall(ctx.env, token2, "listPrepaidPackageTemplate", params);
-      }
+      async (_args, token2) => ocsCall(ctx.env, token2, "listPrepaidPackageTemplate", {}, "templates")
     )
   );
   server2.registerTool(
@@ -1831,7 +2363,7 @@ function registerAllTools(server2, ctx) {
     "get_tariff",
     {
       title: "Get Customer Tariff",
-      description: `Use this to retrieve the tariff table for a reseller: per-country, per-operator wholesale data/voice/SMS rates. Useful for cost analysis, margin calculations, and identifying expensive roaming countries before steering decisions. Params: \`resellerId\` (integer, optional \u2014 omit to use the token owner's reseller); \`country\` (optional, ISO-3166 alpha-2 such as "nl" OR a full country name such as "Netherlands", case-insensitive); \`trafficType\` (optional, "data" | "voice" | "sms" \u2014 keeps only rules whose corresponding rate is greater than zero); \`verbose\` (optional boolean, default false \u2014 returns the full untouched OCS rule shape, capped at ${TARIFF_VERBOSE_MAX_RULES} rows, so combine it with the filters). Returns BY DEFAULT a projected result: \`totalRules\`, \`matchedRules\`, \`returnedRules\`, \`truncated\`, a hoisted \`currency\`, a \`fields\` legend and \`rules[]\` of short-keyed rows (\`iso\`, \`op\`, \`data\`, \`moCall\`, \`mtCall\`, \`moSms\`, \`mtSms\`, \`active\`). Zero rates and inactive flags are omitted per row. Nested operator detail (mccMncs, tadigs, continent, countryCode, utcOffset), the sponsor object, plan ids and the validity/discount flags are dropped unless \`verbose\` is true. Rows are capped at ${TARIFF_MAX_RULES}; when the cap bites, \`truncated\` is true and \`note\` says so explicitly and names the filter params \u2014 the result is never silently shortened. Filtering happens server-side on the complete OCS table, so a filtered call sees every matching rule. Response key in OCS is \`listTariffRule\`. Do NOT use this to assign a pricing plan to a subscriber \u2014 use \`modify_subscriber_mobile_plan\`. This shows the RESELLER's wholesale cost, not what end-users are charged.`,
+      description: `Use this to retrieve the tariff table for a reseller: per-country, per-operator wholesale data/voice/SMS rates. Useful for cost analysis, margin calculations, and identifying expensive roaming countries before steering decisions. Params: \`resellerId\` (integer, optional \u2014 omit to use the token owner's reseller); \`country\` (optional, ISO-3166 alpha-2 such as "nl" OR a full country name such as "Netherlands", case-insensitive); \`trafficType\` (optional, "data" | "voice" | "sms" \u2014 keeps only rules whose corresponding rate is greater than zero); \`verbose\` (optional boolean, default false \u2014 returns the full untouched OCS rule shape, capped at ${TARIFF_VERBOSE_MAX_RULES} rows, so combine it with the filters). Returns BY DEFAULT a projected result: \`totalRules\`, \`matchedRules\`, \`returnedRules\`, \`truncated\`, a hoisted \`currency\`, a \`fields\` legend and \`rules[]\` of short-keyed rows (\`iso\`, \`op\`, \`data\`, \`moCall\`, \`mtCall\`, \`moSms\`, \`mtSms\`, \`active\`). Zero rates and inactive flags are omitted per row. Nested operator detail (mccMncs, tadigs, continent, countryCode, utcOffset), the sponsor object, plan ids and the validity/discount flags are dropped unless \`verbose\` is true. Rows are capped at ${TARIFF_MAX_RULES}; when the cap bites, \`truncated\` is true and \`note\` says so explicitly and names the filter params \u2014 the result is never silently shortened. Filtering happens server-side on the complete OCS table, so a filtered call sees every matching rule. Response key in OCS is \`listTariffRule\`. This is the slowest tool on the platform: the OCS table is ~3.4 MB and takes 3 s in a fast window and up to ~2 minutes in a slow one, so the call carries a 180 s budget. Expect to wait, and do not call it in a loop. Do NOT use this to assign a pricing plan to a subscriber \u2014 use \`modify_subscriber_mobile_plan\`. This shows the RESELLER's wholesale cost, not what end-users are charged.`,
       inputSchema: {
         resellerId: z.number().optional().describe("Reseller ID (omit to use token owner's reseller)"),
         country: z.string().optional().describe(
@@ -1957,8 +2489,9 @@ var ocs_methods_default = {
       scope: "read",
       description: "Retrieve reseller details",
       params: {
-        resellerId: { type: "number", required: false }
+        resellerId: { type: "number", required: false, ocs_field: "id" }
       },
+      params_note: "`resellerId` is the MCP-facing name. OCS getResellerInfo accepts exactly one property, `id`; @carrier/ocs-client translates it at the serialisation chokepoint (OCS_PARAM_RENAMES).",
       response: {},
       annotations: "readOnlyHint",
       verified_against_server: true,
@@ -2363,9 +2896,8 @@ var ocs_methods_default = {
       category: "templates",
       scope: "read",
       description: "List all prepaid package templates",
-      params: {
-        accountId: { type: "number", required: false }
-      },
+      params: {},
+      params_note: "No account filter. OCS listPrepaidPackageTemplate accepts only locationZoneId, templateId, destinationListId, resellerId, sponsorId. The former `accountId` param was rejected by OCS on every call and is not a rename of any of those five: accounts are a different id space from resellers and sponsors.",
       response: {},
       annotations: "readOnlyHint",
       verified_against_server: true,
@@ -3499,26 +4031,9 @@ async function fetchActiveSubscribers(env, token2, accountId, resellerId) {
       { accountId: acctId }
     );
     if (subResult.error) return { data: null, error: subResult.error };
-    const raw = subResult.data;
-    const list = Array.isArray(raw) ? raw : raw?.subscriberList ?? [];
-    aggregated.push(...list);
+    aggregated.push(...subscriberRows(subResult.data));
   }
-  const active = aggregated.filter((s) => String(s.status ?? "").toUpperCase() === "ACTIVE");
-  return { data: active, error: null };
-}
-function formatBytes(bytes) {
-  if (bytes === 0) return "0 B";
-  const units = ["B", "KB", "MB", "GB", "TB"];
-  const i = Math.floor(Math.log(bytes) / Math.log(1024));
-  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
-}
-function daysUntil(dateStr) {
-  const now = /* @__PURE__ */ new Date();
-  const target = new Date(dateStr);
-  return Math.ceil((target.getTime() - now.getTime()) / (1e3 * 60 * 60 * 24));
-}
-function toISODate(d) {
-  return d.toISOString().split("T")[0];
+  return { data: filterActiveSubscribers(aggregated), error: null };
 }
 function result(text, isError = false) {
   return { content: [{ type: "text", text }], ...isError ? { isError: true } : {} };
@@ -3598,10 +4113,10 @@ function registerIntelligenceTools(server2, ctx) {
       }
     }
     const now = /* @__PURE__ */ new Date();
-    const twoDaysAgo = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1e3);
+    const eventWindow = lastNDaysPeriod(3, now);
     const events = await safeCall(ctx.env, token2, "subscriberNetworkEventsOverPeriod", {
       subscriber: { iccid },
-      period: { start: toISODate(twoDaysAgo), end: toISODate(now) }
+      period: eventWindow
     });
     if (events.data && Array.isArray(events.data)) {
       if (events.data.length === 0) {
@@ -3778,11 +4293,11 @@ Package-only accounts at 0 balance require no action.`);
   }, async ({ iccid }) => {
     const token2 = await ctx.getUserToken(ctx.props.sub);
     const now = /* @__PURE__ */ new Date();
-    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const usagePeriod = lastNDaysPeriod(OCS_MAX_USAGE_WINDOW_DAYS, now);
     const [usageResult, pkgResult] = await Promise.all([
       safeCall(ctx.env, token2, "subscriberUsageOverPeriod", {
         subscriber: { iccid },
-        period: { start: toISODate(weekAgo), end: toISODate(now) }
+        period: usagePeriod
       }),
       safeCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid })
     ]);
@@ -3790,13 +4305,8 @@ Package-only accounts at 0 balance require no action.`);
     const sections = [`# Usage Anomaly Report: ${iccid}
 `];
     const anomalies = [];
-    if (usageResult.data && Array.isArray(usageResult.data) && usageResult.data.length > 0) {
-      const dailyData = [];
-      for (const entry of usageResult.data) {
-        const bytes = Number(entry.dataBytes ?? entry.dataVolume ?? entry.totalData ?? 0);
-        const date = String(entry.date ?? entry.day ?? "?");
-        dailyData.push({ date, bytes });
-      }
+    const dailyData = extractDailyUsage(usageResult.data);
+    if (dailyData.length > 0) {
       if (dailyData.length >= 2) {
         const volumes = dailyData.map((d) => d.bytes);
         const mean = volumes.reduce((a, b) => a + b, 0) / volumes.length;
@@ -3864,24 +4374,21 @@ Package-only accounts at 0 balance require no action.`);
   }, async ({ iccid }) => {
     const token2 = await ctx.getUserToken(ctx.props.sub);
     const now = /* @__PURE__ */ new Date();
-    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const usagePeriod = lastNDaysPeriod(OCS_MAX_USAGE_WINDOW_DAYS, now);
     const [usageResult, pkgResult, templatesResult] = await Promise.all([
       safeCall(ctx.env, token2, "subscriberUsageOverPeriod", {
         subscriber: { iccid },
-        period: { start: toISODate(weekAgo), end: toISODate(now) }
+        period: usagePeriod
       }),
       safeCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid }),
       safeCall(ctx.env, token2, "listPrepaidPackageTemplate", {})
     ]);
     const sections = [`# Package Optimization: ${iccid}
 `];
+    const optimizeRows = extractDailyUsage(usageResult.data);
     let avgDailyData = 0;
-    if (usageResult.data && Array.isArray(usageResult.data) && usageResult.data.length > 0) {
-      const totalData = usageResult.data.reduce(
-        (sum, e) => sum + Number(e.dataBytes ?? e.dataVolume ?? e.totalData ?? 0),
-        0
-      );
-      avgDailyData = totalData / usageResult.data.length;
+    if (optimizeRows.length > 0) {
+      avgDailyData = optimizeRows.reduce((sum, r) => sum + r.bytes, 0) / optimizeRows.length;
       sections.push(`## Current Usage Pattern`);
       sections.push(`- Average daily data: ${formatBytes(avgDailyData)}`);
       sections.push(`- Projected monthly: ${formatBytes(avgDailyData * 30)}`);
@@ -3952,22 +4459,21 @@ Package-only accounts at 0 balance require no action.`);
   }, async ({ iccid }) => {
     const token2 = await ctx.getUserToken(ctx.props.sub);
     const now = /* @__PURE__ */ new Date();
-    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const usagePeriod = lastNDaysPeriod(OCS_MAX_USAGE_WINDOW_DAYS, now);
     const [subResult, usageResult, pkgResult, activeResult] = await Promise.all([
       safeCall(ctx.env, token2, "getSingleSubscriber", { iccid }),
       safeCall(ctx.env, token2, "subscriberUsageOverPeriod", {
         subscriber: { iccid },
-        period: { start: toISODate(weekAgo), end: toISODate(now) }
+        period: usagePeriod
       }),
       safeCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid }),
       safeCall(ctx.env, token2, "getSubscriberActivePeriod", { iccid })
     ]);
     let riskScore = 0;
     const factors = [];
-    if (usageResult.data && Array.isArray(usageResult.data) && usageResult.data.length >= 3) {
-      const volumes = usageResult.data.map(
-        (e) => Number(e.dataBytes ?? e.dataVolume ?? e.totalData ?? 0)
-      );
+    const churnRows = extractDailyUsage(usageResult.data);
+    if (churnRows.length >= 3) {
+      const volumes = churnRows.map((r) => r.bytes);
       const firstHalf = volumes.slice(0, Math.floor(volumes.length / 2));
       const secondHalf = volumes.slice(Math.floor(volumes.length / 2));
       const avgFirst = firstHalf.reduce((a, b) => a + b, 0) / firstHalf.length;
@@ -3984,7 +4490,7 @@ Package-only accounts at 0 balance require no action.`);
           factors.push({ factor: "Moderately declining usage", impact, detail: `Usage dropped ${Math.abs(trend * 100).toFixed(0)}%` });
         }
       }
-    } else if (!usageResult.data || Array.isArray(usageResult.data) && usageResult.data.length === 0) {
+    } else if (churnRows.length === 0) {
       riskScore += 25;
       factors.push({ factor: "No recent usage", impact: 25, detail: "Zero data activity in last 7 days" });
     }
@@ -4279,7 +4785,7 @@ ${networksSorted.length} different networks in ${country} \u2014 possible steeri
     const sections = [`# High Cost Subscriber Report
 `];
     const now = /* @__PURE__ */ new Date();
-    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+    const usagePeriod = lastNDaysPeriod(OCS_MAX_USAGE_WINDOW_DAYS, now);
     const highCostSubs = [];
     const batchSize = 5;
     const subs = subsResult.data.slice(0, sampleSize);
@@ -4291,19 +4797,13 @@ ${networksSorted.length} different networks in ${country} \u2014 possible steeri
           const [usage, pkgs, loc] = await Promise.all([
             safeCall(ctx.env, token2, "subscriberUsageOverPeriod", {
               subscriber: { iccid },
-              period: { start: toISODate(weekAgo), end: toISODate(now) }
+              period: usagePeriod
             }),
             safeCall(ctx.env, token2, "listSubscriberPrepaidPackages", { iccid }),
             safeCall(ctx.env, token2, "getSubscriberLocation", { iccid })
           ]);
-          let dailyAvgBytes = 0;
-          if (usage.data && Array.isArray(usage.data) && usage.data.length > 0) {
-            const totalBytes = usage.data.reduce(
-              (sum, e) => sum + Number(e.dataBytes ?? e.dataVolume ?? e.totalData ?? 0),
-              0
-            );
-            dailyAvgBytes = totalBytes / usage.data.length;
-          }
+          const dailyRows = extractDailyUsage(usage.data);
+          const dailyAvgBytes = dailyRows.length > 0 ? dailyRows.reduce((sum, r) => sum + r.bytes, 0) / dailyRows.length : 0;
           if (pkgs.data && Array.isArray(pkgs.data)) {
             const activePkg = pkgs.data.find(
               (p) => String(p.status ?? "").toUpperCase() === "ACTIVE"
@@ -4378,7 +4878,7 @@ ${networksSorted.length} different networks in ${country} \u2014 possible steeri
   });
   server2.registerTool("detect_country_entry", {
     title: "Detect Country Entry",
-    description: "Detects when a subscriber has entered a new country by reading networkInfo.lastMcc from getSingleSubscriber (one cheap OCS call \u2014 avoids the per-call cost of getSubscriberLocationByCellId). Resolves MCC \u2192 ISO 3166-1 alpha-2 and optionally diffs against a caller-supplied expectedCountry to return countryChanged. Designed for downstream country-entry upsell workflows (e.g. mango.talk SMS/push offers). COST NOTE: This tool makes exactly one OCS call per invocation. Consumers running polling crons MUST enforce their own rate floor \u2014 this layer provides no throttle.",
+    description: "Detects when a subscriber has entered a new country by reading networkInfo.lastMcc from getSingleSubscriber (one cheap OCS call \u2014 avoids the per-call cost of getSubscriberLocationByCellId). Resolves MCC \u2192 ISO 3166-1 alpha-2 and optionally diffs against a caller-supplied expectedCountry to return countryChanged. Designed for downstream country-entry upsell workflows (e.g. mango.talk SMS/push offers). NOT AN AI TOOL: this is a deterministic MCC lookup and returns no model-written analysis, unlike the eight intelligence composites. COST NOTE: This tool makes exactly one OCS call per invocation. Consumers running polling crons MUST enforce their own rate floor \u2014 this layer provides no throttle.",
     inputSchema: {
       subscriber: z2.union([
         z2.object({ subscriberId: z2.number() }).describe("Internal subscriber ID"),
@@ -4851,124 +5351,220 @@ 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() {
-  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."
-        })
-      }
-    ]
-  };
-}
-function noManusKeyError() {
+// 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: "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."
+          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 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.
 
-`;
+// 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" };
 }
-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"]
+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 {
+    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);
+    }
+  };
+}
+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 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 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;
+    }
+  };
+  return {
+    env: {
+      ...apiKey2 ? { apiKey: apiKey2 } : {},
+      store: createMemoryStore(),
+      audit: audit2
+    },
+    budget: new RunBudget(maxRunsPerProcess(processEnv)),
+    spend,
+    configured: Boolean(apiKey2),
+    dispatchedTaskIds: /* @__PURE__ */ new Set()
+  };
+}
+
+// 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"
 };
-function wrapUiAgentHandler(toolName, gapId, requiredScope, ctx, buildPrompt) {
+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 isDryRun = args.dry_run === true;
+    const ocsMethod = `[ui-agent:${gapId}]`;
     if (!ctx.props.scope.includes(requiredScope)) {
       ctx.audit({
         tool_name: toolName,
-        ocs_method: `[ui-agent:${gapId}]`,
+        ocs_method: ocsMethod,
         status: "scope_denied",
         dry_run: false,
         duration_ms: 0
@@ -4983,114 +5579,130 @@ function wrapUiAgentHandler(toolName, gapId, requiredScope, ctx, buildPrompt) {
         ]
       };
     }
-    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();
+    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 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 + `
-
-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***");
+    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: `[ui-agent:${gapId}]`,
+        ocs_method: ocsMethod,
         status: "dry_run",
         dry_run: true,
         duration_ms: 0,
         event_type: "ui_agent_dispatch"
       });
-      return {
-        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)
-          }
-        ]
-      };
+      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,
@@ -5101,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'])"),
@@ -5160,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(
@@ -5215,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;
@@ -5227,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 = [
@@ -5247,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
+            )
+          }
+        ]
       };
     }
   );
@@ -5262,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"),
@@ -5270,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'])"),
@@ -5297,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"),
@@ -5324,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"),
@@ -5395,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"
@@ -5535,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 {
@@ -5550,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) => {
@@ -5582,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: [
@@ -5613,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
-        });
+      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: `Error calling Manus task.reply: ${err7 instanceof Error ? err7.message : String(err7)}`
+              text: JSON.stringify({
+                error: "resume_failed",
+                message: outcome.error ?? "The task could not be resumed."
+              })
             }
           ]
         };
       }
-      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
-        });
-        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
-              })
-            }
-          ]
-        };
-      }
-      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
+            )
           }
         ]
       };
@@ -5691,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 () => {
@@ -5706,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
+            )
           }
         ]
       };
@@ -5770,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",
@@ -6049,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,
@@ -6074,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.",
+      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 () => {
-      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 }] };
-      }
-    }
+    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 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 }] };
-      }
-    }
-  );
-  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.",
-      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 }] };
-      }
-    }
-  );
-  server2.registerTool(
-    "ui_agent_schedule_resume",
-    {
-      title: "Resume Manus Schedule",
-      description: "Resumes a paused Manus recurring schedule. Requires admin scope.",
-      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 }] };
+  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 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 () => !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 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 () => !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
+            )
+          }
+        ]
+      };
     }
   );
 }
@@ -6925,8 +6819,11 @@ var WALLET_TOOL_SCOPES = {
   wallet_topup_checkout: "write",
   wallet_auto_topup: "write"
 };
-function ok(text) {
-  return { content: [{ type: "text", text }] };
+function okStructured(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: payload
+  };
 }
 function err(text) {
   return { isError: true, content: [{ type: "text", text }] };
@@ -6940,6 +6837,17 @@ function registerWalletTools(server2, ctx) {
       title: "Wallet Balance",
       description: "Read the caller organisation's Carrier prepaid wallet: current balance and auto-top-up settings. The wallet is what Carrier bills your own eSIM spend against \u2014 it is not an OCS balance and not your MCP plan credits. Params: none (the organisation is taken from the session). Returns: { org_id, balance_eur_cents, auto_topup_enabled, auto_topup_threshold_cents, auto_topup_pack_cents } \u2014 all amounts in EUR cents, not euros. Do NOT use this for a reseller account balance in OCS \u2014 use `get_reseller_info` or `list_reseller_accounts`. Do NOT use this for a subscriber's OCS balance \u2014 use `get_subscriber`. Do NOT use this for MCP plan credits \u2014 use `credit_balance`. Do NOT use this for money held at Stripe \u2014 use `stripe_connect_balance`.",
       inputSchema: {},
+      // Derived from the object literal this handler builds below, not from the
+      // description. Every field is unconditional on the success path and comes
+      // straight off the Wallet record (wallet-client.ts:31-34), so all five are
+      // required rather than optional.
+      outputSchema: {
+        org_id: z7.string().describe("Carrier organisation the wallet belongs to"),
+        balance_eur_cents: z7.number().int().describe("Current balance in EUR cents"),
+        auto_topup_enabled: z7.boolean(),
+        auto_topup_threshold_cents: z7.number().int().describe("Balance at or below which an auto top-up fires, EUR cents"),
+        auto_topup_pack_cents: z7.number().int().describe("Amount an auto top-up charges, EUR cents")
+      },
       annotations: annotationsFor("wallet_balance", "read")
     },
     async () => {
@@ -6958,15 +6866,13 @@ function registerWalletTools(server2, ctx) {
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok(
-          JSON.stringify({
-            org_id: orgId,
-            balance_eur_cents: wallet.balance_eur_cents,
-            auto_topup_enabled: wallet.auto_topup_enabled,
-            auto_topup_threshold_cents: wallet.auto_topup_threshold_cents,
-            auto_topup_pack_cents: wallet.auto_topup_pack_cents
-          })
-        );
+        return okStructured({
+          org_id: orgId,
+          balance_eur_cents: wallet.balance_eur_cents,
+          auto_topup_enabled: wallet.auto_topup_enabled,
+          auto_topup_threshold_cents: wallet.auto_topup_threshold_cents,
+          auto_topup_pack_cents: wallet.auto_topup_pack_cents
+        });
       } catch (e) {
         if (e instanceof WalletClientError) return err(`Wallet error: ${e.message}`);
         Sentry2.captureException(e);
@@ -6984,6 +6890,31 @@ function registerWalletTools(server2, ctx) {
           "Pack id (pack_500/pack_1000/pack_2500/pack_5000) or exact EUR-cents amount. Omit to list packs."
         )
       },
+      /**
+       * This tool really does return two different shapes, so the schema says
+       * so rather than pretending otherwise. `pack` omitted returns the
+       * catalogue arm (`packs`); `pack` supplied returns the session arm. An
+       * `outputSchema` is an object shape, not a union type, so the two arms
+       * are expressed as mutually exclusive optional groups and the pairing is
+       * documented here. Marking either arm required would break the other.
+       */
+      outputSchema: {
+        packs: z7.array(
+          z7.object({
+            id: z7.string(),
+            eur_cents: z7.number().int(),
+            bonus_pct: z7.number(),
+            bonus_eur_cents: z7.number().int(),
+            credited_eur_cents: z7.number().int()
+          })
+        ).optional().describe("Catalogue arm \u2014 present only when `pack` was omitted."),
+        org_id: z7.string().optional().describe("Session arm."),
+        pack_id: z7.string().optional().describe("Session arm."),
+        pack_eur_cents: z7.number().int().optional().describe("Session arm."),
+        bonus_eur_cents: z7.number().int().optional().describe("Session arm."),
+        checkout_session_id: z7.string().optional().describe("Session arm."),
+        checkout_url: z7.string().nullable().optional().describe("Session arm. Stripe may return null for a session URL.")
+      },
       annotations: annotationsFor("wallet_topup_checkout", "write")
     },
     async ({ pack }) => {
@@ -6992,17 +6923,15 @@ function registerWalletTools(server2, ctx) {
       const orgId = defaultOrgId;
       const start = Date.now();
       if (!pack) {
-        return ok(
-          JSON.stringify({
-            packs: PACKS.map((p) => ({
-              id: p.id,
-              eur_cents: p.eurCents,
-              bonus_pct: p.bonusPct,
-              bonus_eur_cents: bonusCentsFor(p),
-              credited_eur_cents: p.eurCents + bonusCentsFor(p)
-            }))
-          })
-        );
+        return okStructured({
+          packs: PACKS.map((p) => ({
+            id: p.id,
+            eur_cents: p.eurCents,
+            bonus_pct: p.bonusPct,
+            bonus_eur_cents: bonusCentsFor(p),
+            credited_eur_cents: p.eurCents + bonusCentsFor(p)
+          }))
+        });
       }
       const selected = resolvePack(pack);
       if (!selected) {
@@ -7021,16 +6950,14 @@ function registerWalletTools(server2, ctx) {
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok(
-          JSON.stringify({
-            org_id: orgId,
-            pack_id: selected.id,
-            pack_eur_cents: selected.eurCents,
-            bonus_eur_cents: bonusCentsFor(selected),
-            checkout_session_id: session.id,
-            checkout_url: session.url
-          })
-        );
+        return okStructured({
+          org_id: orgId,
+          pack_id: selected.id,
+          pack_eur_cents: selected.eurCents,
+          bonus_eur_cents: bonusCentsFor(selected),
+          checkout_session_id: session.id,
+          checkout_url: session.url
+        });
       } catch (e) {
         Sentry2.captureException(e);
         return err(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7045,6 +6972,26 @@ function registerWalletTools(server2, ctx) {
       inputSchema: {
         pack_cents: z7.number().int().positive().optional().describe("Override pack amount in EUR cents (must match a catalog pack).")
       },
+      /**
+       * Only the charged arm is described here — `charged: false` returns
+       * through `err()`, and the SDK skips output validation on an `isError`
+       * result.
+       *
+       * `balance_after_cents` is optional and the description above is wrong to
+       * promise it. runAutoTopup has a second success arm (wallet-tools.ts:337)
+       * where the card was charged but crediting Atlas failed: it carries
+       * `paymentIntentId` and a `reason`, and no balance. Requiring the field
+       * would turn that arm — a real charge the caller must be told about —
+       * into a validation error.
+       */
+      outputSchema: {
+        org_id: z7.string(),
+        charged: z7.literal(true),
+        credited_eur_cents: z7.number().int(),
+        balance_after_cents: z7.number().int().optional().describe("Absent when the charge succeeded but crediting is pending."),
+        payment_intent_id: z7.string().optional(),
+        note: z7.string().optional().describe("Present when the charge landed but the credit is still pending.")
+      },
       annotations: annotationsFor("wallet_auto_topup", "write")
     },
     async ({ pack_cents }) => {
@@ -7068,16 +7015,18 @@ function registerWalletTools(server2, ctx) {
             JSON.stringify({ org_id: orgId, charged: false, reason: result2.reason })
           );
         }
-        return ok(
-          JSON.stringify({
-            org_id: orgId,
-            charged: true,
-            credited_eur_cents: result2.creditedCents,
-            balance_after_cents: result2.balanceAfterCents,
-            payment_intent_id: result2.paymentIntentId,
-            ...result2.reason ? { note: result2.reason } : {}
-          })
-        );
+        return okStructured({
+          org_id: orgId,
+          charged: true,
+          credited_eur_cents: result2.creditedCents,
+          // Spread rather than assign, so the key is absent instead of set to
+          // `undefined`. JSON.stringify drops an undefined value anyway, so
+          // assigning it would make `content` and `structuredContent` disagree
+          // about whether the field is there.
+          ...result2.balanceAfterCents !== void 0 ? { balance_after_cents: result2.balanceAfterCents } : {},
+          ...result2.paymentIntentId !== void 0 ? { payment_intent_id: result2.paymentIntentId } : {},
+          ...result2.reason ? { note: result2.reason } : {}
+        });
       } catch (e) {
         Sentry2.captureException(e);
         return err(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7103,25 +7052,30 @@ async function issueConfirmToken(env, sub, toolName) {
   await env.OAUTH_KV.put(key, token2, { expirationTtl: 300 });
   return token2;
 }
-function ok2(text) {
+function ok(text) {
   return { content: [{ type: "text", text }] };
 }
 function err2(text) {
   return { isError: true, content: [{ type: "text", text }] };
 }
 async function stripeGet(stripeKey, path, connectedAccountId) {
-  const headers = { Authorization: `Bearer ${stripeKey}` };
+  const headers = {
+    Authorization: `Bearer ${stripeKey}`,
+    "Stripe-Version": "2025-08-27.basil"
+  };
   if (connectedAccountId) headers["Stripe-Account"] = connectedAccountId;
   const res = await fetch(`https://api.stripe.com${path}`, { headers });
   const data = await res.json();
   return { ok: res.ok, status: res.status, data };
 }
-async function stripePost(stripeKey, path, params, connectedAccountId) {
+async function stripePost(stripeKey, path, params, connectedAccountId, idempotencyKey) {
   const headers = {
     Authorization: `Bearer ${stripeKey}`,
+    "Stripe-Version": "2025-08-27.basil",
     "Content-Type": "application/x-www-form-urlencoded"
   };
   if (connectedAccountId) headers["Stripe-Account"] = connectedAccountId;
+  if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
   const res = await fetch(`https://api.stripe.com${path}`, {
     method: "POST",
     headers,
@@ -7130,6 +7084,9 @@ async function stripePost(stripeKey, path, params, connectedAccountId) {
   const data = await res.json();
   return { ok: res.ok, status: res.status, data };
 }
+function refundIdempotencyKey(sub, charge, amount, reason) {
+  return `carrier-refund:${sub}:${charge}:${amount ?? "full"}:${reason ?? "none"}`;
+}
 var STRIPE_CONNECT_TOOL_SCOPES = {
   stripe_connect_status: "read",
   stripe_connect_payouts: "read",
@@ -7177,7 +7134,7 @@ function registerStripeConnectTools(server2, ctx) {
         if (!stripeKey) return err2("Stripe not configured");
         const accountId = await env.CARRIER_USERS.get(opKvKey);
         if (!accountId) {
-          return ok2(JSON.stringify({ status: "not_connected", operator_id: opId }));
+          return ok(JSON.stringify({ status: "not_connected", operator_id: opId }));
         }
         const result2 = await stripeGet(stripeKey, `/v1/accounts/${accountId}`);
         if (!result2.ok) return err2(`Stripe error: ${JSON.stringify(result2.data)}`);
@@ -7192,7 +7149,7 @@ function registerStripeConnectTools(server2, ctx) {
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(JSON.stringify({
+        return ok(JSON.stringify({
           status,
           operator_id: opId,
           account_id: accountId,
@@ -7243,7 +7200,7 @@ function registerStripeConnectTools(server2, ctx) {
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(JSON.stringify({ payouts: result2.data.data, has_more: result2.data.has_more }));
+        return ok(JSON.stringify({ payouts: result2.data.data, has_more: result2.data.has_more }));
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7278,7 +7235,7 @@ function registerStripeConnectTools(server2, ctx) {
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(JSON.stringify({
+        return ok(JSON.stringify({
           account_id: accountId,
           available: result2.data.available ?? [],
           pending: result2.data.pending ?? []
@@ -7309,7 +7266,7 @@ function registerStripeConnectTools(server2, ctx) {
       const toolName = "stripe_connect_refund";
       if (!confirm_token) {
         const token2 = await issueConfirmToken(env, props2.sub, toolName);
-        return ok2(
+        return ok(
           `HARD_BLOCK: Refund ${amount_cents ? `${amount_cents} cents on` : "(full) on"} charge ${charge_id} requires confirmation.
 confirm_token: ${token2}
 Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes.`
@@ -7327,7 +7284,13 @@ Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes
         const params = { charge: charge_id };
         if (amount_cents) params.amount = String(amount_cents);
         if (reason) params.reason = reason;
-        const result2 = await stripePost(stripeKey, "/v1/refunds", params, accountId);
+        const result2 = await stripePost(
+          stripeKey,
+          "/v1/refunds",
+          params,
+          accountId,
+          refundIdempotencyKey(props2.sub, charge_id, amount_cents, reason)
+        );
         if (!result2.ok) return err2(`Stripe error: ${JSON.stringify(result2.data)}`);
         writeAudit(env, {
           tool_name: toolName,
@@ -7338,7 +7301,7 @@ Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(`Refund issued: ${result2.data.id} \u2014 status: ${result2.data.status}`);
+        return ok(`Refund issued: ${result2.data.id} \u2014 status: ${result2.data.status}`);
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7378,7 +7341,7 @@ Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(JSON.stringify({ disputes: result2.data.data, has_more: result2.data.has_more }));
+        return ok(JSON.stringify({ disputes: result2.data.data, has_more: result2.data.has_more }));
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7421,7 +7384,7 @@ Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(JSON.stringify({ reviews: result2.data.data, has_more: result2.data.has_more }));
+        return ok(JSON.stringify({ reviews: result2.data.data, has_more: result2.data.has_more }));
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7451,7 +7414,7 @@ Call again with confirm_token="${token2}" to execute. Token expires in 5 minutes
       const start = Date.now();
       if (!confirm_token) {
         const token2 = await issueConfirmToken(env, props2.sub, toolName);
-        return ok2(
+        return ok(
           `HARD_BLOCK: Approving review ${review_id} allows the charge to proceed.
 confirm_token: ${token2}
 Call again with confirm_token="${token2}" to execute. Expires in 5 minutes.`
@@ -7477,7 +7440,7 @@ Call again with confirm_token="${token2}" to execute. Expires in 5 minutes.`
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(`Review ${review_id} approved. Charge will proceed.`);
+        return ok(`Review ${review_id} approved. Charge will proceed.`);
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7507,7 +7470,7 @@ Call again with confirm_token="${token2}" to execute. Expires in 5 minutes.`
       const start = Date.now();
       if (!confirm_token) {
         const token2 = await issueConfirmToken(env, props2.sub, toolName);
-        return ok2(
+        return ok(
           `HARD_BLOCK: Declining review ${review_id} will close/block the charge.
 confirm_token: ${token2}
 Expires in 5 minutes.`
@@ -7533,7 +7496,7 @@ Expires in 5 minutes.`
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(`Review ${review_id} declined.`);
+        return ok(`Review ${review_id} declined.`);
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7564,7 +7527,7 @@ Expires in 5 minutes.`
       const start = Date.now();
       if (!confirm_token) {
         const token2 = await issueConfirmToken(env, props2.sub, toolName);
-        return ok2(
+        return ok(
           `HARD_BLOCK: Adding "${value}" to list ${value_list_id} will affect future charge decisions.
 confirm_token: ${token2}
 Expires in 5 minutes.`
@@ -7590,7 +7553,7 @@ Expires in 5 minutes.`
           sub: props2.sub,
           reseller_id: props2.reseller_id
         });
-        return ok2(`Added "${value}" to Radar list ${value_list_id}.`);
+        return ok(`Added "${value}" to Radar list ${value_list_id}.`);
       } catch (e) {
         Sentry3.captureException(e);
         return err2(`Error: ${e instanceof Error ? e.message : "unknown"}`);
@@ -7616,7 +7579,7 @@ Expires in 5 minutes.`
           "This tool acts on Carrier's platform Stripe account and is restricted to Carrier's own organization."
         );
       }
-      return ok2(
+      return ok(
         `Stripe Radar does not expose rule enable/disable via the public API.
 To ${enabled ? "enable" : "disable"} rule ${rule_id}:
 1. Open https://dashboard.stripe.com/radar/rules
@@ -7633,9 +7596,9 @@ import { z as z9 } from "zod";
 var STOREFRONT_LOGO_TOOL_SCOPES = {
   generate_storefront_logo: "read"
 };
-var ok3 = (text) => ({ content: [{ type: "text", text }] });
+var ok2 = (text) => ({ content: [{ type: "text", text }] });
 var err3 = (text) => ({ isError: true, content: [{ type: "text", text }] });
-function registerStorefrontLogoTools(server2, env = {}) {
+function registerStorefrontLogoTools(server2, env = {}, props2) {
   server2.registerTool(
     "generate_storefront_logo",
     {
@@ -7649,6 +7612,8 @@ function registerStorefrontLogoTools(server2, env = {}) {
       annotations: annotationsFor("generate_storefront_logo", "read")
     },
     async ({ name, accent, tagline }) => {
+      const denied = denyUnlessScoped(props2, "generate_storefront_logo", STOREFRONT_LOGO_TOOL_SCOPES);
+      if (denied) return denied;
       try {
         const hex = accent ? accent.startsWith("#") ? accent : `#${accent}` : void 0;
         const logo = await generateStorefrontLogo({
@@ -7657,7 +7622,7 @@ function registerStorefrontLogoTools(server2, env = {}) {
           tagline,
           env: { ...env, ...process.env }
         });
-        return ok3(
+        return ok2(
           JSON.stringify({
             brand: name,
             source: logo.source,
@@ -7682,11 +7647,11 @@ var STOREFRONT_DEPLOY_TOOL_SCOPES = {
   deploy_storefront: "write",
   provision_storefront_clerk: "write"
 };
-var ok4 = (value) => ({
+var ok3 = (value) => ({
   content: [{ type: "text", text: JSON.stringify(value) }]
 });
 var err4 = (text) => ({ isError: true, content: [{ type: "text", text }] });
-function registerStorefrontDeployTools(server2) {
+function registerStorefrontDeployTools(server2, props2) {
   server2.registerTool(
     "list_deploy_targets",
     {
@@ -7698,10 +7663,12 @@ function registerStorefrontDeployTools(server2) {
       annotations: annotationsFor("list_deploy_targets", "read")
     },
     async ({ dir }) => {
+      const denied = denyUnlessScoped(props2, "list_deploy_targets", STOREFRONT_DEPLOY_TOOL_SCOPES);
+      if (denied) return denied;
       try {
         const statuses = await probeAll(dir);
         const ranked = rankTargets(statuses);
-        return ok4({
+        return ok3({
           targets: statuses,
           default: ranked[0]?.id ?? null,
           reason: ranked.length ? void 0 : "No host is installed and logged in."
@@ -7728,6 +7695,8 @@ function registerStorefrontDeployTools(server2) {
       annotations: annotationsFor("deploy_storefront", "write")
     },
     async ({ dir, target, name, skip_build, push_secrets, verify, domain }) => {
+      const denied = denyUnlessScoped(props2, "deploy_storefront", STOREFRONT_DEPLOY_TOOL_SCOPES);
+      if (denied) return denied;
       try {
         if (target && !isTargetId(target)) return err4(`Unknown target "${target}".`);
         const brand = await loadStorefrontBrand(dir, name ? { name } : void 0);
@@ -7747,7 +7716,7 @@ function registerStorefrontDeployTools(server2) {
           return err4(result2.reason ?? "Deploy failed.");
         }
         const verification = verify !== false && result2.url ? await verifyStorefront(result2.url, dir, process.env) : void 0;
-        return ok4({
+        return ok3({
           deployed: true,
           target: result2.target,
           project: result2.projectName,
@@ -7780,6 +7749,12 @@ function registerStorefrontDeployTools(server2) {
       annotations: annotationsFor("provision_storefront_clerk", "write")
     },
     async ({ dir, name, production, no_create, url }) => {
+      const denied = denyUnlessScoped(
+        props2,
+        "provision_storefront_clerk",
+        STOREFRONT_DEPLOY_TOOL_SCOPES
+      );
+      if (denied) return denied;
       try {
         const brand = await loadStorefrontBrand(dir, name ? { name } : void 0);
         const result2 = await provisionClerk({
@@ -7792,7 +7767,7 @@ function registerStorefrontDeployTools(server2) {
           cli: clerkCliDeps()
         });
         if (!result2.ok || !result2.credentials) {
-          return ok4({
+          return ok3({
             provisioned: false,
             tier: result2.tier,
             reason: result2.reason,
@@ -7808,7 +7783,7 @@ function registerStorefrontDeployTools(server2) {
           allowedOrigins,
           redirectUrls
         });
-        return ok4({
+        return ok3({
           provisioned: true,
           tier: result2.tier,
           application_id: result2.credentials.applicationId ?? null,
@@ -10415,7 +10390,7 @@ function registerRateLimitStatusTool(server2, ctx) {
 
 // src/tools-depletion-events.ts
 import { z as z14 } from "zod";
-function ok5(payload) {
+function ok4(payload) {
   return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
 }
 function err5(message) {
@@ -10475,7 +10450,7 @@ function registerDepletionEventsTool(server2, ctx) {
       if (subscriberId) {
         const raw = await kv.get(`bundle-depleted:${subscriberId}`, "text");
         if (!raw) {
-          return ok5({
+          return ok4({
             subscriber_id: subscriberId,
             depleted: false,
             event: null,
@@ -10486,7 +10461,7 @@ function registerDepletionEventsTool(server2, ctx) {
         try {
           event = JSON.parse(raw);
         } catch {
-          return ok5({
+          return ok4({
             subscriber_id: subscriberId,
             depleted: false,
             event: null,
@@ -10494,7 +10469,7 @@ function registerDepletionEventsTool(server2, ctx) {
           });
         }
         if (!await ownsEvent(ctx, scopeToken, event.iccid)) {
-          return ok5({
+          return ok4({
             subscriber_id: subscriberId,
             depleted: false,
             event: null,
@@ -10502,14 +10477,14 @@ function registerDepletionEventsTool(server2, ctx) {
           });
         }
         if (since && event.depletedAt < since) {
-          return ok5({
+          return ok4({
             subscriber_id: subscriberId,
             depleted: false,
             event: null,
             note: `No bundle depletion after ${since}.`
           });
         }
-        return ok5({
+        return ok4({
           subscriber_id: subscriberId,
           depleted: true,
           event: {
@@ -10523,7 +10498,7 @@ function registerDepletionEventsTool(server2, ctx) {
       }
       const listResult = await kv.list({ prefix: "bundle-depleted:", limit: 20 });
       if (listResult.keys.length === 0) {
-        return ok5({
+        return ok4({
           depletions: [],
           total: 0,
           note: "No bundle depletion events in the last 7 days."
@@ -10550,7 +10525,7 @@ function registerDepletionEventsTool(server2, ctx) {
         })
       );
       events.sort((a, b) => b.depleted_at.localeCompare(a.depleted_at));
-      return ok5({
+      return ok4({
         depletions: events,
         total: events.length,
         list_truncated: !listResult.list_complete
@@ -11926,7 +11901,7 @@ function resolvePortalBaseUrl(env) {
 function getGreenzoneKv(env) {
   return env.GREENZONE_STATE_KV ?? null;
 }
-function ok6(payload) {
+function ok5(payload) {
   return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
 }
 function err6(message) {
@@ -11962,7 +11937,7 @@ function registerGreenzoneTools(server2, ctx) {
         ...ip ? buildAddIpSteps(portalBaseUrl, ip) : []
       ];
       if (dry_run) {
-        return ok6({
+        return ok5({
           dry_run: true,
           message: "Would execute the following Kapture steps against the OCS portal:",
           kapture_steps: steps,
@@ -11985,7 +11960,7 @@ function registerGreenzoneTools(server2, ctx) {
       } else {
         kvWarning = "GREENZONE_STATE_KV not bound in stdio mode \u2014 state not persisted.";
       }
-      return ok6({
+      return ok5({
         requires_kapture: true,
         message: "Execute the Kapture steps below to apply the change in the OCS portal. " + KAPTURE_UNAVAILABLE_MSG,
         kapture_steps: steps,
@@ -12023,7 +11998,7 @@ function registerGreenzoneTools(server2, ctx) {
         ...ip ? buildRemoveIpSteps(portalBaseUrl, ip) : []
       ];
       if (dry_run) {
-        return ok6({
+        return ok5({
           dry_run: true,
           message: "Would execute the following Kapture steps to remove from OCS portal:",
           kapture_steps: steps,
@@ -12046,7 +12021,7 @@ function registerGreenzoneTools(server2, ctx) {
       } else {
         kvWarning = "GREENZONE_STATE_KV not bound in stdio mode \u2014 state not persisted.";
       }
-      return ok6({
+      return ok5({
         requires_kapture: true,
         message: "Execute the Kapture steps below to apply the removal in the OCS portal. " + KAPTURE_UNAVAILABLE_MSG,
         kapture_steps: steps,
@@ -12077,7 +12052,7 @@ function registerGreenzoneTools(server2, ctx) {
       const { from_portal } = args;
       if (from_portal) {
         const portalBaseUrl = resolvePortalBaseUrl(ctx.env);
-        return ok6({
+        return ok5({
           requires_kapture: true,
           message: "Execute the Kapture steps below to read live Greenzone whitelist state from the OCS portal.",
           kapture_steps: buildListSteps(portalBaseUrl),
@@ -12086,7 +12061,7 @@ function registerGreenzoneTools(server2, ctx) {
       }
       const kv = getGreenzoneKv(ctx.env);
       if (!kv) {
-        return ok6({
+        return ok5({
           source: "kv_cache",
           hosts: [],
           ips: [],
@@ -12098,7 +12073,7 @@ function registerGreenzoneTools(server2, ctx) {
       }
       try {
         const state = await readState(kv);
-        return ok6({
+        return ok5({
           source: "kv_cache",
           hosts: state.hosts,
           ips: state.ips,
@@ -12115,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)
+          }
+        ]
+      };
+    }
   );
 }
 
@@ -12177,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
@@ -12222,15 +12389,22 @@ 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);
-registerStorefrontLogoTools(server, stdioEnv);
-registerStorefrontDeployTools(server);
+registerUiAgentGenericTools(server, toolCtx, uiAgentRuntime);
+registerStorefrontLogoTools(
+  server,
+  stdioEnv,
+  props
+);
+registerStorefrontDeployTools(server, props);
 registerAllPrompts(server);
 var transport = new StdioServerTransport();
 await server.connect(transport);