@carrierllc/mcp 0.9.3 → 0.10.1

package/dist/index.js

@@ -2,10 +2,11 @@
 import {
   CARRIER_VERSION,
   OCS_MAX_USAGE_WINDOW_DAYS,
+  OcsApiError,
+  OcsClient,
   ROUTER_RULES,
   TARGET_IDS,
-  acquireEndpointSlot,
-  applyParamRenames,
+  activePeriodFromPackages,
   applySubscriberFilters,
   buildListSubscriberParams,
   buildRouterCatalog,
@@ -33,21 +34,24 @@ import {
   networkEventsOverPeriodParams,
   normalizePackageTemplate,
   normalizePackageTemplateChanges,
+  ocsLocalDateTime,
+  packageActivePeriodParams,
+  prepaidPackageLimits,
   probeAll,
   provisionClerk,
   rankTargets,
   recordToolDescription,
+  recurringIdForPackage,
   recurringPackageParams,
   renderHtml,
   repairPlanFor,
-  runWithBudget,
   storefrontClerkUrls,
   subscriberIdParams,
   subscriberRows,
   usageOverPeriodParams,
   verifyStorefront,
   withOcsListSummary
-} from "./chunk-KHNJNJX3.js";
+} from "./chunk-DP4ICKYF.js";
 import "./chunk-SHKKVIIA.js";
 
 // src/index.ts
@@ -58,59 +62,6 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import * as Sentry from "@sentry/cloudflare";
 
-// src/client.ts
-var OcsApiError = class extends Error {
-  constructor(code, message, method) {
-    super(`[${method}] OCS error ${code}: ${message}`);
-    this.code = code;
-    this.method = method;
-    this.name = "OcsApiError";
-  }
-  code;
-  method;
-};
-var OcsClient = class {
-  baseUrl;
-  token;
-  constructor(baseUrl2, token2) {
-    this.baseUrl = baseUrl2.replace(/\/+$/, "");
-    this.token = token2;
-  }
-  async call(method, params = {}) {
-    await acquireEndpointSlot(this.token, method, "interactive");
-    const url = `${this.baseUrl}/v1?token=${this.token}`;
-    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);
-      }
-      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;
-        }
-        if (json["subscriberLocation"] !== void 0) {
-          return json["subscriberLocation"];
-        }
-      }
-      return json[method] ?? json;
-    });
-  }
-};
-
 // ../../packages/carrier-ai/dist/index.js
 import { AwsClient } from "aws4fetch";
 var AI_TIER_POLICY = {
@@ -360,6 +311,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 = {
@@ -907,7 +1321,12 @@ function registerAllTools(server2, ctx) {
       TOOL_SCOPES["modify_account_balance"],
       ctx,
       async ({ accountId, amount, mode }, token2) => {
-        const params = { accountId, amount, mode };
+        const params = { accountId };
+        if (mode === "set") {
+          params.setBalance = amount;
+        } else {
+          params.amount = amount;
+        }
         return ocsCall(ctx.env, token2, "modifyAccountBalance", params);
       }
     )
@@ -1288,11 +1707,13 @@ function registerAllTools(server2, ctx) {
     "move_subscriber_range_to_account",
     {
       title: "Move Subscribers to Account",
-      description: "Use this to move a contiguous ICCID range of subscribers to a different account. Useful for bulk subscriber migrations between accounts or during account restructuring. Params: `iccidFrom` (start ICCID of range, inclusive), `iccidTo` (end ICCID of range, inclusive), `accountId` (target account ID from `list_reseller_accounts`). Returns: OCS confirmation of the range move with affected subscriber count. Do NOT use this for a single subscriber move \u2014 provide identical iccidFrom and iccidTo. Always call `list_subscribers` on the range first to verify the correct subscribers are included.",
+      description: "BREAKING CHANGE (2026-08-28): this tool's contract was rebuilt around account-ID ranges to match what OCS actually accepts \u2014 ICCID-pair targeting (`iccidFrom`/`iccidTo` + a single `accountId`) is gone. Zero field names were ever shared with OCS's real `moveSubscriberRangeToAccount` shape (verified live 2026-08-24 \u2014 see packages/ocs-spec/ocs-accepted-params.json), so every prior call to this tool failed outright; nothing that used to work stops working. Use this to move a contiguous range of subscribers, identified by IMSI or ICCID, from one account to another. Cross-reseller moves lose the subscribers' packages. Params: `srcAccountId` (source account ID from `list_reseller_accounts`), `destAccount` (destination account ID), `rangeType` ('IMSI' | 'ICCID' \u2014 which identifier `rangeStart`/`rangeEnd` are expressed in), `rangeStart` (inclusive start of the range), `rangeEnd` (inclusive end of the range). Returns: OCS confirmation with the count of subscribers moved. Do NOT use this for a single subscriber move \u2014 provide identical rangeStart and rangeEnd. Always call `list_subscribers` on the range first to verify the correct subscribers are included.",
       inputSchema: {
-        iccidFrom: z.string().describe("Start ICCID of range"),
-        iccidTo: z.string().describe("End ICCID of range"),
-        accountId: z.number().describe("Target account ID"),
+        srcAccountId: z.number().describe("Source account ID to move subscribers FROM"),
+        destAccount: z.number().describe("Destination account ID to move subscribers TO"),
+        rangeType: z.enum(["IMSI", "ICCID"]).describe("Whether rangeStart/rangeEnd identify subscribers by IMSI or ICCID"),
+        rangeStart: z.string().describe("Inclusive start of the identifier range"),
+        rangeEnd: z.string().describe("Inclusive end of the identifier range"),
         ...DRY_RUN_FIELD
       },
       annotations: { destructiveHint: true }
@@ -1302,10 +1723,12 @@ function registerAllTools(server2, ctx) {
       "moveSubscriberRangeToAccount",
       TOOL_SCOPES["move_subscriber_range_to_account"],
       ctx,
-      async ({ iccidFrom, iccidTo, accountId }, token2) => ocsCall(ctx.env, token2, "moveSubscriberRangeToAccount", {
-        iccidFrom,
-        iccidTo,
-        accountId
+      async ({ srcAccountId, destAccount, rangeType, rangeStart, rangeEnd }, token2) => ocsCall(ctx.env, token2, "moveSubscriberRangeToAccount", {
+        srcAccountId,
+        destAccount,
+        rangeType,
+        rangeStart,
+        rangeEnd
       })
     )
   );
@@ -1494,11 +1917,17 @@ function registerAllTools(server2, ctx) {
       "modifySubscriberPrepaidPackageLimits",
       TOOL_SCOPES["modify_package_limits"],
       ctx,
-      async ({ iccid, packageId, limits }, token2) => ocsCall(ctx.env, token2, "modifySubscriberPrepaidPackageLimits", {
-        iccid,
-        packageId,
-        ...JSON.parse(limits)
-      })
+      async ({ packageId, limits }, token2) => (
+        // OCS accepts only packageId/newLimits/comment here, so `iccid` never
+        // reaches the wire, and the limits nest under `newLimits`
+        // (dataByte/mocSecond/mtcSecond/moSms/mtSms) rather than sitting flat.
+        // mcp-stdio is a BYO-token surface, so unlike mcp-server there is no
+        // ownership-evidence use for the ICCID here.
+        ocsCall(ctx.env, token2, "modifySubscriberPrepaidPackageLimits", {
+          packageId,
+          newLimits: prepaidPackageLimits(JSON.parse(limits))
+        })
+      )
     )
   );
   server2.registerTool(
@@ -1530,9 +1959,11 @@ function registerAllTools(server2, ctx) {
       "modifySubscriberPrepaidPackageExpDate",
       TOOL_SCOPES["modify_package_expiry"],
       ctx,
-      async ({ iccid, packageId, expirationDate, validity_days }, token2) => {
-        const params = { iccid, packageId };
-        if (expirationDate !== void 0) params.expirationDate = expirationDate;
+      async ({ packageId, expirationDate, validity_days }, token2) => {
+        const params = { packageId };
+        if (expirationDate !== void 0) {
+          params.newExpirationDate = ocsLocalDateTime(expirationDate);
+        }
         if (validity_days !== void 0) params.newValidityDuration = validity_days;
         return ocsCall(ctx.env, token2, "modifySubscriberPrepaidPackageExpDate", params);
       }
@@ -1556,11 +1987,24 @@ function registerAllTools(server2, ctx) {
       "modifySubscriberPrepaidPackageStatus",
       TOOL_SCOPES["modify_package_status"],
       ctx,
-      async ({ iccid, packageId, status }, token2) => ocsCall(ctx.env, token2, "modifySubscriberPrepaidPackageStatus", {
-        iccid,
-        packageId,
-        status
-      })
+      async ({ packageId, status }, token2) => {
+        const normalised = String(status).trim().toUpperCase();
+        if (normalised !== "ACTIVE" && normalised !== "INACTIVE") {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Invalid status "${status}". Use "ACTIVE" or "INACTIVE".`
+              }
+            ]
+          };
+        }
+        return ocsCall(ctx.env, token2, "modifySubscriberPrepaidPackageStatus", {
+          subsPrepaidPackageId: packageId,
+          active: normalised === "ACTIVE"
+        });
+      }
     )
   );
   server2.registerTool(
@@ -1581,11 +2025,29 @@ function registerAllTools(server2, ctx) {
       "stopResumeSubsRecurringPackage",
       TOOL_SCOPES["stop_resume_recurring_package"],
       ctx,
-      async ({ iccid, packageId, action }, token2) => ocsCall(ctx.env, token2, "stopResumeSubsRecurringPackage", {
-        iccid,
-        packageId,
-        action
-      })
+      async ({ iccid, packageId, action }, token2) => {
+        const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
+        const listed = await client2.call(
+          "listSubscriberPrepaidPackages",
+          { iccid }
+        );
+        const recurringId = recurringIdForPackage(listed, packageId);
+        if (recurringId === void 0) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Package ${packageId} is not a recurring package on ICCID ${iccid}. stop_resume_recurring_package needs a package that came from a recurring template \u2014 call list_subscriber_packages and pick one that reports a recurring subscription.`
+              }
+            ]
+          };
+        }
+        return ocsCall(ctx.env, token2, "stopResumeSubsRecurringPackage", {
+          recurringId,
+          active: action === "resume"
+        });
+      }
     )
   );
   server2.registerTool(
@@ -3708,7 +4170,7 @@ function registerIntelligenceTools(server2, ctx) {
   }, async ({ accountId }) => {
     const token2 = await ctx.getUserToken(ctx.props.sub);
     const resellerId = await getDefaultResellerId(ctx.env, token2).catch(() => void 0);
-    const [statusResult, accountsResult] = await Promise.all([
+    const [statusResult, accountsResult, resellerInfoResult] = await Promise.all([
       safeCall(
         ctx.env,
         token2,
@@ -3720,7 +4182,17 @@ function registerIntelligenceTools(server2, ctx) {
         token2,
         "listResellerAccount",
         resellerId !== void 0 ? { resellerId } : {}
-      )
+      ),
+      // The reseller's OWN balance. Sub-account balances cannot show that the
+      // parent is out of credit, and that is the one state which silently
+      // zeroes every rating group (2026-08-28: reseller 1170 at 0.00 while
+      // fleet_health reported "require no action").
+      resellerId !== void 0 ? safeCall(
+        ctx.env,
+        token2,
+        "getResellerInfo",
+        { id: resellerId }
+      ) : Promise.resolve({ data: null, error: null })
     ]);
     const sections = ["# Fleet Health Dashboard\n"];
     const counts = extractEsimStatusCounts(statusResult.data);
@@ -3769,11 +4241,20 @@ High suspension rate (${totalSuspended} suspended vs ${totalActive} active)`);
       const criticalZero = accounts.filter(
         (a) => a.packageOnly === false && Number(a.balance ?? 0) <= 0
       );
+      const resellerRaw = resellerInfoResult?.data ?? null;
+      const rawBalance = resellerRaw?.getResellerInfo?.balance;
+      const resellerBalance = rawBalance === void 0 || rawBalance === null ? null : Number(rawBalance);
+      const resellerOutOfCredit = resellerBalance !== null && resellerBalance <= 0;
       sections.push(`
 ## Account Summary`);
       sections.push(`- Total accounts: ${accounts.length}`);
       sections.push(`- Low balance (< 10): ${lowBalance.length}`);
       sections.push(`- Package-only with 0 balance: ${packageOnlyZero.length}`);
+      if (resellerBalance !== null) {
+        sections.push(
+          `- Reseller balance: ${resellerBalance.toFixed(2)}` + (resellerOutOfCredit ? ` (OUT OF CREDIT - nothing can be rated)` : ``)
+        );
+      }
       if (lowBalance.length > 0) {
         sections.push(`
 ### Low Balance Accounts (< 10)`);
@@ -3803,8 +4284,15 @@ Action: top up non-package-only accounts at 0 balance to restore rated traffic.`
         sections.push(`
 All accounts healthy.`);
       } else if (informational > 0 && warning <= 0) {
-        sections.push(`
+        if (resellerOutOfCredit) {
+          sections.push(
+            `
+Action: reseller balance is ${resellerBalance.toFixed(2)}. Package-only accounts draw on their packages, but a reseller at 0 cannot rate any traffic - sessions are accepted and granted 0 bytes. Top up the reseller.`
+          );
+        } else {
+          sections.push(`
 Package-only accounts at 0 balance require no action.`);
+        }
       }
     } else {
       sections.push(`
@@ -4625,7 +5113,7 @@ function registerAllBacklogTools(server2, ctx) {
         const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
         const result2 = await client2.call(
           "modifySubscriberMobilePlan",
-          { subscriber: iccid, mobilePlanId: mobile_plan_id }
+          { subscriberId: { iccid }, mobilePlanId: mobile_plan_id }
         );
         return {
           content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
@@ -4643,6 +5131,9 @@ function registerAllBacklogTools(server2, ctx) {
         package_id: z3.number().describe("The subscriber package ID (from list_subscriber_packages)"),
         start_date: z3.string().optional().describe("New start date in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss)"),
         end_date: z3.string().optional().describe("New end date in ISO 8601 format (YYYY-MM-DD or YYYY-MM-DDTHH:mm:ss)"),
+        comment: z3.string().optional().describe(
+          "Audit note stored on the OCS package record. OCS requires this field, so a default is sent when it is omitted."
+        ),
         ...DRY_RUN_FIELD2
       },
       annotations: { destructiveHint: true }
@@ -4652,11 +5143,22 @@ function registerAllBacklogTools(server2, ctx) {
       "modifySubscriberPrepaidPackageActivePeriod",
       BACKLOG_TOOL_SCOPES["modify_subscriber_package_active_period"],
       ctx,
-      async ({ iccid, package_id, start_date, end_date }, token2) => {
-        const params = { subscriber: iccid, packageId: package_id };
-        if (start_date !== void 0) params.startDate = start_date;
-        if (end_date !== void 0) params.endDate = end_date;
+      async ({ iccid, package_id, start_date, end_date, comment }, token2) => {
         const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
+        let current;
+        if (start_date === void 0 || end_date === void 0) {
+          const listed = await client2.call("listSubscriberPrepaidPackages", { iccid });
+          current = activePeriodFromPackages(listed, package_id);
+          if (!current) {
+            throw new Error(`Package ${package_id} is not on subscriber ${iccid}`);
+          }
+        }
+        const params = packageActivePeriodParams(package_id, {
+          startDate: start_date,
+          endDate: end_date,
+          comment,
+          current
+        });
         const result2 = await client2.call(
           "modifySubscriberPrepaidPackageActivePeriod",
           params
@@ -4688,7 +5190,7 @@ function registerAllBacklogTools(server2, ctx) {
         const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
         const result2 = await client2.call(
           "modifySubscriberVoipPlan",
-          { subscriber: iccid, voipPlanId: voip_plan_id }
+          { subscriberId: { iccid }, voipPlanId: voip_plan_id }
         );
         return {
           content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
@@ -4713,13 +5215,10 @@ function registerAllBacklogTools(server2, ctx) {
       BACKLOG_TOOL_SCOPES["push_steering_to_subscriber"],
       ctx,
       async ({ iccid }, token2) => {
-        const cache = /* @__PURE__ */ new Map();
-        const sub = await resolveSubscriberByIccid(ctx.env, token2, iccid, cache);
-        const subscriberId = sub.id ?? sub.subscriberId ?? iccid;
         const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
         const result2 = await client2.call(
           "pushSteeringToSubs",
-          { subscriber: subscriberId }
+          { iccid }
         );
         return {
           content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
@@ -4745,7 +5244,7 @@ function registerAllBacklogTools(server2, ctx) {
       ctx,
       async ({ iccid }, token2) => {
         const client2 = new OcsClient(ctx.env.CARRIER_OCS_BASE_URL, token2);
-        const result2 = await client2.call("resetSubsGzCounter", { subscriber: iccid });
+        const result2 = await client2.call("resetSubsGzCounter", { iccid });
         return {
           content: [{ type: "text", text: JSON.stringify(result2, null, 2) }]
         };
@@ -4888,124 +5387,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() {
+// src/ui-agent-stub.ts
+var REMOTE_MCP_URL = "https://mcp.carrier.llc/mcp";
+var REASON_TEXT = {
+  ocs_portal_credentials: "drives the OCS web dashboard, which needs OCS portal login credentials. Those are stored in Clerk private metadata and read through the Clerk Backend API, which the local CLI has no secret for.",
+  recurring_runtime: "needs a recurring runtime. Browser Use Cloud has no native scheduler, so the hosted Worker implements schedules with KV plus a Cloudflare Cron Trigger and leader election. A CLI process exits when the client disconnects, so a schedule created here would never fire."
+};
+function uiAgentStubError(toolName, reason) {
   return {
     isError: true,
     content: [
       {
         type: "text",
         text: JSON.stringify({
-          error: "ocs_portal_not_linked",
-          message: "OCS portal credentials are not configured. An organisation admin must link their OCS portal login via the Carrier Console settings page (Organisation Profile \u2192 OCS Portal) before UI-agent operations can be dispatched.",
-          action: "Navigate to https://console.carrier.llc/settings and link your OCS portal credentials."
+          error: "requires_worker_runtime",
+          tool: toolName,
+          reason,
+          message: `${toolName} ${REASON_TEXT[reason]} Connect to the remote Carrier MCP Worker to use this tool. Generic web browsing (ui_agent_ask / ui_agent_status) does work locally \u2014 set BROWSER_USE_API_KEY.`,
+          remote_url: REMOTE_MCP_URL
         })
       }
     ]
   };
 }
-function noManusKeyError() {
-  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."
-        })
-      }
-    ]
-  };
+
+// src/portal-credentials.ts
+var PORTAL_OPT_IN_ENV = "CARRIER_ALLOW_PORTAL_PASSWORD";
+var PORTAL_USERNAME_ENV = "CARRIER_OCS_PORTAL_USERNAME";
+var PORTAL_PASSWORD_ENV = "CARRIER_OCS_PORTAL_PASSWORD";
+var PORTAL_DASHBOARD_ENV = "CARRIER_OCS_DASHBOARD_URL";
+var PORTAL_PASSWORD_WARNING = [
+  `${PORTAL_OPT_IN_ENV} is set: the ten OCS-dashboard tools will use the portal login in`,
+  `${PORTAL_USERNAME_ENV} / ${PORTAL_PASSWORD_ENV}.`,
+  "",
+  "That password is full dashboard access, not a scoped API token. Held in an environment",
+  "variable it is readable from shell history, from `ps` output by any process on this",
+  "machine, and from CI logs if this runs in CI. Carrier never logs it, returns it in tool",
+  "output, or writes it to an audit row, but it is sent to Browser Use Cloud, which types it",
+  "into the OCS login form.",
+  "",
+  "Each dashboard run also costs roughly $0.20-1.00 against your own BROWSER_USE_API_KEY.",
+  "",
+  `Unset ${PORTAL_OPT_IN_ENV} to turn this off; the tools then refuse as they did before.`
+].join("\n");
+var PORTAL_PASSWORD_RUN_NOTE = `This run used the OCS portal password from ${PORTAL_PASSWORD_ENV}, enabled by ${PORTAL_OPT_IN_ENV}. That credential is full dashboard access and was sent to Browser Use Cloud to type into the OCS login form. It is not logged, audited or returned anywhere in this response.`;
+function flagSet(raw) {
+  if (raw === void 0) return false;
+  const v = raw.trim().toLowerCase();
+  return v === "1" || v === "true";
+}
+function nonEmpty(raw) {
+  if (raw === void 0) return void 0;
+  return raw.length > 0 ? raw : void 0;
+}
+function readPortalOptIn(env = process.env) {
+  const flag = flagSet(env[PORTAL_OPT_IN_ENV]);
+  const username = nonEmpty(env[PORTAL_USERNAME_ENV]);
+  const password = nonEmpty(env[PORTAL_PASSWORD_ENV]);
+  const hasCredentials = username !== void 0 && password !== void 0;
+  if (flag && hasCredentials) {
+    return {
+      enabled: true,
+      credentials: { username, password },
+      ...nonEmpty(env[PORTAL_DASHBOARD_ENV]) ? { dashboardUrl: env[PORTAL_DASHBOARD_ENV] } : {}
+    };
+  }
+  if (flag) return { enabled: false, gap: "flag_without_credentials" };
+  if (hasCredentials)
+    return { enabled: false, gap: "credentials_without_flag" };
+  return { enabled: false, gap: "not_requested" };
+}
+function warnPortalOptIn(optIn, write = (line) => console.error(line)) {
+  if (optIn.enabled) {
+    write(PORTAL_PASSWORD_WARNING);
+    return;
+  }
+  if (optIn.gap === "flag_without_credentials") {
+    write(PORTAL_PASSWORD_WARNING);
+    write(
+      `${PORTAL_USERNAME_ENV} and ${PORTAL_PASSWORD_ENV} are not both set, so the OCS-dashboard tools stay disabled.`
+    );
+    return;
+  }
+  if (optIn.gap === "credentials_without_flag") {
+    write(
+      `${PORTAL_PASSWORD_ENV} is set but ${PORTAL_OPT_IN_ENV} is not, so the OCS-dashboard tools stay disabled and this portal password is unused. Unset it unless you mean to opt in.`
+    );
+  }
 }
-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/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 UI_AGENT_RESULT_SCHEMA = {
-  type: "object",
-  properties: {
-    success: { type: "boolean", description: "Whether the operation completed successfully" },
-    summary: { type: "string", description: "Human-readable summary of what was done" },
-    entity_id: { type: "string", description: "ID of the created/modified entity (if applicable)" },
-    error_message: { type: "string", description: "Error description if the operation failed" },
-    screenshots_taken: { type: "number", description: "Number of screenshots captured during the operation" }
-  },
-  required: ["success", "summary"]
+var 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
@@ -5020,114 +5615,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,
@@ -5138,57 +5749,44 @@ Report success or failure with a clear summary.`;
         content: [
           {
             type: "text",
-            text: `Error dispatching UI agent: ${err7 instanceof Error ? err7.message : String(err7)}`
+            text: redact(
+              `Error dispatching the UI agent: ${err7 instanceof Error ? err7.message : String(err7)}`
+            )
           }
         ]
       };
     }
   };
 }
-var UI_AGENT_TOOL_SCOPES = {
-  ui_create_steering_list: "write",
-  ui_build_steering_list: "write",
-  ui_set_account_steering_list: "write",
-  ui_request_reseller_relay_change: "write",
-  ui_create_account: "admin",
-  ui_create_destination_list: "write",
-  ui_edit_destination_list: "write",
-  ui_delete_destination_list: "admin",
-  ui_delete_package_template: "admin",
-  ui_edit_location_zone: "write",
-  ui_delete_location_zone: "admin"
-};
-function registerAllUiAgentTools(server2, ctx) {
+function registerAllUiAgentTools(server2, ctx, runtime, optIn = readPortalOptIn()) {
+  const NOTE = stdioNote(optIn);
+  const gated = (toolName, gapId, scope, buildPrompt) => wrapPortalHandler(toolName, gapId, scope, ctx, runtime, optIn, buildPrompt);
   server2.registerTool(
     "ui_create_steering_list",
     {
       title: "Create Steering List (UI Agent)",
-      description: "Creates a new network steering list (OPLMN preference configuration) via the OCS web dashboard. This operation is not available via the OCS REST API. A Manus browser agent will be dispatched to perform the operation. Params: `name` (steering list name), `description` (optional). Returns: dispatch confirmation with Manus task ID for tracking.",
+      description: "Creates a new network steering list (OPLMN preference configuration) via the OCS web dashboard. This operation is not available via the OCS REST API. A browser agent is dispatched to perform the operation. Params: `name` (steering list name), `description` (optional)." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new steering list"),
         description: z4.string().optional().describe("Optional description for the steering list"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_steering_list",
       "G-01",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
-Create a new steering list with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + `Click the "Create" or "Add" button to create the steering list.
-After creation, note the new steering list ID from the dashboard.
-`
+      (args, dashboardUrl) => buildCreateSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_build_steering_list",
     {
       title: "Build Steering List (UI Agent)",
-      description: "Adds or removes operators (MCC-MNC) from an existing steering list via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `steering_list_id`, `add_operators` (array of MCC-MNC to add), `remove_operators` (array to remove), `operator_type` ('priority' or 'excluded').",
+      description: "Adds or removes operators (MCC-MNC) from an existing steering list via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `steering_list_id`, `add_operators` (array of MCC-MNC to add), `remove_operators` (array to remove), `operator_type` ('priority' or 'excluded')." + NOTE,
       inputSchema: {
         steering_list_id: z4.number().describe("ID of the steering list to modify"),
         add_operators: z4.array(z4.string()).optional().describe("MCC-MNC codes to add (e.g. ['20801', '26201'])"),
@@ -5197,42 +5795,35 @@ After creation, note the new steering list ID from the dashboard.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_build_steering_list",
       "G-02",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Steering Lists section of the OCS dashboard at ${dashboardUrl}.
-Open steering list ID ${args.steering_list_id} for editing.
-Operator type: ${args.operator_type ?? "priority"}
-` + (args.add_operators && args.add_operators.length > 0 ? `Add the following operators: ${args.add_operators.join(", ")}
-` : "") + (args.remove_operators && args.remove_operators.length > 0 ? `Remove the following operators: ${args.remove_operators.join(", ")}
-` : "") + `Save the changes and verify the updated operator list.
-`
+      (args, dashboardUrl) => buildBuildSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_set_account_steering_list",
     {
       title: "Set Account Steering List (UI Agent)",
-      description: "Assigns or removes a steering list at the account level via the OCS web dashboard. The subscriber-level counterpart `modify_subscriber_steering_list` is available via API; this account-level operation is UI-only. Params: `account_id`, `steering_list_id` (0 to remove).",
+      description: "Assigns or removes a steering list at the account level via the OCS web dashboard. The subscriber-level counterpart `modify_subscriber_steering_list` is available via API; this account-level operation is UI-only. Params: `account_id`, `steering_list_id` (0 to remove)." + NOTE,
       inputSchema: {
         account_id: z4.number().describe("Account ID to assign the steering list to"),
         steering_list_id: z4.number().describe("Steering list ID to assign (0 to remove/unset)"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_set_account_steering_list",
       "G-03",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
-Open account ID ${args.account_id}.
-` + (args.steering_list_id === 0 ? `Remove/unset the steering list assignment from this account.
-` : `Assign steering list ID ${args.steering_list_id} to this account.
-`) + `Save the changes and verify the steering list assignment is updated.
-`
+      (args, dashboardUrl) => buildSetAccountSteeringListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
@@ -5252,7 +5843,12 @@ Open account ID ${args.account_id}.
       if (!ctx.props.scope.includes("write")) {
         return {
           isError: true,
-          content: [{ type: "text", text: "Scope denied: tool 'ui_request_reseller_relay_change' requires 'write' scope." }]
+          content: [
+            {
+              type: "text",
+              text: "Scope denied: tool 'ui_request_reseller_relay_change' requires 'write' scope."
+            }
+          ]
         };
       }
       const resellerId = args.reseller_id ?? ctx.props.reseller_id;
@@ -5264,7 +5860,15 @@ Open account ID ${args.account_id}.
       if (requested.length === 0) {
         return {
           isError: true,
-          content: [{ type: "text", text: JSON.stringify({ error: "relay_state_required", message: "Choose at least one relay flag and desired state." }) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "relay_state_required",
+                message: "Choose at least one relay flag and desired state."
+              })
+            }
+          ]
         };
       }
       const draft = [
@@ -5284,14 +5888,23 @@ Open account ID ${args.account_id}.
         event_type: "ui_agent_dispatch"
       });
       return {
-        content: [{ type: "text", text: JSON.stringify({
-          status: "parent_request_drafted",
-          capability: "parent_controlled",
-          reseller_id: resellerId,
-          parent_reseller: resellerId === 1170 ? "Bridge4IP" : "parent reseller/support",
-          draft,
-          sent: false
-        }, null, 2) }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                status: "parent_request_drafted",
+                capability: "parent_controlled",
+                reseller_id: resellerId,
+                parent_reseller: resellerId === 1170 ? "Bridge4IP" : "parent reseller/support",
+                draft,
+                sent: false
+              },
+              null,
+              2
+            )
+          }
+        ]
       };
     }
   );
@@ -5299,7 +5912,7 @@ Open account ID ${args.account_id}.
     "ui_create_account",
     {
       title: "Create Account (UI Agent)",
-      description: "Creates a new sub-account under the reseller via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `name` (account name), `description` (optional), `initial_balance` (optional, default 0).",
+      description: "Creates a new sub-account under the reseller via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `name` (account name), `description` (optional), `initial_balance` (optional, default 0)." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new account"),
         description: z4.string().optional().describe("Optional description"),
@@ -5307,26 +5920,21 @@ Open account ID ${args.account_id}.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_account",
       "G-05",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Accounts section of the OCS dashboard at ${dashboardUrl}.
-Create a new account with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + (args.initial_balance ? `  Initial balance: ${args.initial_balance}
-` : "") + `Click the "Create" or "Add" button.
-After creation, note the new account ID from the dashboard.
-`
+      (args, dashboardUrl) => buildCreateAccountPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_create_destination_list",
     {
       title: "Create Destination List (UI Agent)",
-      description: "Creates a new destination list (named set of phone number prefixes for MOC call permissions) via the OCS web dashboard. Params: `name`, `prefixes` (array of prefix strings), `description`.",
+      description: "Creates a new destination list (named set of phone number prefixes for MOC call permissions) via the OCS web dashboard. Params: `name`, `prefixes` (array of prefix strings), `description`." + NOTE,
       inputSchema: {
         name: z4.string().describe("Name for the new destination list"),
         prefixes: z4.array(z4.string()).optional().describe("Phone number prefixes to include (e.g. ['+31', '+49'])"),
@@ -5334,25 +5942,21 @@ After creation, note the new account ID from the dashboard.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_create_destination_list",
       "G-12",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Create a new destination list with the following details:
-  Name: ${args.name}
-` + (args.description ? `  Description: ${args.description}
-` : "") + (args.prefixes && args.prefixes.length > 0 ? `  Prefixes to add: ${args.prefixes.join(", ")}
-` : "") + `Save the new destination list and note the ID.
-`
+      (args, dashboardUrl) => buildCreateDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_edit_destination_list",
     {
       title: "Edit Destination List (UI Agent)",
-      description: "Edits an existing destination list via the OCS web dashboard. Params: `destination_list_id`, `add_prefixes`, `remove_prefixes`, `new_name`.",
+      description: "Edits an existing destination list via the OCS web dashboard. Params: `destination_list_id`, `add_prefixes`, `remove_prefixes`, `new_name`." + NOTE,
       inputSchema: {
         destination_list_id: z4.number().describe("ID of the destination list to edit"),
         add_prefixes: z4.array(z4.string()).optional().describe("Prefixes to add"),
@@ -5361,69 +5965,61 @@ Create a new destination list with the following details:
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_edit_destination_list",
       "G-12",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Open destination list ID ${args.destination_list_id} for editing.
-` + (args.new_name ? `Rename to: ${args.new_name}
-` : "") + (args.add_prefixes && args.add_prefixes.length > 0 ? `Add prefixes: ${args.add_prefixes.join(", ")}
-` : "") + (args.remove_prefixes && args.remove_prefixes.length > 0 ? `Remove prefixes: ${args.remove_prefixes.join(", ")}
-` : "") + `Save the changes and verify the updated prefix list.
-`
+      (args, dashboardUrl) => buildEditDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_destination_list",
     {
       title: "Delete Destination List (UI Agent)",
-      description: "Deletes a destination list via the OCS web dashboard. Params: `destination_list_id`. WARNING: This is destructive and cannot be undone.",
+      description: "Deletes a destination list via the OCS web dashboard. Params: `destination_list_id`. WARNING: This is destructive and cannot be undone." + NOTE,
       inputSchema: {
         destination_list_id: z4.number().describe("ID of the destination list to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_destination_list",
       "G-12",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Destination Lists section of the OCS dashboard at ${dashboardUrl}.
-Find destination list ID ${args.destination_list_id}.
-Delete this destination list. Confirm the deletion when prompted.
-Verify the list no longer appears in the dashboard.
-`
+      (args, dashboardUrl) => buildDeleteDestinationListPrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_package_template",
     {
       title: "Delete Package Template (UI Agent)",
-      description: "Deletes a package template from the product catalog via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `template_id`. WARNING: This is destructive.",
+      description: "Deletes a package template from the product catalog via the OCS web dashboard. This operation is not available via the OCS REST API. Params: `template_id`. WARNING: This is destructive." + NOTE,
       inputSchema: {
         template_id: z4.number().describe("ID of the package template to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_package_template",
       "G-18",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Package Templates section of the OCS dashboard at ${dashboardUrl}.
-Find package template ID ${args.template_id}.
-Delete this package template. Confirm the deletion when prompted.
-Verify the template no longer appears in the template list.
-`
+      (args, dashboardUrl) => buildDeletePackageTemplatePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_edit_location_zone",
     {
       title: "Edit Location Zone (UI Agent)",
-      description: "Edits an existing location zone via the OCS web dashboard. `create_location_zone` is available via API; edit is UI-only. Params: `zone_id`, `new_name`, `add_countries`, `remove_countries`.",
+      description: "Edits an existing location zone via the OCS web dashboard. `create_location_zone` is available via API; edit is UI-only. Params: `zone_id`, `new_name`, `add_countries`, `remove_countries`." + NOTE,
       inputSchema: {
         zone_id: z4.number().describe("ID of the location zone to edit"),
         new_name: z4.string().optional().describe("Rename the location zone"),
@@ -5432,137 +6028,40 @@ Verify the template no longer appears in the template list.
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_edit_location_zone",
       "G-19",
       "write",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
-Open location zone ID ${args.zone_id} for editing.
-` + (args.new_name ? `Rename to: ${args.new_name}
-` : "") + (args.add_countries && args.add_countries.length > 0 ? `Add countries: ${args.add_countries.join(", ")}
-` : "") + (args.remove_countries && args.remove_countries.length > 0 ? `Remove countries: ${args.remove_countries.join(", ")}
-` : "") + `Save the changes and verify the updated country list.
-`
+      (args, dashboardUrl) => buildEditLocationZonePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
   server2.registerTool(
     "ui_delete_location_zone",
     {
       title: "Delete Location Zone (UI Agent)",
-      description: "Deletes a location zone via the OCS web dashboard. `create_location_zone` is available via API; delete is UI-only. Params: `zone_id`. WARNING: Zones in use by active templates may not be deletable.",
+      description: "Deletes a location zone via the OCS web dashboard. `create_location_zone` is available via API; delete is UI-only. Params: `zone_id`. WARNING: Zones in use by active templates may not be deletable." + NOTE,
       inputSchema: {
         zone_id: z4.number().describe("ID of the location zone to delete"),
         dry_run: z4.boolean().optional().describe("Preview the agent prompt without dispatching")
       }
     },
-    wrapUiAgentHandler(
+    gated(
       "ui_delete_location_zone",
       "G-19",
       "admin",
-      ctx,
-      (args, dashboardUrl) => `Navigate to the Location Zones section of the OCS dashboard at ${dashboardUrl}.
-Find location zone ID ${args.zone_id}.
-Delete this location zone. Confirm the deletion when prompted.
-If the dashboard shows an error (e.g. zone in use by active templates), report the error.
-Verify the zone no longer appears in the zone list.
-`
+      (args, dashboardUrl) => buildDeleteLocationZonePrompt(
+        args,
+        dashboardUrl
+      )
     )
   );
 }
 
 // src/tools-ui-agent-ask.ts
 import { z as z5 } from "zod";
-
-// src/manus-webhook.ts
-var MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
-var DEDUP_TTL_SECONDS = 7 * 24 * 3600;
-var PENDING_ASK_TTL_SECONDS = 24 * 3600;
-var PENDING_ASK_PREFIX = "manus_pending_ask:";
-
-// src/manus-client.ts
-var MANUS_API_BASE2 = "https://api.manus.ai/v2";
-function getManusKeys(env) {
-  if (!env.MANUS_API_KEY) return null;
-  return {
-    primary: env.MANUS_API_KEY,
-    fallback: env.MANUS_API_KEY_FALLBACK
-  };
-}
-var FALLBACK_TRIGGER_CODES = /* @__PURE__ */ new Set([401, 403, 429]);
-var ManusApiError = class extends Error {
-  constructor(message, httpStatus, manusError, keyUsed, bothFailed) {
-    super(message);
-    this.httpStatus = httpStatus;
-    this.manusError = manusError;
-    this.keyUsed = keyUsed;
-    this.bothFailed = bothFailed;
-    this.name = "ManusApiError";
-  }
-  httpStatus;
-  manusError;
-  keyUsed;
-  bothFailed;
-};
-async function withFallback(fn, keys) {
-  const primaryResult = await fn(keys.primary);
-  if (!FALLBACK_TRIGGER_CODES.has(primaryResult._httpStatus)) {
-    return { ...primaryResult, key_used: "primary" };
-  }
-  if (!keys.fallback) {
-    throw new ManusApiError(
-      `Manus API request failed: HTTP ${primaryResult._httpStatus}`,
-      primaryResult._httpStatus,
-      void 0,
-      "primary",
-      false
-    );
-  }
-  const fallbackResult = await fn(keys.fallback);
-  if (!FALLBACK_TRIGGER_CODES.has(fallbackResult._httpStatus)) {
-    return { ...fallbackResult, key_used: "fallback" };
-  }
-  throw new ManusApiError(
-    `Manus API request failed with both keys: HTTP ${fallbackResult._httpStatus}`,
-    fallbackResult._httpStatus,
-    void 0,
-    "fallback",
-    true
-  );
-}
-async function manusPost(path, apiKey, body2) {
-  const res = await fetch(`${MANUS_API_BASE2}/${path}`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body2)
-  });
-  const data = await res.json();
-  return { _httpStatus: res.status, data, key_used: "primary" };
-}
-async function sendMessage(keys, taskId, content, opts) {
-  const message = { content };
-  if (opts?.connectors?.length) message.connectors = opts.connectors;
-  if (opts?.enableSkills?.length) message.enable_skills = opts.enableSkills;
-  if (opts?.forceSkills?.length) message.force_skills = opts.forceSkills;
-  const body2 = {
-    task_id: taskId,
-    message
-  };
-  if (opts?.agentProfile) body2.agent_profile = opts.agentProfile;
-  if (opts?.outputSchema) body2.structured_output_schema = opts.outputSchema;
-  return withFallback(
-    (apiKey) => manusPost("task.sendMessage", apiKey, body2),
-    keys
-  );
-}
-async function askReply(keys, taskId, reply) {
-  return sendMessage(keys, taskId, reply);
-}
-
-// src/tools-ui-agent-ask.ts
 var UI_AGENT_ASK_TOOL_SCOPES = {
   ui_agent_reply: "write",
   ui_agent_list_pending: "read"
@@ -5572,12 +6071,23 @@ function computeExpiresAt(askedAt) {
   if (isNaN(asked)) return "";
   return new Date(asked + PENDING_ASK_TTL_SECONDS * 1e3).toISOString();
 }
-async function callerOwnsTask(ctx, taskId) {
-  let raw;
+var emptyStore = {
+  get: async () => null,
+  put: async () => void 0,
+  delete: async () => void 0
+};
+async function callerOwnsTask(ctx, taskId, fallback) {
+  const key = `steel_task:${taskId}`;
+  let raw = null;
   try {
-    raw = await ctx.env.CARRIER_USERS.get(`steel_task:${taskId}`);
+    raw = await ctx.env.CARRIER_USERS.get(key);
   } catch {
-    return false;
+    if (!fallback) return false;
+    try {
+      raw = await fallback.get(key);
+    } catch {
+      return false;
+    }
   }
   if (!raw) return false;
   try {
@@ -5587,15 +6097,26 @@ async function callerOwnsTask(ctx, taskId) {
     return false;
   }
 }
-function registerUiAgentAskTools(server2, ctx) {
+function listableBinding(ctx) {
+  const kv = ctx.env.CARRIER_USERS;
+  return kv && typeof kv.list === "function" ? kv : null;
+}
+function registerUiAgentAskTools(server2, ctx, runtime) {
+  const sharedEnv = () => ({
+    ...runtime?.env.apiKey ? { apiKey: runtime.env.apiKey } : {},
+    store: ctx.env.CARRIER_USERS ?? runtime?.env.store ?? emptyStore,
+    audit: runtime?.env.audit ?? (() => void 0)
+  });
   server2.registerTool(
     "ui_agent_reply",
     {
       title: "Reply to Paused UI Agent Task",
-      description: "Resumes a Manus browser automation task that paused with stop_reason 'ask'. Use ui_agent_list_pending to find tasks waiting for input. Provide the task_id and your reply (e.g. a 2FA code, a field value, or a yes/no answer). The reply content is never recorded in audit logs \u2014 only its length is logged.",
+      description: "Resumes a browser automation task that paused to ask a question. Use ui_agent_list_pending to find tasks waiting for input. Provide the task_id and your reply (e.g. a 2FA code, a field value, or a yes/no answer). The reply content is never recorded in audit logs \u2014 only its length is logged.",
       inputSchema: {
-        task_id: z5.string().describe("Manus task ID to resume (from ui_agent_list_pending)"),
-        reply: z5.string().describe("Your answer to the agent's question (e.g. a 2FA code or confirmation)")
+        task_id: z5.string().describe("Task ID to resume (from ui_agent_list_pending)"),
+        reply: z5.string().describe(
+          "Your answer to the agent's question (e.g. a 2FA code or confirmation)"
+        )
       }
     },
     async (args) => {
@@ -5619,106 +6140,63 @@ function registerUiAgentAskTools(server2, ctx) {
           ]
         };
       }
-      const keys = getManusKeys(ctx.env);
-      if (!keys) {
+      const env = sharedEnv();
+      let pendingRaw = null;
+      try {
+        pendingRaw = await env.store.get(`${PENDING_ASK_PREFIX}${task_id}`);
+      } catch {
+        pendingRaw = null;
+      }
+      if (pendingRaw === null || !await callerOwnsTask(ctx, task_id, runtime?.env.store)) {
         return {
           isError: true,
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                error: "manus_api_not_configured",
-                message: "MANUS_API_KEY is not configured on this deployment."
+                error: "task_not_pending",
+                message: `No pending-ask entry found for task_id=${task_id}. The task may have already been resumed, completed, or expired (24h TTL). Use ui_agent_list_pending to see currently waiting tasks.`
               })
             }
           ]
         };
       }
-      const pendingKey = `${PENDING_ASK_PREFIX}${task_id}`;
-      const pendingRaw = await ctx.env.CARRIER_USERS.get(pendingKey);
-      if (pendingRaw === null || !await callerOwnsTask(ctx, task_id)) {
+      const outcome = await resumeUiAgentTask(task_id, reply, env);
+      ctx.audit({
+        tool_name: "ui_agent_reply",
+        ocs_method: "[ui-agent:ask-reply]",
+        status: outcome.ok ? "ui_agent_resumed" : "error",
+        dry_run: false,
+        duration_ms: Date.now() - start,
+        event_type: "ui_agent_resume"
+      });
+      if (!outcome.ok) {
         return {
           isError: true,
           content: [
             {
               type: "text",
               text: JSON.stringify({
-                error: "task_not_pending",
-                message: `No pending-ask entry found for task_id=${task_id}. The task may have already been resumed, completed, or expired (24h TTL). Use ui_agent_list_pending to see currently waiting tasks.`
+                error: "resume_failed",
+                message: outcome.error ?? "The task could not be resumed."
               })
             }
           ]
         };
       }
-      let result2;
-      try {
-        const replyOutcome = await askReply(keys, task_id, reply);
-        result2 = replyOutcome.data;
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_reply",
-          ocs_method: "[ui-agent:ask-reply]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_resume",
-          manus_task_id: task_id
-        });
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: `Error calling Manus task.reply: ${err7 instanceof Error ? err7.message : String(err7)}`
-            }
-          ]
-        };
-      }
-      if (!result2.ok) {
-        ctx.audit({
-          tool_name: "ui_agent_reply",
-          ocs_method: "[ui-agent:ask-reply]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_resume",
-          manus_task_id: task_id
-        });
-        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
+            )
           }
         ]
       };
@@ -5728,7 +6206,7 @@ function registerUiAgentAskTools(server2, ctx) {
     "ui_agent_list_pending",
     {
       title: "List Pending UI Agent Tasks (Waiting for Input)",
-      description: "Returns all Manus browser automation tasks that are currently paused waiting for human input (stop_reason 'ask'). Shows the agent's question, task URL, and when it was asked. Entries expire after 24 hours. Use ui_agent_reply to resume a task.",
+      description: "Returns browser automation tasks currently paused waiting for human input. Shows the agent's question, task URL, and when it was asked. Entries expire after 24 hours. Use ui_agent_reply to resume a task.",
       inputSchema: {}
     },
     async () => {
@@ -5743,61 +6221,61 @@ function registerUiAgentAskTools(server2, ctx) {
           ]
         };
       }
-      let keys;
-      try {
-        const listing = await ctx.env.CARRIER_USERS.list({ prefix: PENDING_ASK_PREFIX });
-        keys = listing.keys;
-      } catch (err7) {
-        return {
-          isError: true,
-          content: [
-            {
-              type: "text",
-              text: `Error listing pending tasks: ${err7 instanceof Error ? err7.message : String(err7)}`
-            }
-          ]
-        };
-      }
-      if (keys.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                pending_tasks: [],
-                count: 0,
-                message: "No Manus tasks are currently waiting for input."
-              }, null, 2)
-            }
-          ]
-        };
+      const kv = listableBinding(ctx);
+      let taskIds;
+      if (kv) {
+        try {
+          const listing = await kv.list({ prefix: PENDING_ASK_PREFIX });
+          taskIds = listing.keys.map(
+            (k) => k.name.slice(PENDING_ASK_PREFIX.length)
+          );
+        } catch (err7) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `Error listing pending tasks: ${err7 instanceof Error ? err7.message : String(err7)}`
+              }
+            ]
+          };
+        }
+      } else {
+        taskIds = [...runtime?.dispatchedTaskIds ?? []];
       }
+      const store = sharedEnv().store;
       const entries = await Promise.all(
-        keys.map(async ({ name }) => {
-          const raw = await ctx.env.CARRIER_USERS.get(name);
+        taskIds.map(async (taskId) => {
+          let raw;
+          try {
+            raw = await store.get(`${PENDING_ASK_PREFIX}${taskId}`);
+          } catch {
+            return null;
+          }
           if (!raw) return null;
+          if (!await callerOwnsTask(ctx, taskId, runtime?.env.store)) {
+            return null;
+          }
           try {
             const parsed = JSON.parse(raw);
-            const taskId = parsed.task_id ?? name.slice(PENDING_ASK_PREFIX.length);
-            if (!await callerOwnsTask(ctx, taskId)) return null;
-            return {
-              ...parsed,
-              expires_at: computeExpiresAt(parsed.asked_at)
-            };
+            return { ...parsed, expires_at: computeExpiresAt(parsed.asked_at) };
           } catch {
             return null;
           }
         })
       );
-      const validEntries = entries.filter((e) => e !== null);
+      const validEntries = entries.filter(
+        (e) => e !== null
+      );
       return {
         content: [
           {
             type: "text",
-            text: JSON.stringify({
-              pending_tasks: validEntries,
-              count: validEntries.length
-            }, null, 2)
+            text: JSON.stringify(
+              { pending_tasks: validEntries, count: validEntries.length },
+              null,
+              2
+            )
           }
         ]
       };
@@ -5807,277 +6285,6 @@ function registerUiAgentAskTools(server2, ctx) {
 
 // src/tools-ui-agent-schedule.ts
 import { z as z6 } from "zod";
-
-// src/manus-schedule.ts
-var ManusScheduleError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "ManusScheduleError";
-  }
-  statusCode;
-};
-function expandCronMinuteField(minuteField) {
-  if (minuteField === "*" || minuteField.includes(" ")) {
-    return null;
-  }
-  const tokens = minuteField.split(",").map((t) => t.trim()).filter(Boolean);
-  const set = /* @__PURE__ */ new Set();
-  for (const token2 of tokens) {
-    const stepWildcard = /^[*]\/(\d+)$/.exec(token2);
-    if (stepWildcard) {
-      const step = parseInt(stepWildcard[1] ?? "0", 10);
-      if (step < 1) return null;
-      for (let m = 0; m < 60; m += step) set.add(m);
-      continue;
-    }
-    const rangeWithStep = /^(\d+)-(\d+)\/(\d+)$/.exec(token2);
-    if (rangeWithStep) {
-      const start = parseInt(rangeWithStep[1] ?? "0", 10);
-      const end = parseInt(rangeWithStep[2] ?? "0", 10);
-      const step = parseInt(rangeWithStep[3] ?? "0", 10);
-      if (step < 1 || start > end) return null;
-      for (let m = start; m <= end; m += step) set.add(m);
-      continue;
-    }
-    const rangeOnly = /^(\d+)-(\d+)$/.exec(token2);
-    if (rangeOnly) {
-      const start = parseInt(rangeOnly[1] ?? "0", 10);
-      const end = parseInt(rangeOnly[2] ?? "0", 10);
-      if (start > end) return null;
-      for (let m = start; m <= end; m++) set.add(m);
-      continue;
-    }
-    const single = /^(\d+)$/.exec(token2);
-    if (single) {
-      set.add(parseInt(single[1] ?? "0", 10));
-      continue;
-    }
-    return null;
-  }
-  const arr = Array.from(set).sort((a, b) => a - b);
-  for (const v of arr) {
-    if (v < 0 || v > 59) return null;
-  }
-  return arr;
-}
-function minuteFieldViolatesFiveMinuteRule(minuteField, fullCron) {
-  const minutes = expandCronMinuteField(minuteField);
-  if (minutes === null) {
-    return `Cron expression rejected: unrecognized or unsupported minute field '${minuteField}'. Minimum interval is 5 minutes; use lists, ranges with step \u2265 5, or */5 or higher.`;
-  }
-  if (minutes.length === 0) {
-    return `Cron expression rejected: minute field '${minuteField}' expands to no valid minutes.`;
-  }
-  if (minutes.length === 1) {
-    return null;
-  }
-  for (let i = 1; i < minutes.length; i++) {
-    const gap = (minutes[i] ?? 0) - (minutes[i - 1] ?? 0);
-    if (gap < 5) {
-      return `Cron expression rejected: '${fullCron}' implies a ${gap}-minute gap in the minute field. Minimum allowed interval is 5 minutes.`;
-    }
-  }
-  const wrapGap = 60 - (minutes[minutes.length - 1] ?? 0) + (minutes[0] ?? 0);
-  if (wrapGap < 5) {
-    return `Cron expression rejected: '${fullCron}' implies a ${wrapGap}-minute wraparound gap in the minute field. Minimum allowed interval is 5 minutes.`;
-  }
-  return null;
-}
-function validateCron(cron) {
-  const parts = cron.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    return `Invalid cron expression: expected 5 fields (minute hour day month weekday), got ${parts.length}.`;
-  }
-  const [minuteField] = parts;
-  if (minuteField === "*") {
-    return "Cron expression rejected: '* * * * *' runs every minute. Minimum allowed interval is 5 minutes.";
-  }
-  return minuteFieldViolatesFiveMinuteRule(minuteField ?? "", cron);
-}
-async function createSchedule(apiKey, params) {
-  const body2 = {
-    name: params.name,
-    cron: params.cron,
-    prompt_template: params.prompt_template,
-    agent_profile: params.agent_profile ?? "manus-1.6-lite",
-    interactive_mode: false,
-    hide_in_task_list: false
-  };
-  const res = await fetch(`${MANUS_API_BASE}/schedule.create`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify(body2)
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.create failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function listSchedules(apiKey) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.list`, {
-    headers: { "x-manus-api-key": apiKey }
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.list failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  const data = await res.json();
-  if (Array.isArray(data)) {
-    return { ok: true, schedules: data };
-  }
-  return data;
-}
-async function deleteSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.delete`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.delete failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function pauseSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.pause`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.pause failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-async function resumeSchedule(apiKey, scheduleId) {
-  const res = await fetch(`${MANUS_API_BASE}/schedule.resume`, {
-    method: "POST",
-    headers: {
-      "x-manus-api-key": apiKey,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ schedule_id: scheduleId })
-  });
-  if (!res.ok) {
-    throw new ManusScheduleError(
-      `schedule.resume failed: HTTP ${res.status}`,
-      res.status
-    );
-  }
-  return await res.json();
-}
-
-// src/manus-usage.ts
-var ManusUsageError = class extends Error {
-  constructor(message, statusCode) {
-    super(message);
-    this.statusCode = statusCode;
-    this.name = "ManusUsageError";
-  }
-  statusCode;
-};
-var CACHE_KEY = "manus_usage_cache";
-var CACHE_TTL_SECONDS = 60;
-var USAGE_THRESHOLD_WARNING = 1e3;
-var USAGE_THRESHOLD_CRITICAL = 100;
-async function fetchUsageFromApi(apiKey) {
-  const now = /* @__PURE__ */ new Date();
-  const month = `${now.getUTCFullYear()}-${String(now.getUTCMonth() + 1).padStart(2, "0")}`;
-  const [usageRes, creditsRes] = await Promise.all([
-    fetch(`${MANUS_API_BASE}/usage.get`, {
-      headers: { "x-manus-api-key": apiKey }
-    }),
-    fetch(`${MANUS_API_BASE}/credits.get`, {
-      headers: { "x-manus-api-key": apiKey }
-    })
-  ]);
-  if (!usageRes.ok && !creditsRes.ok) {
-    throw new ManusUsageError(
-      `Manus usage APIs failed: usage.get HTTP ${usageRes.status}, credits.get HTTP ${creditsRes.status}`,
-      Math.max(usageRes.status, creditsRes.status)
-    );
-  }
-  let spentCredits = 0;
-  let remainingCredits = 0;
-  let taskCount = 0;
-  if (usageRes.ok) {
-    const usageData = await usageRes.json();
-    spentCredits = usageData.spent_credits ?? usageData.credits_used ?? 0;
-    taskCount = usageData.task_count ?? usageData.tasks_run ?? 0;
-    if (usageData.remaining_credits !== void 0 || usageData.credits_remaining !== void 0) {
-      remainingCredits = usageData.remaining_credits ?? usageData.credits_remaining ?? 0;
-    }
-  }
-  if (creditsRes.ok) {
-    const creditsData = await creditsRes.json();
-    const fromCreditsApi = creditsData.remaining_credits ?? creditsData.credits_remaining ?? creditsData.balance;
-    if (fromCreditsApi !== void 0) {
-      remainingCredits = fromCreditsApi;
-    }
-  }
-  return { month, spent_credits: spentCredits, remaining_credits: remainingCredits, task_count: taskCount };
-}
-async function getUsage(apiKey, env) {
-  const cached = await env.CARRIER_USERS.get(CACHE_KEY, "json");
-  const nowMs = Date.now();
-  if (cached && nowMs - cached.fetched_at < CACHE_TTL_SECONDS * 1e3) {
-    return { data: cached.data, from_cache: true };
-  }
-  const data = await fetchUsageFromApi(apiKey);
-  await env.CARRIER_USERS.put(
-    CACHE_KEY,
-    JSON.stringify({ data, fetched_at: nowMs }),
-    { expirationTtl: CACHE_TTL_SECONDS }
-  );
-  return { data, from_cache: false };
-}
-function emitUsageThresholdIfNeeded(env, data) {
-  const { remaining_credits, month, task_count } = data;
-  if (remaining_credits < USAGE_THRESHOLD_CRITICAL) {
-    writeUsageThresholdAudit(env, "critical", remaining_credits, month, task_count);
-  } else if (remaining_credits < USAGE_THRESHOLD_WARNING) {
-    writeUsageThresholdAudit(env, "warning", remaining_credits, month, task_count);
-  }
-}
-function writeUsageThresholdAudit(env, severity, remainingCredits, month, taskCount) {
-  try {
-    env.AUDIT_LOG.writeDataPoint({
-      blobs: [
-        "manus_usage_threshold",
-        severity,
-        month,
-        String(taskCount)
-      ],
-      doubles: [remainingCredits],
-      indexes: ["manus_usage"]
-    });
-  } catch (err7) {
-    console.error(`[manus-usage] threshold audit write failed: ${err7.message}`);
-  }
-}
-
-// src/tools-ui-agent-schedule.ts
 var UI_AGENT_SCHEDULE_TOOL_SCOPES = {
   ui_agent_schedule_create: "admin",
   ui_agent_schedule_list: "read",
@@ -6086,20 +6293,7 @@ var UI_AGENT_SCHEDULE_TOOL_SCOPES = {
   ui_agent_schedule_resume: "admin",
   ui_agent_usage: "read"
 };
-function noManusKeyError2() {
-  return {
-    isError: true,
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          error: "manus_api_not_configured",
-          message: "MANUS_API_KEY is not configured on this Carrier MCP deployment. Schedule and usage tools require a Manus API key. Contact your Carrier MCP administrator."
-        })
-      }
-    ]
-  };
-}
+var STDIO_NOTE = " Requires the remote Carrier MCP Worker deployment \u2014 a local CLI has no recurring runtime, so schedules cannot fire here.";
 function scopeError(toolName, required, actual) {
   return {
     isError: true,
@@ -6111,427 +6305,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.",
+      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 (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 }] };
-      }
-    }
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_delete", "admin") : uiAgentStubError("ui_agent_schedule_delete", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_schedule_pause",
     {
-      title: "Pause Manus Schedule",
-      description: "Pauses an active Manus recurring schedule. The schedule is preserved and can be resumed later with ui_agent_schedule_resume. Requires admin scope.",
+      title: "Pause UI Agent Schedule",
+      description: "Pauses an active recurring browser-agent schedule. The schedule is preserved and can be resumed later with ui_agent_schedule_resume. Requires admin scope." + STDIO_NOTE,
       inputSchema: {
-        schedule_id: z6.string().describe("ID of the schedule to pause")
-      }
-    },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_pause", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await pauseSchedule(ctx.env.MANUS_API_KEY, args.schedule_id);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_pause_failed",
-                  message: result2.error?.message ?? "Manus schedule.pause returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ status: "paused", schedule_id: args.schedule_id }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_pause",
-          ocs_method: "[manus:schedule.pause]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
+        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 Manus Schedule",
-      description: "Resumes a paused Manus recurring schedule. Requires admin scope.",
+      title: "Resume UI Agent Schedule",
+      description: "Resumes a paused recurring browser-agent schedule. Requires admin scope." + STDIO_NOTE,
       inputSchema: {
         schedule_id: z6.string().describe("ID of the schedule to resume")
       }
     },
-    async (args) => {
-      const start = Date.now();
-      if (!ctx.props.scope.includes("admin")) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: "scope_denied",
-          dry_run: false,
-          duration_ms: 0
-        });
-        return scopeError("ui_agent_schedule_resume", "admin", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const result2 = await resumeSchedule(ctx.env.MANUS_API_KEY, args.schedule_id);
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: result2.ok ? "ok" : "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        if (!result2.ok) {
-          return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  error: "schedule_resume_failed",
-                  message: result2.error?.message ?? "Manus schedule.resume returned ok=false"
-                })
-              }
-            ]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ status: "active", schedule_id: args.schedule_id }, null, 2)
-            }
-          ]
-        };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_schedule_resume",
-          ocs_method: "[manus:schedule.resume]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start,
-          event_type: "ui_agent_dispatch"
-        });
-        const msg = err7 instanceof ManusScheduleError ? `Manus API error (HTTP ${err7.statusCode}): ${err7.message}` : err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
-      }
-    }
+    async () => !ctx.props.scope.includes("admin") ? scopeDenied(ctx, "ui_agent_schedule_resume", "admin") : uiAgentStubError("ui_agent_schedule_resume", "recurring_runtime")
   );
   server2.registerTool(
     "ui_agent_usage",
     {
-      title: "Manus Usage & Credits",
-      description: "Returns current month Manus credit spend, remaining balance, and task count. Result is cached for 60 seconds in KV to avoid rate-limiting the Manus API. Emits an Analytics Engine event when remaining_credits drops below 1000 (warning) or 100 (critical). Use this to track Carrier's Manus credit burn.",
+      title: "UI Agent Usage & Spend",
+      description: "Reports browser-agent spend for the current CLI session: runs dispatched, real vendor-billed cost in USD, and how many runs remain under the session limit. This is a per-process figure, not an account total \u2014 it resets when the CLI restarts, and it cannot see runs billed to the same API key by other processes or by the hosted Worker. Check your Browser Use account for the authoritative balance. Requires read scope.",
       inputSchema: {}
     },
     async () => {
-      const start = Date.now();
       if (!ctx.props.scope.includes("read")) {
         ctx.audit({
           tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
+          ocs_method: "[ui-agent:usage]",
           status: "scope_denied",
           dry_run: false,
           duration_ms: 0
         });
-        return scopeError("ui_agent_usage", "read", ctx.props.scope);
-      }
-      if (!ctx.env.MANUS_API_KEY) {
-        return noManusKeyError2();
-      }
-      try {
-        const { data, from_cache } = await getUsage(ctx.env.MANUS_API_KEY, ctx.env);
-        emitUsageThresholdIfNeeded(ctx.env, data);
-        ctx.audit({
-          tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
-          status: "ok",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
         return {
+          isError: true,
           content: [
             {
               type: "text",
-              text: JSON.stringify({ ...data, from_cache }, null, 2)
+              text: `Scope denied: tool 'ui_agent_usage' requires 'read' scope. Your token has: [${ctx.props.scope.join(", ")}].`
             }
           ]
         };
-      } catch (err7) {
-        ctx.audit({
-          tool_name: "ui_agent_usage",
-          ocs_method: "[manus:usage.get]",
-          status: "error",
-          dry_run: false,
-          duration_ms: Date.now() - start
-        });
-        const msg = err7 instanceof Error ? err7.message : String(err7);
-        return { isError: true, content: [{ type: "text", text: msg }] };
       }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                scope: "cli_session",
+                configured: runtime.configured,
+                runs_billed_this_session: runtime.spend.runs,
+                cost_usd_this_session: runtime.spend.costUsd,
+                runs_dispatched_this_session: runtime.budget.spent,
+                runs_remaining_this_session: runtime.budget.remaining,
+                run_limit_env: MAX_RUNS_ENV,
+                note: "Session-scoped. Resets when this CLI process exits and does not include runs billed to the same key elsewhere. The authoritative balance is in your Browser Use account."
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
     }
   );
 }
@@ -6826,6 +6719,11 @@ async function createTopupCheckout(env, args) {
   const successUrl = args.successUrl ?? env.WALLET_CHECKOUT_SUCCESS_URL ?? DEFAULT_SUCCESS_URL;
   const cancelUrl = args.cancelUrl ?? env.WALLET_CHECKOUT_CANCEL_URL ?? DEFAULT_CANCEL_URL;
   const bonusLabel = bonusCents > 0 ? ` (+\u20AC${(bonusCents / 100).toFixed(2)} bonus)` : "";
+  if (!env.CARRIER_USERS) {
+    throw new Error(
+      "Wallet top-up is not available in local stdio mode: the prepaid wallet is credited by the hosted Carrier service after payment, and this process cannot reach the customer record that crediting depends on. Creating the session here would bill the card against a duplicate Stripe customer and the wallet would never be credited. Top up from the console at https://app.carrier.llc/billing, or connect to the hosted MCP at https://mcp.carrier.llc/mcp, which has the binding. `wallet_balance` still works here if ATLAS_BASE_URL and CARRIER_INTERNAL_API_KEY are set."
+    );
+  }
   const billingSub = await resolveBillingSub(env, args.orgId);
   const existingCustomer = await env.CARRIER_USERS.get(`stripe_customer_id:${billingSub}`).catch(() => null);
   const params = new URLSearchParams({
@@ -6875,7 +6773,7 @@ async function runAutoTopup(env, args) {
   let packCents = args.packCents;
   try {
     const wallet = await getWallet(env, args.orgId);
-    if (packCents === void 0) packCents = wallet.auto_topup_pack_cents;
+    if (packCents === void 0) packCents = wallet.auto_topup_pack_cents ?? void 0;
   } catch (e) {
     if (e instanceof WalletClientError) {
       return { charged: false, creditedCents: 0, reason: `wallet_unreachable: ${e.message}` };
@@ -6981,15 +6879,23 @@ function registerWalletTools(server2, ctx) {
       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.
+      // description. All five keys are always present on the success path, so
+      // none is optional — but the two auto-top-up amounts are nullable, not
+      // just unset. ATLAS types them `number | null` and synthesises an
+      // all-null row for an org with no wallet yet (its toWalletView), so an
+      // org that has never configured auto-top-up — every newly onboarded one
+      // — returns null here. Requiring a number turned that, the most common
+      // state a new operator is in, into an output validation error.
       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")
+        auto_topup_threshold_cents: z7.number().int().nullable().describe(
+          "Balance at or below which an auto top-up fires, EUR cents. Null when auto-top-up is unconfigured."
+        ),
+        auto_topup_pack_cents: z7.number().int().nullable().describe(
+          "Amount an auto top-up charges, EUR cents. Null when auto-top-up is unconfigured."
+        )
       },
       annotations: annotationsFor("wallet_balance", "read")
     },
@@ -7181,7 +7087,39 @@ function registerWalletTools(server2, ctx) {
 // src/stripe-connect-tools.ts
 import { z as z8 } from "zod";
 import * as Sentry3 from "@sentry/cloudflare";
+
+// src/binding-unavailable.ts
+var HOSTED_MCP_URL = "https://mcp.carrier.llc/mcp";
+var BindingUnavailableError = class extends Error {
+  constructor(tool, binding, message) {
+    super(message);
+    this.tool = tool;
+    this.binding = binding;
+    this.name = "BindingUnavailableError";
+  }
+  tool;
+  binding;
+};
+function requireUserStore(env, tool, subject) {
+  requireBinding(env.CARRIER_USERS, tool, "CARRIER_USERS", subject);
+}
+function requireBinding(binding, tool, name, subject) {
+  if (binding) return;
+  throw new BindingUnavailableError(
+    tool,
+    name,
+    `${tool} cannot answer here: ${subject} is held by the hosted Carrier service, and this local MCP server has no connection to it. There is nothing to set in your environment \u2014 the data does not exist on this machine. Connect to the hosted MCP at ${HOSTED_MCP_URL}, or open the console at https://app.carrier.llc, to use this tool. Every OCS tool in this server works against your own token and is unaffected.`
+  );
+}
+
+// src/stripe-connect-tools.ts
 async function verifyConfirmToken(env, sub, toolName, token2) {
+  requireBinding(
+    env.OAUTH_KV,
+    toolName,
+    "OAUTH_KV",
+    "the short-lived confirmation token this operation requires"
+  );
   const key = `confirm:${sub}:${toolName}`;
   const stored = await env.OAUTH_KV.get(key);
   if (!stored || stored !== token2) return false;
@@ -7189,6 +7127,12 @@ async function verifyConfirmToken(env, sub, toolName, token2) {
   return true;
 }
 async function issueConfirmToken(env, sub, toolName) {
+  requireBinding(
+    env.OAUTH_KV,
+    toolName,
+    "OAUTH_KV",
+    "the short-lived confirmation token this operation requires"
+  );
   const bytes = crypto.getRandomValues(new Uint8Array(16));
   const token2 = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
   const key = `confirm:${sub}:${toolName}`;
@@ -8316,6 +8260,7 @@ var PRICING_TOOLS = [
       required: []
     },
     handler: async (env, props2) => {
+      requireUserStore(env, "credit_balance", "your MCP plan credit ledger");
       const tier = props2.tier;
       const summary = await getCreditSummary(env, props2.sub, tier);
       const creditCheck = await checkCredits(env, props2.sub, tier, "read");
@@ -8397,6 +8342,7 @@ var PRICING_TOOLS = [
       required: []
     },
     handler: async (env, props2, args) => {
+      requireUserStore(env, "configure_billing", "your billing configuration");
       const tier = props2.tier;
       if (tier === "free") {
         return {
@@ -8465,6 +8411,11 @@ var PRICING_TOOLS = [
       required: []
     },
     handler: async (env, props2, args) => {
+      requireUserStore(
+        env,
+        "usage_projection",
+        "the consumption history a projection is drawn from"
+      );
       const tier = props2.tier;
       const summary = await getCreditSummary(env, props2.sub, tier);
       const now = /* @__PURE__ */ new Date();
@@ -8613,6 +8564,7 @@ var PRICING_TOOLS = [
       required: []
     },
     handler: async (env, props2, args) => {
+      requireUserStore(env, "billing_events", "your billing event history");
       const limit = Math.min(
         typeof args.limit === "number" ? args.limit : 20,
         50
@@ -8923,6 +8875,11 @@ var PROJECTS_TOOLS = [
       required: ["new_token", "confirm"]
     },
     handler: async (env, props2, args) => {
+      requireUserStore(
+        env,
+        "rotate_credentials",
+        "the encrypted token vault this writes to"
+      );
       if (!args.confirm) {
         return {
           status: "cancelled",
@@ -8937,7 +8894,9 @@ var PROJECTS_TOOLS = [
       }
       const encryptionKey = env.CARRIER_TOKEN_ENCRYPTION_KEY;
       if (!encryptionKey) {
-        return { error: "Encryption key not configured \u2014 contact support" };
+        throw new Error(
+          "rotate_credentials cannot run here: CARRIER_TOKEN_ENCRYPTION_KEY is a secret of the hosted Carrier service and is not present in a local install, so there is no way to encrypt a token for the vault. Rotate from the console at https://app.carrier.llc, or connect to the hosted MCP at https://mcp.carrier.llc/mcp. In local stdio mode the OCS token comes from CARRIER_OCS_API_TOKEN in your own environment \u2014 change it there and restart, no rotation call needed."
+        );
       }
       const encrypted = await encryptToken(newToken, encryptionKey);
       const orgId = props2.org_id;
@@ -9086,13 +9045,17 @@ var PROJECTS_TOOLS = [
     handler: async (env, props2) => {
       const sub = props2.sub;
       const orgId = props2.org_id;
+      const hasStore = !!env.CARRIER_USERS;
       let orgDetails = null;
-      if (orgId) {
+      if (orgId && hasStore) {
         orgDetails = await env.CARRIER_USERS.get(`org:${orgId}`, "json").catch(() => null);
       }
-      const hasStripe = !!await env.CARRIER_USERS.get(`stripe_customer_id:${sub}`);
-      const hasWebhook = !!await env.CARRIER_USERS.get(`webhook_url:${sub}`);
+      const hasStripe = hasStore ? !!await env.CARRIER_USERS.get(`stripe_customer_id:${sub}`) : null;
+      const hasWebhook = hasStore ? !!await env.CARRIER_USERS.get(`webhook_url:${sub}`) : null;
       return {
+        ...hasStore ? {} : {
+          note: "Running as a local stdio server. Fields reported as null are held by the hosted Carrier service and cannot be read from here; connect to https://mcp.carrier.llc/mcp to see them. Everything else below is this session's own configuration and is accurate."
+        },
         environment: {
           user_sub: sub,
           org_id: orgId ?? null,
@@ -9517,8 +9480,8 @@ var CURATED_ROUTER_TOOLS = [
   },
   {
     name: "move_subscriber_range_to_account",
-    description: "Move a range of subscribers to a different account. Intent: 'move subscribers', 'transfer SIMs to account'.",
-    input_schema: { type: "object", properties: { accountId: { type: "number" } } }
+    description: "Move a range of subscribers (by IMSI or ICCID) from one account to another. Intent: 'move subscribers', 'transfer SIMs to account'.",
+    input_schema: { type: "object", properties: { srcAccountId: { type: "number" }, destAccount: { type: "number" }, rangeType: { type: "string" } } }
   },
   {
     name: "hlr_get_bitrate",
@@ -9801,15 +9764,28 @@ var ROUTER_SYSTEM_PROMPT = `You are a carrier fleet operations router. Your job
 
 ${ROUTER_RULES}`;
 var ROUTER_TIMEOUT_MS = 12e3;
+var AskRouterNotConfiguredError = class extends Error {
+  constructor(missing) {
+    super(routerRemediation(missing));
+    this.missing = missing;
+    this.name = "AskRouterNotConfiguredError";
+  }
+  missing;
+};
+function missingRouterCredentials(env) {
+  const missing = [];
+  if (!env.AWS_ACCESS_KEY_ID) missing.push("AWS_ACCESS_KEY_ID");
+  if (!env.AWS_SECRET_ACCESS_KEY) missing.push("AWS_SECRET_ACCESS_KEY");
+  if (env.CARRIER_ASK_ENABLED !== "true") missing.push("CARRIER_ASK_ENABLED=true");
+  return missing;
+}
+function routerRemediation(missing) {
+  return `carrier_ask cannot route: ${missing.join(", ")} ${missing.length === 1 ? "is" : "are"} not set. Set them in the environment of the process running this MCP server (for Claude Desktop / Cursor / Windsurf, the \`env\` block of the server entry in your MCP config), then restart it. The router calls Amazon Bedrock, so the credentials must belong to an IAM identity with bedrock:InvokeModel. Every other Carrier tool works without this \u2014 carrier_ask only picks which one to call, so you can call the tool you want directly in the meantime.`;
+}
 async function _routeIntent(intent, context, env, opts = {}) {
   const { attribution, onUsage } = opts;
   if (env.CARRIER_ASK_ENABLED !== "true" || !env.AWS_ACCESS_KEY_ID || !env.AWS_SECRET_ACCESS_KEY) {
-    return {
-      match: "routing_pending",
-      intent_received: intent,
-      note: "carrier_ask routing engine is not yet activated. Add AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY to Doppler carrier/dev+stg+prd and set CARRIER_ASK_ENABLED=true.",
-      scaffold_version: "v2.0-bedrock"
-    };
+    throw new AskRouterNotConfiguredError(missingRouterCredentials(env));
   }
   const definedContext = Object.fromEntries(
     Object.entries(context).filter(([, value]) => value !== void 0)
@@ -10065,6 +10041,34 @@ function registerAllCarrierAskTools(server2, ctx) {
             }
           });
         } catch (err7) {
+          if (err7 instanceof AskRouterNotConfiguredError) {
+            writeCarrierAskAudit(ctx.env, {
+              intent_hash: intentHash,
+              match: "error",
+              resolved_tool: "none",
+              confirm_token_state: "none",
+              status: "error",
+              latency_ms: Date.now() - start,
+              sub: ctx.props.sub,
+              reseller_id: ctx.props.reseller_id,
+              model_id: "none",
+              tier: ctx.props.tier,
+              usage: ZERO_USAGE
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    error: "router_not_configured",
+                    missing: err7.missing,
+                    message: err7.message
+                  })
+                }
+              ],
+              isError: true
+            };
+          }
           writeCarrierAskAudit(ctx.env, {
             intent_hash: intentHash,
             match: "error",
@@ -10422,6 +10426,12 @@ function registerListRecentOcsEventsTool(server2, ctx) {
             };
           }
         }
+        requireBinding(
+          env.OCS_EVENT_ROUTING,
+          "list_recent_ocs_events",
+          "OCS_EVENT_ROUTING",
+          "the OCS event ring buffer"
+        );
         const result2 = await listRecentOcsEvents2(
           iccid,
           limit,
@@ -10578,7 +10588,7 @@ function registerDepletionEventsTool(server2, ctx) {
       const kv = ctx.env.RATE_LIMIT_KV;
       if (!kv) {
         return err5(
-          "RATE_LIMIT_KV binding is not available in this environment. Add the binding to wrangler.jsonc and redeploy."
+          "subscriber_depletion_events cannot answer here. Depletion events are written by the Carrier webhook receiver as they arrive from the network and kept for 7 days in hosted storage; a local stdio server receives no webhooks and has nowhere to keep them, so there is no history on this machine to read. There is nothing to set in your environment. Use the hosted MCP at https://mcp.carrier.llc/mcp for this tool. To see a subscriber's current bundle state instead of its depletion history, `get_subscriber` and `list_subscriber_packages` query OCS directly and work here."
         );
       }
       const { subscriberId, since } = args;
@@ -12233,43 +12243,228 @@ function registerGreenzoneTools(server2, ctx) {
 
 // src/tools-ui-agent-generic.ts
 import { z as z22 } from "zod";
-var STDIO_ERROR = {
-  isError: true,
-  content: [
-    {
-      type: "text",
-      text: JSON.stringify({
-        error: "requires_worker_runtime",
-        message: "ui_agent_ask and ui_agent_status require the remote Carrier MCP Worker deployment (mcp.carrier.llc/mcp) \u2014 they cannot run in stdio/local mode because Steel browser sessions and KV task state require Cloudflare Workers runtime bindings. Connect to the remote MCP endpoint to use these tools.",
-        remote_url: "https://mcp.carrier.llc/mcp"
-      })
-    }
-  ]
-};
-function registerUiAgentGenericTools(server2, _ctx) {
+var COST_PER_STEP_USD = 0.014;
+var SESSION_OVERHEAD_USD = 5e-3;
+function estimateCostUsd2(steps) {
+  return Math.round((COST_PER_STEP_USD * steps + SESSION_OVERHEAD_USD) * 100) / 100;
+}
+function notConfiguredError(toolName) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "browser_use_not_configured",
+          tool: toolName,
+          message: "BROWSER_USE_API_KEY is not set, so the browsing agent cannot run. Set it in the environment of the process running this MCP server. Runs are billed to that key at roughly $0.20-1.00 each."
+        })
+      }
+    ]
+  };
+}
+function scopeError2(toolName, required, actual) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          error: "scope_denied",
+          message: `Scope denied: tool '${toolName}' requires '${required}' scope. Your token has: [${actual.join(", ")}].`
+        })
+      }
+    ]
+  };
+}
+function registerUiAgentGenericTools(server2, ctx, runtime) {
   server2.registerTool(
     "ui_agent_ask",
     {
-      title: "Dispatch Generic Steel Browsing Agent",
-      description: "Dispatch a Steel browsing agent task with a natural-language prompt. The agent will navigate the web, use Tavily web search if needed, and return the result. Use for ad-hoc research, page extraction, form filling outside the OCS portal. Pro/Enterprise scope required. Cost ~$0.20-1.00 per task depending on complexity. Returns task_id immediately \u2014 poll with ui_agent_status for completion. Set dry_run=true to preview cost estimate without executing. NOTE: requires remote Worker deployment (mcp.carrier.llc/mcp) \u2014 not available in stdio mode.",
+      title: "Dispatch Generic Browsing Agent",
+      description: "Send a plain-language task to a hosted browsing agent, which drives a real browser on the open web \u2014 navigating pages, searching, extracting content, filling forms outside the OCS portal. Each run costs roughly $0.20-1.00 in model spend against your own BROWSER_USE_API_KEY, so treat it as the expensive last resort, not a lookup. Limited to CARRIER_BROWSER_USE_MAX_RUNS runs per CLI session (default 10). Params: `prompt` (1-4000 chars \u2014 name the target URL and the exact data or action), `max_steps` (1-30, default 15; prices the dry-run estimate only), `dry_run` (true returns only `estimated_cost_usd` and creates no session). Returns the finished result: unlike the hosted Worker, a local CLI has no background runtime, so this call blocks for the length of the run. Requires `write` scope. Do NOT use this to work out which Carrier tool answers a request \u2014 that is `carrier_ask`, which costs nothing. Do NOT use this for anything the OCS API already covers; every other tool here is faster, free, and audited.",
       inputSchema: {
-        prompt: z22.string().min(1).max(4e3).describe("Natural-language task description for the Steel browsing agent."),
-        max_steps: z22.number().int().min(1).max(30).optional().describe("Maximum agent steps (1\u201330, default 15)."),
-        dry_run: z22.boolean().optional().describe("Preview cost estimate without dispatching.")
+        prompt: z22.string().min(1).max(4e3).describe(
+          "Natural-language task description for the browsing agent. Be specific: include target URLs, data to extract, or actions to perform."
+        ),
+        max_steps: z22.number().int().min(1).max(30).optional().describe(
+          "Advisory step budget (1\u201330, default 15). Prices the dry-run estimate; the hosted agent sets its own depth."
+        ),
+        dry_run: z22.boolean().optional().describe(
+          "Preview cost estimate without dispatching. Returns estimated_cost_usd only \u2014 no browser session is created."
+        )
       }
     },
-    async (_args) => STDIO_ERROR
+    async (args) => {
+      const start = Date.now();
+      const toolName = "ui_agent_ask";
+      const { prompt, max_steps = 15, dry_run = false } = args;
+      if (!ctx.props.scope.includes("write") && !ctx.props.scope.includes("admin")) {
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: "scope_denied",
+          dry_run: false,
+          duration_ms: 0
+        });
+        return scopeError2(toolName, "write", ctx.props.scope);
+      }
+      if (dry_run) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: "dry_run",
+                  estimated_cost_usd: estimateCostUsd2(max_steps),
+                  runs_remaining_this_session: runtime.budget.remaining,
+                  note: "No browser session was created and nothing was billed."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      }
+      if (!browserUseConfigured(runtime.env)) {
+        return notConfiguredError(toolName);
+      }
+      try {
+        runtime.budget.reserve();
+      } catch (err7) {
+        if (err7 instanceof SpendLimitError) {
+          ctx.audit({
+            tool_name: toolName,
+            ocs_method: "[ui-agent:generic-ask]",
+            // The existing quota status, not a new one: AuditRow's status is a
+            // closed union shared with the Worker, and a stdio-only value would
+            // be a row shape the hosted surface never emits.
+            status: "quota_exceeded",
+            dry_run: false,
+            duration_ms: 0,
+            event_type: "ui_agent_dispatch"
+          });
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  error: "run_limit_reached",
+                  message: err7.message
+                })
+              }
+            ]
+          };
+        }
+        throw err7;
+      }
+      try {
+        const result2 = await runUiAgent(
+          prompt,
+          "Carrier CLI browsing agent",
+          runtime.env
+        );
+        runtime.dispatchedTaskIds.add(result2.task_id);
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: result2.status === "error" ? "error" : "ok",
+          dry_run: false,
+          duration_ms: Date.now() - start,
+          event_type: "ui_agent_dispatch"
+        });
+        return {
+          ...result2.status === "error" ? { isError: true } : {},
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  status: result2.status,
+                  task_id: result2.task_id,
+                  ...result2.session_viewer_url ? { session_viewer_url: result2.session_viewer_url } : {},
+                  result: result2.result,
+                  session_spend_usd: runtime.spend.costUsd,
+                  runs_remaining_this_session: runtime.budget.remaining,
+                  note: "The run completed in-process. Task records live only for this CLI session \u2014 ui_agent_status can read this task_id until the process exits."
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err7) {
+        ctx.audit({
+          tool_name: toolName,
+          ocs_method: "[ui-agent:generic-ask]",
+          status: "error",
+          dry_run: false,
+          duration_ms: Date.now() - start,
+          event_type: "ui_agent_dispatch"
+        });
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "ui_agent_failed",
+                message: err7 instanceof Error ? err7.message : String(err7)
+              })
+            }
+          ]
+        };
+      }
+    }
   );
   server2.registerTool(
     "ui_agent_status",
     {
-      title: "Get Steel Agent Task Status",
-      description: "Poll the status of a Steel browser agent task dispatched by ui_agent_ask or any ui_* tool. Returns current status (pending | running | completed | failed) and result when available. NOTE: requires remote Worker deployment (mcp.carrier.llc/mcp) \u2014 not available in stdio mode.",
+      title: "Poll Browsing Agent Task Status",
+      description: "Returns the current state of a browsing-agent task by `task_id`, including its result once finished. In the local CLI, ui_agent_ask already returns the finished result, so this is mainly for re-reading a task within the same session. Task records do not survive the CLI process exiting. Requires `read` scope.",
       inputSchema: {
-        task_id: z22.string().describe("Steel task ID returned by ui_agent_ask or any ui_* tool dispatch")
+        task_id: z22.string().describe("Task ID returned by ui_agent_ask")
       }
     },
-    async (_args) => STDIO_ERROR
+    async (args) => {
+      const toolName = "ui_agent_status";
+      if (ctx.props.scope.length === 0) {
+        return scopeError2(toolName, "read", ctx.props.scope);
+      }
+      if (!browserUseConfigured(runtime.env)) {
+        return notConfiguredError(toolName);
+      }
+      const task = await getUiAgentTask(
+        args.task_id,
+        runtime.env
+      );
+      if (!task) {
+        return {
+          isError: true,
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                error: "task_not_found",
+                message: `No task record for task_id=${args.task_id}. In the local CLI these live in memory for the lifetime of the process, so a task from an earlier session is gone rather than expired.`
+              })
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(task, null, 2)
+          }
+        ]
+      };
+    }
   );
 }
 
@@ -12295,8 +12490,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
@@ -12304,7 +12506,23 @@ var stdioEnv = {
   ATLAS_BASE_URL: process.env.ATLAS_BASE_URL,
   CARRIER_INTERNAL_API_KEY: process.env.CARRIER_INTERNAL_API_KEY,
   WALLET_CHECKOUT_SUCCESS_URL: process.env.WALLET_CHECKOUT_SUCCESS_URL,
-  WALLET_CHECKOUT_CANCEL_URL: process.env.WALLET_CHECKOUT_CANCEL_URL
+  WALLET_CHECKOUT_CANCEL_URL: process.env.WALLET_CHECKOUT_CANCEL_URL,
+  // Bedrock credentials for carrier_ask, the natural-language router. None of
+  // these appeared in this shim at all until now, so every read saw `undefined`
+  // and the routing gate in tools-carrier-ask.ts could never open: the flagship
+  // router had routed nothing from npm since it shipped. Same treatment as
+  // STRIPE_SECRET_KEY and the wallet values above — read the environment, and
+  // when absent let the tool refuse out loud rather than pretend it answered.
+  AWS_ACCESS_KEY_ID: process.env.AWS_ACCESS_KEY_ID,
+  AWS_SECRET_ACCESS_KEY: process.env.AWS_SECRET_ACCESS_KEY,
+  AWS_REGION: process.env.AWS_REGION,
+  BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID,
+  // Defaults ON here, unlike the Worker. The flag is the Worker's staged
+  // rollout switch; a local operator who has put AWS credentials on the process
+  // has already opted in, and making them set a second variable they have never
+  // heard of is just the same dead gate one step further along. Setting it to
+  // anything other than "true" still turns the router off.
+  CARRIER_ASK_ENABLED: process.env.CARRIER_ASK_ENABLED ?? "true"
 };
 var props = {
   sub: "stdio@local",
@@ -12340,13 +12558,16 @@ registerCountryHistoryTool(server, toolCtx);
 registerDepletionEventsTool(server, toolCtx);
 registerAllApps(server, toolCtx);
 registerAllPricingTools(server, toolCtx);
-registerScheduleAndUsageTools(server, toolCtx);
-registerAllUiAgentTools(server, toolCtx);
-registerUiAgentAskTools(server, toolCtx);
+var uiAgentRuntime = createUiAgentRuntime();
+var portalOptIn = readPortalOptIn();
+warnPortalOptIn(portalOptIn);
+registerScheduleAndUsageTools(server, toolCtx, uiAgentRuntime);
+registerAllUiAgentTools(server, toolCtx, uiAgentRuntime, portalOptIn);
+registerUiAgentAskTools(server, toolCtx, uiAgentRuntime);
 registerStripeConnectTools(server, { env: stdioEnv, props });
 registerWalletTools(server, { env: stdioEnv, props });
 registerGreenzoneTools(server, toolCtx);
-registerUiAgentGenericTools(server, toolCtx);
+registerUiAgentGenericTools(server, toolCtx, uiAgentRuntime);
 registerStorefrontLogoTools(
   server,
   stdioEnv,